@downcity/agent 1.1.408 → 1.1.437

package/scripts/session-queue.test.mjs

@@ -1,19 +1,19 @@
 /**
- * @file 验证 SessionQueue 只保存具体 Command 对象并维护确定的 FIFO 顺序。
+ * @file 验证 SessionQueue 只保存最小 Command 数据并维护确定的 FIFO 顺序。
  */
 
 import assert from "node:assert/strict";
 import test from "node:test";
 import { SessionQueue } from "../bin/session/SessionQueue.js";
-import { SessionCommand } from "../bin/session/SessionCommand.js";
 
 function create_command(name, executed, cancel) {
-  return new SessionCommand({
+  return {
+    kind: cancel ? "prompt" : "maintenance",
     execute: async () => {
       executed.push(name);
     },
     ...(cancel ? { cancel } : {}),
-  });
+  };
 }
 
 test("SessionQueue 按 FIFO 返回具体 Command 对象", async () => {
@@ -79,21 +79,22 @@ test("SessionQueue 可以把未处理 Command 恢复到队列头部", async () =
   assert.deepEqual(executed, ["head", "middle", "tail"]);
 });
 
-test("SessionCommand 成功执行后返回可选的持久化完成信息", async () => {
+test("SessionQueue 保留 Command 的类别与完成信息", async () => {
+  const queue = new SessionQueue();
   const completion = {
     type: "action",
     id: "config-completed",
     title: "Configuration updated",
     description: "The next step uses the new configuration.",
   };
-  const command = new SessionCommand({
+  const command = {
+    kind: "maintenance",
     execute: async () => {},
     completion,
-  });
-  const silent_command = new SessionCommand({
-    execute: async () => {},
-  });
+  };
+  queue.enqueue_command(command);
 
-  assert.deepEqual(await command.execute(), completion);
-  assert.equal(await silent_command.execute(), undefined);
+  assert.equal(queue.take_next(), command);
+  assert.equal(command.kind, "maintenance");
+  assert.deepEqual(command.completion, completion);
 });

package/scripts/session-storage-sqlite.test.mjs

@@ -0,0 +1,209 @@
+/** @file 验证 SessionStorage 的 SQLite 事务、投影、恢复与 Policy 隔离边界。 */
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import test from "node:test";
+import { SqliteSessionStorage } from "../bin/session/storage/SqliteSessionStorage.js";
+
+/** 创建测试用文件系统协议。 */
+function create_files() {
+  return {
+    ensure_directory: async (directory_path) => await fs.mkdir(directory_path, { recursive: true }),
+    file_size: async (file_path) => (await fs.stat(file_path)).size,
+  };
+}
+
+/** 创建一个文件型 SessionStorage。 */
+async function create_storage(directory_path, options = {}) {
+  const storage = new SqliteSessionStorage({
+    session_id: options.session_id || "session-1",
+    agent_id: options.agent_id || "agent-1",
+    workspace_id: "workspace-1",
+    origin: { type: "chat" },
+    database_path: path.join(directory_path, "session.db"),
+    database_location: { type: "file" },
+    files: create_files(),
+    attachments: {},
+  });
+  await storage.initialize();
+  return storage;
+}
+
+/** 创建一条 User Message。 */
+function create_user_message(state) {
+  return {
+    message_id: "user-1",
+    session_id: "session-1",
+    turn_id: "turn-1",
+    sequence: state.message_sequence,
+    revision: 1,
+    role: "user",
+    visibility: "visible",
+    created_at: 10,
+    updated_at: 10,
+    parts: [{ part_id: "part-user-1", sequence: 1, type: "text", text: "你好" }],
+  };
+}
+
+test("Message 与 Part 分表原子保存并刷新列表投影", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const storage = await create_storage(directory_path);
+  const created = await storage.create_message(create_user_message);
+  assert.equal(created.role, "user");
+  const metadata = await storage.read_metadata();
+  assert.equal(metadata.message_count, 1);
+  assert.equal(metadata.preview_text, "你好");
+
+  const database = new DatabaseSync(path.join(directory_path, "session.db"), { readOnly: true });
+  try {
+    const message = database.prepare("SELECT role, state FROM messages").get();
+    assert.deepEqual({ ...message }, { role: "user", state: null });
+    const part = database.prepare("SELECT type, content FROM message_parts").get();
+    assert.equal(part.type, "text");
+    assert.deepEqual(Object.keys(JSON.parse(part.content)).sort(), ["text"]);
+  } finally {
+    database.close();
+  }
+
+  await assert.rejects(storage.update_message({
+    message: { ...created, revision: 3 },
+    expected_revision: 2,
+    changed_parts: [],
+  }), /revision conflict/);
+  const updated = {
+    ...created,
+    revision: 2,
+    updated_at: 20,
+    parts: [{ ...created.parts[0], text: "你好，SQLite" }],
+  };
+  await storage.update_message({
+    message: updated,
+    expected_revision: 1,
+    changed_parts: updated.parts,
+  });
+  assert.equal(updated.parts[0].text, "你好，SQLite");
+  assert.equal((await storage.read_metadata()).preview_text, "你好，SQLite");
+  await storage.dispose();
+});
+
+test("Storage 只查询中断状态，不擅自解释领域恢复语义", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const storage = await create_storage(directory_path);
+  await storage.create_message((state) => ({
+    message_id: "agent-1",
+    session_id: "session-1",
+    turn_id: "turn-1",
+    sequence: state.message_sequence,
+    revision: 1,
+    role: "agent",
+    state: "streaming",
+    visibility: "visible",
+    created_at: 10,
+    updated_at: 10,
+    parts: [
+      { part_id: "text-1", sequence: 1, step_id: "step-1", type: "text", text: "部分输出", state: "streaming" },
+      { part_id: "tool-1", sequence: 2, step_id: "step-1", type: "tool", tool_call_id: "call-1", tool_name: "read", state: "running" },
+      { part_id: "action-1", sequence: 3, type: "action", action_id: "action-1", action_type: "test", state: "running", title: "测试" },
+    ],
+  }));
+  await storage.dispose();
+
+  const reopened = await create_storage(directory_path);
+  const [message] = await reopened.list_recoverable_agent_messages();
+  assert.equal(message.state, "streaming");
+  assert.equal(message.parts[0].state, "streaming");
+  assert.equal(message.parts[1].state, "running");
+  assert.equal(message.parts[2].state, "running");
+  assert.equal((await reopened.read_metadata()).preview_text, "部分输出");
+  await reopened.dispose();
+});
+
+test("Composer Policy 只能写自己的派生 namespace，clear 触发 FK 清理", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const storage = await create_storage(directory_path);
+  await storage.create_message(create_user_message);
+  const policy = storage.composer_storage("sequence");
+  await policy.transaction((transaction) => {
+    transaction.execute("CREATE TABLE composer_sequence_test (message_id TEXT REFERENCES messages(message_id) ON DELETE CASCADE)");
+    transaction.execute("INSERT INTO composer_sequence_test (message_id) VALUES (?)", ["user-1"]);
+  });
+  await assert.rejects(policy.transaction((transaction) => transaction.execute("UPDATE messages SET visibility = 'internal'")), /can only mutate/);
+  await assert.rejects(policy.transaction((transaction) => transaction.execute("ALTER TABLE messages ADD COLUMN invalid TEXT")), /cannot execute database control/);
+  await assert.rejects(
+    policy.transaction((transaction) => transaction.execute(
+      "CREATE INDEX composer_sequence_messages_index ON messages(sequence)",
+    )),
+    /cannot execute database control/,
+  );
+  await storage.clear_messages();
+  assert.equal(await policy.transaction((transaction) => transaction.get("SELECT COUNT(*) AS count FROM composer_sequence_test")).then((row) => row.count), 0);
+  assert.equal((await storage.read_metadata()).preview_text, undefined);
+  await storage.dispose();
+});
+
+test("初始化失败会关闭连接并允许同一实例重试", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const database_path = path.join(directory_path, "session.db");
+  const database = new DatabaseSync(database_path);
+  database.exec("PRAGMA user_version = 99");
+  database.close();
+  const storage = new SqliteSessionStorage({
+    session_id: "session-1",
+    agent_id: "agent-1",
+    origin: { type: "chat" },
+    database_path,
+    database_location: { type: "file" },
+    files: create_files(),
+    attachments: {},
+  });
+  await assert.rejects(storage.initialize(), /Unsupported Session schema version/);
+  const repair = new DatabaseSync(database_path);
+  repair.exec("PRAGMA user_version = 0");
+  repair.close();
+  await storage.initialize();
+  assert.equal((await storage.read_metadata()).session_id, "session-1");
+  await storage.dispose();
+});
+
+test("旧 SQLite schema 必须由外部脚本迁移", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const database_path = path.join(directory_path, "session.db");
+  const database = new DatabaseSync(database_path);
+  database.exec("PRAGMA user_version = 1");
+  database.close();
+  const storage = new SqliteSessionStorage({
+    session_id: "session-1",
+    agent_id: "agent-1",
+    origin: { type: "chat" },
+    database_path,
+    database_location: { type: "file" },
+    files: create_files(),
+    attachments: {},
+  });
+  await assert.rejects(storage.initialize(), /requires the external migration script/);
+  await storage.dispose();
+});
+
+test("Codec 在损坏的 Part 内容进入领域层前失败", async () => {
+  const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
+  const database_path = path.join(directory_path, "session.db");
+  const storage = await create_storage(directory_path);
+  await storage.create_message(create_user_message);
+  await storage.dispose();
+
+  const database = new DatabaseSync(database_path);
+  database.prepare(
+    "UPDATE message_parts SET content = ? WHERE part_id = ?",
+  ).run(JSON.stringify({ text: 42 }), "part-user-1");
+  database.close();
+
+  const reopened = await create_storage(directory_path);
+  await assert.rejects(
+    reopened.list_messages(),
+    /Invalid persisted Session Part part-user-1.*text must be a string/,
+  );
+  await reopened.dispose();
+});

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

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - 动态输入和输出只能通过领域行为读写。
- * - Step 切换和 Context dispose 都会闭合 Plugin lease。
+ * - Step 切换和 Context dispose 都会闭合 Plugin Hook 作用域。
  * - Plugin 只获得独立的只读快照，不能访问根上下文能力。
  */
 
