---
title: Referência de workers auto-hospedados
url: https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference
description: "Referência para workers de sandbox auto-hospedados: flags da CLI ant, variáveis de ambiente, requisitos do host, caminhos do sistema de arquivos e opções dos helpers do 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: Não é elegível para ZDR, exceto o Managed Agents auto-hospedado. Sessões são recursos com estado; as transcrições persistem até que você as exclua.
  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
---

Esta página documenta os workers pré-construídos que atendem a um ambiente `self_hosted`. Para guias orientados a tarefas, comece com [Sandboxes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes) e [Implantar workers auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-workers).

## Comandos e flags da CLI

| Comando | Descrição |
| ----- | ----- |
| `ant beta:worker poll` | Reivindica itens de trabalho da fila do ambiente e executa cada sessão no próprio processo. Com `--on-work`, chama seu script para cada item de trabalho em vez disso. |
| `ant beta:worker run` | Processa uma sessão reivindicada e encerra. Use-o como o entrypoint de um sandbox por sessão. |

| Flag | Descrição |
| ----- | ----- |
| `--environment-id` | O ambiente a ser consultado em busca de trabalho. Também lê de `ANTHROPIC_ENVIRONMENT_ID`. |
| `--environment-key` | Autentica o worker com este ambiente. Também lê de `ANTHROPIC_ENVIRONMENT_KEY`. |
| `--workdir` | Diretório onde o worker baixa as skills e onde as ferramentas leem e gravam arquivos. O padrão é `.` (o diretório atual). O diretório deve existir antes de o worker iniciar. |
| `--on-work` | Script a ser chamado para cada item de trabalho reivindicado em vez de executar as ferramentas no próprio processo. Recebe os detalhes da sessão como variáveis de ambiente e o item de trabalho como JSON na entrada padrão. |
| `--max-idle` | Quanto tempo o worker aguarda enquanto uma sessão está ociosa antes que `ant beta:worker run` encerre ou que `ant beta:worker poll` passe para o próximo item de trabalho. O tempo ocioso com um [stop reason `requires_action`](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) (motivo de parada) não é contabilizado. O padrão é `60s`. Defina como `0` para desativar o tempo limite. Com um script `--on-work`, `ant beta:worker poll` ignora esta flag. Em vez disso, passe-a para o comando `ant beta:worker run` que seu script inicia. |
| `--log-format` | Formato de saída dos logs. Use `json` para ingestão de logs estruturados. O padrão é `text`. |

## Variáveis de ambiente

| Variável | Descrição | Definida por |
| ----- | ----- | ----- |
| `ANTHROPIC_ENVIRONMENT_ID` | O ambiente cuja fila o worker atende. | Você, no host do worker. O poller a repassa ao script `--on-work`. |
| `ANTHROPIC_ENVIRONMENT_KEY` | Autentica o worker na sua fila. | Você, no host do worker. O poller a repassa ao script `--on-work`. |
| `ANTHROPIC_SESSION_ID` | A sessão que um item de trabalho reivindicado representa. | O poller, para o script `--on-work`. |
| `ANTHROPIC_WORK_ID` | O item de trabalho reivindicado. | O poller, para o script `--on-work`. |
| `ANTHROPIC_WORK_SECRET` | O segredo do item de trabalho para a sessão dele. | Você. O poller não a define. Consulte [Encaminhar o segredo do item de trabalho](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret). |
| `ANTHROPIC_BASE_URL` | Substitui o endpoint padrão da API. Opcional. | Você, no host do worker. |
| `ANTHROPIC_WEBHOOK_SIGNING_KEY` | Verifica os payloads de webhook recebidos. | Você, em um host de handler de webhook. |

## Requisitos do host

| Worker | Requisito |
| ----- | ----- |
| Todos os workers | Um host Linux ou macOS com `/bin/bash` exatamente nesse caminho. A ferramenta `bash` do worker o executa diretamente, sem consultar o `PATH`. No macOS, esse é o Bash 3.2 do sistema. |
| SDK TypeScript | `unzip` e `tar` no `PATH`, e Node.js 22 ou posterior. |
| SDKs Python e Go | Nenhum binário adicional. Esses SDKs usam suas bibliotecas padrão para extração de arquivos compactados. |

