@downcity/agent 1.1.338 → 1.1.400

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

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { MockLanguageModelV3 } from "ai/test";
+import { MockModelClient } from "./ModelClientMock.mjs";
 
 import {
   deep_compact_model_messages,
@@ -82,7 +82,7 @@ function create_turn_input(model, messages, context_window = 100) {
       tools: {},
       context_window,
     }),
-    reload_history: async () => messages,
+    reload_history: async () => ({ messages }),
   };
 }
 
@@ -111,74 +111,46 @@ test("普通调用使用 95% 触发，compact 验收使用 50% 目标", () => {
 });
 
 test("最终 Step 达到 95% 时通过 Turn 结果请求 writer 收口后持久化 compact", async () => {
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "usage-trigger-model",
     doStream: async () => create_stream_text_result("done", 90, 5),
   });
   const result = await create_runner().execute(create_turn_input(model, [{
-    id: "user-1",
     role: "user",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "compact-runner-session",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "latest request" }],
+    content: [{ type: "text", text: "latest request" }],
   }]));
   assert.equal(result.success, true);
   assert.equal(result.compact_required, true);
 });
 
 test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "usage-validation-model",
     doStream: async () => create_stream_text_result("done", 55, 5),
   });
   const runner = create_runner();
   const messages = [{
-    id: "summary-1",
     role: "assistant",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "compact-runner-session",
-      source: "compact",
-      kind: "summary",
-    },
-    parts: [{ type: "text", text: "previous checkpoint" }],
+    content: [{ type: "text", text: "previous checkpoint" }],
   }, {
-    id: "user-1",
     role: "user",
-    metadata: {
-      v: 1,
-      ts: 2,
-      session_id: "compact-runner-session",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "latest request" }],
+    content: [{ type: "text", text: "latest request" }],
   }];
-  const first = await runner.execute(create_turn_input(model, messages));
-  const second = await runner.execute(create_turn_input(model, messages));
+  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("显式 compact 后在下一次 provider 调用前重载 canonical history", async () => {
   const provider_prompts = [];
-  const compacted_records = [{
-    id: "summary-reloaded",
+  const compacted_messages = [{
     role: "assistant",
-    metadata: {
-      v: 1,
-      ts: 2,
-      session_id: "compact-runner-session",
-      source: "compact",
-      kind: "summary",
-    },
-    parts: [{ type: "text", text: "compacted checkpoint" }],
+    content: [{ type: "text", text: "compacted checkpoint" }],
   }];
   const runner = new CoreEngineRunner({
     session_id: "compact-runner-session",
@@ -186,7 +158,7 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
     should_compact_on_error: () => false,
   });
   let reload_requested = true;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "history-reload-model",
     doStream: async (options) => {
       provider_prompts.push(JSON.stringify(options.prompt));
@@ -194,16 +166,8 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
     },
   });
   const input = create_turn_input(model, [{
-    id: "old-user",
     role: "user",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "compact-runner-session",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "history before compact" }],
+    content: [{ type: "text", text: "history before compact" }],
   }]);
   input.turn_context = create_session_turn_context({
     session_id: "compact-runner-session",
@@ -214,7 +178,10 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
       return requested;
     },
   });
-  input.reload_history = async () => compacted_records;
+  input.reload_history = async () => ({
+    messages: compacted_messages,
+    summary_id: "summary-reloaded",
+  });
 
   const result = await runner.execute(input);
 
