Documentation 2026-10-29 23:57 UTC to 2026-10-30 23:01 UTC

77* **Python :** vérifiez les types de messages avec `isinstance()` par rapport aux classes importées de `claude_agent_sdk` (par exemple, `isinstance(message, ResultMessage)`).77* **Python :** vérifiez les types de messages avec `isinstance()` par rapport aux classes importées de `claude_agent_sdk` (par exemple, `isinstance(message, ResultMessage)`).

78* **TypeScript :** vérifiez le champ de chaîne `type` (par exemple, `message.type === "result"`). `AssistantMessage` et `UserMessage` enveloppent le message API brut dans un champ `.message`, donc les blocs de contenu sont à `message.message.content`, pas `message.content`.78* **TypeScript :** vérifiez le champ de chaîne `type` (par exemple, `message.type === "result"`). `AssistantMessage` et `UserMessage` enveloppent le message API brut dans un champ `.message`, donc les blocs de contenu sont à `message.message.content`, pas `message.content`.

79 79 

80> **Exemple : Vérifier les types de messages et gérer les résultats**80> [accordion] Exemple : Vérifier les types de messages et gérer les résultats

81>81>

82> ```python Python theme={null}82> ```python Python theme={null}

83> import asyncio83> import asyncio

273* **Hook `PreCompact` :** Exécutez une logique personnalisée avant la compaction, par exemple pour archiver la transcription complète. Le hook reçoit un champ `trigger` (`manual` ou `auto`). Voir [hooks](https://code.claude.com/docs/fr/agent-sdk/hooks.md).273* **Hook `PreCompact` :** Exécutez une logique personnalisée avant la compaction, par exemple pour archiver la transcription complète. Le hook reçoit un champ `trigger` (`manual` ou `auto`). Voir [hooks](https://code.claude.com/docs/fr/agent-sdk/hooks.md).

274* **Compaction manuelle :** Envoyez `/compact` comme chaîne de prompt pour déclencher la compaction à la demande. Les commandes envoyées de cette façon sont des entrées SDK ordinaires. Voir [dispatch commands by name](https://code.claude.com/docs/fr/agent-sdk/skills.md#dispatch-commands-by-name).274* **Compaction manuelle :** Envoyez `/compact` comme chaîne de prompt pour déclencher la compaction à la demande. Les commandes envoyées de cette façon sont des entrées SDK ordinaires. Voir [dispatch commands by name](https://code.claude.com/docs/fr/agent-sdk/skills.md#dispatch-commands-by-name).

275 275 

276> **Exemple : Instructions de résumé dans CLAUDE.md**276> [accordion] Exemple : Instructions de résumé dans CLAUDE.md

277>277>

278> Ajoutez une section au CLAUDE.md de votre projet indiquant au compacteur ce qu'il faut préserver. Le nom d'en-tête n'est pas spécial ; utilisez n'importe quel label clair.278> Ajoutez une section au CLAUDE.md de votre projet indiquant au compacteur ce qu'il faut préserver. Le nom d'en-tête n'est pas spécial ; utilisez n'importe quel label clair.

279>279>

42 42 

43Les exemples Python de cette page qui effectuent des requêtes HTTP utilisent [httpx](https://www.python-httpx.org/). Ajoutez-le avec le gestionnaire de paquets utilisé par votre projet :43Les exemples Python de cette page qui effectuent des requêtes HTTP utilisent [httpx](https://www.python-httpx.org/). Ajoutez-le avec le gestionnaire de paquets utilisé par votre projet :

44 44 

45**Python (uv)**45> [tab] Python (uv)

46 46>

47```bash theme={null}47> ```bash theme={null}

48uv add httpx48> uv add httpx

49```49> ```

50 

51**Python (pip)**

52 50 

53```bash theme={null}51> [tab] Python (pip)

54pip install httpx52>

55```53> ```bash theme={null}

54> pip install httpx

55> ```

56 56 

57### Exemple d'outil météo57### Exemple d'outil météo

58 58 

198 198 

199Combinez cet extrait avec les définitions d'outil et de serveur de l'[exemple d'outil météo](#weather-tool-example) dans un seul fichier, `weather.py` ou `weather.ts`, puis exécutez-le depuis votre terminal :199Combinez cet extrait avec les définitions d'outil et de serveur de l'[exemple d'outil météo](#weather-tool-example) dans un seul fichier, `weather.py` ou `weather.ts`, puis exécutez-le depuis votre terminal :

200 200 

201**TypeScript**201> [tab] TypeScript

202 202>

203```bash theme={null}203> ```bash theme={null}

204npx tsx weather.ts204> npx tsx weather.ts

205```205> ```

206 

207**Python (uv)**

208 

209```bash theme={null}

210uv run weather.py

211```

212 

213**Python (pip)**

214 206 

215Activez l'environnement virtuel dans lequel vous avez installé le SDK, puis exécutez :207> [tab] Python (uv)

208>

209> ```bash theme={null}

210> uv run weather.py

211> ```

216 212 

217```bash theme={null}213> [tab] Python (pip)

218python weather.py214>

219```215> Activez l'environnement virtuel dans lequel vous avez installé le SDK, puis exécutez :

216>

217> ```bash theme={null}

218> python weather.py

219> ```

220 220 

221Claude appelle `get_temperature` et le script affiche une réponse d'une ligne avec la température actuelle à San Francisco.221Claude appelle `get_temperature` et le script affiche une réponse d'une ligne avec la température actuelle à San Francisco.

222 222 

585>585>

586> Ouvrez votre fichier utilitaire (`utils.py` ou `utils.ts`) dans votre IDE ou éditeur avant d'exécuter le script. Vous verrez le fichier se mettre à jour en temps réel alors que l'agent ajoute des commentaires de documentation, puis revenir à l'original lorsque vous choisissez de rembobiner.586> Ouvrez votre fichier utilitaire (`utils.py` ou `utils.ts`) dans votre IDE ou éditeur avant d'exécuter le script. Vous verrez le fichier se mettre à jour en temps réel alors que l'agent ajoute des commentaires de documentation, puis revenir à l'original lorsque vous choisissez de rembobiner.

587 587 

588**Python**588> [tab] Python

589 589>

590```bash theme={null}590> ```bash theme={null}

591python try_checkpointing.py591> python try_checkpointing.py

592```592> ```

593 

594**TypeScript**

595 593 

596```bash theme={null}594> [tab] TypeScript

597npx tsx try_checkpointing.ts595>

598```596> ```bash theme={null}

597> npx tsx try_checkpointing.ts

598> ```

599 599 

600Vous verrez l'agent ajouter des commentaires de documentation, puis une invite vous demandant si vous souhaitez rembobiner. Si vous choisissez oui, le fichier est restauré à son état d'origine.600Vous verrez l'agent ajouter des commentaires de documentation, puis une invite vous demandant si vous souhaitez rembobiner. Si vous choisissez oui, le fichier est restauré à son état d'origine.

601 601 

386 386 

387Utilisez le champ `env` pour transmettre les clés API, les jetons et autres identifiants au serveur MCP :387Utilisez le champ `env` pour transmettre les clés API, les jetons et autres identifiants au serveur MCP :

388 388 

389**Dans le code**389> [tab] Dans le code

390 390>

391```typescript TypeScript hidelines={1,-1} theme={null}391> ```typescript TypeScript hidelines={1,-1} theme={null}

392const _ = {392> const _ = {

393 options: {393> options: {

394 mcpServers: {394> mcpServers: {

395 "api-server": {395> "api-server": {

396 command: "npx",396> command: "npx",

397 args: ["-y", "@your-org/api-mcp-server"],397> args: ["-y", "@your-org/api-mcp-server"],

398 env: {398> env: {

399 API_KEY: process.env.API_KEY399> API_KEY: process.env.API_KEY

400 }400> }

401 }401> }

402 },402> },

403 allowedTools: ["mcp__api-server__*"]403> allowedTools: ["mcp__api-server__*"]

404 }404> }

405};405> };

406```406> ```

407 407>

408```python Python theme={null}408> ```python Python theme={null}

409options = ClaudeAgentOptions(409> options = ClaudeAgentOptions(

410 mcp_servers={410> mcp_servers={

411 "api-server": {411> "api-server": {

412 "command": "npx",412> "command": "npx",

413 "args": ["-y", "@your-org/api-mcp-server"],413> "args": ["-y", "@your-org/api-mcp-server"],

414 "env": {"API_KEY": os.environ["API_KEY"]},414> "env": {"API_KEY": os.environ["API_KEY"]},

415 }415> }

416 },416> },

417 allowed_tools=["mcp__api-server__*"],417> allowed_tools=["mcp__api-server__*"],

418)418> )

419```419> ```

420 420 

421**.mcp.json**421> [tab] .mcp.json

422 422>

423```json theme={null}423> ```json theme={null}

424{424> {

425 "mcpServers": {425> "mcpServers": {

426 "api-server": {426> "api-server": {

427 "command": "npx",427> "command": "npx",

428 "args": ["-y", "@your-org/api-mcp-server"],428> "args": ["-y", "@your-org/api-mcp-server"],

429 "env": {429> "env": {

430 "API_KEY": "${API_KEY}"430> "API_KEY": "${API_KEY}"

431 }431> }

432 }432> }

433 }433> }

434}434> }

435```435> ```

436 436>

437La syntaxe `${API_KEY}` développe les variables d'environnement au moment de l'exécution.437> La syntaxe `${API_KEY}` développe les variables d'environnement au moment de l'exécution.

438 438 

439### En-têtes HTTP pour les serveurs distants439### En-têtes HTTP pour les serveurs distants

440 440 

441Pour les serveurs HTTP et SSE, transmettez les en-têtes d'authentification directement dans la configuration du serveur :441Pour les serveurs HTTP et SSE, transmettez les en-têtes d'authentification directement dans la configuration du serveur :

442 442 

443**Dans le code**443> [tab] Dans le code

444 444>

445```typescript TypeScript hidelines={1,-1} theme={null}445> ```typescript TypeScript hidelines={1,-1} theme={null}

446const _ = {446> const _ = {

447 options: {447> options: {

448 mcpServers: {448> mcpServers: {

449 "secure-api": {449> "secure-api": {

450 type: "http",450> type: "http",

451 url: "https://api.example.com/mcp",451> url: "https://api.example.com/mcp",

452 headers: {452> headers: {

453 Authorization: `Bearer ${process.env.API_TOKEN}`453> Authorization: `Bearer ${process.env.API_TOKEN}`

454 }454> }

455 }455> }

456 },456> },

457 allowedTools: ["mcp__secure-api__*"]457> allowedTools: ["mcp__secure-api__*"]

458 }458> }

459};459> };

460```460> ```

461 461>

462```python Python theme={null}462> ```python Python theme={null}

463options = ClaudeAgentOptions(463> options = ClaudeAgentOptions(

464 mcp_servers={464> mcp_servers={

465 "secure-api": {465> "secure-api": {

466 "type": "http",466> "type": "http",

467 "url": "https://api.example.com/mcp",467> "url": "https://api.example.com/mcp",

468 "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},468> "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},

469 }469> }

470 },470> },

471 allowed_tools=["mcp__secure-api__*"],471> allowed_tools=["mcp__secure-api__*"],

472)472> )

473```473> ```

474 474 

475**.mcp.json**475> [tab] .mcp.json

476 476>

477```json theme={null}477> ```json theme={null}

478{478> {

479 "mcpServers": {479> "mcpServers": {

480 "secure-api": {480> "secure-api": {

481 "type": "http",481> "type": "http",

482 "url": "https://api.example.com/mcp",482> "url": "https://api.example.com/mcp",

483 "headers": {483> "headers": {

484 "Authorization": "Bearer ${API_TOKEN}"484> "Authorization": "Bearer ${API_TOKEN}"

485 }485> }

486 }486> }

487 }487> }

488}488> }

489```489> ```

490 490>

491La syntaxe `${API_TOKEN}` développe les variables d'environnement au moment de l'exécution.491> La syntaxe `${API_TOKEN}` développe les variables d'environnement au moment de l'exécution.

492 492 

493Pour un exemple complet et fonctionnel d'un serveur distant authentifié avec des en-têtes, consultez [Lister les problèmes d'un référentiel](#list-issues-from-a-repository).493Pour un exemple complet et fonctionnel d'un serveur distant authentifié avec des en-têtes, consultez [Lister les problèmes d'un référentiel](#list-issues-from-a-repository).

494 494 

163 163 

164Vous pouvez définir le mode de permission une fois au démarrage d'une requête, ou le modifier dynamiquement pendant que la session est active.164Vous pouvez définir le mode de permission une fois au démarrage d'une requête, ou le modifier dynamiquement pendant que la session est active.

165 165 

166**Au moment de la requête**166> [tab] Au moment de la requête

167 167>

168Passez `permission_mode` (Python) ou `permissionMode` (TypeScript) lors de la création d'une requête.168> Passez `permission_mode` (Python) ou `permissionMode` (TypeScript) lors de la création d'une requête.

169 169>

170```python Python theme={null}170> ```python Python theme={null}

171import asyncio171> import asyncio

172from claude_agent_sdk import query, ClaudeAgentOptions172> from claude_agent_sdk import query, ClaudeAgentOptions

173 173>

174 174>

175async def main():175> async def main():

176 async for message in query(176> async for message in query(

177 prompt="Help me refactor this code",177> prompt="Help me refactor this code",

178 options=ClaudeAgentOptions(178> options=ClaudeAgentOptions(

179 permission_mode="default", # Set the mode here179> permission_mode="default", # Set the mode here

180 ),180> ),

181 ):181> ):

182 if hasattr(message, "result"):182> if hasattr(message, "result"):

183 print(message.result)183> print(message.result)

184 184>

185 185>

186asyncio.run(main())186> asyncio.run(main())

187```187> ```

188 188>

189```typescript TypeScript theme={null}189> ```typescript TypeScript theme={null}

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

191 191>

192async function main() {192> async function main() {

193 for await (const message of query({193> for await (const message of query({

194 prompt: "Help me refactor this code",194> prompt: "Help me refactor this code",

195 options: {195> options: {

196 permissionMode: "default" // Set the mode here196> permissionMode: "default" // Set the mode here

197 }197> }

198 })) {198> })) {

199 if ("result" in message) {199> if ("result" in message) {

200 console.log(message.result);200> console.log(message.result);

201 }201> }

202 }202> }

203}203> }

204 204>

205main();205> main();

206```206> ```

207 

208**Pendant le streaming**

209 

210Appelez `set_permission_mode()` (Python) ou `setPermissionMode()` (TypeScript) pour modifier le mode en cours de session. Le nouveau mode prend effet immédiatement pour toutes les demandes d'outils suivantes. Cela vous permet de commencer de manière restrictive et d'assouplir les permissions à mesure que la confiance augmente, par exemple en passant à `acceptEdits` après avoir examiné l'approche initiale de Claude.

211 

212```python Python theme={null}

213import asyncio

214from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

215 

216 

217async def main():

218 async with ClaudeSDKClient(

219 options=ClaudeAgentOptions(

220 permission_mode="default", # Start in default mode

221 )

222 ) as client:

223 await client.query("Help me refactor this code")

224 

225 # Change mode dynamically mid-session

226 await client.set_permission_mode("acceptEdits")

227 

228 # Process messages with the new permission mode

229 async for message in client.receive_response():

230 if hasattr(message, "result"):

231 print(message.result)

232 

233 

234asyncio.run(main())

235```

236 207 

237```typescript TypeScript theme={null}208> [tab] Pendant le streaming

238import { query } from "@anthropic-ai/claude-agent-sdk";209>

239 210> Appelez `set_permission_mode()` (Python) ou `setPermissionMode()` (TypeScript) pour modifier le mode en cours de session. Le nouveau mode prend effet immédiatement pour toutes les demandes d'outils suivantes. Cela vous permet de commencer de manière restrictive et d'assouplir les permissions à mesure que la confiance augmente, par exemple en passant à `acceptEdits` après avoir examiné l'approche initiale de Claude.

240async function main() {211>

241 const q = query({212> ```python Python theme={null}

242 prompt: "Help me refactor this code",213> import asyncio

243 options: {214> from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

244 permissionMode: "default" // Start in default mode215>

245 }216>

246 });217> async def main():

247 218> async with ClaudeSDKClient(

248 // Change mode dynamically mid-session219> options=ClaudeAgentOptions(

249 await q.setPermissionMode("acceptEdits");220> permission_mode="default", # Start in default mode

250 221> )

251 // Process messages with the new permission mode222> ) as client:

252 for await (const message of q) {223> await client.query("Help me refactor this code")

253 if ("result" in message) {224>

254 console.log(message.result);225> # Change mode dynamically mid-session

255 }226> await client.set_permission_mode("acceptEdits")

256 }227>

257}228> # Process messages with the new permission mode