[Memory stores](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory#requirements) (armazenamentos de memória) adicionam seus próprios requisitos.

No macOS, o volume raiz é somente leitura, então `mkdir` não consegue criar `/workspace`. Defina o diretório de trabalho do worker como um diretório no qual você possa gravar, como um diretório `workspace` no seu diretório pessoal. Para usar memory stores no macOS, primeiro [prepare o host macOS](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory#prepare-a-macos-host).

## Sistema de arquivos do sandbox

| Caminho | Conteúdo |
| ----- | ----- |
| `/workspace` | O diretório de trabalho usado nos exemplos das páginas de sandboxes auto-hospedados. Ele não é o padrão do worker: o worker usa o diretório atual, a menos que você defina `--workdir` ou `workdir` (go: `Workdir`). Os sandboxes em nuvem da Anthropic mantêm skills e repositórios em `/workspace`. Se você usar um diretório de trabalho diferente, atualize o prompt do sistema do seu agente para que Claude consiga localizar os arquivos das skills. |
| `<workdir>/skills/<name>/` | As skills baixadas do agente. |
| `/mnt/memory/<store>/` | Uma cópia local de cada memory store anexado, um diretório por store. A API retorna o caminho completo de cada diretório no campo `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) do recurso de memory store da sessão (por exemplo, `/mnt/memory/user-preferences/`). |

O worker cria os diretórios dos memory stores quando reivindica uma sessão. Ele os remove quando termina de atender a essa sessão ou quando você [parar o worker de forma controlada](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-operations#stop-workers-gracefully). Isso remove apenas as cópias locais, e as memórias permanecem no store.

As skills podem incluir executáveis que o agente pode executar diretamente. Os workers da CLI e do SDK preservam as permissões de execução registradas no pacote da skill ao extraí-lo. Se você mesmo baixar as skills, defina você mesmo as permissões de execução delas.

### Quando o worker termina de atender a uma sessão

O worker termina de atender a uma sessão em qualquer um destes casos:

* A sessão termina.
* Você [para o item de trabalho da sessão](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-operations#stop-a-session-gracefully).
* A sessão permanece ociosa pelo “idle limit” (limite de ociosidade) do worker. A própria sessão permanece aberta. Quando você então enviar a ela um novo evento, como uma mensagem do usuário, o mesmo worker ou outro a reivindica. Esse worker baixa os stores novamente.

O limite de ociosidade é de 60 segundos por padrão. Para alterá-lo, use [`--max-idle`](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#cli-commands-and-flags) para o worker da CLI `ant` ou [`max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`)](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#environment-worker) para o `EnvironmentWorker`. O [chart do Helm `cma-sandboxes`](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes) inicia seus workers com um limite de 30 minutos em vez disso. Para alterar esse limite, altere a configuração `sandbox.idleTimeout` do chart.

### Entregáveis finais

Sandboxes auto-hospedados não têm o diretório `/mnt/session/outputs`. Nos sandboxes na nuvem da Anthropic, o prompt do sistema da sessão instrui o agente a copiar os entregáveis finais para lá. Em ambientes auto-hospedados, o prompt do sistema omite essa instrução. Os entregáveis finais ficam onde quer que o agente os grave, normalmente sob o diretório de trabalho, e o worker não faz upload deles.

Para reunir os entregáveis finais em um só lugar, informe o caminho completo de um diretório no prompt do sistema do seu agente. Escolha um diretório no qual as ferramentas de arquivo do worker possam gravar:

* **Dentro do diretório de trabalho:** por exemplo, `/workspace/outputs` se o diretório de trabalho for `/workspace`.
* **Em qualquer outro lugar, somente com um worker do SDK:** adicione o diretório a `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`). Consulte [AgentToolContext e o conjunto de ferramentas do agente](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#agent-tool-context-and-the-agent-toolset).

## Helpers do SDK

Os SDKs Python, TypeScript e Go fornecem três helpers com diferentes níveis de controle:

| Helper | O que faz | Use quando |
| ----- | ----- | ----- |
| [`EnvironmentWorker`](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#environment-worker) | Cuida do polling, da configuração e da execução de ferramentas de ponta a ponta. | Na maioria dos casos. |
| [`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`)](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#work-poller) | Consulta a fila de trabalho e entrega a você cada sessão reivindicada. | Você determina como tratar cada sessão, por exemplo, iniciando um sandbox em vez de executar as ferramentas no próprio processo. |
| [`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`)](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#session-tool-runner) | Executa chamadas de ferramentas para uma única sessão, dados o ID da sessão e uma lista de ferramentas. | Você já reivindicou o trabalho e só precisa executar as ferramentas. |

### EnvironmentWorker

| Método | Descrição |
| ----- | ----- |
| `run()` (go: `Run()`) | Executa indefinidamente, pegando as sessões à medida que chegam. |
| `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) | Processa um único item de trabalho já reivindicado por um poller. O poller pode ser `ant beta:worker poll --on-work` ou seu próprio código. O método retorna quando o worker termina de atender à sessão do item. Você pode passar `work_id` (typescript: `workId`; go: `WorkID`), `session_id` (typescript: `sessionId`; go: `SessionID`), `environment_id` (typescript: `environmentId`; go: `EnvironmentID`) e `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Para cada um que você omitir, o método lê a [variável `ANTHROPIC_*`](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-reference#environment-variables) correspondente. |

| Opção | Descrição |
| ----- | ----- |
| `tools` (go: `ToolsFunc`) | Uma factory que recebe o `AgentToolContext` da sessão e retorna a lista de ferramentas. O padrão é o conjunto de ferramentas padrão do agente. |
| `max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`) | Quanto tempo o worker aguarda enquanto uma sessão está ociosa antes de terminar de atender à sessão. O tempo ocioso com um [stop reason `requires_action`](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) (motivo de parada) não é contabilizado. O padrão é 60 segundos. Para aguardar 5 minutos, defina como `300` (typescript: `300_000`; go: `anthropic.Ptr(5 * time.Minute)`). Para desativar o limite, defina como `None` (typescript: `0`; go: `new(time.Duration)`). |
| `memory_sync_interval` (typescript: `memorySyncIntervalMs`; go: `MemorySyncInterval`) | O tempo mínimo entre duas sincronizações dos memory stores anexados enquanto a sessão é executada. O worker verifica o intervalo após cada chamada a uma ferramenta executada no seu sandbox, não por um temporizador. O padrão é 15 segundos. Consulte [Intervalo de sincronização](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory#sync-interval). |
| `memory_sync_deletions` (typescript: `memorySyncDeletions`; go: `MemorySyncDeletions`) | Se os arquivos que o agente exclui localmente também são excluídos do store. Consulte [Exclusões](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory#deletions). |

O `EnvironmentWorker` gerencia o `AgentToolContext` e o conjunto de ferramentas automaticamente. Passe uma factory `tools` (go: `ToolsFunc`) para personalizar a lista de ferramentas:

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Um worker é um processo de longa duração, não uma única requisição HTTP. Para personalizar a lista de ferramentas, use o `EnvironmentWorker` no SDK Python, TypeScript ou Go.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    O worker da CLI `ant` sempre usa o conjunto de ferramentas padrão do agente. Para personalizar a lista de ferramentas, use o `EnvironmentWorker` no 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,
              # Liste todas as ferramentas que o agente pode chamar. O worker não responde a nenhuma outra ferramenta.
              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,
    // Liste todas as ferramentas que o agente pode chamar. O worker não responde a nenhuma outra ferramenta.
    tools: (ctx) => [betaBashTool(ctx), getOrderStatus]
  }).run();
  ```

  <CodeGroupItem language="C#">
    O SDK C# não tem `EnvironmentWorker`. Para responder a chamadas de ferramentas personalizadas a partir do seu próprio código, envie cada resultado no stream de eventos da sessão, como em [Retornar um resultado de ferramenta personalizada](https://platform.claude.com/docs/pt-BR/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,
  		// Liste todas as ferramentas que o agente pode chamar. O worker não responde a nenhuma outra ferramenta.
  		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">
    O SDK Java não tem `EnvironmentWorker`. Para responder a chamadas de ferramentas personalizadas a partir do seu próprio código, envie cada resultado no stream de eventos da sessão, como em [Retornar um resultado de ferramenta personalizada](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    O SDK PHP não tem `EnvironmentWorker`. Para responder a chamadas de ferramentas personalizadas a partir do seu próprio código, envie cada resultado no stream de eventos da sessão, como em [Retornar um resultado de ferramenta personalizada](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    O SDK Ruby não tem `EnvironmentWorker`. Para responder a chamadas de ferramentas personalizadas a partir do seu próprio código, envie cada resultado no stream de eventos da sessão, como em [Retornar um resultado de ferramenta personalizada](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>
</CodeGroup>

### Work poller

| Opção | Descrição |
| ----- | ----- |
| `drain` (go: `Drain`) | Se deve parar o polling quando a fila estiver vazia em vez de aguardar novo trabalho. |
| `block_ms` (typescript: `blockMs`; go: `BlockMs`) | Quanto tempo cada poll espera a chegada de trabalho antes de retornar, em milissegundos. Deve estar entre 1 e 999. O helper refaz o poll automaticamente. Passe `null` (python: `None`; go: `param.Null[int64]()`) para uma verificação não bloqueante. O padrão é um long-poll de 999ms. |
| `reclaim_older_than_ms` (typescript: `reclaimOlderThanMs`; go: `ReclaimOlderThanMs`) | Reivindica novamente itens de trabalho que foram reivindicados, mas nunca confirmados dentro desse número de milissegundos. |
| `auto_stop` (typescript: `autoStop`; go: `AutoStop`) | Se o poller envia um sinal de parada para cada item de trabalho quando o corpo do seu loop terminar de processá-lo. O padrão é `true` (python: `True`). Defina como `false` (python: `False`; go: `param.NewOpt(false)`) nos dois casos descritos após esta tabela. |

Defina `auto_stop` (typescript: `autoStop`; go: `AutoStop`) como `false` (python: `False`; go: `param.NewOpt(false)`) em dois casos:

1. Seu loop chama `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`), que envia a parada por conta própria.
2. Seu loop inicia um sandbox para o item e segue em frente. O worker nesse sandbox deve enviar a parada quando o trabalho da sessão terminar, como fazem `ant beta:worker run` e `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`).

Para um exemplo completo, consulte [Iniciar sandboxes a partir do poller do SDK](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller).

### Tool runner de sessão

`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`) recebe uma lista de ferramentas como `tools` (go: `Tools`). Para construir essa lista, configure o `AgentToolContext` você mesmo e chame `beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`):

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    `AgentToolContext` é um helper nos SDKs Python, TypeScript e Go. O cURL não tem equivalente. Use um desses SDKs.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    `AgentToolContext` é um helper nos SDKs Python, TypeScript e Go. A CLI `ant` não tem equivalente. Use um desses SDKs.
  </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 baixadas em /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#">
    O SDK C# não tem `AgentToolContext`.
  </CodeGroupItem>

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

  <CodeGroupItem language="Java">
    O SDK Java não tem `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    O SDK PHP não tem `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    O SDK Ruby não tem `AgentToolContext`.
  </CodeGroupItem>
</CodeGroup>

### AgentToolContext e o conjunto de ferramentas do agente

`AgentToolContext` é o contexto de execução para chamadas de ferramentas. Ele define o diretório de trabalho e a política de caminhos, e pode baixar as skills da sessão.

| Opção | Descrição |
| ----- | ----- |
| `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) | Diretórios, além do diretório de trabalho, que as ferramentas de arquivo (`read`, `write`, `edit`, `glob`, `grep`) podem acessar. |
| `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`) | Diretórios sob os quais `write` e `edit` recusam caminhos. |

O `EnvironmentWorker` adiciona por conta própria os diretórios dos memory stores da sessão a `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`), e os diretórios dos stores anexados com `access: "read_only"` a `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`).

O confinamento é uma proteção apenas para as ferramentas de arquivo, não um sandbox. Ele não restringe o `bash`.

`beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) recebe um `AgentToolContext` e retorna as implementações de ferramentas padrão (`bash`, `read`, `write`, `edit`, `glob`, `grep`).
