@downcity/agent 1.1.237 → 1.1.258

package/scripts/plugin-tool-bridge.test.mjs

@@ -18,9 +18,8 @@ import {
 } from "../bin/executor/tools/plugin/PluginToolBridge.js";
 import { createPluginTools } from "../bin/executor/tools/plugin/PluginToolDefinition.js";
 import { plugin_call_input_schema } from "../bin/executor/tools/plugin/PluginToolSchemas.js";
-import { withSessionRunScope } from "../bin/executor/SessionRunScope.js";
 import { createAction, createPlugin } from "../bin/plugin/core/PluginActionFactory.js";
-import { createAgentPluginRegistry } from "../bin/agent/local/AgentPluginFactory.js";
+import { PluginRegistry } from "../bin/plugin/core/PluginRegistry.js";
 import { z } from "zod";
 
 function create_run_context(project_root) {
@@ -33,6 +32,12 @@ function create_run_context(project_root) {
   };
 }
 
+function create_registry(plugin) {
+  const registry = new PluginRegistry([plugin]);
+  registry.bind_context({ rootPath: process.cwd() });
+  return registry;
+}
+
 test("plugin_call payload schema allows arbitrary object properties", async () => {
   const plugin_call_schema = await plugin_call_input_schema.jsonSchema;
   const payload_schema = plugin_call_schema.properties.payload;
@@ -80,16 +85,15 @@ test("invokePluginCallTool returns absolute paths for materialized file parts",
   };
 
   const run_context = create_run_context(project_root);
-  const result = await withSessionRunScope({ runContext: run_context }, () =>
-    invokePluginCallTool({
-      plugins,
-      input: {
-        plugin: "image",
-        action: "image_result",
-        payload: { job_id: "img_1" },
-      },
-    }),
-  );
+  const result = await invokePluginCallTool({
+    plugins,
+    run_context,
+    input: {
+      plugin: "image",
+      action: "image_result",
+      payload: { job_id: "img_1" },
+    },
+  });
 
   assert.equal(result.success, true);
   assert.equal(result.assistant_file_count, 1);
@@ -149,6 +153,7 @@ test("invokePluginReadTool returns plugin action metadata", async () => {
 
   const result = await invokePluginReadTool({
     plugins,
+    run_context: create_run_context(process.cwd()),
     input: {
       plugin: "image",
       action: "image_create",
@@ -190,11 +195,7 @@ test("PluginRegistry validates action payload with metadata schema", async () =>
       }),
     },
   });
-  const registry = createAgentPluginRegistry({
-    plugins: [plugin],
-    plugin_instances: new Map(),
-    get_context: () => ({ rootPath: process.cwd() }),
-  });
+  const registry = create_registry(plugin);
 
   const metadata = registry.read({ plugin: "demo", action: "echo" });
   assert.equal(metadata.actions[0].description, "Echo text");
@@ -226,41 +227,56 @@ test("createPluginTools binds plugin_call to the current registry", async () =>
       actions: {
         lookup: createAction({
           description: "Return registry owner",
-          execute: async () => ({
+          execute: async ({ run_context }) => ({
             success: true,
-            data: { owner },
+            data: {
+              owner,
+              session_id: run_context?.sessionId,
+            },
             message: owner,
           }),
         }),
       },
     });
-    return createAgentPluginRegistry({
-      plugins: [plugin],
-      plugin_instances: new Map(),
-      get_context: () => ({ rootPath: process.cwd() }),
-    });
+    return create_registry(plugin);
   }
 
   const registry_a = create_owner_registry("agent_a");
   const registry_b = create_owner_registry("agent_b");
   const tools_a = createPluginTools({ plugins: registry_a });
   const tools_b = createPluginTools({ plugins: registry_b });
+  const create_execution_options = (session_id) => {
+    const run_context = create_run_context(process.cwd());
+    run_context.sessionId = session_id;
+    return {
+      toolCallId: `call_${session_id}`,
+      messages: [],
+      experimental_context: {
+        session_run_context: run_context,
+        shell_run_context: {
+          ownerContextId: session_id,
+        },
+      },
+    };
+  };
 
   const result_a = await tools_a.plugin_call.execute({
     plugin: "skill",
     action: "lookup",
     payload: { name: "anything" },
-  });
+  }, create_execution_options("session_a"));
   const result_b = await tools_b.plugin_call.execute({
     plugin: "skill",
     action: "lookup",
     payload: { name: "anything" },
-  });
+  }, create_execution_options("session_b"));
 
   assert.equal(result_a.success, true);
   assert.equal(result_a.data.value.owner, "agent_a");
