Documentation 2026-07-02 23:59 UTC to 2026-07-03 23:00 UTC

90| [Plancher de version](/fr/settings) | Empêcher la mise à jour automatique d'installer en dessous d'un minimum à l'échelle de l'organisation | `minimumVersion` |90| [Plancher de version](/fr/settings) | Empêcher la mise à jour automatique d'installer en dessous d'un minimum à l'échelle de l'organisation | `minimumVersion` |

91| [Plage de version requise](/fr/settings) | Refuser de démarrer complètement lorsque la version en cours d'exécution est en dehors d'une plage approuvée par l'organisation. Plus fort que `minimumVersion`, qui bloque uniquement les rétrograder | `requiredMinimumVersion`, `requiredMaximumVersion` |91| [Plage de version requise](/fr/settings) | Refuser de démarrer complètement lorsque la version en cours d'exécution est en dehors d'une plage approuvée par l'organisation. Plus fort que `minimumVersion`, qui bloque uniquement les rétrograder | `requiredMinimumVersion`, `requiredMaximumVersion` |

92 92 

93Les organisations dont les membres s'authentifient via claude.ai ou l'API Anthropic peuvent également gouverner les modèles sans déployer de paramètres : les [restrictions de modèle d'organisation](/fr/model-config#organization-model-restrictions) désactivent les modèles individuels, un [modèle par défaut d'organisation](/fr/model-config#organization-default-model) définit le modèle sur lequel les nouvelles sessions commencent, et les [limites d'effort d'organisation](/fr/model-config#organization-effort-limits) limitent les niveaux d'effort par rôle. Les trois contrôles nécessitent un plan Claude Enterprise. Les restrictions de modèle et les limites d'effort sont appliquées côté serveur ; le modèle par défaut est un point de départ que les utilisateurs peuvent modifier, sauf si l'organisation l'applique. L'application est disponible pour un ensemble limité d'organisations ; demandez à votre équipe de compte Anthropic la disponibilité. Aucun de ces contrôles n'atteint les sessions sur Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, ou [Claude Platform on AWS](/fr/claude-platform-on-aws) ; sur ces fournisseurs, utilisez `availableModels` ci-dessus pour les restrictions et la clé `model` dans les paramètres gérés pour une valeur par défaut.

94 

93Les règles de permission et le sandboxing couvrent différentes couches. Refuser WebFetch bloque l'outil fetch de Claude, mais si Bash est autorisé, `curl` et `wget` peuvent toujours atteindre n'importe quelle URL. Le sandboxing ferme cette lacune avec une liste blanche de domaines réseau appliquée au niveau du système d'exploitation.95Les règles de permission et le sandboxing couvrent différentes couches. Refuser WebFetch bloque l'outil fetch de Claude, mais si Bash est autorisé, `curl` et `wget` peuvent toujours atteindre n'importe quelle URL. Le sandboxing ferme cette lacune avec une liste blanche de domaines réseau appliquée au niveau du système d'exploitation.

94 96 

95Pour le modèle de menace que ces contrôles défendent, consultez [Sécurité](/fr/security).97Pour le modèle de menace que ces contrôles défendent, consultez [Sécurité](/fr/security).

85L'advisor doit être au moins aussi capable que le modèle principal. Les advisors acceptés pour chaque modèle principal sont :85L'advisor doit être au moins aussi capable que le modèle principal. Les advisors acceptés pour chaque modèle principal sont :

86 86 

87| Modèle principal | Advisors acceptés | Notes |87| Modèle principal | Advisors acceptés | Notes |

88| ----------------------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |88| ----------------------------------------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

89| Haiku 4.5 | Fable, Opus, Sonnet | Haiku peut appeler l'advisor mais ne peut pas en être un |89| Haiku 4.5 | Fable, Opus, Sonnet | Haiku peut appeler l'advisor mais ne peut pas en être un |

90| Sonnet 4.6 | Fable, Opus, Sonnet | |90| Sonnet 4.6 | Fable, Opus, Sonnet | |

91| Sonnet 5 | Fable, Opus, Sonnet 5 | Un advisor Sonnet 4.6 est rejeté |91| Sonnet 5 | Fable, Opus, Sonnet 5 | Un advisor Sonnet 4.6 est rejeté |

92| Opus 4.6 ou ultérieur | Fable, Opus à la version du modèle principal ou ultérieure | Un Opus 4.7 principal avec un advisor Opus 4.6 est rejeté. Un Opus 4.6 principal accepte également un advisor Sonnet 5 |92| Opus 4.6 | Fable, Opus, Sonnet 5 | Sonnet 5 et Opus 4.6 sont classés comme également capables, donc un Opus 4.6 principal accepte un advisor Sonnet 5 |

93| Opus 4.7 ou ultérieur | Fable, Opus 4.7, Opus 4.8 | Opus 4.7 et Opus 4.8 sont classés comme également capables, donc l'un accepte l'autre comme advisor. Un Opus 4.7 principal avec un advisor Opus 4.6 ou Sonnet 5 est rejeté |

93| Fable 5 ({/* min-version: 2.1.170 */}v2.1.170+) | Fable | Un advisor Opus ou Sonnet est rejeté |94| Fable 5 ({/* min-version: 2.1.170 */}v2.1.170+) | Fable | Un advisor Opus ou Sonnet est rejeté |

94 95 

95Fable 5 nécessite Claude Code v2.1.170 ou ultérieur et l'accès à Fable 5, qu'il agisse comme modèle principal ou advisor.96Fable 5 nécessite Claude Code v2.1.170 ou ultérieur et l'accès à Fable 5, qu'il agisse comme modèle principal ou advisor.

174/advisor off175/advisor off

175```176```

176 177 

177Pour désactiver complètement l'outil advisor, y compris la commande `/advisor` et le drapeau `--advisor`, définissez `CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1`. Consultez [Variables d'environnement](/fr/env-vars).178Pour désactiver l'outil advisor entièrement, définissez `CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1`. La commande `/advisor` devient indisponible et tout `advisorModel` configuré est ignoré. Le drapeau `--advisor` est accepté mais n'a aucun effet ; les scripts existants qui le transmettent continuent de fonctionner sans erreurs. Consultez [Variables d'environnement](/fr/env-vars).

178 179 

179<h2 id="compare-with-related-features">180<h2 id="compare-with-related-features">

180 Comparer avec les fonctionnalités connexes181 Comparer avec les fonctionnalités connexes

86<Accordion title="Exemple : Vérifier les types de messages et gérer les résultats">86<Accordion title="Exemple : Vérifier les types de messages et gérer les résultats">

87 <CodeGroup>87 <CodeGroup>

88 ```python Python theme={null}88 ```python Python theme={null}

89 import asyncio

89 from claude_agent_sdk import query, AssistantMessage, ResultMessage90 from claude_agent_sdk import query, AssistantMessage, ResultMessage

90 91 

92 

93 async def main():

94 try:

91 async for message in query(prompt="Summarize this project"):95 async for message in query(prompt="Summarize this project"):

92 if isinstance(message, AssistantMessage):96 if isinstance(message, AssistantMessage):

93 print(f"Turn completed: {len(message.content)} content blocks")97 print(f"Turn completed: {len(message.content)} content blocks")

96 print(message.result)100 print(message.result)

97 else:101 else:

98 print(f"Stopped: {message.subtype}")102 print(f"Stopped: {message.subtype}")

103 except Exception as error:

104 # A single-shot query() raises after yielding an error result. If the

105 # failure was an error result, the error subtype branches above have

106 # already run; connection or process failures yield no result message.

107 print(f"Session ended with an error: {error}")

108 

109 

110 asyncio.run(main())

99 ```111 ```

100 112 

101 ```typescript TypeScript theme={null}113 ```typescript TypeScript theme={null}

102 import { query } from "@anthropic-ai/claude-agent-sdk";114 import { query } from "@anthropic-ai/claude-agent-sdk";

103 115 

116 try {

104 for await (const message of query({ prompt: "Summarize this project" })) {117 for await (const message of query({ prompt: "Summarize this project" })) {

105 if (message.type === "assistant") {118 if (message.type === "assistant") {

106 console.log(`Turn completed: ${message.message.content.length} content blocks`);119 console.log(`Turn completed: ${message.message.content.length} content blocks`);

113 }126 }

114 }127 }

115 }128 }

129 } catch (error) {

130 // A single-shot query() throws after yielding an error result. If the

131 // failure was an error result, the error subtype branches above have

132 // already run; connection or process failures yield no result message.

133 console.log(`Session ended with an error: ${error}`);

134 }

116 ```135 ```

117 </CodeGroup>136 </CodeGroup>

118</Accordion>137</Accordion>

321 340 

