Programmatic Tool Calling：GPT 与 Claude 如何实现「代码编排工具」

用户提问 → 模型返回 tool_use → 你的服务执行工具 → 你把结果塞回上下文 → 模型再推理

传统模式：
  模型 → 工具A → 模型 → 工具B → 模型 → 工具C → 模型 → 答案

PTC 模式：
  模型 → 写程序 → [工具A → 工具B → 工具C]（在沙箱内，不进上下文）→ 程序输出 → 模型 → 答案

你（调用方）                    模型服务商后台
│                                    │
│  ① 发请求（prompt + 工具定义）       │
│ ──────────────────────────────────>│
│                                    │  ② 模型生成编排代码（JS 或 Python）
│                                    │  ③ 在沙箱里开始执行这段代码
│                                    │
│                                    │  ④ 代码执行到「需要调你的工具」→ 暂停
│  ⑤ 收到响应：                        │
│     - 生成的代码（供观察/调试）        │
│     - 需要调用的工具名和参数          │
│     - caller / container 等续跑信息  │
│ <──────────────────────────────────│
│                                    │
│  ⑥ 你的服务执行工具                   │
│                                    │
│  ⑦ 把工具结果 + 续跑信息回传           │
│ ──────────────────────────────────>│
│                                    │  ⑧ 沙箱从断点继续执行代码
│                                    │     （可能再次暂停、再次要工具）
│                                    │
│        ... 可能循环多次 ...           │
│                                    │
│  ⑨ 代码跑完，输出精炼结果              │
│  ⑩ 模型基于最终结果生成回答            │
│ <──────────────────────────────────│

❌ 用户拿到代码 → 自己跑这段 JS/Python
✅ 服务商沙箱跑代码 → 碰到你的工具时暂停 → 你把结果送回 → 沙箱继续跑

{
"type":"function_call_output",
"call_id":"call_inventory_123",
"output":"{\"sku\": \"sku_123\", \"available_units\": 42}",
"caller":{"type":"program","caller_id":"call_prog_123"}
}

{
"role":"user",
"content":[{
"type":"tool_result",
"tool_use_id":"toolu_def456",
"content":"[{\"customer_id\": \"C1\", \"revenue\": 45000}]"
}]
}

for employee in employees:          # 20 个人
    expenses = await get_expenses(employee)  # 每次都会暂停
# 在沙箱内处理...

┌─────────────────────────────────────────────────────┐
│  Responses API Request                               │
│  tools: [                                            │
│    { type: "function", name: "get_inventory",      │
│      allowed_callers: ["programmatic"], ... },       │
│    { type: "programmatic_tool_calling" }  ← 开关    │
│  ]                                                   │
└──────────────────────┬──────────────────────────────┘
                       ▼
┌─────────────────────────────────────────────────────┐
│  模型生成 program 项（JavaScript 代码）               │
│  OpenAI 在隔离 V8 运行时中执行                        │
│  - 支持 top-level await                              │
│  - 无 Node.js、无网络、无文件系统、无 npm             │
│  - 只能通过 tools.* 调用已启用的工具                  │
└──────────────────────┬──────────────────────────────┘
                       ▼ 程序调用 client-owned 工具时暂停
┌─────────────────────────────────────────────────────┐
│  response.output 包含：                              │
│  - program（代码 + call_id + fingerprint）           │
│  - function_call（caller.caller_id → program）       │
└──────────────────────┬──────────────────────────────┘
                       ▼ 你的应用执行工具
┌─────────────────────────────────────────────────────┐
│  回传 function_call_output（保留 call_id + caller）   │
└──────────────────────┬──────────────────────────────┘
                       ▼ 程序恢复执行
┌─────────────────────────────────────────────────────┐
│  program_output（status: completed/incomplete）      │
│  → 模型收到精炼结果，生成最终 message                 │
└─────────────────────────────────────────────────────┘

{
"type":"function",
"name":"get_inventory",
"description":"Return an object with sku (string) and available_units (number).",
"parameters":{
"type":"object",
"properties":{"sku":{"type":"string"}},
"required":["sku"]
},
"output_schema":{
"type":"object",
"properties":{
"sku":{"type":"string"},
"available_units":{"type":"number"}
},
"required":["sku","available_units"]
},
"allowed_callers":["programmatic"]
}

const [stock, demand] = awaitPromise.all([
  tools.get_inventory({ sku: 'sku_123' }),
  tools.get_demand({ sku: 'sku_123' })
]);
text(JSON.stringify({
sku: stock.sku,
available_units: stock.available_units,
requested_units: demand.requested_units,
shortage_units: Math.max(demand.requested_units - stock.available_units, 0)
}));

生成的 JS 代码、call_id、fingerprint（用于恢复/重放）

[
{
"type":"program",
"call_id":"call_prog_123",
"code":"const [stock, demand] = await Promise.all([...]); text(JSON.stringify({...}));",
"fingerprint":"opaque_replay_state"
},
{
"type":"function_call",
"call_id":"call_inventory_123",
"name":"get_inventory",
"arguments":"{\"sku\":\"sku_123\"}",
"caller":{"type":"program","caller_id":"call_prog_123"}
},
{
"type":"function_call",
"call_id":"call_demand_123",
"name":"get_demand",
"arguments":"{\"sku\":\"sku_123\"}",
"caller":{"type":"program","caller_id":"call_prog_123"}
}
]

while (true) {
const response = await client.responses.create({
model: "gpt-5.6",
store: false,
    input,
    tools,
  });

  input.push(...response.output);

const calls = response.output.filter(item => item.type === "function_call");
if (calls.length === 0) {
// 收到最终 message，结束
break;
  }

for (const call of calls) {
const result = awaitexecuteTool(call.name, JSON.parse(call.arguments));
    input.push({
type: "function_call_output",
call_id: call.call_id,
output: JSON.stringify(result),
caller: call.caller,  // 必须原样保留
    });
  }
}

