@downcity/agent 1.1.287 → 1.1.310

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

@@ -13,10 +13,10 @@ 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 { Agent, Workspace } from "../bin/index.js";
 import {
-  createAction,
-  createPlugin,
+  create_action,
+  create_plugin,
 } from "../bin/plugin/core/PluginActionFactory.js";
 
 function create_deferred() {
@@ -82,7 +82,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
       return create_stream_text_result(`done:${String(provider_request_count)}`);
     },
   });
-  const runtime_plugin = createPlugin({
+  const runtime_plugin = create_plugin({
     name: "runtime-config",
     title: "Runtime Config",
     description: "Provides a system block for turn-boundary tests",
@@ -91,32 +91,36 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
         plugin_stop_count += 1;
       },
     },
-    system: (context) => `plugin-env:${context.env.TURN_ENV || "missing"}`,
+    system: (_context, execution_context) =>
+      `plugin-env:${execution_context?.workspace_env?.TURN_ENV || "missing"}`,
     actions: {
-      ping: createAction({
+      ping: create_action({
         description: "Ping",
         execute: async () => ({ success: true, data: { ok: true } }),
       }),
     },
   });
+  const workspace = new Workspace({
+    path: agent_path,
+    env: { TURN_ENV: "old" },
+  });
   const agent = new Agent({
     id: "config_turn_boundary_agent",
-    path: agent_path,
+    workspace,
     model,
     instruction: ["instruction:old"],
-    env: { TURN_ENV: "old" },
     plugins: [runtime_plugin],
   });
 
   try {
     const session = await agent.sessions.create({
-      sessionId: "config_turn_boundary_session",
+      session_id: "config_turn_boundary_session",
     });
     const first_turn = await session.prompt({ query: "first" });
     await first_provider_request_started.promise;
 
-    agent.setInstruction(["instruction:new"]);
-    agent.patchEnv({ TURN_ENV: "new" });
+    agent.set_instruction(["instruction:new"]);
+    workspace.patch_env({ TURN_ENV: "new" });
     await agent.plugins.unregister("runtime-config");
     const steer_turn_promise = session.prompt({ query: "steer" });
 
@@ -142,7 +146,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
       .filter((message) => message.type === "action" && message.status === "completed")
       .map((message) => message.title);
     assert.deepEqual(completed_actions, [
-      "Agent environment updated",
+      "Workspace environment updated",
       "Agent plugin runtime-config unregistered",
     ]);
 
@@ -157,7 +161,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
     assert.doesNotMatch(restored_system_text, /instruction:old/);
 
     const new_session = await agent.sessions.create({
-      sessionId: "config_turn_boundary_new_session",
+      session_id: "config_turn_boundary_new_session",
     });
     const new_system = await new_session.system();
     const new_system_text = new_system.blocks
@@ -177,10 +181,10 @@ test("Plugin registry changes do not rewrite an existing Session system", async
   );
   const agent = new Agent({
     id: "fixed_plugin_system_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model: new MockLanguageModelV3({ modelId: "fixed-plugin-system-model" }),
   });
-  const runtime_plugin = createPlugin({
+  const runtime_plugin = create_plugin({
     name: "runtime-system",
     title: "Runtime System",
     description: "Provides a fixed Session system test block",
@@ -189,7 +193,7 @@ test("Plugin registry changes do not rewrite an existing Session system", async
 
   try {
     const existing_session = await agent.sessions.create({
-      sessionId: "existing_session",
+      session_id: "existing_session",
     });
     const existing_before = await existing_session.system();
 
@@ -198,7 +202,7 @@ test("Plugin registry changes do not rewrite an existing Session system", async
     assert.deepEqual(existing_after_register, existing_before);
 
     const registered_session = await agent.sessions.create({
-      sessionId: "registered_session",
+      session_id: "registered_session",
     });
     const registered_before = await registered_session.system();
     assert.match(
@@ -211,7 +215,7 @@ test("Plugin registry changes do not rewrite an existing Session system", async
     assert.deepEqual(registered_after_unregister, registered_before);
 
     const unregistered_session = await agent.sessions.create({
-      sessionId: "unregistered_session",
+      session_id: "unregistered_session",
     });
     assert.doesNotMatch(
       (await unregistered_session.system()).blocks
@@ -239,7 +243,7 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
     session_id,
     "instruction.md",
   );
-  const create_system_plugin = (content) => createPlugin({
+  const create_system_plugin = (content) => create_plugin({
     name: "syncshot-system",
     title: "Syncshot System",
     description: "Provides system text refreshed by session.syncshot()",
@@ -248,21 +252,21 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
   const model = new MockLanguageModelV3({ modelId: "syncshot-model" });
   const agent = new Agent({
     id: "syncshot_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:initial"],
     plugins: [create_system_plugin("plugin-system:initial")],
   });
 
   try {
-    const session = await agent.sessions.create({ sessionId: session_id });
+    const session = await agent.sessions.create({ session_id: session_id });
     const initial_text = (await session.system()).blocks
       .map((block) => block.content)
       .join("\n");
     assert.match(initial_text, /instruction:initial/);
     assert.match(initial_text, /plugin-system:initial/);
 
-    agent.setInstruction(["instruction:refreshed"]);
+    agent.set_instruction(["instruction:refreshed"]);
     await agent.plugins.register(create_system_plugin("plugin-system:refreshed"));
     await session.syncshot();
 
@@ -275,7 +279,7 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
     await assert.rejects(fs.access(instruction_path));
 
     await session.snapshot();
-    agent.setInstruction(["instruction:latest"]);
+    agent.set_instruction(["instruction:latest"]);
     await agent.plugins.register(create_system_plugin("plugin-system:latest"));
     await Promise.all([session.snapshot(), session.syncshot()]);
 
@@ -303,10 +307,10 @@ test("Session snapshot explicitly persists the complete system to instruction.md
   const model = new MockLanguageModelV3({ modelId: "instruction-restart-model" });
   const first_agent = new Agent({
     id: "instruction_restart_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:old"],
-    plugins: [createPlugin({
+    plugins: [create_plugin({
       name: "snapshot-system",
       title: "Snapshot System",
       description: "Provides system text persisted by session.snapshot()",
@@ -316,7 +320,7 @@ test("Session snapshot explicitly persists the complete system to instruction.md
 
   try {
     const session = await first_agent.sessions.create({
-      sessionId: "instruction_restart_session",
+      session_id: "instruction_restart_session",
     });
     const first_system = await session.system();
     assert.match(
@@ -349,7 +353,7 @@ test("Session snapshot explicitly persists the complete system to instruction.md
 
   const restarted_agent = new Agent({
     id: "instruction_restart_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:new"],
   });
@@ -381,7 +385,7 @@ test("Session snapshot explicitly persists the complete system to instruction.md
 
   const fallback_agent = new Agent({
     id: "instruction_restart_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:new"],
   });
@@ -408,12 +412,12 @@ test("empty Session snapshot suppresses Agent instruction after restart", async
   const model = new MockLanguageModelV3({ modelId: "empty-snapshot-model" });
   const first_agent = new Agent({
     id: "empty_snapshot_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
   });
   try {
     const session = await first_agent.sessions.create({
-      sessionId: "empty_snapshot_session",
+      session_id: "empty_snapshot_session",
     });
     await session.snapshot();
   } finally {
@@ -422,7 +426,7 @@ test("empty Session snapshot suppresses Agent instruction after restart", async
 
   const restarted_agent = new Agent({
     id: "empty_snapshot_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:must-not-appear"],
   });
@@ -467,12 +471,12 @@ test("running session model changes apply with steer at the next Session step",
       return create_stream_text_result("new response");
     },
   });
-  const runtime_plugin = createPlugin({
+  const runtime_plugin = create_plugin({
     name: "model-boundary",
     title: "Model Boundary",
     description: "Ensures the main provider request has tools",
     actions: {
-      ping: createAction({
+      ping: create_action({
         description: "Ping",
         execute: async () => ({ success: true, data: { ok: true } }),
       }),
@@ -480,19 +484,27 @@ test("running session model changes apply with steer at the next Session step",
   });
   const agent = new Agent({
     id: "session_step_boundary_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model: old_model,
     plugins: [runtime_plugin],
   });
 
   try {
     const session = await agent.sessions.create({
-      sessionId: "session_step_boundary_session",
+      session_id: "session_step_boundary_session",
+    });
+    await session.set({ model: old_model });
+    const mutations = [];
+    const unsubscribe = session.subscribe((mutation) => {
+      mutations.push(mutation);
     });
     const first_turn = await session.prompt({ query: "first" });
     await old_model_started.promise;
 
-    await session.set({ model: new_model });
+    await session.set({
+      model: new_model,
+      security: { approval_mode: "always-allow" },
+    });
     const steer_turn_promise = session.prompt({ query: "continue" });
     assert.deepEqual(model_calls, ["old-model"]);
 
@@ -507,15 +519,126 @@ test("running session model changes apply with steer at the next Session step",
     const model_actions = messages.items.filter(
       (message) =>
         message.type === "action" &&
-        message.title === "Session model switched from old-model to new-model",
+        message.title === "Session configuration updated" &&
+        message.description ===
+          "model: new-model; security.approval_mode: always-allow",
+    );
+    assert.equal(model_actions.length, 1);
+    assert.equal(model_actions[0].status, "completed");
+    assert.equal(
+      mutations.some(
+        (mutation) =>
+          mutation.variant === "message" &&
+          mutation.type === "action" &&
+          mutation.message.status === "completed" &&
+          mutation.message.title === "Session configuration updated" &&
+          mutation.message.description ===
+            "model: new-model; security.approval_mode: always-allow",
+      ),
+      true,
     );
-    assert.deepEqual(model_actions, []);
+    unsubscribe();
   } finally {
     release_old_model.resolve();
     await agent.dispose();
   }
 });
 
+test("running session approval mode changes stay queued until the next Session step", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-session-approval-mode-boundary-"),
+  );
+  const first_provider_request_started = create_deferred();
+  const release_first_provider_request = create_deferred();
+  let provider_request_count = 0;
+  const model = new MockLanguageModelV3({
+    modelId: "approval-mode-boundary-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("Approval title");
+      provider_request_count += 1;
+      if (provider_request_count === 1) {
+        first_provider_request_started.resolve();
+        await release_first_provider_request.promise;
+      }
+      return create_stream_text_result(`approval:${provider_request_count}`);
+    },
+  });
+  const runtime_plugin = create_plugin({
+    name: "approval-mode-boundary",
+    title: "Approval Mode Boundary",
+    description: "Keeps the provider request on the tool-enabled execution path",
+    actions: {
+      ping: create_action({
+        description: "Ping",
+        execute: async () => ({ success: true, data: { ok: true } }),
+      }),
+    },
+  });
+  const agent = new Agent({
+    id: "approval_mode_boundary_agent",
+    workspace: new Workspace({ path: agent_path }),
+    model,
+    plugins: [runtime_plugin],
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      session_id: "approval_mode_boundary_session",
+    });
+    const first_turn = await session.prompt({ query: "first" });
+    await first_provider_request_started.promise;
+
+    await session.set({ security: { approval_mode: "always-allow" } });
+    assert.deepEqual(await session.status(), {
+      session_id: session.id,
+      state: "running",
+      active_turn_id: first_turn.id,
+      security: {
+        approval_mode: "always-allow",
+        effective_approval_mode: "ask",
+      },
+    });
+
+    release_first_provider_request.resolve();
+    assert.equal((await first_turn.finished).success, true);
+    assert.deepEqual(await session.status(), {
+      session_id: session.id,
+      state: "idle",
+      security: {
+        approval_mode: "always-allow",
+        effective_approval_mode: "ask",
+      },
+    });
+
+    const second_turn = await session.prompt({ query: "second" });
+    assert.equal((await second_turn.finished).success, true);
+    assert.deepEqual(await session.status(), {
+      session_id: session.id,
+      state: "idle",
+      security: {
+        approval_mode: "always-allow",
+        effective_approval_mode: "always-allow",
+      },
+    });
+    const messages = await session.messages();
+    assert.equal(
+      messages.items.some(
+        (message) =>
+          message.type === "action" &&
+          message.status === "completed" &&
+          message.title === "Session configuration updated" &&
+          message.description === "security.approval_mode: always-allow",
+      ),
+      true,
+    );
+  } finally {
+    release_first_provider_request.resolve();
+    await agent.dispose();
+    await fs.rm(agent_path, { recursive: true, force: true });
+  }
+});
+
 test("config remains effective when its action message cannot be persisted", async () => {
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-config-action-observability-"),
@@ -537,25 +660,36 @@ test("config remains effective when its action message cannot be persisted", asy
   });
   const agent = new Agent({
     id: "config_action_observability_agent",
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model: old_model,
   });
 
   try {
     const session = await agent.sessions.create({
-      sessionId: "config_action_observability_session",
+      session_id: "config_action_observability_session",
     });
-    session.emit_action_event = async () => {
+    await session.set({ model: old_model });
+    const initial_turn = await session.prompt({ query: "initialize model" });
+    assert.equal((await initial_turn.finished).success, true);
+    model_calls.splice(0, model_calls.length);
+    const initial_action_count = (await session.messages()).items.filter(
+      (message) => message.type === "action",
+    ).length;
+
+    session.session_messages.persist_action_record = async () => {
       throw new Error("action store unavailable");
     };
 
     await session.set({ model: new_model });
     const turn = await session.prompt({ query: "use configured model" });
     assert.equal((await turn.finished).success, true);
-    assert.deepEqual(model_calls, ["new", "new"]);
+    assert.deepEqual(model_calls, ["new"]);
 
     const messages = await session.messages();
-    assert.equal(messages.items.some((message) => message.type === "action"), false);
+    assert.equal(
+      messages.items.filter((message) => message.type === "action").length,
+      initial_action_count,
+    );
   } finally {
     await agent.dispose();
   }

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

@@ -2,8 +2,8 @@
  * @file 验证 session 列表从正确目录读取持久化 title。
  *
  * 关键点（中文）
- * - 普通列表只读取 `.downcity/agents/<agentId>/sessions` 下的 meta。
- * - 归档列表只读取 `.downcity/agents/<agentId>/archived-sessions` 下的 meta。
+ * - 普通列表只读取 `.downcity/agents/<agent_id>/sessions` 下的 meta。
+ * - 归档列表只读取 `.downcity/agents/<agent_id>/archived-sessions` 下的 meta。
  * - title 允许为空；这里仅验证已由模型生成并落盘的 title 能被列表返回。
  */
 
@@ -14,7 +14,7 @@ import path from "node:path";
 import fs from "node:fs/promises";
 
 import { MockLanguageModelV3 } from "ai/test";
-import { Agent } from "../bin/index.js";
+import { Agent, Workspace } from "../bin/index.js";
 
 function create_mock_title_model(title_text) {
   return new MockLanguageModelV3({
@@ -60,12 +60,12 @@ async function create_agent_with_titled_session(input) {
   );
   const agent = new Agent({
     id: input.agent_id,
-    path: agent_path,
+    workspace: new Workspace({ path: agent_path }),
     model: create_mock_title_model(input.title),
   });
   const collection = agent.sessions;
   const session = await collection.create({
-    sessionId: input.session_id,
+    session_id: input.session_id,
   });
   await session.set({ model: create_mock_title_model(input.title) });
 
@@ -94,7 +94,7 @@ test("list_sessions returns persisted title from active session metadata", async
     const meta = JSON.parse(
       await fs.readFile(
         path.join(
-          agent.path,
+          agent.workspace.path,
           ".downcity",
           "agents",
           encodeURIComponent(agent.id),
@@ -108,11 +108,11 @@ test("list_sessions returns persisted title from active session metadata", async
     );
 
     assert.equal(page.total, 1);
-    assert.equal(meta.messageCount, 1);
-    assert.equal(meta.previewText, "Need the session list to show the generated title");
+    assert.equal(meta.message_count, 1);
+    assert.equal(meta.preview_text, "Need the session list to show the generated title");
     const history_stat = await fs.stat(
       path.join(
-        agent.path,
+        agent.workspace.path,
         ".downcity",
         "agents",
         encodeURIComponent(agent.id),
@@ -125,15 +125,15 @@ test("list_sessions returns persisted title from active session metadata", async
     assert.equal(meta.historyBytes, history_stat.size);
     assert.deepEqual(
       page.items.map((item) => ({
-        sessionId: item.sessionId,
+        session_id: item.session_id,
         title: item.title,
-        messageCount: item.messageCount,
+        message_count: item.message_count,
       })),
       [
         {
-          sessionId: session.id,
+          session_id: session.id,
           title: "列表标题",
-          messageCount: 1,
+          message_count: 1,
         },
       ],
     );
@@ -151,7 +151,7 @@ test("list_sessions reflects canonical SessionMessages changes", async () => {
     first_user_text: "Initial history",
   });
   const messages_dir = path.join(
-    agent.path,
+    agent.workspace.path,
     ".downcity",
     "agents",
     encodeURIComponent(agent.id),
@@ -188,11 +188,11 @@ test("list_sessions reflects canonical SessionMessages changes", async () => {
       "000000000001-000000000001.jsonl",
     ));
 
-    assert.equal(page.items[0].messageCount, 2);
-    assert.equal(info.messageCount, 2);
-    assert.equal(page.items[0].previewText, "Recorder appended history");
-    assert.equal(repaired_meta.messageCount, 2);
-    assert.equal(repaired_meta.previewText, "Recorder appended history");
+    assert.equal(page.items[0].message_count, 2);
+    assert.equal(info.message_count, 2);
+    assert.equal(page.items[0].preview_text, "Recorder appended history");
+    assert.equal(repaired_meta.message_count, 2);
+    assert.equal(repaired_meta.preview_text, "Recorder appended history");
     assert.equal(repaired_meta.historyBytes, history_stat.size + segment_stat.size);
   } finally {
     await agent.dispose();
@@ -220,15 +220,15 @@ test("archive_sessions returns title from archived session metadata", async () =
     assert.equal(archived_page.total, 1);
     assert.deepEqual(
       archived_page.items.map((item) => ({
-        sessionId: item.sessionId,
+        session_id: item.session_id,
         title: item.title,
-        messageCount: item.messageCount,
+        message_count: item.message_count,
       })),
       [
         {
-          sessionId: session.id,
+          session_id: session.id,
           title: "归档标题",
-          messageCount: 1,
+          message_count: 1,
         },
       ],
     );

package/scripts/session-message-timeline.test.mjs

@@ -0,0 +1,65 @@
+/**
+ * @file 验证 canonical Session Message 到宿主时间线的稳定投影。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { to_session_message_timeline_events } from "../bin/index.js";
+
+test("Session timeline preserves assistant text and tool order", () => {
+  const message = {
+    message_id: "assistant-1",
+    session_id: "session-1",
+    turn_id: "turn-1",
+    sequence: 1,
+    revision: 1,
+    visibility: "visible",
+    created_at: 10,
+    updated_at: 20,
+    type: "assistant",
+    kind: "normal",
+    status: "completed",
+    parts: [
+      {
+        part_id: "text-1",
+        sequence: 1,
+        type: "text",
+        text: "checking",
+        state: "done",
+      },
+      {
+        part_id: "tool-1",
+        sequence: 2,
+        type: "tool",
+        tool_call_id: "call-1",
+        tool_name: "read",
+        state: "completed",
+        input: { path: "README.md" },
+        output: { text: "ok" },
+      },
+      {
+        part_id: "text-2",
+        sequence: 3,
+        type: "text",
+        text: "done",
+        state: "done",
+      },
+    ],
+  };
+
+  const events = to_session_message_timeline_events(message);
+  assert.deepEqual(events.map((event) => event.role), [
+    "assistant",
+    "tool-call",
+    "tool-result",
+    "assistant",
+  ]);
+  assert.deepEqual(events.map((event) => event.id), [
+    "assistant-1:0",
+    "assistant-1:1",
+    "assistant-1:2",
+    "assistant-1:3",
+  ]);
+  assert.equal(events[1].tool_name, "read");
+  assert.match(events[2].text, /"ok"/);
+});

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

@@ -50,7 +50,6 @@ test("open_assistant_message 透传草稿写入失败", async () => {
   await assert.rejects(
     messages.open_assistant_message({
       turn_id: "turn-1",
-      segment_index: 1,
     }),
     /disk full/,
   );