@downcity/agent 1.1.408 → 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,
@@ -63,26 +62,21 @@ function create_context_error_runner() {
   });
 }
 
-function create_turn_input(model, messages, context_window = 100) {
+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 }),
   };
 }
 
@@ -102,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 () => {
@@ -119,35 +111,13 @@ 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 = [];
   const model = {
     id: "retryable-stream-model",
     async stream() {
@@ -188,14 +158,73 @@ test("Provider 在输出前发生可重试流错误时自动重试", async () =>
     content: [{ type: "text", text: "latest request" }],
   }];
 
-  const result = await create_runner().execute(create_turn_input(model, messages));
+  const result = await create_runner().execute(
+    create_turn_input(model, messages, 100, warnings),
+  );
 
   assert.equal(call_count, 2);
   assert.equal(result.success, true);
   assert.equal(result.text, "done");
+  assert.deepEqual(warnings, [{
+    request_kind: "turn",
+    code: "transport_error",
+    message: "temporary disconnect",
+    retryable: true,
+    attempt: 1,
+    max_attempts: 6,
+    will_retry: true,
+  }]);
 });
 
-test("显式 compact 后在下一次 provider 调用前重载 canonical history", async () => {
+test("Provider 不可重试失败会立即发送最终模型 Warning", async () => {
+  const warnings = [];
+  const model = {
+    id: "rejected-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: "request_rejected",
+            model_id: "rejected-model",
+          });
+          controller.enqueue({
+            type: "model_error",
+            error: {
+              code: "authentication_failed",
+              message: "invalid model credential",
+              retryable: false,
+              provider_request_id: "provider_request_1",
+            },
+          });
+          controller.close();
+        },
+      });
+    },
+  };
+  const messages = [{
+    role: "user",
+    content: [{ type: "text", text: "latest request" }],
+  }];
+
+  const result = await create_runner().execute(
+    create_turn_input(model, messages, 100, warnings),
+  );
+
+  assert.equal(result.success, false);
+  assert.deepEqual(warnings, [{
+    request_kind: "turn",
+    code: "authentication_failed",
+    message: "invalid model credential",
+    retryable: false,
+    attempt: 1,
+    max_attempts: 1,
+    will_retry: false,
+    provider_request_id: "provider_request_1",
+  }]);
+});
+
+test("每个 Provider Step 使用 Composer 返回的最新 canonical history", async () => {
   const provider_prompts = [];
   const compacted_messages = [{
     role: "assistant",
@@ -206,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) => {
@@ -218,18 +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",
-    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);
@@ -240,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

@@ -6,6 +6,98 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 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 { is_session_mutation } from "@downcity/type";
+import {
+  MAX_MODEL_REQUEST_ATTEMPTS,
+  MAX_MODEL_REQUEST_RETRIES,
+} from "../bin/executor/model/ModelRequestRunner.js";
+
+test("Agent 模型请求最多自动重试五次", () => {
+  assert.equal(MAX_MODEL_REQUEST_RETRIES, 5);
+  assert.equal(MAX_MODEL_REQUEST_ATTEMPTS, 6);
+});
+
+test("Session 边界把内部模型失败投影为 Warning Mutation", () => {
+  const warning = create_session_model_request_warning({
+    session_id: "session_1",
+    notice: {
+      request_kind: "session_title",
+      code: "provider_timeout",
+      message: "temporary timeout",
+      retryable: true,
+      attempt: 1,
+      max_attempts: 6,
+      will_retry: true,
+    },
+  });
+
+  assert.equal(is_session_mutation(warning), true);
+  assert.equal(warning.variant, "warning");
+  assert.equal(warning.type, "model_request");
+  assert.equal(warning.request_kind, "session_title");
+  assert.equal(warning.turn_id, undefined);
+});
+
+test("非交互模型请求复用统一重试策略", async () => {
+  let call_count = 0;
+  const failures = [];
+  const model = {
+    id: "generated-content-model",
+    async stream() {
+      call_count += 1;
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: `request_${call_count}`,
+            model_id: "generated-content-model",
+          });
+          if (call_count === 1) {
+            controller.enqueue({
+              type: "model_error",
+              error: {
+                code: "provider_timeout",
+                message: "temporary timeout",
+                retryable: true,
+              },
+            });
+          } 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 result = await generate_model(model, {
+    messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+  }, {
+    request_kind: "session_title",
+    on_failure: (notice) => failures.push(notice),
+  });
+
+  assert.equal(call_count, 2);
+  assert.equal(result.text, "done");
+  assert.deepEqual(failures, [{
+    request_kind: "session_title",
+    code: "provider_timeout",
+    message: "temporary timeout",
+    retryable: true,
+    attempt: 1,
+    max_attempts: 6,
+    will_retry: true,
+  }]);
+});
 
 test("模型事件写入 canonical Session 失败时拒绝继续完成 turn", async () => {
   const abort_controller = new AbortController();
@@ -120,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 () => {
@@ -152,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

@@ -13,6 +13,7 @@ import { create_session_turn_context } from "../bin/session/runtime/SessionTurnC
 function create_turn_context(overrides = {}) {
   return create_session_turn_context({
     session_id: "executor-failure-test",
+    session_origin: { type: "chat" },
     turn_id: "executor-failure-turn",
     ...overrides,
   });
@@ -46,21 +47,40 @@ 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: {},
+    }),
   };
 }
 
 test("CoreEngine Provider 失败时只返回结构化错误", async () => {
-  const model = new MockModelClient({
-    modelId: "failing-model",
-    doStream: async () => {
-      throw new Error("quota exceeded");
+  const model = {
+    id: "failing-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: "request_1",
+            model_id: "failing-model",
+          });
+          controller.enqueue({
+            type: "model_error",
+            error: {
+              code: "permission_denied",
+              message: "quota exceeded",
+              retryable: false,
+            },
+          });
+          controller.close();
+        },
+      });
     },
-  });
+  };
   const runner = new CoreEngineRunner({
     session_id: "executor-failure-test",
     logger: { log: async () => {} },
@@ -72,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);
@@ -150,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);