@downcity/agent 1.1.217 → 1.1.222

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-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();
@@ -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({
@@ -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 });
@@ -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,245 @@
+/**
+ * @file 验证 SessionRecorder 单一 Mutation 日志与实时/历史一致性。
+ */
+
+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 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 };
+}
+
+test("每个 assistant delta 都先持久化为独立 Mutation 再发布", async () => {
+  const { recorder, events, 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: "好" });
+  await writer.apply_chunk({ type: "text-end", id: "text-1" });
+  await writer.complete();
+
+  const changes = await recorder.list_message_changes({
+    after_commit_sequence: 0,
+  });
+  const persisted_lines = (await fs.readFile(file_path, "utf8"))
+    .trim()
+    .split("\n");
+  assert.equal(persisted_lines.length, changes.items.length);
+  assert.deepEqual(
+    changes.items.map((item) => item.commit_sequence),
+    events.map((item) => item.commit_sequence),
+  );
+  assert.deepEqual(
+    changes.items.map((item) => `${item.variant}:${item.type}`),
+    [
+      "message:user",
+      "message:assistant",
+      "part:text",
+      "delta:text",
+      "delta:text",
+      "part:text",
+      "message:assistant",
+    ],
+  );
+  assert.deepEqual(
+    changes.items
+      .filter((item) => item.variant === "delta")
+      .map((item) => item.delta),
+    ["你", "好"],
+  );
+
+  const page = await recorder.list_messages();
+  assert.deepEqual(page.items.map((item) => item.type), ["user", "assistant"]);
+  const assistant = page.items[1];
+  assert.equal(assistant.status, "completed");
+  assert.equal(assistant.parts[0].text, "你好");
+});
+
+test("tool 与 action 在原 Message 和 part 上更新", async () => {
+  const { recorder } = await create_recorder("tool-action-test");
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-1",
+    segment_index: 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" },
+  });
+  await writer.apply_chunk({
+    type: "tool-output-available",
+    toolCallId: "call-1",
+    output: { count: 1 },
+  });
+  await writer.complete();
+
+  const action = await recorder.open_action_message({
+    message_id: "action-1",
+    action_type: "compact",
+    title: "Compacting",
+  });
+  const running = recorder.get_message("action-1");
+  await action.complete({ title: "Compacted" });
+  const completed = recorder.get_message("action-1");
+
+  const assistant = (await recorder.list_messages()).items[0];
+  assert.equal(assistant.parts.length, 1);
+  assert.equal(assistant.parts[0].state, "completed");
+  assert.deepEqual(assistant.parts[0].output, { count: 1 });
+  assert.equal(running.sequence, completed.sequence);
+  assert.equal(completed.revision, running.revision + 1);
+  assert.equal(completed.status, "completed");
+});
+
+test("snapshot、changes 分页和重启恢复保持单调顺序", async () => {
+  const { recorder, 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" }],
+  });
+  await recorder.open_assistant_message({
+    turn_id: "turn-1",
+    segment_index: 1,
+  });
+  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 first_page = await recovered.list_messages({ limit: 2 });
+  const second_page = await recovered.list_messages({
+    limit: 2,
+    cursor: first_page.next_cursor,
+  });
+  assert.equal(first_page.items.length, 2);
+  assert.equal(second_page.items.length, 1);
+  assert.ok(first_page.items[1].sequence < second_page.items[0].sequence);
+
+  const messages = [...first_page.items, ...second_page.items];
+  assert.equal(messages[1].status, "stopped");
+  assert.equal(messages[2].status, "failed");
+  assert.deepEqual(
+    recovered_events.map((item) => `${item.variant}:${item.type}`),
+    ["message:assistant", "message:action"],
+  );
+
+  const first_changes = await recovered.list_message_changes({
+    after_commit_sequence: 0,
+    limit: 2,
+  });
+  const next_changes = await recovered.list_message_changes({
+    after_commit_sequence: first_changes.next_commit_sequence,
+    limit: 100,
+  });
+  assert.equal(first_changes.has_more, true);
+  assert.ok(
+    first_changes.items.at(-1).commit_sequence <
+      next_changes.items[0].commit_sequence,
+  );
+});
+
+test("compact 追加 internal summary 且不重写 Mutation 日志", 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);
+
+  const after = await fs.readFile(file_path, "utf8");
+  assert.equal(after.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.summary_through_message_id, all.items[2].message_id);
+  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();

package/src/agent/local/services/AgentSessions.ts

@@ -358,9 +358,7 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
   ): Promise<void> {
     if (this.configured_session_ids.has(session.id)) return;
     const persisted_model_id = String(session.config.modelId || "").trim();
-    if (persisted_model_id && this.resolve_model) {
-      await session.set({ modelId: persisted_model_id });
-    } else if (this.default_model) {
+    if (!persisted_model_id && this.default_model) {
       await session.set({
         model: this.default_model,
         ...(this.default_model_id ? { modelId: this.default_model_id } : {}),