@downcity/agent 1.1.430 → 1.1.437

package/scripts/core-engine-context-compaction.test.mjs

@@ -1,5 +1,5 @@
 /**
- * @file 验证 CoreEngine 基于真实 usage 的触发水位与 part/tool transaction 深度折叠。
+ * @file 验证 CoreEngine 只根据真实 usage 请求 Composer Context Policy 恢复。
  */
 
 import assert from "node:assert/strict";
@@ -7,7 +7,6 @@ import test from "node:test";
 import { MockModelClient } from "./ModelClientMock.mjs";
 
 import {
-  deep_compact_model_messages,
   resolve_model_usage_ratio,
   resolve_model_usage_tokens,
   should_compact_after_usage,
@@ -65,26 +64,19 @@ function create_context_error_runner() {
 
 function create_turn_input(model, messages, context_window = 100, warnings = []) {
   return {
-    execute_input: {
-      query: "latest request",
-      system: [],
-      messages,
-      tools: {},
-    },
-    model,
     turn_context: create_session_turn_context({
       session_id: "compact-runner-session",
       session_origin: { type: "chat" },
       turn_id: "compact-runner-turn",
       report_model_request_failure: (warning) => warnings.push(warning),
     }),
-    resolve_step_inputs: async () => ({
+    resolve_step_input: async () => ({
       model,
       system: [],
+      messages,
       tools: {},
       context_window,
     }),
-    reload_history: async () => ({ messages }),
   };
 }
 
@@ -104,12 +96,10 @@ test("usage 优先读取 totalTokens，并在缺失时回退 input + output", ()
   assert.equal(resolve_model_usage_tokens({}), null);
 });
 
-test("普通调用使用 95% 触发，compact 验收使用 50% 目标", () => {
+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), false);
-  assert.equal(should_compact_after_usage(0.95, false), true);
-  assert.equal(should_compact_after_usage(0.5, true), false);
-  assert.equal(should_compact_after_usage(0.5001, true), true);
+  assert.equal(should_compact_after_usage(0.94), false);
+  assert.equal(should_compact_after_usage(0.95), true);
 });
 
 test("最终 Step 达到 95% 时通过 Turn 结果请求 writer 收口后持久化 compact", async () => {
@@ -121,33 +111,10 @@ test("最终 Step 达到 95% 时通过 Turn 结果请求 writer 收口后持久
     role: "user",
     content: [{ type: "text", text: "latest request" }],
   }]));
-  assert.equal(result.success, true);
+  assert.equal(result.success, true, result.error);
   assert.equal(result.compact_required, true);
 });
 
-test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
-  const model = new MockModelClient({
-    modelId: "usage-validation-model",
-    doStream: async () => create_stream_text_result("done", 55, 5),
-  });
-  const runner = create_runner();
-  const messages = [{
-    role: "assistant",
-    content: [{ type: "text", text: "previous checkpoint" }],
-  }, {
-    role: "user",
-    content: [{ type: "text", text: "latest request" }],
-  }];
-  const first_input = create_turn_input(model, messages);
-  first_input.execute_input.history_summary_id = "summary-1";
-  const second_input = create_turn_input(model, messages);
-  second_input.execute_input.history_summary_id = "summary-1";
-  const first = await runner.execute(first_input);
-  const second = await runner.execute(second_input);
-  assert.equal(first.compact_required, true);
-  assert.equal(second.compact_required, undefined);
-});
-
 test("Provider 在输出前发生可重试流错误时自动重试", async () => {
   let call_count = 0;
   const warnings = [];
@@ -257,7 +224,7 @@ test("Provider 不可重试失败会立即发送最终模型 Warning", async ()
   }]);
 });
 
