---
title: Référence des workers auto-hébergés
url: https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference
description: "Référence pour les workers de sandbox auto-hébergés : options de la CLI ant, variables d'environnement, exigences de l'hôte, chemins du système de fichiers et options des helpers du SDK."
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
---

Cette page documente les workers préconstruits qui desservent un environnement `self_hosted`. Pour des guides orientés tâches, commencez par [Sandboxes auto-hébergées](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes) et [Déployer des workers auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers).

## Commandes et options de la CLI

| Commande | Description |
| ----- | ----- |
| `ant beta:worker poll` | Réclame des éléments de travail dans la file d’attente de l’environnement et exécute chaque session dans le processus. Avec `--on-work`, appelle plutôt votre script pour chaque élément de travail. |
| `ant beta:worker run` | Traite une session réclamée puis se termine. Utilisez-la comme point d’entrée d’une sandbox par session. |

| Option | Description |
| ----- | ----- |
| `--environment-id` | L’environnement à interroger pour obtenir du travail. Lit également `ANTHROPIC_ENVIRONMENT_ID`. |
| `--environment-key` | Authentifie le worker auprès de cet environnement. Lit également `ANTHROPIC_ENVIRONMENT_KEY`. |
| `--workdir` | Répertoire dans lequel le worker télécharge les skills et où les outils lisent et écrivent des fichiers. La valeur par défaut est `.` (le répertoire courant). Le répertoire doit exister avant le démarrage du worker. |
| `--on-work` | Script à appeler pour chaque élément de travail réclamé au lieu d’exécuter les outils dans le processus. Reçoit les détails de la session sous forme de variables d’environnement et l’élément de travail au format JSON sur l’entrée standard. |
| `--max-idle` | Durée pendant laquelle le worker attend lorsqu’une session est inactive avant que `ant beta:worker run` ne se termine ou que `ant beta:worker poll` ne passe à l’élément de travail suivant. Le temps d’inactivité avec une [raison d’arrêt `requires_action`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) n’est pas comptabilisé. La valeur par défaut est `60s`. Définissez-la sur `0` pour désactiver le délai d’expiration. Avec un script `--on-work`, `ant beta:worker poll` ignore cette option. Transmettez-la plutôt à la commande `ant beta:worker run` que votre script lance. |
| `--log-format` | Format de sortie des journaux. Utilisez `json` pour l’ingestion de journaux structurés. La valeur par défaut est `text`. |

## Variables d’environnement

| Variable | Description | Définie par |
| ----- | ----- | ----- |
| `ANTHROPIC_ENVIRONMENT_ID` | L’environnement dont le worker dessert la file d’attente. | Vous, sur l’hôte du worker. Le poller la transmet au script `--on-work`. |
| `ANTHROPIC_ENVIRONMENT_KEY` | Authentifie le worker auprès de sa file d’attente. | Vous, sur l’hôte du worker. Le poller la transmet au script `--on-work`. |
| `ANTHROPIC_SESSION_ID` | La session que représente un élément de travail réclamé. | Le poller, pour le script `--on-work`. |
| `ANTHROPIC_WORK_ID` | L’élément de travail réclamé. | Le poller, pour le script `--on-work`. |
| `ANTHROPIC_WORK_SECRET` | Le secret de l’élément de travail pour sa session. | Vous. Le poller ne la définit pas. Consultez [Transmettre le secret de l’élément de travail](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret). |
| `ANTHROPIC_BASE_URL` | Remplace le point de terminaison de l’API par défaut. Facultative. | Vous, sur l’hôte du worker. |
| `ANTHROPIC_WEBHOOK_SIGNING_KEY` | Vérifie les charges utiles des webhooks entrants. | Vous, sur un hôte de gestionnaire de webhooks. |

## Exigences de l’hôte

| Worker | Exigence |
| ----- | ----- |
| Tous les workers | Un hôte Linux ou macOS avec `/bin/bash` à ce chemin exact. L’outil `bash` du worker l’exécute directement, sans consulter `PATH`. Sur macOS, il s’agit du Bash 3.2 du système. |
| SDK TypeScript | `unzip` et `tar` dans le `PATH`, et Node.js 22 ou version ultérieure. |
| SDK Python et Go | Aucun binaire supplémentaire. Ces SDK utilisent leurs bibliothèques standard pour l’extraction des archives. |

