@downcity/agent 1.1.217 → 1.1.224

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

@@ -113,12 +113,15 @@ test("session.set only persists and publishes model-switching actions when model
     });
     const events = [];
     const unsubscribe = session.subscribe((event) => {
-      if (event.type === "action") events.push(event);
+      if (
+        event.variant === "message" && event.type === "action"
+      ) events.push(event.message);
     });
 
     await session.set({
+      modelId: "test-model",
       model: {
-        modelId: "test-model",
+        modelId: "test-model-label-v1",
         provider: "test",
       },
     });
@@ -126,8 +129,9 @@ test("session.set only persists and publishes model-switching actions when model
     assert.deepEqual(events, []);
 
     await session.set({
+      modelId: "test-model",
       model: {
-        modelId: "test-model",
+        modelId: "test-model-label-v2",
         provider: "test",
       },
     });
@@ -135,26 +139,32 @@ test("session.set only persists and publishes model-switching actions when model
     assert.deepEqual(events, []);
 
     await session.set({
+      modelId: "next-test-model",
       model: {
-        modelId: "next-test-model",
+        modelId: "next-test-model-label",
         provider: "test",
       },
     });
     unsubscribe();
 
     assert.deepEqual(
-      events.map((event) => `${event.title}:${event.state}`),
-      ["Switching session model:running", "Session model switched:completed"],
+      events.map((event) => `${event.title}:${event.status}`),
+      [
+        "Switching session model from test-model-label-v2 to next-test-model-label:running",
+        "Session model switched from test-model-label-v2 to next-test-model-label:completed",
+      ],
     );
-    assert.equal(new Set(events.map((event) => event.id)).size, 1);
+    assert.equal(new Set(events.map((event) => event.message_id)).size, 1);
 
-    const records = await session.records({ view: "timeline" });
-    const action_events = records.items.filter(
-      (item) => item.role === "action",
+    const messages = await session.messages();
+    const action_events = messages.items.filter(
+      (item) => item.type === "action",
     );
     assert.deepEqual(
-      action_events.map((event) => `${event.actionTitle}:${event.actionState}`),
-      ["Session model switched:completed"],
+      action_events.map((event) => `${event.title}:${event.status}`),
+      [
+        "Session model switched from test-model-label-v2 to next-test-model-label:completed",
+      ],
     );
   } finally {
     await agent.dispose();
@@ -177,9 +187,9 @@ test("default model initialization does not persist model-switching actions", as
     const session = await agent.sessions.create({
       sessionId: "model_init_action_session",
     });
-    const records = await session.records({ view: "timeline" });
-    const action_events = records.items.filter(
-      (item) => item.role === "action",
+    const messages = await session.messages();
+    const action_events = messages.items.filter(
+      (item) => item.type === "action",
     );
     assert.deepEqual(action_events, []);
   } finally {
@@ -237,6 +247,67 @@ test("session model id persists and restores through the host resolver", async (
   }
 });
 
+test("runtime restoration does not publish a model switch when model id is unchanged", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-agent-session-model-runtime-restore-"),
+  );
+  const first_agent = new Agent({
+    id: "session_model_runtime_restore_agent",
+    path: agent_path,
+    model: {
+      modelId: "default-model",
+      provider: "test",
+    },
+    model_id: "default-model",
+    resolve_model: async (model_id) => ({
+      modelId: model_id,
+      provider: "test",
+    }),
+  });
+  try {
+    const session = await first_agent.sessions.create({
+      sessionId: "runtime-restored-model-session",
+    });
+    await session.set({ modelId: "session-model" });
+  } finally {
+    await first_agent.dispose();
+  }
+
+  let resolve_count = 0;
+  const restored_agent = new Agent({
+    id: "session_model_runtime_restore_agent",
+    path: agent_path,
+    model: {
+      modelId: "other-default-model",
+      provider: "test",
+    },
+    model_id: "other-default-model",
+    resolve_model: async (model_id) => {
+      resolve_count += 1;
+      return {
+        modelId: model_id,
+        provider: "test",
+      };
+    },
+  });
+  try {
+    const session_port = restored_agent
+      .getContext()
+      .session.get("runtime-restored-model-session");
+    const events = [];
+    const unsubscribe = session_port.subscribe((event) => {
+      if (event.type === "action") events.push(event);
+    });
+    await session_port.stop();
+    unsubscribe();
+
+    assert.equal(resolve_count, 1);
+    assert.deepEqual(events, []);
+  } finally {
+    await restored_agent.dispose();
+  }
+});
+
 test("session.fork persists and publishes history-forking actions on source session", async () => {
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-history-forking-"),
@@ -259,32 +330,32 @@ test("session.fork persists and publishes history-forking actions on source sess
 
     const events = [];
     const unsubscribe = session.subscribe((event) => {
-      if (event.type === "action") {
-        events.push(event);
-      }
+      if (
+        event.variant === "message" && event.type === "action"
+      ) events.push(event.message);
     });
     const forked = await session.fork();
     unsubscribe();
 
     assert.deepEqual(
-      events.map((event) => `${event.title}:${event.state}`),
+      events.map((event) => `${event.title}:${event.status}`),
       ["Forking session records:running", "Session records forked:completed"],
     );
-    assert.equal(new Set(events.map((event) => event.id)).size, 1);
+    assert.equal(new Set(events.map((event) => event.message_id)).size, 1);
     assert.notEqual(forked.id, session.id);
 
-    const source_records = await session.records({ view: "timeline" });
-    const source_fork_actions = source_records.items.filter(
-      (item) => item.role === "action" && item.actionTitle === "Session records forked",
+    const source_messages = await session.messages();
+    const source_fork_actions = source_messages.items.filter(
+      (item) => item.type === "action" && item.title === "Session records forked",
     );
     assert.deepEqual(
-      source_fork_actions.map((event) => event.actionState),
+      source_fork_actions.map((event) => event.status),
       ["completed"],
     );
 
-    const forked_records = await forked.records({ view: "timeline" });
-    const forked_model_actions = forked_records.items.filter(
-      (item) => item.role === "action" && item.actionTitle === "Session model switched",
+    const forked_messages = await forked.messages();
+    const forked_model_actions = forked_messages.items.filter(
+      (item) => item.type === "action" && item.title.startsWith("Session model switched from "),
     );
     assert.equal(forked_model_actions.length, 0);
   } finally {

package/scripts/session-history-inflight.test.mjs

@@ -4,7 +4,7 @@
  * 关键点（中文）
  * - 直接覆盖 JSONL history store 的落盘语义，确保运行中不中断丢失过程。
  * - `messages.jsonl` 仍保持一轮一条 assistant 的正式历史语义。
- * - 运行中快照放在 `inflight.json`，浏览层读取时也应可见。
+ * - 运行中快照放在 `assistant_message.json`，浏览层读取时也应可见。
  */
 
 import test from "node:test";
@@ -93,7 +93,7 @@ test("JsonlSessionHistoryStore exposes inflight assistant during execution and f
     "sessions",
     "session_test",
     "messages",
-    "inflight.json",
+    "assistant_message.json",
   );
   const inflight_exists = await fs
     .access(inflight_path)

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

@@ -141,7 +141,7 @@ test("list_sessions returns persisted title from active session metadata", async
   }
 });
 
-test("list_sessions rebuilds stale metadata after external history changes", async () => {
+test("list_sessions reflects canonical Recorder history changes", async () => {
   const { agent, collection, session } = await create_agent_with_titled_session({
     tmp_prefix: "downcity-agent-session-summary-repair-",
     agent_id: "summary_repair_agent",
@@ -162,31 +162,18 @@ test("list_sessions rebuilds stale metadata after external history changes", asy
   const meta_path = path.join(messages_dir, "meta.json");
 
   try {
-    await fs.appendFile(
-      messages_path,
-      `${JSON.stringify({
-        id: "external_assistant",
-        role: "assistant",
-        metadata: {
-          v: 1,
-          ts: Date.now(),
-          sessionId: session.id,
-          source: "egress",
-          kind: "normal",
-        },
-        parts: [{ type: "text", text: "Externally appended history" }],
-      })}\n`,
-      "utf8",
-    );
+    await session.append_assistant_message({
+      text: "Recorder appended history",
+    });
 
     const page = await collection.list();
     const repaired_meta = JSON.parse(await fs.readFile(meta_path, "utf8"));
     const history_stat = await fs.stat(messages_path);
 
     assert.equal(page.items[0].messageCount, 2);
-    assert.equal(page.items[0].previewText, "Externally appended history");
+    assert.equal(page.items[0].previewText, "Recorder appended history");
     assert.equal(repaired_meta.messageCount, 2);
-    assert.equal(repaired_meta.previewText, "Externally appended history");
+    assert.equal(repaired_meta.previewText, "Recorder appended history");
     assert.equal(repaired_meta.historyBytes, history_stat.size);
   } finally {
     await agent.dispose();

package/scripts/session-prompt-runtime.test.mjs

@@ -76,7 +76,6 @@ async function isSettled(promise) {
 test("SessionPromptRuntime merges queued prompts at the next step boundary", async () => {
   const events = [];
   const persisted = [];
-  const steer_actions = [];
   const merge_lifecycle = [];
   const executionFinished = createDeferred();
   let stepMerge = null;
@@ -92,10 +91,7 @@ test("SessionPromptRuntime merges queued prompts at the next step boundary", asy
       merge_lifecycle.push(`message:${input.query}`);
       return message;
     },
-    emit_steer_action: async (input) => {
-      steer_actions.push(input);
-      merge_lifecycle.push(`action:${input.message.parts[0]?.text}`);
-    },
+    appendErrorMessage: async () => {},
     executeTurn: async (input) => {
       stepMerge = input.onStepMerge;
       await executionFinished.promise;
@@ -126,17 +122,9 @@ test("SessionPromptRuntime merges queued prompts at the next step boundary", asy
     persisted.map((message) => message.parts[0]?.text),
     ["first", "second"],
   );
-  assert.deepEqual(
-    steer_actions.map((action) => ({
-      turn_id: action.turn_id,
-      text: action.message.parts[0]?.text,
-    })),
-    [{ turn_id: firstTurn.id, text: "second" }],
-  );
   assert.deepEqual(merge_lifecycle, [
     "message:first",
     "message:second",
-    "action:second",
   ]);
 
   executionFinished.resolve();
@@ -147,7 +135,7 @@ test("SessionPromptRuntime merges queued prompts at the next step boundary", asy
   assert.equal(secondTurn.result, result);
   assert.deepEqual(
     events.map((event) => event.type),
-    ["turn-start", "turn-finish"],
+    ["start", "finish"],
   );
 });
 
@@ -163,7 +151,7 @@ test("SessionPromptRuntime moves unmerged prompts into the next turn", async ()
     createAndPersistUserMessage: async (input) => {
       return createUserMessage(input.query, events.length + 1);
     },
-    emit_steer_action: async () => {},
+    appendErrorMessage: async () => {},
     executeTurn: async (input) => {
       const deferred = createDeferred();
       finishQueue.push({
@@ -204,7 +192,7 @@ test("SessionPromptRuntime moves unmerged prompts into the next turn", async ()
   assert.equal(secondResult.text, "done:second");
   assert.deepEqual(
     events.map((event) => event.type),
-    ["turn-start", "turn-finish", "turn-start", "turn-finish"],
+    ["start", "finish", "start", "finish"],
   );
 });
 
@@ -221,7 +209,7 @@ test("SessionPromptRuntime stops current turn and cancels unmerged queued prompt
     createAndPersistUserMessage: async (input) => {
       return createUserMessage(input.query, events.length + 1);
     },
-    emit_steer_action: async () => {},
+    appendErrorMessage: async () => {},
     executeTurn: async (input) => {
       await new Promise((resolve) => {
         input.abortSignal.addEventListener("abort", resolve, { once: true });
@@ -265,7 +253,7 @@ test("SessionPromptRuntime stops current turn and cancels unmerged queued prompt
   );
   assert.deepEqual(
     events.map((event) => event.type),
-    ["turn-start", "turn-start", "turn-finish", "turn-finish"],
+    ["start", "start", "finish", "finish"],
   );
 });
 
@@ -278,7 +266,7 @@ test("SessionPromptRuntime does not synthesize assistant text when stopped befor
     createAndPersistUserMessage: async (input) => {
       return createUserMessage(input.query, 1);
     },
-    emit_steer_action: async () => {},
+    appendErrorMessage: async () => {},
     executeTurn: async (input) => {
       await new Promise((resolve) => {
         input.abortSignal.addEventListener("abort", resolve, { once: true });

package/scripts/session-recorder.test.mjs

@@ -0,0 +1,199 @@
+/**
+ * @file 验证 SessionRecorder 的 Message 快照、Assistant 草稿与实时事件一致性。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+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 { MockLanguageModelV3 } from "ai/test";
+
+async function create_recorder(session_id = "session-recorder-test") {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-recorder-"));
+  const file_path = path.join(root_path, "messages.jsonl");
+  const assistant_message_file_path = path.join(root_path, "assistant_message.json");
+  const events = [];
+  const recorder = new SessionRecorder({
+    session_id,
+    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    publish: (mutation) => events.push(mutation),
+  });
+  await recorder.initialize();
+  return { recorder, events, file_path, assistant_message_file_path };
+}
+
+async function read_jsonl(file_path) {
+  const raw = await fs.readFile(file_path, "utf8");
+  return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+
+test("delta 只更新 Assistant 草稿，完成后才写入 messages.jsonl", async () => {
+  const { recorder, events, file_path, assistant_message_file_path } = await create_recorder();
+  await recorder.append_user_message({
+    turn_id: "turn-1",
+    input_type: "prompt",
+    parts: [{ part_id: "user-text-1", type: "text", text: "你好", state: "done" }],
+  });
+  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: "你" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "好" });
+
+  const history_during_stream = await read_jsonl(file_path);
+  const draft = JSON.parse(await fs.readFile(assistant_message_file_path, "utf8"));
+  assert.equal(history_during_stream.length, 1);
+  assert.equal(history_during_stream[0].type, "user");
+  assert.equal(draft.type, "assistant");
+  assert.equal(draft.parts[0].text, "你好");
+  assert.equal(draft.parts[0].sequence, 1);
+
+  await writer.apply_chunk({ type: "text-end", id: "text-1" });
+  await writer.complete();
+
+  const history = await read_jsonl(file_path);
+  assert.deepEqual(history.map((message) => message.type), ["user", "assistant"]);
+  assert.equal(history[1].parts[0].text, "你好");
+  assert.equal(await fs.stat(assistant_message_file_path).then(() => true).catch(() => false), false);
+  assert.deepEqual(events.map((event) => `${event.variant}:${event.type}`), [
+    "message:user",
+    "message:assistant",
+    "part:text",
+    "delta:text",
+    "delta:text",
+    "part:text",
+    "message:assistant",
+  ]);
+  assert.equal(history.some((value) => "variant" in value), false);
+});
+
+test("Tool Part 在文本中间创建后，输入、审批和输出都保持原顺序", async () => {
+  const { recorder, events, file_path } = await create_recorder("tool-order-test");
+  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-available",
+    toolCallId: "call-1",
+    toolName: "search",
+    input: { query: "downcity" },
+  });
+  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",
+  });
+  assert.equal(recorder.get_message(writer.message_id).parts[1].state, "approval-required");
+  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" });
+  await writer.apply_chunk({ type: "tool-output-available", toolCallId: "call-1", output: { count: 1 } });
+  await writer.complete();
+
+  const assistant = (await read_jsonl(file_path))[0];
+  assert.deepEqual(assistant.parts.map((part) => part.type), ["text", "tool", "text"]);
+  assert.deepEqual(assistant.parts.map((part) => part.sequence), [1, 2, 3]);
+  assert.equal(assistant.parts[1].state, "completed");
+  assert.deepEqual(assistant.parts[1].output, { count: 1 });
+  assert.deepEqual(
+    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"]],
+  );
+});
+
+test("重启时将 Assistant 草稿收口为 stopped，并将运行中 Action 标记失败", async () => {
+  const { recorder, file_path, assistant_message_file_path } = await create_recorder("recovery-test");
+  await recorder.append_user_message({
+    turn_id: "turn-1",
+    input_type: "prompt",
+    parts: [{ part_id: "u1", type: "text", text: "one", state: "done" }],
+  });
+  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: "partial" });
+  await recorder.open_action_message({ message_id: "running-action", action_type: "fork", title: "Forking" });
+
+  const recovered_events = [];
+  const recovered = new SessionRecorder({
+    session_id: "recovery-test",
+    store: new JsonlSessionMessageStore({ session_id: "recovery-test", file_path }),
+    publish: (mutation) => recovered_events.push(mutation),
+  });
+  await recovered.initialize();
+
+  const page = await recovered.list_messages({ limit: 10 });
+  assert.deepEqual(page.items.map((message) => message.type), ["user", "assistant", "action"]);
+  assert.equal(page.items[1].status, "stopped");
+  assert.equal(page.items[1].parts[0].text, "partial");
+  assert.equal(page.items[2].status, "failed");
+  assert.deepEqual(recovered_events.map((event) => `${event.variant}:${event.type}`), [
+    "message:assistant",
+    "message:action",
+  ]);
+  assert.equal(await fs.stat(assistant_message_file_path).then(() => true).catch(() => false), false);
+});
+
+test("Action revision 追加完整快照，读取时只返回最新版本", async () => {
+  const { recorder, file_path } = await create_recorder("action-revision-test");
+  const action = await recorder.open_action_message({
+    message_id: "action-1",
+    action_type: "compact",
+    title: "Compacting",
+  });
+  await action.complete({ title: "Compacted" });
+  const history = await read_jsonl(file_path);
+  assert.equal(history.length, 2);
+  assert.deepEqual(history.map((message) => message.revision), [1, 2]);
+  const page = await recorder.list_messages();
+  assert.equal(page.items.length, 1);
+  assert.equal(page.items[0].title, "Compacted");
+});
+
+test("compact 追加 internal summary 且不重写已有 Message 快照", async () => {
+  const { recorder, file_path } = await create_recorder("compact-test");
+  for (let index = 1; index <= 6; index += 1) {
+    await recorder.append_user_message({
+      turn_id: `turn-${String(index)}`,
+      input_type: "prompt",
+      parts: [{ part_id: `user-${String(index)}`, type: "text", text: `message ${String(index)}`, state: "done" }],
+    });
+  }
+  const before = await fs.readFile(file_path, "utf8");
+  const history_store = new SessionRecorderHistoryStore({ session_id: "compact-test", recorder });
+  const model = new MockLanguageModelV3({
+    modelId: "compact-model",
+    doGenerate: async () => ({
+      content: [{ type: "text", text: "Compact 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 result = await history_store.compact({
+    model,
+    system: [],
+    keepLastMessages: 2,
+    maxInputTokensApprox: 1,
+    archiveOnCompact: false,
+    compactRatio: 0.5,
+  });
+  assert.equal(result.compacted, true);
+  assert.equal((await fs.readFile(file_path, "utf8")).startsWith(before), true);
+  const all = await recorder.list_messages({ limit: 100, include_internal: true });
+  const summary = all.items.find((message) => message.type === "assistant" && message.kind === "summary");
+  assert.equal(summary.visibility, "internal");
+  assert.equal(summary.parts[0].sequence, 1);
+  assert.equal((await history_store.list_records()).length, 4);
+});

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

@@ -110,11 +110,13 @@ test("Session keeps title empty when no model is available", async () => {
       text: "Use shell tools to inspect the current workspace",
     });
 
-    const title_event = events.find((event) => event.type === "session-title");
-    assert.equal(title_event, undefined);
-
-    const records = await session.records();
-    assert.equal(records.session.title, undefined);
+    assert.equal(
+      events.some(
+        (event) => event.variant === "message" && event.type === "user",
+      ),
+      true,
+    );
+    assert.equal((await session.get_info()).title, undefined);
   } finally {
     unsubscribe();
     await agent.dispose();
@@ -137,8 +139,7 @@ test("Session logs title generation failure without blocking the session", async
       text: "Diagnose why session title generation is flaky",
     });
 
-    const records = await session.records();
-    assert.equal(records.session.title, undefined);
+    assert.equal((await session.get_info()).title, undefined);
 
     await agent.getLogger().saveAllLogs();
     const log_lines = await read_log_lines(agent_path);
@@ -185,8 +186,7 @@ test("Session retries title generation after model becomes available", async ()
       text: "Investigate flaky session title generation in the SDK",
     });
 
-    const history_before_model = await session.records();
-    assert.equal(history_before_model.session.title, undefined);
+    assert.equal((await session.get_info()).title, undefined);
 
     await session.set({
       model: create_mock_title_model("排查 session 标题"),
@@ -195,15 +195,7 @@ test("Session retries title generation after model becomes available", async ()
       text: "Need another prompt to trigger the retry path",
     });
 
-    const title_event = events.find((event) => event.type === "session-title");
-    assert.deepEqual(title_event, {
-      type: "session-title",
-      sessionId: session.id,
-      title: "排查 session 标题",
-    });
-
-    const records = await session.records();
-    assert.equal(records.session.title, "排查 session 标题");
+    assert.equal((await session.get_info()).title, "排查 session 标题");
   } finally {
     unsubscribe();
     await agent.dispose();