+  assert.equal(result_a.data.value.session_id, "session_a");
   assert.equal(result_b.success, true);
   assert.equal(result_b.data.value.owner, "agent_b");
+  assert.equal(result_b.data.value.session_id, "session_b");
 });
 
 test("PluginRegistry keeps plugin ready after action business failure", async () => {
@@ -290,11 +306,7 @@ test("PluginRegistry keeps plugin ready after action business failure", async ()
       }),
     },
   });
-  const registry = createAgentPluginRegistry({
-    plugins: [plugin],
-    plugin_instances: new Map(),
-    get_context: () => ({ rootPath: process.cwd() }),
-  });
+  const registry = create_registry(plugin);
 
   const failed = await registry.runAction({
     plugin: "skill",
@@ -340,11 +352,7 @@ test("PluginRegistry delays lifecycle stop until the active execution lease is r
       }),
     },
   });
-  const registry = createAgentPluginRegistry({
-    plugins: [plugin],
-    plugin_instances: new Map(),
-    get_context: () => ({ rootPath: process.cwd() }),
-  });
+  const registry = create_registry(plugin);
   await registry.startAll();
   const lease = registry.execution_view().acquire();
 

package/scripts/read-image-tool-bridge.test.mjs

@@ -0,0 +1,71 @@
+/**
+ * @file 验证 read 图片结果会作为临时 UserMessage file part 注入模型输入。
+ *
+ * 关键点（中文）
+ * - data URL 只进入注入消息，不保留在普通 tool result。
+ * - 注入消息包含非空文本 part，能够通过 step 合并消息筛选。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { inject_read_image_user_message } from "../bin/executor/tools/file/ReadImageToolBridge.js";
+import {
+  pickMergedUserMessages,
+  toModelMessages,
+} from "../bin/executor/messages/SessionMessageCodec.js";
+
+test("read image data is injected as a user file part", async () => {
+  const data_url = "data:image/png;base64,iVBORw0KGgo=";
+  const run_context = {
+    sessionId: "session-1",
+    turnId: "turn-1",
+    injectedUserMessages: [],
+    deferredPersistedUserMessages: [],
+    pendingAssistantFileParts: [],
+  };
+  const output = inject_read_image_user_message({
+    tool_name: "read",
+    output: {
+      success: true,
+      type: "image",
+      file_path: "/project/input.png",
+      mime_type: "image/png",
+      data_url,
+    },
+    run_context,
+  });
+
+  assert.equal(output.data_url, undefined);
+  assert.equal(output.image_attached, true);
+  assert.equal(run_context.injectedUserMessages.length, 1);
+  const message = run_context.injectedUserMessages[0];
+  assert.equal(message.role, "user");
+  assert.equal(message.parts[0].type, "text");
+  assert.equal(message.parts[1].type, "file");
+  assert.equal(message.parts[1].url, data_url);
+  assert.equal(message.parts[1].mediaType, "image/png");
+  assert.equal(pickMergedUserMessages([message]).length, 1);
+
+  const model_messages = await toModelMessages([message], {});
+  assert.equal(model_messages.length, 1);
+  assert.equal(model_messages[0].role, "user");
+  assert.match(JSON.stringify(model_messages[0]), /iVBORw0KGgo=/);
+});
+
+test("non-image tool results are unchanged", () => {
+  const output = { success: true, type: "text", content: "hello" };
+  const run_context = {
+    sessionId: "session-1",
+    injectedUserMessages: [],
+    deferredPersistedUserMessages: [],
+    pendingAssistantFileParts: [],
+  };
+  const result = inject_read_image_user_message({
+    tool_name: "read",
+    output,
+    run_context,
+  });
+  assert.equal(result, output);
+  assert.deepEqual(run_context.injectedUserMessages, []);
+});

package/scripts/remote-session-reconnect.test.mjs

@@ -9,7 +9,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { RemoteSession } from "../bin/agent/remote/RemoteSession.js";
+import { RemoteSession } from "../bin/remote/RemoteSession.js";
 
 test("RemoteSession reconnects the event pump after transport close", async () => {
   const subscriptions = [];
@@ -70,39 +70,6 @@ test("RemoteSession reconnects the event pump after transport close", async () =
   assert.equal((await second_turn.finished).text, "done");
 });
 
-test("RemoteSession switches models by stable id without local model instances", async () => {
-  const updates = [];
-  const transport = {
-    async set(_session_id, input) {
-      updates.push(input);
-      return {
-        agentId: "agent_test",
-        sessionId: "session_test",
-        messageCount: 0,
-        modelId: input.modelId,
-        modelLabel: input.modelId,
-      };
-    },
-  };
-  const session = new RemoteSession(transport, {
-    agentId: "agent_test",
-    sessionId: "session_test",
-    messageCount: 0,
-    modelId: "old-model",
-    modelLabel: "old-model",
-  });
-
-  await session.set({ modelId: "next-model" });
-
-  assert.deepEqual(updates, [{ modelId: "next-model" }]);
-  assert.equal(session.config.modelId, "next-model");
-  assert.equal(session.config.modelLabel, "next-model");
-  await assert.rejects(
-    session.set({ model: { modelId: "local-model", provider: "test" } }),
-    /does not accept a local model instance/,
-  );
-});
-
 test("RemoteSession queues compact through its transport", async () => {
   const compacted_session_ids = [];
   const transport = {

package/scripts/session-compaction-prompts.test.mjs

@@ -1,10 +1,9 @@
 /**
- * @file 验证 session compact prompt 与文件操作 XML 记录。
+ * @file 验证 Session compact prompt 的结构化摘要格式。
  *
  * 关键点（中文）
  * - compact prompt 必须保持结构化摘要格式稳定。
  * - 迭代更新 prompt 需要携带 previous-summary 标签。
- * - 文件操作 XML 由本地解析追加，不依赖模型复述工具日志。
  */
 
 import test from "node:test";
