自托管沙箱

curl -sS --fail-with-body http://localhost:38080/v1/environments \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{
    "name": "self-hosted",
    "config": {"type": "self_hosted"}
  }'

ant beta:environments create \
  --name self-hosted \
  --config '{"type": "self_hosted"}'

client = anthropic.Anthropic()

environment = client.beta.environments.create(
    name="self-hosted", config={"type": "self_hosted"}
)
print(environment.id)

const client = new Anthropic();

const environment = await client.beta.environments.create({
  name: "self-hosted",
  config: { type: "self_hosted" }
});
console.log(environment.id);

using Anthropic.Models.Beta.Environments;

var client = new AnthropicClient();

var environment = await client.Beta.Environments.Create(
    new EnvironmentCreateParams
    {
        Name = "self-hosted",
        Config = new BetaSelfHostedConfigParams(),
    }
);
Console.WriteLine(environment.ID);

client := anthropic.NewClient()

environment, err := client.Beta.Environments.New(context.Background(), anthropic.BetaEnvironmentNewParams{
    Name: "self-hosted",
    Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
        OfSelfHosted: &anthropic.BetaSelfHostedConfigParams{},
    },
})
if err != nil {
    panic(err)
}
fmt.Println(environment.ID)

import com.anthropic.models.beta.environments.BetaSelfHostedConfigParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;

void main() {
    var client = AnthropicOkHttpClient.fromEnv();

    var environment = client.beta().environments().create(
        EnvironmentCreateParams.builder()
            .name("self-hosted")
            .config(BetaSelfHostedConfigParams.builder().build())
            .build()
    );
    IO.println(environment.id());
}

$client = new Anthropic\Client();

$environment = $client->beta->environments->create(
    name: 'self-hosted',
    config: ['type' => 'self_hosted'],
);
echo $environment->id, PHP_EOL;

client = Anthropic::Client.new

environment = client.beta.environments.create(
  name: "self-hosted",
  config: {type: :self_hosted}
)
puts environment.id

import asyncio
import os
from anthropic import AsyncAnthropic, beta_async_tool
from anthropic.lib.environments import EnvironmentWorker
from anthropic.lib.tools.agent_toolset import beta_agent_toolset_20260401


@beta_async_tool
async def get_order_status(order_id: str) -> str:
    """Look up an order in the internal fulfillment system by order ID."""
    # 在 worker 主机上运行：可调用沙箱能够访问的任何内容。
    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:
        await EnvironmentWorker(
            client,
            environment_id=environment_id,
            environment_key=environment_key,
            workdir="/workspace",
            tools=lambda env: [*beta_agent_toolset_20260401(env), get_order_status],
        ).run()


asyncio.run(main())

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 { betaAgentToolset20260401 } 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"]
  },
  // 在 worker 主机上运行：可调用沙箱能访问的任何内容。
  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("SIGTERM", () => controller.abort());

await new EnvironmentWorker({
  client,
  environmentId,
  environmentKey,
  workdir: "/workspace",
  signal: controller.signal,
  tools: (ctx) => [...betaAgentToolset20260401(ctx), getOrderStatus]
}).run();

// EnvironmentWorker 目前在 C# SDK 中不可用。
// 如需直接响应自定义工具调用，请参阅会话事件流。

package main

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

    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/lib/environments"
    "github.com/anthropics/anthropic-sdk-go/option"
    "github.com/anthropics/anthropic-sdk-go/toolrunner"
    "github.com/anthropics/anthropic-sdk-go/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,
        Workdir:        "/workspace",
        ToolsFunc: func(env *agenttoolset.AgentToolContext) []anthropic.BetaTool {
            return append(agenttoolset.BetaAgentToolset20260401(env), getOrderStatus)
        },
    })
    if err := worker.Run(ctx); err != nil {
        log.Fatalf("worker: %v", err)
    }
}

// EnvironmentWorker 目前在 Java SDK 中不可用。
// 如需直接响应自定义工具调用，请参阅会话事件流。

// EnvironmentWorker 目前在 PHP SDK 中不可用。
// 如需直接响应自定义工具调用，请参阅会话事件流。

# EnvironmentWorker 目前在 Ruby SDK 中不可用。
# 如需直接响应自定义工具调用，请参阅会话事件流。

import asyncio
from typing import Any, cast
from anthropic import AsyncAnthropic
from anthropic.types.beta import BetaManagedAgentsCustomToolParams
from mcp import ClientSession, types
# 需要 mcp >= 1.24，该版本将 streamablehttp_client 重命名为 streamable_http_client。
from mcp.client.streamable_http import streamable_http_client

MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"


def to_custom_tool(tool: types.Tool) -> BetaManagedAgentsCustomToolParams:
    # MCP 字段与自定义工具声明一一对应。cast
    # 将 schema 字典原样传递给 SDK 的类型化参数。
    return {
        "type": "custom",
        "name": tool.name,
        "description": tool.description or tool.name,
        "input_schema": cast(Any, tool.inputSchema),
    }


