on(eventName, handler).
Construisez votre premier mod avant de commencer ici. Pour chaque événement et ses champs exacts, consultez la référence ou lisez les types pour votre build.
Comment un hook gère un événement
Un hook se situe entre un événement et ce que Claude Code ferait à ce sujet, il peut donc observer l’événement, le réécrire, ou y répondre lui-même. Il reçoit trois arguments : l’API mods en tant que$, l’événement en tant que e, et le gestionnaire suivant en tant que next. Les gestionnaires d’un événement forment une chaîne middleware. next(e) appelle le gestionnaire suivant, qui est le hook d’un autre mod ou, à la fin de la chaîne, le comportement propre de Claude Code, et il se résout au résultat. Ce que votre hook fait avec next décide lequel des trois il fait.
Observer un événement
Pour observer un événement sans le modifier, faites votre travail et retourneznext(e). Ce hook enregistre chaque outil que Claude s’apprête à utiliser :
● my-mod: Claude is about to use Bash apparaît dans la transcription, où my-mod est le nom de votre plugin. L’outil s’exécute comme il le ferait sans le mod.
Pour agir après l’événement, await next(e), faites votre travail, et retournez le résultat. Ce hook enregistre chaque outil après son exécution :
next(e) s’est résolu à.
Réécrire un événement
Pour modifier ce sur quoi Claude Code agit, comme le texte d’un prompt, appeleznext avec une copie modifiée de l’événement. L’événement lui-même est immuable : il est gelé à chaque profondeur, et l’assignation à un champ lève une exception. Ce hook supprime les espaces de chaque prompt avant qu’il ne soit envoyé :
await next(e), puis retourner une copie du résultat avec un champ remplacé.
Répondre à un événement
Pour gérer un événement vous-même, retournez un résultat sans appelernext. Cela court-circuite la chaîne, donc les mods ultérieurs et le comportement propre de Claude Code ne s’exécutent pas. Ce hook refuse chaque commande Bash :
deny comme le résultat de l’outil. Chaque événement a sa propre forme de résultat, que la référence des événements énumère.
Filtrer les événements qu’un hook gère
Pour exécuter un hook pour certains événements seulement, passez un filtre comme deuxième argument àon. Claude Code appelle le filtre un matcher. C’est un objet dont les champs sont comparés avec ceux de l’événement, et le hook s’exécute seulement quand chaque champ correspond. Un champ peut être une valeur, un tableau de valeurs autorisées, ou une expression régulière.
Chaque ligne dans cet exemple enregistre la même fonction, hook, pour un ensemble plus restreint d’appels d’outils :
hook s’exécute une fois pour un appel Bash, Edit ou Write, et une fois pour un appel à un outil dont le nom commence par mcp__github__. Un appel à n’importe quel autre outil, comme Read, ne correspond à aucun des trois, donc hook ne s’exécute pas pour lui.
Le nom de l’événement peut être un wildcard. 'classic.*' correspond à chaque événement hook des paramètres. '*' correspond à chaque événement sauf les événements de télémétrie, qui prennent leur propre nom et un filtre { to: 'collector' }.
Enregistrez chaque événement une fois par matcher. Si vous appelez on deux fois pour session.start sans matcher, le module échoue à charger avec on("session.start") is registered twice without a matcher. Mettez tout ce que votre mod fait au démarrage de la session dans un hook.
Intercepter les dessins et contrôles d’autres mods
Pour intercepter les contrôles, les volets ou la ligne au-dessus du prompt d’un autre mod, passez un matcher avecplugin. Utilisez le nom du mod sans sa marketplace, comme dans { plugin: 'other-mod' }, ou { plugin: '*' } pour tous les mods. Sans plugin, un hook sur ui.press, ui.input, ui.select ou ui.focus ne s’exécute pas pour les contrôles des autres mods, et un hook ui.render ignore leurs volets et leurs lignes au-dessus du prompt.
Un hook sur un wildcard sans matcher, comme on('*', hook) ou on('ui.*', hook), s’exécute toujours pour tous les mods. Un wildcard avec un matcher nécessite également plugin.
{ plugin: '*' } nécessite Claude Code v2.1.323 ou une version ultérieure. Avant la v2.1.323, un hook sans plugin s’exécutait pour tous les mods, et un hook avec { plugin: '*' } ne s’exécutait pas. Pour correspondre à tous les mods sur les deux versions, utilisez { plugin: /./ } sur ui.press, ui.input et ui.select. Pour ui.focus et ui.render, utilisez on('ui.*', hook) et vérifiez le nom de l’événement dans next.event, comme dans if (next.event !== 'ui.focus') return next(e).Intercepter ce que fait Claude
Gérez ces événements pour observer ou modifier un appel d’outil, un prompt, un tour ou une lecture des paramètres au moment où cela se produit. Pour connaître tous les événements et ce qu’un hook peut renvoyer, consultez la référence des événements.Contrôler ou modifier un appel d’outil
Un hooktool.call voit chaque outil que Claude s’apprête à utiliser, ce qui lui permet de refuser l’appel, de modifier ses arguments ou de le laisser passer. tool.call se déclenche lorsque Claude Code s’apprête à exécuter un outil, y compris pour les appels effectués par un sous-agent et les appels aux outils MCP. e.tool est le nom de l’outil et les arguments de l’outil sont des champs de e, comme e.command pour Bash. Lorsque vous appelez next(e), Claude Code effectue la vérification des permissions, puis exécute l’outil.
Ce hook refuse une commande Bash qui effectue un force-push et indique à Claude pourquoi :
git push --force, la commande ne s’exécute pas et aucune demande de permission n’apparaît, car le hook n’appelle jamais next. Claude lit le texte de deny comme résultat de l’outil ; rédigez-le donc comme une instruction sur laquelle Claude peut agir. Toutes les autres commandes Bash s’exécutent comme elles le feraient sans le mod.
Si ce hook lève une exception ou dépasse le délai, Claude Code l’ignore et la commande se poursuit comme elle le ferait sans le mod. Pour refuser plutôt la commande, ajoutez un gestionnaire .catch au hook.
Pour agir après l’exécution d’un outil, faites await next(e), effectuez votre traitement, puis renvoyez ce que next vous a fourni. Ce hook consigne chaque fichier .mdx que Claude modifie, avec $.ui.log, qui ajoute à la transcription une ligne estompée que Claude ne lit pas :
.mdx, une ligne estompée dans la transcription indique le nom du fichier. Rien n’est consigné pour un autre type de fichier, ni pour un appel refusé ou en échec. La vision que Claude a de l’appel ne change pas, car le hook renvoie le résultat qu’il a reçu.
Votre hook peut aussi modifier un appel, le réessayer, y répondre lui-même ou masquer son résultat :
- Modifier l’appel : transmettez des arguments modifiés à
next. - Réessayer l’appel : appelez de nouveau
next(e). Un hook qui voitisErrordans le premier résultat peut exécuter l’outil une seconde fois et renvoyer ce résultat. - Répondre vous-même à l’appel : renvoyez un objet avec un champ
result, sans appelernext, et pour un outil intégré, donnez àresultla forme qu’a le résultat de cet outil dans les types de votre build. Aucune demande de permission n’apparaît et l’outil ne s’exécute pas ; le résultat que vous renvoyez est donc tout ce que Claude apprend de ce qui s’est passé. - Masquer le résultat à Claude : renvoyez
{ deny: reason }aprèsawait next(e). Claude lit votre motif à la place de ce quenexta renvoyé. Lorsque l’outil s’est exécuté, le deny empêche Claude de voir son résultat et n’annule rien de ce que l’outil a fait. Lorsque l’outil s’est exécuté avec succès, le motif suit une note commeBash ran, and a plugin withheld its result:.
tool.call de tout mod. Lorsqu’un hook géré bloque l’appel, aucun hook tool.call de mod ne s’exécute pour cet appel.
Suspendre un appel d’outil jusqu’à la décision de l’utilisateur
Un hook peut mettre en pause un appel d’outil et demander à l’utilisateur quoi faire avant de poursuivre. Un hooktool.call peut faire un await avant d’appeler next ou de renvoyer une valeur, et l’appel d’outil reste en attente jusque-là. Pour poser la question à l’utilisateur, appelez $.ui.ask. Cette fonction affiche votre question au-dessus d’une liste numérotée de vos options, dans la boîte de dialogue que Claude utilise pour vous demander quelque chose, et se résout avec le libellé choisi par l’utilisateur. Après vos options, la boîte de dialogue ajoute une ligne pour saisir une autre réponse et une ligne Chat about this.
Le motif RISKY de cet exemple correspond à rm -r, rm -rf, git reset --hard et git push avec --force, et ne détecte pas d’autres écritures comme git push -f. Ce module pose une question avant d’exécuter une commande Bash qui correspond au motif :
rm -rf build, la question apparaît avec la commande, et la commande attend la réponse :
- L’utilisateur choisit Run it : le hook appelle
next(e), et la vérification habituelle des permissions s’exécute toujours ensuite - L’utilisateur choisit Refuse : la commande ne s’exécute pas, et Claude lit le texte de
deny - L’utilisateur saisit une réponse :
$.ui.askse résout avec le texte saisi. Le hook le compare àRun it, donc tout autre texte refuse la commande. - Personne ne répond :
$.ui.askest rejetée lorsque l’utilisateur ferme la question ou choisit Chat about this, ainsi que lors d’une exécutionclaude -p; le bloccatchlaisse donc la réponse àRefuse
$.ui.ask, car ce temps n’est pas décompté de la limite de temps du hook. Le temps passé à attendre une promesse de votre propre code, en revanche, est décompté.
Claude Code ignore un hook qui dépasse le délai, si bien que la commande suspendue s’exécuterait. Pour plutôt la refuser, chaînez un gestionnaire .catch sur l’enregistrement que renvoie on. Ce gestionnaire est distinct du bloc catch situé à l’intérieur du hook.
Approuver ou refuser un appel d’outil avant que l’utilisateur ne soit sollicité
Pour décider si un appel d’outil peut s’exécuter, géreztool.check, l’événement où Claude Code prend cette décision.
Pour une commande ou un chemin fixe, utilisez une règle de permission comme Bash(npm test), qui ne nécessite aucun code. Gérez tool.check lorsque la décision dépend de ce qui est vrai à ce moment-là, comme la branche Git courante ou une valeur enregistrée par un autre hook.
- Ce qu’il faut renvoyer : pour décider vous-même de l’appel, renvoyez votre propre objet, comme
{ decision: 'allow' }ou{ decision: 'deny', reason }. Pour ne pas toucher à la décision, renvoyez ce que vous fournitawait next(e). - Ce que vous fournit
await next(e): la décision propre de Claude Code, sous la forme d’un objet dont le champdecisionvautallow,askoudeny. Aucune demande de permission n’apparaît pendant l’exécution denext(e). - Arguments :
e.inputcontient les arguments de l’outil, commecommandpour Bash - Quand
tool.checkse déclenche : après l’exécution des hooksPreToolUse, et avant la demande de permission, le classifieur du mode auto ou un hookPermissionRequest
git push lorsque la branche courante est main :
git push sur main et laisse passer tous les autres appels :
- Sur
main: le hook renvoiedeny, même lorsqu’une règle autorisegit push - Sur une autre branche, et pour les autres commandes : l’appel obtient la décision qu’il obtiendrait sans le mod
- Le hook lève une exception ou dépasse le délai : l’appel obtient également la décision qu’il obtiendrait sans le mod. Pour plutôt refuser l’appel, ajoutez un gestionnaire
.catchqui renvoie{ decision: 'deny', reason: 'the reason' }.
main pour tout le monde, protégez la branche sur votre hébergeur Git.
Un hook
tool.check peut aussi renvoyer allow ou ask. En mode plan, pour un appel qui n’est pas en lecture seule, comme une modification de fichier, votre hook peut durcir la décision que renvoie next(e), mais pas l’assouplir. Pour connaître les règles de permission et les décisions des hooks PreToolUse que l’allow de votre hook ne peut pas remplacer, consultez Étendre les permissions avec des hooks.Vérifier si un appel d’outil est en lecture seule
Dans un hooktool.check, e.isReadOnly vaut true lorsque l’outil signale l’appel comme étant en lecture seule. Sinon, le champ est absent, et ne vaut pas false. e.isReadOnly nécessite Claude Code v2.1.304 ou une version ultérieure.
Certains outils, comme Read, Grep, Glob et WebSearch, signalent chaque appel comme étant en lecture seule. Bash et les outils MCP signalent un appel comme étant en lecture seule dans les cas suivants :
- Bash : la commande passe la vérification intégrée des commandes en lecture seule de Claude Code
- Un outil MCP : le serveur définit l’annotation
readOnlyHintde l’outil surtrue
ask pour chaque appel mcp__github__ qui n’est pas en lecture seule et qui n’a pas déjà été refusé :
Filtrer un hook tool.check selon que l’appel est en lecture seule ou non
Pour limiter les appels que traite votre hook en fonction de e.isReadOnly, utilisez le matcher pour les appels en lecture seule et le corps du hook pour les autres :
- Appels en lecture seule uniquement : ajoutez
isReadOnly: trueau matcher, comme danson('tool.check', { tool: 'Bash', isReadOnly: true }, hook) - Appels qui ne sont pas en lecture seule : testez
e.isReadOnlydans le corps du hook, comme le fait l’exemplemcp__github__. Si vous placezisReadOnly: falsedans un matcher, votre hook ne s’exécute jamais.
Réécrire un prompt ou y ajouter du contenu
Un hookprompt.submit voit chaque prompt avant le début du tour, ce qui lui permet de réécrire le texte ou d’y ajouter du contenu. e.text correspond à ce qui a été saisi.
Ce hook ajoute pour Claude le nom de la branche courante chaque fois qu’un prompt mentionne une pull request :
open a PR for this change, votre message reste identique dans la transcription, et Claude lit également après celui-ci une ligne comme Current branch: feature/auth. Un prompt qui ne mentionne pas de pull request passe sans modification, et git ne s’exécute pas.
Pour arrêter un prompt, renvoyez { drop: 'the reason' } sans appeler next. Le texte revient dans la zone de saisie du prompt de l’utilisateur, qui voit Prompt dropped by a hook: suivi de votre motif ; adressez donc ce motif à l’utilisateur. Le prompt est tout de même envoyé dans les cas suivants :
- Votre hook renvoie un
dropaprès que son appelnext(e)a laissé passer le prompt : le tour s’exécute quand même, et le hook échoue avec un message qui incluta drop after its next() was answered - Votre hook lève une exception ou dépasse le délai : Claude Code l’ignore et envoie le prompt. Ajoutez un gestionnaire
.catchafin qu’un échec n’envoie pas un prompt que le hook aurait arrêté.
prompt.section pour chaque section du prompt système, prompt.context pour le contexte envoyé avec le premier message, et skill.prompt pour le texte d’un skill. Pour modifier une section après le début d’une conversation, consultez Envoyer une section de prompt système ou une description d’outil modifiée. Dans un hook skill.prompt, vous pouvez également lire le plugin ou le fichier dont provient le skill.
Suivre un tour
Un tour correspond à tout ce que fait Claude en réponse à un prompt. Gérezturn.start, turn.step et turn.complete pour en suivre un :
Écrivez un hook
turn.step sous forme de générateur asynchrone, car l’événement est diffusé en streaming. yield* next(e) transmet la réponse au fil du streaming et s’évalue en résultat final. Ce hook consigne la part de chaque requête que l’API Claude a servie depuis le cache des prompts :
result.usage contient le nombre de tokens que l’API Claude indique pour une requête, ainsi que le model qui a répondu : input_tokens, output_tokens, cache_read_input_tokens et cache_creation_input_tokens. Le hook s’exécute aussi pour les requêtes des sous-agents ; vérifiez donc e.agentId si vous ne souhaitez traiter que la conversation principale.
Pour voir les appels d’outils que l’API a exécutés elle-même pendant la requête, comme les appels à l’outil advisor, lisez result.serverToolUses. Claude Code n’exécute pas ces appels ; aucun hook tool.call ou tool.check ne se déclenche donc pour eux. Le champ est absent lorsque la réponse ne contient aucun appel de ce type, et il nécessite Claude Code v2.1.290 ou une version ultérieure.
Envoyer une requête à un autre modèle
Si une requêteturn.step échoue avec une erreur de modèle lorsque model est un alias comme haiku, passez à Claude Code v2.1.309 ou une version ultérieure, ou utilisez un identifiant de modèle complet. Avant la v2.1.309, un alias était envoyé tel quel.
Pour envoyer une requête à un autre modèle, transmettez à next l’événement avec model modifié, comme dans yield* next({ ...e, model: 'haiku' }).
Modifier ou refuser une lecture des paramètres
Utilisez un hooksettings.read pour modifier ou refuser une lecture des paramètres, qu’il s’agisse de la lecture effectuée par un mod ou de la lecture propre à Claude Code :
- Lecture par un mod : un mod appelle
$.settings.read. - Lecture propre à Claude Code : votre hook s’exécute une première fois lorsque Claude Code fusionne les paramètres de la session, après le chargement des mods de la session. Votre hook s’exécute de nouveau lorsque les paramètres ou les plugins chargés changent.
- Le garde-fou intégré : là où le garde-fou intégré se charge, il peut ignorer ce hook dans un mod que vous installez ou chargez avec
--plugin-dir. Pour le vérifier, recherchezsettings.read bypassed by cc-plugin-sec-defaultdans le log de débogage. Si une ligne contenant ce texte nomme votre mod, demandez à l’administrateur de votre organisation d’installer le mod parmi les mods de l’organisation. - La version : le déclenchement de l’événement lors de la lecture propre à Claude Code, ainsi que le champ
e.layers, nécessitent Claude Code v2.1.304 ou une version ultérieure.
Ce que reçoit un hook settings.read
Dans
e.layers, plugin contient les paramètres fournis par les plugins activés ; il s’agit uniquement d’un nom de couche, et non d’une source que vous pouvez transmettre à $.settings.read. flag contient les paramètres transmis avec --settings, et policy contient les paramètres gérés.
Distinguer la lecture propre à Claude Code de la lecture par un mod
Vérifieznext.origin :
- Lecture propre à Claude Code :
{ plugin: 'engine', tier: 'core' } - Lecture par un mod :
pluginest le nom du mod appelant
Ce que peut renvoyer un hook settings.read
Renvoyez le résultat de next(e) sans modification pour laisser la lecture telle quelle, ou renvoyez l’une des valeurs suivantes :
Lors de la lecture propre à Claude Code, construisez votre
{ value } à partir de la value de next(e), car une clé que vous omettez n’est pas définie. Lorsque Claude Code lit une clé comme env depuis chaque source séparément, la modifier dans votre value n’a aucun effet.
Ce que next(e) fournit à un hook settings.read
next(e) se résout avec { value } ou avec { deny } :
{ value }:valuecorrespond aux paramètres fusionnés, ou aux paramètres d’une seule source lorsquee.sourceest défini. Si un hook qui s’exécute après le vôtre a renvoyé son propre{ value }, vous obtenez lavaluede ce hook à la place.{ deny }: un hook qui s’exécute après le vôtre a refusé la lecture. Renvoyez ce{ deny }sans modification.
Modifier un paramètre depuis un hook settings.read
Vérifiez d’abord quels mods reçoivent cet événement, et à partir de quelle version.
Pour modifier une clé, décomposez la value de next(e) et définissez cette clé, comme le fait ce hook avec spinnerTipsEnabled. Le hook ne vérifie pas next.origin ; il modifie donc la clé aussi bien lors de la lecture propre à Claude Code que lors de la lecture fusionnée d’un mod :
the answer for <key> is no value the key can hold. Si votre valeur respecte le schéma et que la clé ne change toujours pas, consultez pourquoi une clé ne prend pas effet.
Gérer les événements des hooks des paramètres
Les hooks de paramètres sont les hooks de type commande, HTTP, prompt et agent que vous configurez dans les fichiers de paramètres. Chaque événement de hook de paramètres, commeStop, SessionEnd ou PostToolUse, est aussi un événement nommé classic. suivi du nom de l’événement de hook de paramètres, comme classic.Stop. e est le JSON qu’un hook de paramètres reçoit sur stdin, y compris transcript_path. Là où le garde-fou intégré se charge, un hook sur ces événements dans un mod que vous installez ne s’exécute pas.
Ce hook utilise Stop, qui se déclenche lorsque Claude a fini de répondre, pour consigner l’emplacement où la transcription de la session est enregistrée :
next(e) : il observe donc l’événement sans rien changer à la façon dont le tour se termine.
Exécuter aux côtés d’autres mods
Plusieurs mods peuvent gérer le même événement, et n’importe lequel d’eux peut échouer. Si votre mod bloque les appels d’outils, vérifiez sa position dans la chaîne et ce qui se passe quand son hook échoue.L’ordre dans lequel les mods s’exécutent
Les hooks sur le même événement forment une chaîne middleware. Chaquenext d’un mod appelle le hook du mod suivant, et le dernier next atteint le comportement propre de Claude Code. Le premier mod est le plus externe : il voit l’événement avant les autres et le résultat après eux, et il décide si les autres s’exécutent du tout. Un mod ultérieur ne peut pas empêcher un mod antérieur de voir un événement.
Claude Code ordonne la chaîne par où chaque mod vient :
- Le garde-fou intégré
sec-default@builtin, un mod intégré à Claude Code que/pluginénumère en tant quecc-plugin-sec-default, où il charge, les mods que votre organisation énumère dansprependPlugins, puis tout autre mod qui compte comme celui de votre organisation et n’est pas dansappendPlugins - Les mods que vous installez
- Les mods que votre organisation énumère dans
appendPlugins - D’autres mods intégrés à Claude Code
dependencies dans son manifeste. Dans un module, les hooks s’exécutent dans l’ordre où register a appelé on.
Où les hooks de paramètres s’exécutent dans l’ordre
Les hooksPreToolUse configurés dans les fichiers de paramètres s’exécutent aussi pendant un appel d’outil, à des points fixes dans la chaîne des mods :
- Hooks
PreToolUsedes paramètres gérés : s’exécutent avant le hooktool.calldu premier mod. Lorsqu’un hook géré bloque l’appel, aucun hooktool.calld’un mod ne s’exécute pour cet appel. - Hooks
PreToolUsede chaque autre fichier de paramètres et deshooks/hooks.jsondes plugins : s’exécutent après que le dernier mod appellenext, comme partie du comportement propre de Claude Code. Un mod qui répond àtool.callsans appelernextles empêche de s’exécuter, et un mod qui appellenextvoit leur décision dans le résultat qu’il retourne.
tool.check se déclenche une fois que les hooks PreToolUse se sont exécutés. Pour connaître les règles de permission et les décisions de hooks PreToolUse que l’allow d’un hook tool.check ne peut pas remplacer, consultez Étendre les permissions avec des hooks.
Gérer un hook qui échoue
Un hook qui échoue ne casse pas la session, et vous pouvez décider ce qui se passe à la place. Quand un hook sans gestionnaire.catch lève une exception, expire, ou retourne un résultat de la mauvaise forme, ce qui se passe ensuite dépend de s’il avait appelé next :
- Il a échoué avant d’appeler
next: Claude Code le saute, et le gestionnaire suivant s’exécute à sa place - Il a échoué après que
nextse soit résolu : ce résultat tient, et rien ne s’exécute une deuxième fois
my-mod: tool.call hook skipped: threw Error: boom. Où vous la lisez dépend de la session, comme Découvrir pourquoi un mod ne fait rien l’énumère. Un hook ui.render dont l’arbre ne se valide pas compte comme un hook qui a retourné un résultat de la mauvaise forme.
Pour qu’un hook qui bloque les appels échoue en mode fermé, ajoutez un gestionnaire d’erreur .catch qui répond à sa place. Ici, guard est votre fonction hook, et le gestionnaire teste next.called pour savoir si guard avait déjà appelé next lorsqu’il a échoué :
guard lève une exception ou expire sur un appel Bash, Claude Code appelle le gestionnaire avec le même événement :
guarda échoué avant d’appelernext: la commande ne s’exécute pas, et Claude lit le texte dedenyavec le type à la finguarda échoué après avoir appelénext: lenext(e)du gestionnaire se résout avec le résultat qu’a produit l’appel deguard, sans exécuter à nouveau la commande, et Claude lit ce résultat
guard n’avait pas appelé next, la commande se poursuit alors comme elle le ferait sans le mod.
La même forme de gestionnaire convient à un garde-fou sur prompt.submit ou config.set. Lorsque next.called vaut false, retournez le refus que la référence des événements indique pour cet événement : { drop: 'the reason' } pour prompt.submit, { deny: 'the reason' } pour config.set.
Pour tool.check et plugin.register, un refus retourné après que next s’est résolu reste valable, donc retournez-le sans tester next.called :
tool.check: retournez{ decision: 'deny', reason: 'the reason' }plugin.register: retournez{ refuse: 'the reason' }, comme le montre Refuser les mods lorsque votre vérification échoue
tool.call, un deny retourné après que next s’est résolu soustrait le résultat à Claude.
Prochaines étapes
- Utiliser l’API mods : ajouter des commandes et des outils, appeler un modèle, et exécuter du travail sur un minuteur
- Dessiner dans l’interface : afficher ce que vos hooks collectent dans un volet ou au-dessus de l’invite
- Tester un mod : déclencher n’importe lequel de ces événements à partir d’un test
- Référence des mods : chaque événement, chaque méthode API mods, et les limites