@downcity/agent 1.1.238 → 1.1.259

package/scripts/{session-recorder.test.mjs → session-messages.test.mjs}

@@ -1,5 +1,5 @@
 /**
- * @file 验证 SessionRecorder 的 Message 快照、Assistant 草稿与实时事件一致性。
+ * @file 验证 SessionMessages 的 Message 快照、Assistant 草稿与实时事件一致性。
  */
 
 import test from "node:test";
@@ -8,24 +8,57 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { JsonlSessionMessageStore } from "../bin/session/recorder/JsonlSessionMessageStore.js";
-import { SessionRecorder } from "../bin/session/recorder/SessionRecorder.js";
-import { SessionRecorderHistoryStore } from "../bin/session/recorder/SessionRecorderHistoryStore.js";
-import { SessionViewService } from "../bin/session/services/SessionViewService.js";
+import { JsonlSessionMessageStore } from "../bin/session/messages/JsonlSessionMessageStore.js";
+import { SessionMessages } from "../bin/session/SessionMessages.js";
+import { SessionApprovalBroker } from "../bin/session/approval/SessionApprovalBroker.js";
+import { compose_session_compaction } from "../bin/session/messages/SessionMessageCompaction.js";
+import { to_executor_history } from "../bin/session/messages/SessionMessageCodec.js";
 import { MockLanguageModelV3 } from "ai/test";
 