async def main() -> None:
    # 请在您创建智能体的位置运行此代码，而不是在工作主机上：
    # 它使用您的 OMA API 密钥（OMA_API_KEY）进行身份验证。
    async with (
        streamable_http_client(MCP_SERVER_URL) as (read, write, _),
        ClientSession(read, write) as mcp_session,
        AsyncAnthropic() as client,
    ):
        await mcp_session.initialize()
        listed = await mcp_session.list_tools()
        agent = await client.beta.agents.create(
            name="Internal tools agent",
            model="claude-opus-5",
            tools=[
                {"type": "agent_toolset_20260401"},
                *[to_custom_tool(tool) for tool in listed.tools],
            ],
        )
        print(agent.id)


asyncio.run(main())

import Anthropic from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

// 请在您创建智能体的位置运行此代码，而不是在工作主机上：它
// 使用您的 OMA API 密钥（OMA_API_KEY）进行身份验证。
const client = new Anthropic();

const mcpClient = new Client({ name: "declare-agent-tools", version: "1.0.0" });
await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
const { tools } = await mcpClient.listTools();

const agent = await client.beta.agents.create({
  name: "Internal tools agent",
  model: "claude-opus-5",
  tools: [
    { type: "agent_toolset_20260401" },
    // MCP 字段与自定义工具声明一一对应。
    ...tools.map((tool) => ({
      type: "custom" as const,
      name: tool.name,
      description: tool.description || tool.name,
      input_schema: tool.inputSchema
    }))
  ]
});
console.log(agent.id);

await mcpClient.close();

// 请参阅 Python、TypeScript 和 Go 选项卡。在 C# 中声明自定义工具的
// 方式相同，只需先使用 MCP 客户端列出服务器的工具即可。

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/anthropics/anthropic-sdk-go"
    mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
)

const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

// toCustomTool 将一个 MCP 工具定义映射为一个自定义工具声明。
// 字段一一对应：类型化参数承载 `properties` 和
// `required`，服务器输出的其他所有 JSON Schema 关键字都放入
// ExtraFields，以便声明的 schema 与服务器的 schema 保持一致。
func toCustomTool(tool *mcpsdk.Tool) (anthropic.BetaAgentNewParamsToolUnion, error) {
    raw, err := json.Marshal(tool.InputSchema)
    if err != nil {
        return anthropic.BetaAgentNewParamsToolUnion{}, err
    }
    var schema map[string]any
    if err := json.Unmarshal(raw, &schema); err != nil {
        return anthropic.BetaAgentNewParamsToolUnion{}, err
    }

    inputSchema := anthropic.BetaManagedAgentsCustomToolInputSchemaParam{ExtraFields: map[string]any{}}
    for keyword, value := range schema {
        switch keyword {
        case "type":
            // 该参数类型始终序列化为 "type": "object"。
        case "properties":
            properties, _ := value.(map[string]any)
            inputSchema.Properties = properties
        case "required":
            entries, _ := value.([]any)
            for _, entry := range entries {
                if name, isString := entry.(string); isString {
                    inputSchema.Required = append(inputSchema.Required, name)
                }
            }
        default:
            inputSchema.ExtraFields[keyword] = value
        }
    }

    description := tool.Description
    if description == "" {
        description = tool.Name
    }
    return anthropic.BetaAgentNewParamsToolUnion{
        OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
            Type:        anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
            Name:        tool.Name,
            Description: description,
            InputSchema: inputSchema,
        },
    }, nil
}

func main() {
    ctx := context.Background()

    // 请在您创建智能体的位置运行此程序，而非在工作节点主机上：
    // 它使用您的 OMA API 密钥（OMA_API_KEY）进行身份验证。
    client := anthropic.NewClient()

    mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "declare-agent-tools", Version: "1.0.0"}, nil)
    session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
    if err != nil {
        log.Fatalf("connect to MCP server: %v", err)
    }
    defer session.Close()

    listed, err := session.ListTools(ctx, nil)
    if err != nil {
        log.Fatalf("list MCP tools: %v", err)
    }

    tools := []anthropic.BetaAgentNewParamsToolUnion{
        {OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
            Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
        }},
    }
    for _, tool := range listed.Tools {
        custom, err := toCustomTool(tool)
        if err != nil {
            log.Fatalf("convert MCP tool %s: %v", tool.Name, err)
        }
        tools = append(tools, custom)
    }

    agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
        Name:  "Internal tools agent",
        Model: anthropic.BetaManagedAgentsModelConfigParams{ID: anthropic.BetaManagedAgentsModelClaudeOpus5},
        Tools: tools,
    })
    if err != nil {
        log.Fatalf("create agent: %v", err)
    }
    fmt.Println(agent.ID)
}