322Le champ `result` (la sortie textuelle finale) n'est présent que sur la variante `success`, donc vérifiez toujours le sous-type avant de le lire. Tous les sous-types de résultat portent `total_cost_usd`, `usage`, `num_turns` et `session_id` afin que vous puissiez suivre le coût et reprendre même après des erreurs. En Python, `total_cost_usd` et `usage` sont typés comme optionnels et peuvent être `None` sur certains chemins d'erreur, donc gardez-les avant de les formater. Voir [Suivi des coûts et de l'utilisation](/fr/agent-sdk/cost-tracking) pour les détails sur l'interprétation des champs `usage`.341Le champ `result` (la sortie textuelle finale) n'est présent que sur la variante `success`, donc vérifiez toujours le sous-type avant de le lire. Tous les sous-types de résultat portent `total_cost_usd`, `usage`, `num_turns` et `session_id` afin que vous puissiez suivre le coût et reprendre même après des erreurs. En Python, `total_cost_usd` et `usage` sont typés comme optionnels et peuvent être `None` sur certains chemins d'erreur, donc gardez-les avant de les formater. Voir [Suivi des coûts et de l'utilisation](/fr/agent-sdk/cost-tracking) pour les détails sur l'interprétation des champs `usage`.

323 342 

343<Note>

344 Lorsqu'une requête se termine sur un résultat d'erreur :

345 

346 * Un appel `query()` unique produit le message de résultat final, puis lève une erreur qui inclut le texte d'échec, tel que `Reached maximum number of turns`. La levée est intentionnelle — enveloppez la boucle dans un bloc try si votre code doit continuer au-delà. Le processus Claude Code sous-jacent se termine également avec un code non nul.

347 * Une session d'entrée en streaming reste active, et vous pouvez continuer à envoyer des messages.

348</Note>

349 

324Le résultat inclut également un champ `stop_reason` (`string | null` en TypeScript, `str | None` en Python) indiquant pourquoi le modèle a arrêté de générer sur son tour final. Les valeurs courantes sont `end_turn` (le modèle a terminé normalement), `max_tokens` (limite de token de sortie atteinte) et `refusal` (le modèle a refusé la requête). Sur les sous-types de résultat d'erreur, `stop_reason` porte la valeur de la dernière réponse d'assistant avant la fin de la boucle. Pour détecter les refus, vérifiez `stop_reason === "refusal"` (TypeScript) ou `stop_reason == "refusal"` (Python). Voir [`SDKResultMessage`](/fr/agent-sdk/typescript#sdkresultmessage) (TypeScript) ou [`ResultMessage`](/fr/agent-sdk/python#resultmessage) (Python) pour le type complet.350Le résultat inclut également un champ `stop_reason` (`string | null` en TypeScript, `str | None` en Python) indiquant pourquoi le modèle a arrêté de générer sur son tour final. Les valeurs courantes sont `end_turn` (le modèle a terminé normalement), `max_tokens` (limite de token de sortie atteinte) et `refusal` (le modèle a refusé la requête). Sur les sous-types de résultat d'erreur, `stop_reason` porte la valeur de la dernière réponse d'assistant avant la fin de la boucle. Pour détecter les refus, vérifiez `stop_reason === "refusal"` (TypeScript) ou `stop_reason == "refusal"` (Python). Voir [`SDKResultMessage`](/fr/agent-sdk/typescript#sdkresultmessage) (TypeScript) ou [`ResultMessage`](/fr/agent-sdk/python#resultmessage) (Python) pour le type complet.

325 351 

326<h2 id="hooks">352<h2 id="hooks">

348 374 

349Cet exemple combine les concepts clés de cette page dans un seul agent qui corrige les tests défaillants. Il configure l'agent avec les outils autorisés (approuvés automatiquement afin que l'agent s'exécute de manière autonome), les paramètres du projet et les limites de sécurité sur les tours et l'effort de raisonnement. Lorsque la boucle s'exécute, elle capture l'ID de session pour une reprise potentielle, gère le résultat final et imprime le coût total.375Cet exemple combine les concepts clés de cette page dans un seul agent qui corrige les tests défaillants. Il configure l'agent avec les outils autorisés (approuvés automatiquement afin que l'agent s'exécute de manière autonome), les paramètres du projet et les limites de sécurité sur les tours et l'effort de raisonnement. Lorsque la boucle s'exécute, elle capture l'ID de session pour une reprise potentielle, gère le résultat final et imprime le coût total.

350 376 

377Parce qu'un appel unique `query()` lève une exception après avoir produit un résultat d'erreur, la boucle est enveloppée dans un bloc try afin que le script se termine proprement lorsqu'une limite est atteinte.

378 

351<CodeGroup>379<CodeGroup>

352 ```python Python theme={null}380 ```python Python theme={null}

353 import asyncio381 import asyncio

357 async def run_agent():385 async def run_agent():

358 session_id = None386 session_id = None

359 387 

388 try:

360 async for message in query(389 async for message in query(

361 prompt="Find and fix the bug causing test failures in the auth module",390 prompt="Find and fix the bug causing test failures in the auth module",

362 options=ClaudeAgentOptions(391 options=ClaudeAgentOptions(

389 print(f"Stopped: {message.subtype}")418 print(f"Stopped: {message.subtype}")

390 if message.total_cost_usd is not None:419 if message.total_cost_usd is not None:

391 print(f"Cost: ${message.total_cost_usd:.4f}")420 print(f"Cost: ${message.total_cost_usd:.4f}")

421 except Exception as error:

422 # A single-shot query() raises after yielding an error result. If the

423 # failure was an error result, the error subtype branches above have

424 # already run; connection or process failures yield no result message.

425 print(f"Session ended with an error: {error}")

392 426 

393 427 

394 asyncio.run(run_agent())428 asyncio.run(run_agent())

399 433 

400 let sessionId: string | undefined;434 let sessionId: string | undefined;

401 435 

436 try {

402 for await (const message of query({437 for await (const message of query({

403 prompt: "Find and fix the bug causing test failures in the auth module",438 prompt: "Find and fix the bug causing test failures in the auth module",

404 options: {439 options: {

428 console.log(`Cost: $${message.total_cost_usd.toFixed(4)}`);463 console.log(`Cost: $${message.total_cost_usd.toFixed(4)}`);

429 }464 }

430 }465 }

466 } catch (error) {

467 // A single-shot query() throws after yielding an error result. If the

468 // failure was an error result, the error subtype branches above have

469 // already run; connection or process failures yield no result message.

470 console.log(`Session ended with an error: ${error}`);

471 }

431 ```472 ```

432</CodeGroup>473</CodeGroup>

433 474 

63 ```typescript TypeScript theme={null}63 ```typescript TypeScript theme={null}

64 import { query } from "@anthropic-ai/claude-agent-sdk";64 import { query } from "@anthropic-ai/claude-agent-sdk";

65 65 

66 try {

66 for await (const message of query({ prompt: "Summarize this project" })) {67 for await (const message of query({ prompt: "Summarize this project" })) {

67 if (message.type === "result") {68 if (message.type === "result") {

68 console.log(`Total cost: $${message.total_cost_usd}`);69 console.log(`Total cost: $${message.total_cost_usd}`);

69 }70 }

70 }71 }

72 } catch (error) {

73 // A single-shot query() throws after yielding an error result. If the

74 // failure was an error result, it still carried total_cost_usd and the

75 // branch above has already run; connection or process failures yield

76 // no result message.

77 console.error(`Session ended with an error: ${error}`);

78 }

71 ```79 ```

72 80 

73 ```python Python theme={null}81 ```python Python theme={null}

76 84 

77 85 

78 async def main():86 async def main():

87 try:

79 async for message in query(prompt="Summarize this project"):88 async for message in query(prompt="Summarize this project"):

80 if isinstance(message, ResultMessage):89 if isinstance(message, ResultMessage):

81 print(f"Total cost: ${message.total_cost_usd or 0}")90 print(f"Total cost: ${message.total_cost_usd or 0}")

91 except Exception as error:

92 # A single-shot query() raises after yielding an error result. If the

93 # failure was an error result, it still carried total_cost_usd and the

94 # branch above has already run; connection or process failures yield

95 # no result message.

96 print(f"Session ended with an error: {error}")

82 97 

83 98 

84 asyncio.run(main())99 asyncio.run(main())

110let totalInputTokens = 0;125let totalInputTokens = 0;

111let totalOutputTokens = 0;126let totalOutputTokens = 0;

112 127 

113for await (const message of query({ prompt: "Summarize this project" })) {128try {

129 for await (const message of query({ prompt: "Summarize this project" })) {

114 if (message.type === "assistant") {130 if (message.type === "assistant") {

115 const msgId = message.message.id;131 const msgId = message.message.id;

116 132 

121 totalOutputTokens += message.message.usage.output_tokens;137 totalOutputTokens += message.message.usage.output_tokens;

122 }138 }

123 }139 }

140 }

141} catch (error) {

142 // A single-shot query() throws after yielding an error result, so the

143 // totals below still reflect the steps that ran before the failure.

144 console.error(`Session ended with an error: ${error}`);

124}145}

125 146 

126console.log(`Steps: ${seenIds.size}`);147console.log(`Steps: ${seenIds.size}`);

139```typescript theme={null}160```typescript theme={null}

140import { query } from "@anthropic-ai/claude-agent-sdk";161import { query } from "@anthropic-ai/claude-agent-sdk";

141 162 

142for await (const message of query({ prompt: "Summarize this project" })) {163try {

164 for await (const message of query({ prompt: "Summarize this project" })) {

143 if (message.type !== "result") continue;165 if (message.type !== "result") continue;

144 166 

145 for (const [modelName, usage] of Object.entries(message.modelUsage)) {167 for (const [modelName, usage] of Object.entries(message.modelUsage)) {

149 console.log(` Cache read: ${usage.cacheReadInputTokens}`);171 console.log(` Cache read: ${usage.cacheReadInputTokens}`);

150 console.log(` Cache creation: ${usage.cacheCreationInputTokens}`);172 console.log(` Cache creation: ${usage.cacheCreationInputTokens}`);

151 }173 }

174 }

175} catch (error) {

176 // A single-shot query() throws after yielding an error result. If the

177 // failure was an error result, the per-model breakdown above has already

178 // printed; connection or process failures yield no result message.

179 console.error(`Session ended with an error: ${error}`);

152}180}

153```181```

154 182 

173 ];201 ];

174 202 

175 for (const prompt of prompts) {203 for (const prompt of prompts) {

204 try {

176 for await (const message of query({ prompt })) {205 for await (const message of query({ prompt })) {

177 if (message.type === "result") {206 if (message.type === "result") {

178 totalSpend += message.total_cost_usd;207 totalSpend += message.total_cost_usd;

179 console.log(`This call: $${message.total_cost_usd}`);208 console.log(`This call: $${message.total_cost_usd}`);

180 }209 }

181 }210 }

211 } catch (error) {

212 // A single-shot query() throws after yielding an error result. If the

213 // failure was an error result, this call's cost was already counted;

214 // connection or process failures yield no result message. Continue

215 // with the next prompt.

216 console.error(`Call failed: ${error}`);

217 }

182 }218 }

183 219 

184 console.log(`Total spend: $${totalSpend.toFixed(4)}`);220 console.log(`Total spend: $${totalSpend.toFixed(4)}`);

199 ]235 ]

200 236 

201 for prompt in prompts:237 for prompt in prompts:

238 try:

202 async for message in query(prompt=prompt):239 async for message in query(prompt=prompt):

203 if isinstance(message, ResultMessage):240 if isinstance(message, ResultMessage):

204 cost = message.total_cost_usd or 0241 cost = message.total_cost_usd or 0

205 total_spend += cost242 total_spend += cost

206 print(f"This call: ${cost}")243 print(f"This call: ${cost}")

244 except Exception as error:

245 # A single-shot query() raises after yielding an error result. If

246 # the failure was an error result, this call's cost was already

247 # counted; connection or process failures yield no result message.

248 # Continue with the next prompt.

249 print(f"Call failed: {error}")

207 250 

208 print(f"Total spend: ${total_spend:.4f}")251 print(f"Total spend: ${total_spend:.4f}")

209 252 

50 50 

51Pour utiliser le point de contrôle de fichier, activez-le dans vos options, capturez les UUID de point de contrôle du flux de réponse, puis appelez `rewindFiles()` (TypeScript) ou `rewind_files()` (Python) lorsque vous devez restaurer.51Pour utiliser le point de contrôle de fichier, activez-le dans vos options, capturez les UUID de point de contrôle du flux de réponse, puis appelez `rewindFiles()` (TypeScript) ou `rewind_files()` (Python) lorsque vous devez restaurer.

52 52 

53L'exemple suivant montre le flux complet : activez le point de contrôle, capturez l'UUID du point de contrôle et l'ID de session du flux de réponse, puis reprenez la session plus tard pour rembobiner les fichiers. Chaque étape est expliquée en détail ci-dessous.53L'exemple suivant montre le flux complet : activez le point de contrôle, capturez l'UUID du point de contrôle et l'ID de session du flux de réponse, puis reprenez la session plus tard pour rembobiner les fichiers. Chaque étape est expliquée en détail ci-dessous. Les exemples de cette section utilisent l'invite « Refactor the authentication module ». Exécutez-les dans un projet qui contient un module d'authentification, ou modifiez l'invite pour nommer les fichiers qui existent dans votre projet, afin que vous puissiez regarder les fichiers changer et voir le rembobinage les restaurer.

54 54 

55<CodeGroup>55<CodeGroup>

56 ```python Python theme={null}56 ```python Python theme={null}

197 session_id = None197 session_id = None

198 198 

199 async for message in client.receive_response():199 async for message in client.receive_response():

200 # Update checkpoint on each user message (keeps the latest)200 # Capture the first user message UUID as the checkpoint

201 if isinstance(message, UserMessage) and message.uuid:201 if isinstance(message, UserMessage) and message.uuid and checkpoint_id is None:

202 checkpoint_id = message.uuid202 checkpoint_id = message.uuid

203 # Capture session ID from the result message203 # Capture session ID from the result message

204 if isinstance(message, ResultMessage):204 if isinstance(message, ResultMessage):

210 let sessionId: string | undefined;210 let sessionId: string | undefined;

211 211 

212 for await (const message of response) {212 for await (const message of response) {

213 // Update checkpoint on each user message (keeps the latest)213 // Capture the first user message UUID as the checkpoint

214 if (message.type === "user" && message.uuid) {214 if (message.type === "user" && message.uuid && !checkpointId) {

215 checkpointId = message.uuid;215 checkpointId = message.uuid;

216 }216 }

217 // Capture session ID from any message that has it217 // Capture session ID from any message that has it

250 ```250 ```

251 </CodeGroup>251 </CodeGroup>

252 252 

253 Si vous capturez l'ID de session et l'UUID de point de contrôle, vous pouvez également rembobiner à partir de la CLI :253 Si vous capturez l'ID de session et l'UUID de point de contrôle, vous pouvez également rembobiner à partir de la CLI. Cette commande nécessite l'exécutable `claude`, qui provient de l'[installation de Claude Code](/fr/setup) et n'est pas installé par le package SDK. Le SDK active le point de contrôle pour vous, mais lorsque vous exécutez `claude -p` directement, vous devez définir la variable d'environnement `CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING` :

254 254 

255 ```bash theme={null}255 ```bash theme={null}

256 claude -p --resume <session-id> --rewind-files <checkpoint-uuid>256 CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true claude -p --resume <session-id> --rewind-files <checkpoint-uuid>

257 ```257 ```

258 

259 Le drapeau `--rewind-files` n'apparaît pas dans la sortie `claude --help`, mais la CLI l'accepte comme indiqué.

258 </Step>260 </Step>

259</Steps>261</Steps>

260 262 

270 272 

271Ce modèle conserve uniquement l'UUID de point de contrôle le plus récent, le mettant à jour avant chaque tour d'agent. Si quelque chose se passe mal pendant le traitement, vous pouvez immédiatement rembobiner vers le dernier état sûr et sortir de la boucle.273Ce modèle conserve uniquement l'UUID de point de contrôle le plus récent, le mettant à jour avant chaque tour d'agent. Si quelque chose se passe mal pendant le traitement, vous pouvez immédiatement rembobiner vers le dernier état sûr et sortir de la boucle.

272 274 

275Avant d'exécuter cet exemple, remplacez `your_revert_condition` (Python) ou `yourRevertCondition` (TypeScript) par votre propre vérification, telle que la détection d'erreurs ou un échec de validation ; l'espace réservé n'est pas défini dans l'exemple.

276 

273<CodeGroup>277<CodeGroup>

274 ```python Python theme={null}278 ```python Python theme={null}

275 import asyncio279 import asyncio

752 756 

753**Solution** : Assurez-vous que `enable_file_checkpointing=True` (Python) ou `enableFileCheckpointing: true` (TypeScript) a été défini sur la session d'origine, puis utilisez le modèle montré dans les exemples : capturez l'UUID du premier message utilisateur, complétez la session entièrement, puis reprenez avec une invite vide et appelez `rewindFiles()` une fois.757**Solution** : Assurez-vous que `enable_file_checkpointing=True` (Python) ou `enableFileCheckpointing: true` (TypeScript) a été défini sur la session d'origine, puis utilisez le modèle montré dans les exemples : capturez l'UUID du premier message utilisateur, complétez la session entièrement, puis reprenez avec une invite vide et appelez `rewindFiles()` une fois.

754 758 

759<h3 id="file-rewinding-is-not-enabled-error">

760 Erreur « File rewinding is not enabled »

761</h3>

762 

763Cette erreur se produit lorsque vous tentez un rembobinage non interactif sans point de contrôle activé : exécuter `claude -p` avec `--rewind-files`, ou exécuter une session SDK, y compris une session reprise, dont les options n'activent pas le point de contrôle. Le SDK définit la variable d'environnement `CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING` en interne uniquement lorsque `enable_file_checkpointing` (Python) ou `enableFileCheckpointing` (TypeScript) est activé sur la session effectuant le rembobinage ; l'interface CLI simple ne la définit jamais.

764 

765**Solution** : Pour l'interface CLI simple, définissez la variable d'environnement lors de l'exécution de la commande :

766 

767```bash theme={null}

768CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true claude -p --resume <session-id> --rewind-files <checkpoint-uuid>

769```

770 

771Pour le SDK, définissez `enable_file_checkpointing=True` (Python) ou `enableFileCheckpointing: true` (TypeScript) sur la session reprise, comme le font les exemples sur cette page.

772 

755<h3 id="processtransport-is-not-ready-for-writing-error">773<h3 id="processtransport-is-not-ready-for-writing-error">

756 Erreur « ProcessTransport is not ready for writing »774 Erreur « ProcessTransport is not ready for writing »

757</h3>775</h3>

28 </Step>28 </Step>

29 29 

30 <Step title="Règles de demande">30 <Step title="Règles de demande">

31 Vérifiez les règles `ask` à partir de [settings.json](/fr/settings#permission-settings). Si une règle de demande correspond, l'appel passe à votre callback [`canUseTool`](/fr/agent-sdk/user-input) pour confirmation, même en mode `bypassPermissions`. En mode `dontAsk`, une règle de demande correspondante est refusée à la place, car ce mode ne demande jamais.31 Vérifiez les règles `ask` à partir de [settings.json](/fr/settings#permission-settings). Si une règle de demande correspond, l'appel passe à votre callback [`canUseTool`](/fr/agent-sdk/user-input) pour confirmation, même en mode `bypassPermissions`.

32 

33 Les outils qui nécessitent une interaction utilisateur se comportent de la même manière : `AskUserQuestion` et les outils MCP dont le serveur définit [`_meta["anthropic/requiresUserInteraction"]`](/fr/mcp#require-approval-for-a-specific-tool) passent toujours au callback, même lorsqu'une règle d'autorisation correspond. En mode `dontAsk`, les deux cas sont refusés à la place, car ce mode ne demande jamais. {/* min-version: 2.1.199 */}L'annotation MCP nécessite Claude Code v2.1.199 ou ultérieur.

32 </Step>34 </Step>

33 35 

34 <Step title="Mode de permission">36 <Step title="Mode de permission">

46 48 

47<img src="https://mintcdn.com/claude-code/jYgs7qigNjO1Badj/images/agent-sdk/permissions-flow.svg?fit=max&auto=format&n=jYgs7qigNjO1Badj&q=85&s=c771ad9085b1277d3708027a49c744bc" alt="Diagramme du flux d'évaluation des permissions en six étapes correspondant aux étapes ci-dessus : une demande d'outil passe par les hooks, les règles de refus, les règles de demande, le mode de permission, les règles d'autorisation et canUseTool. Les hooks, les règles de refus et canUseTool peuvent router vers Bloqué ; le contournement du mode de permission, les règles d'autorisation et canUseTool peuvent router vers Exécuter ; les règles de demande routent vers canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow.svg" />49<img src="https://mintcdn.com/claude-code/jYgs7qigNjO1Badj/images/agent-sdk/permissions-flow.svg?fit=max&auto=format&n=jYgs7qigNjO1Badj&q=85&s=c771ad9085b1277d3708027a49c744bc" alt="Diagramme du flux d'évaluation des permissions en six étapes correspondant aux étapes ci-dessus : une demande d'outil passe par les hooks, les règles de refus, les règles de demande, le mode de permission, les règles d'autorisation et canUseTool. Les hooks, les règles de refus et canUseTool peuvent router vers Bloqué ; le contournement du mode de permission, les règles d'autorisation et canUseTool peuvent router vers Exécuter ; les règles de demande routent vers canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow.svg" />

48 50 

51À partir de la v2.1.198, si vous transmettez un callback `canUseTool` que cet ordre d'évaluation ne peut jamais atteindre, le SDK TypeScript émet un avertissement du processus Node.js une fois lorsque la requête est construite. Le code de l'avertissement est `CLAUDE_SDK_CAN_USE_TOOL_SHADOWED`. Deux configurations le déclenchent :

52 

53* `permissionMode: 'bypassPermissions'`, qui approuve automatiquement chaque appel qui atteint l'étape du mode de permission

54* Chaque entrée `allowedTools` simple comme `"Read"`, qui approuve automatiquement cet outil entier avant que le callback ne soit consulté

55 

56Les entrées avec un spécificateur comme `Bash(ls *)` et le mode `acceptEdits` ne le déclenchent pas, et les règles d'autorisation provenant des fichiers de paramètres ne sont pas visibles pour la vérification.

57 

58Écoutez avec `process.on('warning', ...)` et faites correspondre le code pour le journaliser ou le supprimer. Pour contrôler chaque appel d'outil indépendamment du mode et des règles, utilisez plutôt un [hook `PreToolUse`](/fr/agent-sdk/hooks).

59 

49Cette page se concentre sur les **règles d'autorisation et de refus** et les **modes de permission**. Pour les autres étapes :60Cette page se concentre sur les **règles d'autorisation et de refus** et les **modes de permission**. Pour les autres étapes :

50 61 

51* **Hooks :** exécutez du code personnalisé pour autoriser, refuser ou modifier les demandes d'outils. Consultez [Contrôler l'exécution avec les hooks](/fr/agent-sdk/hooks).62* **Hooks :** exécutez du code personnalisé pour autoriser, refuser ou modifier les demandes d'outils. Consultez [Contrôler l'exécution avec les hooks](/fr/agent-sdk/hooks).

67Les règles d'autorisation acceptent les globs de noms d'outils uniquement après un préfixe littéral `mcp__<server>__`. Le segment serveur doit être sans glob afin que la règle nomme un serveur spécifique que vous avez configuré : `mcp__puppeteer__*` correspond à chaque outil du serveur `puppeteer`, et `mcp__github__get_*` correspond à ses outils `get_`. Une entrée non ancrée comme `allowed_tools=["*"]` ou `allowed_tools=["mcp__*"]` est ignorée avec un avertissement au démarrage et n'auto-approuve rien.78Les règles d'autorisation acceptent les globs de noms d'outils uniquement après un préfixe littéral `mcp__<server>__`. Le segment serveur doit être sans glob afin que la règle nomme un serveur spécifique que vous avez configuré : `mcp__puppeteer__*` correspond à chaque outil du serveur `puppeteer`, et `mcp__github__get_*` correspond à ses outils `get_`. Une entrée non ancrée comme `allowed_tools=["*"]` ou `allowed_tools=["mcp__*"]` est ignorée avec un avertissement au démarrage et n'auto-approuve rien.

68 79 

69<Warning>80<Warning>

70 **Les outils auto-approuvés ne parviennent jamais à `canUseTool`.** Un appel d'outil approuvé à n'importe quelle étape antérieure, par `acceptEdits` ou `bypassPermissions`, ou par une règle d'autorisation, ignore votre rappel `canUseTool`, de sorte que les vérifications de permission que vous y mettez sont silencieusement contournées pour cet outil. La couverture dépend de la forme de l'entrée : un nom nu comme `Read` ou `mcp__github__get_issue` auto-approuve chaque appel à cet outil, tandis qu'une règle délimitée comme `Bash(ls *)` auto-approuve uniquement les appels correspondants et les autres appels `Bash` passent toujours au rappel. Pour les vérifications qui doivent s'exécuter sur chaque appel d'outil, utilisez un hook [`PreToolUse`](/fr/agent-sdk/hooks) : les hooks s'exécutent avant chaque autre étape, et un refus de hook s'applique même en mode `bypassPermissions`.81 **Les outils auto-approuvés ne parviennent jamais à `canUseTool`.** Un appel d'outil approuvé à n'importe quelle étape antérieure, par `acceptEdits` ou `bypassPermissions`, ou par une règle d'autorisation, ignore votre rappel `canUseTool`, de sorte que les vérifications de permission que vous y mettez sont silencieusement contournées pour cet outil. L'exception concerne les outils qui nécessitent une interaction utilisateur, `AskUserQuestion` et les outils MCP marqués avec [`_meta["anthropic/requiresUserInteraction"]`](/fr/mcp#require-approval-for-a-specific-tool), qui parviennent au rappel même lorsqu'une règle d'autorisation correspond. La couverture dépend de la forme de l'entrée : un nom nu comme `Read` ou `mcp__github__get_issue` auto-approuve chaque appel à cet outil, tandis qu'une règle délimitée comme `Bash(ls *)` auto-approuve uniquement les appels correspondants et les autres appels `Bash` passent toujours au rappel. Pour les vérifications qui doivent s'exécuter sur chaque appel d'outil, utilisez un hook [`PreToolUse`](/fr/agent-sdk/hooks) : les hooks s'exécutent avant chaque autre étape, et un refus de hook s'applique même en mode `bypassPermissions`.

71</Warning>82</Warning>

72 83 

73Pour un agent verrouillé, associez `allowedTools` avec `permissionMode: "dontAsk"`. Les outils listés sont approuvés ; tout le reste est refusé directement au lieu de demander :84Pour un agent verrouillé, associez `allowedTools` avec `permissionMode: "dontAsk"`. Les outils listés sont approuvés ; tout le reste est refusé directement au lieu de demander :

958```958```

959 959 

960* `API_TIMEOUT_MS` : délai d'expiration par requête sur le client Anthropic, en millisecondes. Par défaut `600000`. S'applique à la boucle principale et à tous les sous-agents.960* `API_TIMEOUT_MS` : délai d'expiration par requête sur le client Anthropic, en millisecondes. Par défaut `600000`. S'applique à la boucle principale et à tous les sous-agents.

961* `CLAUDE_CODE_MAX_RETRIES` : nombre maximum de tentatives API. Par défaut `10`, limité à `15`. Chaque tentative obtient sa propre fenêtre `API_TIMEOUT_MS`, donc le pire temps mural est approximativement `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` plus le backoff. Pour les exécutions sans surveillance qui doivent attendre des pannes plus longues, définissez `CLAUDE_CODE_RETRY_WATCHDOG=1` pour réessayer les erreurs de capacité indéfiniment.961* `CLAUDE_CODE_MAX_RETRIES` : nombre maximum de tentatives API. Par défaut `10`, limité à `15`. Chaque tentative obtient sa propre fenêtre `API_TIMEOUT_MS`, donc le pire temps mural est approximativement `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` plus le backoff. Pour les exécutions sans surveillance qui doivent attendre des pannes plus longues, définissez `CLAUDE_CODE_RETRY_WATCHDOG=1` : il réessaye les erreurs de capacité indéfiniment, et {/* min-version: 2.1.199 */}à partir de Claude Code v2.1.199 augmente la valeur par défaut pour les autres erreurs transitoires à `300` et supprime le plafond sur cette variable.

962* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS` : chien de garde de blocage pour les sous-agents lancés avec `run_in_background`. Par défaut `600000`. Réinitialise à chaque événement de flux ; en cas de blocage, il abandonne le sous-agent, marque la tâche comme échouée et expose l'erreur au parent avec tout résultat partiel. Ne s'applique pas aux sous-agents synchrones.962* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS` : chien de garde de blocage pour les sous-agents lancés avec `run_in_background`. Par défaut `600000`. Réinitialise à chaque événement de flux ; en cas de blocage, il abandonne le sous-agent, marque la tâche comme échouée et expose l'erreur au parent avec tout résultat partiel. Ne s'applique pas aux sous-agents synchrones.

963* `CLAUDE_ENABLE_STREAM_WATCHDOG` avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` : abandonne la requête quand les en-têtes sont arrivés mais le corps de la réponse cesse de faire du streaming. Le chien de garde est activé par défaut pour tous les fournisseurs ; définissez `CLAUDE_ENABLE_STREAM_WATCHDOG=0` pour le désactiver. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` par défaut à `300000` et est limité à ce minimum. La requête abandonnée passe par le chemin de tentative normal.963* `CLAUDE_ENABLE_STREAM_WATCHDOG` avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` : abandonne la requête quand les en-têtes sont arrivés mais le corps de la réponse cesse de faire du streaming. Le chien de garde est activé par défaut pour tous les fournisseurs ; définissez `CLAUDE_ENABLE_STREAM_WATCHDOG=0` pour le désactiver. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` par défaut à `300000` et est limité à ce minimum. La requête abandonnée passe par le chemin de tentative normal.

964 964 

7> Définissez et invoquez des sous-agents pour isoler le contexte, exécuter des tâches en parallèle et appliquer des instructions spécialisées dans vos applications Claude Agent SDK.7> Définissez et invoquez des sous-agents pour isoler le contexte, exécuter des tâches en parallèle et appliquer des instructions spécialisées dans vos applications Claude Agent SDK.

8 8 

9Les sous-agents sont des instances d'agent distinctes que votre agent principal peut créer pour gérer des sous-tâches ciblées.9Les sous-agents sont des instances d'agent distinctes que votre agent principal peut créer pour gérer des sous-tâches ciblées.

10Utilisez les sous-agents pour isoler le contexte des sous-tâches ciblées, exécuter plusieurs analyses en parallèle et appliquer des instructions spécialisées sans surcharger l'invite du principal agent.10Utilisez les sous-agents pour isoler le contexte, exécuter plusieurs analyses en parallèle et appliquer des instructions spécialisées sans surcharger l'invite de l'agent principal.

11 11 

12Ce guide explique comment définir et utiliser les sous-agents dans le SDK en utilisant le paramètre `agents`.12Ce guide explique comment définir et utiliser les sous-agents dans le SDK en utilisant le paramètre `agents`.

13 13 

17 17 

18Vous pouvez créer des sous-agents de trois façons :18Vous pouvez créer des sous-agents de trois façons :

19 19 

20* **Par programmation** : utilisez le paramètre `agents` dans vos options `query()` ([TypeScript](/fr/agent-sdk/typescript#agentdefinition), [Python](/fr/agent-sdk/python#agentdefinition))20* **Par programmation** : utilisez le paramètre `agents` dans vos options `query()`. Consultez les références [TypeScript](/fr/agent-sdk/typescript#agentdefinition) et [Python](/fr/agent-sdk/python#agentdefinition)

21* **Basé sur le système de fichiers** : définissez les agents comme des fichiers markdown dans les répertoires `.claude/agents/` (voir [définir les sous-agents comme fichiers](/fr/sub-agents))21* **Basé sur le système de fichiers** : définissez les agents comme des fichiers markdown dans les répertoires `.claude/agents/`. Consultez [définir les sous-agents comme fichiers](/fr/sub-agents)

22* **Général intégré** : Claude peut invoquer le sous-agent `general-purpose` intégré à tout moment via l'outil Agent sans que vous ayez besoin de rien définir22* **Général intégré** : Claude peut invoquer le sous-agent `general-purpose` intégré à tout moment via l'outil Agent sans que vous ayez besoin de rien définir

23 23 

24Ce guide se concentre sur l'approche programmatique, qui est recommandée pour les applications SDK.24Ce guide se concentre sur l'approche programmatique, qui est recommandée pour les applications SDK.

25 25 

26Lorsque vous définissez des sous-agents, Claude détermine s'il faut les invoquer en fonction du champ `description` de chaque sous-agent. Écrivez des descriptions claires qui expliquent quand le sous-agent doit être utilisé, et Claude délèguera automatiquement les tâches appropriées. Vous pouvez également demander explicitement un sous-agent par son nom dans votre invite (par exemple, « Utilisez l'agent code-reviewer pour... »).26Lorsque vous définissez des sous-agents, Claude détermine s'il faut les invoquer en fonction du champ `description` de chaque sous-agent. Écrivez des descriptions claires qui expliquent quand utiliser le sous-agent, et Claude délèguera automatiquement les tâches appropriées. Vous pouvez également demander explicitement un sous-agent par son nom dans votre invite, par exemple « Utilisez l'agent code-reviewer pour... ».

27 27 

28<h2 id="benefits-of-using-subagents">28<h2 id="benefits-of-using-subagents">

29 Avantages de l'utilisation des sous-agents29 Avantages de l'utilisation des sous-agents

61 61 

62**Exemple :** un sous-agent `doc-reviewer` pourrait n'avoir accès qu'aux outils Read et Grep, garantissant qu'il peut analyser mais ne peut jamais modifier accidentellement vos fichiers de documentation.62**Exemple :** un sous-agent `doc-reviewer` pourrait n'avoir accès qu'aux outils Read et Grep, garantissant qu'il peut analyser mais ne peut jamais modifier accidentellement vos fichiers de documentation.

63 63 

64<h2 id="creating-subagents">64<h2 id="create-subagents">

65 Création de sous-agents65 Créer des sous-agents

66</h2>66</h2>

67 67 

68<h3 id="programmatic-definition-recommended">68<h3 id="programmatic-definition-recommended">

69 Définition programmatique (recommandée)69 Définition programmatique (recommandée)

70</h3>70</h3>

71 71 

72Définissez les sous-agents directement dans votre code en utilisant le paramètre `agents`. Cet exemple crée deux sous-agents : un examinateur de code avec accès en lecture seule et un exécuteur de tests qui peut exécuter des commandes. Claude invoque les sous-agents via l'outil `Agent`, donc incluez `Agent` dans `allowedTools` pour approuver automatiquement les invocations de sous-agents sans invite de permission.72Définissez les sous-agents directement dans votre code en utilisant le paramètre `agents`. Claude invoque les sous-agents via l'outil `Agent`, donc incluez `Agent` dans `allowedTools` pour approuver automatiquement les invocations de sous-agents sans invite de permission.

73 73 

74La plupart des exemples de cette page n'impriment que le résultat final. Pour confirmer que Claude a délégué à un sous-agent plutôt que de répondre directement, voir [Détection de l'invocation de sous-agent](#detecting-subagent-invocation).74La plupart des exemples de cette page n'impriment que le résultat final. Pour confirmer que Claude a délégué à un sous-agent plutôt que de répondre directement, voir [Détecter l'invocation de sous-agent](#detect-subagent-invocation).

75 

76Cet exemple crée deux sous-agents : un examinateur de code avec accès en lecture seule et un exécuteur de tests qui peut exécuter des commandes.

75 77 

76<CodeGroup>78<CodeGroup>

77 ```python Python theme={null}79 ```python Python theme={null}

197 199 

198Dans le SDK Python, les noms de champs multi-mots tels que `disallowedTools` et `mcpServers` conservent leur orthographe camelCase pour correspondre au format de transmission plutôt que de suivre la convention snake\_case de Python. Voir la référence [`AgentDefinition`](/fr/agent-sdk/python#agentdefinition) pour plus de détails.200Dans le SDK Python, les noms de champs multi-mots tels que `disallowedTools` et `mcpServers` conservent leur orthographe camelCase pour correspondre au format de transmission plutôt que de suivre la convention snake\_case de Python. Voir la référence [`AgentDefinition`](/fr/agent-sdk/python#agentdefinition) pour plus de détails.

199 201 

202Deux comportements de sous-agent ont changé dans Claude Code v2.1.198 :

203 

204* Les sous-agents s'exécutent en arrière-plan par défaut. Un appel d'outil Agent qui omet l'entrée [`run_in_background`](/fr/agent-sdk/typescript) lance un sous-agent en arrière-plan, et Claude définit `run_in_background: false` lorsqu'il a besoin du résultat avant de continuer. Avant v2.1.198, l'omission de `run_in_background` exécutait le sous-agent de manière synchrone. Définissez le champ `background` à `true` pour forcer l'exécution en arrière-plan pour un agent spécifique indépendamment de ce que Claude demande.

205* Un sous-agent hérite de la configuration de la réflexion étendue de la session principale. Sur les versions antérieures, la réflexion étendue est désactivée à l'intérieur des sous-agents indépendamment du paramètre de la session principale.

206 

200<Note>207<Note>

201 {/* min-version: 2.1.172 */}À partir de Claude Code v2.1.172, les sous-agents peuvent créer leurs propres sous-agents. Un sous-agent de fond cinq niveaux en dessous de l'agent principal ne peut pas créer d'autres sous-agents, indépendamment du fait qu'il s'exécute au premier plan ou en arrière-plan. Pour empêcher un sous-agent de créer d'autres agents, omettez `Agent` de son tableau `tools` ou ajoutez-le à `disallowedTools`. Voir [sous-agents imbriqués](/fr/sub-agents#spawn-nested-subagents) pour les règles de profondeur complètes.208 {/* min-version: 2.1.172 */}À partir de Claude Code v2.1.172, les sous-agents peuvent créer leurs propres sous-agents. Un sous-agent cinq niveaux en dessous de l'agent principal ne peut pas créer d'autres sous-agents, indépendamment du fait qu'il s'exécute au premier plan ou en arrière-plan. Pour empêcher un sous-agent de créer d'autres agents, omettez `Agent` de son tableau `tools` ou ajoutez-le à `disallowedTools`. Voir [sous-agents imbriqués](/fr/sub-agents#spawn-nested-subagents) pour les règles de profondeur complètes.

202</Note>209</Note>

203 210 

204<h3 id="filesystem-based-definition-alternative">211<h3 id="filesystem-based-definition-alternative">

215 Ce que les sous-agents héritent222 Ce que les sous-agents héritent

216</h2>223</h2>

217 224 

218La fenêtre de contexte d'un sous-agent commence fraîche (pas de conversation parent) mais n'est pas vide. Le seul canal du parent au sous-agent est la chaîne d'invite de l'outil Agent, donc incluez tous les chemins de fichiers, messages d'erreur ou décisions dont le sous-agent a besoin directement dans cette invite.225La fenêtre de contexte d'un sous-agent commence fraîche, sans conversation parent, mais n'est pas vide. Le seul canal du parent au sous-agent est la chaîne d'invite de l'outil Agent, donc incluez tous les chemins de fichiers, messages d'erreur ou décisions dont le sous-agent a besoin directement dans cette invite.

219 226 

220| Le sous-agent reçoit | Le sous-agent ne reçoit pas |227| Le sous-agent reçoit | Le sous-agent ne reçoit pas |

221| :----------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- |228| :----------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- |

224| Les définitions d'outils (héritées du parent, ou le sous-ensemble dans `tools`) | L'invite système du parent |231| Les définitions d'outils (héritées du parent, ou le sous-ensemble dans `tools`) | L'invite système du parent |

225 232 

226<Note>233<Note>

227 Le parent reçoit le message final du sous-agent tel quel comme résultat de l'outil Agent, mais peut le résumer dans sa propre réponse. Pour préserver la sortie du sous-agent tel quel dans la réponse visible par l'utilisateur, incluez une instruction pour le faire dans l'invite ou l'option `systemPrompt` que vous transmettez à l'appel `query()` **principal**.234 Le parent reçoit le message final du sous-agent tel quel comme résultat de l'outil Agent, mais peut le résumer dans sa propre réponse. Pour préserver la sortie du sous-agent tel quel dans la réponse visible par l'utilisateur, incluez une instruction pour le faire dans l'invite ou l'option `systemPrompt` que vous transmettez à l'appel `query()` principal.

228</Note>235</Note>

229 236 

230<h2 id="invoking-subagents">237{/* min-version: 2.1.199 */}À partir de Claude Code v2.1.199, une erreur API qui termine le sous-agent prématurément, comme une limite de débit, n'est jamais livrée comme résultat. Si le sous-agent a déjà produit une sortie, l'outil Agent retourne cette sortie partielle avec une note indiquant que le sous-agent n'a pas terminé ; sinon, le résultat de l'outil est un message d'erreur, `Agent terminated early due to an API error`, suivi du détail de l'erreur. Consultez [API errors in subagents](/fr/sub-agents#api-errors-in-subagents) pour le comportement au premier plan et en arrière-plan.

231 Invocation des sous-agents238 

239<h2 id="invoke-subagents">

240 Invoquer les sous-agents

232</h2>241</h2>

233 242 

234<h3 id="automatic-invocation">243<h3 id="automatic-invocation">

329 ```338 ```

330</CodeGroup>339</CodeGroup>

331 340 

332<h2 id="detecting-subagent-invocation">341<h2 id="detect-subagent-invocation">

333 Détection de l'invocation de sous-agents342 Détection de l'invocation de sous-agents

334</h2>343</h2>

335 344 

336Les sous-agents sont invoqués via l'outil Agent. Pour détecter quand un sous-agent est invoqué, vérifiez les blocs `tool_use` où `name` est `"Agent"`. Les messages provenant du contexte d'un sous-agent incluent un champ `parent_tool_use_id`.345Claude invoque les sous-agents via l'outil Agent. Pour détecter quand un sous-agent est invoqué, vérifiez les blocs `tool_use` où `name` est `"Agent"`. Les messages provenant du contexte d'un sous-agent incluent un champ `parent_tool_use_id`.

337 346 

338<Note>347<Note>

339 Le nom de l'outil a été renommé de `"Task"` à `"Agent"` dans Claude Code v2.1.63. Les versions actuelles du SDK émettent `"Agent"` dans les blocs `tool_use` mais utilisent toujours `"Task"` dans la liste des outils `system:init` et dans `result.permission_denials[].tool_name`. Vérifier les deux valeurs dans `block.name` assure la compatibilité entre les versions du SDK.348 Le nom de l'outil a été renommé de `"Task"` à `"Agent"` dans Claude Code v2.1.63. Les versions actuelles du SDK émettent `"Agent"` dans les blocs `tool_use` mais utilisent toujours `"Task"` dans la liste des outils `system:init` et dans `result.permission_denials[].tool_name`. Vérifier les deux valeurs dans `block.name` assure la compatibilité entre les versions du SDK.

422 ```431 ```

423</CodeGroup>432</CodeGroup>

424 433 

425<h2 id="resuming-subagents">434<h2 id="resume-subagents">

426 Reprise des sous-agents435 Reprise des sous-agents

427</h2>436</h2>

428 437 

429Les sous-agents peuvent être repris pour continuer là où ils se sont arrêtés. Les sous-agents repris conservent leur historique de conversation complet, y compris tous les appels d'outils précédents, les résultats et le raisonnement. Le sous-agent reprend exactement là où il s'est arrêté plutôt que de recommencer à zéro.438Vous pouvez reprendre un sous-agent pour continuer là où il s'est arrêté plutôt que de recommencer à zéro. Un sous-agent repris conserve son historique de conversation complet, y compris tous les appels d'outils précédents, les résultats et le raisonnement.

430 439 

431Lorsqu'un sous-agent se termine, le résultat de l'outil Agent inclut un bloc de texte contenant `agentId: <id>`. Les agents intégrés [`Explore` et `Plan`](/fr/sub-agents#built-in-subagents) sont ponctuels et ne retournent pas d'`agentId`, donc utilisez un agent personnalisé ou `general-purpose` lorsque vous avez besoin de reprendre. Pour reprendre un sous-agent par programmation :440Lorsqu'un sous-agent se termine, le résultat de l'outil Agent inclut un bloc de texte contenant `agentId: <id>`. Les agents intégrés [`Explore` et `Plan`](/fr/sub-agents#built-in-subagents) sont ponctuels et ne retournent pas d'`agentId`, donc utilisez un agent personnalisé ou `general-purpose` lorsque vous avez besoin de reprendre. Pour reprendre un sous-agent par programmation :

432 441 

568 577 

569* **Compaction de la conversation principale** : Lorsque la conversation principale se compacte, les transcriptions des sous-agents ne sont pas affectées. Elles sont stockées dans des fichiers séparés.578* **Compaction de la conversation principale** : Lorsque la conversation principale se compacte, les transcriptions des sous-agents ne sont pas affectées. Elles sont stockées dans des fichiers séparés.

570* **Persistance de la session** : Les transcriptions des sous-agents persistent au sein de leur session. Vous pouvez reprendre un sous-agent après avoir redémarré Claude Code en reprenant la même session.579* **Persistance de la session** : Les transcriptions des sous-agents persistent au sein de leur session. Vous pouvez reprendre un sous-agent après avoir redémarré Claude Code en reprenant la même session.

571* **Nettoyage automatique** : Les transcriptions sont nettoyées en fonction du paramètre `cleanupPeriodDays` (par défaut : 30 jours).580* **Nettoyage automatique** : Les transcriptions sont nettoyées en fonction du paramètre `cleanupPeriodDays`, qui est défini par défaut à 30 jours.

572 581 

573<h2 id="tool-restrictions-1">582<h2 id="tool-restrictions-1">

574 Restrictions d'outils583 Restrictions d'outils

662 671 

663Si Claude complète les tâches directement au lieu de déléguer à votre sous-agent :672Si Claude complète les tâches directement au lieu de déléguer à votre sous-agent :

664 673 

6651. **Vérifiez que les invocations d'Agent sont approuvées** : incluez `Agent` dans `allowedTools` pour approuver automatiquement les appels de sous-agent. Sans cela, les invocations d'Agent passent par votre callback `canUseTool` ou, en mode `dontAsk`, sont refusées674* **Vérifiez que les invocations d'Agent sont approuvées** : incluez `Agent` dans `allowedTools` pour approuver automatiquement les appels de sous-agent. Sans cela, les invocations d'Agent passent par votre callback `canUseTool` ou, en mode `dontAsk`, sont refusées

6662. **Utilisez des invites explicites** : mentionnez le sous-agent par son nom dans votre invite (par exemple, « Utilisez l'agent code-reviewer pour... »)675* **Utilisez des invites explicites** : mentionnez le sous-agent par son nom dans votre invite, par exemple « Utilisez l'agent code-reviewer pour... »

6673. **Écrivez une description claire** : expliquez exactement quand le sous-agent doit être utilisé pour que Claude puisse faire correspondre les tâches de manière appropriée676* **Écrivez une description claire** : expliquez exactement quand utiliser le sous-agent pour que Claude puisse faire correspondre les tâches de manière appropriée

668 677 

669<h3 id="filesystem-based-agents-not-loading">678<h3 id="filesystem-based-agents-not-loading">

670 Les agents basés sur le système de fichiers ne se chargent pas679 Les agents basés sur le système de fichiers ne se chargent pas

671</h3>680</h3>

672 681 

673Les agents définis dans `.claude/agents/` sont chargés au démarrage uniquement. Si vous créez un nouveau fichier d'agent pendant que Claude Code s'exécute, redémarrez la session pour le charger.682Claude Code surveille `~/.claude/agents/` et `.claude/agents/` et détecte un fichier d'agent nouveau ou modifié en quelques secondes, sans redémarrage nécessaire. Si une définition n'apparaît jamais, vérifiez ces causes :

683 

684* **Nouveau répertoire `agents`** : le moniteur couvre uniquement les répertoires qui existaient au démarrage de la session, donc le premier fichier dans un nouveau répertoire nécessite un redémarrage de session. C'est la cause la plus courante.

685* **Frontmatter invalide ou `name` en doublon** : vérifiez le YAML du fichier et si un agent existant utilise déjà le `name`.

686* **`--disable-slash-commands`** : les sessions démarrées avec ce flag ne surveillent pas ces répertoires et nécessitent toujours un redémarrage pour charger les nouveaux fichiers.

687* **Un agent programmatique avec le même nom** : les `agents` passés à `query()` remplacent un agent du système de fichiers avec le même nom.

688 

689Pour le format de fichier, consultez [comment écrire des fichiers de sous-agent](/fr/sub-agents#write-subagent-files).

674 690 

675<h3 id="windows-long-prompt-failures">691<h3 id="long-prompt-failures-on-windows">

676 Windows : échecs d'invite longue692 Échecs d'invite longue sur Windows

677</h3>693</h3>

678 694 

679Sur Windows, les sous-agents avec des invites très longues peuvent échouer en raison des limites de longueur de ligne de commande (8191 caractères). Gardez les invites concises ou utilisez des agents basés sur le système de fichiers pour les instructions complexes.695Sur Windows, les sous-agents avec des invites très longues peuvent échouer en raison de la limite de longueur de ligne de commande de 8191 caractères. Gardez les invites concises ou utilisez des agents basés sur le système de fichiers pour les instructions complexes.

680 696 

681<h2 id="related-documentation">697<h2 id="related-documentation">

682 Documentation connexe698 Documentation connexe

9Le suivi des tâches fournit un moyen structuré de gérer les tâches et d'afficher la progression aux utilisateurs. Le SDK Claude Agent inclut une fonctionnalité de tâches intégrée qui aide à organiser les flux de travail complexes et à tenir les utilisateurs informés de la progression des tâches.9Le suivi des tâches fournit un moyen structuré de gérer les tâches et d'afficher la progression aux utilisateurs. Le SDK Claude Agent inclut une fonctionnalité de tâches intégrée qui aide à organiser les flux de travail complexes et à tenir les utilisateurs informés de la progression des tâches.

10 10 

11<Note>11<Note>

12 À partir du TypeScript Agent SDK 0.3.142 et Claude Code v2.1.142, les sessions utilisent les outils Task structurés `TaskCreate`, `TaskUpdate`, `TaskGet` et `TaskList` à la place de `TodoWrite`. Consultez [Migrer vers les outils Task](#migrate-to-task-tools) pour savoir comment le code de surveillance change. Les exemples de cette page définissent `CLAUDE_CODE_ENABLE_TASKS=0` pour continuer à afficher `TodoWrite` pour les sessions qui n'ont pas encore migré.12 À partir du TypeScript Agent SDK 0.3.142 et Claude Code v2.1.142, les sessions utilisent les outils Task structurés `TaskCreate`, `TaskUpdate`, `TaskGet` et `TaskList` à la place de `TodoWrite`. Le SDK Python obtient ce changement à partir de la CLI Claude Code qu'il lance, et non à partir de la version du package Python : le changement s'applique une fois que cette CLI — la copie fournie dans le package pip, ou celle vers laquelle vous pointez avec `cli_path` — est v2.1.142 ou ultérieure. Consultez [Migrer vers les outils Task](#migrate-to-task-tools) pour savoir comment le code de surveillance change. Les exemples de cette page définissent `CLAUDE_CODE_ENABLE_TASKS=0` pour continuer à afficher `TodoWrite` pour les sessions qui n'ont pas encore migré.

13</Note>13</Note>

14 14 

15<h3 id="todo-lifecycle">15<h3 id="todo-lifecycle">

27 Quand les tâches sont utilisées27 Quand les tâches sont utilisées

28</h3>28</h3>

29 29 

30Le SDK crée automatiquement des tâches pour :30Le SDK crée des tâches pour la plupart des travaux multi-étapes, tels que :

31 31 

32* **Les tâches complexes multi-étapes** nécessitant 3 actions distinctes ou plus32* **Les tâches complexes multi-étapes** nécessitant 3 actions distinctes ou plus

33* **Les listes de tâches fournies par l'utilisateur** lorsque plusieurs éléments sont mentionnés33* **Les listes de tâches fournies par l'utilisateur** lorsque plusieurs éléments sont mentionnés

34* **Les opérations non triviales** qui bénéficient du suivi de la progression34* **Les opérations non triviales** qui bénéficient du suivi de la progression

35* **Les demandes explicites** lorsque les utilisateurs demandent une organisation des tâches35* **Les demandes explicites** lorsque les utilisateurs demandent une organisation des tâches

36 36 

37Il peut ignorer les tâches pour les demandes très courtes ou à une seule étape.

38 

37<h2 id="examples">39<h2 id="examples">

38 Exemples40 Exemples

39</h2>41</h2>

40 42 

43Avant d'exécuter ces exemples, installez le Claude Agent SDK en suivant le [démarrage rapide](/fr/agent-sdk/quickstart).

44 

45Chaque exemple s'exécute jusqu'à ce que l'agent se termine et produise son message de résultat final. Si une session atteint d'abord sa limite de tours, ce message de résultat a le sous-type `error_max_turns`. Vérifiez `subtype` pour détecter cette fin.

46 

47Ces exemples utilisent des appels `query()` uniques. Après avoir produit un résultat `error_max_turns`, `query()` lève une erreur qui inclut `Reached maximum number of turns`. Chaque exemple enveloppe sa boucle dans un bloc try pour quitter proprement quand cela se produit.

48 

49Voir [Gérer le résultat](/fr/agent-sdk/agent-loop#handle-the-result) pour les sous-types de résultat.

50 

41<h3 id="monitoring-todo-changes">51<h3 id="monitoring-todo-changes">

42 Surveillance des modifications des tâches52 Surveillance des modifications des tâches

43</h3>53</h3>

46 ```typescript TypeScript theme={null}56 ```typescript TypeScript theme={null}

47 import { query } from "@anthropic-ai/claude-agent-sdk";57 import { query } from "@anthropic-ai/claude-agent-sdk";

48 58 

59 try {

49 for await (const message of query({60 for await (const message of query({

50 prompt: "Optimize my React app performance and track progress with todos",61 prompt: "Optimize my React app performance and track progress with todos",

51 // Re-enable TodoWrite, which this example monitors. Without it, the SDK uses62 // Re-enable TodoWrite, which this example monitors. Without it, the SDK uses

68 }79 }

69 }80 }

70 }81 }

82 } catch (error) {

83 // A single-shot query() throws after yielding an error result,

84 // such as when the maxTurns limit is hit.

85 console.log(`Session ended with an error: ${error}`);

86 }

71 ```87 ```

72 88 

73 ```python Python theme={null}89 ```python Python theme={null}

90 import asyncio

91 

74 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock92 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock

75 93 

94 

95 async def main():

96 try:

76 async for message in query(97 async for message in query(

77 prompt="Optimize my React app performance and track progress with todos",98 prompt="Optimize my React app performance and track progress with todos",

78 # Re-enable TodoWrite, which this example monitors. Without it, the SDK uses99 # Re-enable TodoWrite, which this example monitors. Without it, the SDK uses

95 else "❌"116 else "❌"

96 )117 )

97 print(f"{i + 1}. {status} {todo['content']}")118 print(f"{i + 1}. {status} {todo['content']}")

119 except Exception as error:

120 # A single-shot query() raises after yielding an error result,

121 # such as when the max_turns limit is hit.

122 print(f"Session ended with an error: {error}")

123 

124 

125 asyncio.run(main())

98 ```126 ```

99</CodeGroup>127</CodeGroup>

100 128 

128 }156 }

129 157 

130 async trackQuery(prompt: string) {158 async trackQuery(prompt: string) {

159 try {

131 for await (const message of query({160 for await (const message of query({

132 prompt,161 prompt,

133 // Re-enable TodoWrite, which this tracker watches for.162 // Re-enable TodoWrite, which this tracker watches for.

142 }171 }

143 }172 }

144 }173 }

174 } catch (error) {

175 // A single-shot query() throws after yielding an error result,

176 // such as when the maxTurns limit is hit.

177 console.log(`Session ended with an error: ${error}`);

178 }

145 }179 }

146 }180 }

147 181 

151 ```185 ```

152 186 

153 ```python Python theme={null}187 ```python Python theme={null}

188 import asyncio

189 

154 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock190 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock

155 from typing import List, Dict191 from typing import List, Dict

156 192 

186 print(f"{i + 1}. {icon} {text}")222 print(f"{i + 1}. {icon} {text}")

187 223 

188 async def track_query(self, prompt: str):224 async def track_query(self, prompt: str):

225 try:

189 async for message in query(226 async for message in query(

190 prompt=prompt,227 prompt=prompt,

191 # Re-enable TodoWrite, which this tracker watches for.228 # Re-enable TodoWrite, which this tracker watches for.

196 if isinstance(block, ToolUseBlock) and block.name == "TodoWrite":233 if isinstance(block, ToolUseBlock) and block.name == "TodoWrite":

197 self.todos = block.input["todos"]234 self.todos = block.input["todos"]

198 self.display_progress()235 self.display_progress()

236 except Exception as error:

237 # A single-shot query() raises after yielding an error result,

238 # such as when the max_turns limit is hit.

239 print(f"Session ended with an error: {error}")

199 240 

200 241 

201 # Usage242 # Usage

243 async def main():

202 tracker = TodoTracker()244 tracker = TodoTracker()

203 await tracker.track_query("Build a complete authentication system with todos")245 await tracker.track_query("Build a complete authentication system with todos")

246 

247 

248 asyncio.run(main())

204 ```249 ```

205</CodeGroup>250</CodeGroup>

206 251 

217| Forme d'élément : `{ content, status, activeForm }` | Entrée `TaskCreate` : `{ subject, description, activeForm?, metadata? }`. Entrée `TaskUpdate` : `{ taskId, status?, subject?, description?, activeForm?, addBlocks?, addBlockedBy?, owner?, metadata? }`. `status` est `"pending"`, `"in_progress"` ou `"completed"` ; définissez `status: "deleted"` pour supprimer |262| Forme d'élément : `{ content, status, activeForm }` | Entrée `TaskCreate` : `{ subject, description, activeForm?, metadata? }`. Entrée `TaskUpdate` : `{ taskId, status?, subject?, description?, activeForm?, addBlocks?, addBlockedBy?, owner?, metadata? }`. `status` est `"pending"`, `"in_progress"` ou `"completed"` ; définissez `status: "deleted"` pour supprimer |

218| Rendre `block.input.todos` directement | Accumuler les éléments entre les appels, ou lire un instantané à partir d'un résultat d'outil `TaskList` |263| Rendre `block.input.todos` directement | Accumuler les éléments entre les appels, ou lire un instantané à partir d'un résultat d'outil `TaskList` |

219 264 

220L'ID de tâche assigné ne se trouve pas dans l'entrée `TaskCreate`. Il revient dans le bloc `tool_result` correspondant sous la forme `{ task: { id, subject } }`, donc capturez-le à partir du bloc de résultat pour indexer votre carte. L'exemple suivant montre le changement minimal à la boucle [Surveillance des modifications des tâches](#monitoring-todo-changes). Pour rendre une liste complète, regardez un résultat d'outil `TaskList` dans le flux ou accumulez les résultats `TaskCreate` et les entrées `TaskUpdate` dans une carte.265L'ID de tâche assigné ne se trouve pas dans l'entrée `TaskCreate`. Il revient dans le bloc `tool_result` correspondant sous la forme `{ task: { id, subject } }`, donc capturez-le à partir du bloc de résultat pour indexer votre carte. L'exemple suivant montre le changement minimal à la boucle [Surveillance des modifications des tâches](#monitoring-todo-changes). Il lit uniquement les entrées `tool_use` et ignore la capture des ID à partir des blocs `tool_result`. Pour rendre une liste complète, regardez un résultat d'outil `TaskList` dans le flux ou accumulez les résultats `TaskCreate` et les entrées `TaskUpdate` dans une carte.

221 266 

222Le flux `tool_use` d'entrée est la forme brute que le modèle a émise. Claude Code répare certains noms de clés proches mais incorrects avant l'exécution, en mappant `id` ou `task_id` à `taskId` et `active_form` à `activeForm`, mais cette réparation n'est pas reflétée dans le flux. Lisez les champs d'entrée `TaskUpdate` de manière défensive, comme le font les exemples ci-dessous, plutôt que de supposer que le nom canonique est toujours présent.267Le flux `tool_use` d'entrée est la forme brute que le modèle a émise. Claude Code répare certains noms de clés proches mais incorrects avant l'exécution, en mappant `id` ou `task_id` à `taskId` et `active_form` à `activeForm`, mais cette réparation n'est pas reflétée dans le flux. Lisez les champs d'entrée `TaskUpdate` de manière défensive, comme le font les exemples ci-dessous, plutôt que de supposer que le nom canonique est toujours présent.

223 268 

225 ```typescript TypeScript theme={null}270 ```typescript TypeScript theme={null}

226 import { query } from "@anthropic-ai/claude-agent-sdk";271 import { query } from "@anthropic-ai/claude-agent-sdk";

227 272 

273 try {

228 for await (const message of query({274 for await (const message of query({

229 prompt: "Optimize my React app performance",275 prompt: "Optimize my React app performance and track progress with todos",

276 options: { maxTurns: 15 },

230 })) {277 })) {

231 if (message.type !== "assistant") continue;278 if (message.type !== "assistant") continue;

232 for (const block of message.message.content) {279 for (const block of message.message.content) {

246 }293 }

247 }294 }

248 }295 }

296 } catch (error) {

297 // A single-shot query() throws after yielding an error result.

298 console.log(`Session ended with an error: ${error}`);

299 }

249 ```300 ```

250 301 

251 ```python Python theme={null}302 ```python Python theme={null}

252 from claude_agent_sdk import query, AssistantMessage, ToolUseBlock303 import asyncio

253 304 

305 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock

306 

307 async def main():

308 try:

254 async for message in query(309 async for message in query(

255 prompt="Optimize my React app performance",310 prompt="Optimize my React app performance and track progress with todos",

311 options=ClaudeAgentOptions(max_turns=15),

256 ):312 ):

257 if not isinstance(message, AssistantMessage):313 if not isinstance(message, AssistantMessage):

258 continue314 continue

269 )325 )

270 if task_id:326 if task_id:

271 print(f" {task_id} -> {block.input['status']}")327 print(f" {task_id} -> {block.input['status']}")

328 except Exception as error:

329 # A single-shot query() raises after yielding an error result.

330 print(f"Session ended with an error: {error}")

331 

332 

333 asyncio.run(main())

272 ```334 ```

273</CodeGroup>335</CodeGroup>

274 336 

551```551```

552 552 

553* `API_TIMEOUT_MS` : délai d'expiration par requête sur le client Anthropic, en millisecondes. Par défaut `600000`. S'applique à la boucle principale et à tous les sous-agents.553* `API_TIMEOUT_MS` : délai d'expiration par requête sur le client Anthropic, en millisecondes. Par défaut `600000`. S'applique à la boucle principale et à tous les sous-agents.

554* `CLAUDE_CODE_MAX_RETRIES` : tentatives API maximales. Par défaut `10`, limité à `15`. Chaque tentative obtient sa propre fenêtre `API_TIMEOUT_MS`, donc le pire cas de temps mural est approximativement `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` plus le backoff. Pour les exécutions sans surveillance qui doivent attendre des pannes plus longues, définissez `CLAUDE_CODE_RETRY_WATCHDOG=1` pour réessayer les erreurs de capacité indéfiniment.554* `CLAUDE_CODE_MAX_RETRIES` : tentatives API maximales. Par défaut `10`, limité à `15`. Chaque tentative obtient sa propre fenêtre `API_TIMEOUT_MS`, donc le pire cas de temps mural est approximativement `API_TIMEOUT_MS × (CLAUDE_CODE_MAX_RETRIES + 1)` plus le backoff. Pour les exécutions sans surveillance qui doivent attendre des pannes plus longues, définissez `CLAUDE_CODE_RETRY_WATCHDOG=1` : il réessaye les erreurs de capacité indéfiniment, et {/* min-version: 2.1.199 */}à partir de Claude Code v2.1.199 augmente la valeur par défaut pour les autres erreurs transitoires à `300` et supprime le plafond sur cette variable.

555* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS` : chien de garde de blocage pour les sous-agents lancés avec `run_in_background`. Par défaut `600000`. Réinitialise à chaque événement de flux ; en cas de blocage, il abandonne le sous-agent, marque la tâche comme échouée et expose l'erreur au parent avec tout résultat partiel. Ne s'applique pas aux sous-agents synchrones.555* `CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS` : chien de garde de blocage pour les sous-agents lancés avec `run_in_background`. Par défaut `600000`. Réinitialise à chaque événement de flux ; en cas de blocage, il abandonne le sous-agent, marque la tâche comme échouée et expose l'erreur au parent avec tout résultat partiel. Ne s'applique pas aux sous-agents synchrones.

556* `CLAUDE_ENABLE_STREAM_WATCHDOG` avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` : abandonne la requête quand les en-têtes sont arrivés mais que le corps de la réponse cesse de diffuser. Le chien de garde est activé par défaut pour tous les fournisseurs ; définissez `CLAUDE_ENABLE_STREAM_WATCHDOG=0` pour le désactiver. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` par défaut à `300000` et est limité à ce minimum. La requête abandonnée passe par le chemin de tentative normal.556* `CLAUDE_ENABLE_STREAM_WATCHDOG` avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` : abandonne la requête quand les en-têtes sont arrivés mais que le corps de la réponse cesse de diffuser. Le chien de garde est activé par défaut pour tous les fournisseurs ; définissez `CLAUDE_ENABLE_STREAM_WATCHDOG=0` pour le désactiver. `CLAUDE_STREAM_IDLE_TIMEOUT_MS` par défaut à `300000` et est limité à ce minimum. La requête abandonnée passe par le chemin de tentative normal.

557 557 

901 decisionReason?: string;901 decisionReason?: string;

902 toolUseID: string;902 toolUseID: string;

903 agentID?: string;903 agentID?: string;

904 requestId: string;

904 }905 }

905) => Promise<PermissionResult>;906) => Promise<PermissionResult | null>;

906```907```

907 908 

908| Option | Type | Description |909| Option | Type | Description |

913| `decisionReason` | `string` | Explique pourquoi cette demande de permission a été déclenchée |914| `decisionReason` | `string` | Explique pourquoi cette demande de permission a été déclenchée |

914| `toolUseID` | `string` | Identifiant unique pour cet appel d'outil spécifique dans le message assistant |915| `toolUseID` | `string` | Identifiant unique pour cet appel d'outil spécifique dans le message assistant |

915| `agentID` | `string` | Si exécuté dans un sous-agent, l'ID du sous-agent |916| `agentID` | `string` | Si exécuté dans un sous-agent, l'ID du sous-agent |

917| `requestId` | `string` | L'`request_id` du wrapper d'enveloppe `control_request`. Une `control_response` que votre application envoie en dehors du SDK, comme un POST HTTP signé, doit répéter cette valeur pour que le processus Claude Code puisse faire correspondre la réponse à la demande |

918 

919Le rappel résout normalement la demande en retournant un [`PermissionResult`](#permissionresult), que le SDK écrit en retour sur son transport en tant que `control_response`. Retournez `null` uniquement quand votre application a déjà envoyé la `control_response` pour cette demande sur son propre canal, en répétant `requestId` ; le SDK saute alors l'écriture de la réponse sur son transport. Retourner `null` dans tout autre cas laisse l'appel d'outil bloqué indéfiniment, car aucune `control_response` n'est jamais envoyée et les invites de permission ne s'écoulent pas.

920 

921L'option `requestId` et la valeur de retour `null` nécessitent Claude Code v2.1.199 ou ultérieur.

916 922 

917<h3 id="permissionresult">923<h3 id="permissionresult">

918 `PermissionResult`924 `PermissionResult`

2179};2185};

2180```2186```

2181 2187 

2182Arrête une tâche de fond en cours d'exécution ou un shell par ID.2188Arrête une tâche de fond en cours d'exécution ou un shell par ID. {/* min-version: 2.1.198 */}À partir de v2.1.198, `task_id` accepte également un coéquipier d'équipe d'agent ou un agent de fond nommé par ID d'agent ou nom.

2183 2189 

2184<h3 id="notebookedit">2190<h3 id="notebookedit">

2185 NotebookEdit2191 NotebookEdit

3788| `ripgrep` | `{ command: string; args?: string[] }` | `undefined` | Configuration de binaire ripgrep personnalisée pour les environnements sandbox |3794| `ripgrep` | `{ command: string; args?: string[] }` | `undefined` | Configuration de binaire ripgrep personnalisée pour les environnements sandbox |

3789 3795 

3790<Note>3796<Note>

3791 Le sandbox dépend du support de la plateforme et, sur Linux, d'outils comme `bubblewrap` et `socat`. Quand `enabled` est `true` et que le sandbox ne peut pas démarrer, `query()` signale un message `result` avec `subtype: "error_during_execution"` et la raison dans `errors`, puis s'arrête. Surveillez ce subtype plutôt que de vous attendre à ce que `query()` lève une exception avant de produire des messages.3797 Le sandbox dépend du support de la plateforme et, sur Linux, d'outils comme `bubblewrap` et `socat`. Quand `enabled` est `true` et que le sandbox ne peut pas démarrer, `query()` signale un message `result` avec `subtype: "error_during_execution"` et la raison dans `errors`. Pour un appel `query()` à message unique, le SDK lève une exception après avoir produit ce résultat d'erreur, donc enveloppez la boucle dans un bloc try pour continuer au-delà. Voir [Gérer le résultat](/fr/agent-sdk/agent-loop#handle-the-result) pour le contrat d'erreur.

3792 3798 

3793 Pour exécuter sans sandbox à la place, définissez `failIfUnavailable: false`.3799 Pour exécuter sans sandbox à la place, définissez `failIfUnavailable: false`.

3794</Note>3800</Note>

3800```typescript theme={null}3806```typescript theme={null}

3801import { query } from "@anthropic-ai/claude-agent-sdk";3807import { query } from "@anthropic-ai/claude-agent-sdk";

3802 3808 

3803for await (const message of query({3809try {

3810 for await (const message of query({

3804 prompt: "Build and test my project",3811 prompt: "Build and test my project",

3805 options: {3812 options: {

3806 sandbox: {3813 sandbox: {

3811 }3818 }

3812 }3819 }

3813 }3820 }

3814})) {3821 })) {

3815 if ("result" in message) console.log(message.result);3822 if ("result" in message) console.log(message.result);

3823 }

3824} catch (error) {

3825 // Un appel query() à message unique lève une exception après avoir produit un résultat d'erreur,

3826 // par exemple quand le sandbox ne peut pas démarrer (failIfUnavailable est par défaut true).

3827 console.log(`Session ended with an error: ${error}`);

3816}3828}

3817```3829```

3818 3830 

3929<Warning>3941<Warning>

3930 Les commandes s'exécutant avec `dangerouslyDisableSandbox: true` ont un accès complet au système. Assurez-vous que votre gestionnaire `canUseTool` valide ces demandes avec soin.3942 Les commandes s'exécutant avec `dangerouslyDisableSandbox: true` ont un accès complet au système. Assurez-vous que votre gestionnaire `canUseTool` valide ces demandes avec soin.

3931 3943 

3932 Si `permissionMode` est défini sur `bypassPermissions` et `allowUnsandboxedCommands` est activé, le modèle peut exécuter de manière autonome des commandes en dehors du sandbox sans aucune invite d'approbation. Cette combinaison permet effectivement au modèle d'échapper à l'isolation du sandbox silencieusement.3944 Si `permissionMode` est défini sur `bypassPermissions` et `allowUnsandboxedCommands` est activé, le modèle peut exécuter de manière autonome des commandes en dehors du sandbox sans aucune invite d'approbation (une [règle `ask`](/fr/agent-sdk/permissions#how-permissions-are-evaluated) explicite en force toujours une). Cette combinaison permet effectivement au modèle d'échapper à l'isolation du sandbox silencieusement.

3933</Warning>3945</Warning>

3934 3946 

3935<h2 id="see-also">3947<h2 id="see-also">

89* **Entrée** : ouvrir la transcription du coéquipier sélectionné et lui envoyer un message directement89* **Entrée** : ouvrir la transcription du coéquipier sélectionné et lui envoyer un message directement

90* **Échap** : interrompre le tour actuel du coéquipier sélectionné90* **Échap** : interrompre le tour actuel du coéquipier sélectionné

91 91 

92{/* min-version: 2.1.181 */}À partir de la v2.1.181, la ligne d'un coéquipier inactif se masque après 30 secondes et réapparaît à son prochain tour. Le coéquipier continue de fonctionner et reste adressable pendant qu'il est masqué.92{/* min-version: 2.1.199 */}À partir de la v2.1.199, la ligne d'un coéquipier inactif reste dans le panneau tant que n'importe quel coéquipier ou sous-agent travaille encore, vous pouvez donc la sélectionner pour examiner sa transcription ou lui envoyer plus de travail. Une fois que chaque agent du panneau est inactif, les lignes inactives se masquent après 30 secondes et réapparaissent au prochain tour du coéquipier ; le coéquipier continue de fonctionner et reste adressable pendant qu'il est masqué. Dans les versions v2.1.181 à v2.1.198, une ligne inactif s'est masquée 30 secondes après la fin de son propre tour, même si d'autres coéquipiers travaillaient encore ; les lignes inactives ne sont pas masquées dans les versions antérieures à v2.1.181.

93 

94Lorsque plus de trois coéquipiers sont inactifs à la fois, les lignes au-delà des trois premières se réduisent en une seule ligne qui compte les coéquipiers réduits, comme `2 agents inactifs` quand cinq sont inactifs. Sélectionnez-la et appuyez sur Entrée pour développer les lignes réduites, ou appuyez sur Échap pour les réduire à nouveau. Les coéquipiers qui travaillent, les coéquipiers qui ont échoué, et le coéquipier que vous consultez conservent toujours leurs propres lignes.

93 95 

94Si vous souhaitez que chaque coéquipier soit dans son propre volet divisé, consultez [Choisir un mode d'affichage](#choose-a-display-mode).96Si vous souhaitez que chaque coéquipier soit dans son propre volet divisé, consultez [Choisir un mode d'affichage](#choose-a-display-mode).

95 97 

174* **Mode in-process** : utilisez les touches fléchées haut et bas dans le panneau d'agent pour sélectionner un coéquipier, puis appuyez sur Entrée pour afficher sa session et tapez pour lui envoyer un message. Appuyez sur `x` sur un coéquipier sélectionné pour l'arrêter. Appuyez sur Ctrl+T pour basculer la liste des tâches.176* **Mode in-process** : utilisez les touches fléchées haut et bas dans le panneau d'agent pour sélectionner un coéquipier, puis appuyez sur Entrée pour afficher sa session et tapez pour lui envoyer un message. Appuyez sur `x` sur un coéquipier sélectionné pour l'arrêter. Appuyez sur Ctrl+T pour basculer la liste des tâches.

175* **Mode volets divisés** : cliquez dans le volet d'un coéquipier pour interagir directement avec sa session. Chaque coéquipier a une vue complète de son propre terminal.177* **Mode volets divisés** : cliquez dans le volet d'un coéquipier pour interagir directement avec sa session. Chaque coéquipier a une vue complète de son propre terminal.

176 178 

179Pendant que vous visualisez un coéquipier in-process, le texte brut et les [skills](/fr/skills) vont à ce coéquipier, mais les commandes intégrées s'exécutent toujours dans la session du chef.

180 

181Le modèle et le mode rapide d'un coéquipier sont fixés lorsqu'il est généré, donc `/model` et `/fast` ne changent que les paramètres du chef. {/* min-version: 2.1.199 */}À partir de la v2.1.199, taper l'une ou l'autre commande en visualisant un coéquipier affiche un avis indiquant que le changement s'applique au chef ; les versions antérieures l'appliquaient au chef sans indication. `/effort` s'applique toujours aux tours ultérieurs du coéquipier visualisé, car les coéquipiers suivent le [niveau d'effort](/fr/model-config#adjust-effort-level) du chef.

182 

177<h3 id="assign-and-claim-tasks">183<h3 id="assign-and-claim-tasks">

178 Assigner et revendiquer des tâches184 Assigner et revendiquer des tâches

179</h3>185</h3>

295**Comment les coéquipiers partagent les informations :**301**Comment les coéquipiers partagent les informations :**

296 302 

297* **Livraison automatique de messages** : lorsque les coéquipiers envoient des messages, ils sont livrés automatiquement aux destinataires. Le chef n'a pas besoin d'interroger les mises à jour.303* **Livraison automatique de messages** : lorsque les coéquipiers envoient des messages, ils sont livrés automatiquement aux destinataires. Le chef n'a pas besoin d'interroger les mises à jour.

298* **Notifications d'inactivité** : lorsqu'un coéquipier termine et s'arrête, il notifie automatiquement le chef.304* **Notifications d'inactivité** : lorsqu'un coéquipier termine et s'arrête, il notifie automatiquement le chef. {/* min-version: 2.1.198 */}À partir de la v2.1.198, un coéquipier dont le tour se termine sur une erreur API notifie le chef qu'il a échoué et inclut le texte d'erreur, au lieu d'apparaître comme terminé normalement.

299* **Liste de tâches partagée** : tous les agents peuvent voir l'état des tâches et revendiquer le travail disponible.305* **Liste de tâches partagée** : tous les agents peuvent voir l'état des tâches et revendiquer le travail disponible.

300* **Messagerie des coéquipiers** : envoyer un message à un coéquipier spécifique par son nom. Pour atteindre tout le monde, envoyez un message par destinataire.306* **Messagerie des coéquipiers** : envoyer un message à un coéquipier spécifique par son nom. Pour atteindre tout le monde, envoyez un message par destinataire.

301 307 

430Si les coéquipiers n'apparaissent pas après avoir demandé à Claude de créer une équipe :436Si les coéquipiers n'apparaissent pas après avoir demandé à Claude de créer une équipe :

431 437 

432* En mode in-process, les coéquipiers apparaissent dans le panneau d'agent sous l'entrée de prompt. Utilisez les touches fléchées haut et bas pour en sélectionner un, puis appuyez sur Entrée pour l'afficher.438* En mode in-process, les coéquipiers apparaissent dans le panneau d'agent sous l'entrée de prompt. Utilisez les touches fléchées haut et bas pour en sélectionner un, puis appuyez sur Entrée pour l'afficher.

433* Une ligne de coéquipier qui a disparu après être restée inactive a été masquée, non arrêtée. Les lignes inactives se masquent après 30 secondes et réapparaissent au prochain tour du coéquipier. Envoyez un message au coéquipier par son nom pour le ramener.439* Une ligne de coéquipier qui a disparu après être restée inactive a été masquée, non arrêtée. Les lignes inactives se masquent 30 secondes après que le panneau entier devienne inactif et réapparaissent au prochain tour du coéquipier. Quand plus de trois coéquipiers sont inactifs, leurs lignes excédentaires s'effondrent en une seule ligne `N idle agents` que Entrée développe. Envoyez un message au coéquipier par son nom pour ramener une ligne masquée.

434* Vérifiez que la tâche que vous avez donnée à Claude était suffisamment complexe pour justifier une équipe. Claude décide s'il faut générer des coéquipiers en fonction de la tâche.440* Vérifiez que la tâche que vous avez donnée à Claude était suffisamment complexe pour justifier une équipe. Claude décide s'il faut générer des coéquipiers en fonction de la tâche.

435* Si vous avez explicitement demandé des volets divisés, assurez-vous que tmux est installé et disponible dans votre PATH :441* Si vous avez explicitement demandé des volets divisés, assurez-vous que tmux est installé et disponible dans votre PATH :

436 ```bash theme={null}442 ```bash theme={null}

453* Donnez-leur des instructions supplémentaires directement459* Donnez-leur des instructions supplémentaires directement

454* Générez un coéquipier de remplacement pour continuer le travail460* Générez un coéquipier de remplacement pour continuer le travail

455 461 

462{/* min-version: 2.1.198 */}À partir de la v2.1.198, un message du chef ou d'un autre coéquipier réveille un coéquipier in-process qui attend de réessayer une demande API échouée, il réessaie donc immédiatement au lieu d'attendre le délai de réessai complet.

463 

456<h3 id="lead-shuts-down-before-work-is-done">464<h3 id="lead-shuts-down-before-work-is-done">

457 Le chef s'arrête avant que le travail ne soit terminé465 Le chef s'arrête avant que le travail ne soit terminé

458</h3>466</h3>

481* **L'arrêt peut être lent** : les coéquipiers terminent leur demande actuelle ou appel d'outil avant de s'arrêter, ce qui peut prendre du temps.489* **L'arrêt peut être lent** : les coéquipiers terminent leur demande actuelle ou appel d'outil avant de s'arrêter, ce qui peut prendre du temps.

482* **Une équipe par session** : une session a exactement une équipe, limitée à cette session. Vous ne pouvez pas créer d'équipes nommées supplémentaires ou partager une équipe entre les sessions.490* **Une équipe par session** : une session a exactement une équipe, limitée à cette session. Vous ne pouvez pas créer d'équipes nommées supplémentaires ou partager une équipe entre les sessions.

483* **Pas d'équipes imbriquées** : les coéquipiers ne peuvent pas générer leurs propres coéquipiers. Seul le chef peut gérer l'équipe.491* **Pas d'équipes imbriquées** : les coéquipiers ne peuvent pas générer leurs propres coéquipiers. Seul le chef peut gérer l'équipe.

492* **Pas de sous-agents d'arrière-plan à partir de coéquipiers in-process** : les propres sous-agents d'un coéquipier in-process s'exécutent au premier plan. Demander un sous-agent d'arrière-plan, que ce soit avec `run_in_background` ou une définition de sous-agent qui définit `background: true`, retourne une erreur, car le travail d'arrière-plan d'un coéquipier ne peut pas survivre au processus du chef. Les sous-agents lancés à partir de la conversation principale suivent la [valeur par défaut d'arrière-plan](/fr/sub-agents#run-subagents-in-foreground-or-background).

484* **Le chef est fixe** : la session principale est le chef pour sa durée de vie. Vous ne pouvez pas promouvoir un coéquipier en chef ou transférer le leadership.493* **Le chef est fixe** : la session principale est le chef pour sa durée de vie. Vous ne pouvez pas promouvoir un coéquipier en chef ou transférer le leadership.

485* **Permissions définies au moment de la génération** : tous les coéquipiers commencent avec le mode de permission du chef. Vous pouvez modifier les modes de coéquipiers individuels après la génération, mais vous ne pouvez pas définir les modes par coéquipier au moment de la génération.494* **Permissions définies au moment de la génération** : tous les coéquipiers commencent avec le mode de permission du chef. Vous pouvez modifier les modes de coéquipiers individuels après la génération, mais vous ne pouvez pas définir les modes par coéquipier au moment de la génération.

486* **Les volets divisés nécessitent tmux ou iTerm2** : le mode in-process par défaut fonctionne dans n'importe quel terminal. Le mode volets divisés n'est pas supporté dans le terminal intégré de VS Code, Windows Terminal ou Ghostty.495* **Les volets divisés nécessitent tmux ou iTerm2** : le mode in-process par défaut fonctionne dans n'importe quel terminal. Le mode volets divisés n'est pas supporté dans le terminal intégré de VS Code, Windows Terminal ou Ghostty.

27* [Démarrage rapide](#quick-start) : donnez à Claude une tâche à accomplir en arrière-plan, vérifiez-la et intervenez quand c'est nécessaire27* [Démarrage rapide](#quick-start) : donnez à Claude une tâche à accomplir en arrière-plan, vérifiez-la et intervenez quand c'est nécessaire

28* [Surveiller les sessions avec la vue agent](#monitor-sessions-with-agent-view), y compris les icônes d'état, l'aperçu et la réponse, l'attachement, l'organisation et les raccourcis clavier28* [Surveiller les sessions avec la vue agent](#monitor-sessions-with-agent-view), y compris les icônes d'état, l'aperçu et la réponse, l'attachement, l'organisation et les raccourcis clavier

29* [Lancer de nouveaux agents](#dispatch-new-agents) à partir de la vue agent, depuis l'intérieur d'une session, ou depuis votre shell29* [Lancer de nouveaux agents](#dispatch-new-agents) à partir de la vue agent, depuis l'intérieur d'une session, ou depuis votre shell

30* [Gérer les sessions depuis le shell](#manage-sessions-from-the-shell)30* [Gérer les sessions depuis le shell](#manage-sessions-from-the-shell) avec `claude agents`, `claude attach` et les commandes associées

31* [Comment les sessions en arrière-plan sont hébergées](#how-background-sessions-are-hosted) par le processus superviseur31* [Comment les sessions en arrière-plan sont hébergées](#how-background-sessions-are-hosted) par le processus superviseur

32 32 

33<h2 id="quick-start">33<h2 id="quick-start">

64 </Step>64 </Step>

65 65 

66 <Step title="Amener une session existante">66 <Step title="Amener une session existante">

67 Pour déplacer une session que vous avez déjà ouverte dans la vue agent, exécutez `/bg` à l'intérieur, ou appuyez sur `←` sur une invite vide pour la mettre en arrière-plan et ouvrir la vue agent en une seule étape. La session continue de s'exécuter et apparaît sous forme de ligne aux côtés de celles que vous avez dispatchées.67 Cette étape nécessite une session en cours d'exécution. Si vous avez suivi les étapes précédentes, vous n'en avez pas ouverte dans ce terminal, ouvrez donc une session `claude` régulière dans un autre terminal et envoyez-lui d'abord un message. Pour déplacer une session que vous avez déjà ouverte dans la vue agent, exécutez `/bg` à l'intérieur, ou appuyez sur `←` sur une invite vide pour la mettre en arrière-plan et ouvrir la vue agent en une seule étape. La session continue de s'exécuter et apparaît sous forme de ligne aux côtés de celles que vous avez dispatchées.

68 </Step>68 </Step>

69</Steps>69</Steps>

70 70 

76 76 

77Exécutez `claude agents` pour ouvrir la vue agent. Elle prend le contrôle du terminal complet et répertorie chaque session groupée par état, avec les sessions épinglées et celles qui ont besoin de vous en haut. Chaque ligne affiche le nom de la session, l'activité actuelle, et depuis combien de temps elle a changé pour la dernière fois.77Exécutez `claude agents` pour ouvrir la vue agent. Elle prend le contrôle du terminal complet et répertorie chaque session groupée par état, avec les sessions épinglées et celles qui ont besoin de vous en haut. Chaque ligne affiche le nom de la session, l'activité actuelle, et depuis combien de temps elle a changé pour la dernière fois.

78 78 

79Le nom est teinté avec la couleur définie par [`/color`](/fr/commands) dans cette session. À partir de la v2.1.199, la couleur se transporte quand vous [mettez une session en arrière-plan](#from-inside-a-session) avec `←` ou `/background`.

80 

79Par défaut, la liste affiche chaque session en arrière-plan que vous avez démarrée, dans tous vos projets. Une session travaillant dans un référentiel et une autre dans une worktree différente apparaissent toutes les deux ici, quel que soit le répertoire à partir duquel vous avez ouvert la vue agent. Pour limiter la liste à un projet, passez `--cwd` :81Par défaut, la liste affiche chaque session en arrière-plan que vous avez démarrée, dans tous vos projets. Une session travaillant dans un référentiel et une autre dans une worktree différente apparaissent toutes les deux ici, quel que soit le répertoire à partir duquel vous avez ouvert la vue agent. Pour limiter la liste à un projet, passez `--cwd` :

80 82 

81```bash theme={null}83```bash theme={null}

91 ✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m93 ✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m

92 94 

93Prêtes pour examen95Prêtes pour examen

94 ∙ jump physics Opened PR with collision fix PR #2048 2h96 ∙ jump physics Opened PR with collision fix #2048 2h

95 97 

96Nécessite une intervention98Nécessite une intervention

97 ✻ power-up design needs input: double jump or wall climb? 1m99 ✻ power-up design needs input: double jump or wall climb? 1m

129| `∙` | Le processus a quitté. Vous pouvez toujours apercevoir, répondre, ou vous attacher, et Claude redémarre à partir de là où il s'était arrêté |131| `∙` | Le processus a quitté. Vous pouvez toujours apercevoir, répondre, ou vous attacher, et Claude redémarre à partir de là où il s'était arrêté |

130| `✢` | Une session [`/loop`](/fr/scheduled-tasks) dormant entre les itérations. La ligne affiche son nombre d'exécutions et un compte à rebours |132| `✢` | Une session [`/loop`](/fr/scheduled-tasks) dormant entre les itérations. La ligne affiche son nombre d'exécutions et un compte à rebours |

131 133 

132L'étiquette `PR #N` qui peut apparaître au bord droit d'une ligne est le [statut de la pull request que la session a ouvert](#pull-request-status), pas une partie de l'icône d'état. Quand une session a ouvert plus d'une pull request, l'étiquette affiche un nombre à la place, comme `3 PRs`.134L'étiquette `#N` qui peut apparaître au bord droit d'une ligne est la [pull request que la session a ouvert](#pull-request-status), pas une partie de l'icône d'état.

133 135 

134Le titre de l'onglet du terminal affiche le nombre d'entrées en attente pendant que la vue agent est ouverte : `2 awaiting input · claude agents` quand les sessions ont besoin d'une intervention, ou `claude agents` quand ce n'est pas le cas.136Le titre de l'onglet du terminal affiche le nombre d'entrées en attente pendant que la vue agent est ouverte : `2 awaiting input · claude agents` quand les sessions ont besoin d'une intervention, ou `claude agents` quand ce n'est pas le cas.

135 137 

138À partir de la v2.1.198, pendant que la vue agent est ouverte, Claude Code envoie également une notification via votre [canal de notification de terminal configuré](/fr/terminal-config#get-a-terminal-bell-or-notification) quand une session en arrière-plan local commence à avoir besoin de votre intervention, se termine, ou échoue. Les sessions qui s'exécutent selon un calendrier, comme les sessions [`/loop`](/fr/scheduled-tasks), ne notifient que quand elles ont besoin de votre intervention. Les notifications utilisent le même paramètre [`preferredNotifChannel`](/fr/settings#available-settings) que le reste de Claude Code et déclenchent le hook [`Notification`](/fr/hooks#notification) avec le type `agent_needs_input` ou `agent_completed`.

139 

136Les sessions en arrière-plan n'ont besoin d'aucun terminal ouvert pour continuer à fonctionner. Un [processus superviseur](#the-supervisor-process) séparé les exécute, vous pouvez donc fermer la vue agent, fermer votre shell, ou démarrer une nouvelle session interactive et votre travail lancé continue.140Les sessions en arrière-plan n'ont besoin d'aucun terminal ouvert pour continuer à fonctionner. Un [processus superviseur](#the-supervisor-process) séparé les exécute, vous pouvez donc fermer la vue agent, fermer votre shell, ou démarrer une nouvelle session interactive et votre travail lancé continue.

137 141 

138L'état de la session persiste sur le disque via les mises à jour automatiques et les redémarrages du superviseur. Les sessions sont également préservées quand votre machine se met en veille. Leurs processus reprennent au réveil et le superviseur se reconnecte à eux au lieu de traiter l'écart de temps comme inactif. L'arrêt arrête toujours les sessions en cours ; consultez [Les sessions s'affichent comme échouées après l'arrêt](#sessions-show-as-failed-after-shutdown) pour savoir comment les récupérer.142L'état de la session persiste sur le disque via les mises à jour automatiques et les redémarrages du superviseur. Les sessions sont également préservées quand votre machine se met en veille. Leurs processus reprennent au réveil et le superviseur se reconnecte à eux au lieu de traiter l'écart de temps comme inactif. L'arrêt arrête toujours les sessions en cours ; consultez [Les sessions s'affichent comme échouées après l'arrêt](#sessions-show-as-failed-after-shutdown) pour savoir comment les récupérer.

151 Statut de la pull request155 Statut de la pull request

152</h3>156</h3>

153 157 

154Quand une session ouvre une pull request, une étiquette `PR #1234` apparaît au bord droit de la ligne, liée à la pull request dans les terminaux qui supportent les hyperliens. L'étiquette persiste quand vous envoyez un suivi à la session, donc la pull request reste visible pendant que la ligne revient à la progression en direct.158Quand une session ouvre une pull request, une étiquette `#1234` apparaît au bord droit de la ligne, liée à la pull request dans les terminaux qui supportent les hyperliens. L'étiquette persiste quand vous envoyez un suivi à la session, donc la pull request reste visible pendant que la ligne revient à la progression en direct. Les sessions en arrière-plan qui ont isolé leurs modifications dans une worktree ouvrent elles-mêmes ces pull requests ; [Comment les modifications de fichiers sont isolées](#how-file-edits-are-isolated) couvre quand cela se produit et ce qu'une session ne fait jamais sans demander.

155 159 

156Quand une session a ouvert plus d'une pull request, l'étiquette affiche un nombre à la place, comme `3 PRs`, colorée par la pull request ouverte qui a le plus besoin d'attention. Ouvrez le [panneau d'aperçu](#peek-and-reply) pour les voir toutes.160Quand une session a ouvert plus d'une pull request, l'étiquette affiche un nombre à la place, comme `3 PRs`, colorée par la pull request ouverte qui a le plus besoin d'attention. Ouvrez le [panneau d'aperçu](#peek-and-reply) pour les voir toutes.

157 161 

190 194 

191Les sessions attachées s'affichent toujours en [mode plein écran](/fr/fullscreen), quel que soit votre paramètre `tui`, car une session en arrière-plan n'a pas d'historique de terminal à ajouter. Faites défiler avec `PgUp`, `PgDn`, ou la molette de la souris, et appuyez sur `Ctrl+O` pour le mode transcription. Le défilement natif de votre terminal et le mode copie tmux affichent uniquement la fenêtre d'affichage actuelle, comme lorsque vous exécutez n'importe quelle application plein écran.195Les sessions attachées s'affichent toujours en [mode plein écran](/fr/fullscreen), quel que soit votre paramètre `tui`, car une session en arrière-plan n'a pas d'historique de terminal à ajouter. Faites défiler avec `PgUp`, `PgDn`, ou la molette de la souris, et appuyez sur `Ctrl+O` pour le mode transcription. Le défilement natif de votre terminal et le mode copie tmux affichent uniquement la fenêtre d'affichage actuelle, comme lorsque vous exécutez n'importe quelle application plein écran.

192 196 

193Appuyez sur `←` sur une invite vide pour vous détacher et revenir à la vue agent. Si une boîte de dialogue a le focus et ne répond pas à `←`, appuyez sur `Ctrl+Z` pour vous détacher immédiatement.197À partir de la v2.1.198, appuyez sur `←` sur une invite vide, ou exécutez `/exit`, pour vous détacher et revenir à la vue agent. À partir de la v2.1.198, cela fonctionne de la même manière que vous ayez ouvert la session à partir de la vue agent ou avec `claude attach <id>` à partir de votre shell.

198 

199`Ctrl+Z` se détache également mais revient à l'endroit où vous avez commencé à la place : la vue agent si vous vous êtes attaché à partir de là, ou votre shell si vous avez exécuté `claude attach`. Utilisez `Ctrl+Z` quand une boîte de dialogue a le focus et ne répond pas à `←`.

194 200 

195`Ctrl+C` conserve son comportement d'interruption standard pendant que vous êtes attaché : il annule une réponse en cours d'exécution ou une commande shell `!` plutôt que de vous détacher. Appuyer sur `Ctrl+C` deux fois sur une invite vide vous détache, comme dans n'importe quelle session.201`Ctrl+C` conserve son comportement d'interruption standard pendant que vous êtes attaché : il annule une réponse en cours d'exécution ou une commande shell `!` plutôt que de vous détacher. Appuyer sur `Ctrl+C` deux fois sur une invite vide vous détache, comme dans n'importe quelle session.

196 202 

289| `#<number>` ou une URL de pull request | Si une session travaille déjà sur cette PR, sélectionnez-la au lieu de lancer |295| `#<number>` ou une URL de pull request | Si une session travaille déjà sur cette PR, sélectionnez-la au lieu de lancer |

290| `Shift+Entrée` | Lancer et s'attacher immédiatement à la nouvelle session |296| `Shift+Entrée` | Lancer et s'attacher immédiatement à la nouvelle session |

291 297 

292Un petit ensemble de commandes s'exécutent dans la vue agent elle-même au lieu de lancer : `/exit` et `/quit` ferment la vue agent, `/logout` vous déconnecte, et `/model` définit le [modèle de lancement](#set-the-model). Les skills, vos propres commandes, et les built-ins qui développent les invites comme `/init` sont envoyés à une nouvelle session en arrière-plan comme leur première invite. Les autres commandes built-in affichent plutôt un indice `attach to a session to run it`.298Un petit ensemble de commandes s'exécutent dans la vue agent elle-même au lieu de lancer :

299 

300* `/exit` et `/quit` ferment la vue agent

301* `/logout` vous déconnecte

302* `/model` définit le [modèle de lancement](#set-the-model)

303* {/* min-version: 2.1.198 */}À partir de la v2.1.198, `/login` ouvre la boîte de dialogue de connexion pour que vous puissiez vous connecter à nouveau sans vous attacher à une session

304 

305Les skills, vos propres commandes, et les built-ins qui développent les invites comme `/init` sont envoyés à une nouvelle session en arrière-plan comme leur première invite. Les autres commandes built-in affichent plutôt un indice `attach to a session to run it`.

293 306 

294Empaqueter une tâche récurrente comme un [skill](/fr/skills) vous permet de démarrer le même workflow à partir de la vue agent à plusieurs reprises sans retaper l'invite.307Empaqueter une tâche récurrente comme un [skill](/fr/skills) vous permet de démarrer le même workflow à partir de la vue agent à plusieurs reprises sans retaper l'invite.

295 308 

313 326 

314Exécutez `/background` ou son alias `/bg` pour déplacer la conversation actuelle dans une session en arrière-plan. Passez une invite comme `/bg run the test suite and fix any failures` pour donner une instruction supplémentaire d'abord. Si Claude répond quand vous exécutez `/bg`, la réponse continue dans la session en arrière-plan.327Exécutez `/background` ou son alias `/bg` pour déplacer la conversation actuelle dans une session en arrière-plan. Passez une invite comme `/bg run the test suite and fix any failures` pour donner une instruction supplémentaire d'abord. Si Claude répond quand vous exécutez `/bg`, la réponse continue dans la session en arrière-plan.

315 328 

329Quitter une session interactive qui a encore du travail en arrière-plan en cours d'exécution, comme des sous-agents, des commandes shell en arrière-plan, des workflows, ou des [monitors](/fr/tools-reference#monitor-tool), affiche une boîte de dialogue `Background work is running` au lieu de quitter immédiatement. {/* min-version: 2.1.198 */}À partir de la v2.1.198, la boîte de dialogue propose `Move to background and exit` aux côtés de `Exit anyway` et `Stay`. La choisir déplace la session en arrière-plan de la même manière que `/background` le fait, puis vous ramène à votre shell, donc le travail qui peut se poursuivre continue de s'exécuter et la session apparaît dans la vue agent. L'option n'est pas affichée quand la vue agent est [désactivée](#turn-off-agent-view).

330 

316Mettre en arrière-plan à partir d'une session interactive démarre un processus nouveau qui reprend à partir de la conversation enregistrée, et le travail en cours se transfère à celui-ci : les commandes shell en arrière-plan en cours d'exécution, les sous-agents mis en arrière-plan, les workflows dynamiques, et les tâches planifiées que vous avez créées avec [`/loop`](/fr/scheduled-tasks) se transfèrent à la session en arrière-plan et continuent de s'exécuter là. Un sous-agent se déplace avec tout ce qu'il a démarré, donc il se transfère uniquement quand tout ce travail peut se transférer aussi, y compris sur Windows. Pour arrêter le travail en cours au lieu de le transférer, définissez la variable d'environnement [`CLAUDE_DISABLE_ADOPT=1`](/fr/env-vars#variables) ; Claude Code vous demande alors de confirmer avant de mettre en arrière-plan.331Mettre en arrière-plan à partir d'une session interactive démarre un processus nouveau qui reprend à partir de la conversation enregistrée, et le travail en cours se transfère à celui-ci : les commandes shell en arrière-plan en cours d'exécution, les sous-agents mis en arrière-plan, les workflows dynamiques, et les tâches planifiées que vous avez créées avec [`/loop`](/fr/scheduled-tasks) se transfèrent à la session en arrière-plan et continuent de s'exécuter là. Un sous-agent se déplace avec tout ce qu'il a démarré, donc il se transfère uniquement quand tout ce travail peut se transférer aussi, y compris sur Windows. Pour arrêter le travail en cours au lieu de le transférer, définissez la variable d'environnement [`CLAUDE_DISABLE_ADOPT=1`](/fr/env-vars#variables) ; Claude Code vous demande alors de confirmer avant de mettre en arrière-plan.

317 332 

318Le travail qui ne peut pas se transférer, comme un [monitor](/fr/tools-reference#monitor-tool) en cours d'exécution, est arrêté. Un sous-agent mis en arrière-plan qui possède un monitor est arrêté avec lui. Quand un tel travail s'exécute, Claude Code affiche une boîte de dialogue `Background this session?` pour que vous puissiez confirmer avant qu'il soit arrêté.333Le travail qui ne peut pas se transférer, comme un [monitor](/fr/tools-reference#monitor-tool) en cours d'exécution, est arrêté. Un sous-agent mis en arrière-plan qui possède un monitor est arrêté avec lui. Quand un tel travail s'exécute, Claude Code affiche une boîte de dialogue `Background this session?` pour que vous puissiez confirmer avant qu'il soit arrêté.

342claude --bg "investigate the flaky SettingsChangeDetector test"357claude --bg "investigate the flaky SettingsChangeDetector test"

343```358```

344 359 

360L'invite est l'argument positionnel, pas une valeur `-p`. {/* min-version: 2.1.198 */}À partir de la v2.1.198, combiner `--bg` avec `-p` ou `--print` est rejeté avec une erreur avant que toute session soit créée, car `--print` ne démarre jamais la session interactive à laquelle `claude agents` s'attache.

361 

345Pour exécuter un sous-agent spécifique comme l'agent principal de la session, combinez `--bg` avec `--agent` :362Pour exécuter un sous-agent spécifique comme l'agent principal de la session, combinez `--bg` avec `--agent` :

346 363 

347```bash theme={null}364```bash theme={null}

414 431 

415Un [sous-agent](/fr/sub-agents) que la session en arrière-plan lance hérite du répertoire de travail de la session, donc ses modifications de fichiers se retrouvent dans la worktree de la session plutôt que dans votre copie de travail. Pour donner à un sous-agent sa propre worktree séparée à la place, définissez [`isolation: worktree`](/fr/sub-agents#supported-frontmatter-fields) dans son frontmatter ou passez `isolation: "worktree"` lors de son lancement.432Un [sous-agent](/fr/sub-agents) que la session en arrière-plan lance hérite du répertoire de travail de la session, donc ses modifications de fichiers se retrouvent dans la worktree de la session plutôt que dans votre copie de travail. Pour donner à un sous-agent sa propre worktree séparée à la place, définissez [`isolation: worktree`](/fr/sub-agents#supported-frontmatter-fields) dans son frontmatter ou passez `isolation: "worktree"` lors de son lancement.

416 433 

434À partir de la v2.1.198, une session en arrière-plan qui a isolé ses modifications de code dans une worktree valide également, pousse sa propre branche, et ouvre une demande de tirage en brouillon sans s'arrêter pour demander. L'étiquette [`#N`](#pull-request-status) apparaît sur sa ligne quand la demande de tirage s'ouvre. Elle ne pousse jamais vers `main` ou `master`, ne force jamais les poussées ou les fusions, et elle ignore la demande de tirage quand vous lui avez dit de ne pas en ouvrir une ou que le référentiel n'a pas de remote.

435 

436Une session modifiant un checkout qu'elle n'a pas isolée elle-même demande toujours avant de valider ou de changer de branche. Cela s'applique quand l'isolation est définie sur `"none"`, quand le déplacement de la worktree a échoué, ou quand la session a démarré à l'intérieur d'une worktree qui existait déjà.

437 

417<h3 id="set-the-model">438<h3 id="set-the-model">

418 Définir le modèle439 Définir le modèle

419</h3>440</h3>

529 550 

530Une fois qu'une session se termine et reste non attachée pendant environ une heure, le superviseur arrête son processus pour libérer des ressources. Une session que vous avez [épinglée](#organize-the-list) avec `Ctrl+T` est exemptée et garde son processus en cours d'exécution pendant qu'elle est inactive. La transcription et l'état restent sur le disque de toute façon, et la prochaine fois que vous vous attachez, apercevez, ou répondez à une session arrêtée, le superviseur démarre un processus frais à partir de là où il s'était arrêté. Quand chaque session s'est terminée et qu'aucun terminal n'est connecté, le superviseur lui-même quitte et redémarre la prochaine fois que vous en avez besoin.551Une fois qu'une session se termine et reste non attachée pendant environ une heure, le superviseur arrête son processus pour libérer des ressources. Une session que vous avez [épinglée](#organize-the-list) avec `Ctrl+T` est exemptée et garde son processus en cours d'exécution pendant qu'elle est inactive. La transcription et l'état restent sur le disque de toute façon, et la prochaine fois que vous vous attachez, apercevez, ou répondez à une session arrêtée, le superviseur démarre un processus frais à partir de là où il s'était arrêté. Quand chaque session s'est terminée et qu'aucun terminal n'est connecté, le superviseur lui-même quitte et redémarre la prochaine fois que vous en avez besoin.

531 552 

532Les commandes shell en arrière-plan et les workflows dynamiques que la session a démarrés continuent de s'exécuter quand son processus est arrêté, redémarré ou mis à jour, y compris sur Windows. Le processus suivant démarré pour cette session les reprend, une commande shell qui s'est terminée entre-temps est signalée comme terminée avec sa sortie, et un workflow reprend à partir de là où il s'était arrêté. Les commandes shell démarrées par un sous-agent et les [monitors](/fr/tools-reference#monitor-tool) en cours d'exécution s'arrêtent toujours avec le processus, et supprimer la session arrête tout ce qu'elle a confié. Pour arrêter les commandes shell en arrière-plan et les workflows avec le processus aussi, définissez la variable d'environnement [`CLAUDE_CODE_DISABLE_BG_EXIT_HANDOFF`](/fr/env-vars#variables) à `1`.553Le travail en arrière-plan que la session elle-même a démarré au niveau supérieur est confié quand son processus est arrêté, redémarré ou mis à jour, y compris sur Windows. Le processus suivant démarré pour cette session reprend le travail :

554 

555* Une commande shell en arrière-plan qui s'est terminée entre-temps est signalée comme terminée avec sa sortie

556* Un workflow dynamique reprend à partir de là où il s'était arrêté

557* Un [sous-agent en arrière-plan](/fr/sub-agents#run-subagents-in-foreground-or-background) reprend à partir de sa propre transcription

558 

559{/* min-version: 2.1.198 */}À partir de v2.1.198, la remise couvre tous les trois. Avant v2.1.198, elle couvrait uniquement les commandes shell et les workflows, donc un sous-agent en arrière-plan s'arrêtait avec le processus et était signalé comme échoué au prochain réveil.

560 

561Le travail dont l'état vit uniquement à l'intérieur du processus lui-même s'arrête avec lui au lieu d'être confié. C'est les commandes shell qu'un sous-agent a démarrées, que le sous-agent repris peut redémarrer, et les [monitors](/fr/tools-reference#monitor-tool) en cours d'exécution, dont le flux d'événements ne peut pas être déplacé vers un autre processus.

562 

563Supprimer la session arrête tout ce qu'elle a confié. Pour arrêter tout le travail en arrière-plan de la session avec le processus au lieu de le confier, définissez la variable d'environnement [`CLAUDE_CODE_DISABLE_BG_EXIT_HANDOFF`](/fr/env-vars#variables) à `1`.

533 564 

534Si une session redémarrée revient en affichant uniquement son invite d'origine parce que Claude Code a mal lu sa transcription comme vide, la transcription de conversation est renommée avec un suffixe `.orphaned-` au lieu d'être supprimée, donc elle reste sur votre machine.565Si une session redémarrée revient en affichant uniquement son invite d'origine parce que Claude Code a mal lu sa transcription comme vide, la transcription de conversation est renommée avec un suffixe `.orphaned-` au lieu d'être supprimée, donc elle reste sur votre machine.

535 566 

606 637 

607La mise en veille seule ne cause pas cela. Les sessions sont préservées lors de la mise en veille et le superviseur se reconnecte à elles au réveil.638La mise en veille seule ne cause pas cela. Les sessions sont préservées lors de la mise en veille et le superviseur se reconnecte à elles au réveil.

608 639 

640<h3 id="a-session-fails-before-starting-with-a-possibly-low-memory-note">

641 Une session échoue avant de démarrer avec une note « possibly low memory »

642</h3>

643 

644À partir de la v2.1.199, quand le processus d'une session en arrière-plan se termine avant de finir de démarrer et que l'hôte manque de mémoire, le statut de la ligne nomme la sortie et ajoute `possibly low memory — free some up and retry`. Les versions antérieures affichaient uniquement la raison de sortie brute pour cet échec.

645 

646La note est une hypothèse, pas une cause confirmée. Claude Code l'ajoute uniquement quand le processus s'est terminé silencieusement, sans écrire d'erreur et sans être arrêté par un signal, et que l'hôte a signalé une mémoire faible à ce moment. Quand le processus a écrit une erreur avant de se terminer, la ligne affiche cette erreur à la place.

647 

648Libérez de la mémoire sur la machine, puis attachez-vous, apercevez, ou répondez à la ligne et le superviseur démarre un processus frais pour la session. Quand la mémoire reste faible, le superviseur [arrête également les sessions inactives](#the-supervisor-process) pour libérer des ressources de lui-même.

649 

609<h3 id="agent-view-says-the-background-service-did-not-respond">650<h3 id="agent-view-says-the-background-service-did-not-respond">

610 La vue agent indique que le service en arrière-plan n'a pas répondu651 La vue agent indique que le service en arrière-plan n'a pas répondu

611</h3>652</h3>

636 677 

637Voir la [référence d'erreur](/fr/errors#could-not-resolve-authentication-method) pour la liste complète des causes et des correctifs.678Voir la [référence d'erreur](/fr/errors#could-not-resolve-authentication-method) pour la liste complète des causes et des correctifs.

638 679 

639<h3 id="background-sessions-cannot-read-desktop-documents-or-downloads-on-macos">680<h3 id="background-sessions-can’t-read-desktop-documents-or-downloads-on-macos">

640 Les sessions en arrière-plan ne peuvent pas lire Desktop, Documents ou Downloads sur macOS681 Les sessions en arrière-plan ne peuvent pas lire Desktop, Documents ou Downloads sur macOS

641</h3>682</h3>

642 683 

644 685 

645Avec l'installateur natif, l'entrée apparaît comme Claude Code et l'autorisation persiste lors des mises à jour. Avec d'autres méthodes d'installation comme Homebrew ou npm, l'entrée affiche le chemin du binaire et peut avoir besoin d'être accordée à nouveau après la mise à jour.686Avec l'installateur natif, l'entrée apparaît comme Claude Code et l'autorisation persiste lors des mises à jour. Avec d'autres méthodes d'installation comme Homebrew ou npm, l'entrée affiche le chemin du binaire et peut avoir besoin d'être accordée à nouveau après la mise à jour.

646 687 

688<h3 id="background-sessions-can’t-reach-local-network-hosts-on-macos">

689 Les sessions en arrière-plan ne peuvent pas atteindre les hôtes du réseau local sur macOS

690</h3>

691 

692Sur macOS 15 et versions ultérieures, le système bloque un processus d'atteindre les appareils sur votre réseau local jusqu'à ce que vous accordiez la permission Réseau local. Avant la v2.1.198, l'hôte de session en arrière-plan n'a jamais demandé cette permission, donc les commandes ciblant une adresse LAN échouaient avec `connect: no route to host` même si la même commande fonctionnait dans un terminal de premier plan. {/* min-version: 2.1.198 */}À partir de la v2.1.198, la première commande dans une session en arrière-plan qui se connecte à une adresse de réseau local déclenche l'invite de permission Réseau local de macOS pour Claude Code. Accordez-la une fois et ces commandes atteindront les hôtes LAN de la même manière qu'ils le font dans un terminal de premier plan.

693 

647<h3 id="a-session-is-slow-to-respond-after-attaching">694<h3 id="a-session-is-slow-to-respond-after-attaching">

648 Une session est lente à répondre après l'attachement695 Une session est lente à répondre après l'attachement

649</h3>696</h3>

683La vue agent a évolué rapidement pendant l'aperçu de recherche. Si vous êtes sur une version plus ancienne de Claude Code, certains comportements sur cette page peuvent différer ; en particulier, `claude agents` rejette les drapeaux qu'il ne supporte pas encore avec une erreur `unknown option`. Le tableau ci-dessous répertorie quand chaque drapeau et comportement a été ajouté.730La vue agent a évolué rapidement pendant l'aperçu de recherche. Si vous êtes sur une version plus ancienne de Claude Code, certains comportements sur cette page peuvent différer ; en particulier, `claude agents` rejette les drapeaux qu'il ne supporte pas encore avec une erreur `unknown option`. Le tableau ci-dessous répertorie quand chaque drapeau et comportement a été ajouté.

684 731 

685| Version | Changement |732| Version | Changement |

686| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |733| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

734| v2.1.199 | {/* min-version: 2.1.199 */}Une session en arrière-plan dont le processus se termine avant de finir de démarrer sur un hôte à faible mémoire affiche `possibly low memory — free some up and retry` dans le statut de sa ligne au lieu de seulement la raison de sortie brute. Mettre en arrière-plan une session avec `←` ou `/background` transfère son `/color` vers la nouvelle ligne. |

735| v2.1.198 | {/* min-version: 2.1.198 */}La vue agent envoie une notification via `preferredNotifChannel` quand une session en arrière-plan a besoin d'une entrée, se termine ou échoue, et déclenche le hook `Notification` avec le type `agent_needs_input` ou `agent_completed`. `←` et `/exit` à l'intérieur de `claude attach <id>` reviennent à la vue agent au lieu de quitter vers le shell ; `Ctrl+Z` revient au shell. Une session en arrière-plan qui a isolé son travail dans un worktree valide, pousse sa propre branche isolée, jamais `main` ou `master`, et ouvre une demande de tirage en brouillon quand elle se termine au lieu de demander d'abord. `/login` s'exécute dans la vue agent et ouvre la boîte de dialogue de connexion. La boîte de dialogue de sortie `Background work is running` propose `Move to background and exit`. Le transfert de sortie couvre également les sous-agents en arrière-plan, qui reprennent à partir de leur transcription à la prochaine activation au lieu d'être signalés comme échoués. `claude --bg` combiné avec `-p` ou `--print` est rejeté avec une erreur. |

687| v2.1.196 | {/* min-version: 2.1.196 */}Une seule pression sur `←` met en arrière-plan une session au premier plan ; les versions antérieures nécessitaient deux pressions, avec un indice de pied de page et une confirmation. `--dangerously-skip-permissions` passé à `claude agents` affiche la clause de non-responsabilité du contournement au lieu d'être silencieusement supprimé. Les sessions interactives que vous n'avez jamais nommées portent un nom par défaut comme `my-app-3f` dans les listes de sessions et `claude agents --json`. Les commandes shell en arrière-plan et les workflows dynamiques survivent à l'arrêt, au redémarrage ou à la mise à jour du processus de la session, y compris sur Windows ; définissez `CLAUDE_CODE_DISABLE_BG_EXIT_HANDOFF=1` pour désactiver le transfert. Une transcription mal lue comme vide au redémarrage est renommée avec un suffixe `.orphaned-` au lieu d'être supprimée. |736| v2.1.196 | {/* min-version: 2.1.196 */}Une seule pression sur `←` met en arrière-plan une session au premier plan ; les versions antérieures nécessitaient deux pressions, avec un indice de pied de page et une confirmation. `--dangerously-skip-permissions` passé à `claude agents` affiche la clause de non-responsabilité du contournement au lieu d'être silencieusement supprimé. Les sessions interactives que vous n'avez jamais nommées portent un nom par défaut comme `my-app-3f` dans les listes de sessions et `claude agents --json`. Les commandes shell en arrière-plan et les workflows dynamiques survivent à l'arrêt, au redémarrage ou à la mise à jour du processus de la session, y compris sur Windows ; définissez `CLAUDE_CODE_DISABLE_BG_EXIT_HANDOFF=1` pour désactiver le transfert. Une transcription mal lue comme vide au redémarrage est renommée avec un suffixe `.orphaned-` au lieu d'être supprimée. |

688| v2.1.195 | {/* min-version: 2.1.195 */}Le travail en cours se transfère aussi quand vous mettez en arrière-plan une session sur Windows ; définissez `CLAUDE_DISABLE_ADOPT=1` pour l'arrêter à la place. Le groupe `Completed` remplit l'espace vertical restant et l'en-tête se compacte sur les terminaux courts. Une version plus ancienne de Claude Code ne supprime plus les champs `state.json` plus récents des sessions ou ne cache plus ces sessions de `claude agents`. S'attacher à une session arrêtée bascule immédiatement au lieu d'afficher un écran vide pendant jusqu'à cinq secondes. Un superviseur qui ne peut pas accepter les connexions quitte et libère son verrou de lui-même. |737| v2.1.195 | {/* min-version: 2.1.195 */}Le travail en cours se transfère aussi quand vous mettez en arrière-plan une session sur Windows ; définissez `CLAUDE_DISABLE_ADOPT=1` pour l'arrêter à la place. Le groupe `Completed` remplit l'espace vertical restant et l'en-tête se compacte sur les terminaux courts. Une version plus ancienne de Claude Code ne supprime plus les champs `state.json` plus récents des sessions ou ne cache plus ces sessions de `claude agents`. S'attacher à une session arrêtée bascule immédiatement au lieu d'afficher un écran vide pendant jusqu'à cinq secondes. Un superviseur qui ne peut pas accepter les connexions quitte et libère son verrou de lui-même. |

689| v2.1.174 | {/* min-version: 2.1.174 */}Les sessions en arrière-plan n'héritent plus des variables de point de terminaison de passerelle comme `ANTHROPIC_BASE_URL` du shell de lancement du superviseur ; le superviseur fournit un nouvel instantané d'identifiants aux workers préchauffés, corrigeant les erreurs `Could not resolve authentication method` spurieuses. |738| v2.1.174 | {/* min-version: 2.1.174 */}Les sessions en arrière-plan n'héritent plus des variables de point de terminaison de passerelle comme `ANTHROPIC_BASE_URL` du shell de lancement du superviseur ; le superviseur fournit un nouvel instantané d'identifiants aux workers préchauffés, corrigeant les erreurs `Could not resolve authentication method` spurieuses. |

53La commande pour vérifier le travail en cours dépend de l'approche que vous avez utilisée :53La commande pour vérifier le travail en cours dépend de l'approche que vous avez utilisée :

54 54 

55* Pour les sessions en arrière-plan, `claude agents` ouvre [la vue agent](/fr/agent-view) : un écran montrant chaque session, son état et lesquelles ont besoin de votre entrée.55* Pour les sessions en arrière-plan, `claude agents` ouvre [la vue agent](/fr/agent-view) : un écran montrant chaque session, son état et lesquelles ont besoin de votre entrée.

56* Pour les sous-agents dans la session actuelle, `/agents` ouvre un panneau avec un onglet **Running** listant les sous-agents actifs et un onglet **Library** où vous [créez et modifiez des sous-agents personnalisés](/fr/sub-agents#use-the-%2Fagents-command). Malgré le nom similaire, c'est séparé de `claude agents`.56* Pour les sous-agents dans la session actuelle, les sous-agents nommés en arrière-plan apparaissent dans la saisie semi-automatique @-mention avec leur statut. {/* min-version: 2.1.198 */}À partir de la v2.1.198, `/agents` n'ouvre plus un panneau ; il affiche un avis pointant vers les emplacements des fichiers de sous-agents. Pour [créer et modifier des sous-agents personnalisés](/fr/sub-agents#configure-subagents), demandez à Claude ou modifiez les fichiers directement. Malgré le nom similaire, `/agents` est séparé de `claude agents`.

57* Pour tout ce qui s'exécute en arrière-plan de la session actuelle, `/tasks` liste chaque élément et vous permet de le vérifier, de vous y attacher ou de l'arrêter.57* Pour tout ce qui s'exécute en arrière-plan de la session actuelle, `/tasks` liste chaque élément et vous permet de le vérifier, de vous y attacher ou de l'arrêter.

58* Pour les workflows dynamiques, `/workflows` liste les exécutions en cours et terminées, la phase dans laquelle chacune se trouve et le nombre d'agents qui ont terminé.58* Pour les workflows dynamiques, `/workflows` liste les exécutions en cours et terminées, la phase dans laquelle chacune se trouve et le nombre d'agents qui ont terminé.

59 59 

184 184 

185Ces deux paramètres ont des conditions de déclenchement différentes :185Ces deux paramètres ont des conditions de déclenchement différentes :

186 186 

187* **`awsAuthRefresh`** : s'exécute uniquement lorsque Claude Code détecte que vos identifiants AWS ont expiré, soit localement en fonction de leur horodatage, soit lorsque Bedrock retourne une erreur d'identifiants, puis réessaye la demande avec des identifiants actualisés.187* **`awsAuthRefresh`** : s'exécute uniquement lorsque Claude Code détecte que vos identifiants AWS ont expiré, soit localement en fonction de leur horodatage, soit lorsque l'API retourne une erreur d'identifiants, puis réessaye la demande avec des identifiants actualisés.

188* **`awsCredentialExport`** : s'exécute au démarrage de la session et à chaque rechargement des identifiants, même lorsque les identifiants de votre chaîne de fournisseurs d'identifiants AWS par défaut sont toujours valides. Utilisez ceci lorsque votre compte Bedrock nécessite des identifiants inter-comptes qui diffèrent de ceux que la chaîne de fournisseurs par défaut résoudrait.188* **`awsCredentialExport`** : s'exécute au démarrage de la session et à chaque rechargement des identifiants, même lorsque les identifiants de votre chaîne de fournisseurs d'identifiants AWS par défaut sont toujours valides. Utilisez ceci lorsque votre compte Bedrock nécessite des identifiants inter-comptes qui diffèrent de ceux que la chaîne de fournisseurs par défaut résoudrait.

189 189 

190<h5 id="example-configuration">190<h5 id="example-configuration">

54 54 

55Pour la plupart des organisations, `autoMode.environment` est le seul champ que vous devez définir. Il indique au classificateur quels dépôts, buckets et domaines sont approuvés : le classificateur l'utilise pour décider ce que signifie « externe », donc toute destination non listée est une cible d'exfiltration potentielle.55Pour la plupart des organisations, `autoMode.environment` est le seul champ que vous devez définir. Il indique au classificateur quels dépôts, buckets et domaines sont approuvés : le classificateur l'utilise pour décider ce que signifie « externe », donc toute destination non listée est une cible d'exfiltration potentielle.

56 56 

57À partir de Claude Code v2.1.195, `claude auto-mode defaults` imprime deux types d'entrées d'environnement.57À partir de Claude Code v2.1.198, `claude auto-mode defaults` imprime trois types d'entrées d'environnement. Les versions antérieures à v2.1.195 impriment uniquement les cinq premiers emplacements de confiance.

58 58 

59* **Emplacements de contexte** : décrivent votre organisation, votre pile technologique et votre posture de sécurité afin que le classificateur lise les autres règles dans votre contexte. Contrairement aux deux autres types, les emplacements de contexte n'ont pas de règles propres qui les ciblent. Chacun est par défaut `Aucun configuré` ou à l'hypothèse conservatrice nommée à côté :

60 * **Organisation**

61 * **Utilisation principale de Claude Code** : par défaut développement logiciel

62 * **Fournisseur(s) cloud**

63 * **Visibilité du dépôt** : un dépôt est supposé privé sauf si son hôte distant et son nom l'indiquent autrement

64 * **Partage interne / hébergement d'extraits** : les services publics de paste et gist sont traités comme en dehors de la limite de confiance jusqu'à ce que vous en nomiez un

65 * **CLI spécifiques à l'organisation**

66 * **Gestion des secrets**

67 * **Branches par défaut / protégées** : `main` et `master` sont traités comme protégés jusqu'à ce que vous en nomiez d'autres

68 * **Cibles de déploiement CI/CD**

69 * **Posture réseau**

70 * **Espaces de noms / environnements de déploiement protégés** : revient à l'heuristique des cibles distantes sensibles jusqu'à ce que vous les nomiez

71 * **Rétention des données / déclassification**

59* **Emplacements de confiance** : nomment ce que le classificateur traite comme à l'intérieur de votre limite. Les emplacements sont Dépôt approuvé, Contrôle de source, Domaines internes approuvés, Buckets cloud approuvés, Services internes clés et Registre de packages interne. Les entrées de dépôt et de contrôle de source sont par défaut le dépôt de travail et ses remotes configurées. Tous les autres emplacements de confiance sont par défaut `Aucun configuré`, donc rien d'autre n'est approuvé jusqu'à ce que vous l'ajoutiez.72* **Emplacements de confiance** : nomment ce que le classificateur traite comme à l'intérieur de votre limite. Les emplacements sont Dépôt approuvé, Contrôle de source, Domaines internes approuvés, Buckets cloud approuvés, Services internes clés et Registre de packages interne. Les entrées de dépôt et de contrôle de source sont par défaut le dépôt de travail et ses remotes configurées. Tous les autres emplacements de confiance sont par défaut `Aucun configuré`, donc rien d'autre n'est approuvé jusqu'à ce que vous l'ajoutiez.

60* **Emplacements de sensibilité** : nomment ce que les règles de protection traitent comme à haut risque. Les emplacements sont Emplacements de données PII / réglementées, Cibles distantes sensibles et Portées IaC protégées. Chacun est par défaut une heuristique large, comme traiter tout hôte ou espace de noms dont le nom porte `prod` ou `production` comme une cible distante sensible, donc les règles de protection sont actives avant que vous configuriez quoi que ce soit. Nommer des cibles concrètes dans un emplacement de sensibilité fait que ces règles s'appliquent aux cibles nommées au lieu de l'heuristique.73* **Emplacements de sensibilité** : nomment ce que les règles de protection traitent comme à haut risque. Les emplacements sont Emplacements de données sensibles et audiences, Cibles distantes sensibles et Portées IaC protégées. Chacun est par défaut une heuristique large, comme traiter tout hôte ou espace de noms dont le nom porte `prod` ou `production` comme une cible distante sensible, donc les règles de protection sont actives avant que vous configuriez quoi que ce soit. Nommer des cibles concrètes dans un emplacement de sensibilité fait que ces règles s'appliquent aux cibles nommées au lieu de l'heuristique.

61 

62Les versions antérieures à v2.1.195 impriment uniquement les cinq premiers emplacements de confiance.

63 74 

64Pour ajouter vos propres entrées aux côtés des valeurs par défaut, incluez la chaîne littérale `"$defaults"` dans le tableau. Les entrées par défaut sont insérées à cette position, donc vos entrées personnalisées peuvent aller avant ou après elles.75Pour ajouter vos propres entrées aux côtés des valeurs par défaut, incluez la chaîne littérale `"$defaults"` dans le tableau. Les entrées par défaut sont insérées à cette position, donc vos entrées personnalisées peuvent aller avant ou après elles.

65 76 

87* **Domaines internes approuvés** : noms d'hôtes pour les API, tableaux de bord et services à l'intérieur de votre réseau, comme `*.internal.example.com`98* **Domaines internes approuvés** : noms d'hôtes pour les API, tableaux de bord et services à l'intérieur de votre réseau, comme `*.internal.example.com`

88* **Services internes clés** : CI, registres d'artefacts, index de packages internes, outils d'incident99* **Services internes clés** : CI, registres d'artefacts, index de packages internes, outils d'incident

89* **Registre de packages interne** : le registre npm, PyPI ou autre privé par lequel les installations doivent être acheminées, donc les installations qui le contournent pour un registre public sont bloquées100* **Registre de packages interne** : le registre npm, PyPI ou autre privé par lequel les installations doivent être acheminées, donc les installations qui le contournent pour un registre public sont bloquées

90* **Emplacements de données PII / réglementées** : les buckets, bases de données ou chemins qui contiennent des données personnelles ou réglementées, afin que le classificateur protège ces emplacements au lieu de deviner à partir du contenu101* **Emplacements de données sensibles et audiences** : les buckets, bases de données ou chemins qui contiennent des données personnelles, des données commerciales confidentielles, des identifiants, des données réglementées ou du matériel similaire sensible, et les audiences avec lesquelles les données de chaque emplacement peuvent être partagées, afin que le classificateur protège ces emplacements au lieu de deviner à partir du contenu. {/* min-version: 2.1.195 */}{/* max-version: 2.1.197 */}Claude Code v2.1.195 à v2.1.197 nomme cette entrée Emplacements de données PII / réglementées et couvre uniquement les emplacements qui contiennent des données personnelles ou réglementées, sans la dimension d'audience

91* **Cibles distantes sensibles** : les espaces de noms, hôtes ou conteneurs qui comptent comme production, donc les shells distants et les redirections de ports vers eux ont besoin de votre approbation explicite102* **Cibles distantes sensibles** : les espaces de noms, hôtes ou conteneurs qui comptent comme production, donc les shells distants et les redirections de ports vers eux ont besoin de votre approbation explicite

92* **Portées IaC protégées** : les ressources d'infrastructure dont l'application ou la destruction doivent toujours vous demander de nommer le changement103* **Portées IaC protégées** : les ressources d'infrastructure dont l'application ou la destruction doivent toujours vous demander de nommer le changement

93* **Contexte supplémentaire** : contraintes d'industrie réglementée, infrastructure multi-locataire ou exigences de conformité qui affectent ce que le classificateur devrait traiter comme risqué104* **Contexte supplémentaire** : contraintes d'industrie réglementée, infrastructure multi-locataire ou exigences de conformité qui affectent ce que le classificateur devrait traiter comme risqué

94 105 

95Les entrées Registre de packages interne, Emplacements de données PII / réglementées, Cibles distantes sensibles et Portées IaC protégées nécessitent Claude Code v2.1.195 ou ultérieur. Les versions antérieures les lisent toujours comme du contexte simple mais n'ont pas les règles intégrées qui les ciblent.106Les entrées Registre de packages interne, Emplacements de données sensibles et audiences, Cibles distantes sensibles et Portées IaC protégées nécessitent Claude Code v2.1.195 ou ultérieur. Les versions antérieures les lisent toujours comme du contexte simple mais n'ont pas les règles intégrées qui les ciblent.

96 107 

97Un modèle de démarrage utile : remplissez les champs entre crochets et supprimez les lignes qui ne s'appliquent pas.108Un modèle de démarrage utile : remplissez les champs entre crochets et supprimez les lignes qui ne s'appliquent pas.

98 109 

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.3> Use this file to discover all available pages before exploring further.

4 4 

5# Utiliser Claude Code avec Chrome (bêta)5# Utiliser Claude Code avec Chrome

6 6 

7> Connectez Claude Code à votre navigateur Chrome pour tester des applications web, déboguer avec les journaux de console, automatiser le remplissage de formulaires et extraire des données des pages web.7> Connectez Claude Code à votre navigateur Chrome pour tester des applications web, déboguer avec les journaux de console, automatiser le remplissage de formulaires et extraire des données des pages web.

8 8 

11Claude ouvre de nouveaux onglets pour les tâches du navigateur et partage l'état de connexion de votre navigateur, ce qui lui permet d'accéder à n'importe quel site auquel vous êtes déjà connecté. Les actions du navigateur s'exécutent en temps réel dans une fenêtre Chrome visible. Lorsque Claude rencontre une page de connexion ou un CAPTCHA, il s'arrête et vous demande de le gérer manuellement.11Claude ouvre de nouveaux onglets pour les tâches du navigateur et partage l'état de connexion de votre navigateur, ce qui lui permet d'accéder à n'importe quel site auquel vous êtes déjà connecté. Les actions du navigateur s'exécutent en temps réel dans une fenêtre Chrome visible. Lorsque Claude rencontre une page de connexion ou un CAPTCHA, il s'arrête et vous demande de le gérer manuellement.

12 12 

13<Note>13<Note>

14 L'intégration Chrome est en bêta et fonctionne actuellement avec Google Chrome et Microsoft Edge. Elle n'est pas encore prise en charge sur Brave, Arc ou d'autres navigateurs basés sur Chromium. WSL (Windows Subsystem for Linux) n'est pas non plus pris en charge.14 L'intégration Chrome fonctionne avec Google Chrome et Microsoft Edge. Elle n'est pas encore prise en charge sur Brave, Arc ou d'autres navigateurs basés sur Chromium. Elle n'est pas non plus prise en charge dans Windows Subsystem for Linux (WSL).

15</Note>15</Note>

16 16 

17<h2 id="capabilities">17<h2 id="capabilities">

90 90 

91Les autorisations au niveau du site sont héritées de l'extension Chrome. Gérez les autorisations dans les paramètres de l'extension Chrome pour contrôler les sites que Claude peut parcourir, cliquer et taper.91Les autorisations au niveau du site sont héritées de l'extension Chrome. Gérez les autorisations dans les paramètres de l'extension Chrome pour contrôler les sites que Claude peut parcourir, cliquer et taper.

92 92 

93<h3 id="browser-tools-in-plan-mode">

94 Outils du navigateur en mode plan

95</h3>

96 

97En [mode plan](/fr/permission-modes#analyze-before-you-edit-with-plan-mode), les appels d'outils du navigateur qui lisent uniquement la page ou l'état du navigateur s'exécutent sans invite d'autorisation, et les appels qui modifient l'état demandent une approbation.

98 

99* **Appels en lecture seule** : `read_page`, `get_page_text`, `find`, lecture des messages de console ou des demandes réseau, et prise de capture d'écran

100* **Appels modifiant l'état** : clics, saisie, navigation, gestion des onglets et des fenêtres, et enregistrement d'un GIF

101 

102À partir de la v2.1.199, un appel autrement en lecture seule qui définit un drapeau d'entrée modifiant l'état, tel que `createIfEmpty` sur `tabs_context_mcp`, `clear` sur les lecteurs de console et de réseau, ou `save_to_disk` sur une capture d'écran, demande également une approbation. Un appel `browser_batch` s'exécute sans invite uniquement lorsque chaque action à l'intérieur est en lecture seule.

103 

93<h2 id="example-workflows">104<h2 id="example-workflows">

94 Exemples de flux de travail105 Exemples de flux de travail

95</h2>106</h2>

208 219 

209La première fois que vous activez l'intégration Chrome, Claude Code installe un fichier de configuration d'hôte de messagerie native. Chrome lit ce fichier au démarrage, donc si l'extension n'est pas détectée à votre première tentative, redémarrez Chrome pour récupérer la nouvelle configuration.220La première fois que vous activez l'intégration Chrome, Claude Code installe un fichier de configuration d'hôte de messagerie native. Chrome lit ce fichier au démarrage, donc si l'extension n'est pas détectée à votre première tentative, redémarrez Chrome pour récupérer la nouvelle configuration.

210 221 

222À partir de la v2.1.199, Claude Code ouvre un onglet du navigateur vous invitant à connecter l'extension uniquement lors de cette première installation. Les sessions ultérieures qui réécrivent le fichier de configuration, par exemple après le changement de versions de Claude Code ou de répertoires de configuration, ne le rouvrent pas.

223 

211Si la connexion échoue toujours, vérifiez que le fichier de configuration d'hôte existe à :224Si la connexion échoue toujours, vérifiez que le fichier de configuration d'hôte existe à :

212 225 

213Pour Chrome :226Pour Chrome :

4 4 

5# Configuration de la passerelle Claude apps5# Configuration de la passerelle Claude apps

6 6 

7> Référence pour chaque option gateway.yaml : écouteur et TLS, OIDC, session, magasin Postgres, amonts Bedrock/Agent Platform/Foundry, routage des modèles, politiques gérées et télémétrie.7> Référence pour chaque option gateway.yaml : écouteur et TLS, OIDC, session, magasin Postgres, amonts Bedrock/Claude Platform sur AWS/Agent Platform/Foundry, routage des modèles, politiques gérées et télémétrie.

8 8 

9Un déploiement de passerelle Claude apps est configuré par un fichier YAML, conventionnellement `gateway.yaml`. Le fichier définit tout ce que fait la passerelle : où elle écoute, comment les développeurs se connectent, où va l'inférence et quelles politiques et télémétrie s'appliquent. Cette page est la référence pour chaque option de ce fichier. Pour écrire votre première, commencez par le [démarrage rapide](/fr/claude-apps-gateway#quickstart), qui crée une configuration minimale fonctionnelle et l'exécute ; une fois que vous avez une configuration avec laquelle vous êtes satisfait, le [guide de déploiement](/fr/claude-apps-gateway-deploy) couvre la conteneurisation et l'hébergement sur Kubernetes, Cloud Run ou votre propre plateforme.9Un déploiement de passerelle Claude apps est configuré par un fichier YAML, conventionnellement `gateway.yaml`. Le fichier définit tout ce que fait la passerelle : où elle écoute, comment les développeurs se connectent, où va l'inférence et quelles politiques et télémétrie s'appliquent. Cette page est la référence pour chaque option de ce fichier.

10 

11Pour écrire votre première, commencez par le [démarrage rapide](/fr/claude-apps-gateway#quickstart), qui crée une configuration minimale fonctionnelle et l'exécute. Une fois que vous avez une configuration avec laquelle vous êtes satisfait, le [guide de déploiement](/fr/claude-apps-gateway-deploy) couvre la conteneurisation et l'hébergement sur Kubernetes, Cloud Run ou votre propre plateforme.

10 12 

11La passerelle lit le fichier une fois, au démarrage, avec `claude gateway --config /path/to/gateway.yaml`. Chaque option est validée par rapport à un schéma au démarrage, donc une configuration mal formée échoue au démarrage avec une erreur au niveau du champ plutôt qu'à la première utilisation.13La passerelle lit le fichier une fois, au démarrage, avec `claude gateway --config /path/to/gateway.yaml`. Chaque option est validée par rapport à un schéma au démarrage, donc une configuration mal formée échoue au démarrage avec une erreur au niveau du champ plutôt qu'à la première utilisation.

12 14 

24* [`oidc`](#oidc) : votre fournisseur d'identité (IdP), y compris l'émetteur, le client, le mappage des réclamations et qui peut se connecter26* [`oidc`](#oidc) : votre fournisseur d'identité (IdP), y compris l'émetteur, le client, le mappage des réclamations et qui peut se connecter

25* [`session`](#session) : les jetons porteurs que la passerelle émet, avec secret et durée de vie27* [`session`](#session) : les jetons porteurs que la passerelle émet, avec secret et durée de vie

26* [`store`](#store) : PostgreSQL, pour les subventions d'appareils et les compteurs de limite de débit28* [`store`](#store) : PostgreSQL, pour les subventions d'appareils et les compteurs de limite de débit

27* [`upstreams`](#upstreams) : où l'inférence va, qu'il s'agisse d'Anthropic, Bedrock, Agent Platform ou Foundry29* [`upstreams`](#upstreams) : où l'inférence va, qu'il s'agisse d'Anthropic, Bedrock, Claude Platform sur AWS, Agent Platform ou Foundry

28 30 

29**Sections optionnelles :**31**Sections optionnelles :**

30 32 

68 `oidc`70 `oidc`

69</h3>71</h3>

70 72 

71OpenID Connect (OIDC) est le protocole SSO que la passerelle utilise avec votre fournisseur d'identité ; voir [Configuration du fournisseur d'identité](/fr/claude-apps-gateway-deploy#identity-provider-setup) pour ce qu'il faut enregistrer du côté IdP. Le bloc `oidc` connecte la passerelle à votre fournisseur d'identité et décide qui peut se connecter. Il nomme l'émetteur et le client OAuth, mappe les réclamations qui portent l'e-mail et les groupes, et restreint la connexion par domaine d'e-mail ou groupe.73Le bloc `oidc` connecte la passerelle à votre fournisseur d'identité et décide qui peut se connecter. Il nomme l'émetteur et le client OAuth, mappe les réclamations qui portent l'e-mail et les groupes, et restreint la connexion par domaine d'e-mail ou groupe.

74 

75OpenID Connect (OIDC) est le protocole SSO que la passerelle utilise avec votre fournisseur d'identité ; voir [Configuration du fournisseur d'identité](/fr/claude-apps-gateway-deploy#identity-provider-setup) pour ce qu'il faut enregistrer du côté IdP.

72 76 

73| Champ | Requis | Description |77| Champ | Requis | Description |

74| ------------------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |78| ------------------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

121 `upstreams`125 `upstreams`

122</h3>126</h3>

123 127 

124`upstreams` est une liste ordonnée. La passerelle transfère l'inférence au premier upstream qui résout le modèle demandé. Sur `5xx`, `429` ou timeout, elle bascule vers le suivant ; les autres `4xx` ne le font pas, car ces erreurs sont attribuables à la demande plutôt qu'à l'upstream. Plusieurs upstreams du même fournisseur doivent définir un `name:` distinct.128`upstreams` est une liste ordonnée. La passerelle transfère l'inférence au premier upstream qui résout le modèle demandé. Sur `5xx`, `429`, `401`, `403`, `404`, ou timeout, elle bascule vers le suivant ; les autres `4xx` ne le font pas, car ces erreurs sont attribuables à la demande plutôt qu'à l'upstream. Un `401` ou `403` signifie que l'identifiant propre de la passerelle a échoué contre cet upstream, et un `404` signifie que cet upstream ne sert pas le modèle demandé, donc un upstream ultérieur dans la liste peut toujours le faire.

129 

130Le basculement sur `404` nécessite la passerelle v2.1.198 ou ultérieure. Les versions antérieures retournaient le premier `404` au client même lorsqu'un upstream ultérieur dans la liste servait le modèle.

125 131 

126Les clients Bedrock, Agent Platform et Foundry sont construits une fois au démarrage, et leurs SDKs actualisent les identifiants en interne, donc la rotation des identifiants cloud ne nécessite pas un redémarrage. Les clés API Anthropic statiques et les porteurs sont lus au démarrage ; voir [Anthropic API](#anthropic-api).132Plusieurs upstreams du même fournisseur doivent définir un `name:` distinct.

133 

134Les clients Bedrock, Claude Platform on AWS, Agent Platform et Foundry sont construits une fois au démarrage, et leurs SDKs actualisent les identifiants en interne, donc la rotation des identifiants cloud ne nécessite pas un redémarrage. Les clés API Anthropic statiques et les porteurs sont lus au démarrage ; voir [Anthropic API](#anthropic-api).

127 135 

128<h4 id="anthropic-api">136<h4 id="anthropic-api">

129 Anthropic API137 Anthropic API

193| N'importe où ailleurs | Passez les identifiants via les variables env `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` et `AWS_SESSION_TOKEN`, ou définissez-les explicitement dans `auth:` avec expansion `${VAR}` |201| N'importe où ailleurs | Passez les identifiants via les variables env `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` et `AWS_SESSION_TOKEN`, ou définissez-les explicitement dans `auth:` avec expansion `${VAR}` |

194| Région | `region:` est la région du point de terminaison API. Les profils d'inférence inter-régions routent à travers la géographie (US, EU, APAC) indépendamment de celui que vous choisissez. Pour les régions non-US ou les ARNs de débit provisionné, ajoutez un bloc [`models:`](#models) avec les bons IDs par upstream. |202| Région | `region:` est la région du point de terminaison API. Les profils d'inférence inter-régions routent à travers la géographie (US, EU, APAC) indépendamment de celui que vous choisissez. Pour les régions non-US ou les ARNs de débit provisionné, ajoutez un bloc [`models:`](#models) avec les bons IDs par upstream. |

195 203 

204<h4 id="claude-platform-on-aws">

205 Claude Platform on AWS

206</h4>

207 

208Claude Platform on AWS sert l'API Anthropic propriétaire sur l'infrastructure AWS à `aws-external-anthropic.<region>.api.aws`. Il utilise les IDs de modèle propriétaires, honore les en-têtes `anthropic-beta` tels qu'envoyés, et sert `count_tokens`, donc aucune des traductions spécifiques à Bedrock ne s'applique. Le fournisseur `anthropicAws` nécessite Claude Code v2.1.198 ou ultérieur ; les versions antérieures de la passerelle le rejettent au démarrage.

209 

210Pour le déploiement côté client de la même plateforme, voir [Claude Code sur Claude Platform on AWS](/fr/claude-platform-on-aws). L'upstream côté passerelle :

211 

212```yaml theme={null}

213upstreams:

214 - provider: anthropicAws

215 region: us-east-1

216 workspace_id: wrkspc_...

217 auth:

218 api_key: ${ANTHROPIC_AWS_API_KEY} # envoyé en tant que x-api-key

219 # OU SigV4 via la chaîne d'identifiants par défaut AWS :

220 # auth: {}

221 # OU identifiants SigV4 explicites :

222 # auth:

223 # aws_access_key_id: ${AWS_ACCESS_KEY_ID}

224 # aws_secret_access_key: ${AWS_SECRET_ACCESS_KEY}

225 # Remplacer le point de terminaison dérivé :

226 # base_url: https://aws-external-anthropic.us-east-1.api.aws

227```

228 

229La plateforme s'exécute dans un compte AWS séparé d'Amazon Bedrock et signe les demandes SigV4 pour son propre nom de service, `aws-external-anthropic`, donc un rôle IAM limité à Bedrock ne l'autorise pas. Une clé API dans `auth.api_key` prend la priorité lorsque les identifiants SigV4 sont également définis. Un bloc `auth` vide utilise la chaîne d'identifiants par défaut du SDK AWS, la même chaîne que l'upstream [Amazon Bedrock](#amazon-bedrock) utilise.

230 

231| Champ | Requis | Description |

232| ------------------------------------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

233| `region` | Oui | Région AWS, lettres minuscules, chiffres et traits d'union. La passerelle dérive le point de terminaison à partir de celui-ci en tant que `https://aws-external-anthropic.<region>.api.aws`. |

234| `workspace_id` | Oui | Envoyé en tant qu'en-tête sur chaque demande ; la plateforme l'exige |

235| `auth.api_key` | Non | Clé API pour la plateforme, envoyée en tant que `x-api-key`. Pas un jeton porteur : les deux modes d'authentification sont une clé API ou SigV4. |

236| `auth.aws_access_key_id` / `auth.aws_secret_access_key` | Non | Identifiants SigV4 explicites. Définir l'un sans l'autre échoue au démarrage. `auth.aws_session_token` est accepté à côté d'eux. |

237| `base_url` | Non | Remplacer le point de terminaison dérivé |

238 

239Parce que la plateforme résout les IDs de modèle propriétaires, le catalogue intégré route vers elle sans bloc [`models:`](#models). Lorsque vous organisez une liste `models:`, indexez l'entrée `anthropicAws:` avec l'ID propriétaire.

240 

196<h4 id="google-cloud-agent-platform">241<h4 id="google-cloud-agent-platform">

197 Google Cloud Agent Platform242 Google Cloud Agent Platform

198</h4>243</h4>

255 300 

256Le même fournisseur peut apparaître plus d'une fois avec un `name:` distinct. Cela couvre différentes régions, différents comptes via différentes chaînes d'identifiants, débit provisionné par rapport à la demande, et basculement inter-fournisseur.301Le même fournisseur peut apparaître plus d'une fois avec un `name:` distinct. Cela couvre différentes régions, différents comptes via différentes chaînes d'identifiants, débit provisionné par rapport à la demande, et basculement inter-fournisseur.

257 302 

258La passerelle essaie les upstreams dans l'ordre. `5xx`, `429`, timeouts et point de terminaison manquant (`501`) basculent ; les autres `4xx` ne le font pas. `429` est la capacité par upstream, donc l'épuisement du débit provisionné (PT) bascule vers la demande. Un upstream qui ne peut pas résoudre le modèle demandé est ignoré sans un aller-retour réseau.303La passerelle essaie les upstreams dans l'ordre. `5xx`, `429`, `401`, `403`, `404`, timeouts et point de terminaison manquant (`501`) basculent ; les autres `4xx` ne le font pas.

304 

305`429` est la capacité par upstream, donc l'épuisement du débit provisionné (PT) bascule vers la demande. `404` est la disponibilité du modèle par upstream, donc un upstream qui n'a pas activé un modèle ne bloque pas un upstream ultérieur qui le sert. Un upstream qui ne peut pas résoudre le modèle demandé est ignoré sans un aller-retour réseau.

259 306 

260Cet exemple route une allocation Bedrock de débit provisionné en premier, déborde vers la demande et un deuxième compte, et revient à l'API Anthropic en dernier :307Cet exemple route une allocation Bedrock de débit provisionné en premier, déborde vers la demande et un deuxième compte, et revient à l'API Anthropic en dernier :

261 308 

580| `limits` | `max_request_bytes` | 32 MiB | Corps de demande entrant max ; les demandes surdimensionnées obtiennent `413` avant que le corps soit mis en mémoire tampon. Augmentez pour les demandes de fichiers ou d'images volumineux. |627| `limits` | `max_request_bytes` | 32 MiB | Corps de demande entrant max ; les demandes surdimensionnées obtiennent `413` avant que le corps soit mis en mémoire tampon. Augmentez pour les demandes de fichiers ou d'images volumineux. |

581| `limits` | `max_request_header_bytes` | non défini | Lorsqu'il est défini, les en-têtes surdimensionnés retournent `431` |628| `limits` | `max_request_header_bytes` | non défini | Lorsqu'il est défini, les en-têtes surdimensionnés retournent `431` |

582| `limits` | `max_url_length` | non défini | Lorsqu'il est défini, une URL trop longue retourne `414` |629| `limits` | `max_url_length` | non défini | Lorsqu'il est défini, une URL trop longue retourne `414` |

583| `timeouts` | `upstream_ttfb_ms` | 120000 | Attente max pour les en-têtes de réponse upstream (time to first byte). Le corps de la réponse s'écoule ensuite sans plafond de temps mural. S'applique au chemin upstream Anthropic direct ; Bedrock, Agent Platform et Foundry sont limités par le timeout du SDK du fournisseur. |630| `timeouts` | `upstream_ttfb_ms` | 120000 | Attente max pour les en-têtes de réponse upstream (time to first byte). Le corps de la réponse s'écoule ensuite sans plafond de temps mural. S'applique au chemin upstream Anthropic direct ; chaque autre fournisseur est limité par le timeout du SDK du fournisseur. |

584| `rate_limits` | `device_authorization.max` / `.window_seconds` | 30 / 600 | Limite de débit par IP sur le point de terminaison d'autorisation d'appareil non authentifié. Augmentez pour une grande organisation derrière une IP de sortie partagée ou NAT. Ces limites s'appliquent uniquement au flux de connexion de subvention d'appareil, pas à l'inférence `/v1/messages`. Voir [Résistance à la force brute du code utilisateur](/fr/claude-apps-gateway-deploy#user-code-brute-force-resistance). |631| `rate_limits` | `device_authorization.max` / `.window_seconds` | 30 / 600 | Limite de débit par IP sur le point de terminaison d'autorisation d'appareil non authentifié. Augmentez pour une grande organisation derrière une IP de sortie partagée ou NAT. Ces limites s'appliquent uniquement au flux de connexion de subvention d'appareil, pas à l'inférence `/v1/messages`. Voir [Résistance à la force brute du code utilisateur](/fr/claude-apps-gateway-deploy#user-code-brute-force-resistance). |

585| `rate_limits` | `device_verify.max` / `.window_seconds` | 10 / 600 | Limite de débit par IP sur les soumissions `user_code` à `/device` |632| `rate_limits` | `device_verify.max` / `.window_seconds` | 10 / 600 | Limite de débit par IP sur les soumissions `user_code` à `/device` |

586 633 

662 # region: us-east-1709 # region: us-east-1

663 # auth: {}710 # auth: {}

664 711 

712 # - provider: anthropicAws

713 # region: us-east-1

714 # workspace_id: wrkspc_...

715 # auth:

716 # api_key: ${ANTHROPIC_AWS_API_KEY}

717 

665 # - provider: vertex718 # - provider: vertex

666 # region: us-east5719 # region: us-east5

667 # project_id: example-prod720 # project_id: example-prod

678 upstream_model:731 upstream_model:

679 anthropic: claude-opus-4-8732 anthropic: claude-opus-4-8

680 # bedrock: us.anthropic.claude-opus-4-8733 # bedrock: us.anthropic.claude-opus-4-8

734 # anthropicAws: claude-opus-4-8

681 # vertex: claude-opus-4-8735 # vertex: claude-opus-4-8

682 # foundry: <your-opus-deployment-name>736 # foundry: <your-opus-deployment-name>

683 - id: claude-sonnet-4-6737 - id: claude-sonnet-4-6

97<Note>97<Note>

98 **Identité de charge de travail**98 **Identité de charge de travail**

99 99 

100 Préférez l'identité de charge de travail de la plateforme aux clés statiques : IRSA sur EKS pour Bedrock, Workload Identity sur GKE pour Agent Platform, et identité de charge de travail sur AKS pour Foundry. Définissez `auth: {}` dans le bloc en amont, ou `use_azure_ad: true` pour Foundry, et la passerelle récupère l'identité du pod via la chaîne de credentials par défaut de ce fournisseur. Pour un appairage inter-cloud, tel qu'un amont Bedrock sur GKE, définissez des credentials explicites dans le bloc `auth` de l'amont à la place. La [référence `upstreams`](/fr/claude-apps-gateway-config#upstreams) a des détails de configuration par plateforme.100 Préférez l'identité de charge de travail de la plateforme aux clés statiques : IRSA sur EKS pour Bedrock et pour Claude Platform sur AWS, Workload Identity sur GKE pour Agent Platform, et identité de charge de travail sur AKS pour Foundry. Définissez `auth: {}` dans le bloc en amont, ou `use_azure_ad: true` pour Foundry, et la passerelle récupère l'identité du pod via la chaîne de credentials par défaut de ce fournisseur. Pour un appairage inter-cloud, tel qu'un amont Bedrock sur GKE, définissez des credentials explicites dans le bloc `auth` de l'amont à la place. La [référence `upstreams`](/fr/claude-apps-gateway-config#upstreams) a des détails de configuration par plateforme.

101</Note>101</Note>

102 102 

103<h3 id="cloud-run">103<h3 id="cloud-run">

723La téléportation vérifie ces exigences avant de reprendre une session. Si une exigence n'est pas satisfaite, vous verrez une erreur ou vous serez invité à résoudre le problème.723La téléportation vérifie ces exigences avant de reprendre une session. Si une exigence n'est pas satisfaite, vous verrez une erreur ou vous serez invité à résoudre le problème.

724 724 

725| Exigence | Détails |725| Exigence | Détails |

726| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |726| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

727| État git propre | Votre répertoire de travail ne doit avoir aucune modification non validée. La téléportation vous invite à ranger les modifications si nécessaire. |727| État git propre | Votre répertoire de travail ne doit avoir aucune modification non validée. La téléportation vous invite à ranger les modifications si nécessaire. |

728| Référentiel correct | Vous devez exécuter `--teleport` à partir d'une extraction du même référentiel, pas d'une fourche. |728| Référentiel correct | Vous devez exécuter `--teleport` à partir d'une extraction du même référentiel, pas d'une fourche. À partir de la v2.1.199, Claude Code accepte une extraction même lorsqu'il ne peut pas analyser le serveur distant en nom d'hôte, comme un alias d'hôte SSH comme `git@work:owner/repo.git` ou une forme courte réécrite par `insteadOf`. Il affiche d'abord une invite de confirmation, et uniquement lorsque le propriétaire du serveur distant et le nom du référentiel correspondent au référentiel de la session. |

729| Branche disponible | La branche de la session cloud doit avoir été poussée vers le serveur distant. La téléportation la récupère et l'extrait automatiquement. |729| Branche disponible | La branche de la session cloud doit avoir été poussée vers le serveur distant. La téléportation la récupère et l'extrait automatiquement. |

730| Même compte | Vous devez être authentifié au même compte claude.ai utilisé dans la session cloud. |730| Même compte | Vous devez être authentifié au même compte claude.ai utilisé dans la session cloud. |

731 731 

230 230 

231Pour l'intégration continue et l'automatisation, donnez au runner un rôle IAM avec la permission d'invoquer le service Anthropic et définissez `AWS_REGION`. La chaîne d'identifiants récupère automatiquement le rôle.231Pour l'intégration continue et l'automatisation, donnez au runner un rôle IAM avec la permission d'invoquer le service Anthropic et définissez `AWS_REGION`. La chaîne d'identifiants récupère automatiquement le rôle.

232 232 

233Si vos identifiants SSO expirent en cours de session, configurez [`awsAuthRefresh`](/fr/amazon-bedrock#advanced-credential-configuration) pour que Claude Code réexécute votre commande de connexion et réessaie au lieu d'échouer. Ajoutez la commande à votre `settings.json` :233Si vos identifiants SSO expirent en cours de session, configurez [`awsAuthRefresh`](/fr/amazon-bedrock#advanced-credential-configuration) pour que Claude Code réexécute votre commande de connexion et réessaie au lieu d'échouer. L'actualisation automatique sur Claude Platform on AWS nécessite Claude Code v2.1.198 ou version ultérieure ; les versions antérieures s'arrêtent avec une invite pour exécuter `/login`, qui ne peut pas actualiser les identifiants AWS. Ajoutez la commande à votre `settings.json` :

234 234 

235```json theme={null}235```json theme={null}

236{236{

47 47 

48Si vous tapez mal une sous-commande, Claude Code suggère la correspondance la plus proche et quitte sans démarrer une session. Par exemple, `claude udpate` imprime `Did you mean claude update?`.48Si vous tapez mal une sous-commande, Claude Code suggère la correspondance la plus proche et quitte sans démarrer une session. Par exemple, `claude udpate` imprime `Did you mean claude update?`.

49 49 

50{/* min-version: 2.1.199 */}À partir de v2.1.199, `claude --dangerously-skip-permissions daemon <subcommand>` exécute la sous-commande `daemon`. Les versions antérieures traitaient `daemon <subcommand>` comme l'invite pour une nouvelle session interactive, donc la sous-commande ne s'exécutait jamais quand le drapeau venait en premier, une configuration courante quand `claude` est aliasé pour inclure le drapeau. Seul un `--dangerously-skip-permissions` ou `--allow-dangerously-skip-permissions` en tête achemine vers `daemon` de cette façon ; tout autre drapeau en tête démarre toujours une session interactive.

51 

50<h2 id="cli-flags">52<h2 id="cli-flags">

51 Drapeaux CLI53 Drapeaux CLI

52</h2>54</h2>

66| `--ax-screen-reader` | {/* min-version: 2.1.181 */}Afficher une sortie accessible aux lecteurs d'écran : texte plat sans bordures décoratives ni animations. Force le rendu classique, donc le paramètre [`tui`](/fr/settings#available-settings) n'a aucun effet pour la session. Prend la priorité sur [`CLAUDE_AX_SCREEN_READER`](/fr/env-vars) et le paramètre [`axScreenReader`](/fr/settings#available-settings). Nécessite Claude Code v2.1.181 ou ultérieur | `claude --ax-screen-reader` |68| `--ax-screen-reader` | {/* min-version: 2.1.181 */}Afficher une sortie accessible aux lecteurs d'écran : texte plat sans bordures décoratives ni animations. Force le rendu classique, donc le paramètre [`tui`](/fr/settings#available-settings) n'a aucun effet pour la session. Prend la priorité sur [`CLAUDE_AX_SCREEN_READER`](/fr/env-vars) et le paramètre [`axScreenReader`](/fr/settings#available-settings). Nécessite Claude Code v2.1.181 ou ultérieur | `claude --ax-screen-reader` |

67| `--bare` | Mode minimal : ignorer la découverte automatique des hooks, skills, plugins, serveurs MCP, mémoire automatique et CLAUDE.md afin que les appels scriptés démarrent plus rapidement. Claude a accès aux outils Bash, lecture de fichier et édition de fichier. Définit [`CLAUDE_CODE_SIMPLE`](/fr/env-vars). Voir [mode bare](/fr/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |69| `--bare` | Mode minimal : ignorer la découverte automatique des hooks, skills, plugins, serveurs MCP, mémoire automatique et CLAUDE.md afin que les appels scriptés démarrent plus rapidement. Claude a accès aux outils Bash, lecture de fichier et édition de fichier. Définit [`CLAUDE_CODE_SIMPLE`](/fr/env-vars). Voir [mode bare](/fr/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |

68| `--betas` | En-têtes bêta à inclure dans les requêtes API (utilisateurs de clé API uniquement) | `claude --betas interleaved-thinking` |70| `--betas` | En-têtes bêta à inclure dans les requêtes API (utilisateurs de clé API uniquement) | `claude --betas interleaved-thinking` |

69| `--bg`, `--background` | Démarrer la session en tant qu'[agent en arrière-plan](/fr/agent-view) et revenir immédiatement. Affiche l'ID de session et les commandes de gestion. Combinez avec `--exec` pour exécuter une commande shell en tant que travail en arrière-plan au lieu d'une session Claude, ou avec `--agent` pour exécuter un subagent spécifique | `claude --bg "investigate the flaky test"` |71| `--bg`, `--background` | Démarrer la session en tant qu'[agent en arrière-plan](/fr/agent-view) et revenir immédiatement. Affiche l'ID de session et les commandes de gestion. Combinez avec `--exec` pour exécuter une commande shell en tant que travail en arrière-plan au lieu d'une session Claude, ou avec `--agent` pour exécuter un subagent spécifique. {/* min-version: 2.1.198 */}Ne peut pas être combiné avec `-p`/`--print` ; voir la [référence d'erreur](/fr/errors#command-line-errors) | `claude --bg "investigate the flaky test"` |

70| `--channels` | (Aperçu de recherche) Serveurs MCP dont les notifications de [canal](/fr/channels) Claude doit écouter dans cette session. Liste séparée par des espaces d'entrées `plugin:<name>@<marketplace>`. Nécessite l'authentification Claude.ai | `claude --channels plugin:my-notifier@my-marketplace` |72| `--channels` | (Aperçu de recherche) Serveurs MCP dont les notifications de [canal](/fr/channels) Claude doit écouter dans cette session. Liste séparée par des espaces d'entrées `plugin:<name>@<marketplace>`. Nécessite l'authentification Claude.ai | `claude --channels plugin:my-notifier@my-marketplace` |