@downcity/agent 1.1.258 → 1.1.260

package/scripts/multi-agent-plugin-isolation.test.mjs

@@ -1,161 +1,100 @@
 /**
  * @file 验证多个 Agent 经 session.prompt 执行 plugin_call 时保持 registry 隔离。
  *
- * 关键点（中文）
- * - 先创建 Agent A，再创建 Agent B，锁住历史全局 runtime 的覆盖顺序。
- * - 两个 Session 并发进入模型 tool loop，验证异步作用域不会造成 registry 串线。
- * - 第二次模型请求必须收到各自 plugin action 返回的 owner。
+ * 两个 CityModel 并发进入原生 LanguageModelV3 tool loop，第二次模型调用必须只
+ * 收到各自 Agent plugin action 返回的 owner。
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { MockLanguageModelV3 } from "ai/test";
 
 import { Agent } from "../bin/index.js";
-import {
-  createAction,
-  createPlugin,
-} from "../bin/plugin/core/PluginActionFactory.js";
-import { CITY_MODEL_INVOKER, CITY_MODEL_KIND } from "@downcity/type";
+import { createAction, createPlugin } from "../bin/plugin/core/PluginActionFactory.js";
+import { CITY_MODEL_KIND } from "@downcity/type";
 
-/**
- * 写入一组 OpenAI-compatible SSE chunk。
- */
-function write_openai_sse(response, chunks) {
-  response.writeHead(200, {
-    "content-type": "text/event-stream; charset=utf-8",
-    "cache-control": "no-cache",
-    connection: "keep-alive",
-  });
-  for (const chunk of chunks) {
-    const payload = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
-    response.write(`data: ${payload}\n\n`);
-  }
-  response.end();
+/** 构造 AI SDK V3 usage。 */
+function create_usage() {
+  return {
+    inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 1, text: 1, reasoning: 0 },
+  };
 }
 
-/**
- * 读取 HTTP JSON 请求体。
- */
-async function read_json_body(request) {
-  const raw = await new Promise((resolve, reject) => {
-    let data = "";
-    request.on("data", (chunk) => {
-      data += chunk;
-    });
-    request.on("end", () => resolve(data));
-    request.on("error", reject);
-  });
-  return JSON.parse(String(raw || "{}"));
+/** 返回普通文本模型流。 */
+function create_text_stream(text) {
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "text-start", id: "text_1" });
+        controller.enqueue({ type: "text-delta", id: "text_1", delta: text });
+        controller.enqueue({ type: "text-end", id: "text_1" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "stop", raw: "stop" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
 }
 
-/**
- * 返回普通文本模型流。
- */
-function write_text_response(response, input) {
-  write_openai_sse(response, [
-    {
-      id: input.id,
-      object: "chat.completion.chunk",
-      created: 1,
-      model: input.model,
-      choices: [
-        {
-          index: 0,
-          delta: { role: "assistant", content: input.text },
-          finish_reason: null,
-        },
-      ],
-    },
-    {
-      id: input.id,
-      object: "chat.completion.chunk",
-      created: 1,
-      model: input.model,
-      choices: [
-        {
-          index: 0,
-          delta: {},
-          finish_reason: "stop",
-        },
-      ],
-    },
-    "[DONE]",
-  ]);
+/** 返回一次 plugin_call tool call。 */
+function create_plugin_call_stream(model_id) {
+  const tool_input = JSON.stringify({
+    plugin: "skill",
+    action: "lookup",
+    payload: {},
+  });
+  const call_id = `call_${model_id}`;
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "tool-input-start", id: call_id, toolName: "plugin_call" });
+        controller.enqueue({ type: "tool-input-delta", id: call_id, delta: tool_input });
+        controller.enqueue({ type: "tool-input-end", id: call_id });
+        controller.enqueue({
+          type: "tool-call",
+          toolCallId: call_id,
+          toolName: "plugin_call",
+          input: tool_input,
+        });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "tool-calls", raw: "tool_calls" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
 }
 
