niceeval 0.1.1 → 0.2.0

package/src/agents/bub.ts

@@ -2,8 +2,9 @@ import { defineSandboxAgent } from "../define.ts";
 import { requireEnv, getEnv } from "../util.ts";
 import { shared } from "./shared.ts";
 import { createCheckpoint, restoreCheckpoint } from "../sandbox/checkpoint.ts";
-import type { Agent, Sandbox, StreamEvent } from "../types.ts";
-import { createHash } from "node:crypto";
+import { mapBubSpans } from "../o11y/otlp/mappers/bub.ts";
+import type { Agent, Sandbox } from "../types.ts";
+import { createHash, randomUUID } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
@@ -37,15 +38,19 @@ const UV = "$HOME/.local/bin/uv";
 // 预制模板把 bub 装到 /usr/local/bin(见 sandbox/docker/Dockerfile),command -v 命中即用 → 跳过安装。
 const BUB = "$(command -v bub || echo $HOME/.local/bin/bub)";
 
-const BUB_OVERRIDE = "bub @ git+https://github.com/CorrectRoadH/bub.git@fix/streaming-usage-include-usage";
+// TODO(upstream): 这两个默认值钉在个人 fork 的修复分支上,等上游合并后改回发布版并删掉本注释。
+// 可用 NICEEVAL_BUB_OVERRIDE / NICEEVAL_BUB_OTEL_PLUGIN 覆盖,不必改源码。
+const BUB_OVERRIDE =
+  getEnv("NICEEVAL_BUB_OVERRIDE") ??
+  "bub @ git+https://github.com/CorrectRoadH/bub.git@fix/streaming-usage-include-usage";
 const BUB_OVERRIDE_FILE = "/tmp/bub-override.txt";
 const OTEL_PLUGIN =
+  getEnv("NICEEVAL_BUB_OTEL_PLUGIN") ??
   "git+https://github.com/CorrectRoadH/bub-contrib.git@fix/tapestore-otel-tape-entry-validation" +
-  "#subdirectory=packages/bub-tapestore-otel";
+    "#subdirectory=packages/bub-tapestore-otel";
 
 const INSTALL_SPEC = `bub --override(${BUB_OVERRIDE}) --with ${OTEL_PLUGIN}`;
 const INSTALL_HASH = createHash("md5").update(INSTALL_SPEC).digest("hex").slice(0, 12);
-const DEFAULT_WORKSPACE = "/home/sandbox/workspace";
 
 function diskCachePath(home: string): string {
   const homeKey = createHash("md5").update(home).digest("hex").slice(0, 8);
@@ -108,8 +113,10 @@ async function ensureBub(sb: Sandbox, home: string): Promise<void> {
     resolveInstall();
   } catch (e) {
     rejectInstall(e);
-    installsInProgress.delete(home);
     throw e;
+  } finally {
+    // 成功/失败都清锁:锁只表达「正在装」,装完后 memCheckpoints 是唯一缓存事实源。
+    installsInProgress.delete(home);
   }
 }
 
@@ -119,25 +126,6 @@ function tapePath(workspace: string, sessionId: string, bubHome: string): string
   return `${bubHome}/tapes/${w}__${s}.jsonl`;
 }
 
