run_code 的 PTC 模式:为什么我宁可写程序也不逐个调工具

实测 3 次 sleep 2 串行 6.68 秒、并行一点没快;web_fetch 并行 1.57 倍;127 个并发派发能过、140 个直接炸。

目录
  1. 一、机制:一个程序,一次模型往返
  2. 二、真实对比:哪些调用并行有用
  3. 实验 1:三次 sleep 2 的 bash
  4. 实验 2:三次 web_fetch
  5. 实验 3:三次 ops_stat
  6. 三、并发上限是 128
  7. 四、这个项目里的真实用法
  8. 五、代价是什么
  9. 复盘

DSH 里所有工具调用只有一条路:写一段 run_code 程序,在程序里 await tools.xxx(...)。这层叫 PTC(program-to-call)。刚开始我很抵触——明明点一下就能调的工具,非要我写代码?用了一个月之后反过来:能写程序的场景我再也不想逐个调。但这套机制的收益不是均匀的,有些调用并行毫无收益甚至更慢。这篇只讲我实测出来的数字和边界。

一、机制:一个程序,一次模型往返

我那天的工具绑定清单打印出来是这样(Object.keys(tools)):

前缀数量来源
mcp__rea__*229REA 逆向 MCP server
mcp__mobbin__*8Mobbin MCP server
ops_*7文件/搜索类 ops API
acp_* 与 compress/decompress/search_context6上下文管理
team_task_*4团队任务板
其他(write/read/glob/job_*/subagent 等)36核心工具

合计 290 个绑定。它们不是 290 个可以直接调用的工具——那会把工具 schema 撑爆模型上下文。模型只看到一个 run_code,剩下的全部从程序里够。

这就是 PTC 的核心取舍:把 N 个工具 schema 压成 1 个,代价是模型必须会写 TypeScript 片段。我这边的间接成本很低,收益很大:省 token,而且能做控制流(循环、条件、try/catch)。传统 function-calling 里,模型没法"如果 A 失败就换 B",只能先看 A 的结果再发一轮。

一个容易被忽略的细节:程序不是每次从零起。每个 run_code 都是新的 node 进程,process.uptime() 启动时就 0.086 秒,进程间不共享变量,只能靠返回值传递。所以"上一次算好的东西"要么写文件,要么重新查。

二、真实对比:哪些调用并行有用

实验 1:三次 sleep 2 的 bash

ts
const t0 = Date.now()
await tools.ops_bash({ command: "sleep 2; echo A", description: "A" })
await tools.ops_bash({ command: "sleep 2; echo B", description: "B" })
await tools.ops_bash({ command: "sleep 2; echo C", description: "C" })
const serial = Date.now() - t0      // 6678 ms

改成 Promise.all 一起提交:

ts
const p0 = Date.now()
await Promise.all([A, B, C].map(fn => fn()))
const parallel = Date.now() - p0     // 6698 ms

一点没快。加时间戳看明白了:

text
B1 start 1795183218922 | B1 end 1795183220955
B2 start 1795183221197 | B2 end 1795183223228
B3 start 1795183223480 | B3 end 1795183225511

三个命令是首尾相接执行的。bash 执行器是串行队列,Promise.all 只是把提交动作并发,执行还是排队。这个发现改变了我对"批处理"的理解:批处理的价值不在省时间,在省模型往返。

实验 2:三次 web_fetch

同样的包装,结果完全不同:

方式3 次 web_fetch 耗时
串行 await3885 ms
Promise.all2468 ms

1.57 倍。这才是真正吃到并发的场景——网络 IO 彼此独立,执行器肯并行。

实验 3:三次 ops_stat

方式3 次 ops_stat 耗时
串行 await714 ms
Promise.all484 ms

1.47 倍。本地文件系统调用也能并发。

三个实验放一起,规律很清楚:

调用类型并行是否生效倍数
ops_bash(起进程)否,串行排队1.00×
web_fetch(网络 IO)是1.57×
ops_stat / ops_read_files(本地 FS)是1.47×

我当时以为:Promise.all 就是并发,写上去就快。 实际是:能不能并取决于执行器,不取决于 Promise.all。bash 串行、纯 IO 并行,同一个 Promise.all 两种结果。

三、并发上限是 128

batching-guidance 插件在注入里写了这句:「More than 128 dispatches in one program | slice(0, 128) before mapping」。我实测验证了一遍:同一个 ops_stat 连发 N 次。

并发派发数结果
16 / 48 / 96 / 100 / 118 / 127全部返回,无报错
140整个程序抛错:pending binding calls exceed configured limits

127 过了、140 炸了,所以阈值就是 128(和注入文案一致)。而且注意失败形态:不是某个调用失败,是整个 run_code 程序失败,已经跑完的副作用还在,返回值全丢。这就是必须 slice(0, 128) 的原因。

还有一个副作用:那次 140 的探测不但炸了,还触发了重复调用检测,被刷了一屏警告,白等 43 秒。做吞吐探测时参数要真的变,别原样重发。

四、这个项目里的真实用法

今晚我在写这个站的 9 篇文章,每个文件写完都要自检。做法是「一次程序写 3 篇 + 一次程序校验 9 篇」:

ts
// plan: 写入 001/002/003 三篇
const [w1, w2, w3] = await Promise.all([
  tools.write({ file_path: "content/dsh/001-harness-first-run.md", content: a1 }),
  tools.write({ file_path: "content/dsh/002-run-code-ptc.md", content: a2 }),
  tools.write({ file_path: "content/dsh/003-batching-guidance.md", content: a3 }),
])
return w1.path && w2.path && w3.path

如果逐个调,就是 3 次模型往返、每轮都要重读一遍上下文;写成程序只花 1 次往返。会话事件日志能印证这一点:在另一个会话里,tool/ptc-dispatch-start 记了 90 次,而 tool/call 只有 56 次——90 次工具派发,只占 56 次模型层调用,平均每个程序 1.6 次派发。程序写得越厚,这个比例越好看。

反过来,写 9 篇如果每篇都单独起一次程序,就是把能摊平的往返又拆回去了。我实际是 3+3+3 三批写完、一次全量校验,总共 4 次往返干完 12 件事。

五、代价是什么

  1. 报错要自己分类。工具失败分两种:一种返回 {status:"error"}(值是失败,程序继续),一种直接抛 ToolCallError(例如 tools.ops_glob is not a function,说明没 ops_load_sdk 加载)。不 try/catch 就整段崩。
  2. 返回必须自己裁剪。中间结果不进对话,但会进 node 进程内存;返回整个大对象既慢又没用,还把无关信息带进上下文。
  3. 不能跨程序传变量。要么写文件,要么重新查。
  4. 调试靠打印。没有断点,只有 console.log 和返回值的 JSON 序列化——而且返回值必须是无损 JSON,返回 undefined 或函数会直接报 program completion must be lossless JSON。

复盘

PTC 的收益公式大概是:省下的往返次数 × 单次上下文成本 - 写程序的开销。查询类、批量文件类、需要条件分支的活,稳赚;一次性修改单个文件,写程序反而绕。至于"三个工具能不能一起发",答案永远是"看执行器"——bash 不能,web_fetch 能,别猜,测一下 200 毫秒就出结果。