@@ -12,15 +11,10 @@ import assert from "node:assert/strict";
 
 import {
   SESSION_COMPACTION_SYSTEM_PROMPT,
-  append_session_compaction_file_operations,
   build_initial_session_compaction_prompt,
   build_turn_prefix_session_compaction_prompt,
   build_update_session_compaction_prompt,
 } from "../bin/executor/composer/compaction/jsonl/JsonlSessionCompactionPrompts.js";
-import {
-  collect_session_compaction_file_operations,
-  format_session_compaction_file_operations,
-} from "../bin/executor/composer/compaction/jsonl/JsonlSessionCompactionFileOperations.js";
 
 test("session compaction prompts preserve structured formats", () => {
   assert.match(
@@ -53,45 +47,3 @@ test("session compaction prompts preserve structured formats", () => {
   assert.match(prefix_prompt, /## Original Request/);
   assert.match(prefix_prompt, /## Context for Suffix/);
 });
-
-test("session compaction file operations are appended as xml", () => {
-  const messages = [
-    {
-      id: "a:1",
-      role: "assistant",
-      parts: [
-        {
-          type: "tool-exec_command",
-          input: {
-            cmd: "sed -n '1,40p' packages/agent/src/foo.ts && rg -n compact packages/agent/src",
-          },
-          output: [
-            "*** Update File: packages/agent/src/bar.ts",
-            " M packages/agent/src/baz.ts",
-          ].join("\n"),
-        },
-      ],
-    },
-  ];
-
-  const operations = collect_session_compaction_file_operations(messages);
-  assert.deepEqual(operations.read_files, [
-    "packages/agent/src",
-    "packages/agent/src/foo.ts",
-  ]);
-  assert.deepEqual(operations.modified_files, [
-    "packages/agent/src/bar.ts",
-    "packages/agent/src/baz.ts",
-  ]);
-
-  const xml = format_session_compaction_file_operations(messages);
-  assert.match(xml, /<read-files>\npackages\/agent\/src/);
-  assert.match(xml, /<modified-files>\npackages\/agent\/src\/bar\.ts/);
-
-  const summary = append_session_compaction_file_operations({
-    summary: "## Goal\n完成 compact",
-    file_operations_xml: xml,
-  });
-  assert.match(summary, /## Goal\n完成 compact\n\n<read-files>/);
-  assert.match(summary, /<\/modified-files>$/);
-});

package/scripts/session-composer.test.mjs

@@ -0,0 +1,163 @@
+/**
+ * @file 验证统一 SessionComposer 只读取快照并返回模型输入或压缩计划。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { MockLanguageModelV3 } from "ai/test";
+import {
+  Agent,
+  DefaultSessionComposer,
+  Session,
+} from "../bin/index.js";
+
+function create_input(model) {
+  return {
+    session: {
+      agent_id: "composer-agent",
+      session_id: "composer-session",
+      project_root: "/tmp/composer-project",
+      created_at: 1,
+      timezone: "UTC",
+    },
+    state: {
+      model,
+      env: {},
+      systems: ["Base instruction"],
+      tools: {},
+      instruction_system_blocks: [{
+        source: "instruction",
+        name: "agent",
+        content: "Base instruction",
+      }],
+      managed_plugin_system_blocks: [],
+      plugin_system_blocks: [],
+    },
+    history: {
+      summary: null,
+      messages: [{
+        message_id: "user-1",
+        session_id: "composer-session",
+        turn_id: "turn-1",
+        sequence: 1,
+        revision: 1,
+        visibility: "visible",
+        created_at: 1,
+        updated_at: 1,
+        type: "user",
+        input_type: "prompt",
+        parts: [{
+          part_id: "text-1",
+          type: "text",
+          text: "hello",
+          state: "done",
+        }],
+      }],
+    },
+    turn: { turn_id: "turn-1", retry_count: 0 },
+  };
+}
+
+test("DefaultSessionComposer 从 canonical 快照组装 Step 输入", async () => {
+  const model = new MockLanguageModelV3({ modelId: "composer-model" });
+  const input = create_input(model);
+  const step = await new DefaultSessionComposer().compose(input);
+
+  assert.equal(step.messages.length, 1);
+  assert.equal(step.messages[0].parts[0].text, "hello");
+  assert.equal(step.system_blocks[0].content, "Base instruction");
+  assert.match(step.system.at(-1).content, /composer-session/);
+});
+
+test("Custom Composer 可以覆盖组装结果而不接触持久化", async () => {
+  class CustomComposer extends DefaultSessionComposer {
+    async compose(input) {
+      const step = await super.compose(input);
+      return {
+        ...step,
+        system: [
+          ...step.system,
+          { role: "system", content: "Custom behavior" },
+        ],
+      };
+    }
+  }
+
+  const model = new MockLanguageModelV3({ modelId: "custom-composer-model" });
+  const input = create_input(model);
+  const before = structuredClone(input.history);
+  const step = await new CustomComposer().compose(input);
+
+  assert.equal(step.system.at(-1).content, "Custom behavior");
+  assert.deepEqual(input.history, before);
+});
+
+test("Session system 快照与 Custom Composer 的实际模型输入一致", async () => {
+  class CustomComposer extends DefaultSessionComposer {
+    async compose(input) {
+      const step = await super.compose(input);
+      return {
+        ...step,
+        system: [
+          ...step.system,
+          { role: "system", content: "Custom snapshot behavior" },
+        ],
+      };
+    }
+  }
+
+  class CustomSession extends Session {
+    constructor(options) {
+      super({ ...options, composer: new CustomComposer() });
+    }
+  }
+
+  const project_root = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-session-composer-system-"),
+  );
+  const agent = new Agent({
+    id: "custom_composer_agent",
+    path: project_root,
+    model: new MockLanguageModelV3({ modelId: "custom-composer-model" }),
+    Session: CustomSession,
+  });
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "custom_composer_session",
+    });
+    const snapshot = await session.system();
+    assert.equal(snapshot.blocks.at(-1).content, "Custom snapshot behavior");
+    assert.equal(snapshot.blocks.at(-1).source, "session");
+  } finally {
+    await agent.dispose();
+    await fs.rm(project_root, { recursive: true, force: true });
+  }
+});
+
+test("Composer compact 只返回计划，不修改 Message 快照", async () => {
+  const model = new MockLanguageModelV3({
+    modelId: "composer-compact-model",
+    doGenerate: async () => ({
+      content: [{ type: "text", text: "Composer summary" }],
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: {
+        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+        outputTokens: { total: 0, text: 0, reasoning: 0 },
+      },
+      warnings: [],
+    }),
+  });
+  const input = create_input(model);
+  const before = structuredClone(input.history);
+  const plan = await new DefaultSessionComposer().compact({
+    ...input,
+    force: true,
+  });
+
+  assert.equal(plan.through_sequence, 1);
+  assert.equal(plan.summary.text, "Composer summary");
+  assert.deepEqual(input.history, before);
+});

package/scripts/session-config-turn-boundary.test.mjs

@@ -222,10 +222,7 @@ test("running session model changes apply with steer at the next Session step",
         message.type === "action" &&
         message.title === "Session model switched from old-model to new-model",
     );
-    assert.deepEqual(
-      model_actions.map((message) => message.status),
-      ["completed"],
-    );
+    assert.deepEqual(model_actions, []);
   } finally {
     release_old_model.resolve();
     await agent.dispose();
@@ -261,7 +258,7 @@ test("config remains effective when its action message cannot be persisted", asy
     const session = await agent.sessions.create({
       sessionId: "config_action_observability_session",
     });
-    session.stateService.emit_action_event = async () => {
+    session.emit_action_event = async () => {
       throw new Error("action store unavailable");
     };
 

package/scripts/session-list-title.test.mjs

@@ -67,6 +67,7 @@ async function create_agent_with_titled_session(input) {
   const session = await collection.create({
     sessionId: input.session_id,
   });
+  await session.set({ model: create_mock_title_model(input.title) });
 
   await session.append_user_message({
     text: input.first_user_text,
@@ -141,7 +142,7 @@ test("list_sessions returns persisted title from active session metadata", async
   }
 });
 
-test("list_sessions reflects canonical Recorder history changes", async () => {
+test("list_sessions reflects canonical SessionMessages changes", async () => {
   const { agent, collection, session } = await create_agent_with_titled_session({
     tmp_prefix: "downcity-agent-session-summary-repair-",
     agent_id: "summary_repair_agent",
@@ -165,7 +166,7 @@ test("list_sessions reflects canonical Recorder history changes", async () => {
     await session.append_assistant_message({
       text: "Recorder appended history",
     });
-    await session.recorder.compact_active({
+    await session.session_messages.compact_active({
       through_sequence: 1,
       summary: {
         record_type: "summary",

package/scripts/session-messages-error.test.mjs

@@ -0,0 +1,57 @@
+/**
+ * @file 验证 SessionMessages 不会掩盖 canonical Store 写入失败。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionMessages } from "../bin/session/SessionMessages.js";
+
+function create_messages(store) {
+  return new SessionMessages({
+    session_id: "messages-error-session",
+    store: {
+      initialize: async () => {},
+      list_messages: async () => [],
+      ...store,
+    },
+    publish: () => {},
+  });
+}
+
+test("append_user_message 透传 Store 写入失败", async () => {
+  const messages = create_messages({
+    append_message: async () => {
+      throw new Error("disk full");
+    },
+  });
+  await messages.initialize();
+  await assert.rejects(
+    messages.append_user_message({
+      turn_id: "turn-1",
+      input_type: "prompt",
+      parts: [{
+        part_id: "text-1",
+        type: "text",
+        text: "hello",
+        state: "done",
+      }],
+    }),
+    /disk full/,
+  );
+});
+
+test("open_assistant_message 透传草稿写入失败", async () => {
+  const messages = create_messages({
+    create_assistant_message: async () => {
+      throw new Error("disk full");
+    },
+  });
+  await messages.initialize();
+  await assert.rejects(
+    messages.open_assistant_message({
+      turn_id: "turn-1",
+      segment_index: 1,
+    }),
+    /disk full/,
+  );
+});