-test("显式 compact 后在下一次 provider 调用前重载 canonical history", async () => {
+test("每个 Provider Step 使用 Composer 返回的最新 canonical history", async () => {
   const provider_prompts = [];
   const compacted_messages = [{
     role: "assistant",
@@ -268,7 +235,6 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
     logger: { log: async () => {} },
     should_compact_on_error: () => false,
   });
-  let reload_requested = true;
   const model = new MockModelClient({
     modelId: "history-reload-model",
     doStream: async (options) => {
@@ -280,19 +246,12 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
     role: "user",
     content: [{ type: "text", text: "history before compact" }],
   }]);
-  input.turn_context = create_session_turn_context({
-    session_id: "compact-runner-session",
-    session_origin: { type: "chat" },
-    turn_id: "compact-runner-turn",
-    consume_history_reload: () => {
-      const requested = reload_requested;
-      reload_requested = false;
-      return requested;
-    },
-  });
-  input.reload_history = async () => ({
+  input.resolve_step_input = async () => ({
+    model,
+    system: [],
     messages: compacted_messages,
-    summary_id: "summary-reloaded",
+    tools: {},
+    context_window: 100,
   });
 
   const result = await runner.execute(input);
@@ -303,176 +262,94 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
   assert.doesNotMatch(provider_prompts[0], /history before compact/);
 });
 
-test("Provider context-length error 在当前 tool-loop 内 deep compact 后重试", async () => {
-  let provider_calls = 0;
+test("每个 Provider Step 只解析一次完整 Composer 输入", async () => {
+  let provider_call_count = 0;
+  let compose_count = 0;
+  const model = {
+    id: "single-compose-per-step-model",
+    async stream() {
+      provider_call_count += 1;
+      const current_call = provider_call_count;
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: `request_${current_call}`,
+            model_id: "single-compose-per-step-model",
+          });
+          if (current_call === 1) {
+            controller.enqueue({
+              type: "tool_call_start",
+              content_id: "tool_1",
+              tool_call_id: "call_1",
+              tool_name: "ping",
+            });
+            controller.enqueue({
+              type: "tool_call_finish",
+              content_id: "tool_1",
+              input: {},
+            });
+            controller.enqueue({
+              type: "model_usage",
+              usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+            });
+            controller.enqueue({
+              type: "model_finish",
+              finish_reason: "tool_call",
+            });
+          } else {
+            controller.enqueue({ type: "text_start", content_id: "text_1" });
+            controller.enqueue({
+              type: "text_delta",
+              content_id: "text_1",
+              delta: "done",
+            });
+            controller.enqueue({ type: "text_finish", content_id: "text_1" });
+            controller.enqueue({
+              type: "model_usage",
+              usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+            });
+            controller.enqueue({ type: "model_finish", finish_reason: "stop" });
+          }
+          controller.close();
+        },
+      });
+    },
+  };
+  const input = create_turn_input(model, [{
+    role: "user",
+    content: [{ type: "text", text: "ping" }],
+  }]);
+  input.resolve_step_input = async () => {
+    compose_count += 1;
+    return {
+      model,
+      system: [],
+      messages: [{
+        role: "user",
+        content: [{ type: "text", text: "ping" }],
+      }],
+      tools: { ping: { execute: async () => "pong" } },
+      context_window: 100,
+    };
+  };
+
+  const result = await create_runner().execute(input);
+
+  assert.equal(result.success, true, result.error);
+  assert.equal(provider_call_count, 2);
+  assert.equal(compose_count, 2);
+});
+
+test("Provider context-length error 交给外层 Composer 恢复策略", async () => {
   const model = new MockModelClient({
     modelId: "context-error-model",
-    doStream: async () => {
-      provider_calls += 1;
-      if (provider_calls === 1) throw new Error("context length exceeded");
-      return create_stream_text_result("recovered", 40, 5);
-    },
+    doStream: async () => { throw new Error("context length exceeded"); },
   });
-  const result = await create_context_error_runner().execute(
+  await assert.rejects(create_context_error_runner().execute(
     create_turn_input(model, [{
       role: "user",
       content: [{ type: "text", text: "latest request" }],
     }]),
-  );
-  assert.equal(result.success, true);
-  assert.equal(result.compact_required, true);
-  assert.equal(provider_calls, 2);
-});
-
-test("deep compact 删除 reasoning，并完整保留最新并行 tool transaction", () => {
-  const large_output = "tool-output-".repeat(8_000);
-  const messages = [
-    { role: "user", content: [{ type: "text", text: "older request" }] },
-    {
-      role: "assistant",
-      content: [
-        { type: "reasoning", text: "old reasoning".repeat(2_000) },
-        {
-          type: "tool_call",
-          tool_call_id: "old-call",
-          tool_name: "old_tool",
-          input: { query: "old" },
-        },
-      ],
-    },
-    {
-      role: "tool",
-      content: [
-        {
-          type: "tool_result",
-          tool_call_id: "old-call",
-          tool_name: "old_tool",
-          outcome: "succeeded",
-          content: [{ type: "text", text: large_output }],
-        },
-      ],
-    },
-    { role: "user", content: [{ type: "text", text: "latest request" }] },
-    {
-      role: "assistant",
-      content: [
-        {
-          type: "reasoning",
-          text: "latest reasoning".repeat(2_000),
-        },
-        {
-          type: "text",
-          text: "running tools",
-        },
-        {
-          type: "tool_call",
-          tool_call_id: "call-a",
-          tool_name: "tool_a",
-          input: { value: "a" },
-        },
-        {
-          type: "tool_call",
-          tool_call_id: "call-b",
-          tool_name: "tool_b",
-          input: { value: "b" },
-        },
-      ],
-    },
-    {
-      role: "tool",
-      content: [
-        {
-          type: "tool_result",
-          tool_call_id: "call-a",
-          tool_name: "tool_a",
-          outcome: "succeeded",
-          content: [{ type: "text", text: large_output }],
-        },
-        {
-          type: "tool_result",
-          tool_call_id: "call-b",
-          tool_name: "tool_b",
-          outcome: "succeeded",
-          content: [{ type: "json", value: { large_output } }],
-        },
-      ],
-    },
-  ];
-
-  const compacted = deep_compact_model_messages(messages, 0);
-  const serialized = JSON.stringify(compacted);
-  assert.equal(serialized.includes("old reasoning"), false);
-  assert.equal(serialized.includes("latest reasoning"), false);
-  assert.equal(serialized.includes('"itemId":"rs_latest"'), false);
-  assert.equal(serialized.includes('"itemId":"msg_latest"'), false);
-  assert.equal(serialized.includes('"phase":"final_answer"'), false);
-  assert.equal(serialized.includes("latest request"), true);
-  assert.equal(serialized.includes("call-a"), true);
-  assert.equal(serialized.includes("call-b"), true);
-  assert.ok(serialized.length < JSON.stringify(messages).length / 2);
-
-  const tool_call_ids = new Set();
-  const tool_result_ids = new Set();
-  const active_tool_text = [];
-  for (const message of compacted) {
-    if (!Array.isArray(message.content)) continue;
-    for (const part of message.content) {
-      if (part.type === "tool_call") tool_call_ids.add(part.tool_call_id);
-      if (part.type === "tool_result") tool_result_ids.add(part.tool_call_id);
-      if (part.type === "tool_call" || part.type === "tool_result") {
-        active_tool_text.push(JSON.stringify(part));
-      }
-    }
-  }
-  assert.equal(active_tool_text.join("\n").includes("old-call"), false);
-  assert.deepEqual([...tool_call_ids].sort(), ["call-a", "call-b"]);
-  assert.deepEqual([...tool_result_ids].sort(), ["call-a", "call-b"]);
-  assert.equal(serialized.includes('"itemId":"fc_a"'), false);
-  assert.equal(serialized.includes('"resultId":"result_a"'), false);
-});
-
-test("单条 assistant 含大量 parts 时也会在消息内部折叠", () => {
-  const messages = [{
-    role: "assistant",
-    content: Array.from({ length: 40 }, (_, index) => ({
-      type: "text",
-      text: `part-${String(index)}:${"x".repeat(4_000)}`,
-    })),
-  }];
-  const compacted = deep_compact_model_messages(messages, 0);
-  assert.equal(compacted.length, 1);
-  assert.ok(JSON.stringify(compacted).length < JSON.stringify(messages).length / 4);
-});
-
-test("最新工具调用与工具结果一起保留且不产生孤儿", () => {
-  const compacted = deep_compact_model_messages([
-    { role: "user", content: [{ type: "text", text: "run the operation" }] },
-    {
-      role: "assistant",
-      content: [
-        {
-          type: "tool_call",
-          tool_call_id: "operation-call",
-          tool_name: "operation_tool",
-          input: { path: "/tmp/example" },
-        },
-      ],
-    },
-    {
-      role: "tool",
-      content: [
-        {
-          type: "tool_result",
-          tool_call_id: "operation-call",
-          tool_name: "operation_tool",
-          outcome: "succeeded",
-          content: [{ type: "json", value: { changed: true } }],
-        },
-      ],
-    },
-  ]);
-  const serialized = JSON.stringify(compacted);
-  assert.equal(serialized.includes('"tool_call_id":"operation-call"'), true);
-  assert.equal(serialized.includes('"outcome":"succeeded"'), true);
-  assert.equal(serialized.includes('"changed":true'), true);
+  ), /context length exceeded/);
 });

package/scripts/core-engine-model-stream.test.mjs

@@ -212,9 +212,8 @@ test("模型生成无效工具输入时向下一 Step 返回 failed tool_result"
 
   assert.equal(executed, false);
   assert.equal(result.step_result.tool_results[0].success, false);
-  const tool_message = result.step_result.response.messages[1];
-  assert.equal(tool_message.content[0].outcome, "failed");
-  assert.match(tool_message.content[0].content[0].value.error, /invalid JSON/);
+  assert.match(result.step_result.tool_results[0].output.error, /invalid JSON/);
+  assert.equal(result.assistant_parts[0].state, "failed");
 });
 
 test("Tool 返回 success false 时不会被标记为成功", async () => {
@@ -244,5 +243,4 @@ test("Tool 返回 success false 时不会被标记为成功", async () => {
 
   assert.equal(result.step_result.tool_results[0].success, false);
   assert.equal(result.assistant_parts[0].state, "failed");
-  assert.equal(result.step_result.response.messages[1].content[0].outcome, "failed");
 });

package/scripts/executor-failure-result.test.mjs

@@ -47,11 +47,13 @@ function create_execution_input(model, turn_context) {
     content: [{ type: "text", text: "hello" }],
   }];
   return {
-    execute_input: { query: "hello", system: [], messages, tools: {} },
-    model,
     turn_context,
-    resolve_step_inputs: async () => ({ model, system: [], tools: {} }),
-    reload_history: async () => ({ messages }),
+    resolve_step_input: async () => ({
+      model,
+      system: [],
+      messages,
+      tools: {},
+    }),
   };
 }
 