JavaScript（V8 隔离运行时）

┌─────────────────────────────────────────────────────┐
│  Messages API Request                                │
│  tools: [                                            │
│    { type: "code_execution_20260120",                │
│      name: "code_execution" },        ← 沙箱开关    │
│    { name: "query_database",                         │
│      allowed_callers: ["code_execution_20260120"] }  │
│  ]                                                   │
└──────────────────────┬──────────────────────────────┘
                       ▼
┌─────────────────────────────────────────────────────┐
│  模型生成 server_tool_use（Python 代码）              │
│  Anthropic 在 Code Execution 容器中执行               │
│  - 工具被暴露为 async Python 函数                     │
│  - 支持 asyncio.gather 并行                          │
│  - REPL 状态可跨 cell 持久化（20260120 版本）         │
└──────────────────────┬──────────────────────────────┘
                       ▼ 代码调用 client-owned 工具时暂停
┌─────────────────────────────────────────────────────┐
│  response 包含：                                     │
│  - server_tool_use（code_execution 代码）             │
│  - tool_use（caller 指向 code_execution 实例）      │
│  - container.id（必须回传以恢复执行）                 │
│  - stop_reason: "tool_use"                           │
└──────────────────────┬──────────────────────────────┘
                       ▼ 你的应用执行工具
┌─────────────────────────────────────────────────────┐
│  回传 tool_result（user 消息，仅含 tool_result）      │
│  必须带 container ID                                 │
└──────────────────────┬──────────────────────────────┘
                       ▼ 代码从断点恢复
┌─────────────────────────────────────────────────────┐
│  code_execution_tool_result（stdout/stderr）          │
│  → 模型收到精炼结果，生成最终 text                     │
└─────────────────────────────────────────────────────┘

import json

rows = json.loads(await query_database({"sql": "SELECT ..."}))
top_customers = sorted(rows, key=lambda x: x['revenue'], reverse=True)[:5]
print(f'Top 5 customers: {top_customers}')

模型发起的 code execution 请求，包含 Python 代码

{
"role":"assistant",
"content":[
{"type":"text","text":"I'll query the purchase history and analyze the results."},
{
"type":"server_tool_use",
"id":"srvtoolu_abc123",
"name":"code_execution",
"input":{"code":"import json\nrows = json.loads(await query_database({...}))\n..."}
},
{
"type":"tool_use",
"id":"toolu_def456",
"name":"query_database",
"input":{"sql":"SELECT ..."},
"caller":{
"type":"code_execution_20260120",
"tool_id":"srvtoolu_abc123"
}
}
],
"container":{
"id":"container_xyz789",
"expires_at":"2026-01-20T14:30:00Z"
},
"stop_reason":"tool_use"
}

messages = [{"role": "user", "content": "..."}]
container_id = None

whileTrue:
    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=4096,
        messages=messages,
        tools=tools,
        container=container_id,  # 续传时必传
    )

    messages.append({"role": "assistant", "content": response.content})
    container_id = response.container.idif response.container elseNone

# 检查是否有程序发起的 tool_use
    programmatic_calls = [
        block for block in response.content
if block.type == "tool_use"
and block.caller.type.startswith("code_execution")
    ]

ifnot programmatic_calls:
break# 程序已结束或没有工具调用

# 回传工具结果：user 消息只能包含 tool_result，不能有 text
    tool_results = []
for call in programmatic_calls:
        result = execute_tool(call.name, call.input)
        tool_results.append({
"type": "tool_result",
"tool_use_id": call.id,
"content": json.dumps(result),
        })

    messages.append({"role": "user", "content": tool_results})

Python（沙箱容器）

1. POST /v1/responses
   tools: [get_sales(region), programmatic_tool_calling]
   input: "查 West/East/Central 三地销售，找出最高收入区域"

2. 响应 output:
   ├─ program: "const results = {}; for (const r of ['West','East','Central']) {
   │     results[r] = await tools.get_sales({region: r});
   │   } text(JSON.stringify(results));"
   ├─ function_call: get_sales({region: "West"})  caller→program
   ├─ function_call: get_sales({region: "East"})  caller→program
   └─ function_call: get_sales({region: "Central"})  caller→program

3. 你的服务并行执行三个 get_sales，回传三个 function_call_output

4. 响应 output:
   └─ program_output: {"West": 120000, "East": 95000, "Central": 110000}

5. 响应 output:
   └─ message: "Central 区域收入最高，为 $110,000。"

1. POST /v1/messages
   tools: [code_execution_20260120, get_sales(allowed_callers: code_execution)]
   messages: [{role: user, content: "查三地销售..."}]

2. 响应:
   ├─ server_tool_use: code_execution (Python 循环代码)
   ├─ tool_use: get_sales({region: "West"})  caller→code_execution
   ├─ container: {id: "container_abc", expires_at: "..."}
   └─ stop_reason: "tool_use"

3. 你的服务执行 get_sales，回传 tool_result
   ⚠️ 必须带 container: "container_abc"
   ⚠️ user 消息只能含 tool_result

4. （可能重复 2-3 步，直到代码中所有工具调用完成）

5. 响应:
   ├─ code_execution_tool_result: stdout="{'West': 120000, ...}"
   └─ text: "Central 区域收入最高，为 $110,000。"

<tool_orchestration>
对 [bounded stage] 使用 Programmatic Tool Calling，仅调用 [eligible tools]。
并行执行独立调用。处理中间结果后，输出恰好 [schema]。

对 [semantic judgment / approval / validation] 使用 direct tool calling。
</tool_orchestration>

程序需要解析，不是读自然语言