258 229> async for message in client.receive_response():

259main();230> if hasattr(message, "result"):

260```231> print(message.result)

232>

233>

234> asyncio.run(main())

235> ```

236>

237> ```typescript TypeScript theme={null}

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

239>

240> async function main() {

241> const q = query({

242> prompt: "Help me refactor this code",

243> options: {

244> permissionMode: "default" // Start in default mode

245> }

246> });

247>

248> // Change mode dynamically mid-session

249> await q.setPermissionMode("acceptEdits");

250>

251> // Process messages with the new permission mode

252> for await (const message of q) {

253> if ("result" in message) {

254> console.log(message.result);

255> }

256> }

257> }

258>

259> main();

260> ```

261 261 

262### Détails des modes262### Détails des modes

263 263 

36 36 

37Installez le package du SDK Agent pour votre langage :37Installez le package du SDK Agent pour votre langage :

38 38 

39**TypeScript (nouveau projet)**39> [tab] TypeScript (nouveau projet)

40 40>

41```bash theme={null}41> ```bash theme={null}

42npm init -y42> npm init -y

43npm pkg set type=module43> npm pkg set type=module

44npm install @anthropic-ai/claude-agent-sdk44> npm install @anthropic-ai/claude-agent-sdk

45npm install --save-dev tsx45> npm install --save-dev tsx

46```46> ```

47 47>