// 请参阅 Python、TypeScript 和 Go 标签页。在 Java 中声明自定义工具的
// 方式相同，只需先使用 MCP 客户端列出服务器的工具即可。

// 请参阅 Python、TypeScript 和 Go 标签页。在 PHP 中声明自定义工具的
// 方式相同，只需先通过 MCP 客户端列出服务器的工具即可。

# 请参阅 Python、TypeScript 和 Go 标签页。在 Ruby 中声明自定义工具的
# 方式相同，只需先使用 MCP 客户端列出服务器的工具即可。

import asyncio
import os
from datetime import timedelta
from anthropic import AsyncAnthropic
from anthropic.lib.environments import EnvironmentWorker
from anthropic.lib.tools.agent_toolset import beta_agent_toolset_20260401
from anthropic.lib.tools.mcp import async_mcp_tool
from mcp import ClientSession
# 需要 mcp >= 1.24，该版本将 streamablehttp_client 重命名为 streamable_http_client。
from mcp.client.streamable_http import streamable_http_client

MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"


async def main() -> None:
    environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
    environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
    # 在启动时连接一次 MCP 服务器，并在工作进程的整个生命周期内
    # 保持会话打开。超时设置会将挂起的工具调用转为错误
    # 结果，而不是让调用一直停滞。
    async with (
        streamable_http_client(MCP_SERVER_URL) as (read, write, _),
        ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as mcp_session,
        AsyncAnthropic(auth_token=environment_key) as client,
    ):
        await mcp_session.initialize()
        listed = await mcp_session.list_tools()
        mcp_tools = [async_mcp_tool(tool, mcp_session) for tool in listed.tools]
        await EnvironmentWorker(
            client,
            environment_id=environment_id,
            environment_key=environment_key,
            workdir="/workspace",
            tools=lambda env: [*beta_agent_toolset_20260401(env), *mcp_tools],
        ).run()


asyncio.run(main())

import Anthropic from "@anthropic-ai/sdk";
import { EnvironmentWorker } from "@anthropic-ai/sdk/helpers/beta/environments";
import {
  mcpTools,
  type MCPCallToolResultLike,
  type MCPClientLike
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { betaAgentToolset20260401 } from "@anthropic-ai/sdk/tools/agent-toolset/node";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

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("SIGTERM", () => controller.abort());

// 在启动时连接一次 MCP 服务器，并在工作进程的整个生命周期内
// 保持连接打开。
const mcpClient = new Client({ name: "sandbox-worker", version: "1.0.0" });
await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
const { tools } = await mcpClient.listTools();

// MCP SDK 的 callTool 返回类型仍包含 mcpTools 不接受的旧版结果形状；
// 需要收窄类型。待 MCPClientLike 放宽后删除此处理。
const mcpClientForTools: MCPClientLike = {
  callTool: (params) => mcpClient.callTool(params) as Promise<MCPCallToolResultLike>
};

await new EnvironmentWorker({
  client,
  environmentId,
  environmentKey,
  workdir: "/workspace",
  signal: controller.signal,
  tools: (ctx) => [...betaAgentToolset20260401(ctx), ...mcpTools(tools, mcpClientForTools)]
}).run();

// EnvironmentWorker 目前在 C# SDK 中不可用。

package main

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

    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/lib/environments"
    "github.com/anthropics/anthropic-sdk-go/mcp"
    "github.com/anthropics/anthropic-sdk-go/option"
    "github.com/anthropics/anthropic-sdk-go/tools/agenttoolset"
    mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
)

const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

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()

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

    // 在启动时连接一次 MCP 服务器，并在工作进程的整个生命周期内
    // 保持会话打开。
    mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "sandbox-worker", Version: "1.0.0"}, nil)
    session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
    if err != nil {
        log.Fatalf("connect to MCP server: %v", err)
    }
    defer session.Close()

    listed, err := session.ListTools(ctx, nil)
    if err != nil {
        log.Fatalf("list MCP tools: %v", err)
    }
    mcpTools, err := mcp.NewBetaTools(listed.Tools, session)
    if err != nil {
        log.Fatalf("convert MCP tools: %v", err)
    }

    worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
        EnvironmentID:  environmentID,
        EnvironmentKey: environmentKey,
        Workdir:        "/workspace",
        ToolsFunc: func(env *agenttoolset.AgentToolContext) []anthropic.BetaTool {
            return append(agenttoolset.BetaAgentToolset20260401(env), mcpTools...)
        },
    })
    if err := worker.Run(ctx); err != nil {
        log.Fatalf("worker: %v", err)
    }
}

// EnvironmentWorker 目前在 Java SDK 中不可用。

// EnvironmentWorker 目前在 PHP SDK 中不可用。

# EnvironmentWorker 目前在 Ruby SDK 中不可用。