@downcity/agent 1.1.437 → 1.1.445

package/scripts/{core-engine-context-compaction.test.mjs → session-executor-context-pressure.test.mjs}

@@ -1,5 +1,5 @@
 /**
- * @file 验证 CoreEngine 只根据真实 usage 请求 Composer Context Policy 恢复。
+ * @file 验证 SessionExecutor 只根据真实 usage 判断是否需要推进上下文。
  */
 
 import assert from "node:assert/strict";
@@ -7,12 +7,12 @@ import test from "node:test";
 import { MockModelClient } from "./ModelClientMock.mjs";
 
 import {
-  resolve_model_usage_ratio,
-  resolve_model_usage_tokens,
-  should_compact_after_usage,
-} from "../bin/executor/core-engine/CoreEngineContextCompaction.js";
-import { CoreEngineRunner } from "../bin/executor/core-engine/CoreEngineRunner.js";
-import { create_session_turn_context } from "../bin/session/runtime/SessionTurnContext.js";
+  resolve_usage_ratio,
+  resolve_usage_tokens,
+  is_context_pressured,
+} from "../bin/session/runner/ContextPressure.js";
+import { SessionExecutor } from "../bin/session/runner/SessionExecutor.js";
+import { create_session_turn_context } from "../bin/session/loop/SessionTurnContext.js";
 
 function create_stream_text_result(text, input_tokens, output_tokens) {
   return {
@@ -46,21 +46,14 @@ function create_stream_text_result(text, input_tokens, output_tokens) {
 }
 
 function create_runner() {
-  return new CoreEngineRunner({
+  return new SessionExecutor({
     session_id: "compact-runner-session",
     logger: { log: async () => {} },
-    should_compact_on_error: () => false,
+    is_context_limit: () => false,
+    advance_context: async () => false,
   });
 }
 
-function create_context_error_runner() {
-  return new CoreEngineRunner({
-    session_id: "compact-runner-session",
-    logger: { log: async () => {} },
-    should_compact_on_error: (error) =>
-      String(error || "").includes("context length"),
-  });
-}
 
 function create_turn_input(model, messages, context_window = 100, warnings = []) {
   return {
@@ -82,7 +75,7 @@ function create_turn_input(model, messages, context_window = 100, warnings = [])
 
 test("usage 优先读取 totalTokens，并在缺失时回退 input + output", () => {
   assert.equal(
-    resolve_model_usage_tokens({
+    resolve_usage_tokens({
       totalTokens: 95,
       inputTokens: 80,
       outputTokens: 10,
@@ -90,16 +83,16 @@ test("usage 优先读取 totalTokens，并在缺失时回退 input + output", ()
     95,
   );
   assert.equal(
-    resolve_model_usage_tokens({ inputTokens: 80, outputTokens: 15 }),
+    resolve_usage_tokens({ inputTokens: 80, outputTokens: 15 }),
     95,
   );
-  assert.equal(resolve_model_usage_tokens({}), null);
+  assert.equal(resolve_usage_tokens({}), null);
 });
 
 test("真实 usage 达到 95% 时请求 Context Policy 恢复", () => {
-  assert.equal(resolve_model_usage_ratio({ totalTokens: 94 }, 100), 0.94);
-  assert.equal(should_compact_after_usage(0.94), false);
-  assert.equal(should_compact_after_usage(0.95), true);
+  assert.equal(resolve_usage_ratio({ totalTokens: 94 }, 100), 0.94);
+  assert.equal(is_context_pressured(0.94), false);
+  assert.equal(is_context_pressured(0.95), true);
 });
 
 test("最终 Step 达到 95% 时通过 Turn 结果请求 writer 收口后持久化 compact", async () => {
@@ -230,10 +223,11 @@ test("每个 Provider Step 使用 Composer 返回的最新 canonical history", a
     role: "assistant",
     content: [{ type: "text", text: "compacted checkpoint" }],
   }];
-  const runner = new CoreEngineRunner({
+  const runner = new SessionExecutor({
     session_id: "compact-runner-session",
     logger: { log: async () => {} },
-    should_compact_on_error: () => false,
+    is_context_limit: () => false,
+    advance_context: async () => false,
   });
   const model = new MockModelClient({
     modelId: "history-reload-model",
@@ -341,15 +335,29 @@ test("每个 Provider Step 只解析一次完整 Composer 输入", async () => {
   assert.equal(compose_count, 2);
 });
 
-test("Provider context-length error 交给外层 Composer 恢复策略", async () => {
+test("Provider context-length error 在执行器内推进上下文后重试，用尽后返回结构化失败", async () => {
   const model = new MockModelClient({
     modelId: "context-error-model",
     doStream: async () => { throw new Error("context length exceeded"); },
   });
-  await assert.rejects(create_context_error_runner().execute(
-    create_turn_input(model, [{
-      role: "user",
-      content: [{ type: "text", text: "latest request" }],
-    }]),
-  ), /context length exceeded/);
+  let advance_count = 0;
+  const runner = new SessionExecutor({
+    session_id: "compact-runner-session",
+    logger: { log: async () => {} },
+    is_context_limit: (error) => String(error || "").includes("context length"),
+    advance_context: async () => {
+      advance_count += 1;
+      // 始终声称已推进，验证重试次数上限与最终收口。
+      return true;
+    },
+  });
+
+  const result = await runner.execute(create_turn_input(model, [{
+    role: "user",
+    content: [{ type: "text", text: "latest request" }],
+  }]));
+
+  assert.equal(result.success, false);
+  assert.match(result.error, /Context length exceeded and retries failed/);
+  assert.equal(advance_count, 3);
 });

package/scripts/{executor-failure-result.test.mjs → session-executor-failure-result.test.mjs}

@@ -6,9 +6,9 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { MockModelClient } from "./ModelClientMock.mjs";
 
-import { CoreEngineRunner } from "../bin/executor/core-engine/CoreEngineRunner.js";
-import { ExecutorRecoveryPolicy } from "../bin/executor/services/ExecutorRecoveryPolicy.js";
-import { create_session_turn_context } from "../bin/session/runtime/SessionTurnContext.js";
+import { SessionExecutor } from "../bin/session/runner/SessionExecutor.js";
+import { ContextRetry } from "../bin/session/runner/ContextRetry.js";
+import { create_session_turn_context } from "../bin/session/loop/SessionTurnContext.js";
 
 function create_turn_context(overrides = {}) {
   return create_session_turn_context({
@@ -57,7 +57,7 @@ function create_execution_input(model, turn_context) {
   };
 }
 
-test("CoreEngine Provider 失败时只返回结构化错误", async () => {
+test("SessionExecutor Provider 失败时只返回结构化错误", async () => {
   const model = {
     id: "failing-model",
     async stream() {
@@ -81,10 +81,11 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
       });
     },
   };
-  const runner = new CoreEngineRunner({
+  const runner = new SessionExecutor({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
-    should_compact_on_error: () => false,
+    is_context_limit: () => false,
+    advance_context: async () => false,
   });
   const messages = [{
     role: "user",
@@ -106,16 +107,17 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
   assert.equal(result.text, "");
 });
 
-test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", async () => {
+test("SessionExecutor 成功流按 start、chunks、finish 完成 canonical step", async () => {
   const events = [];
   const model = new MockModelClient({
     modelId: "canonical-step-model",
     doStream: async () => create_text_stream("done"),
   });
-  const runner = new CoreEngineRunner({
+  const runner = new SessionExecutor({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
-    should_compact_on_error: () => false,
+    is_context_limit: () => false,
+    advance_context: async () => false,
   });
   const result = await runner.execute(create_execution_input(
     model,
@@ -138,16 +140,17 @@ test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", as
   assert.equal(events.includes("abort"), false);
 });
 
-test("CoreEngine chunk 写入失败时中止 canonical step", async () => {
+test("SessionExecutor chunk 写入失败时中止 canonical step", async () => {
   const events = [];
   const model = new MockModelClient({
     modelId: "canonical-step-failure-model",
     doStream: async () => create_text_stream("partial"),
   });
-  const runner = new CoreEngineRunner({
+  const runner = new SessionExecutor({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
-    should_compact_on_error: () => false,
+    is_context_limit: () => false,
+    advance_context: async () => false,
   });
   const result = await runner.execute(create_execution_input(
     model,
@@ -169,10 +172,10 @@ test("CoreEngine chunk 写入失败时中止 canonical step", async () => {
 });
 
 test("恢复策略捕获普通异常后只返回结构化错误", async () => {
-  const policy = new ExecutorRecoveryPolicy({
+  const policy = new ContextRetry({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
-    recover_context: async () => false,
+    advance_context: async () => false,
   });
   const result = await policy.execute_with_retry({
     execute_turn: async () => {

package/scripts/session-executor-max-steps.test.mjs

@@ -0,0 +1,143 @@
+/**
+ * @file 验证工具循环撞顶后先强制收尾，收尾仍无正文时按明确失败收口。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { SessionExecutor } from "../bin/session/runner/SessionExecutor.js";
+import {
+  MAX_TOOL_LOOP_STEPS,
+  TOOL_LOOP_MAX_STEPS_ERROR_CODE,
+  build_max_steps_error_text,
+} from "../bin/session/runner/ToolLoopLimits.js";
+import { create_session_turn_context } from "../bin/session/loop/SessionTurnContext.js";
+
+const usage = { input_tokens: 1, output_tokens: 1, total_tokens: 2 };
+
+/**
+ * 构造“每步都请求工具调用、禁用工具后才给正文”的模型。
+ *
+ * 关键点（中文）：收尾 Step 由 `call.tools` 为空识别，避免依赖 Step 序号假设。
+ */
+function create_tool_loop_model(wrap_up_text) {
+  let provider_call_count = 0;
+  const observed_calls = [];
+  return {
+    id: "tool-loop-limit-model",
+    get provider_call_count() {
+      return provider_call_count;
+    },
+    observed_calls,
+    async stream(call) {
+      provider_call_count += 1;
+      const current_call = provider_call_count;
+      const has_tools = (call.tools?.length ?? 0) > 0;
+      observed_calls.push({ tool_count: call.tools?.length ?? 0 });
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: `request_${current_call}`,
+            model_id: "tool-loop-limit-model",
+          });
+          if (has_tools) {
+            controller.enqueue({
+              type: "tool_call_start",
+              content_id: `tool_${current_call}`,
+              tool_call_id: `call_${current_call}`,
+              tool_name: "ping",
+            });
+            controller.enqueue({
+              type: "tool_call_finish",
+              content_id: `tool_${current_call}`,
+              input: {},
+            });
+            controller.enqueue({ type: "model_usage", usage });
+            controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          } else {
+            if (wrap_up_text) {
+              controller.enqueue({ type: "text_start", content_id: "wrap_text" });
+              controller.enqueue({
+                type: "text_delta",
+                content_id: "wrap_text",
+                delta: wrap_up_text,
+              });
+              controller.enqueue({ type: "text_finish", content_id: "wrap_text" });
+            }
+            controller.enqueue({ type: "model_usage", usage });
+            controller.enqueue({ type: "model_finish", finish_reason: "stop" });
+          }
+          controller.close();
+        },
+      });
+    },
+  };
+}
+
+/** 创建一次可观测内部输入的 Turn 执行输入。 */
+function create_turn_input(model) {
+  const internal_parts = [];
+  return {
+    internal_parts,
+    input: {
+      turn_context: create_session_turn_context({
+        session_id: "tool-loop-limit-session",
+        session_origin: { type: "chat" },
+        turn_id: "tool-loop-limit-turn",
+        append_internal_user_message: async (parts) => {
+          internal_parts.push(...parts);
+          return { message_id: "internal", parts };
+        },
+      }),
+      resolve_step_input: async () => ({
+        model,
+        system: [],
+        messages: [{ role: "user", content: [{ type: "text", text: "keep going" }] }],
+        tools: { ping: { execute: async () => ({ ok: true }) } },
+      }),
+    },
+  };
+}
+
+function create_runner() {
+  return new SessionExecutor({
+    session_id: "tool-loop-limit-session",
+    logger: { log: async () => {} },
+    is_context_limit: () => false,
+    advance_context: async () => false,
+  });
+}
+
+test("工具循环上限提高到 1000", () => {
+  assert.equal(MAX_TOOL_LOOP_STEPS, 1000);
+});
+
+test("撞顶后强制收尾一次，收尾无正文时返回明确失败", async () => {
+  const model = create_tool_loop_model("");
+  const turn = create_turn_input(model);
+
+  const result = await create_runner().execute(turn.input);
+
+  assert.equal(result.success, false);
+  assert.equal(result.error_code, TOOL_LOOP_MAX_STEPS_ERROR_CODE);
+  assert.equal(result.error, build_max_steps_error_text(MAX_TOOL_LOOP_STEPS));
+  // 正常循环耗尽上限后，额外只允许一次禁用工具的收尾 Step。
+  assert.equal(model.provider_call_count, MAX_TOOL_LOOP_STEPS + 1);
+  assert.deepEqual(model.observed_calls.at(-1), { tool_count: 0 });
+  assert.equal(turn.internal_parts.length, 1);
+  assert.match(turn.internal_parts[0].text, /达到工具循环上限/);
+});
+
+test("撞顶后收尾成功时按成功收口并返回正文", async () => {
+  const model = create_tool_loop_model("已完成的结论");
+  const turn = create_turn_input(model);
+
+  const result = await create_runner().execute(turn.input);
+
+  assert.equal(result.success, true, result.error);
+  assert.equal(result.error_code, undefined);
+  assert.equal(result.text, "已完成的结论");
+  assert.equal(model.provider_call_count, MAX_TOOL_LOOP_STEPS + 1);
+  assert.deepEqual(model.observed_calls.at(-1), { tool_count: 0 });
+});

package/scripts/session-initialization.test.mjs

@@ -29,8 +29,7 @@ function create_session(overrides = {}) {
     list_messages: async () => [],
     list_recoverable_agent_messages: async () => [],
     message_stats: async () => ({ message_count: 0, storage_bytes: 0, latest_message: null }),
-    composer_storage: () => ({
-      list_messages: async () => [],
+    derived_store: () => ({
       transaction: async (operation) => operation({
         execute: () => {},
         get: () => null,
@@ -65,7 +64,7 @@ function create_session(overrides = {}) {
     get_instruction_system_blocks: () => [],
     get_workspace_env: () => ({}),
     get_hooks: () => ({}),
-    get_managed_plugin_system_blocks: async () => [],
+    get_managed_power_system_blocks: async () => [],
     get_agent_model: () => undefined,
   });
   return { calls, session };
@@ -109,7 +108,7 @@ test("Session 并发初始化共享完整初始化图", async () => {
   });
 });
 
-test("SessionComposition 恢复失败后允许 Session 重试", async () => {
+test("StepInput 初始化失败后允许 Session 重试", async () => {
   const { calls, session } = create_session({
     read_instruction: async (attempt) => {
       if (attempt === 1) throw new Error("instruction unavailable");

package/scripts/session-interaction-migration.test.mjs

@@ -0,0 +1,145 @@
+/** @file 验证旧格式 Interaction 数据经外部迁移后能被当前编解码读回。 */
+
+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 { migrate_session_interactions } from "../../../scripts/migrate-session-interaction-into-tool.mjs";
+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) {
+  const storage = new SqliteSessionStorage({
+    session_id: "session-1",
+    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;
+}
+
+/** 创建一条包含 Tool Part 的 Agent Message。 */
+async function create_agent_message(storage) {
+  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: "done",
+    visibility: "visible",
+    created_at: 10,
+    updated_at: 10,
+    parts: [
+      { part_id: "text-1", sequence: 1, step_id: "step-1", type: "text", text: "执行中", state: "done" },
+      {
+        part_id: "tool:call-1",
+        sequence: 2,
+        step_id: "step-1",
+        type: "tool",
+        tool_call_id: "call-1",
+        tool_name: "shell_exec",
+        state: "completed",
+        input: { cmd: "ls" },
+      },
+    ],
+  }));
+}
+
+/** 以旧格式写入一条独立 Interaction 行，模拟迁移前的磁盘状态。 */
+function insert_legacy_interaction(database_path, sequence) {
+  const database = new DatabaseSync(database_path);
+  try {
+    database.prepare(
+      `INSERT INTO message_parts (part_id, message_id, sequence, step_id, type, content, created_at, updated_at)
+       VALUES (?, 'agent-1', ?, NULL, 'interaction', ?, 10, 10)`,
+    ).run(
+      "interaction:interaction:i-1",
+      sequence,
+      JSON.stringify({
+        interaction_id: "interaction:i-1",
+        interaction_type: "approval",
+        status: "resolved",
+        request: {
+          interaction_id: "interaction:i-1",
+          turn_id: "turn-1",
+          type: "approval",
+          source: { type: "shell", tool_call_id: "call-1", tool_name: "shell_exec" },
+          title: "Approve shell_exec",
+          payload: { cmd: "ls" },
+          created_at: 100,
+        },
+        response: { type: "approval", outcome: "resolved", payload: { approved: true } },
+        resolved_at: 200,
+      }),
+    );
+  } finally {
+    database.close();
+  }
+}
+
+test("旧格式交互在迁移前不可读，迁移后可读且归属正确", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-interaction-migration-"));
+  const directory_path = path.join(root_path, "agents", "agent-1", "sessions", "chat", "session-1");
+  const database_path = path.join(directory_path, "session.db");
+
+  const storage = await create_storage(directory_path);
+  await create_agent_message(storage);
+  await storage.dispose();
+
+  insert_legacy_interaction(database_path, 3);
+  const legacy = await create_storage(directory_path);
+  // 迁移前的磁盘状态就是用户会话失败时的状态：编解码拒绝整条 message。
+  await assert.rejects(
+    legacy.list_messages(),
+    /legacy standalone Interaction Part requires migration into its Tool Part/,
+  );
+  await legacy.dispose();
+
+  const result = await migrate_session_interactions({ root_path, dry_run: false });
+  assert.equal(result.migrated_databases, 1);
+  assert.equal(result.migrated_interactions, 1);
+  assert.equal(result.blocked_databases, 0);
+
+  const migrated = await create_storage(directory_path);
+  const messages = await migrated.list_messages();
+  await migrated.dispose();
+  const tool_part = messages.flatMap((message) => message.parts).find((part) => part.type === "tool");
+  assert.deepEqual(tool_part.interactions, [{
+    interaction_id: "interaction:i-1",
+    interaction_type: "approval",
+    status: "resolved",
+    request: {
+      interaction_id: "interaction:i-1",
+      turn_id: "turn-1",
+      type: "approval",
+      source: { type: "shell", tool_call_id: "call-1", tool_name: "shell_exec" },
+      title: "Approve shell_exec",
+      payload: { cmd: "ls" },
+      created_at: 100,
+    },
+    response: { type: "approval", outcome: "resolved", payload: { approved: true } },
+    resolved_at: 200,
+  }]);
+
+  // 重跑必须无副作用，否则脚本无法安全地重复执行。
+  const again = await migrate_session_interactions({ root_path, dry_run: false });
+  assert.equal(again.skipped_databases, 1);
+  assert.equal(again.migrated_databases, 0);
+});