48Définir `"type": "module"` dans `package.json` permet à votre script d'agent d'utiliser `await` au niveau supérieur, et [tsx](https://tsx.hirok.io) exécute les fichiers TypeScript directement. npm affiche `added N packages` lorsque l'installation réussit.48> Définir `"type": "module"` dans `package.json` permet à votre script d'agent d'utiliser `await` au niveau supérieur, et [tsx](https://tsx.hirok.io) exécute les fichiers TypeScript directement. npm affiche `added N packages` lorsque l'installation réussit.

49 

50**TypeScript (projet existant)**

51 

52```bash theme={null}

53npm install @anthropic-ai/claude-agent-sdk

54npm install --save-dev tsx

55```

56 

57[tsx](https://tsx.hirok.io) exécute les fichiers TypeScript directement. Si votre projet utilise CommonJS, nommez votre script d'agent `agent.mts` au lieu de `agent.ts`. L'extension `.mts` fait que tsx traite le fichier comme un module ES, donc `await` au niveau supérieur fonctionne sans convertir tout votre projet en modules ES. Utilisez `agent.mts` à la place de `agent.ts` dans les étapes de création et d'exécution plus tard dans ce démarrage rapide.

58 

59**Python (uv)**

60 

61[Installez uv](https://docs.astral.sh/uv/), un gestionnaire de paquets Python rapide qui gère automatiquement les environnements virtuels. Ensuite, initialisez un projet et ajoutez le SDK :

62 

63```bash theme={null}

64uv init

65uv add claude-agent-sdk

66```

67 

68**Python (pip)**

69 

70Créez et activez un environnement virtuel, puis installez le package.

71 

72Sur macOS ou Linux :

73 

74```bash theme={null}

75python3 -m venv .venv

76source .venv/bin/activate

77pip install claude-agent-sdk

78```

79 49 

80Sur Windows :50> [tab] TypeScript (projet existant)

51>

52> ```bash theme={null}

53> npm install @anthropic-ai/claude-agent-sdk

54> npm install --save-dev tsx

55> ```

56>

57> [tsx](https://tsx.hirok.io) exécute les fichiers TypeScript directement. Si votre projet utilise CommonJS, nommez votre script d'agent `agent.mts` au lieu de `agent.ts`. L'extension `.mts` fait que tsx traite le fichier comme un module ES, donc `await` au niveau supérieur fonctionne sans convertir tout votre projet en modules ES. Utilisez `agent.mts` à la place de `agent.ts` dans les étapes de création et d'exécution plus tard dans ce démarrage rapide.

81 58 

82```powershell theme={null}59> [tab] Python (uv)

83py -m venv .venv60>

84.venv\Scripts\Activate.ps161> [Installez uv](https://docs.astral.sh/uv/), un gestionnaire de paquets Python rapide qui gère automatiquement les environnements virtuels. Ensuite, initialisez un projet et ajoutez le SDK :

85pip install claude-agent-sdk62>

86```63> ```bash theme={null}

64> uv init

65> uv add claude-agent-sdk

66> ```

87 67 

88Si PowerShell bloque `Activate.ps1` avec une erreur de politique d'exécution, exécutez d'abord `Set-ExecutionPolicy -Scope Process RemoteSigned`.68> [tab] Python (pip)

69>

70> Créez et activez un environnement virtuel, puis installez le package.

71>

72> Sur macOS ou Linux :

73>

74> ```bash theme={null}

75> python3 -m venv .venv

76> source .venv/bin/activate

77> pip install claude-agent-sdk

78> ```

79>

80> Sur Windows :

81>

82> ```powershell theme={null}

83> py -m venv .venv

84> .venv\Scripts\Activate.ps1

85> pip install claude-agent-sdk

86> ```

87>

88> Si PowerShell bloque `Activate.ps1` avec une erreur de politique d'exécution, exécutez d'abord `Set-ExecutionPolicy -Scope Process RemoteSigned`.

89 89 

90> [!NOTE]90> [!NOTE]

91>91>

98 98 

99Obtenez une clé API à partir de la [Console Claude](https://platform.claude.com/), puis définissez-la comme variable d'environnement dans le shell où vous exécuterez votre agent :99Obtenez une clé API à partir de la [Console Claude](https://platform.claude.com/), puis définissez-la comme variable d'environnement dans le shell où vous exécuterez votre agent :

100 100 

101**macOS / Linux**101> [tab] macOS / Linux

102 102>

103```bash theme={null}103> ```bash theme={null}

104export ANTHROPIC_API_KEY=your-api-key104> export ANTHROPIC_API_KEY=your-api-key

105```105> ```

106 

107**Windows (PowerShell)**

108 106 

109```powershell theme={null}107> [tab] Windows (PowerShell)

110$env:ANTHROPIC_API_KEY = "your-api-key"108>

111```109> ```powershell theme={null}

110> $env:ANTHROPIC_API_KEY = "your-api-key"

111> ```

112 112 

113Le SDK lit la clé à partir de l'environnement du processus qui exécute votre agent ; il ne charge pas les fichiers `.env` automatiquement. Si vous conservez la clé dans un fichier `.env`, chargez-la vous-même, par exemple avec le package `dotenv`, avant d'appeler le SDK.113Le SDK lit la clé à partir de l'environnement du processus qui exécute votre agent ; il ne charge pas les fichiers `.env` automatiquement. Si vous conservez la clé dans un fichier `.env`, chargez-la vous-même, par exemple avec le package `dotenv`, avant d'appeler le SDK.

114 114 

224 224 

225Votre agent est prêt. Exécutez-le avec la commande suivante :225Votre agent est prêt. Exécutez-le avec la commande suivante :

226 226 

227**TypeScript**227> [tab] TypeScript

228 228>

229```bash theme={null}229> ```bash theme={null}

230npx tsx agent.ts230> npx tsx agent.ts

231```231> ```

232 232>

233Si vous avez nommé votre script `agent.mts`, exécutez `npx tsx agent.mts` à la place.233> Si vous avez nommé votre script `agent.mts`, exécutez `npx tsx agent.mts` à la place.

234 

235**Python (uv)**

236 

237```bash theme={null}

238uv run agent.py

239```

240 

241**Python (pip)**

242 234 

243Avec votre environnement virtuel toujours activé :235> [tab] Python (uv)

236>

237> ```bash theme={null}

238> uv run agent.py

239> ```

244 240 

245```bash theme={null}241> [tab] Python (pip)

246python agent.py242>

247```243> Avec votre environnement virtuel toujours activé :

244>

245> ```bash theme={null}

246> python agent.py

247> ```

248 248 

249Au fur et à mesure qu'il travaille, l'agent imprime son raisonnement et chaque outil qu'il appelle, se terminant par `Done: success`. Après l'exécution, vérifiez `utils.py`. Vous verrez du code défensif gérant les listes vides et les utilisateurs nuls. Votre agent a autonomement :249Au fur et à mesure qu'il travaille, l'agent imprime son raisonnement et chaque outil qu'il appelle, se terminant par `Done: success`. Après l'exécution, vérifiez `utils.py`. Vous verrez du code défensif gérant les listes vides et les utilisateurs nuls. Votre agent a autonomement :

250 250 

470 470 

471Chaque SDK expose le rejet différemment :471Chaque SDK expose le rejet différemment :

472 472 

473**TypeScript**473> [tab] TypeScript

474 474>

475Le SDK TypeScript lève une `Error` indiquant la règle que l'entrée a enfreinte. Par exemple, `skills: ["docs:*"]` lève :475> Le SDK TypeScript lève une `Error` indiquant la règle que l'entrée a enfreinte. Par exemple, `skills: ["docs:*"]` lève :

476 476>

477```text theme={null}477> ```text theme={null}

478Invalid skill name "docs:*": wildcard-suffix names are not allowed; list each skill by its exact name.478> Invalid skill name "docs:*": wildcard-suffix names are not allowed; list each skill by its exact name.

479```479> ```

480 480>

481Un nom vide rapporte `Skill names must be non-empty strings.`481> Un nom vide rapporte `Skill names must be non-empty strings.`

482 482>

483Avant le TypeScript Agent SDK 0.3.221, le SDK n'exécutait pas cette vérification.483> Avant le TypeScript Agent SDK 0.3.221, le SDK n'exécutait pas cette vérification.

484 

485**Python**

486 

487Le SDK Python lève `ValueError` indiquant la règle que l'entrée a enfreinte. Par exemple, `skills=["docs:*"]` lève :

488 

489```text theme={null}

490ValueError: Invalid skill name 'docs:*': wildcard-suffix names are not allowed; list each skill by its exact name.

491```

492 

493Un nom vide rapporte `Skill names must be non-empty strings`.

494 484 

495Avant le Python Agent SDK 0.2.129, le SDK n'exécutait pas cette vérification.485> [tab] Python

486>

487> Le SDK Python lève `ValueError` indiquant la règle que l'entrée a enfreinte. Par exemple, `skills=["docs:*"]` lève :

488>

489> ```text theme={null}

490> ValueError: Invalid skill name 'docs:*': wildcard-suffix names are not allowed; list each skill by its exact name.

491> ```

492>

493> Un nom vide rapporte `Skill names must be non-empty strings`.

494>

495> Avant le Python Agent SDK 0.2.129, le SDK n'exécutait pas cette vérification.

496 496 

497### Dépannage supplémentaire497### Dépannage supplémentaire

498 498 

16 16 

17Considérez une application de recettes où un agent recherche sur le web et ramène des recettes. Sans sorties structurées, vous obtenez du texte libre que vous devriez analyser vous-même. Avec les sorties structurées, vous définissez la forme que vous souhaitez et obtenez des données typées que vous pouvez utiliser directement dans votre application.17Considérez une application de recettes où un agent recherche sur le web et ramène des recettes. Sans sorties structurées, vous obtenez du texte libre que vous devriez analyser vous-même. Avec les sorties structurées, vous définissez la forme que vous souhaitez et obtenez des données typées que vous pouvez utiliser directement dans votre application.

18 18 

19> **Sans sorties structurées**19> [accordion] Sans sorties structurées

20>20>

21> ```text theme={null}21> ```text theme={null}

22> Voici une recette classique de biscuits aux pépites de chocolat !22> Voici une recette classique de biscuits aux pépites de chocolat !

32>32>

33> Pour utiliser ceci dans votre application, vous devriez analyser le titre, convertir ' 15 minutes ' en nombre, séparer les ingrédients des instructions et gérer le formatage incohérent entre les réponses.33> Pour utiliser ceci dans votre application, vous devriez analyser le titre, convertir ' 15 minutes ' en nombre, séparer les ingrédients des instructions et gérer le formatage incohérent entre les réponses.

34 34 

35> **Avec sorties structurées**35> [accordion] Avec sorties structurées

36>36>

37> ```jsonc theme={null}37> ```jsonc theme={null}

38> {38> {

225 225 

226Les helpers `ask_user` et `askUser` dans les extraits suivants représentent votre propre interface utilisateur d'invite d'application.226Les helpers `ask_user` et `askUser` dans les extraits suivants représentent votre propre interface utilisateur d'invite d'application.

227 227 

228**Approuver**228> [tab] Approuver

229 229>

230L'utilisateur approuve l'action telle quelle. Passez l'`input` de votre callback inchangée et l'outil s'exécute exactement comme Claude l'a demandé.230> L'utilisateur approuve l'action telle quelle. Passez l'`input` de votre callback inchangée et l'outil s'exécute exactement comme Claude l'a demandé.

231 231>

232```python Python theme={null}232> ```python Python theme={null}

233async def can_use_tool(tool_name, input_data, context):233> async def can_use_tool(tool_name, input_data, context):

234 print(f"Claude wants to use {tool_name}")234> print(f"Claude wants to use {tool_name}")

235 approved = await ask_user("Allow this action?")235> approved = await ask_user("Allow this action?")

236 236>

237 if approved:237> if approved:

238 return PermissionResultAllow(updated_input=input_data)238> return PermissionResultAllow(updated_input=input_data)

239 return PermissionResultDeny(message="User declined")239> return PermissionResultDeny(message="User declined")

240```240> ```

241 241>

242```typescript TypeScript theme={null}242> ```typescript TypeScript theme={null}

243canUseTool: async (toolName, input) => {243> canUseTool: async (toolName, input) => {

244 console.log(`Claude wants to use ${toolName}`);244> console.log(`Claude wants to use ${toolName}`);

245 const approved = await askUser("Allow this action?");245> const approved = await askUser("Allow this action?");

246 246>

247 if (approved) {247> if (approved) {

248 return { behavior: "allow", updatedInput: input };248> return { behavior: "allow", updatedInput: input };

249 }249> }

250 return { behavior: "deny", message: "User declined" };250> return { behavior: "deny", message: "User declined" };

251};251> };

252```252> ```

253 253 

254**Approuver avec des modifications**254> [tab] Approuver avec des modifications

255 255>

256L'utilisateur approuve mais veut d'abord modifier la demande. Vous pouvez modifier l'entrée avant l'exécution de l'outil. Claude voit le résultat mais n'est pas informé que vous avez changé quelque chose. Utile pour nettoyer les paramètres, ajouter des contraintes, ou limiter l'accès.256> L'utilisateur approuve mais veut d'abord modifier la demande. Vous pouvez modifier l'entrée avant l'exécution de l'outil. Claude voit le résultat mais n'est pas informé que vous avez changé quelque chose. Utile pour nettoyer les paramètres, ajouter des contraintes, ou limiter l'accès.

257 257>

258```python Python theme={null}258> ```python Python theme={null}

259async def can_use_tool(tool_name, input_data, context):259> async def can_use_tool(tool_name, input_data, context):

260 if tool_name == "Bash":260> if tool_name == "Bash":

261 # L'utilisateur a approuvé, mais limiter toutes les commandes au sandbox261> # L'utilisateur a approuvé, mais limiter toutes les commandes au sandbox

262 sandboxed_input = {**input_data}262> sandboxed_input = {**input_data}

263 sandboxed_input["command"] = input_data["command"].replace(263> sandboxed_input["command"] = input_data["command"].replace(

264 "/tmp", "/tmp/sandbox"264> "/tmp", "/tmp/sandbox"

265 )265> )

266 return PermissionResultAllow(updated_input=sandboxed_input)266> return PermissionResultAllow(updated_input=sandboxed_input)

267 return PermissionResultAllow(updated_input=input_data)267> return PermissionResultAllow(updated_input=input_data)

268```268> ```

269 269>

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

271canUseTool: async (toolName, input) => {271> canUseTool: async (toolName, input) => {

272 if (toolName === "Bash") {272> if (toolName === "Bash") {

273 // L'utilisateur a approuvé, mais limiter toutes les commandes au sandbox273> // L'utilisateur a approuvé, mais limiter toutes les commandes au sandbox

274 const sandboxedInput = {274> const sandboxedInput = {

275 ...input,275> ...input,

276 command: input.command.replace("/tmp", "/tmp/sandbox")276> command: input.command.replace("/tmp", "/tmp/sandbox")

277 };277> };

278 return { behavior: "allow", updatedInput: sandboxedInput };278> return { behavior: "allow", updatedInput: sandboxedInput };

279 }279> }

280 return { behavior: "allow", updatedInput: input };280> return { behavior: "allow", updatedInput: input };

281};281> };

282```282> ```

283 283 

284**Approuver et mémoriser**284> [tab] Approuver et mémoriser

285 285>

286L'utilisateur approuve et ne veut pas être invité à nouveau pour ce type d'appel. Le troisième argument du callback porte `suggestions`, un tableau d'entrées [`PermissionUpdate`](https://code.claude.com/docs/fr/agent-sdk/typescript#permissionupdate) prêtes à l'emploi. Renvoyez-en une dans `updatedPermissions` pour l'appliquer. Une suggestion avec la destination `localSettings` écrit la règle dans `.claude/settings.local.json` afin que les futures sessions ignorent l'invite pour les appels correspondants.286> L'utilisateur approuve et ne veut pas être invité à nouveau pour ce type d'appel. Le troisième argument du callback porte `suggestions`, un tableau d'entrées [`PermissionUpdate`](https://code.claude.com/docs/fr/agent-sdk/typescript#permissionupdate) prêtes à l'emploi. Renvoyez-en une dans `updatedPermissions` pour l'appliquer. Une suggestion avec la destination `localSettings` écrit la règle dans `.claude/settings.local.json` afin que les futures sessions ignorent l'invite pour les appels correspondants.

287 287>

288En TypeScript, ignorez le choix always-allow pour une demande dont les options portent [`suppressAlwaysAllowRule: true`](https://code.claude.com/docs/fr/agent-sdk/typescript#canusetool). L'indice nécessite Agent SDK v0.3.268 ou ultérieur, et le `context` Python ne le porte pas.288> En TypeScript, ignorez le choix always-allow pour une demande dont les options portent [`suppressAlwaysAllowRule: true`](https://code.claude.com/docs/fr/agent-sdk/typescript#canusetool). L'indice nécessite Agent SDK v0.3.268 ou ultérieur, et le `context` Python ne le porte pas.

289 289>

290L'exemple Python nécessite `claude-agent-sdk` 0.1.80 ou ultérieur.290> L'exemple Python nécessite `claude-agent-sdk` 0.1.80 ou ultérieur.

291 291>

292```python Python theme={null}292> ```python Python theme={null}

293async def can_use_tool(tool_name, input_data, context):293> async def can_use_tool(tool_name, input_data, context):

294 choice = await ask_user(f"Allow {tool_name}?", ["once", "always", "no"])294> choice = await ask_user(f"Allow {tool_name}?", ["once", "always", "no"])

295 295>

296 if choice == "always":296> if choice == "always":

297 persist = [297> persist = [

298 s for s in context.suggestions if s.destination == "localSettings"298> s for s in context.suggestions if s.destination == "localSettings"

299 ]299> ]

300 return PermissionResultAllow(300> return PermissionResultAllow(

301 updated_input=input_data, updated_permissions=persist301> updated_input=input_data, updated_permissions=persist

302 )302> )

303 if choice == "once":303> if choice == "once":

304 return PermissionResultAllow(updated_input=input_data)304> return PermissionResultAllow(updated_input=input_data)

305 return PermissionResultDeny(message="User declined")305> return PermissionResultDeny(message="User declined")

306```306> ```

307 307>

308```typescript TypeScript theme={null}308> ```typescript TypeScript theme={null}

309canUseTool: async (toolName, input, { suggestions = [] }) => {309> canUseTool: async (toolName, input, { suggestions = [] }) => {

310 const choice = await askUser(`Allow ${toolName}?`, ["once", "always", "no"]);310> const choice = await askUser(`Allow ${toolName}?`, ["once", "always", "no"]);

311 311>

312 if (choice === "always") {312> if (choice === "always") {

313 const persist = suggestions.filter(313> const persist = suggestions.filter(

314 (s) => s.destination === "localSettings"314> (s) => s.destination === "localSettings"

315 );315> );

316 return {316> return {

317 behavior: "allow",317> behavior: "allow",

318 updatedInput: input,318> updatedInput: input,

319 updatedPermissions: persist319> updatedPermissions: persist

320 };320> };

321 }321> }

322 if (choice === "once") {322> if (choice === "once") {

323 return { behavior: "allow", updatedInput: input };323> return { behavior: "allow", updatedInput: input };

324 }324> }

325 return { behavior: "deny", message: "User declined" };325> return { behavior: "deny", message: "User declined" };

326};326> };

327```327> ```

328 328 

329**Rejeter**329> [tab] Rejeter

330 330>

331L'utilisateur ne veut pas que cette action se produise. Bloquez l'outil et fournissez un message expliquant pourquoi. Claude voit ce message et peut essayer une approche différente.331> L'utilisateur ne veut pas que cette action se produise. Bloquez l'outil et fournissez un message expliquant pourquoi. Claude voit ce message et peut essayer une approche différente.

332 332>

333```python Python theme={null}333> ```python Python theme={null}

334async def can_use_tool(tool_name, input_data, context):334> async def can_use_tool(tool_name, input_data, context):

335 approved = await ask_user(f"Allow {tool_name}?")335> approved = await ask_user(f"Allow {tool_name}?")

336 336>

337 if not approved:337> if not approved:

338 return PermissionResultDeny(message="User rejected this action")338> return PermissionResultDeny(message="User rejected this action")

339 return PermissionResultAllow(updated_input=input_data)339> return PermissionResultAllow(updated_input=input_data)

340```340> ```

341 341>

342```typescript TypeScript theme={null}342> ```typescript TypeScript theme={null}

343canUseTool: async (toolName, input) => {343> canUseTool: async (toolName, input) => {

344 const approved = await askUser(`Allow ${toolName}?`);344> const approved = await askUser(`Allow ${toolName}?`);

345 345>

346 if (!approved) {346> if (!approved) {

347 return {347> return {

348 behavior: "deny",348> behavior: "deny",

349 message: "User rejected this action"349> message: "User rejected this action"

350 };350> };

351 }351> }

352 return { behavior: "allow", updatedInput: input };352> return { behavior: "allow", updatedInput: input };

353};353> };

354```354> ```

355 355 

356**Suggérer une alternative**356> [tab] Suggérer une alternative

357 357>

358L'utilisateur ne veut pas cette action spécifique, mais a une idée différente. Bloquez l'outil et incluez des conseils dans votre message. Claude lira ceci et décidera comment procéder en fonction de vos commentaires.358> L'utilisateur ne veut pas cette action spécifique, mais a une idée différente. Bloquez l'outil et incluez des conseils dans votre message. Claude lira ceci et décidera comment procéder en fonction de vos commentaires.

359 359>

360```python Python theme={null}360> ```python Python theme={null}

361async def can_use_tool(tool_name, input_data, context):361> async def can_use_tool(tool_name, input_data, context):

362 if tool_name == "Bash" and "rm" in input_data.get("command", ""):362> if tool_name == "Bash" and "rm" in input_data.get("command", ""):

363 # L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place363> # L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place

364 return PermissionResultDeny(364> return PermissionResultDeny(

365 message="User doesn't want to delete files. They asked if you could compress them into an archive instead."365> message="User doesn't want to delete files. They asked if you could compress them into an archive instead."

366 )366> )

367 return PermissionResultAllow(updated_input=input_data)367> return PermissionResultAllow(updated_input=input_data)

368```368> ```

369 369>

370```typescript TypeScript theme={null}370> ```typescript TypeScript theme={null}

371canUseTool: async (toolName, input) => {371> canUseTool: async (toolName, input) => {

372 if (toolName === "Bash" && input.command.includes("rm")) {372> if (toolName === "Bash" && input.command.includes("rm")) {

373 // L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place373> // L'utilisateur ne veut pas supprimer, suggérer d'archiver à la place

374 return {374> return {

375 behavior: "deny",375> behavior: "deny",

376 message:376> message:

377 "User doesn't want to delete files. They asked if you could compress them into an archive instead."377> "User doesn't want to delete files. They asked if you could compress them into an archive instead."

378 };378> };

379 }379> }

380 return { behavior: "allow", updatedInput: input };380> return { behavior: "allow", updatedInput: input };

381};381> };

382```382> ```

383 383 

384**Rediriger entièrement**384> [tab] Rediriger entièrement

385 385>

386Pour un changement de direction complet (pas seulement une nudge), utilisez [streaming input](https://code.claude.com/docs/fr/agent-sdk/streaming-vs-single-mode.md) pour envoyer à Claude une nouvelle instruction directement. Cela contourne la demande d'outil actuelle et donne à Claude des instructions entièrement nouvelles à suivre.386> Pour un changement de direction complet (pas seulement une nudge), utilisez [streaming input](https://code.claude.com/docs/fr/agent-sdk/streaming-vs-single-mode.md) pour envoyer à Claude une nouvelle instruction directement. Cela contourne la demande d'outil actuelle et donne à Claude des instructions entièrement nouvelles à suivre.

387 387 

388## Gérer les questions de clarification388## Gérer les questions de clarification

389 389 

13| [Sous-agents](https://code.claude.com/docs/fr/sub-agents.md) | Des travailleurs délégués dans une session qui effectuent une tâche secondaire dans leur propre contexte et retournent un résumé | Une tâche secondaire inonderait votre conversation principale avec des résultats de recherche, des journaux ou des contenus de fichiers que vous ne référencerez plus |13| [Sous-agents](https://code.claude.com/docs/fr/sub-agents.md) | Des travailleurs délégués dans une session qui effectuent une tâche secondaire dans leur propre contexte et retournent un résumé | Une tâche secondaire inonderait votre conversation principale avec des résultats de recherche, des journaux ou des contenus de fichiers que vous ne référencerez plus |

14| [Vue agent](https://code.claude.com/docs/fr/agent-view.md) | Un écran pour dispatcher et surveiller les sessions s'exécutant en arrière-plan, ouvert avec `claude agents`. Aperçu de recherche | Vous avez plusieurs tâches indépendantes et voulez les déléguer, vérifier l'état en un coup d'œil et intervenir uniquement quand l'une d'elles a besoin de vous |14| [Vue agent](https://code.claude.com/docs/fr/agent-view.md) | Un écran pour dispatcher et surveiller les sessions s'exécutant en arrière-plan, ouvert avec `claude agents`. Aperçu de recherche | Vous avez plusieurs tâches indépendantes et voulez les déléguer, vérifier l'état en un coup d'œil et intervenir uniquement quand l'une d'elles a besoin de vous |

15| [Équipes d'agents](https://code.claude.com/docs/fr/agent-teams.md) | Plusieurs sessions coordonnées avec une liste de tâches partagée et une messagerie inter-agents, gérées par un responsable. Expérimental et désactivé par défaut | Vous voulez que Claude divise un projet en morceaux, les assigne et maintient les travailleurs synchronisés |15| [Équipes d'agents](https://code.claude.com/docs/fr/agent-teams.md) | Plusieurs sessions coordonnées avec une liste de tâches partagée et une messagerie inter-agents, gérées par un responsable. Expérimental et désactivé par défaut | Vous voulez que Claude divise un projet en morceaux, les assigne et maintient les travailleurs synchronisés |

16| [Projets](https://code.claude.com/docs/fr/claude-projects.md) | Une conversation continue sur claude.ai/code ou dans l'application de bureau. Claude démarre des sessions parallèles appelées threads, dans le cloud ou, quand vous le demandez, sur votre ordinateur via Remote Control, donne à chacune les instructions du projet et vous montre lesquelles ont besoin de vous. Bêta publique sur Pro et Max | Le travail s'étend sur plusieurs tâches pendant des jours ou des semaines, devrait continuer à s'exécuter quand votre machine est éteinte, et vous préférez le décrire une fois plutôt que de dispatcher et suivre chaque session |16| [Projets](https://code.claude.com/docs/fr/claude-projects.md) | Une conversation continue sur claude.ai/code ou dans l'application de bureau. Claude démarre des sessions parallèles appelées threads, dans le cloud ou, quand vous le demandez, sur votre ordinateur via Remote Control. Il donne à chacune les instructions du projet et vous montre lesquelles ont besoin de vous. Bêta publique sur Pro, Max et Ultra | Le travail s'étend sur plusieurs tâches pendant des jours ou des semaines, devrait continuer à s'exécuter quand votre machine est éteinte, et vous préférez le décrire une fois plutôt que de dispatcher et suivre chaque session |

17| [Workflows dynamiques](https://code.claude.com/docs/fr/workflows.md) | Un script qui exécute de nombreux sous-agents et vérifie leurs résultats, pour un travail trop important pour être coordonné en un seul tour ou qui nécessite plus d'une seule passe | Une tâche dépasse une poignée de sous-agents, ou vous voulez que les résultats soient vérifiés les uns par rapport aux autres : un audit à l'échelle de la base de code, une migration de 500 fichiers, une recherche vérifiée de manière croisée, ou un plan élaboré sous plusieurs angles |17| [Workflows dynamiques](https://code.claude.com/docs/fr/workflows.md) | Un script qui exécute de nombreux sous-agents et vérifie leurs résultats, pour un travail trop important pour être coordonné en un seul tour ou qui nécessite plus d'une seule passe | Une tâche dépasse une poignée de sous-agents, ou vous voulez que les résultats soient vérifiés les uns par rapport aux autres : un audit à l'échelle de la base de code, une migration de 500 fichiers, une recherche vérifiée de manière croisée, ou un plan élaboré sous plusieurs angles |

18 18 

19Dans chaque approche, les travailleurs sont des sessions Claude. Pour impliquer un outil différent, exposez-le à Claude en tant que [serveur MCP](https://code.claude.com/docs/fr/mcp.md).19Dans chaque approche, les travailleurs sont des sessions Claude. Pour impliquer un outil différent, exposez-le à Claude en tant que [serveur MCP](https://code.claude.com/docs/fr/mcp.md).

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Les artefacts sont disponibles sur les plans Pro, Max, Team et Enterprise et nécessitent une session connectée avec [`/login`](https://code.claude.com/docs/fr/setup#authenticate). Consultez [Disponibilité](#availability) pour l'ensemble complet des exigences.11> Les artefacts sont disponibles sur les plans Pro, Max, Ultra, Team et Enterprise et nécessitent une session connectée avec [`/login`](https://code.claude.com/docs/fr/setup#authenticate). Consultez [Disponibilité](#availability) pour l'ensemble complet des exigences.

12 12 

13Un [artefact](https://claude.com/features/artifacts) est une page web en direct et interactive que Claude Code publie depuis votre session vers une URL privée sur claude.ai. Vous l'ouvrez dans un navigateur, et elle se met à jour sur place à mesure que la session continue. Partagez-la depuis l'en-tête de la page quand vous voulez que quelqu'un d'autre la voie aussi.13Un [artefact](https://claude.com/features/artifacts) est une page web en direct et interactive que Claude Code publie depuis votre session vers une URL privée sur claude.ai. Vous l'ouvrez dans un navigateur, et elle se met à jour sur place à mesure que la session continue. Partagez-la depuis l'en-tête de la page quand vous voulez que quelqu'un d'autre la voie aussi.

14 14 

197 197 

198## Récupérer des données en direct avec les connecteurs MCP198## Récupérer des données en direct avec les connecteurs MCP

199 199 

200Un artifact peut appeler des [connecteurs MCP](https://code.claude.com/docs/fr/mcp.md#use-mcp-servers-from-claude-ai) chaque fois que quelqu'un le consulte, de sorte que la page affiche des données actuelles plutôt qu'une capture instantanée de la session qui l'a créé. Les appels de connecteur à partir d'artifacts sont disponibles sur les plans Pro, Max, Team et Enterprise et nécessitent Claude Code v2.1.209 ou version ultérieure. Sur les versions antérieures, Claude publie la page avec les données que la session a rassemblées lors de sa création.200Un artefact peut appeler des [connecteurs MCP](https://code.claude.com/docs/fr/mcp.md#use-mcp-servers-from-claude-ai) chaque fois que quelqu'un le consulte, de sorte que la page affiche des données actuelles plutôt qu'une capture instantanée de la session qui l'a créé. Les appels de connecteur à partir d'artefacts sont disponibles sur les plans Pro, Max, Ultra, Team et Enterprise et nécessitent Claude Code v2.1.209 ou version ultérieure. Sur les versions antérieures, Claude publie la page avec les données que la session a rassemblées lors de sa création.

201 201 

202Pour créer une page alimentée par un connecteur, nommez le connecteur et les données que vous souhaitez dans votre prompt :202Pour créer une page alimentée par un connecteur, nommez le connecteur et les données que vous souhaitez dans votre prompt :

203 203 

314 314 

315> [!NOTE]315> [!NOTE]

316>316>

317> Les modèles sont en version bêta. Ils sont activés par défaut sur les plans Pro, Max et Team. Sur les plans Enterprise, un propriétaire [active chaque modèle](https://support.claude.com/fr/articles/16994751-artifacts-admin-guide-for-team-and-enterprise-plans) sous **Paramètres de l'organisation > Artefacts**. Si votre organisation a désactivé le modèle Slides, `/slides` n'apparaît pas ; si elle a désactivé le modèle Design, `/design` ne crée pas de conceptions. Les deux commandes nécessitent Claude Code v2.1.265 ou version ultérieure et une session où [les artefacts sont disponibles](#availability).317> Les modèles sont en version bêta. Ils sont activés par défaut sur les plans Pro, Max, Ultra et Team. Sur les plans Enterprise, un propriétaire [active chaque modèle](https://support.claude.com/fr/articles/16994751-artifacts-admin-guide-for-team-and-enterprise-plans) sous **Paramètres de l'organisation > Artefacts**. Si votre organisation a désactivé le modèle Slides, `/slides` n'apparaît pas ; si elle a désactivé le modèle Design, `/design` ne crée pas de conceptions. Les deux commandes nécessitent Claude Code v2.1.265 ou version ultérieure et une session où [les artefacts sont disponibles](#availability).

318 318 

319### Créer une présentation319### Créer une présentation

320 320 

368 368 

369| Exigence | Disponible quand |369| Exigence | Disponible quand |

370| :- | :- |370| :- | :- |

371| Plan | Pro, Max, Team ou Enterprise. Sur les plans Pro et Max, les artefacts sont privés pour vous jusqu'à ce que vous les partagiez, et aucune gestion d'administrateur ne s'applique. Sur les plans Team et Enterprise, les artefacts sont activés par défaut, et un propriétaire peut [les désactiver pour l'organisation](#manage-artifacts-for-your-organization) dans les paramètres d'administration de claude.ai. |371| Plan | Pro, Max, Ultra, Team ou Enterprise. Sur les plans Pro, Max et Ultra, les artefacts sont privés pour vous jusqu'à ce que vous les partagiez, et aucune gestion d'administrateur ne s'applique. Sur les plans Team et Enterprise, les artefacts sont activés par défaut, et un propriétaire peut [les désactiver pour l'organisation](#manage-artifacts-for-your-organization) dans les paramètres d'administration de claude.ai. |

372| Authentification | La session s'appuie sur un compte claude.ai : connectez-vous avec `/login` dans la CLI ou l'application de bureau. Les sessions Claude Tag ne nécessitent aucune étape de connexion. Les sessions utilisant une clé API, un [jeton de passerelle](https://code.claude.com/docs/fr/llm-gateway) ou des identifiants de fournisseur cloud ne peuvent pas publier. |372| Authentification | La session s'appuie sur un compte claude.ai : connectez-vous avec `/login` dans la CLI ou l'application de bureau. Les sessions Claude Tag ne nécessitent aucune étape de connexion. Les sessions utilisant une clé API, un [jeton de passerelle](https://code.claude.com/docs/fr/llm-gateway) ou des identifiants de fournisseur cloud ne peuvent pas publier. |

373| Fournisseur de modèle | API Anthropic. Non disponible sur [Amazon Bedrock](https://code.claude.com/docs/fr/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/fr/google-vertex-ai.md) ou [Microsoft Foundry](https://code.claude.com/docs/fr/microsoft-foundry.md). |373| Fournisseur de modèle | API Anthropic. Non disponible sur [Amazon Bedrock](https://code.claude.com/docs/fr/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/fr/google-vertex-ai.md) ou [Microsoft Foundry](https://code.claude.com/docs/fr/microsoft-foundry.md). |

374| Politique organisationnelle | Les clés de chiffrement gérées par le client (CMEK), HIPAA et [Zéro rétention de données](https://code.claude.com/docs/fr/zero-data-retention.md) ne sont pas activées pour l'organisation. |374| Politique organisationnelle | Les clés de chiffrement gérées par le client (CMEK), HIPAA et [Zéro rétention de données](https://code.claude.com/docs/fr/zero-data-retention.md) ne sont pas activées pour l'organisation. |

23 23 

24Vous pouvez vous authentifier avec l'un de ces types de comptes :24Vous pouvez vous authentifier avec l'un de ces types de comptes :

25 25 

26* **Abonnement Claude Pro ou Max** : connectez-vous avec votre compte claude.ai. Abonnez-vous sur [claude.com/pricing](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=authentication_pro_max).26* **Abonnement Claude Pro, Max ou Ultra** : connectez-vous avec votre compte claude.ai. Abonnez-vous sur [claude.com/pricing](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=authentication_pro_max).

27* **Claude for Teams ou Enterprise** : connectez-vous avec le compte claude.ai auquel l'administrateur de votre équipe vous a invité.27* **Claude for Teams ou Enterprise** : connectez-vous avec le compte claude.ai auquel l'administrateur de votre équipe vous a invité.

28* **Claude Console** : connectez-vous avec vos identifiants Console. Votre administrateur doit d'abord vous avoir [invité](#claude-console-authentication). Vous pouvez vous connecter avec ou sans [créer de clé API](#sign-in-without-an-api-key).28* **Claude Console** : connectez-vous avec vos identifiants Console. Votre administrateur doit d'abord vous avoir [invité](#claude-console-authentication). Vous pouvez vous connecter avec ou sans [créer de clé API](#sign-in-without-an-api-key).

29* **Fournisseurs cloud** : si votre organisation utilise [Amazon Bedrock](https://code.claude.com/docs/fr/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/fr/google-vertex-ai.md) ou [Microsoft Foundry](https://code.claude.com/docs/fr/microsoft-foundry.md), définissez les variables d'environnement requises avant d'exécuter `claude`, ou sélectionnez **3rd-party platform** dans la demande de connexion, ce qui lance un assistant de configuration interactif pour Bedrock et Vertex AI. Aucune connexion via le navigateur n'est nécessaire.29* **Fournisseurs cloud** : si votre organisation utilise [Amazon Bedrock](https://code.claude.com/docs/fr/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/fr/google-vertex-ai.md) ou [Microsoft Foundry](https://code.claude.com/docs/fr/microsoft-foundry.md), définissez les variables d'environnement requises avant d'exécuter `claude`, ou sélectionnez **3rd-party platform** dans la demande de connexion, ce qui lance un assistant de configuration interactif pour Bedrock et Vertex AI. Aucune connexion via le navigateur n'est nécessaire.

2534. Sortie du script [`apiKeyHelper`](https://code.claude.com/docs/fr/settings-reference#apikeyhelper). Utilisez ceci pour les identifiants dynamiques ou rotatifs, tels que les jetons de courte durée récupérés à partir d'un coffre-fort.2534. Sortie du script [`apiKeyHelper`](https://code.claude.com/docs/fr/settings-reference#apikeyhelper). Utilisez ceci pour les identifiants dynamiques ou rotatifs, tels que les jetons de courte durée récupérés à partir d'un coffre-fort.

2545. Variable d'environnement `CLAUDE_CODE_OAUTH_TOKEN`. Un jeton OAuth de longue durée généré par [`claude setup-token`](#generate-a-long-lived-token). Utilisez ceci pour les pipelines CI et les scripts où la connexion au navigateur n'est pas disponible. Si vous exécutez `/login` alors que la variable est définie, Claude Code bascule la session actuelle vers la nouvelle connexion, mais relit la variable dans chaque nouvelle session jusqu'à ce que vous la supprimiez de votre profil shell ou du bloc `env` d'un [fichier de paramètres](https://code.claude.com/docs/fr/settings.md).2545. Variable d'environnement `CLAUDE_CODE_OAUTH_TOKEN`. Un jeton OAuth de longue durée généré par [`claude setup-token`](#generate-a-long-lived-token). Utilisez ceci pour les pipelines CI et les scripts où la connexion au navigateur n'est pas disponible. Si vous exécutez `/login` alors que la variable est définie, Claude Code bascule la session actuelle vers la nouvelle connexion, mais relit la variable dans chaque nouvelle session jusqu'à ce que vous la supprimiez de votre profil shell ou du bloc `env` d'un [fichier de paramètres](https://code.claude.com/docs/fr/settings.md).

2556. Identifiants de profil Anthropic et de fédération, les identifiants que la CLI `ant` et Workload Identity Federation utilisent. Un profil que `ant auth login` a écrit ne se classe ici que lorsque vous le nommez dans `ANTHROPIC_PROFILE` ; sinon, il se classe en dessous de `/login`. Consultez [Profils Anthropic et identifiants de fédération](#anthropic-profiles-and-federation-credentials).2556. Identifiants de profil Anthropic et de fédération, les identifiants que la CLI `ant` et Workload Identity Federation utilisent. Un profil que `ant auth login` a écrit ne se classe ici que lorsque vous le nommez dans `ANTHROPIC_PROFILE` ; sinon, il se classe en dessous de `/login`. Consultez [Profils Anthropic et identifiants de fédération](#anthropic-profiles-and-federation-credentials).

2567. Identifiants OAuth d'abonnement de `/login`. C'est la valeur par défaut pour les utilisateurs Claude Pro, Max, Team et Enterprise.2567. Identifiants OAuth d'abonnement de `/login`. C'est la valeur par défaut pour les utilisateurs Claude Pro, Max, Ultra, Team et Enterprise.

257 257 

258Une session [passerelle d'applications Claude](https://code.claude.com/docs/fr/claude-apps-gateway) signée se situe en dehors de cette liste : c'est une sélection de fournisseur comme Amazon Bedrock ou Google Cloud's Agent Platform, et elle les surclasse. Lorsqu'une session de passerelle existe, la CLI s'authentifie avec le jeton de passerelle même si `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX` ou `CLAUDE_CODE_USE_FOUNDRY` est défini, et les sources d'identifiants ci-dessus telles que le jeton porteur, la clé API, `apiKeyHelper` et les profils ne sont pas utilisés.258Une session [passerelle d'applications Claude](https://code.claude.com/docs/fr/claude-apps-gateway) signée se situe en dehors de cette liste : c'est une sélection de fournisseur comme Amazon Bedrock ou Google Cloud's Agent Platform, et elle les surclasse. Lorsqu'une session de passerelle existe, la CLI s'authentifie avec le jeton de passerelle même si `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX` ou `CLAUDE_CODE_USE_FOUNDRY` est défini, et les sources d'identifiants ci-dessus telles que le jeton porteur, la clé API, `apiKeyHelper` et les profils ne sont pas utilisés.

259 259 

300 300 

301La commande ouvre le même flux d'autorisation du navigateur que `/login`, et le jeton s'affiche dans le terminal après que vous ayez approuvé l'accès dans le navigateur. Il ne sauvegarde le jeton nulle part ; copiez-le et définissez-le en tant que variable d'environnement `CLAUDE_CODE_OAUTH_TOKEN` partout où vous souhaitez vous authentifier :301La commande ouvre le même flux d'autorisation du navigateur que `/login`, et le jeton s'affiche dans le terminal après que vous ayez approuvé l'accès dans le navigateur. Il ne sauvegarde le jeton nulle part ; copiez-le et définissez-le en tant que variable d'environnement `CLAUDE_CODE_OAUTH_TOKEN` partout où vous souhaitez vous authentifier :

302 302 

303**macOS, Linux, WSL**303> [tab] macOS, Linux, WSL

304 304>

305```bash theme={null}305> ```bash theme={null}

306export CLAUDE_CODE_OAUTH_TOKEN=your-token306> export CLAUDE_CODE_OAUTH_TOKEN=your-token

307```307> ```

308 308 

309**Windows PowerShell**309> [tab] Windows PowerShell

310 310>

311```powershell theme={null}311> ```powershell theme={null}

312$env:CLAUDE_CODE_OAUTH_TOKEN = "your-token"312> $env:CLAUDE_CODE_OAUTH_TOKEN = "your-token"

313```313> ```

314 314 

315**Windows CMD**315> [tab] Windows CMD

316 316>

317```batch theme={null}317> ```batch theme={null}

318set CLAUDE_CODE_OAUTH_TOKEN=your-token318> set CLAUDE_CODE_OAUTH_TOKEN=your-token

319```319> ```

320 320 

321Ce jeton s'authentifie avec votre abonnement Claude et nécessite un plan Pro, Max, Team ou Enterprise. Il ne peut faire que des requêtes de modèle, il ne peut donc pas établir de sessions [Remote Control](https://code.claude.com/docs/fr/remote-control.md) ou récupérer [les connecteurs claude.ai](https://code.claude.com/docs/fr/mcp.md#use-mcp-servers-from-claude-ai). Les serveurs MCP que vous configurez localement fonctionnent toujours.321Ce jeton s'authentifie avec votre abonnement Claude et nécessite un plan Pro, Max, Ultra, Team ou Enterprise. Il ne peut faire que des requêtes de modèle, il ne peut donc pas établir de sessions [Remote Control](https://code.claude.com/docs/fr/remote-control.md) ou récupérer [les connecteurs claude.ai](https://code.claude.com/docs/fr/mcp.md#use-mcp-servers-from-claude-ai). Les serveurs MCP que vous configurez localement fonctionnent toujours.

322 322 

323[Le mode bare](https://code.claude.com/docs/fr/headless.md#start-faster-with-bare-mode) ne lit pas `CLAUDE_CODE_OAUTH_TOKEN`. Si votre script passe `--bare`, authentifiez-vous avec `ANTHROPIC_API_KEY` ou un `apiKeyHelper` à la place.323[Le mode bare](https://code.claude.com/docs/fr/headless.md#start-faster-with-bare-mode) ne lit pas `CLAUDE_CODE_OAUTH_TOKEN`. Si votre script passe `--bare`, authentifiez-vous avec `ANTHROPIC_API_KEY` ou un `apiKeyHelper` à la place.

43 43 

44## Pourquoi la notification apparaît44## Pourquoi la notification apparaît

45 45 

46[L'examen du classificateur côté serveur](https://code.claude.com/docs/fr/permission-modes.md#server-side-classifier-review) répertorie les sessions qui demandent au serveur d'effectuer les vérifications du classificateur. Les plans Pro, Max et Team n'affichent jamais la notification. Lorsqu'elle apparaît, les causes habituelles sont :46Avec un plan Pro, Max, Ultra ou Team, vous ne voyez jamais la notification. Pour savoir quelles sessions demandent au serveur d'effectuer les vérifications du classificateur, consultez [L'examen du classificateur côté serveur](https://code.claude.com/docs/fr/permission-modes.md#server-side-classifier-review). Si vous voyez la notification, vérifiez ces causes habituelles :

47 47 

48* **Une passerelle LLM ou un proxy se trouve dans le chemin** : l'un qui supprime ou réécrit les en-têtes de requête, supprime les champs de requête qu'il ne reconnaît pas, ou modifie les réponses. Le serveur ne reçoit alors jamais la demande de vérifications, ou Claude Code ne reçoit jamais les résultats. Lorsque votre configuration ou les réponses identifient la passerelle, la notification la nomme.48* **Une passerelle LLM ou un proxy se trouve dans le chemin** : l'un qui supprime ou réécrit les en-têtes de requête, supprime les champs de requête qu'il ne reconnaît pas, ou modifie les réponses. Le serveur ne reçoit alors jamais la demande de vérifications, ou Claude Code ne reçoit jamais les résultats. Lorsque votre configuration ou les réponses identifient la passerelle, la notification la nomme.

49* **Les vérifications côté serveur n'ont pas encore atteint votre plateforme, région ou identifiant** : qu'une plateforme ou une région les effectue dépend du déploiement de cette plateforme. Si vous voyez la notification sans passerelle ou proxy dans le chemin et qu'elle continue d'apparaître, c'est la cause probable. Pour confirmer, contactez le support ou l'administrateur de votre entreprise, ou signalez-le avec `/feedback`.49* **Les vérifications côté serveur n'ont pas encore atteint votre plateforme, région ou identifiant** : qu'une plateforme ou une région les effectue dépend du déploiement de cette plateforme. Si vous voyez la notification sans passerelle ou proxy dans le chemin et qu'elle continue d'apparaître, c'est la cause probable. Pour confirmer, contactez le support ou l'administrateur de votre entreprise, ou signalez-le avec `/feedback`.

161 161 

162> [!NOTE]162> [!NOTE]

163>163>

164> `/auto-mode-setup` est disponible avec les forfaits Pro, Max, Team et Enterprise, ainsi qu'avec une clé API Claude Console. Avec un forfait Pro, Max ou Team, vous avez besoin de la v2.1.228 ou ultérieure, ou de la v2.1.233 ou ultérieure sous Windows natif. Avec un forfait Enterprise ou une clé API Claude Console, vous avez besoin de la v2.1.283 ou ultérieure. Si la commande est absente de votre session, consultez [`/auto-mode-setup` renvoie « Unknown command »](#auto-mode-setup-returns-unknown-command).164> `/auto-mode-setup` est disponible avec les forfaits Pro, Max, Ultra, Team et Enterprise, ainsi qu'avec une clé API Claude Console. Avec un forfait Pro, Max, Ultra ou Team, vous avez besoin de la v2.1.228 ou ultérieure, ou de la v2.1.233 ou ultérieure sous Windows natif. Avec un forfait Enterprise ou une clé API Claude Console, vous avez besoin de la v2.1.283 ou ultérieure. Si la commande est absente de votre session, consultez [`/auto-mode-setup` renvoie « Unknown command »](#auto-mode-setup-returns-unknown-command).

165 165 

166### Ce que lit `/auto-mode-setup`166### Ce que lit `/auto-mode-setup`

167 167 

489 489 

490Avec une fenêtre de 1M de tokens sur la plupart des modèles actuels et une compaction proche de sa limite, vous manquerez rarement de contexte. Vous pouvez cependant toujours *payer* pour du contexte dont vous n'avez pas besoin. Chaque requête envoie toute la conversation, donc une session qui a accumulé trois tâches sans rapport relit les trois à chaque tour de la quatrième. C'est [à prix réduit tant que le cache est chaud](https://code.claude.com/docs/fr/costs.md#why-usage-climbs-in-a-long-session) et à plein tarif une fois qu'il a expiré.490Avec une fenêtre de 1M de tokens sur la plupart des modèles actuels et une compaction proche de sa limite, vous manquerez rarement de contexte. Vous pouvez cependant toujours *payer* pour du contexte dont vous n'avez pas besoin. Chaque requête envoie toute la conversation, donc une session qui a accumulé trois tâches sans rapport relit les trois à chaque tour de la quatrième. C'est [à prix réduit tant que le cache est chaud](https://code.claude.com/docs/fr/costs.md#why-usage-climbs-in-a-long-session) et à plein tarif une fois qu'il a expiré.

491 491 

492[`/usage`](https://code.claude.com/docs/fr/costs) est le premier endroit où regarder. Sur Pro, Max, Team et Enterprise, il ventile votre utilisation par skill, sous-agent, plugin et serveur MCP. Il signale aussi des tendances comme un contexte long ou des défauts de cache fréquents dès que l'une d'elles dépasse 10 % de votre utilisation. À partir de là, les solutions habituelles :492[`/usage`](https://code.claude.com/docs/fr/costs) est le premier endroit où regarder. Sur Pro, Max, Ultra, Team et Enterprise, il ventile votre utilisation par skill, sous-agent, plugin et serveur MCP. Il signale aussi des tendances comme un contexte long ou des défauts de cache fréquents dès que l'une d'elles dépasse 10 % de votre utilisation. À partir de là, les solutions habituelles :

493 493 

494* `/clear` entre des tâches sans rapport. Cela ne coûte rien, et la tâche suivante ne continue pas à payer pour l'historique de la précédente. `/clear oauth-migration` nomme la session que vous quittez, afin que vous puissiez y revenir plus tard.494* `/clear` entre des tâches sans rapport. Cela ne coûte rien, et la tâche suivante ne continue pas à payer pour l'historique de la précédente. `/clear oauth-migration` nomme la session que vous quittez, afin que vous puissiez y revenir plus tard.

495* `/compact` avec un objectif, comme `/compact keep the API changes and the test commands`. Sur une longue session, `/compact` est lui-même une grosse requête, puisqu'il lit toute la conversation pour la résumer, et plus encore une fois le cache expiré.495* `/compact` avec un objectif, comme `/compact keep the API changes and the test commands`. Sur une longue session, `/compact` est lui-même une grosse requête, puisqu'il lit toute la conversation pour la résumer, et plus encore une fois le cache expiré.

24 24 

25Chaque canal pris en charge est un plugin qui nécessite [Bun](https://bun.sh). Pour une démonstration pratique du flux de plugin avant de connecter une plateforme réelle, essayez le [démarrage rapide fakechat](#quickstart).25Chaque canal pris en charge est un plugin qui nécessite [Bun](https://bun.sh). Pour une démonstration pratique du flux de plugin avant de connecter une plateforme réelle, essayez le [démarrage rapide fakechat](#quickstart).

26 26 

27**Telegram**27> [tab] Telegram

28 

29Consultez la [source complète du plugin Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram).

30 

31**1. Créer un bot Telegram**

32 

33Ouvrez [BotFather](https://t.me/BotFather) dans Telegram et envoyez `/newbot`. Donnez-lui un nom d'affichage et un nom d'utilisateur unique se terminant par `bot`. Copiez le jeton que BotFather retourne.

34 

35**2. Installer le plugin**

36 

37Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

38 

39```

40/plugin install telegram@claude-plugins-official

41```

42 

43Si l'installation échoue, faites correspondre le message que Claude Code signale :

44 

45* `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

46* `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

47 

48Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets. Vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to apply.`, consultez [Appliquer les modifications de plugin sans redémarrer](https://code.claude.com/docs/fr/plugins/cli-reference.md#reload-plugins) pour rendre la commande de configuration du plugin disponible.

49 

50**3. Configurer votre jeton**

51 

52Exécutez la commande de configuration avec le jeton de BotFather :

53 

54```

55/telegram:configure <token>

56```

57 

58Cela l'enregistre dans `~/.claude/channels/telegram/.env`. Vous pouvez également définir `TELEGRAM_BOT_TOKEN` dans votre environnement shell avant de lancer Claude Code.

59 

60**4. Redémarrer avec les canaux activés**

61 

62Quittez Claude Code et redémarrez avec le flag de canal. Cela démarre le plugin Telegram, qui commence à interroger les messages de votre bot :

63 

64```bash theme={null}

65claude --channels plugin:telegram@claude-plugins-official

66```

67 

68**5. Appairer votre compte**

69 

70Ouvrez Telegram et envoyez n'importe quel message à votre bot. Le bot répond avec un code d'appairage.

71 

72> [!NOTE]

73>28>

74> Si votre bot ne répond pas, assurez-vous que Claude Code s'exécute avec `--channels` à partir de l'étape précédente. Le bot ne peut répondre que lorsque le canal est actif.29> Consultez la [source complète du plugin Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram).

75 

76De retour dans Claude Code, exécutez :

77 

78```

79/telegram:access pair <code>

80```

81 

82Ensuite, verrouillez l'accès pour que seul votre compte puisse envoyer des messages :

83 

84```

85/telegram:access policy allowlist

86```

87 

88**Discord**

89 

90Consultez la [source complète du plugin Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord).

91 

92**1. Créer un bot Discord**

93 

94Allez au [Portail des développeurs Discord](https://discord.com/developers/applications), cliquez sur **New Application** et nommez-le. Dans la section **Bot**, créez un nom d'utilisateur, puis cliquez sur **Reset Token** et copiez le jeton.

95 

96**2. Activer Message Content Intent**

97 

98Dans les paramètres de votre bot, faites défiler jusqu'à **Privileged Gateway Intents** et activez **Message Content Intent**.

99 

100**3. Inviter le bot à votre serveur**

101 

102Allez à **OAuth2 > URL Generator**. Sélectionnez la portée `bot` et activez ces permissions :

103 

104* View Channels

105* Send Messages

106* Send Messages in Threads

107* Read Message History

108* Attach Files

109* Add Reactions

110 

111Ouvrez l'URL générée pour ajouter le bot à votre serveur.

112 

113**4. Installer le plugin**

114 

115Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

116 

117```

118/plugin install discord@claude-plugins-official

119```

120 

121Si l'installation échoue, faites correspondre le message que Claude Code signale :

122 

123* `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

124* `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

125 

126Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets. Vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to apply.`, consultez [Appliquer les modifications de plugin sans redémarrer](https://code.claude.com/docs/fr/plugins/cli-reference.md#reload-plugins) pour rendre la commande de configuration du plugin disponible.

127 

128**5. Configurer votre jeton**

129 

130Exécutez la commande de configuration avec le jeton du bot que vous avez copié :

131 

132```

133/discord:configure <token>

134```

135 

136Cela l'enregistre dans `~/.claude/channels/discord/.env`. Vous pouvez également définir `DISCORD_BOT_TOKEN` dans votre environnement shell avant de lancer Claude Code.

137 

138**6. Redémarrer avec les canaux activés**

139 

140Quittez Claude Code et redémarrez avec le flag de canal. Cela connecte le plugin Discord pour que votre bot puisse recevoir et répondre aux messages :

141 

142```bash theme={null}

143claude --channels plugin:discord@claude-plugins-official

144```

145 

146**7. Appairer votre compte**

147 

148Envoyez un DM à votre bot sur Discord. Le bot répond avec un code d'appairage.

149 

150> [!NOTE]

151>30>

152> Si votre bot ne répond pas, assurez-vous que Claude Code s'exécute avec `--channels` à partir de l'étape précédente. Le bot ne peut répondre que lorsque le canal est actif.31> **1. Créer un bot Telegram**

153 

154De retour dans Claude Code, exécutez :

155 

156```

157/discord:access pair <code>

158```

159 

160Ensuite, verrouillez l'accès pour que seul votre compte puisse envoyer des messages :

161 

162```

163/discord:access policy allowlist

164```

165 

166**iMessage**

167 

168Consultez la [source complète du plugin iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage).

169 

170Le canal iMessage lit votre base de données Messages directement et envoie les réponses via AppleScript. Il nécessite macOS et n'a besoin d'aucun jeton de bot ou service externe.

171 

172**1. Accorder l'accès complet au disque**

173 

174La base de données Messages à `~/Library/Messages/chat.db` est protégée par macOS. La première fois que le serveur la lit, macOS demande l'accès : cliquez sur **Allow**. L'invite nomme l'application qui a lancé Bun, comme Terminal, iTerm ou votre IDE.

175 

176Si l'invite n'apparaît pas ou si vous avez cliqué sur Don't Allow, accordez l'accès manuellement sous **System Settings > Privacy & Security > Full Disk Access** et ajoutez votre terminal. Sans cela, le serveur se ferme immédiatement avec `authorization denied`.

177 

178**2. Installer le plugin**

179 

180Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

181 

182```

183/plugin install imessage@claude-plugins-official

184```

185 

186Si l'installation échoue, faites correspondre le message que Claude Code signale :

187 

188* `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

189* `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

190 

191Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets.

192 

193Si le résumé d'installation signale `Run /reload-plugins to apply.`, vous pouvez ignorer cela ici, car le redémarrage à l'étape suivante récupère le plugin.

194 

195**3. Redémarrer avec les canaux activés**

196 

197Quittez Claude Code et redémarrez avec le flag de canal :

198 

199```bash theme={null}

200claude --channels plugin:imessage@claude-plugins-official

201```

202 

203**4. Vous envoyer un message**

204 

205Ouvrez Messages sur n'importe quel appareil connecté à votre Apple ID et envoyez-vous un message. Il atteint Claude immédiatement : l'auto-chat contourne le contrôle d'accès sans configuration.

206 

207> [!NOTE]

208>32>

209> La première réponse que Claude envoie déclenche une invite d'automatisation macOS demandant si votre terminal peut contrôler Messages. Cliquez sur **OK**.33> Ouvrez [BotFather](https://t.me/BotFather) dans Telegram et envoyez `/newbot`. Donnez-lui un nom d'affichage et un nom d'utilisateur unique se terminant par `bot`. Copiez le jeton que BotFather retourne.

210 34>

211**5. Autoriser d'autres expéditeurs**35> **2. Installer le plugin**

212 36>

213Par défaut, seuls vos propres messages passent. Pour laisser un autre contact atteindre Claude, ajoutez son identifiant :37> Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

38>

39> ```

40> /plugin install telegram@claude-plugins-official

41> ```

42>

43> Si l'installation échoue, faites correspondre le message que Claude Code signale :

44>

45> * `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

46> * `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

47>

48> Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets. Vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to apply.`, consultez [Appliquer les modifications de plugin sans redémarrer](https://code.claude.com/docs/fr/plugins/cli-reference.md#reload-plugins) pour rendre la commande de configuration du plugin disponible.

49>

50> **3. Configurer votre jeton**

51>

52> Exécutez la commande de configuration avec le jeton de BotFather :

53>

54> ```

55> /telegram:configure <token>

56> ```

57>

58> Cela l'enregistre dans `~/.claude/channels/telegram/.env`. Vous pouvez également définir `TELEGRAM_BOT_TOKEN` dans votre environnement shell avant de lancer Claude Code.

59>

60> **4. Redémarrer avec les canaux activés**

61>

62> Quittez Claude Code et redémarrez avec le flag de canal. Cela démarre le plugin Telegram, qui commence à interroger les messages de votre bot :

63>

64> ```bash theme={null}

65> claude --channels plugin:telegram@claude-plugins-official

66> ```

67>

68> **5. Appairer votre compte**

69>

70> Ouvrez Telegram et envoyez n'importe quel message à votre bot. Le bot répond avec un code d'appairage.

71>

72> > [!NOTE]

73> >

74> > Si votre bot ne répond pas, assurez-vous que Claude Code s'exécute avec `--channels` à partir de l'étape précédente. Le bot ne peut répondre que lorsque le canal est actif.

75>

76> De retour dans Claude Code, exécutez :

77>

78> ```

79> /telegram:access pair <code>

80> ```

81>

82> Ensuite, verrouillez l'accès pour que seul votre compte puisse envoyer des messages :

83>

84> ```

85> /telegram:access policy allowlist

86> ```

214 87 

215```88> [tab] Discord

216/imessage:access allow +1555123456789>

217```90> Consultez la [source complète du plugin Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord).

91>

92> **1. Créer un bot Discord**

93>

94> Allez au [Portail des développeurs Discord](https://discord.com/developers/applications), cliquez sur **New Application** et nommez-le. Dans la section **Bot**, créez un nom d'utilisateur, puis cliquez sur **Reset Token** et copiez le jeton.

95>

96> **2. Activer Message Content Intent**

97>

98> Dans les paramètres de votre bot, faites défiler jusqu'à **Privileged Gateway Intents** et activez **Message Content Intent**.

99>

100> **3. Inviter le bot à votre serveur**

101>

102> Allez à **OAuth2 > URL Generator**. Sélectionnez la portée `bot` et activez ces permissions :

103>

104> * View Channels

105> * Send Messages

106> * Send Messages in Threads

107> * Read Message History

108> * Attach Files

109> * Add Reactions

110>

111> Ouvrez l'URL générée pour ajouter le bot à votre serveur.

112>

113> **4. Installer le plugin**

114>

115> Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

116>

117> ```

118> /plugin install discord@claude-plugins-official

119> ```

120>

121> Si l'installation échoue, faites correspondre le message que Claude Code signale :

122>

123> * `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

124> * `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

125>

126> Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets. Vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to apply.`, consultez [Appliquer les modifications de plugin sans redémarrer](https://code.claude.com/docs/fr/plugins/cli-reference.md#reload-plugins) pour rendre la commande de configuration du plugin disponible.

127>

128> **5. Configurer votre jeton**

129>

130> Exécutez la commande de configuration avec le jeton du bot que vous avez copié :

131>

132> ```

133> /discord:configure <token>

134> ```

135>

136> Cela l'enregistre dans `~/.claude/channels/discord/.env`. Vous pouvez également définir `DISCORD_BOT_TOKEN` dans votre environnement shell avant de lancer Claude Code.

137>

138> **6. Redémarrer avec les canaux activés**

139>

140> Quittez Claude Code et redémarrez avec le flag de canal. Cela connecte le plugin Discord pour que votre bot puisse recevoir et répondre aux messages :

141>

142> ```bash theme={null}

143> claude --channels plugin:discord@claude-plugins-official

144> ```

145>

146> **7. Appairer votre compte**

147>

148> Envoyez un DM à votre bot sur Discord. Le bot répond avec un code d'appairage.

149>

150> > [!NOTE]

151> >

152> > Si votre bot ne répond pas, assurez-vous que Claude Code s'exécute avec `--channels` à partir de l'étape précédente. Le bot ne peut répondre que lorsque le canal est actif.

153>

154> De retour dans Claude Code, exécutez :

155>

156> ```

157> /discord:access pair <code>

158> ```

159>

160> Ensuite, verrouillez l'accès pour que seul votre compte puisse envoyer des messages :

161>

162> ```

163> /discord:access policy allowlist

164> ```

218 165 

219Les identifiants sont des numéros de téléphone au format `+country` ou des e-mails Apple ID comme `user@example.com`.166> [tab] iMessage

167>

168> Consultez la [source complète du plugin iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage).

169>

170> Le canal iMessage lit votre base de données Messages directement et envoie les réponses via AppleScript. Il nécessite macOS et n'a besoin d'aucun jeton de bot ou service externe.

171>

172> **1. Accorder l'accès complet au disque**

173>

174> La base de données Messages à `~/Library/Messages/chat.db` est protégée par macOS. La première fois que le serveur la lit, macOS demande l'accès : cliquez sur **Allow**. L'invite nomme l'application qui a lancé Bun, comme Terminal, iTerm ou votre IDE.

175>

176> Si l'invite n'apparaît pas ou si vous avez cliqué sur Don't Allow, accordez l'accès manuellement sous **System Settings > Privacy & Security > Full Disk Access** et ajoutez votre terminal. Sans cela, le serveur se ferme immédiatement avec `authorization denied`.

177>

178> **2. Installer le plugin**

179>

180> Démarrez Claude Code en exécutant `claude` dans votre terminal, puis saisissez ceci à son invite :

181>

182> ```

183> /plugin install imessage@claude-plugins-official

184> ```

185>

186> Si l'installation échoue, faites correspondre le message que Claude Code signale :

187>

188> * `Marketplace "claude-plugins-official" not found` : ajoutez la marketplace avec `/plugin marketplace add anthropics/claude-plugins-official`, puis réessayez l'installation.

189> * `Plugin "<name>" not found in marketplace "claude-plugins-official"` : votre copie locale du catalogue de la marketplace est peut-être obsolète. Actualisez-la avec `/plugin marketplace update claude-plugins-official`, puis réessayez l'installation. Si la nouvelle tentative affiche le même message, consultez [Plugin introuvable dans la marketplace](https://code.claude.com/docs/fr/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

190>

191> Lorsque l'installation vous demande une portée d'installation, choisissez l'option de portée utilisateur pour que le plugin soit disponible dans tous vos projets.

192>

193> Si le résumé d'installation signale `Run /reload-plugins to apply.`, vous pouvez ignorer cela ici, car le redémarrage à l'étape suivante récupère le plugin.

194>

195> **3. Redémarrer avec les canaux activés**

196>

197> Quittez Claude Code et redémarrez avec le flag de canal :

198>

199> ```bash theme={null}

200> claude --channels plugin:imessage@claude-plugins-official

201> ```

202>

203> **4. Vous envoyer un message**

204>

205> Ouvrez Messages sur n'importe quel appareil connecté à votre Apple ID et envoyez-vous un message. Il atteint Claude immédiatement : l'auto-chat contourne le contrôle d'accès sans configuration.

206>

207> > [!NOTE]

208> >

209> > La première réponse que Claude envoie déclenche une invite d'automatisation macOS demandant si votre terminal peut contrôler Messages. Cliquez sur **OK**.

210>

211> **5. Autoriser d'autres expéditeurs**

212>

213> Par défaut, seuls vos propres messages passent. Pour laisser un autre contact atteindre Claude, ajoutez son identifiant :

214>

215> ```

216> /imessage:access allow +15551234567

217> ```

218>

219> Les identifiants sont des numéros de téléphone au format `+country` ou des e-mails Apple ID comme `user@example.com`.

220 220 

221## Démarrage rapide221## Démarrage rapide

222 222 

308| `channelsEnabled` | Commutateur maître. Doit être `true` pour que tout canal puisse livrer des messages. Bloque tous les canaux, y compris l'indicateur de développement lorsqu'il est désactivé. Voir [Activer les canaux pour votre organisation](#enable-channels-for-your-organization). | claude.ai Team et Enterprise : canaux bloqués. Console : canaux autorisés sauf si votre organisation déploie des paramètres gérés, auquel cas les canaux sont bloqués jusqu'à ce que cette clé soit définie |308| `channelsEnabled` | Commutateur maître. Doit être `true` pour que tout canal puisse livrer des messages. Bloque tous les canaux, y compris l'indicateur de développement lorsqu'il est désactivé. Voir [Activer les canaux pour votre organisation](#enable-channels-for-your-organization). | claude.ai Team et Enterprise : canaux bloqués. Console : canaux autorisés sauf si votre organisation déploie des paramètres gérés, auquel cas les canaux sont bloqués jusqu'à ce que cette clé soit définie |

309| `allowedChannelPlugins` | Quels plugins peuvent s'enregistrer une fois les canaux activés. Remplace la liste maintenue par Anthropic lorsqu'elle est définie. | La liste par défaut d'Anthropic s'applique |309| `allowedChannelPlugins` | Quels plugins peuvent s'enregistrer une fois les canaux activés. Remplace la liste maintenue par Anthropic lorsqu'elle est définie. | La liste par défaut d'Anthropic s'applique |

310 310 

311Les utilisateurs Pro et Max sans organisation ignorent complètement ces vérifications : les canaux sont disponibles et les utilisateurs optent pour chaque session avec `--channels`.311Les utilisateurs Pro, Max et Ultra sans organisation ignorent complètement ces vérifications : les canaux sont disponibles et les utilisateurs optent pour chaque session avec `--channels`.

312 312 

313### Activer les canaux pour votre organisation313### Activer les canaux pour votre organisation

314 314 

39* [Google Chrome](https://www.google.com/chrome/), [Microsoft Edge](https://www.microsoft.com/edge) ou un autre navigateur basé sur Chromium tel que Brave, Arc, Vivaldi ou Opera39* [Google Chrome](https://www.google.com/chrome/), [Microsoft Edge](https://www.microsoft.com/edge) ou un autre navigateur basé sur Chromium tel que Brave, Arc, Vivaldi ou Opera

40* Extension [Claude in Chrome](https://chromewebstore.google.com/detail/claude/fcoeoabgfenejglbffodgkkbkcdhcgfn) version 1.0.36 ou supérieure, disponible dans le Chrome Web Store40* Extension [Claude in Chrome](https://chromewebstore.google.com/detail/claude/fcoeoabgfenejglbffodgkkbkcdhcgfn) version 1.0.36 ou supérieure, disponible dans le Chrome Web Store

41* [Claude Code](https://code.claude.com/docs/fr/quickstart.md#step-1-install-claude-code)41* [Claude Code](https://code.claude.com/docs/fr/quickstart.md#step-1-install-claude-code)

42* Un plan Anthropic direct (Pro, Max, Team ou Enterprise)42* Un plan Anthropic direct (Pro, Max, Ultra, Team ou Enterprise)

43 43 

44Dans les organisations Enterprise pour lesquelles HIPAA est activé, Claude in Chrome est désactivé par défaut, et un [Owner](https://code.claude.com/docs/fr/server-managed-settings.md#access-control) peut l'activer dans [**Organization settings > Claude in Chrome**](https://claude.ai/admin-settings/browser-extension). Votre Business Associate Agreement (BAA) avec Anthropic ne couvre pas les données envoyées à des sites tiers via Claude in Chrome. Consultez l'[Implementation Guide](https://trust.anthropic.com/resources?s=l1wrssd9hsbi4gak0tp5a6\&name=%5Banthropic%5D-hipaa-ready-offering-implementation-guide) pour obtenir la liste des Eligible Services.44Dans les organisations Enterprise pour lesquelles HIPAA est activé, Claude in Chrome est désactivé par défaut, et un [Owner](https://code.claude.com/docs/fr/server-managed-settings.md#access-control) peut l'activer dans [**Organization settings > Claude in Chrome**](https://claude.ai/admin-settings/browser-extension). Votre Business Associate Agreement (BAA) avec Anthropic ne couvre pas les données envoyées à des sites tiers via Claude in Chrome. Consultez l'[Implementation Guide](https://trust.anthropic.com/resources?s=l1wrssd9hsbi4gak0tp5a6\&name=%5Banthropic%5D-hipaa-ready-offering-implementation-guide) pour obtenir la liste des Eligible Services.

45 45 

325 325 

326**7. Déployer**326**7. Déployer**

327 327 

328**ECS Fargate**328> [tab] ECS Fargate

329 329>

330Créez le cluster et un groupe de journaux pour la sortie d'erreur standard de la passerelle, qui porte à la fois ses événements d'audit et ses journaux opérationnels. La rétention est un appel séparé, et sans elle CloudWatch garde les journaux pour toujours ; alignez les 90 jours avec votre politique de rétention d'audit :330> Créez le cluster et un groupe de journaux pour la sortie d'erreur standard de la passerelle, qui porte à la fois ses événements d'audit et ses journaux opérationnels. La rétention est un appel séparé, et sans elle CloudWatch garde les journaux pour toujours ; alignez les 90 jours avec votre politique de rétention d'audit :

331 331>

332```bash theme={null}332> ```bash theme={null}

333aws ecs create-cluster --cluster-name claude-gateway333> aws ecs create-cluster --cluster-name claude-gateway

334aws logs create-log-group --log-group-name /ecs/claude-gateway334> aws logs create-log-group --log-group-name /ecs/claude-gateway

335aws logs put-retention-policy --log-group-name /ecs/claude-gateway \335> aws logs put-retention-policy --log-group-name /ecs/claude-gateway \

336 --retention-in-days 90336> --retention-in-days 90

337```337> ```

338 338>

339Écrivez la définition de tâche. Le rôle de tâche porte la permission Bedrock et le rôle d'exécution injecte les secrets ; utilisez les ARN de secret de l'étape Secrets Manager :339> Écrivez la définition de tâche. Le rôle de tâche porte la permission Bedrock et le rôle d'exécution injecte les secrets ; utilisez les ARN de secret de l'étape Secrets Manager :

340 340>

341```json claude-gateway-task.json theme={null}341> ```json claude-gateway-task.json theme={null}

342{342> {

343 "family": "claude-gateway",343> "family": "claude-gateway",

344 "networkMode": "awsvpc",344> "networkMode": "awsvpc",

345 "requiresCompatibilities": ["FARGATE"],345> "requiresCompatibilities": ["FARGATE"],

346 "cpu": "1024",346> "cpu": "1024",

347 "memory": "2048",347> "memory": "2048",

348 "runtimePlatform": { "cpuArchitecture": "X86_64", "operatingSystemFamily": "LINUX" },348> "runtimePlatform": { "cpuArchitecture": "X86_64", "operatingSystemFamily": "LINUX" },

349 "executionRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-execution",349> "executionRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-execution",

350 "taskRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-task",350> "taskRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-task",

351 "containerDefinitions": [351> "containerDefinitions": [

352 {352> {

353 "name": "gateway",353> "name": "gateway",

354 "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/claude-gateway:<version>",354> "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/claude-gateway:<version>",

355 "portMappings": [{ "containerPort": 8080 }],355> "portMappings": [{ "containerPort": 8080 }],

356 "secrets": [356> "secrets": [

357 { "name": "GATEWAY_JWT_SECRET", "valueFrom": "<gateway-jwt-secret ARN>" },357> { "name": "GATEWAY_JWT_SECRET", "valueFrom": "<gateway-jwt-secret ARN>" },

358 { "name": "OIDC_CLIENT_SECRET", "valueFrom": "<gateway-oidc-client-secret ARN>" },358> { "name": "OIDC_CLIENT_SECRET", "valueFrom": "<gateway-oidc-client-secret ARN>" },

359 { "name": "GATEWAY_POSTGRES_URL", "valueFrom": "<gateway-postgres-url ARN>" }359> { "name": "GATEWAY_POSTGRES_URL", "valueFrom": "<gateway-postgres-url ARN>" }

360 ],360> ],

361 "logConfiguration": {361> "logConfiguration": {

362 "logDriver": "awslogs",362> "logDriver": "awslogs",

363 "options": {363> "options": {

364 "awslogs-group": "/ecs/claude-gateway",364> "awslogs-group": "/ecs/claude-gateway",

365 "awslogs-region": "<region>",365> "awslogs-region": "<region>",

366 "awslogs-stream-prefix": "gateway"366> "awslogs-stream-prefix": "gateway"

367 }367> }

368 }368> }

369 }369> }

370 ]370> ]

371}371> }

372```372> ```