@@ -12,65 +12,79 @@ import test from "node:test";
 
 import { create_session_turn_context } from "../bin/session/runtime/SessionTurnContext.js";
 
-function create_user_message(message_id, text, created_at) {
-  return {
-    message_id,
-    session_id: "session-context-test",
-    turn_id: "turn-context-test",
-    sequence: created_at,
-    revision: 1,
-    visibility: "visible",
-    created_at,
-    updated_at: created_at,
-    type: "user",
-    input_type: "steer",
-    parts: [{
-      part_id: `${message_id}:text`,
-      type: "text",
-      text,
-      state: "done",
-    }],
-  };
-}
-
 test("SessionTurnContext 在检查点消费输入并封装输出缓冲", async () => {
+  let commit_count = 0;
+  const internal_messages = [];
   const context = create_session_turn_context({
     session_id: "session-context-test",
+    session_origin: { type: "chat" },
     turn_id: "turn-context-test",
     project_root: "/workspace",
-    merge_step_input: async () => [create_user_message("queued-message", "queued", 2)],
+    commit_step_input: async () => {
+      commit_count += 1;
+    },
+    append_internal_user_message: async (parts) => {
+      internal_messages.push(parts);
+      return {
+        message_id: "internal-1", session_id: "session-context-test",
+        turn_id: "turn-context-test", sequence: 1, revision: 1,
+        visibility: "internal", created_at: 1, updated_at: 1,
+        role: "user", parts: parts.map((part, index) => ({
+          ...part, part_id: `part-${index + 1}`, sequence: index + 1,
+        })),
+      };
+    },
   });
-  context.input.inject_user_message(
-    create_user_message("injected-message", "injected", 1),
-  );
+  await context.input.append_internal([{ type: "text", text: "injected" }]);
   context.output.enqueue_assistant_parts([{
     type: "file",
     media_type: "text/plain",
     url: "/workspace/result.txt",
   }]);
 
-  assert.deepEqual(
-    (await context.input.checkpoint()).map((message) => message.message_id),
-    ["injected-message", "queued-message"],
-  );
-  assert.deepEqual(
-    (await context.input.checkpoint()).map((message) => message.message_id),
-    ["queued-message"],
-  );
+  await context.input.checkpoint();
+  await context.input.checkpoint();
+  assert.equal(internal_messages[0][0].text, "injected");
+  assert.equal(commit_count, 2);
   assert.equal(context.output.take_assistant_parts().length, 1);
   assert.equal(context.output.take_assistant_parts().length, 0);
 });
 
