@downcity/agent 1.1.438 → 1.1.445

package/scripts/group-session-archive.test.mjs

@@ -0,0 +1,193 @@
+/**
+ * @file 验证 GroupSession 的归档：目录搬迁、活动/归档两个区、以及不可逆的清理。
+ *
+ * 归档是**目录搬迁**（`sessions/` → `archived-sessions/`），不是打标记。因此这里的断言
+ * 都围绕「位置」：活动列表不含它、归档列表含它、清理只动归档区。
+ *
+ * 用真实临时目录而不是内存 mock：搬迁本身是文件系统操作，mock 掉它就等于不测它。
+ */
+
+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 { LocalGroupSessionStore } from "../bin/group/storage/LocalGroupSessionStore.js";
+
+/** 创建测试用文件系统协议；只需 Store 用到的那几个能力。 */
+function create_files() {
+  return {
+    root_path: "",
+    resolve_path: (...segments) => path.resolve(...segments),
+    path_exists: async (target) => await fs.access(target).then(() => true, () => false),
+    read_file: async (target) => await fs.readFile(target),
+    file_size: async (target) => (await fs.stat(target)).size,
+    ensure_directory: async (directory_path) => await fs.mkdir(directory_path, { recursive: true }),
+    remove_path: async (target) => await fs.rm(target, { recursive: true, force: true }),
+    move_path: async (source, target) => await fs.rename(source, target),
+    read_directory: async (directory_path) => {
+      const entries = await fs.readdir(directory_path, { withFileTypes: true });
+      return entries.map((entry) => ({
+        name: entry.name,
+        is_directory: entry.isDirectory(),
+        is_file: entry.isFile(),
+      }));
+    },
+    write_file_atomically: async (file_path, content) => await fs.writeFile(file_path, content),
+    append_file: async (file_path, content) => await fs.appendFile(file_path, content),
+    with_file_lock: async (_lock_path, action) => await action(),
+    run_file_action: async () => { throw new Error("not used"); },
+    run_search_action: async () => { throw new Error("not used"); },
+  };
+}
+
+/** 创建一个 Store 与它的临时根目录。 */
+async function create_store() {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-session-"));
+  const store = new LocalGroupSessionStore({
+    files: create_files(),
+    storage_root_path: root_path,
+    group_id: "group-1",
+  });
+  return { store, root_path };
+}
+
+/** 建一个活动区的 GroupSession 并写入一条消息，返回它的 id。 */
+async function create_session(store, session_id) {
+  const session = store.session(session_id);
+  await session.initialize();
+  return session_id;
+}
+
+/** 两个区在磁盘上的实际位置。 */
+function area_paths(root_path, session_id) {
+  return {
+    active: path.join(root_path, "sessions", encodeURIComponent(session_id)),
+    archived: path.join(root_path, "archived-sessions", encodeURIComponent(session_id)),
+  };
+}
+
+test("归档把群聊从活动区搬到归档区", async () => {
+  const { store, root_path } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+
+  const result = await store.archive_session(session_id);
+  assert.equal(result.session_id, session_id);
+  assert.ok(result.archived_at > 0, "归档结果缺少时间戳");
+
+  // 位置变了：这正是归档的全部内容。
+  const paths = area_paths(root_path, session_id);
+  assert.equal(await fs.access(paths.active).then(() => true, () => false), false, "活动区仍留着已归档的目录");
+  assert.equal(await fs.access(paths.archived).then(() => true, () => false), true, "归档区没有收到目录");
+});
+
+test("归档后活动列表不含它、归档列表含它", async () => {
+  const { store } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+
+  assert.deepEqual((await store.list_session_metadata()).map((item) => item.session_id), [session_id]);
+  assert.deepEqual(await store.list_archived_session_metadata(), []);
+
+  await store.archive_session(session_id);
+
+  assert.deepEqual(await store.list_session_metadata(), [], "活动列表仍含已归档的群聊");
+  assert.deepEqual((await store.list_archived_session_metadata()).map((item) => item.session_id), [session_id]);
+});
+
+test("归档不改 metadata 内容，只改位置", async () => {
+  const { store } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+  const before = await store.session(session_id).read_metadata();
+
+  await store.archive_session(session_id);
+
+  const after = await store.session(session_id, "archived").read_metadata();
+  assert.deepEqual(after, before, "归档改动了 metadata：归档只该是位置变化");
+});
+
+test("归档不存在的群聊报错，不静默成功", async () => {
+  const { store } = await create_store();
+  await assert.rejects(() => store.archive_session("missing"), /not found/);
+});
+
+test("重复归档报错，不覆盖已有归档", async () => {
+  const { store } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+  await store.archive_session(session_id);
+
+  // 覆盖会丢掉一份真实数据，因此必须是错误而不是静默替换。
+  await assert.rejects(() => store.archive_session(session_id), /already exists/);
+});
+
+test("has_session 只看活动区", async () => {
+  const { store } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+  assert.equal(await store.has_session(session_id), true);
+
+  await store.archive_session(session_id);
+  // 归档之后它不再是「活动 Session」——否则 get() 会去活动区找一个已经搬走的目录。
+  assert.equal(await store.has_session(session_id), false);
+});
+
+test("删除活动群聊不影响归档区的同名条目", async () => {
+  const { store } = await create_store();
+  const session_id = await create_session(store, "group-session-1");
+  await store.archive_session(session_id);
+
+  // 活动区已经空了，删它返回 false；归档区的那份必须还在。
+  assert.equal(await store.remove_session(session_id), false);
+  assert.deepEqual((await store.list_archived_session_metadata()).map((item) => item.session_id), [session_id]);
+
+  // 删归档区的那份才真的删掉它。
+  assert.equal(await store.remove_archived_session(session_id), true);
+  assert.deepEqual(await store.list_archived_session_metadata(), []);
+});
+
+test("clean_archive 清空归档区且不动活动区", async () => {
+  const { store } = await create_store();
+  const archived_ids = [await create_session(store, "archived-1"), await create_session(store, "archived-2")];
+  for (const session_id of archived_ids) await store.archive_session(session_id);
+  const active_id = await create_session(store, "active-1");
+
+  const result = await store.clean_archive();
+  assert.deepEqual([...result.removed_session_ids].sort(), [...archived_ids].sort(), "清理结果没有列出被删的 id");
+  assert.deepEqual(await store.list_archived_session_metadata(), []);
+  // 活动区不受影响：清理归档不该顺手删掉正在用的群聊。
+  assert.deepEqual((await store.list_session_metadata()).map((item) => item.session_id), [active_id]);
+});
+
+test("归档区不存在时清理返回空结果", async () => {
+  const { store } = await create_store();
+  await create_session(store, "active-1");
+  // 没有任何归档时不该报错，也不该顺手建出归档目录。
+  assert.deepEqual(await store.clean_archive(), { removed_session_ids: [] });
+});
+
+/**
+ * `purge` 服务于「Group 被删除」。
+ *
+ * 没有它时删掉一个 Group 会在磁盘上留下无人认领的孤儿目录：
+ * 没有入口能再访问它们，只是磁盘泄漏。归档能力加上后这一点更明显——
+ * 归档区会永久积累这类数据。
+ */
+test("purge 删掉活动区与归档区，且不留残渣", async () => {
+  const { store, root_path } = await create_store();
+  const archived_id = await create_session(store, "archived-1");
+  await store.archive_session(archived_id);
+  await create_session(store, "active-1");
+
+  await store.purge();
+
+  assert.deepEqual(await store.list_session_metadata(), []);
+  assert.deepEqual(await store.list_archived_session_metadata(), []);
+  // 两个区目录都不在了：只删其中一个都会留下残渣。
+  assert.equal(await fs.access(path.join(root_path, "sessions")).then(() => true, () => false), false);
+  assert.equal(await fs.access(path.join(root_path, "archived-sessions")).then(() => true, () => false), false);
+});
+
+test("purge 在没有任何数据时也不报错", async () => {
+  const { store } = await create_store();
+  // 幂等：删一个从没聊过的 Group 不该失败。
+  await store.purge();
+  assert.deepEqual(await store.list_session_metadata(), []);
+});