-async function create_recorder(session_id = "session-recorder-test") {
+/** 可暂停一次 Assistant 草稿写入，用于稳定复现并发写入顺序。 */
+class PausingAssistantMessageStore extends JsonlSessionMessageStore {
+  next_assistant_write = null;
+
+  pause_next_assistant_write() {
+    let mark_started;
+    let release;
+    const started = new Promise((resolve) => {
+      mark_started = resolve;
+    });
+    const wait = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.next_assistant_write = { mark_started, wait };
+    return { started, release };
+  }
+
+  async write_assistant_message(message) {
+    const pending = this.next_assistant_write;
+    if (pending) {
+      this.next_assistant_write = null;
+      pending.mark_started();
+      await pending.wait;
+    }
+    await super.write_assistant_message(message);
+  }
+}
+
+async function create_recorder(
+  session_id = "session-recorder-test",
+  create_store = (options) => new JsonlSessionMessageStore(options),
+) {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-recorder-"));
   const file_path = path.join(root_path, "active.jsonl");
   const assistant_message_file_path = path.join(root_path, "assistant_message.json");
   const events = [];
-  const recorder = new SessionRecorder({
+  const store = create_store({ session_id, file_path });
+  const recorder = new SessionMessages({
     session_id,
-    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    store,
     publish: (mutation) => events.push(mutation),
   });
   await recorder.initialize();
-  return { recorder, events, file_path, assistant_message_file_path };
+  return { recorder, store, events, file_path, assistant_message_file_path };
 }
 
 async function read_jsonl(file_path) {
@@ -41,7 +74,7 @@ async function create_seeded_recorder(session_id, messages) {
     `${messages.map((message) => JSON.stringify(message)).join("\n")}\n`,
     "utf8",
   );
-  const recorder = new SessionRecorder({
+  const recorder = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
@@ -50,6 +83,20 @@ async function create_seeded_recorder(session_id, messages) {
   return { recorder, file_path };
 }
 
+async function compact_messages(recorder, session_id, model) {
+  const plan = await compose_session_compaction({
+    session_id,
+    snapshot: await recorder.context_snapshot(),
+    model,
+  });
+  if (!plan) return false;
+  await recorder.compact_active({
+    through_sequence: plan.through_sequence,
+    summary: plan.summary,
+  });
+  return true;
+}
+
 function create_seeded_user_message(session_id, sequence) {
   return {
     message_id: `user-${String(sequence)}`,
@@ -110,26 +157,42 @@ test("delta 只更新 Assistant 草稿，完成后才写入 active.jsonl", async
   assert.equal(history.some((value) => "variant" in value), false);
 });
 
-test("Tool Part 在文本中间创建后，输入、审批和输出都保持原顺序", async () => {
+test("Tool Runtime 在文本中间保持输入、审批和输出的确定顺序", async () => {
   const { recorder, events, file_path } = await create_recorder("tool-order-test");
+  const approval_broker = new SessionApprovalBroker({
+    session_id: "tool-order-test",
+    messages: recorder,
+  });
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
   await writer.apply_chunk({ type: "text-start", id: "text-1" });
   await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "before" });
   await writer.apply_chunk({ type: "text-end", id: "text-1" });
-  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-1", toolName: "search" });
+  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-1", toolName: "shell_exec" });
   await writer.apply_chunk({
     type: "tool-input-available",
     toolCallId: "call-1",
-    toolName: "search",
-    input: { query: "downcity" },
+    toolName: "shell_exec",
+    input: { cmd: "pwd", sandbox: "unrestricted", reason: "Inspect directory" },
   });
   assert.equal(recorder.get_message(writer.message_id).parts[1].state, "ready");
-  await writer.apply_chunk({
-    type: "tool-approval-request",
-    toolCallId: "call-1",
-    approvalId: "approval-1",
+  const approval_handle = await approval_broker.request({
+    shell_id: "shell-1",
+    tool_call_id: "call-1",
+    tool_name: "shell_exec",
+    session_id: "tool-order-test",
+    turn_id: "turn-1",
+    command: "pwd",
+    cwd: "/workspace",
+    reason: "Inspect directory",
+    operation: "exec",
+    timeout_ms: 60_000,
   });
   assert.equal(recorder.get_message(writer.message_id).parts[1].state, "approval-required");
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "approved",
+  });
+  assert.equal(await approval_handle.decision, "approved");
   await writer.apply_chunk({ type: "text-start", id: "text-2" });
   await writer.apply_chunk({ type: "text-delta", id: "text-2", delta: "after" });
   await writer.apply_chunk({ type: "text-end", id: "text-2" });
@@ -145,10 +208,158 @@ test("Tool Part 在文本中间创建后，输入、审批和输出都保持原
     events
       .filter((event) => event.variant === "part" && event.type === "tool")
       .map((event) => [event.part.sequence, event.part.state]),
-    [[2, "input-streaming"], [2, "ready"], [2, "approval-required"], [2, "completed"]],
+    [
+      [2, "input-streaming"],
+      [2, "ready"],
+      [2, "approval-required"],
+      [2, "running"],
+      [2, "completed"],
+    ],
+  );
+});
+
+test("Approval Broker 只接受已经准备完整输入的 Tool", async () => {
+  const { recorder, events } = await create_recorder("tool-ready-barrier-test");
+  const approval_broker = new SessionApprovalBroker({
+    session_id: "tool-ready-barrier-test",
+    messages: recorder,
+  });
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-ready-barrier",
+    segment_index: 1,
+  });
+  const approval_input = {
+    shell_id: "shell-ready-barrier",
+    tool_call_id: "call-ready-barrier",
+    tool_name: "shell_exec",
+    session_id: "tool-ready-barrier-test",
+    turn_id: "turn-ready-barrier",
+    command: "ls -la /Users/example/Desktop",
+    cwd: "/workspace",
+    reason: "Inspect requested desktop files",
+    operation: "exec",
+    timeout_ms: 60_000,
+  };
+  await assert.rejects(
+    approval_broker.request(approval_input),
+    /Streaming Tool Part not found/,
+  );
+  assert.equal(approval_broker.list().length, 0);
+
+  await writer.prepare_tool_input({
+    tool_call_id: "call-ready-barrier",
+    tool_name: "shell_exec",
+    input: {
+      cmd: "ls -la /Users/example/Desktop",
+      sandbox: "unrestricted",
+      reason: "Inspect requested desktop files",
+    },
+  });
+  const approval_handle = await approval_broker.request(approval_input);
+
+  const tool = recorder.get_message(writer.message_id).parts[0];
+  assert.equal(tool.state, "approval-required");
+  assert.equal(tool.approval.approval_id, approval_handle.approval_id);
+  assert.equal(tool.approval.command, approval_input.command);
+  assert.equal(tool.input.cmd, "ls -la /Users/example/Desktop");
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "denied",
+  });
+  assert.equal(await approval_handle.decision, "denied");
+  await writer.apply_chunk({
+    type: "tool-output-available",
+    toolCallId: "call-ready-barrier",
+    output: { success: false, approval_status: "denied" },
+  });
+  assert.equal(recorder.get_message(writer.message_id).parts[0].state, "failed");
+  assert.deepEqual(
+    events
+      .filter((event) => event.variant === "part" && event.type === "tool")
+      .map((event) => event.part.state),
+    ["ready", "approval-required", "failed"],
   );
 });
 
+test("流式更新与 Approval 共享 Assistant revision 写队列", async () => {
+  const session_id = "approval-revision-queue-test";
+  const { recorder, store, events } = await create_recorder(
+    session_id,
+    (options) => new PausingAssistantMessageStore(options),
+  );
+  const approval_broker = new SessionApprovalBroker({ session_id, messages: recorder });
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-approval-race",
+    segment_index: 1,
+  });
+  await writer.prepare_tool_input({
+    tool_call_id: "call-approval-race",
+    tool_name: "shell_exec",
+    input: {
+      cmd: "ls -la ~",
+      sandbox: "unrestricted",
+      reason: "验证审批写入顺序",
+    },
+  });
+  await writer.apply_chunk({ type: "text-start", id: "text-race" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-race", delta: "准备执行" });
+
+  const gate = store.pause_next_assistant_write();
+  const stream_write = writer.apply_chunk({
+    type: "text-delta",
+    id: "text-race",
+    delta: "命令",
+  });
+  await gate.started;
+  const approval_write = approval_broker.request({
+    shell_id: "shell-approval-race",
+    tool_call_id: "call-approval-race",
+    tool_name: "shell_exec",
+    session_id,
+    turn_id: "turn-approval-race",
+    command: "ls -la ~",
+    cwd: "/workspace",
+    reason: "验证审批写入顺序",
+    operation: "exec",
+    timeout_ms: 60_000,
+  });
+
+  // 让 Approval 路径有机会进入写入；旧实现会在这里基于同一 revision 提交。
+  await new Promise((resolve) => setImmediate(resolve));
+  gate.release();
+  const [, approval_handle] = await Promise.all([stream_write, approval_write]);
+
+  const assistant = recorder.get_message(writer.message_id);
+  const tool = assistant.parts.find((part) => part.type === "tool");
+  const text_part = assistant.parts.find((part) => part.type === "text");
+  assert.equal(assistant.revision, 6);
+  assert.equal(tool.state, "approval-required");
+  assert.equal(tool.approval.approval_id, approval_handle.approval_id);
+  assert.equal(tool.input.cmd, "ls -la ~");
+  assert.equal(text_part.text, "准备执行命令");
+  assert.deepEqual(
+    events
+      .filter((event) => event.message_id === writer.message_id)
+      .map((event) => event.revision),
+    [1, 2, 3, 4, 5, 6],
+  );
+  assert.equal(
+    events.some(
+      (event) =>
+        event.variant === "part" &&
+        event.type === "tool" &&
+        event.part.state === "approval-required",
+    ),
+    true,
+  );
+
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "denied",
+  });
+  assert.equal(await approval_handle.decision, "denied");
+});
+
 test("不同模型 step 重复使用 Text chunk ID 时仍保持真实 Part 顺序", async () => {
   const { recorder, file_path } = await create_recorder("reused-text-id-order-test");
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
@@ -248,7 +459,7 @@ test("重启时将 Assistant 草稿收口为 stopped，并将运行中 Action
   await recorder.open_action_message({ message_id: "running-action", action_type: "fork", title: "Forking" });
 
   const recovered_events = [];
-  const recovered = new SessionRecorder({
+  const recovered = new SessionMessages({
     session_id: "recovery-test",
     store: new JsonlSessionMessageStore({ session_id: "recovery-test", file_path }),
     publish: (mutation) => recovered_events.push(mutation),
@@ -292,7 +503,6 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
       parts: [{ part_id: `user-${String(index)}`, type: "text", text: `message ${String(index)}`, state: "done" }],
     });
   }
-  const history_store = new SessionRecorderHistoryStore({ session_id: "compact-test", recorder });
   const model = new MockLanguageModelV3({
     modelId: "compact-model",
     doGenerate: async () => ({
@@ -305,12 +515,7 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
       warnings: [],
     }),
   });
-  const result = await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
-  assert.equal(result.compacted, true);
+  assert.equal(await compact_messages(recorder, "compact-test", model), true);
   assert.equal((await fs.readFile(file_path, "utf8")).includes("message 1"), false);
   const active = await recorder.list_messages({ include_internal: true });
   assert.deepEqual(active.items.map((message) => message.sequence), []);
@@ -322,7 +527,10 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
   });
   assert.deepEqual(segment.items.map((message) => message.sequence), [1, 2, 3, 4, 5, 6]);
   assert.equal(segment.source, "segment");
-  assert.equal((await history_store.list_records()).length, 1);
+  assert.equal(
+    to_executor_history("compact-test", await recorder.context_snapshot()).length,
+    1,
+  );
   await assert.rejects(
     recorder.list_messages({ before_sequence: 0 }),
     /before_sequence must be a positive integer/,
@@ -356,14 +564,13 @@ test("重启后从最新 Segment Summary 与 Active 恢复模型上下文", asyn
     },
   });
 
-  const restarted = new SessionRecorder({
+  const restarted = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
   });
   await restarted.initialize();
-  const context_store = new SessionRecorderHistoryStore({ session_id, recorder: restarted });
-  const context = await context_store.list_records();
+  const context = to_executor_history(session_id, await restarted.context_snapshot());
   assert.deepEqual(
     context.map((message) => message.parts[0]?.text),
     ["summary through 4", "message 5", "message 6"],
@@ -414,7 +621,7 @@ test("Compact 两步提交中断后会清理 Active 与 Segment 的重叠前缀"
     "utf8",
   );
 
-  const restarted = new SessionRecorder({
+  const restarted = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
@@ -449,7 +656,6 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
       };
     },
   });
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
   const append_messages = async (start, end) => {
     for (let index = start; index <= end; index += 1) {
       await recorder.append_user_message({
@@ -464,16 +670,12 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
       });
     }
   };
-  const compact = async () => await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
+  const compact = async () => await compact_messages(recorder, session_id, model);
 
   await append_messages(1, 8);
-  assert.equal((await compact()).compacted, true);
+  assert.equal(await compact(), true);
   await append_messages(9, 12);
-  assert.equal((await compact()).compacted, true);
+  assert.equal(await compact(), true);
 
   assert.equal(prompts.length, 2);
   assert.equal(prompts[1].includes("<previous-summary>"), true);
@@ -487,7 +689,7 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
     before_sequence: latest_segment.start_sequence,
   });
   assert.deepEqual(earliest_segment.items.map((message) => message.sequence), [1, 2, 3, 4, 5, 6, 7, 8]);
