@downcity/agent 1.1.408 → 1.1.437

package/scripts/agent-store.test.mjs

@@ -1,182 +0,0 @@
-/**
- * @file 验证 SessionStore / SessionDataStore 的领域边界与本地实现契约。
- */
-
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { Agent } from "../bin/index.js";
-import { create_workspace_entry } from "../bin/internal/index.js";
-import { Workspace } from "@downcity/workspace";
-import { LocalStorageProvider } from "@downcity/workspace";
-import { LocalSessionStore } from "../bin/workspace/store/LocalSessionStore.js";
-
-/** 由 Agent 领域在 City 提供的 Agent 作用域上创建 SessionStore。 */
-function create_agent_storage(storage, agent_id, workspace_id = "test_workspace") {
-  const scope = storage.open_scope([
-    "agents",
-    agent_id,
-  ]);
-  return {
-    root_path: scope.root_path,
-    files: scope.files,
-    sessions: new LocalSessionStore({
-      files: scope.files,
-      storage_root_path: scope.root_path,
-      agent_id,
-      workspace_id,
-    }),
-  };
-}
-
-async function create_test_roots(t) {
-  const parent_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-store-"));
-  const workspace_path = path.join(parent_path, "workspace");
-  const data_root_path = path.join(parent_path, "platform");
-  await fs.mkdir(workspace_path);
-  t.after(async () => await fs.rm(parent_path, { recursive: true, force: true }));
-  return { data_root_path, workspace_path };
-}
-
-test("Agent creates SessionStore on the Agent storage scope", async (t) => {
-  const { data_root_path, workspace_path } = await create_test_roots(t);
-  const workspace = new Workspace({
-    id: "test_workspace",
-    path: workspace_path,
-  });
-  const storage = create_agent_storage(new LocalStorageProvider(data_root_path), "store-test");
-  const store = storage.sessions;
-  const session_store = store.session("first");
-
-  assert.equal(store.session("first"), session_store);
-  assert.equal(await store.has_session("first"), false);
-
-  await session_store.messages.initialize();
-  await session_store.write_metadata({
-    v: 1,
-    session_id: "first",
-    agent_id: "store-test",
-    workspace_id: "test_workspace",
-    created_at: 1,
-    updated_at: 1,
-    title: "独立存储",
-  });
-  await session_store.write_instruction("");
-
-  assert.equal(await store.has_session("first"), true);
-  assert.equal((await session_store.read_metadata()).title, "独立存储");
-  assert.equal(await session_store.has_instruction(), true);
-  assert.equal(await session_store.read_instruction(), "");
-  const tool_result = await storage.files.run_file_action({
-    action: "read",
-    input: {
-      file_path: "sessions/first/meta.json",
-    },
-  });
-  assert.equal(tool_result.success, true);
-  assert.match(tool_result.success ? tool_result.content : "", /独立存储/);
-  assert.equal(await fs.access(path.join(workspace_path, ".downcity")).then(() => true).catch(() => false), false);
-  assert.equal((await fs.stat(storage.root_path)).mode & 0o777, 0o700);
-  assert.equal(
-    (await fs.stat(path.join(storage.root_path, "sessions", "first", "meta.json"))).mode & 0o777,
-    0o600,
-  );
-
-  assert.equal(await store.clear_session_messages("first"), true);
-  assert.equal((await store.session("first").read_metadata()).title, "独立存储");
-  assert.equal(await store.has_session("first"), true);
-  assert.equal(await store.remove_session("first"), true);
-  assert.equal(await store.has_session("first"), false);
-});
-
-test("LocalSessionStore archives and cleans sessions", async (t) => {
-  const { data_root_path, workspace_path } = await create_test_roots(t);
-  const workspace = new Workspace({
-    id: "test_workspace",
-    path: workspace_path,
-  });
-  const store = create_agent_storage(new LocalStorageProvider(data_root_path), "archive-test").sessions;
-  const archived_store = store.session("archived");
-  await archived_store.messages.initialize();
-  await archived_store.write_metadata({
-    v: 1,
-    session_id: "archived",
-    agent_id: "archive-test",
-    workspace_id: "test_workspace",
-    updated_at: 1,
-  });
-
-  const archived = await store.archive_session("archived");
-  assert.equal(archived.session_id, "archived");
-  assert.equal((await store.list_archived_sessions()).items[0]?.session_id, "archived");
-  assert.deepEqual((await store.clean_archive()).removed_session_ids, ["archived"]);
-  assert.equal((await store.list_archived_sessions()).items.length, 0);
-});
-
-test("LocalSessionStore 按 Workspace 隔离活动与归档 Session", async (t) => {
-  const { data_root_path, workspace_path } = await create_test_roots(t);
-  const store = create_agent_storage(new LocalStorageProvider(data_root_path), "workspace-filter-test", null).sessions;
-
-  for (const [session_id, workspace_id] of [["first", "workspace-first"], ["second", "workspace-second"]]) {
-    const session_store = store.session(session_id, workspace_id);
-    await session_store.messages.initialize();
-    await session_store.write_metadata({
-      v: 1,
-      session_id,
-      agent_id: "workspace-filter-test",
-      workspace_id,
-      updated_at: 1,
-    });
-  }
-
-  assert.deepEqual(
-    (await store.list_sessions({ workspace_id: "workspace-first" }, new Set())).items.map((item) => item.session_id),
-    ["first"],
-  );
-  assert.deepEqual(
-    (await store.list_sessions({ workspace_id: "workspace-missing" }, new Set())).items,
-    [],
-  );
-
-  await store.archive_session("first");
-  assert.deepEqual(
-    (await store.list_archived_sessions({ workspace_id: "workspace-first" })).items.map((item) => item.session_id),
-    ["first"],
-  );
-  assert.deepEqual(
-    (await store.list_archived_sessions({ workspace_id: "workspace-second" })).items,
-    [],
-  );
-});
-
-test("Workspace execution entry obtains its Store from the Agent storage scope", async (t) => {
-  const { data_root_path, workspace_path } = await create_test_roots(t);
-  const workspace = new Workspace({
-    id: "test_workspace",
-    path: workspace_path,
-    data_root_path,
-  });
-  const agent = new Agent({ id: "dispose-test" });
-  const entry = create_workspace_entry(agent, workspace);
-
-  assert.equal(entry.workspace, workspace);
-  const first_session = await entry.sessions.create();
-  assert.ok(first_session.id);
-  await agent.dispose();
-});
-
-test("Agent sessions runtime 只解析已加载的 Session", async () => {
-  const agent = new Agent({ id: "runtime-lookup-test" });
-  try {
-    assert.throws(
-      () => agent.sessions.runtime("missing-session"),
-      /call sessions\.get\(session_id\) first/u,
-    );
-    const session = await agent.sessions.create();
-    assert.equal(agent.sessions.runtime(session.id).session_id, session.id);
-  } finally {
-    await agent.dispose();
-  }
-});

