@downcity/agent 1.1.337 → 1.1.399

package/scripts/session-turn-failure.test.mjs

@@ -11,7 +11,7 @@ import test from "node:test";
 import { SessionInteractions } from "../bin/session/control/SessionInteractions.js";
 import { SessionShellApprovalAdapter } from "../bin/session/execution/tools/SessionShellApprovalAdapter.js";
 import { JsonlSessionMessageStore } from "../bin/workspace/store/JsonlSessionMessageStore.js";
-import { LocalFileSystem } from "../bin/workspace/LocalFileSystem.js";
+import { LocalFileSystem } from "@downcity/workspace";
 import { SessionMessages } from "../bin/session/SessionMessages.js";
 import { SessionEventHub } from "../bin/session/runtime/SessionEventHub.js";
 import { SessionLoop } from "../bin/session/SessionLoop.js";
@@ -60,6 +60,28 @@ async function create_turn_harness(execute_turn) {
   return { messages, turn };
 }
 
+/** 通过 Downcity Model Protocol 写入一个完整文本 part。 */
+async function write_text(output, content_id, text) {
+  await output.write_model_event({ type: "text_start", content_id });
+  await output.write_model_event({ type: "text_delta", content_id, delta: text });
+  await output.write_model_event({ type: "text_finish", content_id });
+}
+
+/** 通过 Downcity Model Protocol 写入一个完整工具调用。 */
+async function write_tool_call(output, input) {
+  await output.write_model_event({
+    type: "tool_call_start",
+    content_id: input.content_id,
+    tool_call_id: input.tool_call_id,
+    tool_name: input.tool_name,
+  });
+  await output.write_model_event({
+    type: "tool_call_finish",
+    content_id: input.content_id,
+    input: input.tool_input,
+  });
+}
+
 test("Provider 在输出前失败时只持久化 Error Message", async () => {
   const { messages, turn } = await create_turn_harness(async () => ({
     success: false,
@@ -80,6 +102,31 @@ test("Provider 在输出前失败时只持久化 Error Message", async () => {
   assert.equal(page.items[1].message, "quota exceeded");
 });
 
+test("SessionLoop 只在 canonical 用户消息写入后返回 prompt 句柄", async () => {
+  let finish_execution;
+  const execution_finished = new Promise((resolve) => {
+    finish_execution = resolve;
+  });
+  const { messages, turn } = await create_turn_harness(async () => {
+    await execution_finished;
+    return {
+      success: true,
+      text: "done",
+      deferred_persisted_user_messages: [],
+    };
+  });
+
+  const handle = await turn.prompt({ query: "已持久化的输入" });
+  const page = await messages.list_messages();
+
+  assert.equal(handle.result, null);
+  assert.deepEqual(page.items.map((message) => message.type), ["user"]);
+  assert.equal(page.items[0].parts[0].text, "已持久化的输入");
+
+  finish_execution();
+  await handle.finished;
+});
+
 test("SessionLoop 在 Turn 收口后释放其 SessionTurnContext", async () => {
   let release_count = 0;
   const { turn } = await create_turn_harness(async (turn_context) => {
@@ -107,13 +154,7 @@ test("SessionLoop 在 Turn 收口后释放其 SessionTurnContext", async () => {
 test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Error Message", async () => {
   const { messages, turn } = await create_turn_harness(async (turn_context) => {
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({ type: "text-start", id: "text-1" });
-    await turn_context.output.assistant.write_chunk({
-      type: "text-delta",
-      id: "text-1",
-      delta: "partial response",
-    });
-    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
+    await write_text(turn_context.output.assistant, "text-1", "partial response");
     return {
       success: false,
       text: "partial response",
@@ -141,15 +182,16 @@ test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Erro
 test("Assistant 失败收口时不会遗留 input-streaming Tool Part", async () => {
   const { messages, turn } = await create_turn_harness(async (turn_context) => {
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-start",
-      toolCallId: "call-1",
-      toolName: "shell_exec",
+    await turn_context.output.assistant.write_model_event({
+      type: "tool_call_start",
+      content_id: "tool-1",
+      tool_call_id: "call-1",
+      tool_name: "shell_exec",
     });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-delta",
-      toolCallId: "call-1",
-      inputTextDelta: '{"cmd":"pwd"}',
+    await turn_context.output.assistant.write_model_event({
+      type: "tool_call_delta",
+      content_id: "tool-1",
+      input_delta: '{"cmd":"pwd"}',
     });
     return {
       success: false,
@@ -170,48 +212,36 @@ test("Assistant 失败收口时不会遗留 input-streaming Tool Part", async ()
   assert.equal(assistant?.parts[0]?.error, "stream interrupted");
 });
 
-test("Turn 使用 step canonical chunks 保持 Tool 与最终正文顺序", async () => {
+test("Turn 使用标准模型事件保持 Tool 与最终正文顺序", async () => {
   const { messages, turn } = await create_turn_harness(async (turn_context) => {
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-start",
-      toolCallId: "call-1",
-      toolName: "shell_exec",
+    await write_tool_call(turn_context.output.assistant, {
+      content_id: "tool-1",
+      tool_call_id: "call-1",
+      tool_name: "shell_exec",
+      tool_input: { cmd: "pwd" },
     });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-available",
-      toolCallId: "call-1",
-      toolName: "shell_exec",
-      input: { cmd: "pwd" },
-    });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-output-available",
-      toolCallId: "call-1",
+    await turn_context.output.assistant.write_tool_result({
+      tool_call_id: "call-1",
+      tool_name: "shell_exec",
+      succeeded: true,
       output: { success: true },
     });
-    await turn_context.output.assistant.write_chunk({ type: "text-start", id: "text-1" });
-    await turn_context.output.assistant.write_chunk({
-      type: "text-delta",
-      id: "text-1",
-      delta: "最终结论",
-    });
-    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
-    const assistant_message = {
-      id: "assistant-1",
-      role: "assistant",
-      parts: [
+    await write_text(turn_context.output.assistant, "text-1", "最终结论");
+    const assistant_parts = [
         {
-          type: "dynamic-tool",
-          toolCallId: "call-1",
-          toolName: "shell_exec",
-          state: "output-available",
+          part_id: "tool:call-1",
+          sequence: 1,
+          type: "tool",
+          tool_call_id: "call-1",
+          tool_name: "shell_exec",
+          state: "completed",
           input: { cmd: "pwd" },
           output: { success: true },
         },
-        { type: "text", text: "最终结论", state: "done" },
-      ],
-    };
-    await turn_context.output.assistant.finish_step(assistant_message);
+        { part_id: "text:text-1", sequence: 2, type: "text", text: "最终结论", state: "done" },
+      ];
+    await turn_context.output.assistant.finish_step(assistant_parts);
     return {
       success: true,
       text: "最终结论",
@@ -232,58 +262,38 @@ test("Turn 使用 step canonical chunks 保持 Tool 与最终正文顺序", asyn
 test("普通 Tool Loop 的多个 Provider Step 始终写入同一个 Assistant Message", async () => {
   const { messages, turn } = await create_turn_harness(async (turn_context) => {
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({ type: "text-start", id: "text-1" });
-    await turn_context.output.assistant.write_chunk({
-      type: "text-delta",
-      id: "text-1",
-      delta: "先检查项目。",
-    });
-    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-start",
-      toolCallId: "call-1",
-      toolName: "shell_exec",
+    await write_text(turn_context.output.assistant, "text-1", "先检查项目。");
+    await write_tool_call(turn_context.output.assistant, {
+      content_id: "tool-1",
+      tool_call_id: "call-1",
+      tool_name: "shell_exec",
+      tool_input: { cmd: "pnpm typecheck" },
     });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-input-available",
-      toolCallId: "call-1",
-      toolName: "shell_exec",
-      input: { cmd: "pnpm typecheck" },
-    });
-    await turn_context.output.assistant.write_chunk({
-      type: "tool-output-available",
-      toolCallId: "call-1",
+    await turn_context.output.assistant.write_tool_result({
+      tool_call_id: "call-1",
+      tool_name: "shell_exec",
+      succeeded: true,
       output: { success: true },
     });
-    await turn_context.output.assistant.finish_step({
-      id: "provider-step-1",
-      role: "assistant",
-      parts: [
-        { type: "text", text: "先检查项目。", state: "done" },
+    await turn_context.output.assistant.finish_step([
+        { part_id: "text:text-1", sequence: 1, type: "text", text: "先检查项目。", state: "done" },
         {
-          type: "dynamic-tool",
-          toolCallId: "call-1",
-          toolName: "shell_exec",
-          state: "output-available",
+          part_id: "tool:call-1",
+          sequence: 2,
+          type: "tool",
+          tool_call_id: "call-1",
+          tool_name: "shell_exec",
+          state: "completed",
           input: { cmd: "pnpm typecheck" },
           output: { success: true },
         },
-      ],
-    });
+      ]);
 
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({ type: "text-start", id: "text-2" });
-    await turn_context.output.assistant.write_chunk({
-      type: "text-delta",
-      id: "text-2",
-      delta: "检查完成。",
-    });
-    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-2" });
-    await turn_context.output.assistant.finish_step({
-      id: "provider-step-2",
-      role: "assistant",
-      parts: [{ type: "text", text: "检查完成。", state: "done" }],
-    });
+    await write_text(turn_context.output.assistant, "text-2", "检查完成。");
+    await turn_context.output.assistant.finish_step([
+      { part_id: "text:text-2", sequence: 1, type: "text", text: "检查完成。", state: "done" },
+    ]);
     return {
       success: true,
       text: "检查完成。",
@@ -314,29 +324,21 @@ test("普通 Tool Loop 的多个 Provider Step 始终写入同一个 Assistant M
 test("Turn 在 step 最终快照出现未流式写入的 Tool 时失败", async () => {
   const { messages, turn } = await create_turn_harness(async (turn_context) => {
     await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_chunk({ type: "text-start", id: "text-1" });
-    await turn_context.output.assistant.write_chunk({
-      type: "text-delta",
-      id: "text-1",
-      delta: "最终结论",
-    });
-    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
+    await write_text(turn_context.output.assistant, "text-1", "最终结论");
     try {
-      await turn_context.output.assistant.finish_step({
-        id: "assistant-1",
-        role: "assistant",
-        parts: [
+      await turn_context.output.assistant.finish_step([
           {
-            type: "dynamic-tool",
-            toolCallId: "call-1",
-            toolName: "shell_exec",
-            state: "output-available",
+            part_id: "tool:call-1",
+            sequence: 1,
+            type: "tool",
+            tool_call_id: "call-1",
+            tool_name: "shell_exec",
+            state: "completed",
             input: { cmd: "pwd" },
             output: { success: true },
           },
-          { type: "text", text: "最终结论", state: "done" },
-        ],
-      });
+          { part_id: "text:text-1", sequence: 2, type: "text", text: "最终结论", state: "done" },
+        ]);
     } catch (error) {
       await turn_context.output.assistant.abort_step();
       return {

package/scripts/verify-build-aliases.mjs

@@ -0,0 +1,32 @@
+/**
+ * 校验 Agent 发布产物没有遗留 TypeScript 路径别名。
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const bin_root = path.resolve(__dirname, "../bin");
+const alias_pattern = /(?:from\s+["'](?:@\/|@executor\/)|import\s*\(\s*["'](?:@\/|@executor\/)|["'](?:@\/|@executor\/))/;
+
+async function collect_files(dir_path) {
+  const entries = await fs.readdir(dir_path, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entry_path = path.join(dir_path, entry.name);
+    if (entry.isDirectory()) files.push(...await collect_files(entry_path));
+    else if (entry.isFile() && (entry.name.endsWith(".js") || entry.name.endsWith(".d.ts"))) files.push(entry_path);
+  }
+  return files;
+}
+
+const failed_files = [];
+for (const file_path of await collect_files(bin_root)) {
+  if (alias_pattern.test(await fs.readFile(file_path, "utf-8"))) failed_files.push(file_path);
+}
+if (failed_files.length > 0) {
+  console.error("[agent-build] unresolved @/ imports:");
+  for (const file_path of failed_files) console.error(`- ${file_path}`);
+  process.exit(1);
+}

package/scripts/workspace.test.mjs

@@ -7,13 +7,33 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { Agent, Workspace } from "../bin/index.js";
+import { Agent } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { Workspace } from "@downcity/workspace";
+
+test("Agent runtime uses memory data when no City is attached", async (t) => {
+  const fixture_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-root-"));
+  const project_path = path.join(fixture_root, "project");
+  await fs.mkdir(project_path);
+  const agent = new Agent({ id: "internal-root-agent" });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "internal-root-workspace",
+    path: project_path,
+  }));
+  t.after(async () => {
+    await agent.dispose();
+    await fs.rm(fixture_root, { recursive: true, force: true });
+  });
+
+  assert.equal(entry.data_path, "/memory/agents/internal-root-agent");
+});
 
 test("Workspace exposes file tools without requiring Shell", async (t) => {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-"));
 
-  const workspace = new Workspace({ path: root_path });
-  const agent = new Agent({ id: "workspace-files", workspace });
+  const workspace = new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") });
+  const agent = new Agent({ id: "workspace-files" });
+  const entry = create_workspace_entry(agent, workspace);
   t.after(async () => {
     await agent.dispose();
     await fs.rm(root_path, { recursive: true, force: true });
@@ -27,50 +47,136 @@ test("Workspace exposes file tools without requiring Shell", async (t) => {
     "read",
     "write",
   ]);
-  assert.equal(agent.workspace, workspace);
-  assert.equal(agent.get_shell(), undefined);
+  assert.equal(entry.workspace, workspace);
+  assert.equal(entry.get_shell(), undefined);
 });
 
-test("Workspace binds one Agent and is disposed with it", async (t) => {
+test("one unbound Workspace instance belongs to one Agent", async (t) => {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-shared-"));
   t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
   let dispose_count = 0;
   const shell = {
     tools: { shell_exec: {} },
-    bind(root_path) {
-      assert.equal(root_path, workspace_path);
+    bind(binding) {
+      assert.equal(binding.root_path, workspace_path);
+      assert.equal(binding.data_path, workspace_path);
     },
     set_env(env) {
       assert.deepEqual(env, {});
     },
+    async run_safe_command() {
+      throw new Error("not used");
+    },
     async dispose() {
       dispose_count += 1;
     },
   };
   const workspace_path = await fs.realpath(root_path);
-  const workspace = new Workspace({ path: root_path, shell });
-  const agent = new Agent({ id: "workspace-first", workspace });
+  const workspace = new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data"), shell });
+  const agent = new Agent({ id: "workspace-first" });
+  const second_agent = new Agent({ id: "workspace-second" });
+  create_workspace_entry(agent, workspace);
   assert.throws(
-    () => new Agent({ id: "workspace-second", workspace }),
-    /already bound to Agent "workspace-first"/,
+    () => create_workspace_entry(second_agent, workspace),
+    /already bound to another scope/,
   );
 
   await agent.dispose();
-  await agent.dispose();
+  await second_agent.dispose();
   assert.equal(dispose_count, 1);
 });
 
 test("separate Workspace instances may use the same directory", async (t) => {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-directory-"));
   t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const first_agent = new Agent({
-    id: "workspace-directory-first",
-    workspace: new Workspace({ path: root_path }),
-  });
-  const second_agent = new Agent({
-    id: "workspace-directory-second",
-    workspace: new Workspace({ path: root_path }),
+  const first_agent = new Agent({ id: "workspace-directory-first" });
+  const second_agent = new Agent({ id: "workspace-directory-second" });
+  const first_entry = create_workspace_entry(first_agent, new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }));
+  const second_entry = create_workspace_entry(second_agent, new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }));
+  assert.notEqual(first_entry.data_path, second_entry.data_path);
+  const first_session = await first_entry.sessions.create();
+  const second_session = await second_entry.sessions.create();
+  assert.deepEqual(
+    (await first_entry.sessions.list()).items.map((item) => item.session_id),
+    [first_session.id],
+  );
+  assert.deepEqual(
+    (await second_entry.sessions.list()).items.map((item) => item.session_id),
+    [second_session.id],
+  );
+
+  await first_agent.dispose();
+  await second_agent.dispose();
+});
+
+test("同一 Agent 的 Workspace Session 列表彼此隔离", async (t) => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-session-filter-"));
+  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
+  const agent = new Agent({ id: "workspace-session-filter" });
+  const first_entry = create_workspace_entry(agent, new Workspace({
+    id: "workspace-first",
+    path: root_path,
+    data_root_path: path.join(root_path, "data"),
+  }));
+  const second_entry = create_workspace_entry(agent, new Workspace({
+    id: "workspace-second",
+    path: root_path,
+    data_root_path: path.join(root_path, "data"),
+  }));
+  t.after(async () => await agent.dispose());
+
+  const first_session = await first_entry.sessions.create();
+  const second_session = await second_entry.sessions.create();
+  assert.deepEqual((await first_entry.sessions.list()).items.map((item) => item.session_id), [first_session.id]);
+  assert.deepEqual((await second_entry.sessions.list()).items.map((item) => item.session_id), [second_session.id]);
+});
+
+test("恢复绑定 Workspace 的 Session 必须提供同一个 Workspace", async (t) => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-workspace-restore-"));
+  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
+  const agent = new Agent({ id: "workspace-restore-agent" });
+  const workspace = new Workspace({
+    id: "restore-workspace",
+    path: root_path,
+    data_root_path: path.join(root_path, "data"),
   });
+  const entry = create_workspace_entry(agent, workspace);
+  try {
+    const session = await entry.sessions.create();
+    await assert.rejects(
+      agent.sessions.get(session.id),
+      /requires Workspace "restore-workspace"/u,
+    );
+    assert.equal((await entry.sessions.get(session.id, { workspace })).id, session.id);
+  } finally {
+    await agent.dispose();
+  }
+});
+
+test("Session IDs are isolated by Agent in one Workspace", async (t) => {
+  const root_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-workspace-session-owner-"),
+  );
+  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
+  const data_root_path = path.join(root_path, "data");
+  const first_agent = new Agent({ id: "session-owner-first" });
+  const second_agent = new Agent({ id: "session-owner-second" });
+  const first_entry = create_workspace_entry(first_agent, new Workspace({
+    id: "test_workspace",
+    path: root_path,
+    data_root_path,
+  }));
+  const second_entry = create_workspace_entry(second_agent, new Workspace({
+    id: "test_workspace",
+    path: root_path,
+    data_root_path,
+  }));
+
+  const results = await Promise.allSettled([
+    first_entry.sessions.create({ session_id: "shared-session" }),
+    second_entry.sessions.create({ session_id: "shared-session" }),
+  ]);
+  assert.equal(results.every((result) => result.status === "fulfilled"), true);
 
   await first_agent.dispose();
   await second_agent.dispose();
@@ -87,11 +193,14 @@ test("Workspace owns env and publishes only real changes", async (t) => {
     set_env(env) {
       shell_env_snapshots.push({ ...env });
     },
+    async run_safe_command() {
+      throw new Error("not used");
+    },
     async dispose() {},
   };
 
-  const workspace = new Workspace({
-    path: root_path,
+  const workspace = new Workspace({ id: "test_workspace",
+    path: root_path, data_root_path: path.join(root_path, "data"),
     shell,
     env: { OVERRIDE: "explicit", EXPLICIT: "value" },
   });
@@ -127,20 +236,25 @@ test("Agent rejects Workspace, Plugin and custom Tool name conflicts", async (t)
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-tools-"));
   t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
 
+  const workspace_conflict_agent = new Agent({
+    id: "workspace-tool-conflict",
+    tools: { read: {} },
+  });
   assert.throws(
-    () => new Agent({
-      id: "workspace-tool-conflict",
-      workspace: new Workspace({ path: root_path }),
-      tools: { read: {} },
-    }),
+    () => create_workspace_entry(workspace_conflict_agent,
+      new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }),
+    ),
     /Agent tool name conflict: "read"/,
   );
+  const plugin_conflict_agent = new Agent({
+    id: "plugin-tool-conflict",
+    tools: { plugin_call: {} },
+  });
   assert.throws(
-    () => new Agent({
-      id: "plugin-tool-conflict",
-      workspace: new Workspace({ path: root_path }),
-      tools: { plugin_call: {} },
-    }),
+    () => create_workspace_entry(plugin_conflict_agent,
+      new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }),
+    ),
     /reserved for PluginRegistry/,
   );
+  await Promise.all([workspace_conflict_agent.dispose(), plugin_conflict_agent.dispose()]);
 });