-  const context = await history_store.list_records();
+  const context = to_executor_history(session_id, await recorder.context_snapshot());
   assert.equal(context[0].parts[0]?.text, "Summary 2");
 });
 
@@ -512,14 +714,7 @@ test("Summary 生成失败时使用确定性 Summary 完成归档", async () =>
       throw new Error("summary unavailable");
     },
   });
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
-  const result = await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
-
-  assert.deepEqual(result, { compacted: true });
+  assert.equal(await compact_messages(recorder, session_id, model), true);
   assert.deepEqual((await recorder.list_messages()).items, []);
   const segment_entries = await fs.readdir(path.join(path.dirname(file_path), "segments"));
   assert.equal(segment_entries.length, 1);
@@ -554,52 +749,9 @@ test("内部上下文读取完整快照并保留第 500 条之后的最新消息
   assert.equal(previous.start_sequence, 1);
   assert.equal(previous.end_sequence, 499);
 
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
-  const context = await history_store.list_records();
+  const context = to_executor_history(session_id, await recorder.context_snapshot());
   assert.deepEqual(
     context.map((message) => message.parts[0]?.text),
     ["summary through 499", "message 500", "message 501"],
   );
 });
-
-test("Session fork 可以选择并复制第 500 条之后的消息", async () => {
-  const session_id = "complete-fork-snapshot-test";
-  const messages = Array.from(
-    { length: 501 },
-    (_, index) => create_seeded_user_message(session_id, index + 1),
-  );
-  const { recorder } = await create_seeded_recorder(session_id, messages);
-  let imported_messages = [];
-  const state_service = {
-    emit_action_event: async () => {},
-    get_config: () => ({}),
-  };
-  const view_service = new SessionViewService({
-    agent_id: "fork-agent",
-    project_root: os.tmpdir(),
-    session_id,
-    history_store: new SessionRecorderHistoryStore({ session_id, recorder }),
-    recorder,
-    state_service,
-    logger: { log: async () => {} },
-    is_executing: () => false,
-    get_instruction_system_blocks: () => [],
-    get_managed_plugin_system_blocks: async () => [],
-    get_plugin_system_blocks: async () => [],
-    create_fork_session: async () => ({
-      session: { id: "forked-session", set: async () => {} },
-      history_store: {},
-      recorder: {
-        import_messages: async (input) => {
-          imported_messages = input;
-        },
-      },
-      state_service: { set: async () => {} },
-    }),
-  });
-
-  await view_service.fork("user-501");
-
-  assert.equal(imported_messages.length, 501);
-  assert.equal(imported_messages[500].message_id, "user-501");
-});