-/**
- * 返回一次 plugin_call tool call。
- */
-function write_plugin_call_response(response, model) {
-  write_openai_sse(response, [
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: { role: "assistant" },
-          finish_reason: null,
-        },
-      ],
-    },
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: {
-            tool_calls: [
-              {
-                index: 0,
-                id: `call_${model}`,
-                type: "function",
-                function: {
-                  name: "plugin_call",
-                  arguments: JSON.stringify({
-                    plugin: "skill",
-                    action: "lookup",
-                    payload: {},
-                  }),
-                },
-              },
-            ],
-          },
-          finish_reason: null,
-        },
-      ],
+/** 创建原生 LanguageModelV3 CityModel。 */
+function create_test_model(model_id, model_requests) {
+  let request_count = 0;
+  const language_model = new MockLanguageModelV3({
+    modelId: model_id,
+    doStream: async (options) => {
+      if (!Array.isArray(options.tools) || options.tools.length === 0) {
+        return create_text_stream(`Title ${model_id}`);
+      }
+      request_count += 1;
+      const requests = model_requests.get(model_id) ?? [];
+      requests.push(options);
+      model_requests.set(model_id, requests);
+      return request_count === 1
+        ? create_plugin_call_stream(model_id)
+        : create_text_stream("done");
     },
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: {},
-          finish_reason: "tool_calls",
-        },
-      ],
-    },
-    "[DONE]",
-  ]);
-}
-
-/**
- * 创建绑定测试 HTTP 服务的 CityModel。
- */
-function create_test_model(base_url, model_id) {
-  return Object.freeze({
+  });
+  return Object.assign(language_model, {
     id: model_id,
     name: model_id,
     description: "Multi-agent plugin isolation model",
@@ -163,19 +102,10 @@ function create_test_model(base_url, model_id) {
     tags: [],
     meta: {},
     kind: CITY_MODEL_KIND,
-    [CITY_MODEL_INVOKER]: {
-      connection: () => ({
-        base_url,
-        api_key: "test_key",
-        model_id,
-      }),
-    },
   });
 }
 
-/**
- * 创建返回固定 owner 的 skill plugin。
- */
+/** 创建返回固定 owner 的 skill plugin。 */
 function create_owner_plugin(owner, executed_owners) {
   return createPlugin({
     name: "skill",
@@ -200,63 +130,19 @@ function create_owner_plugin(owner, executed_owners) {
 test("multiple session prompts use only their owning Agent plugin registry", async () => {
   const model_requests = new Map();
   const executed_owners = [];
-  const server = http.createServer(async (request, response) => {
-    const url = new URL(String(request.url || "/"), "http://127.0.0.1");
-    if (
-      request.method !== "POST" ||
-      url.pathname !== "/v1/ai/chat/completions"
-    ) {
-      response.writeHead(404);
-      response.end("not found");
-      return;
-    }
-
-    const body = await read_json_body(request);
-    const model = String(body.model || "");
-    if (!Array.isArray(body.tools)) {
-      write_text_response(response, {
-        id: `chatcmpl_${model}_title`,
-        model,
-        text: `Title ${model}`,
-      });
-      return;
-    }
-
-    const requests = model_requests.get(model) || [];
-    requests.push(body);
-    model_requests.set(model, requests);
-    if (requests.length === 1) {
-      write_plugin_call_response(response, model);
-      return;
-    }
-    write_text_response(response, {
-      id: `chatcmpl_${model}_done`,
-      model,
-      text: "done",
-    });
-  });
-
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  assert.ok(address && typeof address === "object");
-  const base_url = `http://127.0.0.1:${String(address.port)}/v1/ai`;
-  const root_a = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-plugin-isolation-a-"),
-  );
-  const root_b = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-plugin-isolation-b-"),
-  );
+  const root_a = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-isolation-a-"));
+  const root_b = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-isolation-b-"));
   const agent_a = new Agent({
     id: "agent_a",
     path: root_a,
     plugins: [create_owner_plugin("agent_a", executed_owners)],
-    model: create_test_model(base_url, "model_a"),
+    model: create_test_model("model_a", model_requests),
   });
   const agent_b = new Agent({
     id: "agent_b",
     path: root_b,
     plugins: [create_owner_plugin("agent_b", executed_owners)],
-    model: create_test_model(base_url, "model_b"),
+    model: create_test_model("model_b", model_requests),
   });
 
   try {
@@ -266,24 +152,17 @@ test("multiple session prompts use only their owning Agent plugin registry", asy
       session_a.prompt({ query: "Call your skill plugin" }),
       session_b.prompt({ query: "Call your skill plugin" }),
     ]);
-    const [result_a, result_b] = await Promise.all([
-      turn_a.finished,
-      turn_b.finished,
-    ]);
+    const [result_a, result_b] = await Promise.all([turn_a.finished, turn_b.finished]);
 
     assert.equal(result_a.success, true);
     assert.equal(result_b.success, true);
     assert.deepEqual([...executed_owners].sort(), ["agent_a", "agent_b"]);
-    for (const [model, owner] of [
-      ["model_a", "agent_a"],
-      ["model_b", "agent_b"],
-    ]) {
-      const requests = model_requests.get(model) || [];
+    for (const [model_id, owner] of [["model_a", "agent_a"], ["model_b", "agent_b"]]) {
+      const requests = model_requests.get(model_id) ?? [];
       assert.equal(requests.length, 2);
-      assert.match(JSON.stringify(requests[1].messages), new RegExp(owner));
+      assert.match(JSON.stringify(requests[1].prompt), new RegExp(owner));
     }
   } finally {
     await Promise.all([agent_a.dispose(), agent_b.dispose()]);
-    await new Promise((resolve) => server.close(() => resolve()));
   }
 });

package/scripts/session-messages.test.mjs

@@ -15,18 +15,50 @@ import { compose_session_compaction } from "../bin/session/messages/SessionMessa
 import { to_executor_history } from "../bin/session/messages/SessionMessageCodec.js";
 import { MockLanguageModelV3 } from "ai/test";
 
-async function create_recorder(session_id = "session-recorder-test") {
+/** 可暂停一次 Assistant 草稿写入，用于稳定复现并发写入顺序。 */
+class PausingAssistantMessageStore extends JsonlSessionMessageStore {
+  next_assistant_write = null;
+
+  pause_next_assistant_write() {
+    let mark_started;
+    let release;
+    const started = new Promise((resolve) => {
+      mark_started = resolve;
+    });
+    const wait = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.next_assistant_write = { mark_started, wait };
+    return { started, release };
+  }
+
+  async write_assistant_message(message) {
+    const pending = this.next_assistant_write;
+    if (pending) {
+      this.next_assistant_write = null;
+      pending.mark_started();
+      await pending.wait;
+    }
+    await super.write_assistant_message(message);
+  }
+}
+
+async function create_recorder(
+  session_id = "session-recorder-test",
+  create_store = (options) => new JsonlSessionMessageStore(options),
+) {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-recorder-"));
   const file_path = path.join(root_path, "active.jsonl");
   const assistant_message_file_path = path.join(root_path, "assistant_message.json");
   const events = [];
+  const store = create_store({ session_id, file_path });
   const recorder = new SessionMessages({
     session_id,
-    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    store,
     publish: (mutation) => events.push(mutation),
   });
   await recorder.initialize();
-  return { recorder, events, file_path, assistant_message_file_path };
+  return { recorder, store, events, file_path, assistant_message_file_path };
 }
 
 async function read_jsonl(file_path) {
@@ -249,6 +281,85 @@ test("Approval Broker 只接受已经准备完整输入的 Tool", async () => {
   );
 });
 
+test("流式更新与 Approval 共享 Assistant revision 写队列", async () => {
+  const session_id = "approval-revision-queue-test";
+  const { recorder, store, events } = await create_recorder(
+    session_id,
+    (options) => new PausingAssistantMessageStore(options),
+  );
+  const approval_broker = new SessionApprovalBroker({ session_id, messages: recorder });
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-approval-race",
+    segment_index: 1,
+  });
+  await writer.prepare_tool_input({
+    tool_call_id: "call-approval-race",
+    tool_name: "shell_exec",
+    input: {
+      cmd: "ls -la ~",
+      sandbox: "unrestricted",
+      reason: "验证审批写入顺序",
+    },
+  });
+  await writer.apply_chunk({ type: "text-start", id: "text-race" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-race", delta: "准备执行" });
+
+  const gate = store.pause_next_assistant_write();
+  const stream_write = writer.apply_chunk({
+    type: "text-delta",
+    id: "text-race",
+    delta: "命令",
+  });
+  await gate.started;
+  const approval_write = approval_broker.request({
+    shell_id: "shell-approval-race",
+    tool_call_id: "call-approval-race",
+    tool_name: "shell_exec",
+    session_id,
+    turn_id: "turn-approval-race",
+    command: "ls -la ~",
+    cwd: "/workspace",
+    reason: "验证审批写入顺序",
+    operation: "exec",
+    timeout_ms: 60_000,
+  });
+
+  // 让 Approval 路径有机会进入写入；旧实现会在这里基于同一 revision 提交。
+  await new Promise((resolve) => setImmediate(resolve));
+  gate.release();
+  const [, approval_handle] = await Promise.all([stream_write, approval_write]);
+
+  const assistant = recorder.get_message(writer.message_id);
+  const tool = assistant.parts.find((part) => part.type === "tool");
+  const text_part = assistant.parts.find((part) => part.type === "text");
+  assert.equal(assistant.revision, 6);
+  assert.equal(tool.state, "approval-required");
+  assert.equal(tool.approval.approval_id, approval_handle.approval_id);
+  assert.equal(tool.input.cmd, "ls -la ~");
+  assert.equal(text_part.text, "准备执行命令");
+  assert.deepEqual(
+    events
+      .filter((event) => event.message_id === writer.message_id)
+      .map((event) => event.revision),
+    [1, 2, 3, 4, 5, 6],
+  );
+  assert.equal(
+    events.some(
+      (event) =>
+        event.variant === "part" &&
+        event.type === "tool" &&
+        event.part.state === "approval-required",
+    ),
+    true,
+  );
+
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "denied",
+  });
+  assert.equal(await approval_handle.decision, "denied");
+});
+
 test("不同模型 step 重复使用 Text chunk ID 时仍保持真实 Part 顺序", async () => {
   const { recorder, file_path } = await create_recorder("reused-text-id-order-test");
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });

package/scripts/shell-sandbox-env.test.mjs

@@ -1,93 +1,80 @@
 /**
- * @file 验证 shell safe sandbox 注入的临时目录环境变量。
- *
- * 关键点（中文）
- * - 测试编译后的 shell 包导出，确保最终 package 产物包含一致行为。
- * - zsh heredoc 会读取 `TMPPREFIX` 创建临时文件，因此必须指向 sandbox tmp。
+ * @file 验证 Safe Sandbox 环境变量收敛与临时目录映射。
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
 import path from "node:path";
 
-import { buildMacOsSeatbeltSandboxEnv } from "@downcity/shell/sandbox/MacOsSeatbeltSandbox.js";
-import { buildLinuxBubblewrapSandboxEnv } from "@downcity/shell/sandbox/LinuxBubblewrapSandbox.js";
-import {
-  resolveSandboxEnvAllowlist,
-} from "@downcity/shell/sandbox/SandboxConfigResolver.js";
-
-function createParams() {
-  const rootPath = "/tmp/downcity-shell-env/project";
-  const sandboxDir = path.join(rootPath, ".downcity", "sandbox");
-  const tmpDir = path.join(sandboxDir, "tmp");
-  const cacheDir = path.join(sandboxDir, ".cache");
+import { build_macos_sandbox_env } from "@downcity/shell/sandbox/MacOsSeatbelt.js";
+import { build_linux_sandbox_env } from "@downcity/shell/sandbox/LinuxBubblewrap.js";
+import { resolve_sandbox_policy } from "@downcity/shell/sandbox/SandboxPolicy.js";
 
+function create_request() {
+  const root_path = "/tmp/downcity-shell-env/project";
+  const sandbox_dir = path.join(root_path, ".downcity", "sandbox");
   return {
-    executionId: "sh_test",
-    executionDir: path.join(rootPath, ".downcity", "shell", "sh_test"),
+    execution_id: "sh_test",
+    execution_dir: path.join(root_path, ".downcity", "shell", "sh_test"),
     cmd: "printf hello",
-    cwd: rootPath,
-    shellPath: "/bin/zsh",
+    cwd: root_path,
+    shell_path: "/bin/zsh",
     login: true,
-    baseEnv: {
+    base_env: {
       PATH: "/usr/bin:/bin",
       LANG: "C.UTF-8",
       DC_SESSION_ID: "session_test",
     },
-    config: {
+    policy: {
       backend: "macos-seatbelt",
-      rootPath,
-      sandboxDir,
-      homeDir: sandboxDir,
-      tmpDir,
-      cacheDir,
-      envAllowlist: ["PATH", "LANG"],
-      writablePaths: [rootPath, sandboxDir],
-      networkMode: "full",
+      root_path,
+      sandbox_dir,
+      home_dir: sandbox_dir,
+      tmp_dir: path.join(sandbox_dir, "tmp"),
+      cache_dir: path.join(sandbox_dir, ".cache"),
+      env_allowlist: ["PATH", "LANG"],
+      read_only_paths: ["/usr", "/bin"],
+      read_write_paths: [root_path],
+      network_mode: "full",
+      fingerprint: "policy_test",
     },
   };
 }
 
-function assertSandboxTmpEnv(env, tmpDir) {
-  assert.equal(env.TMPDIR, tmpDir);
-  assert.equal(env.TMP, tmpDir);
-  assert.equal(env.TEMP, tmpDir);
-  assert.equal(env.TEMPDIR, tmpDir);
-  assert.equal(env.TMPPREFIX, path.join(tmpDir, "zsh"));
-  assert.equal(env.DC_SANDBOX_TMP, tmpDir);
+function assert_sandbox_tmp_env(env, tmp_dir) {
+  assert.equal(env.TMPDIR, tmp_dir);
+  assert.equal(env.TMP, tmp_dir);
+  assert.equal(env.TEMP, tmp_dir);
+  assert.equal(env.TEMPDIR, tmp_dir);
+  assert.equal(env.TMPPREFIX, path.join(tmp_dir, "zsh"));
+  assert.equal(env.DC_SANDBOX_TMP, tmp_dir);
 }
 
-test("macOS seatbelt sandbox env points zsh TMPPREFIX at sandbox tmp", () => {
-  const params = createParams();
-  const env = buildMacOsSeatbeltSandboxEnv(params);
-
-  assertSandboxTmpEnv(env, params.config.tmpDir);
+test("macOS safe env points temporary variables at sandbox tmp", () => {
+  const request = create_request();
+  const env = build_macos_sandbox_env(request);
+  assert_sandbox_tmp_env(env, request.policy.tmp_dir);
 });
 
-test("Linux bubblewrap sandbox env points zsh TMPPREFIX at sandbox tmp", () => {
-  const params = createParams();
-  const env = buildLinuxBubblewrapSandboxEnv({
-    ...params,
-    config: {
-      ...params.config,
-      backend: "linux-bubblewrap",
-    },
+test("Linux safe env points temporary variables at sandbox tmp", () => {
+  const request = create_request();
+  const env = build_linux_sandbox_env({
+    ...request,
+    policy: { ...request.policy, backend: "linux-bubblewrap" },
   });
-
-  assertSandboxTmpEnv(env, params.config.tmpDir);
+  assert_sandbox_tmp_env(env, request.policy.tmp_dir);
 });
 
-test("safe sandbox env allowlist includes explicit agent env keys only", () => {
-  const allowlist = resolveSandboxEnvAllowlist({
+test("safe policy exports explicit agent env keys only", async () => {
+  const policy = await resolve_sandbox_policy({
     rootPath: "/tmp/downcity-shell-env/project",
     env: {
       DYNAMIC_ENV_REPRO: "dynamic_value",
       DC_DYNAMIC_REPRO: "dc_value",
     },
-  });
-
-  assert.equal(allowlist.includes("PATH"), true);
-  assert.equal(allowlist.includes("DYNAMIC_ENV_REPRO"), true);
-  assert.equal(allowlist.includes("DC_DYNAMIC_REPRO"), true);
-  assert.equal(allowlist.includes("HOST_ONLY_ENV_REPRO"), false);
+  }, {});
+  assert.equal(policy.env_allowlist.includes("PATH"), true);
+  assert.equal(policy.env_allowlist.includes("DYNAMIC_ENV_REPRO"), true);
+  assert.equal(policy.env_allowlist.includes("DC_DYNAMIC_REPRO"), true);
+  assert.equal(policy.env_allowlist.includes("HOST_ONLY_ENV_REPRO"), false);
 });