-function diagnose(
-  res: { exitCode: number; stdout: string; stderr: string },
-  events: StreamEvent[],
-  rawTape: string | undefined,
-): string {
-  const parts: string[] = [t("bub.diagnose.exitCode", { code: res.exitCode })];
-  if (rawTape === undefined) parts.push(t("bub.diagnose.noTape"));
-  else if (events.length === 0) parts.push(t("bub.diagnose.zeroEvents"));
-  const lastErr = [...events].reverse().find((e) => e.type === "error") as { type: "error"; message: string } | undefined;
-  if (lastErr) parts.push(t("bub.diagnose.lastError", { message: lastErr.message }));
-  const errTail = tail(res.stderr) || tail(res.stdout);
-  if (errTail) parts.push(t("bub.diagnose.outputTail", { tail: errTail }));
-  return parts.join(" · ");
-}
-
-function tail(s: string, n = 6): string {
-  return s.trim().split("\n").filter(Boolean).slice(-n).join(" ⏎ ").slice(0, 600);
-}
-
 export function bubAgent(config?: BubConfig): Agent {
   const getApiKey = () => config?.apiKey ?? requireEnv("BUB_API_KEY");
   const getApiBase = () => config?.apiBase ?? requireEnv("BUB_API_BASE");
@@ -146,7 +134,7 @@ export function bubAgent(config?: BubConfig): Agent {
 
   return defineSandboxAgent({
     name: "bub",
-    capabilities: { conversation: true, toolObservability: true, workspace: true, compactionObservability: true, tracing: true },
+    spanMapper: mapBubSpans,
 
     tracing: {
       protocol: "http/protobuf",
@@ -158,8 +146,11 @@ export function bubAgent(config?: BubConfig): Agent {
     },
 
     async setup(sb) {
-      const home = (await sb.runShell("printf '%s' $HOME")).stdout.trim() || "/home/node";
-      const workspace = DEFAULT_WORKSPACE;
+      // home 必须来自运行时探测:各 sandbox 后端不同(/home/node、/home/vercel-sandbox…),
+      // 兜一个后端专属常量会静默走错路径(tape 读不到 → 空事件流 → 负断言假通过)。
+      const home = (await sb.runShell("printf '%s' $HOME")).stdout.trim();
+      if (!home) throw new Error(t("bub.homeDetectFailed"));
+      const workspace = sb.workdir;
       sessionInfo.set(sb.sandboxId, { home, workspace });
       await ensureBub(sb, home);
 
@@ -191,30 +182,32 @@ export function bubAgent(config?: BubConfig): Agent {
 
     async send(input, ctx) {
       const sb = ctx.sandbox;
-      const info = sessionInfo.get(sb.sandboxId) ?? { home: "/home/node", workspace: DEFAULT_WORKSPACE };
+      const info = sessionInfo.get(sb.sandboxId);
+      if (!info) throw new Error(t("bub.setupNotRun"));
       const { home, workspace } = info;
       const bubHome = `${home}/.bub`;
-      const model = ctx.model ?? "gpt-5.4";
-      const sessionId = `fe-${sb.sandboxId}`;
-      ctx.session.id = sessionId;
+      // 会话契约:ctx.session.id 未记录时开新 tape(新 sessionId),否则 resume 传入的 id。
+      // tape 路径由 md5(workspace)+md5(sessionId) 决定,同沙箱多会话靠 sessionId 区分。
+      const sessionId = ctx.session.id ?? `fe-${sb.sandboxId}-${randomUUID().slice(0, 8)}`;
+      ctx.session.capture(sessionId);
 
-      const env = {
+      const env: Record<string, string> = {
         BUB_API_KEY: getApiKey(),
         BUB_API_BASE: getApiBase(),
-        BUB_MODEL: `openai:${model}`,
         BUB_HOME: bubHome,
         ...ctx.telemetry?.env,
       };
-      const escaped = input.text.replace(/'/g, "'\\''");
+      // model 归属:实验决定(ctx.model),省略时交给 bub 原生默认 / 用户环境,不硬编码。
+      if (ctx.model) env.BUB_MODEL = `openai:${ctx.model}`;
       const res = await sb.runShell(
-        `${BUB} --workspace ${workspace} run '${escaped}' --session-id ${sessionId}`,
+        `${BUB} --workspace ${workspace} run ${shared.shellQuote(input.text)} --session-id ${sessionId}`,
         { env, stream: true },
       );
 
       const raw = await sb.readFile(tapePath(workspace, sessionId, bubHome)).catch(() => undefined);
       const parsed = shared.parseBub(raw);
       const events = [...parsed.events];
-      if (res.exitCode !== 0) events.push({ type: "error", message: diagnose(res, parsed.events, raw) });
+      if (res.exitCode !== 0) events.push({ type: "error", message: shared.diagnoseFailure(res, parsed.events, raw) });
       return { events, usage: parsed.usage, status: res.exitCode === 0 ? "completed" : "failed" };
     },
   });

package/src/agents/claude-code.ts

@@ -43,7 +43,6 @@ export function claudeCodeAgent(config?: ClaudeCodeConfig): Agent {
 
   return defineSandboxAgent({
     name: "claude-code",
-    capabilities: { conversation: true, toolObservability: true, workspace: true, compactionObservability: true },
 
     async setup(sb) {
       // 预制模板已把 claude 烘焙进镜像(PATH 上)就跳过安装;否则 npm 全局装。
@@ -76,7 +75,7 @@ export function claudeCodeAgent(config?: ClaudeCodeConfig): Agent {
       if (ctx.model) args.push("--model", ctx.model);
       if (config?.maxTurns != null) args.push("--max-turns", String(config.maxTurns));
       if (ctx.flags.webResearch) args.push("--allowedTools", "WebSearch,WebFetch");
-      if (!ctx.session.isNew && ctx.session.id) args.push("--resume", ctx.session.id);
+      if (ctx.session.id) args.push("--resume", ctx.session.id);
       args.push(input.text);
 
       const env: Record<string, string> = { ANTHROPIC_API_KEY: getApiKey() };
@@ -85,10 +84,14 @@ export function claudeCodeAgent(config?: ClaudeCodeConfig): Agent {
 
       const res = await sb.runCommand("claude", args, { env, stream: true });
 
+      // 「最新 jsonl」而非按 session id 精确定位:--resume 会 fork 新 session id 的新文件,
+      // 精确匹配旧 id 会读到过期 transcript。send 串行,最新的一定是刚跑完的这次。
       const raw = await shared.captureLatestJsonl(sb, "~/.claude/projects");
-      ctx.session.id = shared.sessionIdFromClaudeTranscript(raw) ?? ctx.session.id;
+      ctx.session.capture(shared.sessionIdFromClaudeTranscript(raw));
       const parsed = shared.parseClaudeCode(raw);
-      return { events: parsed.events, usage: parsed.usage, status: res.exitCode === 0 ? "completed" : "failed" };
+      const events = [...parsed.events];
+      if (res.exitCode !== 0) events.push({ type: "error", message: shared.diagnoseFailure(res, parsed.events, raw) });
+      return { events, usage: parsed.usage, status: res.exitCode === 0 ? "completed" : "failed" };
     },
   });
 }

package/src/agents/codex.ts

@@ -1,6 +1,7 @@
 import { defineSandboxAgent } from "../define.ts";
 import { requireEnv, getEnv } from "../util.ts";
 import { shared } from "./shared.ts";
+import { mapCodexSpans } from "../o11y/otlp/mappers/codex.ts";
 import type { Agent, McpServer } from "../types.ts";
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -35,13 +36,15 @@ export function codexAgent(config?: CodexConfig): Agent {
 
   return defineSandboxAgent({
     name: "codex",
-    capabilities: { conversation: true, toolObservability: true, workspace: true, compactionObservability: true, tracing: true },
+    spanMapper: mapCodexSpans,
 
     async setup(sb, ctx) {
       // 预制模板已把 codex 烘焙进镜像(PATH 上)就跳过安装;否则 npm 全局装。
       await sb.runShell("command -v codex >/dev/null 2>&1 || npm install -g @openai/codex");
 
-      const model = ctx.model ?? "gpt-5.4";
+      // model 归属:实验决定(ctx.model);省略时不写 model 行,交给 codex CLI 原生默认,
+      // 不在 adapter 里硬编码一个会过期的模型名。
+      const modelLine = ctx.model ? `model = "${ctx.model}"\n` : "";
       const effort = (ctx.flags.effort as string | undefined) ?? "medium";
       const base = getBaseUrl();
 
@@ -49,7 +52,7 @@ export function codexAgent(config?: CodexConfig): Agent {
         await shared.writeFile(
           sb,
           "~/.codex/config.toml",
-          `model = "${model}"\n` +
+          modelLine +
             `model_provider = "s2a"\n` +
             `model_reasoning_effort = "${effort}"\n\n` +
             `[model_providers.s2a]\n` +
@@ -59,7 +62,7 @@ export function codexAgent(config?: CodexConfig): Agent {
             `wire_api = "responses"\n`,
         );
       } else {
-        await shared.writeFile(sb, "~/.codex/config.toml", `model = "${model}"\nmodel_reasoning_effort = "${effort}"\n`);
+        await shared.writeFile(sb, "~/.codex/config.toml", `${modelLine}model_reasoning_effort = "${effort}"\n`);
       }
 
       if (config?.mcpServers?.length) {
@@ -103,18 +106,20 @@ export function codexAgent(config?: CodexConfig): Agent {
     async send(input, ctx) {
       const sb = ctx.sandbox;
       const flags = "--json --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check";
-      const escaped = input.text.replace(/'/g, "'\\''");
-      const resuming = !ctx.session.isNew && ctx.session.id;
+      const prompt = shared.shellQuote(input.text);
+      const resuming = ctx.session.id;
       const cmd = resuming
-        ? `codex exec resume ${ctx.session.id} ${flags} '${escaped}'`
-        : `codex exec ${flags} '${escaped}'`;
+        ? `codex exec resume ${ctx.session.id} ${flags} ${prompt}`
+        : `codex exec ${flags} ${prompt}`;
 
       const res = await sb.runShell(cmd, { env: { CODEX_API_KEY: getApiKey() }, stream: true });
 
       const raw = shared.extractJsonlFromStdout(res.stdout);
-      ctx.session.id = shared.codexThreadId(res.stdout) ?? ctx.session.id;
+      ctx.session.capture(shared.codexThreadId(res.stdout));
       const parsed = shared.parseCodex(raw);
-      return { events: parsed.events, usage: parsed.usage, status: res.exitCode === 0 ? "completed" : "failed" };
+      const events = [...parsed.events];
+      if (res.exitCode !== 0) events.push({ type: "error", message: shared.diagnoseFailure(res, parsed.events, raw) });
+      return { events, usage: parsed.usage, status: res.exitCode === 0 ? "completed" : "failed" };
     },
   });
 }

package/src/agents/index.ts

@@ -4,6 +4,53 @@ export { defineAgent, defineSandboxAgent } from "../define.ts";
 export { shared } from "./shared.ts";
 export type { Shared } from "./shared.ts";
 
+// span → canonical GenAI 归一(只服务瀑布图,不喂断言)。私有埋点写自己的 spanMapper 时用:
+// tagSpan 把判定写回 span(原属性只增不改),heuristicTag 是通用兜底判定;mapCodexSpans 是
+// 现成的参考实现(无侵入接 codex 后端时直接声明 `spanMapper: mapCodexSpans`)。
+// 映射目标(什么属性亮起瀑布图的什么)见 docs-site/zh/guides/connect-otel.mdx「瀑布图画得准不准」。
+export { tagSpan, heuristicTag } from "../o11y/otlp/canonical.ts";
+export type { SpanTag } from "../o11y/otlp/canonical.ts";
+export { mapCodexSpans } from "../o11y/otlp/mappers/codex.ts";
+
+export { uiMessageStreamAgent } from "./ui-message-stream.ts";
+export type { UiMessageStreamAgentOptions, UIMessageLike, UIMessagePartLike } from "./ui-message-stream.ts";
+
+// SDK 原生事件流 → 标准事件的官方转换器(无侵入 adapter 只剩传输粘合)+ 通用 SSE 读帧器。
+export { sseJsonFrames, fromClaudeSdkMessages, fromPiAgentEvents, fromCodexThreadEvents } from "./sdk-streams.ts";
+export type {
+  SseFrameCursor,
+  ClaudeSdkMessageLike,
+  ClaudeSdkStream,
+  PiAgentEventLike,
+  PiAgentStream,
+  CodexThreadEventLike,
+  CodexThreadStream,
+} from "./sdk-streams.ts";
+
+// 通用「拼装方式」件:逐帧驱动循环、逐 token/参数增量累加器。见 docs-site/zh/guides/write-send.mdx——
+// 这些和任何具体协议无关,自己写 adapter 时优先拿这些拼,只有 transport(怎么发)与
+// 「帧类型 → 操作」这张映射表才是真正要手写的。会话续接与 HITL 停轮现场不再是可选件,
+// 而是 ctx.session(AgentSession)本身自带的存取器(history()/id+capture()、hold()/take())。
+export { driveFrameStream, deltaStream } from "./streaming.ts";
+export type { FrameReducer, FrameHook, DeltaOp, DeltaStreamSpec } from "./streaming.ts";
+
+// tracing 管线的内置实现 aiSdkOtel() 在 `niceeval/adapter/otel`(独立子路径,不从这里
+// re-export):OTel 三件套是可选 peer 依赖,只有 import 那个入口的项目才需要安装。
+export { fromAiSdk, aiSdkAgent } from "./ai-sdk.ts";
+export type {
+  AiSdkAgentOptions,
+  AiSdkGenerateContext,
+  AiSdkResultLike,
+  AiSdkStepLike,
+  AiSdkTelemetrySettings,
+  AiSdkToolCallLike,
+  AiSdkToolResultLike,
+  AiSdkTracing,
+  AiSdkTurn,
+  AiSdkTurnTelemetry,
+  AiSdkUsageLike,
+} from "./ai-sdk.ts";
+
 export { BUILTIN_AGENTS } from "./builtin.ts";
 export { claudeCodeAgent } from "./claude-code.ts";
 export { codexAgent } from "./codex.ts";
@@ -15,9 +62,9 @@ export type { BubConfig } from "./bub.ts";
 export type {
   Agent,
   AgentContext,
-  AgentCapabilities,
   AgentSession,
   AgentTracing,
+  SpanMapper,
   Telemetry,
   SandboxAgentDef,
   RemoteAgentDef,

package/src/agents/sdk-streams.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "vitest";
+
+import { fromClaudeSdkMessages, fromCodexThreadEvents, fromPiAgentEvents, sseJsonFrames } from "./sdk-streams.ts";
+
+function sseBody(frames: unknown[]): ReadableStream<Uint8Array> {
+  const text = frames.map((f) => `data: ${JSON.stringify(f)}\n\n`).join("") + "data: [DONE]\n\n";
+  return new Response(text).body!;
+}
+
+describe("sseJsonFrames", () => {
+  it("逐帧解析 data: JSON,跳过 [DONE],流结束返回 null", async () => {
+    const cursor = sseJsonFrames<{ n: number }>(sseBody([{ n: 1 }, { n: 2 }]));
+    expect(await cursor.next()).toEqual({ n: 1 });
+    expect(await cursor.next()).toEqual({ n: 2 });
+    expect(await cursor.next()).toBeNull();
+  });
+});
+
+describe("fromClaudeSdkMessages", () => {
+  it("system/init → sessionId;assistant/user → 事件对;result → usage", () => {
+    const s = fromClaudeSdkMessages();
+    expect(s.add({ type: "system", subtype: "init", session_id: "sess-1" })).toEqual([]);
+    expect(s.sessionId).toBe("sess-1");
+
+    const called = s.add({
+      type: "assistant",
+      message: { content: [{ type: "text", text: "查一下" }, { type: "tool_use", id: "tu1", name: "get_weather", input: { city: "北京" } }] },
+    });
+    expect(called).toEqual([
+      { type: "message", role: "assistant", text: "查一下" },
+      { type: "action.called", callId: "tu1", name: "get_weather", input: { city: "北京" } },
+    ]);
+
+    expect(s.add({ type: "user", message: { content: [{ type: "tool_result", tool_use_id: "tu1", content: "晴 21 度" }] } })).toEqual([
+      { type: "action.result", callId: "tu1", output: "晴 21 度", status: "completed" },
+    ]);
+
+    s.add({ type: "result", is_error: false, num_turns: 2, total_cost_usd: 0.01, usage: { input_tokens: 100, output_tokens: 20 } });
+    expect(s.usage).toMatchObject({ inputTokens: 100, outputTokens: 20, requests: 2, costUSD: 0.01 });
+    expect(s.failed).toBe(false);
+  });
+
+  it("markRejected:tool_result 落成 rejected;permission_denied 与 tool_result 只产一条", () => {
+    const s = fromClaudeSdkMessages();
+    s.markRejected("tu1");
+    expect(s.add({ type: "system", subtype: "permission_denied", tool_use_id: "tu1" })).toEqual([
+      { type: "action.result", callId: "tu1", status: "rejected" },
+    ]);
+    // SDK 若随后也发 tool_result,不重复
+    expect(s.add({ type: "user", message: { content: [{ type: "tool_result", tool_use_id: "tu1", content: "denied" }] } })).toEqual([]);
+  });
+
+  it("stream_event 等未知帧返回 []", () => {
+    expect(fromClaudeSdkMessages().add({ type: "stream_event" })).toEqual([]);
+  });
+});
+
+describe("fromPiAgentEvents", () => {
+  it("message_end → message/thinking + usage 累加;tool_execution_* → 事件对", () => {
+    const s = fromPiAgentEvents();
+    expect(s.add({ type: "tool_execution_start", toolCallId: "c1", toolName: "get_weather", args: { city: "上海" } })).toEqual([
+      { type: "action.called", callId: "c1", name: "get_weather", input: { city: "上海" } },
+    ]);
+    expect(s.add({ type: "tool_execution_end", toolCallId: "c1", result: { temp: 18 }, isError: false })).toEqual([
+      { type: "action.result", callId: "c1", output: { temp: 18 }, status: "completed" },
+    ]);
+    const msgEvents = s.add({
+      type: "message_end",
+      message: {
+        role: "assistant",
+        content: [{ type: "thinking", thinking: "想想" }, { type: "text", text: "18 度" }],
+        usage: { input: 10, output: 5, cacheRead: 1, cacheWrite: 2, cost: { total: 0.001 } },
+      },
+    });
+    expect(msgEvents).toEqual([
+      { type: "message", role: "assistant", text: "18 度" },
+      { type: "thinking", text: "想想" },
+    ]);
+    expect(s.usage).toMatchObject({ inputTokens: 10, outputTokens: 5, requests: 1 });
+  });
+
+  it("markRejected:isError 的 tool_execution_end 落成 rejected 而非 failed", () => {
+    const s = fromPiAgentEvents();
+    s.markRejected("c9");
+    expect(s.add({ type: "tool_execution_end", toolCallId: "c9", isError: true })).toEqual([
+      { type: "action.result", callId: "c9", output: undefined, status: "rejected" },
+    ]);
+  });
+});
+
+describe("fromCodexThreadEvents", () => {
+  it("thread.started → threadId;agent_message/reasoning → 消息;turn.failed → error", () => {
+    const s = fromCodexThreadEvents();
+    s.add({ type: "thread.started", thread_id: "t-1" });
+    expect(s.threadId).toBe("t-1");
+    expect(s.add({ type: "item.completed", item: { type: "agent_message", text: "改好了" } })).toEqual([
+      { type: "message", role: "assistant", text: "改好了" },
+    ]);
+    expect(s.add({ type: "item.completed", item: { type: "reasoning", text: "先看文件" } })).toEqual([
+      { type: "thinking", text: "先看文件" },
+    ]);
+    expect(s.failed).toBe(false);
+    expect(s.add({ type: "turn.failed", error: { message: "boom" } })).toEqual([{ type: "error", message: "boom" }]);
+    expect(s.failed).toBe(true);
+  });
+
+  it("command_execution:started 发 called,completed 只补 result(按 exit_code 判状态)", () => {
+    const s = fromCodexThreadEvents();
+    expect(s.add({ type: "item.started", item: { type: "command_execution", id: "c1", command: "ls" } })).toEqual([
+      { type: "action.called", callId: "c1", name: "command_execution", input: { command: "ls" } },
+    ]);
+    expect(
+      s.add({ type: "item.completed", item: { type: "command_execution", id: "c1", command: "ls", exit_code: 0, aggregated_output: "a.txt" } }),
+    ).toEqual([{ type: "action.result", callId: "c1", output: { output: "a.txt", exit_code: 0 }, status: "completed" }]);
+  });
+
+  it("只有 completed 的工具项也成对;失败 exit_code → failed", () => {
+    const s = fromCodexThreadEvents();
+    expect(s.add({ type: "item.completed", item: { type: "command_execution", id: "c2", command: "false", exit_code: 1 } })).toEqual([
+      { type: "action.called", callId: "c2", name: "command_execution", input: { command: "false" } },
+      { type: "action.result", callId: "c2", output: { output: null, exit_code: 1 }, status: "failed" },
+    ]);
+  });
+
+  it("mcp_tool_call 带 server 前缀;turn.completed 聚合 usage", () => {
+    const s = fromCodexThreadEvents();
+    expect(s.add({ type: "item.completed", item: { type: "mcp_tool_call", id: "m1", server: "kb", tool: "search", arguments: { q: "x" } } })).toEqual([
+      { type: "action.called", callId: "m1", name: "kb.search", input: { q: "x" } },
+      { type: "action.result", callId: "m1", output: null, status: "completed" },
+    ]);
+    expect(s.usage).toBeUndefined();
+    s.add({ type: "turn.completed", usage: { input_tokens: 100, cached_input_tokens: 40, output_tokens: 7 } });
+    expect(s.usage).toEqual({ inputTokens: 100, outputTokens: 7, cacheReadTokens: 40, requests: 1 });
+  });
+
+  it("file_change 每个文件一对 called/result", () => {
+    const s = fromCodexThreadEvents();
+    expect(
+      s.add({ type: "item.completed", item: { type: "file_change", id: "p1", changes: [{ path: "a.ts", kind: "update" }] } }),
+    ).toEqual([
+      { type: "action.called", callId: "p1#0", name: "file_change", input: { path: "a.ts", kind: "update" } },
+      { type: "action.result", callId: "p1#0", output: { path: "a.ts", kind: "update" }, status: "completed" },
+    ]);
+  });
+});