package/scripts/{core-engine-model-stream.test.mjs → model-step-runner.test.mjs}

@@ -4,15 +4,16 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
+import { z } from "zod";
 
-import { run_model_step } from "../bin/executor/model/ModelStepRunner.js";
-import { generate_model } from "../bin/executor/model/ModelGenerate.js";
-import { create_session_model_request_warning } from "../bin/session/runtime/SessionModelRequestWarning.js";
+import { run_model_step } from "../bin/model/ModelStepRunner.js";
+import { generate_model } from "../bin/model/ModelGenerate.js";
+import { create_session_model_request_warning } from "../bin/session/messages/SessionModelRequestWarning.js";
 import { is_session_mutation } from "@downcity/type";
 import {
   MAX_MODEL_REQUEST_ATTEMPTS,
   MAX_MODEL_REQUEST_RETRIES,
-} from "../bin/executor/model/ModelRequestRunner.js";
+} from "../bin/model/ModelRequestRunner.js";
 
 test("Agent 模型请求最多自动重试五次", () => {
   assert.equal(MAX_MODEL_REQUEST_RETRIES, 5);
@@ -216,6 +217,98 @@ test("模型生成无效工具输入时向下一 Step 返回 failed tool_result"
   assert.equal(result.assistant_parts[0].state, "failed");
 });
 
+test("Tool 输入不符合自己的 schema 时拒绝执行并返回结构化失败", async () => {
+  let executed = false;
+  const model = {
+    id: "schema-invalid-input-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "schema-invalid-input-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "grep" });
+          controller.enqueue({
+            type: "tool_call_finish",
+            content_id: "tool_1",
+            // glob 契约是字符串数组；传字符串必须在派发前被拦住。
+            input: { query: "value", glob: "*.ts" },
+          });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+  const grep_input_schema = z.object({
+    query: z.string().min(1),
+    glob: z.array(z.string().min(1)).optional(),
+  });
+
+  const result = await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "search" }] }],
+    tools: {
+      grep: {
+        input_schema: grep_input_schema,
+        execute: async () => {
+          executed = true;
+          return { success: true };
+        },
+      },
+    },
+    abort_signal: new AbortController().signal,
+  });
+
+  assert.equal(executed, false);
+  assert.equal(result.step_result.tool_results[0].success, false);
+  assert.match(result.step_result.tool_results[0].output.error, /Invalid input for tool "grep"/);
+  assert.match(result.step_result.tool_results[0].output.error, /glob/);
+  assert.equal(result.assistant_parts[0].state, "failed");
+});
+
+test("Tool 输入通过 schema 校验后使用规范化结果执行", async () => {
+  let received_input;
+  const model = {
+    id: "schema-normalized-input-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "schema-normalized-input-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "find" });
+          controller.enqueue({ type: "tool_call_finish", content_id: "tool_1", input: { pattern: "*.ts" } });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+  const find_input_schema = z.object({
+    pattern: z.string().min(1),
+    path: z.string().min(1).default("."),
+  });
+
+  await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "find" }] }],
+    tools: {
+      find: {
+        input_schema: find_input_schema,
+        execute: async (input) => {
+          received_input = input;
+          return { success: true };
+        },
+      },
+    },
+    abort_signal: new AbortController().signal,
+  });
+
+  // zod 默认值在派发前生效，工具实现拿到的是规范化输入。
+  assert.deepEqual(received_input, { pattern: "*.ts", path: "." });
+});
+
 test("Tool 返回 success false 时不会被标记为成功", async () => {
   const model = {
     id: "structured-tool-failure-model",

package/scripts/rewrite-build-aliases.mjs

@@ -12,7 +12,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const package_root = path.resolve(__dirname, "..");
 const bin_root = path.join(package_root, "bin");
-const alias_literal_pattern = /(["'])(@\/|@executor\/)([^"']+)\1/g;
+const alias_literal_pattern = /(["'])@\/([^"']+)\1/g;
 
 async function collect_files(dir_path) {
   const entries = await fs.readdir(dir_path, { withFileTypes: true });
@@ -35,10 +35,9 @@ function to_posix_path(value) {
 let rewritten_count = 0;
 for (const file_path of await collect_files(bin_root)) {
   const content = await fs.readFile(file_path, "utf-8");
-  const rewritten = content.replace(alias_literal_pattern, (literal, quote, alias_prefix, alias_target) => {
+  const rewritten = content.replace(alias_literal_pattern, (literal, quote, alias_target) => {
     rewritten_count += 1;
-    const target_root = alias_prefix === "@executor/" ? path.join(bin_root, "executor") : bin_root;
-    const target_path = path.join(target_root, alias_target);
+    const target_path = path.join(bin_root, alias_target);
     const relative_path = to_posix_path(path.relative(path.dirname(file_path), target_path));
     const specifier = relative_path.startsWith(".") ? relative_path : `./${relative_path}`;
     return `${quote}${specifier}${quote}`;

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

@@ -0,0 +1,172 @@
+/**
+ * @file 验证 Session Action 在存在流式 Agent Message 时内联进同一条 Message，否则回退独立消息。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionMessages } from "../bin/session/messages/SessionMessages.js";
+
+/** 创建支持聚合创建和 expected revision 更新的最小内存 SessionStorage。 */
+function create_fixture(initial_messages = []) {
+  const stored_messages = structuredClone(initial_messages);
+  const publications = [];
+  const store = {
+    initialize: async () => {},
+    list_messages: async () => structuredClone(stored_messages),
+    list_recoverable_agent_messages: async () => structuredClone(
+      stored_messages.filter((message) =>
+        message.role === "agent" && message.state === "streaming"
+      ),
+    ),
+    read_message: async (message_id) => structuredClone(
+      stored_messages.find((message) => message.message_id === message_id) ?? null,
+    ),
+    read_latest_agent_message: async (turn_id) => structuredClone(
+      stored_messages
+        .filter((message) =>
+          message.role === "agent" && (!turn_id || message.turn_id === turn_id)
+        )
+        .sort((left, right) => right.sequence - left.sequence)[0] ?? null,
+    ),
+    message_stats: async () => ({
+      message_count: stored_messages.length,
+      storage_bytes: 0,
+      latest_message: structuredClone(stored_messages.at(-1) ?? null),
+    }),
+    create_message: async (build_message) => {
+      const message = build_message({
+        message_sequence: stored_messages.reduce(
+          (maximum, candidate) => Math.max(maximum, candidate.sequence),
+          0,
+        ) + 1,
+      });
+      stored_messages.push(structuredClone(message));
+      return structuredClone(message);
+    },
+    update_message: async ({ message, expected_revision }) => {
+      const index = stored_messages.findIndex(
+        (candidate) => candidate.message_id === message.message_id,
+      );
+      const current = stored_messages[index];
+      if (!current || current.revision !== expected_revision) {
+        throw new Error("revision conflict");
+      }
+      stored_messages[index] = structuredClone(message);
+    },
+  };
+  const messages = new SessionMessages({
+    session_id: "session-1",
+    store,
+    publish: (mutation) => publications.push(mutation),
+  });
+  return {
+    messages,
+    publications,
+    read_visible: () => structuredClone(stored_messages),
+    read_draft: () => structuredClone(
+      stored_messages.find(
+        (message) => message.role === "agent" && message.state === "streaming",
+      ) ?? null,
+    ),
+  };
+}
+
+/** 构造一条已完成 Turn 的配置变更 Action 事件。 */
+function create_config_action(overrides = {}) {
+  return {
+    action_id: "config-1",
+    action_type: "command",
+    turn_id: "turn-1",
+    title: "Session configuration updated",
+    description: "model: demo-model",
+    status: "completed",
+    ...overrides,
+  };
+}
+
+test("存在流式 Agent Message 时 Action 内联为同一条 Message 的 Part", async () => {
+  const fixture = create_fixture();
+  await fixture.messages.initialize();
+  const writer = await fixture.messages.open_agent_message({ turn_id: "turn-1" });
+  await writer.append_result_parts([{ type: "text", text: "处理中" }]);
+  const message_id = writer.message_id;
+
+  await fixture.messages.persist_action(create_config_action());
+
+  const visible = fixture.read_visible();
+  assert.equal(visible.length, 1, "不应新增独立 Agent Message");
+  assert.equal(visible[0].message_id, message_id);
+  assert.deepEqual(visible[0].parts.map((part) => part.type), ["text", "action"]);
+  assert.deepEqual(visible[0].parts.map((part) => part.sequence), [1, 2]);
+  const action_part = visible[0].parts[1];
+  assert.equal(action_part.action_id, "config-1");
+  assert.equal(action_part.state, "completed");
+  assert.equal(action_part.title, "Session configuration updated");
+});
+
+test("同一 Action ID 重复落盘原地更新，不产生重复 Part", async () => {
+  const fixture = create_fixture();
+  await fixture.messages.initialize();
+  const writer = await fixture.messages.open_agent_message({ turn_id: "turn-1" });
+  await writer.append_result_parts([{ type: "text", text: "处理中" }]);
+
+  await fixture.messages.persist_action(create_config_action({
+    status: "running",
+    description: undefined,
+  }));
+  await fixture.messages.persist_action(create_config_action({
+    description: "security.approval_mode: ask",
+  }));
+
+  const draft = fixture.read_draft();
+  assert.deepEqual(draft.parts.map((part) => part.type), ["text", "action"]);
+  assert.equal(draft.parts[1].state, "completed");
+  assert.equal(draft.parts[1].description, "security.approval_mode: ask");
+});
+
+test("没有流式目标时 Action 回退为独立 Agent Message", async () => {
+  const fixture = create_fixture();
+  await fixture.messages.initialize();
+
+  await fixture.messages.persist_action(create_config_action({
+    action_id: "config-standalone",
+    turn_id: undefined,
+  }));
+
+  const visible = fixture.read_visible();
+  assert.equal(visible.length, 1);
+  assert.equal(visible[0].message_id, "config-standalone");
+  assert.equal(visible[0].state, "done");
+  assert.deepEqual(visible[0].parts.map((part) => part.type), ["action"]);
+});
+
+test("Turn 存在但尚未产生 Agent Message 时 Action 仍可观测", async () => {
+  const fixture = create_fixture();
+  await fixture.messages.initialize();
+
+  await fixture.messages.persist_action(create_config_action({ action_id: "config-early" }));
+
+  const visible = fixture.read_visible();
+  assert.equal(visible.length, 1);
+  assert.equal(visible[0].message_id, "config-early");
+  assert.equal(visible[0].turn_id, "turn-1");
+  assert.equal(visible[0].state, "done");
+});
+
+test("publish_mutation=false 时内联 Action 不发布 Message Mutation", async () => {
+  const fixture = create_fixture();
+  await fixture.messages.initialize();
+  const writer = await fixture.messages.open_agent_message({ turn_id: "turn-1" });
+  await writer.append_result_parts([{ type: "text", text: "处理中" }]);
+  const baseline = fixture.publications.length;
+
+  await fixture.messages.persist_action(create_config_action(), {
+    publish_mutation: false,
+  });
+
+  assert.equal(fixture.publications.length, baseline);
+  assert.deepEqual(
+    fixture.read_visible()[0].parts.map((part) => part.type),
+    ["text", "action"],
+  );
+});

package/scripts/session-agent-message-part-order.test.mjs

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SessionAgentMessageWriter } from "../bin/session/SessionMessages.js";
+import { SessionAgentMessageWriter } from "../bin/session/messages/SessionMessages.js";
 
 /** 使用最小内存 Recorder 验证 Writer 的 Part 顺序能力。 */
 test("Error Part 在后续 Turn 结果 Data Part 之前写入", async () => {
@@ -21,27 +21,33 @@ test("Error Part 在后续 Turn 结果 Data Part 之前写入", async () => {
     state: "streaming",
     parts: [],
   };
-  const recorder = {
-    get_message: () => message,
-    project_agent_part: (_message_id, part) => {
+  const cache = {
+    get: () => message,
+  };
+  const state = {
+    project_part: (_message_id, part) => {
       const index = message.parts.findIndex((candidate) => candidate.part_id === part.part_id);
       const parts = [...message.parts];
       if (index < 0) parts.push(part);
       else parts[index] = part;
       message = { ...message, parts };
     },
-    commit_agent_parts: async (_message_id, new_parts) => {
+    commit_parts: async (_message_id, new_parts) => {
       message = {
         ...message,
         revision: message.revision + 1,
         parts: [...message.parts, ...new_parts],
       };
     },
-    complete_agent_message: async (_message_id, status) => {
+    complete: async (_message_id, status) => {
       message = { ...message, state: "done", revision: message.revision + 1 };
     },
   };
-  const writer = new SessionAgentMessageWriter(recorder, message.message_id);
+  const writer = new SessionAgentMessageWriter({
+    message_id: message.message_id,
+    state,
+    cache,
+  });
 
   await writer.append_result_parts([{ type: "text", text: "处理中" }]);
   await writer.append_error({