Les [magasins de mémoire](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#requirements) ajoutent leurs propres exigences.

Sur macOS, le volume racine est en lecture seule, de sorte que `mkdir` ne peut pas créer `/workspace`. Définissez le répertoire de travail du worker sur un répertoire dans lequel vous pouvez écrire, par exemple un répertoire `workspace` dans votre répertoire personnel. Pour utiliser des magasins de mémoire sur macOS, commencez par [préparer l’hôte macOS](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#prepare-a-macos-host).

## Système de fichiers de la sandbox

| Chemin | Contenu |
| ----- | ----- |
| `/workspace` | Le répertoire de travail utilisé dans les exemples des pages sur les sandboxes auto-hébergées. Ce n’est pas la valeur par défaut du worker : le worker utilise le répertoire courant, sauf si vous définissez `--workdir` ou `workdir` (go: `Workdir`). Les sandboxes cloud d’Anthropic conservent les skills et les dépôts dans `/workspace`. Si vous utilisez un répertoire de travail différent, mettez à jour l’invite système de votre agent afin que Claude puisse localiser les fichiers des skills. |
| `<workdir>/skills/<name>/` | Les skills téléchargées de l’agent. |
| `/mnt/memory/<store>/` | Une copie locale de chaque magasin de mémoire attaché, un répertoire par magasin. L’API renvoie le chemin complet de chaque répertoire dans le champ `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) de la ressource de magasin de mémoire de la session (par exemple, `/mnt/memory/user-preferences/`). |

Le worker crée les répertoires des magasins de mémoire lorsqu’il réclame une session. Il les supprime lorsqu’il en a terminé avec cette session ou lorsque vous [arrêtez le worker proprement](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-operations#stop-workers-gracefully). Cela ne supprime que les copies locales, et les mémoires restent dans le magasin.

Les skills peuvent inclure des exécutables que l’agent peut lancer directement. Les workers de la CLI et du SDK préservent les permissions d’exécution enregistrées dans le bundle de la skill lors de son extraction. Si vous téléchargez vous-même les skills, définissez vous-même leurs permissions d’exécution.

### Quand le worker en a terminé avec une session

Le worker en a terminé avec une session dans l’un des cas suivants :

* La session se termine.
* Vous [arrêtez l’élément de travail de la session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-operations#stop-a-session-gracefully).
* La session reste inactive pendant la durée de la limite d’inactivité du worker. La session elle-même reste ouverte. Lorsque vous lui envoyez ensuite un nouvel événement, tel qu’un message utilisateur, le même worker ou un autre la réclame. Ce worker télécharge à nouveau les magasins.

La limite d’inactivité est de 60 secondes par défaut. Pour la modifier, utilisez [`--max-idle`](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#cli-commands-and-flags) pour le worker de la CLI `ant` ou [`max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`)](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#environment-worker) pour `EnvironmentWorker`. Le [chart Helm `cma-sandboxes`](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes) démarre plutôt ses workers avec une limite de 30 minutes. Pour modifier cette limite, modifiez le paramètre `sandbox.idleTimeout` du chart.

### Livrables finaux

Les sandboxes auto-hébergées n’ont pas de répertoire `/mnt/session/outputs`. Dans les sandboxes cloud d’Anthropic, l’invite système de la session indique à l’agent d’y copier les livrables finaux. Dans les environnements auto-hébergés, l’invite système omet cette instruction. Les livrables finaux restent là où l’agent les écrit, généralement sous le répertoire de travail, et le worker ne les téléverse pas.

Pour rassembler les livrables finaux en un seul endroit, indiquez le chemin complet d’un répertoire dans l’invite système de votre agent. Choisissez un répertoire dans lequel les outils de fichiers du worker peuvent écrire :

* **À l’intérieur du répertoire de travail :** par exemple, `/workspace/outputs` si le répertoire de travail est `/workspace`.
* **N’importe où ailleurs, avec un worker du SDK uniquement :** ajoutez le répertoire à `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`). Consultez [AgentToolContext et l’ensemble d’outils de l’agent](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#agent-tool-context-and-the-agent-toolset).

## Helpers du SDK

Les SDK Python, TypeScript et Go fournissent trois helpers offrant différents niveaux de contrôle :

| Helper | Ce qu’il fait | Quand l’utiliser |
| ----- | ----- | ----- |
| [`EnvironmentWorker`](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#environment-worker) | Gère l’interrogation, la configuration et l’exécution des outils de bout en bout. | Dans la plupart des cas. |
| [`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`)](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#work-poller) | Interroge la file d’attente de travail et vous fournit chaque session réclamée. | Vous déterminez comment traiter chaque session, par exemple en lançant une sandbox plutôt qu’en exécutant les outils dans le processus. |
| [`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`)](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#session-tool-runner) | Exécute les appels d’outils pour une seule session, à partir de l’ID de session et d’une liste d’outils. | Vous avez déjà réclamé le travail et n’avez besoin que d’exécuter les outils. |

### EnvironmentWorker

| Méthode | Description |
| ----- | ----- |
| `run()` (go: `Run()`) | S’exécute indéfiniment, en prenant en charge les sessions à mesure qu’elles arrivent. |
| `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) | Traite un élément de travail déjà réclamé par un poller. Le poller peut être `ant beta:worker poll --on-work` ou votre propre code. La méthode retourne lorsque le worker en a terminé avec la session de l’élément. Vous pouvez transmettre `work_id` (typescript: `workId`; go: `WorkID`), `session_id` (typescript: `sessionId`; go: `SessionID`), `environment_id` (typescript: `environmentId`; go: `EnvironmentID`) et `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Pour chacun de ceux que vous omettez, la méthode lit la [variable `ANTHROPIC_*`](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference#environment-variables) correspondante. |

| Option | Description |
| ----- | ----- |
| `tools` (go: `ToolsFunc`) | Une fabrique qui reçoit l’`AgentToolContext` de la session et renvoie la liste d’outils. Par défaut, il s’agit de l’ensemble d’outils standard de l’agent. |
| `max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`) | Durée pendant laquelle le worker attend lorsqu’une session est inactive avant d’en avoir terminé avec la session. Le temps d’inactivité avec une [raison d’arrêt `requires_action`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) n’est pas comptabilisé. La valeur par défaut est de 60 secondes. Pour attendre 5 minutes, définissez-la sur `300` (typescript: `300_000`; go: `anthropic.Ptr(5 * time.Minute)`). Pour désactiver la limite, définissez-la sur `None` (typescript: `0`; go: `new(time.Duration)`). |
| `memory_sync_interval` (typescript: `memorySyncIntervalMs`; go: `MemorySyncInterval`) | Le délai le plus court entre deux synchronisations des magasins de mémoire attachés pendant l’exécution de la session. Le worker vérifie l’intervalle après chaque appel à un outil qui s’exécute dans votre sandbox, et non selon un minuteur. La valeur par défaut est de 15 secondes. Consultez [Intervalle de synchronisation](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#sync-interval). |
| `memory_sync_deletions` (typescript: `memorySyncDeletions`; go: `MemorySyncDeletions`) | Indique si les fichiers que l’agent supprime localement sont également supprimés du magasin. Consultez [Suppressions](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#deletions). |

`EnvironmentWorker` gère automatiquement l’`AgentToolContext` et l’ensemble d’outils. Transmettez une fabrique `tools` (go: `ToolsFunc`) pour personnaliser la liste d’outils :

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Un worker est un processus de longue durée, et non une simple requête HTTP. Pour personnaliser la liste d’outils, utilisez `EnvironmentWorker` dans le SDK Python, TypeScript ou Go.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Le worker de la CLI `ant` utilise toujours l’ensemble d’outils standard de l’agent. Pour personnaliser la liste d’outils, utilisez `EnvironmentWorker` dans le SDK Python, TypeScript ou Go.
  </CodeGroupItem>

  ```python Python
  import asyncio
  import contextlib
  import os
  import signal
  from anthropic import AsyncAnthropic, beta_async_tool
  from anthropic.lib.environments import EnvironmentWorker
  from anthropic.lib.tools.agent_toolset import beta_bash_tool


  @beta_async_tool
  async def get_order_status(order_id: str) -> str:
      """Look up an order in the internal fulfillment system by order ID."""
      return f"Order {order_id}: shipped"


  async def main() -> None:
      environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
      async with AsyncAnthropic(auth_token=environment_key) as client:
          worker = EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              # Listez chaque outil que l'agent peut appeler. Le worker ne répond à aucun autre outil.
              tools=lambda env: [beta_bash_tool(env), get_order_status],
          )
          task = asyncio.create_task(worker.run())
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task


  asyncio.run(main())
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { EnvironmentWorker } from "@anthropic-ai/sdk/helpers/beta/environments";
  import { betaTool } from "@anthropic-ai/sdk/helpers/beta/json-schema";
  import { betaBashTool } from "@anthropic-ai/sdk/tools/agent-toolset/node";

  const getOrderStatus = betaTool({
    name: "get_order_status",
    description: "Look up an order in the internal fulfillment system by order ID.",
    inputSchema: {
      type: "object",
      properties: { order_id: { type: "string", description: "The order ID" } },
      required: ["order_id"]
    },
    run: async ({ order_id }) => `Order ${order_id}: shipped`
  });

  const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
  const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
  const client = new Anthropic({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    signal: controller.signal,
    // Listez tous les outils que l'agent peut appeler. Le worker ne répond à aucun autre outil.
    tools: (ctx) => [betaBashTool(ctx), getOrderStatus]
  }).run();
  ```

  <CodeGroupItem language="C#">
    Le SDK C# ne dispose pas d’`EnvironmentWorker`. Pour répondre aux appels d’outils personnalisés depuis votre propre code, envoyez chaque résultat sur le flux d’événements de la session, comme dans [Renvoyer un résultat d’outil personnalisé](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  ```go Go
  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
  	"github.com/anthropics/anthropic-sdk-go/v2/option"
  	"github.com/anthropics/anthropic-sdk-go/v2/toolrunner"
  	"github.com/anthropics/anthropic-sdk-go/v2/tools/agenttoolset"
  )

  type orderStatusInput struct {
  	OrderID string `json:"order_id"`
  }

  func main() {
  	environmentKey := os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("ANTHROPIC_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	getOrderStatus := toolrunner.NewBetaTool(
  		"get_order_status",
  		"Look up an order in the internal fulfillment system by order ID.",
  		anthropic.BetaToolInputSchemaParam{
  			Properties: map[string]any{
  				"order_id": map[string]any{"type": "string", "description": "The order ID"},
  			},
  			Required: []string{"order_id"},
  		},
  		func(ctx context.Context, input orderStatusInput) (anthropic.BetaToolResultBlockParamContentUnion, error) {
  			return anthropic.BetaToolResultBlockParamContentUnion{
  				OfText: &anthropic.BetaTextBlockParam{Text: "Order " + input.OrderID + ": shipped"},
  			}, nil
  		},
  	)

  	client := anthropic.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		// Listez chaque outil que l'agent peut appeler. Le worker ne répond à aucun autre outil.
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []anthropic.BetaTool {
  			return []anthropic.BetaTool{agenttoolset.BetaBashTool(env), getOrderStatus}
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    Le SDK Java ne dispose pas d’`EnvironmentWorker`. Pour répondre aux appels d’outils personnalisés depuis votre propre code, envoyez chaque résultat sur le flux d’événements de la session, comme dans [Renvoyer un résultat d’outil personnalisé](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Le SDK PHP ne dispose pas d’`EnvironmentWorker`. Pour répondre aux appels d’outils personnalisés depuis votre propre code, envoyez chaque résultat sur le flux d’événements de la session, comme dans [Renvoyer un résultat d’outil personnalisé](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Le SDK Ruby ne dispose pas d’`EnvironmentWorker`. Pour répondre aux appels d’outils personnalisés depuis votre propre code, envoyez chaque résultat sur le flux d’événements de la session, comme dans [Renvoyer un résultat d’outil personnalisé](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>
</CodeGroup>

### Work poller

| Option | Description |
| ----- | ----- |
| `drain` (go: `Drain`) | Indique s’il faut arrêter l’interrogation une fois la file d’attente vide plutôt que d’attendre de nouveaux travaux. |
| `block_ms` (typescript: `blockMs`; go: `BlockMs`) | Durée pendant laquelle chaque interrogation attend l’arrivée de travail avant de retourner, en millisecondes. Doit être comprise entre 1 et 999. Le helper relance automatiquement l’interrogation. Transmettez `null` (python: `None`; go: `param.Null[int64]()`) pour une vérification non bloquante. Utilise par défaut un long-poll de 999 ms. |
| `reclaim_older_than_ms` (typescript: `reclaimOlderThanMs`; go: `ReclaimOlderThanMs`) | Réclame à nouveau les éléments de travail qui ont été réclamés mais jamais acquittés dans ce nombre de millisecondes. |
| `auto_stop` (typescript: `autoStop`; go: `AutoStop`) | Indique si le poller publie un signal d’arrêt pour chaque élément de travail une fois que le corps de votre boucle en a terminé avec lui. La valeur par défaut est `true` (python: `True`). Définissez-la sur `false` (python: `False`; go: `param.NewOpt(false)`) dans les deux cas qui suivent ce tableau. |

Définissez `auto_stop` (typescript: `autoStop`; go: `AutoStop`) sur `false` (python: `False`; go: `param.NewOpt(false)`) dans deux cas :

1. Votre boucle appelle `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`), qui publie lui-même l’arrêt.
2. Votre boucle lance une sandbox pour l’élément et passe à la suite. Le worker de cette sandbox doit publier l’arrêt lorsque le travail de la session se termine, comme le font `ant beta:worker run` et `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`).

Pour un exemple complet, consultez [Lancer des sandboxes depuis le poller du SDK](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller).

### Exécuteur d’outils de session

`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`) prend une liste d’outils via `tools` (go: `Tools`). Pour construire cette liste, configurez vous-même `AgentToolContext` et appelez `beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) :

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    `AgentToolContext` est un helper des SDK Python, TypeScript et Go. cURL n’a pas d’équivalent. Utilisez l’un de ces SDK.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    `AgentToolContext` est un helper des SDK Python, TypeScript et Go. La CLI `ant` n’a pas d’équivalent. Utilisez l’un de ces SDK.
  </CodeGroupItem>

  ```python Python
  from anthropic.lib.tools.agent_toolset import (
      AgentToolContext,
      beta_agent_toolset_20260401,
  )

  async with AgentToolContext(
      workdir="/workspace", client=client, session_id=work.data.id
  ) as env:
      # skills téléchargés dans /workspace/skills/<name>/
      tools = beta_agent_toolset_20260401(env)
  ```

  ```typescript TypeScript
  import {
    setupSkills,
    betaAgentToolset20260401
  } from "@anthropic-ai/sdk/tools/agent-toolset/node";

  const ctx = { workdir: "/workspace", client, sessionId: work.data.id };
  await setupSkills(ctx);
  const tools = betaAgentToolset20260401(ctx);
  ```

  <CodeGroupItem language="C#">
    Le SDK C# ne dispose pas d’`AgentToolContext`.
  </CodeGroupItem>

  ```go Go
  env := &agenttoolset.AgentToolContext{Workdir: "/workspace"}
  if err := env.SetupSkills(ctx, client, work.Data.ID); err != nil {
  	panic(err)
  }
  // skills téléchargés dans /workspace/skills/<name>/
  tools := agenttoolset.BetaAgentToolset20260401(env)
  ```

  <CodeGroupItem language="Java">
    Le SDK Java ne dispose pas d’`AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Le SDK PHP ne dispose pas d’`AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Le SDK Ruby ne dispose pas d’`AgentToolContext`.
  </CodeGroupItem>
</CodeGroup>

### AgentToolContext et l’ensemble d’outils de l’agent

`AgentToolContext` est le contexte d’exécution des appels d’outils. Il définit le répertoire de travail et la politique de chemins, et peut télécharger les skills de la session.

| Option | Description |
| ----- | ----- |
| `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) | Répertoires, en plus du répertoire de travail, auxquels les outils de fichiers (`read`, `write`, `edit`, `glob`, `grep`) peuvent accéder. |
| `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`) | Répertoires sous lesquels `write` et `edit` refusent les chemins. |

`EnvironmentWorker` ajoute lui-même les répertoires des magasins de mémoire de la session à `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`), et les répertoires des magasins attachés avec `access: "read_only"` à `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`).

Ce confinement est un garde-fou pour les outils de fichiers uniquement, et non une sandbox. Il ne restreint pas `bash`.

`beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) prend un `AgentToolContext` et renvoie les implémentations d’outils standard (`bash`, `read`, `write`, `edit`, `glob`, `grep`).