-test("SessionTurnContext 负责 Plugin lease 与只读投影生命周期", async () => {
+test("SessionTurnContext 只按顺序收集当前 Turn 的 Tool effects", () => {
+  const context = create_session_turn_context({
+    session_id: "session-context-test",
+    session_origin: { type: "chat" },
+    turn_id: "turn-context-test",
+  });
+  context.effects.append([{
+    type: "example.first",
+    data: { value: 1 },
+  }]);
+  const first_snapshot = context.effects.snapshot();
+  context.effects.append([{
+    type: "example.second",
+    data: { value: 2 },
+  }]);
+
+  assert.equal(Object.isFrozen(first_snapshot), true);
+  assert.deepEqual(first_snapshot.map((effect) => effect.type), ["example.first"]);
+  assert.deepEqual(
+    context.effects.snapshot().map((effect) => effect.type),
+    ["example.first", "example.second"],
+  );
+});
+
+test("SessionTurnContext 负责 Plugin Hook 作用域与只读投影生命周期", async () => {
   const released = [];
-  const create_lease = (name) => ({
-    read: () => ({ plugins: [] }),
-    run_action: async () => ({ success: true }),
+  const create_scope = (name) => ({
     system_blocks: async () => [],
-    release: async () => released.push(name),
+    pipeline: async (_point_name, value) => value,
+    effect: async () => {},
+    close: async () => released.push(name),
   });
   const context = create_session_turn_context({
     session_id: "session-context-test",
+    session_origin: { type: "group", group_id: "group-1" },
     turn_id: "turn-context-test",
     project_root: "/workspace",
   });
@@ -78,21 +92,26 @@ test("SessionTurnContext 负责 Plugin lease 与只读投影生命周期", async
     workspace_env: { REGION: "cn" },
     agent_systems: ["system"],
   });
-  await context.step.replace_plugins(create_lease("first"));
-  await context.step.replace_plugins(create_lease("second"));
+  await context.step.replace_hooks(create_scope("first"));
+  await context.step.replace_hooks(create_scope("second"));
 
-  const plugin_execution_context = context.step.plugin_execution_context("call-context-test");
+  const plugin_execution_context = context.step.hook_context("call-context-test");
   assert.deepEqual(Object.keys(plugin_execution_context).sort(), [
     "abort_signal",
     "agent_systems",
     "call_id",
     "project_root",
     "session_id",
+    "session_origin",
     "turn_id",
     "workspace_env",
   ]);
   assert.equal(Object.isFrozen(plugin_execution_context), true);
   assert.equal(plugin_execution_context.call_id, "call-context-test");
+  assert.deepEqual(plugin_execution_context.session_origin, {
+    type: "group",
+    group_id: "group-1",
+  });
   assert.deepEqual(plugin_execution_context.workspace_env, { REGION: "cn" });
   assert.deepEqual(released, ["first"]);
 
@@ -100,3 +119,32 @@ test("SessionTurnContext 负责 Plugin lease 与只读投影生命周期", async
   await context.lifecycle.dispose();
   assert.deepEqual(released, ["first", "second"]);
 });
+
+test("SessionTurnContext 在整个 Turn 中只解析一次 Plugin Context", async () => {
+  const context = create_session_turn_context({
+    session_id: "session-context-test",
+    session_origin: { type: "chat" },
+    turn_id: "turn-context-test",
+  });
+  let resolve_count = 0;
+  const resolver = async () => {
+    resolve_count += 1;
+    return [{
+      source_plugin: "memory",
+      name: "recall",
+      content: "stable recall",
+      trust_level: "reference",
+      citations: ["memory:1"],
+    }];
+  };
+
+  const first = await context.step.resolve_plugin_context_blocks(resolver);
+  const second = await context.step.resolve_plugin_context_blocks(resolver);
+
+  assert.equal(resolve_count, 1);
+  assert.equal(first, second);
+  assert.equal(first, context.step.plugin_context_blocks);
+  assert.equal(Object.isFrozen(first), true);
+  assert.equal(Object.isFrozen(first[0]), true);
+  assert.equal(Object.isFrozen(first[0].citations), true);
+});