@@ -90,11 +92,13 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
   }];
 
   const result = await runner.execute({
-    execute_input: { query: "hello", system: [], messages, tools: {} },
-    model,
     turn_context: create_turn_context(),
-    resolve_step_inputs: async () => ({ model, system: [], tools: {} }),
-    reload_history: async () => ({ messages }),
+    resolve_step_input: async () => ({
+      model,
+      system: [],
+      messages,
+      tools: {},
+    }),
   });
 
   assert.equal(result.success, false);
@@ -168,19 +172,12 @@ test("恢复策略捕获普通异常后只返回结构化错误", async () => {
   const policy = new ExecutorRecoveryPolicy({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
-    should_compact: () => false,
+    recover_context: async () => false,
   });
-  const turn_context = create_turn_context();
   const result = await policy.execute_with_retry({
-    query: "hello",
-    model: {},
-    turn_context,
-    prepare_execute_input: async () => {
+    execute_turn: async () => {
       throw new Error("configuration failed");
     },
-    execute_prepared_input: async () => {
-      throw new Error("unexpected execution");
-    },
   });
 
   assert.equal(result.success, false);

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

@@ -0,0 +1,63 @@
+/**
+ * @file 验证 Agent Message 的终态 Error 与 Turn 结果 Part 使用同一 canonical sequence。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionAgentMessageWriter } from "../bin/session/SessionMessages.js";
+
+/** 使用最小内存 Recorder 验证 Writer 的 Part 顺序能力。 */
+test("Error Part 在后续 Turn 结果 Data Part 之前写入", async () => {
+  let message = {
+    message_id: "agent:session-1:message-1",
+    session_id: "session-1",
+    turn_id: "turn-1",
+    sequence: 2,
+    revision: 1,
+    visibility: "visible",
+    created_at: 1,
+    updated_at: 1,
+    role: "agent",
+    state: "streaming",
+    parts: [],
+  };
+  const recorder = {
+    get_message: () => message,
+    project_agent_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) => {
+      message = {
+        ...message,
+        revision: message.revision + 1,
+        parts: [...message.parts, ...new_parts],
+      };
+    },
+    complete_agent_message: async (_message_id, status) => {
+      message = { ...message, state: "done", revision: message.revision + 1 };
+    },
+  };
+  const writer = new SessionAgentMessageWriter(recorder, message.message_id);
+
+  await writer.append_result_parts([{ type: "text", text: "处理中" }]);
+  await writer.append_error({
+    scope: "turn",
+    code: "turn_execution_failed",
+    message: "执行失败",
+    recoverable: true,
+  });
+  await writer.append_result_parts([{
+    type: "data",
+    data_type: "data-session-turn-file-diff",
+    data: { files: [], additions: 0, deletions: 0 },
+  }]);
+  await writer.fail("执行失败");
+
+  assert.deepEqual(message.parts.map((part) => part.type), ["text", "error", "data"]);
+  assert.deepEqual(message.parts.map((part) => part.sequence), [1, 2, 3]);
+  assert.equal(message.state, "done");
+});

package/scripts/session-initialization.test.mjs

@@ -0,0 +1,141 @@
+/**
+ * @file 验证 Session 初始化图并发复用成功任务，并在临时存储失败后允许重试。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Session } from "../bin/session/Session.js";
+
+/** 创建可以精确观测初始化调用次数的最小 Session。 */
+function create_session(overrides = {}) {
+  const calls = {
+    initialize_messages: 0,
+    read_instruction: 0,
+    read_metadata: 0,
+    write_metadata: 0,
+  };
+  let initialize_promise;
+  const store = {
+    session_id: "initialization-session",
+    origin: { type: "chat" },
+    attachments: {},
+    initialize: async () => {
+      if (!initialize_promise) initialize_promise = (async () => {
+        calls.initialize_messages += 1;
+        await overrides.initialize_messages?.(calls.initialize_messages);
+      })();
+      await initialize_promise;
+    },
+    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 () => [],
+      transaction: async (operation) => operation({
+        execute: () => {},
+        get: () => null,
+        all: () => [],
+      }),
+    }),
+    read_instruction: async () => {
+      calls.read_instruction += 1;
+      return await overrides.read_instruction?.(calls.read_instruction) ?? null;
+    },
+    read_metadata: async () => {
+      calls.read_metadata += 1;
+      return await overrides.read_metadata?.(calls.read_metadata) ?? {};
+    },
+    write_metadata: async () => {
+      calls.write_metadata += 1;
+    },
+    has_instruction: async () => false,
+    write_instruction: async () => {},
+  };
+  const session = new Session({
+    agent_id: "initialization-agent",
+    workspace_path: "/tmp/downcity-session-initialization",
+    origin: store.origin,
+    store,
+    create_session_store: () => store,
+    register_forked_session: () => {},
+    session_id: store.session_id,
+    get_tools: () => ({}),
+    logger: { log: async () => {} },
+    instruction_system_blocks: [],
+    get_instruction_system_blocks: () => [],
+    get_workspace_env: () => ({}),
+    get_hooks: () => ({}),
+    get_managed_plugin_system_blocks: async () => [],
+    get_agent_model: () => undefined,
+  });
+  return { calls, session };
+}
+
+/** 创建由测试显式释放的异步门。 */
+function create_gate() {
+  let release;
+  const promise = new Promise((resolve) => {
+    release = resolve;
+  });
+  return { promise, release };
+}
+
+test("Session 并发初始化共享完整初始化图", async () => {
+  const gate = create_gate();
+  const { calls, session } = create_session({
+    read_instruction: async () => {
+      await gate.promise;
+      return null;
+    },
+  });
+
+  const first = session.initialize();
+  const second = session.initialize();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(calls.initialize_messages, 1);
+  assert.equal(calls.read_instruction, 1);
+  assert.equal(calls.read_metadata, 1);
+  assert.ok(calls.write_metadata <= 1);
+
+  gate.release();
+  assert.equal(await first, session);
+  assert.equal(await second, session);
+  assert.equal(await session.initialize(), session);
+  assert.deepEqual(calls, {
+    initialize_messages: 1,
+    read_instruction: 1,
+    read_metadata: 1,
+    write_metadata: 1,
+  });
+});
+
+test("SessionComposition 恢复失败后允许 Session 重试", async () => {
+  const { calls, session } = create_session({
+    read_instruction: async (attempt) => {
+      if (attempt === 1) throw new Error("instruction unavailable");
+      return null;
+    },
+  });
+
+  await assert.rejects(session.initialize(), /instruction unavailable/);
+  await session.initialize();
+  assert.equal(calls.read_instruction, 2);
+  assert.equal(calls.initialize_messages, 1);
+  assert.equal(calls.read_metadata, 1);
+});
+
+test("SessionState 恢复失败后允许 Session 重试", async () => {
+  const { calls, session } = create_session({
+    read_metadata: async (attempt) => {
+      if (attempt === 1) throw new Error("metadata unavailable");
+      return {};
+    },
+  });
+
+  await assert.rejects(session.initialize(), /metadata unavailable/);
+  await session.initialize();
+  assert.equal(calls.read_metadata, 2);
+  assert.equal(calls.write_metadata, 1);
+  assert.equal(calls.read_instruction, 1);
+  assert.equal(calls.initialize_messages, 1);
+});