package/scripts/city-model-tool-loop.test.mjs

@@ -1,95 +0,0 @@
-/** Agent 原生 Downcity Model Protocol 工具循环测试。 */
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { define_runtime_tool } from "@downcity/type";
-import { z } from "zod";
-import { Agent } from "../bin/index.js";
-import { create_workspace_entry } from "../bin/internal/index.js";
-import { Workspace } from "@downcity/workspace";
-
-const usage = { input_tokens: 5, output_tokens: 3, total_tokens: 8 };
-
-function event_stream(events) {
-  return new ReadableStream({ start(controller) {
-    for (const event of events) controller.enqueue(event);
-    controller.close();
-  } });
-}
-
-test("Agent executes a RuntimeTool and sends tool_result into the next ModelCall", async () => {
-  const calls = [];
-  let tool_executed = false;
-  const model = {
-    id: "mock-model",
-    async stream(call) {
-      calls.push(call);
-      if (!call.tools?.length) {
-        return event_stream([
-          { type: "model_start", request_id: "title", model_id: this.id },
-          { type: "text_start", content_id: "title_text" },
-          { type: "text_delta", content_id: "title_text", delta: "Tool loop" },
-          { type: "text_finish", content_id: "title_text" },
-          { type: "model_usage", usage },
-          { type: "model_finish", finish_reason: "stop" },
-        ]);
-      }
-      const has_result = call.messages.some((message) => message.role === "tool");
-      return has_result
-        ? event_stream([
-            { type: "model_start", request_id: "step_2", model_id: this.id },
-            { type: "text_start", content_id: "text_2" },
-            { type: "text_delta", content_id: "text_2", delta: "done" },
-            { type: "text_finish", content_id: "text_2" },
-            { type: "model_usage", usage },
-            { type: "model_finish", finish_reason: "stop" },
-          ])
-        : event_stream([
-            { type: "model_start", request_id: "step_1", model_id: this.id },
-            { type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "ping" },
-            { type: "tool_call_delta", content_id: "tool_1", input_delta: "{\"value\":\"hello\"}" },
-            { type: "tool_call_finish", content_id: "tool_1", input: { value: "hello" } },
-            { type: "model_usage", usage },
-            { type: "model_finish", finish_reason: "tool_call" },
-          ]);
-    },
-  };
-  const agent_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-model-tool-loop-"));
-  const agent = new Agent({
-    id: "tool_loop_agent",
-    model,
-    tools: {
-      ping: define_runtime_tool({
-        description: "ping tool",
-        input_schema: z.object({ value: z.string() }),
-        execute: async ({ value }, options) => {
-          tool_executed = true;
-          assert.equal(options.tool_call_id, "call_1");
-          assert.equal(options.abort_signal instanceof AbortSignal, true);
-          return { echoed: value };
-        },
-      }),
-    },
-  });
-  const entry = create_workspace_entry(agent, new Workspace({
-    id: "workspace", path: agent_path, data_root_path: path.join(agent_path, "data"),
-  }));
-
-  try {
-    const session = await entry.sessions.create();
-    const result = await (await session.prompt({ query: "use ping" })).finished;
-    assert.equal(result.success, true);
-    assert.equal(result.text, "done");
-    assert.equal(tool_executed, true);
-    const tool_call = calls.find((call) => call.tools?.some((tool) => tool.name === "ping"));
-    assert.equal(tool_call.tools.find((tool) => tool.name === "ping").input_schema.type, "object");
-    const follow_up = calls.find((call) => call.messages.some((message) => message.role === "tool"));
-    const tool_result = follow_up.messages.find((message) => message.role === "tool").content[0];
-    assert.equal(tool_result.tool_call_id, "call_1");
-    assert.deepEqual(tool_result.content[0].value, { echoed: "hello" });
-  } finally {
-    await agent.dispose();
-  }
-});

package/scripts/file-tools.test.mjs

@@ -1,282 +0,0 @@
-/**
- * @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/workspace";
-
-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({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }).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, {
-    tool_call_id: `test-${name}`,
-    messages: [],
-    abort_signal: 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,
-      media_type: "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,
-      media_type: "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");
-});