@downcity/agent 1.1.338 → 1.1.400

package/scripts/plugin-tools.test.mjs

@@ -28,13 +28,22 @@ function create_turn_context(project_root) {
 }
 
 function create_registry(plugin) {
-  const registry = new PluginRegistry([plugin]);
-  registry.bind_context({ workspace_path: process.cwd() });
-  return registry;
+  const registry = new PluginRegistry({
+    agent_id: "plugin_tools_agent",
+    instructions: [],
+  }, [plugin]);
+  const context = {
+    agent_id: "plugin_tools_agent",
+    workspace_id: "plugin_tools_workspace",
+    workspace_path: process.cwd(),
+  };
+  return Object.assign(registry.contextual(context), {
+    execution_view: () => registry.execution_view(context),
+  });
 }
 
 test("plugin_call payload schema allows arbitrary object properties", async () => {
-  const plugin_call_schema = await plugin_call_input_schema.jsonSchema;
+  const plugin_call_schema = plugin_call_input_schema;
   const payload_schema = plugin_call_schema.properties.payload;
 
   assert.equal(plugin_call_schema.type, "object");
@@ -59,7 +68,7 @@ test("invoke_plugin_call_tool preserves Action output and messages", async () =>
         parts: [
           {
             type: "file",
-            mediaType: "image/png",
+            media_type: "image/png",
             filename: "image.png",
             url: "/workspace/image.png",
           },
@@ -78,6 +87,7 @@ test("invoke_plugin_call_tool preserves Action output and messages", async () =>
   const result = await invoke_plugin_call_tool({
     plugins,
     turn_context,
+    call_id: "call_image_result",
     input: {
       plugin: "image",
       action: "image_result",
@@ -96,7 +106,7 @@ test("invoke_plugin_call_tool preserves Action output and messages", async () =>
     role: "assistant",
     parts: [{
       type: "file",
-      mediaType: "image/png",
+      media_type: "image/png",
       filename: "image.png",
       url: "/workspace/image.png",
     }],
@@ -262,12 +272,14 @@ test("create_plugin_tools binds plugin_call to the current registry", async () =
       actions: {
         lookup: create_action({
           description: "Return registry owner",
-          execute: async ({ execution_context }) => ({
+          execute: async ({ execution }) => ({
             success: true,
             data: {
               owner,
-              session_id: execution_context?.session_id,
-              context_keys: Object.keys(execution_context || {}).sort(),
+              session_id: execution.session?.session_id,
+              call_id: execution.call_id,
+              has_interactions: Boolean(execution.session?.interactions),
+              context_keys: Object.keys(execution).sort(),
             },
             message: owner,
           }),
@@ -286,15 +298,17 @@ test("create_plugin_tools binds plugin_call to the current registry", async () =
       session_id,
       turn_id: `turn_${session_id}`,
       project_root: process.cwd(),
+      interactions: {
+        request: async () => {
+          throw new Error("interaction request is not expected in this test");
+        },
+      },
     });
     return {
-      toolCallId: `call_${session_id}`,
+      tool_call_id: `call_${session_id}`,
       messages: [],
-      experimental_context: {
+      context: {
         session_turn_context: turn_context,
-        shell_run_context: {
-          ownerContextId: session_id,
-        },
       },
     };
   };
@@ -313,16 +327,137 @@ test("create_plugin_tools binds plugin_call to the current registry", async () =
   assert.equal(result_a.output.success, true);
   assert.equal(result_a.output.data.owner, "agent_a");
   assert.equal(result_a.output.data.session_id, "session_a");
+  assert.equal(result_a.output.data.call_id, "call_session_a");
+  assert.equal(result_a.output.data.has_interactions, true);
   assert.deepEqual(result_a.output.data.context_keys, [
     "abort_signal",
-    "agent_systems",
-    "project_root",
-    "session_id",
-    "turn_id",
+    "call_id",
+    "session",
+    "snapshot",
   ]);
   assert.equal(result_b.output.success, true);
   assert.equal(result_b.output.data.owner, "agent_b");
   assert.equal(result_b.output.data.session_id, "session_b");
+  assert.equal(result_b.output.data.call_id, "call_session_b");
+  assert.equal(result_b.output.data.has_interactions, true);
+});
+
+test("PluginRegistry keeps Session identity when no Interaction port is provided", async () => {
+  let observed_execution;
+  const plugin = create_plugin({
+    name: "session_identity",
+    actions: {
+      inspect: create_action({
+        execute: async ({ execution }) => {
+          observed_execution = execution;
+          return { success: true };
+        },
+      }),
+    },
+  });
+  const plugins = create_registry(plugin);
+
+  const result = await plugins.run_action({
+    plugin: "session_identity",
+    action: "inspect",
+    execution_context: {
+      session_id: "session_without_interactions",
+      turn_id: "turn_without_interactions",
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(observed_execution.session.session_id, "session_without_interactions");
+  assert.equal(observed_execution.session.turn_id, "turn_without_interactions");
+  assert.equal(observed_execution.session.interactions, undefined);
+});
+
+test("PluginRegistry separates stable context from non-Session action execution", async () => {
+  let observed_context;
+  let observed_execution;
+  const plugin = create_plugin({
+    name: "identity",
+    actions: {
+      inspect: create_action({
+        execute: async ({ context, execution }) => {
+          observed_context = context;
+          observed_execution = execution;
+          return { success: true };
+        },
+      }),
+    },
+  });
+  const plugins = create_registry(plugin);
+
+  const result = await plugins.run_action({
+    plugin: "identity",
+    action: "inspect",
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(observed_context.agent_id, "plugin_tools_agent");
+  assert.equal(observed_context.workspace_id, "plugin_tools_workspace");
+  assert.match(observed_execution.call_id, /^plugin:/);
+  assert.equal(observed_execution.abort_signal.aborted, false);
+  assert.equal(Object.isFrozen(observed_execution), true);
+  assert.equal(observed_execution.session, undefined);
+});
+
+test("PluginRegistry rejects an action before execution when the caller is cancelled", async () => {
+  let executed = false;
+  const plugin = create_plugin({
+    name: "cancelled",
+    actions: {
+      run: create_action({
+        execute: async () => {
+          executed = true;
+          return { success: true };
+        },
+      }),
+    },
+  });
+  const plugins = create_registry(plugin);
+  const controller = new AbortController();
+  controller.abort(new Error("caller cancelled"));
+
+  const result = await plugins.run_action({
+    plugin: "cancelled",
+    action: "run",
+    execution_context: {
+      call_id: "call_cancelled",
+      abort_signal: controller.signal,
+    },
+  });
+
+  assert.equal(result.success, false);
+  assert.equal(result.error, "caller cancelled");
+  assert.equal(executed, false);
+});
+
+test("PluginRegistry applies the action cooperative timeout to abort_signal", async () => {
+  const plugin = create_plugin({
+    name: "timeout",
+    actions: {
+      wait: create_action({
+        timeout_ms: 10,
+        execute: async ({ execution }) => {
+          await new Promise((resolve) => {
+            execution.abort_signal.addEventListener("abort", resolve, { once: true });
+          });
+          return { success: true };
+        },
+      }),
+    },
+  });
+  const plugins = create_registry(plugin);
+
+  const result = await plugins.run_action({
+    plugin: "timeout",
+    action: "wait",
+  });
+
+  assert.equal(result.success, false);
+  assert.match(result.error, /timed out after 10 ms/);
 });
 
 test("PluginRegistry keeps plugin ready after action business failure", async () => {

package/scripts/public-api-naming.test.mjs

@@ -24,7 +24,6 @@ const public_declaration_files = [
   "remote/RemoteAgent.d.ts",
   "remote/RemoteSession.d.ts",
   "session/Session.d.ts",
-  "workspace/Workspace.d.ts",
   "plugin/core/PluginRegistry.d.ts",
   "types/agent/AgentOptions.d.ts",
   "types/agent/SessionActor.d.ts",

package/scripts/rewrite-build-aliases.mjs

@@ -0,0 +1,49 @@
+/**
+ * Agent 构建产物路径别名重写。
+ *
+ * TypeScript 的 `paths` 仅服务编译期；发布到 Node 运行时的 `bin` 产物
+ * 必须改成相对路径。只处理 Agent 包自己的 `@/` 别名，不触碰真实包名。
+ */
+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 package_root = path.resolve(__dirname, "..");
+const bin_root = path.join(package_root, "bin");
+const alias_literal_pattern = /(["'])(@\/|@executor\/)([^"']+)\1/g;
+
+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;
+}
+
+function to_posix_path(value) {
+  return value.split(path.sep).join("/");
+}
+
+let rewritten_count = 0;
+for (const file_path of await collect_files(bin_root)) {
+  const content = await fs.readFile(file_path, "utf-8");
+  const rewritten = content.replace(alias_literal_pattern, (literal, quote, alias_prefix, alias_target) => {
+    rewritten_count += 1;
+    const target_root = alias_prefix === "@executor/" ? path.join(bin_root, "executor") : bin_root;
+    const target_path = path.join(target_root, alias_target);
+    const relative_path = to_posix_path(path.relative(path.dirname(file_path), target_path));
+    const specifier = relative_path.startsWith(".") ? relative_path : `./${relative_path}`;
+    return `${quote}${specifier}${quote}`;
+  });
+  if (rewritten !== content) await fs.writeFile(file_path, rewritten, "utf-8");
+}
+
+console.log(`[agent-build] rewrote ${String(rewritten_count)} @/ imports`);

package/scripts/rpc-url-routing.test.mjs

@@ -0,0 +1,29 @@
+/**
+ * @file 验证 RemoteAgent RPC URL 中的 Agent ID 会进入每个请求。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parse_rpc_url } from "../bin/remote/transports/RpcClient.js";
+
+test("parse_rpc_url extracts optional City Agent and Workspace IDs", () => {
+  assert.deepEqual(parse_rpc_url("rpc://127.0.0.1:15314/lucas"), {
+    host: "127.0.0.1",
+    port: 15314,
+    agent_id: "lucas",
+  });
+  assert.deepEqual(parse_rpc_url("rpc://127.0.0.1:15314"), {
+    host: "127.0.0.1",
+    port: 15314,
+  });
+  assert.deepEqual(parse_rpc_url("rpc://127.0.0.1:15314/lucas/sdk"), {
+    host: "127.0.0.1",
+    port: 15314,
+    agent_id: "lucas",
+    workspace_id: "sdk",
+  });
+  assert.throws(
+    () => parse_rpc_url("rpc://127.0.0.1:15314/first/second/third"),
+    /at most Agent ID and Workspace ID path segments/,
+  );
+});

package/scripts/search-tools.test.mjs

@@ -13,7 +13,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { Workspace } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
 
 const rg_available = spawnSync("rg", ["--version"], { stdio: "ignore" }).status === 0;
 
@@ -27,7 +27,7 @@ async function create_fixture(t) {
   return {
     root_path,
     outside_path,
-    tools: new Workspace({ path: root_path }).tools,
+    tools: new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }).tools,
   };
 }
 
@@ -35,9 +35,9 @@ async function execute_tool(tools, name, input, abort_signal) {
   const execute = tools[name]?.execute;
   assert.equal(typeof execute, "function", `${name} tool must be executable`);
   const result = await execute(input, {
-    toolCallId: `test-${name}`,
+    tool_call_id: `test-${name}`,
     messages: [],
-    abortSignal: abort_signal || new AbortController().signal,
+    abort_signal: abort_signal || new AbortController().signal,
   });
   assert.deepEqual(result.messages, []);
   return result.output;

package/scripts/session-ask-question.test.mjs

@@ -12,8 +12,10 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { MockLanguageModelV3 } from "ai/test";
-import { Agent, Workspace } from "@downcity/agent";
+import { MockModelClient } from "./ModelClientMock.mjs";
+import { Agent } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
+import { create_workspace_entry } from "../bin/internal/index.js";
 import { AskQuestionsTool } from "@downcity/agent/tools";
 
 /** 构造 AI SDK V3 usage。 */
@@ -99,13 +101,11 @@ test("Agent 默认不注册 ask_question", async () => {
   const project_root = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-without-ask-question-"),
   );
-  const agent = new Agent({
-    id: "agent_without_ask_question",
-    workspace: new Workspace({ path: project_root }),
-  });
+  const agent = new Agent({ id: "agent_without_ask_question" });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
 
   try {
-    assert.equal("ask_question" in agent.tools, false);
+    assert.equal("ask_question" in entry.tools, false);
   } finally {
     await agent.dispose();
     await fs.rm(project_root, { recursive: true, force: true });
@@ -117,7 +117,7 @@ test("显式注入的 ask_question 等待回答并继续同一个 Turn", async (
     path.join(os.tmpdir(), "downcity-session-ask-question-"),
   );
   let stream_count = 0;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "session-ask-question-model",
     doStream: async (options) => {
       if (!Array.isArray(options.tools) || options.tools.length === 0) {
@@ -137,16 +137,16 @@ test("显式注入的 ask_question 等待回答并继续同一个 Turn", async (
   });
   const agent = new Agent({
     id: "session_ask_question_agent",
-    workspace: new Workspace({ path: project_root }),
     model,
     tools: {
       ask_question: AskQuestionsTool,
     },
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
 
   try {
-    assert.ok(agent.tools.ask_question);
-    const session = await agent.sessions.create({
+    assert.ok(entry.tools.ask_question);
+    const session = await entry.sessions.create({
       session_id: "session_ask_question",
     });
     let pending_interaction;
@@ -156,17 +156,18 @@ test("显式注入的 ask_question 等待回答并继续同一个 Turn", async (
         mutation.variant !== "part" ||
         mutation.type !== "interaction" ||
         mutation.part.status !== "pending" ||
-        mutation.part.request.kind !== "question"
+        mutation.part.request.type !== "question"
       ) return;
       pending_interaction = mutation.part;
       response_result = session.respond({
         interaction_id: mutation.part.interaction_id,
         response: {
-          kind: "question",
-          answers: [{
-            question_id: pending_interaction.request.questions[0].question_id,
+          type: "question",
+          outcome: "resolved",
+          payload: { answers: [{
+            question_id: pending_interaction.request.payload.questions[0].question_id,
             value: "cn",
-          }],
+          }] },
         },
       });
     });
@@ -185,11 +186,12 @@ test("显式注入的 ask_question 等待回答并继续同一个 Turn", async (
       status: "resolved",
       interaction_id: pending_interaction.interaction_id,
       response: {
-        kind: "question",
-        answers: [{
-          question_id: pending_interaction.request.questions[0].question_id,
+        type: "question",
+        outcome: "resolved",
+        payload: { answers: [{
+          question_id: pending_interaction.request.payload.questions[0].question_id,
           value: "cn",
-        }],
+        }] },
       },
     });
 
@@ -207,7 +209,7 @@ test("显式注入的 ask_question 等待回答并继续同一个 Turn", async (
     assert.deepEqual(tool_part?.output, {
       status: "resolved",
       answers: [{
-        question_id: pending_interaction.request.questions[0].question_id,
+        question_id: pending_interaction.request.payload.questions[0].question_id,
         value: "cn",
       }],
     });

package/scripts/session-attachments.test.mjs

@@ -7,15 +7,16 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { LocalFileSystem } from "../bin/workspace/LocalFileSystem.js";
-import { LocalSessionStore } from "../bin/workspace/store/LocalSessionStore.js";
+import { LocalFileSystem } from "@downcity/workspace";
+import { LocalSessionDataStore } from "../bin/workspace/store/LocalSessionDataStore.js";
 import { SessionMessages } from "../bin/session/SessionMessages.js";
 
 async function create_harness() {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-attachment-"));
   const files = new LocalFileSystem(root_path);
-  const store = new LocalSessionStore({
+  const store = new LocalSessionDataStore({
     files,
+    storage_root_path: root_path,
     agent_id: "attachment-test-agent",
     session_id: "attachment-test-session",
   });
@@ -37,7 +38,7 @@ test("Data URL 落盘后保留用户文件名并保存相对路径", async () =>
     prompt: {
       query: [{
         type: "file",
-        mediaType: "image/png",
+        media_type: "image/png",
         url: "data:image/png;base64,aGVsbG8=",
         filename: "diagram.png",
       }],
@@ -47,11 +48,12 @@ test("Data URL 落盘后保留用户文件名并保存相对路径", async () =>
 
   const part = result.parts[0];
   assert.equal(part.type, "file");
-  assert.match(part.url, /^\.downcity\/agents\/attachment-test-agent\/sessions\/attachment-test-session\/attachments\/att_/);
+  assert.equal(path.isAbsolute(part.url), true);
+  assert.match(part.url, /sessions\/attachment-test-session\/attachments\/att_/);
   assert.equal(part.url.endsWith(".png"), true);
   assert.equal(part.filename, "diagram.png");
   assert.equal(
-    (await fs.readFile(path.join(harness.root_path, part.url))).toString(),
+    (await fs.readFile(part.url)).toString(),
     "hello",
   );
   assert.equal(part.url.includes("base64"), false);
@@ -65,7 +67,7 @@ test("视频 Data URL 使用 MIME 类型和扩展名落盘", async () => {
     prompt: {
       query: [{
         type: "file",
-        mediaType: "video/mp4",
+        media_type: "video/mp4",
         url: "data:video/mp4;base64,AQID",
         filename: "demo.mp4",
       }],
@@ -76,7 +78,7 @@ test("视频 Data URL 使用 MIME 类型和扩展名落盘", async () => {
   const part = result.parts[0];
   assert.equal(part.url.endsWith(".mp4"), true);
   assert.deepEqual(
-    [...await fs.readFile(path.join(harness.root_path, part.url))],
+    [...await fs.readFile(part.url)],
     [1, 2, 3],
   );
 });
@@ -90,7 +92,7 @@ test("无效 Data URL 不会写入 Session Message", async () => {
       prompt: {
         query: [{
           type: "file",
-          mediaType: "image/png",
+          media_type: "image/png",
           url: "data:image/png;base64",
         }],
       },

package/scripts/session-compact-handle.test.mjs

@@ -12,14 +12,15 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { MockLanguageModelV3 } from "ai/test";
+import { MockModelClient } from "./ModelClientMock.mjs";
 
 import {
   Agent,
   DefaultSessionComposer,
   Session,
-  Workspace,
 } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { Workspace } from "@downcity/workspace";
 
 function create_deferred() {
   let resolve;
@@ -74,16 +75,16 @@ test("compact Handle 在队列命令完成后兑现并阻塞后续 Prompt", asyn
   );
   const agent = new Agent({
     id: "compact_handle_agent",
-    workspace: new Workspace({ path: project_root }),
-    model: new MockLanguageModelV3({
+    model: new MockModelClient({
       modelId: "compact-handle-model",
       doStream: async () => create_stream_text_result("done"),
     }),
     session_class: CompactSession,
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "compact_handle_session",
     });
     const compact_handle = await session.compact();