package/scripts/session-queue.test.mjs

@@ -0,0 +1,64 @@
+/**
+ * @file 验证 SessionQueue 只维护 Prompt/Command 的确定 FIFO 顺序。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionQueue } from "../bin/session/SessionQueue.js";
+
+function model_command(command_id) {
+  return {
+    type: "session_model",
+    command_id,
+    config: {},
+  };
+}
+
+test("SessionQueue 返回首个 Prompt 及其之前的命令", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_command(model_command("command-1"));
+  const handle = queue.enqueue_prompt({ query: "first" });
+  queue.enqueue_command({ type: "compact", command_id: "compact-1" });
+
+  const next = queue.take_next_prompt();
+  assert.deepEqual(next.commands.map((item) => item.command_id), ["command-1"]);
+  assert.equal(next.prompt.input.query, "first");
+  assert.equal(handle instanceof Promise, true);
+  assert.equal(queue.has_command(), true);
+  assert.equal(queue.has_prompt(), false);
+});
+
+test("SessionQueue drain 保留 Prompt 和 Command 的原始顺序", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_prompt({ query: "steer-1" });
+  queue.enqueue_command(model_command("command-1"));
+  queue.enqueue_prompt({ query: "steer-2" });
+
+  assert.deepEqual(
+    queue.drain().map((item) => item.type),
+    ["prompt", "session_model", "prompt"],
+  );
+  assert.equal(queue.has_prompt(), false);
+});
+
+test("SessionQueue cancel_prompts 取消 Prompt 但保留命令", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_prompt({ query: "queued" });
+  queue.enqueue_command({ type: "compact", command_id: "compact-1" });
+
+  assert.equal(queue.cancel_prompts().length, 1);
+  assert.deepEqual(queue.drain(), [
+    { type: "compact", command_id: "compact-1" },
+  ]);
+});
+
+test("SessionQueue 可以把未处理输入恢复到队列头部", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_command({ type: "compact", command_id: "tail" });
+  queue.restore_front([model_command("head")]);
+
+  assert.deepEqual(
+    queue.drain().map((item) => item.command_id),
+    ["head", "tail"],
+  );
+});