@downcity/agent 1.1.287 → 1.1.310

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

@@ -13,6 +13,7 @@ import {
   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";
 
 function create_stream_text_result(text, input_tokens, output_tokens) {
   return {
@@ -62,7 +63,7 @@ function create_context_error_runner() {
   });
 }
 
-function create_run_input(model, messages, context_window = 100) {
+function create_turn_input(model, messages, context_window = 100) {
   return {
     execute_input: {
       query: "latest request",
@@ -71,12 +72,10 @@ function create_run_input(model, messages, context_window = 100) {
       tools: {},
     },
     model,
-    run_context: {
-      sessionId: "compact-runner-session",
-      injectedUserMessages: [],
-      deferredPersistedUserMessages: [],
-      pendingAssistantFileParts: [],
-    },
+    turn_context: create_session_turn_context({
+      session_id: "compact-runner-session",
+      turn_id: "compact-runner-turn",
+    }),
     resolve_step_inputs: async () => ({
       model,
       system: [],
@@ -111,18 +110,18 @@ test("普通调用使用 95% 触发，compact 验收使用 50% 目标", () => {
   assert.equal(should_compact_after_usage(0.5001, true), true);
 });
 
-test("最终 step 达到 95% 时通过 run result 请求 writer 收口后持久化 compact", async () => {
+test("最终 Step 达到 95% 时通过 Turn 结果请求 writer 收口后持久化 compact", async () => {
   const model = new MockLanguageModelV3({
     modelId: "usage-trigger-model",
     doStream: async () => create_stream_text_result("done", 90, 5),
   });
-  const result = await create_runner().run(create_run_input(model, [{
+  const result = await create_runner().execute(create_turn_input(model, [{
     id: "user-1",
     role: "user",
     metadata: {
       v: 1,
       ts: 1,
-      sessionId: "compact-runner-session",
+      session_id: "compact-runner-session",
       source: "ingress",
       kind: "normal",
     },
@@ -144,7 +143,7 @@ test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
     metadata: {
       v: 1,
       ts: 1,
-      sessionId: "compact-runner-session",
+      session_id: "compact-runner-session",
       source: "compact",
       kind: "summary",
     },
@@ -155,14 +154,14 @@ test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
     metadata: {
       v: 1,
       ts: 2,
-      sessionId: "compact-runner-session",
+      session_id: "compact-runner-session",
       source: "ingress",
       kind: "normal",
     },
     parts: [{ type: "text", text: "latest request" }],
   }];
-  const first = await runner.run(create_run_input(model, messages));
-  const second = await runner.run(create_run_input(model, messages));
+  const first = await runner.execute(create_turn_input(model, messages));
+  const second = await runner.execute(create_turn_input(model, messages));
   assert.equal(first.compact_required, true);
   assert.equal(second.compact_required, undefined);
 });
@@ -175,7 +174,7 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
     metadata: {
       v: 1,
       ts: 2,
-      sessionId: "compact-runner-session",
+      session_id: "compact-runner-session",
       source: "compact",
       kind: "summary",
     },
@@ -194,26 +193,30 @@ test("显式 compact 后在下一次 provider 调用前重载 canonical history"
       return create_stream_text_result("done", 20, 5);
     },
   });
-  const input = create_run_input(model, [{
+  const input = create_turn_input(model, [{
     id: "old-user",
     role: "user",
     metadata: {
       v: 1,
       ts: 1,
-      sessionId: "compact-runner-session",
+      session_id: "compact-runner-session",
       source: "ingress",
       kind: "normal",
     },
     parts: [{ type: "text", text: "history before compact" }],
   }]);
-  input.run_context.consume_history_reload = () => {
-    const requested = reload_requested;
-    reload_requested = false;
-    return requested;
-  };
+  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 () => compacted_records;
 
-  const result = await runner.run(input);
+  const result = await runner.execute(input);
 
   assert.equal(result.success, true);
   assert.equal(provider_prompts.length, 1);
@@ -231,14 +234,14 @@ test("Provider context-length error 在当前 tool-loop 内 deep compact 后重
       return create_stream_text_result("recovered", 40, 5);
     },
   });
-  const result = await create_context_error_runner().run(
-    create_run_input(model, [{
+  const result = await create_context_error_runner().execute(
+    create_turn_input(model, [{
       id: "user-1",
       role: "user",
       metadata: {
         v: 1,
         ts: 1,
-        sessionId: "compact-runner-session",
+        session_id: "compact-runner-session",
         source: "ingress",
         kind: "normal",
       },

package/scripts/core-engine-ui-stream-collector.test.mjs

@@ -5,7 +5,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { collectFinalAssistantMessageFromUiStream } from "../bin/executor/core-engine/CoreEngineUiStreamCollector.js";
+import { collect_final_assistant_message_from_ui_stream } from "../bin/executor/core-engine/CoreEngineUiStreamCollector.js";
 
 test("canonical message chunk 写入失败时拒绝继续完成 turn", async () => {
   const abort_controller = new AbortController();
@@ -19,9 +19,9 @@ test("canonical message chunk 写入失败时拒绝继续完成 turn", async ()
   };
 
   await assert.rejects(
-    collectFinalAssistantMessageFromUiStream({
+    collect_final_assistant_message_from_ui_stream({
       result,
-      sessionId: "callback-failure-test",
+      session_id: "callback-failure-test",
       abortSignal: abort_controller.signal,
       logger: { log: async () => {} },
       buildFallbackAssistantMessage: (text) => ({
@@ -29,7 +29,7 @@ test("canonical message chunk 写入失败时拒绝继续完成 turn", async ()
         role: "assistant",
         parts: [{ type: "text", text }],
       }),
-      onUiMessageChunkCallback: async () => {
+      on_ui_message_chunk_callback: async () => {
         throw new Error("canonical write failed");
       },
     }),

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

@@ -8,15 +8,14 @@ import { MockLanguageModelV3 } from "ai/test";
 
 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";
 
-function create_run_context(overrides = {}) {
-  return {
-    sessionId: "executor-failure-test",
-    injectedUserMessages: [],
-    deferredPersistedUserMessages: [],
-    pendingAssistantFileParts: [],
+function create_turn_context(overrides = {}) {
+  return create_session_turn_context({
+    session_id: "executor-failure-test",
+    turn_id: "executor-failure-turn",
     ...overrides,
-  };
+  });
 }
 
 function create_text_stream(text) {
@@ -41,14 +40,14 @@ function create_text_stream(text) {
   };
 }
 
-function create_runner_input(model, run_context) {
+function create_execution_input(model, turn_context) {
   const messages = [{
     id: "user-1",
     role: "user",
     metadata: {
       v: 1,
       ts: 1,
-      sessionId: "executor-failure-test",
+      session_id: "executor-failure-test",
       source: "ingress",
       kind: "normal",
     },
@@ -57,7 +56,7 @@ function create_runner_input(model, run_context) {
   return {
     execute_input: { query: "hello", system: [], messages, tools: {} },
     model,
-    run_context,
+    turn_context,
     resolve_step_inputs: async () => ({ model, system: [], tools: {} }),
     reload_history: async () => messages,
   };
@@ -81,24 +80,24 @@ test("CoreEngine Provider 失败时只返回结构化错误", async () => {
     metadata: {
       v: 1,
       ts: 1,
-      sessionId: "executor-failure-test",
+      session_id: "executor-failure-test",
       source: "ingress",
       kind: "normal",
     },
     parts: [{ type: "text", text: "hello" }],
   }];
 
-  const result = await runner.run({
+  const result = await runner.execute({
     execute_input: { query: "hello", system: [], messages, tools: {} },
     model,
-    run_context: create_run_context(),
+    turn_context: create_turn_context(),
     resolve_step_inputs: async () => ({ model, system: [], tools: {} }),
     reload_history: async () => messages,
   });
 
   assert.equal(result.success, false);
   assert.match(result.error, /quota exceeded/);
-  assert.equal(result.assistantMessage, undefined);
+  assert.equal(result.text, "");
 });
 
 test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", async () => {
@@ -112,15 +111,17 @@ test("CoreEngine 成功流按 start、chunks、finish 完成 canonical step", as
     logger: { log: async () => {} },
     should_compact_on_error: () => false,
   });
-  const result = await runner.run(create_runner_input(
+  const result = await runner.execute(create_execution_input(
     model,
-    create_run_context({
-      on_ui_message_step_start: async () => events.push("start"),
-      onUiMessageChunkCallback: async (chunk) => events.push(chunk.type),
-      on_ui_message_step_finish: async (message) => {
-        events.push(`finish:${message.parts.map((part) => part.type).join(",")}`);
+    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(",")}`);
+        },
+        abort_step: async () => events.push("abort"),
       },
-      on_ui_message_step_abort: async () => events.push("abort"),
     }),
   ));
 
@@ -142,15 +143,17 @@ test("CoreEngine chunk 写入失败时中止 canonical step", async () => {
     logger: { log: async () => {} },
     should_compact_on_error: () => false,
   });
-  const result = await runner.run(create_runner_input(
+  const result = await runner.execute(create_execution_input(
     model,
-    create_run_context({
-      on_ui_message_step_start: async () => events.push("start"),
-      onUiMessageChunkCallback: async () => {
-        throw new Error("canonical write failed");
+    create_turn_context({
+      assistant_output: {
+        begin_step: async () => events.push("start"),
+        write_chunk: async () => {
+          throw new Error("canonical write failed");
+        },
+        finish_step: async () => events.push("finish"),
+        abort_step: async () => events.push("abort"),
       },
-      on_ui_message_step_finish: async () => events.push("finish"),
-      on_ui_message_step_abort: async () => events.push("abort"),
     }),
   ));
 
@@ -165,20 +168,20 @@ test("恢复策略捕获普通异常后只返回结构化错误", async () => {
     logger: { log: async () => {} },
     should_compact: () => false,
   });
-  const run_context = create_run_context();
-  const result = await policy.run_with_retry({
+  const turn_context = create_turn_context();
+  const result = await policy.execute_with_retry({
     query: "hello",
     model: {},
-    run_context,
+    turn_context,
     prepare_execute_input: async () => {
       throw new Error("configuration failed");
     },
-    execute_prepared_run: async () => {
+    execute_prepared_input: async () => {
       throw new Error("unexpected execution");
     },
   });
 
   assert.equal(result.success, false);
   assert.match(result.error, /configuration failed/);
-  assert.equal(result.assistantMessage, undefined);
+  assert.equal(result.assistant_message, undefined);
 });

package/scripts/file-tools.test.mjs

@@ -0,0 +1,282 @@
+/**
+ * @file 验证 Workspace 可装配的结构化文件工具。
+ *
+ * 关键点（中文）
+ * - 覆盖读取分页、二进制识别、原子写入和精确编辑。
+ * - 覆盖项目根目录边界、符号链接逃逸和并发 hash 保护。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { Workspace } from "@downcity/agent";
+
+async function create_fixture(t) {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-file-tools-"));
+  const outside_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-file-tools-outside-"));
+  t.after(async () => {
+    await fs.rm(root_path, { recursive: true, force: true });
+    await fs.rm(outside_path, { recursive: true, force: true });
+  });
+  return {
+    root_path,
+    outside_path,
+    tools: new Workspace({ path: root_path }).tools,
+  };
+}
+
+async function execute_tool(tools, name, input) {
+  return (await execute_action_tool(tools, name, input)).output;
+}
+
+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}`,
+    messages: [],
+    abortSignal: new AbortController().signal,
+  });
+}
+
+test("write creates parents and read paginates text with a stable hash", async (t) => {
+  const fixture = await create_fixture(t);
+  const written = await execute_tool(fixture.tools, "write", {
+    file_path: "nested/example.txt",
+    content: "first\r\nsecond\r\nthird\r\nfourth\r\n",
+  });
+  assert.equal(written.success, true);
+  assert.equal(written.overwritten, false);
+  assert.equal(written.lines_written, 4);
+  assert.equal(
+    await fs.readFile(path.join(fixture.root_path, "nested/example.txt"), "utf8"),
+    "first\nsecond\nthird\nfourth\n",
+  );
+
+  const first_page = await execute_tool(fixture.tools, "read", {
+    file_path: "nested/example.txt",
+    limit: 2,
+  });
+  assert.equal(first_page.success, true);
+  assert.equal(first_page.content, "first\nsecond");
+  assert.equal(first_page.total_lines, 4);
+  assert.equal(first_page.start_line, 0);
+  assert.equal(first_page.end_line, 1);
+  assert.equal(first_page.truncated, true);
+  assert.equal(first_page.next_offset, 2);
+  assert.match(first_page.sha256, /^[a-f0-9]{64}$/);
+
+  const second_page = await execute_tool(fixture.tools, "read", {
+    file_path: "nested/example.txt",
+    offset: first_page.next_offset,
+    limit: 2,
+  });
+  assert.equal(second_page.success, true);
+  assert.equal(second_page.content, "third\nfourth");
+  assert.equal(second_page.truncated, false);
+});
+
+test("write rejects implicit overwrite and preserves file permissions", async (t) => {
+  const fixture = await create_fixture(t);
+  const file_path = path.join(fixture.root_path, "mode.txt");
+  await fs.writeFile(file_path, "before\n", { mode: 0o640 });
+
+  const rejected = await execute_tool(fixture.tools, "write", {
+    file_path: "mode.txt",
+    content: "after\n",
+  });
+  assert.equal(rejected.success, false);
+  assert.equal(rejected.error_code, "file_exists");
+  assert.equal(await fs.readFile(file_path, "utf8"), "before\n");
+
+  const replaced = await execute_tool(fixture.tools, "write", {
+    file_path: "mode.txt",
+    content: "after\n",
+    overwrite: true,
+  });
+  assert.equal(replaced.success, true);
+  assert.equal(replaced.overwritten, true);
+  assert.equal((await fs.stat(file_path)).mode & 0o777, 0o640);
+  assert.equal(await fs.readFile(file_path, "utf8"), "after\n");
+});
+
+test("read identifies binary files without returning raw bytes", async (t) => {
+  const fixture = await create_fixture(t);
+  await fs.writeFile(
+    path.join(fixture.root_path, "image.png"),
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0x01, 0x02]),
+  );
+  const result = await execute_tool(fixture.tools, "read", {
+    file_path: "image.png",
+  });
+  assert.equal(result.success, true);
+  assert.equal(result.type, "binary");
+  assert.equal(result.mime_type, "image/png");
+  assert.equal(result.content, "");
+  assert.equal(result.total_lines, 0);
+});
+
+test("read returns images as next-step User File Parts", async (t) => {
+  const fixture = await create_fixture(t);
+  const image = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+    0x00, 0x01, 0x02, 0x03,
+  ]);
+  await fs.writeFile(path.join(fixture.root_path, "input.bin"), image);
+
+  const result = await execute_action_tool(fixture.tools, "read", {
+    file_path: "input.bin",
+  });
+  assert.equal(result.output.success, true);
+  assert.equal(result.output.type, "image");
+  assert.equal(result.output.mime_type, "image/png");
+  assert.equal(result.output.content, "");
+  assert.deepEqual(result.messages, [{
+    role: "user",
+    parts: [{
+      type: "file",
+      url: result.output.file_path,
+      mediaType: "image/png",
+      filename: "input.bin",
+    }],
+  }]);
+});
+
+test("read returns PDFs as next-step User File Parts", async (t) => {
+  const fixture = await create_fixture(t);
+  await fs.writeFile(
+    path.join(fixture.root_path, "document.pdf"),
+    Buffer.from("%PDF-1.7\n% binary\u0000content", "utf8"),
+  );
+
+  const result = await execute_action_tool(fixture.tools, "read", {
+    file_path: "document.pdf",
+  });
+  assert.equal(result.output.success, true);
+  assert.equal(result.output.type, "binary");
+  assert.equal(result.output.mime_type, "application/pdf");
+  assert.deepEqual(result.messages, [{
+    role: "user",
+    parts: [{
+      type: "file",
+      url: result.output.file_path,
+      mediaType: "application/pdf",
+      filename: "document.pdf",
+    }],
+  }]);
+});
+
+test("file tools reject project escapes and symbolic-link escapes", async (t) => {
+  const fixture = await create_fixture(t);
+  const direct_escape = await execute_tool(fixture.tools, "write", {
+    file_path: path.join(fixture.outside_path, "escape.txt"),
+    content: "blocked",
+  });
+  assert.equal(direct_escape.success, false);
+  assert.equal(direct_escape.error_code, "sandbox_denied");
+
+  await fs.symlink(fixture.outside_path, path.join(fixture.root_path, "outside-link"));
+  const symlink_escape = await execute_tool(fixture.tools, "write", {
+    file_path: "outside-link/escape.txt",
+    content: "blocked",
+  });
+  assert.equal(symlink_escape.success, false);
+  assert.equal(symlink_escape.error_code, "sandbox_denied");
+  await assert.rejects(fs.access(path.join(fixture.outside_path, "escape.txt")));
+});
+
+test("edit applies multiple exact replacements atomically and preserves CRLF", async (t) => {
+  const fixture = await create_fixture(t);
+  const file_path = path.join(fixture.root_path, "edit.txt");
+  await fs.writeFile(file_path, "alpha\r\nvalue = 1\r\nomega\r\n", "utf8");
+  const before = await execute_tool(fixture.tools, "read", {
+    file_path: "edit.txt",
+  });
+  assert.equal(before.success, true);
+
+  const edited = await execute_tool(fixture.tools, "edit", {
+    file_path: "edit.txt",
+    expected_sha256: before.sha256,
+    edits: [
+      { old_text: "value = 1", new_text: "value = 2" },
+      { old_text: "omega", new_text: "done\nnext" },
+    ],
+  });
+  assert.equal(edited.success, true);
+  assert.equal(edited.applied, 2);
+  assert.equal(edited.new_total_lines, 4);
+  assert.equal(
+    await fs.readFile(file_path, "utf8"),
+    "alpha\r\nvalue = 2\r\ndone\r\nnext\r\n",
+  );
+});
+
+test("edit rejects duplicate, overlapping, and stale operations without writes", async (t) => {
+  const fixture = await create_fixture(t);
+  const file_path = path.join(fixture.root_path, "guarded.txt");
+  await fs.writeFile(file_path, "abc abc def\n", "utf8");
+
+  const duplicate = await execute_tool(fixture.tools, "edit", {
+    file_path: "guarded.txt",
+    edits: [{ old_text: "abc", new_text: "x" }],
+  });
+  assert.equal(duplicate.success, false);
+  assert.equal(duplicate.error_code, "duplicate_match");
+  assert.equal(await fs.readFile(file_path, "utf8"), "abc abc def\n");
+
+  await fs.writeFile(file_path, "abcdef\n", "utf8");
+  const before = await execute_tool(fixture.tools, "read", {
+    file_path: "guarded.txt",
+  });
+  assert.equal(before.success, true);
+  const overlapping = await execute_tool(fixture.tools, "edit", {
+    file_path: "guarded.txt",
+    edits: [
+      { old_text: "abc", new_text: "x" },
+      { old_text: "bcd", new_text: "y" },
+    ],
+  });
+  assert.equal(overlapping.success, false);
+  assert.equal(overlapping.error_code, "overlapping_edits");
+  assert.equal(await fs.readFile(file_path, "utf8"), "abcdef\n");
+
+  await fs.writeFile(file_path, "changed\n", "utf8");
+  const stale = await execute_tool(fixture.tools, "edit", {
+    file_path: "guarded.txt",
+    expected_sha256: before.sha256,
+    edits: [{ old_text: "changed", new_text: "overwritten" }],
+  });
+  assert.equal(stale.success, false);
+  assert.equal(stale.error_code, "file_changed");
+  assert.equal(await fs.readFile(file_path, "utf8"), "changed\n");
+});
+
+test("edit preserves UTF-16LE encoding and BOM", async (t) => {
+  const fixture = await create_fixture(t);
+  const file_path = path.join(fixture.root_path, "utf16.txt");
+  const original = Buffer.concat([
+    Buffer.from([0xff, 0xfe]),
+    Buffer.from("hello\r\n", "utf16le"),
+  ]);
+  await fs.writeFile(file_path, original);
+
+  const read_result = await execute_tool(fixture.tools, "read", {
+    file_path: "utf16.txt",
+  });
+  assert.equal(read_result.success, true);
+  assert.equal(read_result.encoding, "utf-16le");
+  assert.equal(read_result.content, "hello");
+
+  const edit_result = await execute_tool(fixture.tools, "edit", {
+    file_path: "utf16.txt",
+    expected_sha256: read_result.sha256,
+    edits: [{ old_text: "hello", new_text: "world" }],
+  });
+  assert.equal(edit_result.success, true);
+  const next_buffer = await fs.readFile(file_path);
+  assert.deepEqual([...next_buffer.subarray(0, 2)], [0xff, 0xfe]);
+  assert.equal(next_buffer.subarray(2).toString("utf16le"), "world\r\n");
+});