@downcity/agent 1.1.287 → 1.1.310

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

@@ -8,33 +8,41 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
-import { SessionApprovalBroker } from "../bin/session/approval/SessionApprovalBroker.js";
-import { JsonlSessionMessageStore } from "../bin/session/messages/JsonlSessionMessageStore.js";
+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 { SessionMessages } from "../bin/session/SessionMessages.js";
 import { SessionEventHub } from "../bin/session/runtime/SessionEventHub.js";
-import { SessionTurn } from "../bin/session/SessionTurn.js";
+import { SessionLoop } from "../bin/session/SessionLoop.js";
+import { SessionQueue } from "../bin/session/SessionQueue.js";
 
-async function create_turn_harness(execute_run) {
+async function create_turn_harness(execute_turn) {
   const session_id = "session-turn-failure-test";
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-turn-failure-"));
   const messages = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({
+      files: new LocalFileSystem(root_path),
       session_id,
       file_path: path.join(root_path, "active.jsonl"),
     }),
     publish: () => {},
   });
   await messages.initialize();
+  const interactions = new SessionInteractions({ session_id, messages });
+  const shell_approval_gateway = new SessionShellApprovalAdapter({
+    session_id,
+    interactions,
+  });
 
-  const turn = new SessionTurn({
+  const turn = new SessionLoop({
     session_id,
-    project_root: root_path,
+    workspace_path: root_path,
     executor: {
-      run: async ({ runContext }) => await execute_run(runContext),
-      stop: () => false,
-      compact_history: async () => ({ compacted: false, reason: "nothing_to_compact" }),
+      execute: async ({ turn_context }) => await execute_turn(turn_context),
     },
+    compact_history: async () => ({ compacted: false, reason: "nothing_to_compact" }),
     state: {
       ensure_runnable: async () => {},
       ensure_title_from_history: async () => {},
@@ -42,8 +50,10 @@ async function create_turn_harness(execute_run) {
     },
     messages,
     events: new SessionEventHub(),
-    approvals: new SessionApprovalBroker({ session_id, messages }),
-    apply_command: async () => {},
+    logger: { log: async () => {} },
+    queue: new SessionQueue(),
+    interactions,
+    shell_approval_gateway,
   });
 
   return { messages, turn };
@@ -52,8 +62,9 @@ async function create_turn_harness(execute_run) {
 test("Provider 在输出前失败时只持久化 Error Message", async () => {
   const { messages, turn } = await create_turn_harness(async () => ({
     success: false,
+    text: "",
     error: "quota exceeded",
-    deferredPersistedUserMessages: [],
+    deferred_persisted_user_messages: [],
   }));
 
   const handle = await turn.prompt({ query: "hello" });
@@ -62,25 +73,51 @@ test("Provider 在输出前失败时只持久化 Error Message", async () => {
 
   assert.equal(result.success, false);
   assert.equal(result.error, "quota exceeded");
-  assert.equal(result.assistantMessage, undefined);
+  assert.equal(result.assistant_message, undefined);
   assert.deepEqual(page.items.map((message) => message.type), ["user", "error"]);
   assert.equal(page.items[1].code, "turn_execution_failed");
   assert.equal(page.items[1].message, "quota exceeded");
 });
 
+test("SessionLoop 在 Turn 收口后释放其 SessionTurnContext", async () => {
+  let release_count = 0;
+  const { turn } = await create_turn_harness(async (turn_context) => {
+    await turn_context.step.replace_plugins({
+      read: () => ({ plugins: [] }),
+      run_action: async () => ({ success: true }),
+      system_blocks: async () => [],
+      release: async () => {
+        release_count += 1;
+      },
+    });
+    return {
+      success: true,
+      text: "done",
+      deferred_persisted_user_messages: [],
+    };
+  });
+
+  const handle = await turn.prompt({ query: "hello" });
+  await handle.finished;
+
+  assert.equal(release_count, 1);
+});
+
 test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Error Message", async () => {
-  const { messages, turn } = await create_turn_harness(async (run_context) => {
-    await run_context.onUiMessageChunkCallback({ type: "text-start", id: "text-1" });
-    await run_context.onUiMessageChunkCallback({
+  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 run_context.onUiMessageChunkCallback({ type: "text-end", id: "text-1" });
+    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
     return {
       success: false,
+      text: "partial response",
       error: "stream interrupted",
-      deferredPersistedUserMessages: [],
+      deferred_persisted_user_messages: [],
     };
   });
 
@@ -89,7 +126,7 @@ test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Erro
   const page = await messages.list_messages();
 
   assert.equal(result.success, false);
-  assert.equal(result.assistantMessage, undefined);
+  assert.equal(result.assistant_message, undefined);
   assert.deepEqual(page.items.map((message) => message.type), [
     "user",
     "assistant",
@@ -101,31 +138,31 @@ test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Erro
 });
 
 test("Turn 使用 step canonical chunks 保持 Tool 与最终正文顺序", async () => {
-  const { messages, turn } = await create_turn_harness(async (run_context) => {
-    await run_context.on_ui_message_step_start();
-    await run_context.onUiMessageChunkCallback({
+  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 run_context.onUiMessageChunkCallback({
+    await turn_context.output.assistant.write_chunk({
       type: "tool-input-available",
       toolCallId: "call-1",
       toolName: "shell_exec",
       input: { cmd: "pwd" },
     });
-    await run_context.onUiMessageChunkCallback({
+    await turn_context.output.assistant.write_chunk({
       type: "tool-output-available",
       toolCallId: "call-1",
       output: { success: true },
     });
-    await run_context.onUiMessageChunkCallback({ type: "text-start", id: "text-1" });
-    await run_context.onUiMessageChunkCallback({
+    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 run_context.onUiMessageChunkCallback({ type: "text-end", id: "text-1" });
+    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
     const assistant_message = {
       id: "assistant-1",
       role: "assistant",
@@ -141,11 +178,11 @@ test("Turn 使用 step canonical chunks 保持 Tool 与最终正文顺序", asyn
         { type: "text", text: "最终结论", state: "done" },
       ],
     };
-    await run_context.on_ui_message_step_finish(assistant_message);
+    await turn_context.output.assistant.finish_step(assistant_message);
     return {
       success: true,
-      assistantMessage: assistant_message,
-      deferredPersistedUserMessages: [],
+      text: "最终结论",
+      deferred_persisted_user_messages: [],
     };
   });
 
@@ -159,18 +196,100 @@ test("Turn 使用 step canonical chunks 保持 Tool 与最终正文顺序", asyn
   assert.deepEqual(assistant.parts.map((part) => part.sequence), [1, 2]);
 });
 
+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 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",
+      output: { success: true },
+    });
+    await turn_context.output.assistant.finish_step({
+      id: "provider-step-1",
+      role: "assistant",
+      parts: [
+        { type: "text", text: "先检查项目。", state: "done" },
+        {
+          type: "dynamic-tool",
+          toolCallId: "call-1",
+          toolName: "shell_exec",
+          state: "output-available",
+          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" }],
+    });
+    return {
+      success: true,
+      text: "检查完成。",
+      deferred_persisted_user_messages: [],
+    };
+  });
+
+  const handle = await turn.prompt({ query: "检查项目" });
+  await handle.finished;
+  const page = await messages.list_messages();
+  const assistant_messages = page.items.filter(
+    (message) => message.type === "assistant",
+  );
+
+  assert.equal(assistant_messages.length, 1);
+  assert.deepEqual(
+    assistant_messages[0].parts.map((part) => part.type),
+    ["text", "tool", "text"],
+  );
+  assert.deepEqual(
+    assistant_messages[0].parts
+      .filter((part) => part.type === "text")
+      .map((part) => part.text),
+    ["先检查项目。", "检查完成。"],
+  );
+});
+
 test("Turn 在 step 最终快照出现未流式写入的 Tool 时失败", async () => {
-  const { messages, turn } = await create_turn_harness(async (run_context) => {
-    await run_context.on_ui_message_step_start();
-    await run_context.onUiMessageChunkCallback({ type: "text-start", id: "text-1" });
-    await run_context.onUiMessageChunkCallback({
+  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 run_context.onUiMessageChunkCallback({ type: "text-end", id: "text-1" });
+    await turn_context.output.assistant.write_chunk({ type: "text-end", id: "text-1" });
     try {
-      await run_context.on_ui_message_step_finish({
+      await turn_context.output.assistant.finish_step({
         id: "assistant-1",
         role: "assistant",
         parts: [
@@ -186,11 +305,12 @@ test("Turn 在 step 最终快照出现未流式写入的 Tool 时失败", async
         ],
       });
     } catch (error) {
-      await run_context.on_ui_message_step_abort();
+      await turn_context.output.assistant.abort_step();
       return {
         success: false,
+        text: "最终结论",
         error: error.message,
-        deferredPersistedUserMessages: [],
+        deferred_persisted_user_messages: [],
       };
     }
   });

package/scripts/workspace.test.mjs

@@ -0,0 +1,146 @@
+/**
+ * @file 验证 Workspace 的资源边界、工具装配与独立生命周期。
+ */
+
+import assert from "node:assert/strict";
+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";
+
+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 });
+  t.after(async () => {
+    await agent.dispose();
+    await fs.rm(root_path, { recursive: true, force: true });
+  });
+
+  assert.equal(workspace.path, await fs.realpath(root_path));
+  assert.deepEqual(Object.keys(workspace.tools).sort(), [
+    "edit",
+    "find",
+    "grep",
+    "read",
+    "write",
+  ]);
+  assert.equal(agent.workspace, workspace);
+  assert.equal(agent.get_shell(), undefined);
+});
+
+test("Workspace binds one Agent and is disposed with it", 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);
+    },
+    set_env(env) {
+      assert.deepEqual(env, {});
+    },
+    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 });
+  assert.throws(
+    () => new Agent({ id: "workspace-second", workspace }),
+    /already bound to Agent "workspace-first"/,
+  );
+
+  await agent.dispose();
+  await 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 }),
+  });
+
+  await first_agent.dispose();
+  await second_agent.dispose();
+});
+
+test("Workspace owns env and publishes only real changes", async (t) => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-env-"));
+  await fs.writeFile(path.join(root_path, ".env"), "FROM_FILE=file\nOVERRIDE=file\n");
+  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
+  const shell_env_snapshots = [];
+  const shell = {
+    tools: {},
+    bind() {},
+    set_env(env) {
+      shell_env_snapshots.push({ ...env });
+    },
+    async dispose() {},
+  };
+
+  const workspace = new Workspace({
+    path: root_path,
+    shell,
+    env: { OVERRIDE: "explicit", EXPLICIT: "value" },
+  });
+  const changes = [];
+  const unsubscribe = workspace.subscribe_env((env) => changes.push({ ...env }));
+
+  assert.deepEqual(workspace.get_env(), {
+    FROM_FILE: "file",
+    OVERRIDE: "explicit",
+    EXPLICIT: "value",
+  });
+  assert.deepEqual(shell_env_snapshots, [workspace.get_env()]);
+  workspace.patch_env({ OVERRIDE: "explicit" });
+  assert.equal(changes.length, 0);
+
+  workspace.patch_env({ FROM_FILE: null, NEXT: "next" });
+  assert.deepEqual(changes, [{
+    OVERRIDE: "explicit",
+    EXPLICIT: "value",
+    NEXT: "next",
+  }]);
+  assert.deepEqual(shell_env_snapshots.at(-1), changes.at(-1));
+
+  unsubscribe();
+  workspace.set_env({ ONLY: "one" });
+  assert.deepEqual(workspace.get_env(), { ONLY: "one" });
+  assert.equal(changes.length, 1);
+  assert.deepEqual(shell_env_snapshots.at(-1), { ONLY: "one" });
+  await workspace.dispose();
+});
+
+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 }));
+
+  assert.throws(
+    () => new Agent({
+      id: "workspace-tool-conflict",
+      workspace: new Workspace({ path: root_path }),
+      tools: { read: {} },
+    }),
+    /Agent tool name conflict: "read"/,
+  );
+  assert.throws(
+    () => new Agent({
+      id: "plugin-tool-conflict",
+      workspace: new Workspace({ path: root_path }),
+      tools: { plugin_call: {} },
+    }),
+    /reserved for PluginRegistry/,
+  );
+});