@@ -226,7 +193,7 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
 
 test("Provider context-length error 在当前 tool-loop 内 deep compact 后重试", async () => {
   let provider_calls = 0;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "context-error-model",
     doStream: async () => {
       provider_calls += 1;
@@ -236,16 +203,8 @@ test("Provider context-length error 在当前 tool-loop 内 deep compact 后重
   });
   const result = await create_context_error_runner().execute(
     create_turn_input(model, [{
-      id: "user-1",
       role: "user",
-      metadata: {
-        v: 1,
-        ts: 1,
-        session_id: "compact-runner-session",
-        source: "ingress",
-        kind: "normal",
-      },
-      parts: [{ type: "text", text: "latest request" }],
+      content: [{ type: "text", text: "latest request" }],
     }]),
   );
   assert.equal(result.success, true);
@@ -256,15 +215,15 @@ test("Provider context-length error 在当前 tool-loop 内 deep compact 后重
 test("deep compact 删除 reasoning，并完整保留最新并行 tool transaction", () => {
   const large_output = "tool-output-".repeat(8_000);
   const messages = [
-    { role: "user", content: "older request" },
+    { role: "user", content: [{ type: "text", text: "older request" }] },
     {
       role: "assistant",
       content: [
         { type: "reasoning", text: "old reasoning".repeat(2_000) },
         {
-          type: "tool-call",
-          toolCallId: "old-call",
-          toolName: "old_tool",
+          type: "tool_call",
+          tool_call_id: "old-call",
+          tool_name: "old_tool",
           input: { query: "old" },
         },
       ],
@@ -273,40 +232,36 @@ test("deep compact 删除 reasoning，并完整保留最新并行 tool transacti
       role: "tool",
       content: [
         {
-          type: "tool-result",
-          toolCallId: "old-call",
-          toolName: "old_tool",
-          output: { type: "text", value: large_output },
+          type: "tool_result",
+          tool_call_id: "old-call",
+          tool_name: "old_tool",
+          outcome: "succeeded",
+          content: [{ type: "text", text: large_output }],
         },
       ],
     },
-    { role: "user", content: "latest request" },
+    { role: "user", content: [{ type: "text", text: "latest request" }] },
     {
       role: "assistant",
       content: [
         {
           type: "reasoning",
           text: "latest reasoning".repeat(2_000),
-          providerOptions: { openai: { itemId: "rs_latest" } },
         },
         {
           type: "text",
           text: "running tools",
-          providerOptions: {
-            openai: { itemId: "msg_latest", phase: "final_answer" },
-          },
         },
         {
-          type: "tool-call",
-          toolCallId: "call-a",
-          toolName: "tool_a",
+          type: "tool_call",
+          tool_call_id: "call-a",
+          tool_name: "tool_a",
           input: { value: "a" },
-          providerOptions: { openai: { itemId: "fc_a" } },
         },
         {
-          type: "tool-call",
-          toolCallId: "call-b",
-          toolName: "tool_b",
+          type: "tool_call",
+          tool_call_id: "call-b",
+          tool_name: "tool_b",
           input: { value: "b" },
         },
       ],
@@ -315,17 +270,18 @@ test("deep compact 删除 reasoning，并完整保留最新并行 tool transacti
       role: "tool",
       content: [
         {
-          type: "tool-result",
-          toolCallId: "call-a",
-          toolName: "tool_a",
-          output: { type: "text", value: large_output },
-          providerOptions: { openai: { resultId: "result_a" } },
+          type: "tool_result",
+          tool_call_id: "call-a",
+          tool_name: "tool_a",
+          outcome: "succeeded",
+          content: [{ type: "text", text: large_output }],
         },
         {
-          type: "tool-result",
-          toolCallId: "call-b",
-          toolName: "tool_b",
-          output: { type: "json", value: { large_output } },
+          type: "tool_result",
+          tool_call_id: "call-b",
+          tool_name: "tool_b",
+          outcome: "succeeded",
+          content: [{ type: "json", value: { large_output } }],
         },
       ],
     },
@@ -349,9 +305,9 @@ test("deep compact 删除 reasoning，并完整保留最新并行 tool transacti
   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.toolCallId);
-      if (part.type === "tool-result") tool_result_ids.add(part.toolCallId);
-      if (part.type === "tool-call" || part.type === "tool-result") {
+      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));
       }
     }
@@ -376,39 +332,35 @@ test("单条 assistant 含大量 parts 时也会在消息内部折叠", () => {
   assert.ok(JSON.stringify(compacted).length < JSON.stringify(messages).length / 4);
 });
 
-test("tool approval request/response 与对应 call 一起保留且不产生孤儿", () => {
+test("最新工具调用与工具结果一起保留且不产生孤儿", () => {
   const compacted = deep_compact_model_messages([
-    { role: "user", content: "approve the operation" },
+    { role: "user", content: [{ type: "text", text: "run the operation" }] },
     {
       role: "assistant",
       content: [
         {
-          type: "tool-call",
-          toolCallId: "approval-call",
-          toolName: "dangerous_tool",
+          type: "tool_call",
+          tool_call_id: "operation-call",
+          tool_name: "operation_tool",
           input: { path: "/tmp/example" },
         },
-        {
-          type: "tool-approval-request",
-          toolCallId: "approval-call",
-          approvalId: "approval-1",
-        },
       ],
     },
     {
       role: "tool",
       content: [
         {
-          type: "tool-approval-response",
-          approvalId: "approval-1",
-          approved: true,
-          providerExecuted: true,
+          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('"toolCallId":"approval-call"'), true);
-  assert.equal(serialized.includes('"approvalId":"approval-1"'), true);
-  assert.equal(serialized.includes('"approved":true'), true);
+  assert.equal(serialized.includes('"tool_call_id":"operation-call"'), true);
+  assert.equal(serialized.includes('"outcome":"succeeded"'), true);
+  assert.equal(serialized.includes('"changed":true'), true);
 });

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

@@ -0,0 +1,87 @@
+/**
+ * @file 验证 Downcity 模型事件写入失败会终止当前 model step。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { run_model_step } from "../bin/executor/model/ModelStepRunner.js";
+
+test("模型事件写入 canonical Session 失败时拒绝继续完成 turn", async () => {
+  const abort_controller = new AbortController();
+  const model = {
+    id: "projection-failure-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: "request_1",
+            model_id: "projection-failure-model",
+          });
+          controller.enqueue({ type: "text_start", content_id: "text_1" });
+          controller.enqueue({ type: "text_delta", content_id: "text_1", delta: "partial" });
+          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();
+        },
+      });
+    },
+  };
+
+  await assert.rejects(
+    run_model_step({
+      model,
+      system: [],
+      messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+      tools: {},
+      abort_signal: abort_controller.signal,
+      assistant_output: {
+        write_model_event: async () => {
+          throw new Error("canonical write failed");
+        },
+      },
+    }),
+    /canonical write failed/,
+  );
+});
+
+test("Agent 拒绝不合法的 Downcity 模型流状态", async () => {
+  const invalid_event_sets = [
+    [{ type: "text_delta", content_id: "text_1", delta: "orphan" }],
+    [
+      { type: "model_start", request_id: "request_1", model_id: "invalid-model" },
+      { type: "tool_call_finish", content_id: "tool_1", input: {} },
+    ],
+    [
+      { type: "model_start", request_id: "request_1", model_id: "invalid-model" },
+      { type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } },
+      { type: "model_finish", finish_reason: "tool_call" },
+    ],
+  ];
+
+  for (const events of invalid_event_sets) {
+    const model = {
+      id: "invalid-model",
+      async stream() {
+        return new ReadableStream({
+          start(controller) {
+            for (const event of events) controller.enqueue(event);
+            controller.close();
+          },
+        });
+      },
+    };
+    await assert.rejects(run_model_step({
+      model,
+      system: [],
+      messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+      tools: {},
+      abort_signal: new AbortController().signal,
+    }), /Invalid Downcity model stream/);
+  }
+});

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

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { MockLanguageModelV3 } from "ai/test";
+import { MockModelClient } from "./ModelClientMock.mjs";
 
 import { CoreEngineRunner } from "../bin/executor/core-engine/CoreEngineRunner.js";
 import { ExecutorRecoveryPolicy } from "../bin/executor/services/ExecutorRecoveryPolicy.js";
@@ -42,28 +42,20 @@ function create_text_stream(text) {
 
 function create_execution_input(model, turn_context) {
   const messages = [{
-    id: "user-1",
     role: "user",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "executor-failure-test",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "hello" }],
+    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,
+    reload_history: async () => ({ messages }),
   };
 }
 
 test("CoreEngine Provider 失败时只返回结构化错误", async () => {
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "failing-model",
     doStream: async () => {
       throw new Error("quota exceeded");
@@ -75,16 +67,8 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
     should_compact_on_error: () => false,
   });
   const messages = [{
-    id: "user-1",
     role: "user",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "executor-failure-test",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "hello" }],
+    content: [{ type: "text", text: "hello" }],
   }];
 
   const result = await runner.execute({
@@ -92,7 +76,7 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
     model,
     turn_context: create_turn_context(),
     resolve_step_inputs: async () => ({ model, system: [], tools: {} }),
-    reload_history: async () => messages,
+    reload_history: async () => ({ messages }),
   });
 
   assert.equal(result.success, false);
@@ -102,7 +86,7 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
 
 test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", async () => {
   const events = [];
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "canonical-step-model",
     doStream: async () => create_text_stream("done"),
   });
@@ -116,9 +100,9 @@ test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", as
     create_turn_context({
       assistant_output: {
         begin_step: async () => events.push("start"),
-        write_chunk: async (chunk) => events.push(chunk.type),
-        finish_step: async (message) => {
-          events.push(`finish:${message.parts.map((part) => part.type).join(",")}`);
+        write_model_event: async (event) => events.push(event.type),
+        finish_step: async (parts) => {
+          events.push(`finish:${parts.map((part) => part.type).join(",")}`);
         },
         abort_step: async () => events.push("abort"),
       },
@@ -127,14 +111,14 @@ test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", as
 
   assert.equal(result.success, true);
   assert.equal(events[0], "start");
-  assert.equal(events.includes("text-delta"), true);
+  assert.equal(events.includes("text_delta"), true);
   assert.match(events.at(-1), /^finish:/);
   assert.equal(events.includes("abort"), false);
 });
 
 test("CoreEngine chunk 写入失败时中止 canonical step", async () => {
   const events = [];
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "canonical-step-failure-model",
     doStream: async () => create_text_stream("partial"),
   });
@@ -148,7 +132,7 @@ test("CoreEngine chunk 写入失败时中止 canonical step", async () => {
     create_turn_context({
       assistant_output: {
         begin_step: async () => events.push("start"),
-        write_chunk: async () => {
+        write_model_event: async () => {
           throw new Error("canonical write failed");
         },
         finish_step: async () => events.push("finish"),

package/scripts/file-tools.test.mjs

@@ -12,7 +12,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { Workspace } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
 
 async function create_fixture(t) {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-file-tools-"));
@@ -24,7 +24,7 @@ async function create_fixture(t) {
   return {
     root_path,
     outside_path,
-    tools: new Workspace({ path: root_path }).tools,
+    tools: new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }).tools,
   };
 }
 
@@ -36,9 +36,9 @@ async function execute_action_tool(tools, name, input) {
   const execute = tools[name]?.execute;
   assert.equal(typeof execute, "function", `${name} tool must be executable`);
   return await execute(input, {
-    toolCallId: `test-${name}`,
+    tool_call_id: `test-${name}`,
     messages: [],
-    abortSignal: new AbortController().signal,
+    abort_signal: new AbortController().signal,
   });
 }
 
@@ -139,7 +139,7 @@ test("read returns images as next-step User File Parts", async (t) => {
     parts: [{
       type: "file",
       url: result.output.file_path,
-      mediaType: "image/png",
+      media_type: "image/png",
       filename: "input.bin",
     }],
   }]);
@@ -163,7 +163,7 @@ test("read returns PDFs as next-step User File Parts", async (t) => {
     parts: [{
       type: "file",
       url: result.output.file_path,
-      mediaType: "application/pdf",
+      media_type: "application/pdf",
       filename: "document.pdf",
     }],
   }]);