@downcity/agent 1.1.338 → 1.1.400

package/scripts/agent-session-maintenance.test.mjs

@@ -7,47 +7,34 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { Agent, Workspace } from "../bin/index.js";
+import { Agent } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { Workspace } from "@downcity/workspace";
 
 function create_project_root() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "downcity-session-maintenance-"));
 }
 
-function get_session_path(root_path, agent_id, session_id) {
-  return path.join(
-    root_path,
-    ".downcity",
-    "agents",
-    encodeURIComponent(agent_id),
-    "sessions",
-    encodeURIComponent(session_id),
-  );
-}
-
 test("Agent sessions 负责清空消息和删除 Session 数据", async () => {
   const root_path = create_project_root();
-  const agent = new Agent({
-    id: "agent_test",
-    workspace: new Workspace({ path: root_path }),
-  });
+  const data_root_path = path.join(root_path, "data");
+  const agent = new Agent({ id: "agent_test" });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "test_workspace",
+    path: root_path,
+    data_root_path,
+  }));
   try {
-    await agent.ready();
-    const session_id = "session_test";
-    await agent.sessions.create({ session_id: session_id });
-    const session_path = get_session_path(root_path, agent.id, session_id);
-    const messages_path = path.join(session_path, "messages");
-    fs.mkdirSync(messages_path, { recursive: true });
-    fs.writeFileSync(path.join(messages_path, "active.jsonl"), "{}\n");
+    const session = await entry.sessions.create();
+    const session_id = session.id;
+    await session.append_user_message({ text: "maintenance" });
 
     assert.equal(
-      await agent.sessions.clear_messages(session_id),
+      await entry.sessions.clear_messages(session_id),
       true,
     );
-    assert.equal(fs.existsSync(messages_path), false);
-    assert.equal(fs.existsSync(session_path), true);
 
-    assert.equal(await agent.sessions.remove(session_id), true);
-    assert.equal(fs.existsSync(session_path), false);
+    assert.equal(await entry.sessions.remove(session_id), true);
   } finally {
     await agent.dispose();
     fs.rmSync(root_path, {

package/scripts/agent-store.test.mjs

@@ -1,5 +1,5 @@
 /**
- * @file 验证 AgentStore / SessionStore 的领域边界与本地实现契约。
+ * @file 验证 SessionStore / SessionDataStore 的领域边界与本地实现契约。
  */
 
 import assert from "node:assert/strict";
@@ -7,20 +7,47 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { Agent, Workspace } from "../bin/index.js";
+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 { workspace_path };
+  return { data_root_path, workspace_path };
 }
 
-test("Workspace provides AgentStore on the same file resource", async (t) => {
-  const { workspace_path } = await create_test_roots(t);
-  const workspace = new Workspace({ path: workspace_path });
-  const store = workspace.bind_agent("store-test");
+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);
@@ -31,6 +58,7 @@ test("Workspace provides AgentStore on the same file resource", async (t) => {
     v: 1,
     session_id: "first",
     agent_id: "store-test",
+    workspace_id: "test_workspace",
     created_at: 1,
     updated_at: 1,
     title: "独立存储",
@@ -41,26 +69,44 @@ test("Workspace provides AgentStore on the same file resource", async (t) => {
   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 workspace.files.run_file_action({
+  const tool_result = await storage.files.run_file_action({
     action: "read",
     input: {
-      file_path: ".downcity/agents/store-test/sessions/first/messages/meta.json",
+      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, undefined);
+  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("LocalAgentStore archives and cleans sessions", async (t) => {
-  const { workspace_path } = await create_test_roots(t);
-  const store = new Workspace({ path: workspace_path }).bind_agent("archive-test");
-  await store.session("archived").messages.initialize();
+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");
@@ -69,15 +115,68 @@ test("LocalAgentStore archives and cleans sessions", async (t) => {
   assert.equal((await store.list_archived_sessions()).items.length, 0);
 });
 
-test("Agent obtains its Store from Workspace", async (t) => {
-  const { workspace_path } = await create_test_roots(t);
-  const workspace = new Workspace({ path: workspace_path });
-  const agent = new Agent({
-    id: "dispose-test",
-    workspace,
+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(agent.workspace, workspace);
-  assert.equal((await agent.sessions.create({ session_id: "first" })).id, "first");
+  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,223 +1,94 @@
-/**
- * @file 验证 Agent 直接调用实现 LanguageModelV3 的 CityModel 并完成 tool loop。
- *
- * 关键点（中文）
- * - 测试模型自身已经实现 LanguageModelV3，Agent 不再创建第二个 Provider 模型。
- * - 第一次调用返回 tool-call，Agent 本地执行后把 tool-result 放进第二次调用。
- * - CityModel 的目录信息继续用于上下文窗口和日志，不参与网络连接转换。
- */
-
+/** 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 { MockLanguageModelV3 } from "ai/test";
-import { tool } from "ai";
+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";
 
-import { Agent, Workspace } from "../bin/index.js";
-import { create_action, create_plugin } from "../bin/plugin/core/PluginActionFactory.js";
-import { CITY_MODEL_KIND } from "@downcity/type";
-
-/** 构造 AI SDK V3 usage。 */
-function create_usage() {
-  return {
-    inputTokens: { total: 5, noCache: 5, cacheRead: 0, cacheWrite: 0 },
-    outputTokens: { total: 3, text: 3, reasoning: 0 },
-  };
-}
-
-/** 构造一次 ping tool-call。 */
-function create_tool_call_stream() {
-  const input = JSON.stringify({ value: "hello" });
-  return {
-    stream: new ReadableStream({
-      start(controller) {
-        controller.enqueue({ type: "stream-start", warnings: [] });
-        controller.enqueue({ type: "tool-input-start", id: "call_1", toolName: "ping" });
-        controller.enqueue({ type: "tool-input-delta", id: "call_1", delta: input });
-        controller.enqueue({ type: "tool-input-end", id: "call_1" });
-        controller.enqueue({
-          type: "tool-call",
-          toolCallId: "call_1",
-          toolName: "ping",
-          input,
-          providerMetadata: { openai: { itemId: "fc_1" } },
-        });
-        controller.enqueue({
-          type: "finish",
-          finishReason: { unified: "tool-calls", raw: "tool_calls" },
-          usage: create_usage(),
-        });
-        controller.close();
-      },
-    }),
-  };
-}
+const usage = { input_tokens: 5, output_tokens: 3, total_tokens: 8 };
 
-/** 构造普通文本完成流。 */
-function create_text_stream(text) {
-  return {
-    stream: new ReadableStream({
-      start(controller) {
-        controller.enqueue({ type: "stream-start", warnings: [] });
-        controller.enqueue({ type: "text-start", id: "text_1" });
-        controller.enqueue({ type: "text-delta", id: "text_1", delta: text });
-        controller.enqueue({ type: "text-end", id: "text_1" });
-        controller.enqueue({
-          type: "finish",
-          finishReason: { unified: "stop", raw: "stop" },
-          usage: create_usage(),
-        });
-        controller.close();
-      },
-    }),
-  };
+function event_stream(events) {
+  return new ReadableStream({ start(controller) {
+    for (const event of events) controller.enqueue(event);
+    controller.close();
+  } });
 }
 
-/** 给标准 LanguageModelV3 附加 CityModel 目录协议。 */
-function create_city_model(model_requests) {
-  let request_count = 0;
-  const model = new MockLanguageModelV3({
-    modelId: "mock-model",
-    doStream: async (options) => {
-      if (!Array.isArray(options.tools) || options.tools.length === 0) {
-        return create_text_stream("Tool loop");
-      }
-      request_count += 1;
-      model_requests.push(options);
-      return request_count === 1
-        ? create_tool_call_stream()
-        : create_text_stream("done");
-    },
-  });
-  return Object.assign(model, {
-    id: "mock-model",
-    name: "Mock Model",
-    description: "Native CityModel tool loop test",
-    modalities: ["text", "stream"],
-    tags: [],
-    meta: {},
-    kind: CITY_MODEL_KIND,
-  });
-}
-
-test("CityModel uses direct LanguageModel path and sends tool result back", async () => {
-  const model_requests = [];
+test("Agent executes a RuntimeTool and sends tool_result into the next ModelCall", async () => {
+  const calls = [];
   let tool_executed = false;
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-city-model-tool-loop-"),
-  );
-  const input_image_path = path.join(agent_path, "tool-input.png");
-  await fs.writeFile(input_image_path, Buffer.from("tool-input-image"));
-  const skill_plugin = create_plugin({
-    name: "skill",
-    title: "Skill",
-    description: "Test skill plugin",
-    actions: {
-      lookup: create_action({
-        description: "Lookup a skill",
-        execute: async ({ input }) => ({
-          success: true,
-          data: { name: input.name },
-          message: "loaded",
-        }),
-      }),
+  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",
-    workspace: new Workspace({ path: agent_path }),
-    plugins: [skill_plugin],
+    model,
     tools: {
-      ping: tool({
+      ping: define_runtime_tool({
         description: "ping tool",
-        inputSchema: z.object({ value: z.string() }),
-        execute: async ({ value }) => {
+        input_schema: z.object({ value: z.string() }),
+        execute: async ({ value }, options) => {
           tool_executed = true;
-          return {
-            output: { echoed: value },
-            messages: [
-              {
-                role: "assistant",
-                parts: [{
-                  type: "file",
-                  mediaType: "image/png",
-                  url: "/workspace/tool-output.png",
-                  filename: "tool-output.png",
-                }],
-              },
-              {
-                role: "user",
-                parts: [{
-                  type: "file",
-                  mediaType: "image/png",
-                  url: input_image_path,
-                  filename: "tool-input.png",
-                }],
-              },
-            ],
-          };
+          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 agent.sessions.create();
-    await session.set({ model: create_city_model(model_requests) });
-    const turn = await session.prompt({ query: "please use the ping tool" });
-    const result = await turn.finished;
-
+    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);
-    assert.equal(model_requests.length, 2);
-    assert.equal(model_requests[0].providerOptions, undefined);
-    assert.equal(model_requests[1].providerOptions, undefined);
-    const plugin_call_tool = model_requests[0].tools.find((item) => item.name === "plugin_call");
-    assert.ok(plugin_call_tool);
-    assert.equal(plugin_call_tool.inputSchema.type, "object");
-    assert.deepEqual(plugin_call_tool.inputSchema.required, ["plugin", "action"]);
-    assert.equal(plugin_call_tool.inputSchema.additionalProperties, false);
-
-    const serialized_second_prompt = JSON.stringify(model_requests[1].prompt);
-    assert.match(serialized_second_prompt, /"role":"tool"/);
-    assert.match(serialized_second_prompt, /call_1/);
-    assert.match(serialized_second_prompt, /echoed/);
-    assert.match(serialized_second_prompt, /hello/);
-    const injected_file = model_requests[1].prompt
-      .filter((message) => message.role === "user")
-      .flatMap((message) => Array.isArray(message.content) ? message.content : [])
-      .find((part) => part.type === "file" && part.filename === "tool-input.png");
-    assert.ok(injected_file, JSON.stringify(model_requests[1].prompt.at(-1)));
-    assert.equal(injected_file.mediaType, "image/png");
-    assert.equal(
-      String(injected_file.data),
-      Buffer.from("tool-input-image").toString("base64"),
-    );
-    const restored_tool_call = model_requests[1].prompt
-      .flatMap((message) => Array.isArray(message.content) ? message.content : [])
-      .find((part) => part.type === "tool-call" && part.toolCallId === "call_1");
-    assert.deepEqual(restored_tool_call.providerOptions, {
-      openai: { itemId: "fc_1" },
-    });
-
-    const session_messages = await session.messages({ include_internal: true });
-    const persisted_assistant = session_messages.items.find((message) => message.type === "assistant");
-    const result_file = persisted_assistant.parts.find((part) => part.type === "file");
-    assert.deepEqual(result_file, {
-      part_id: result_file.part_id,
-      sequence: result_file.sequence,
-      type: "file",
-      media_type: "image/png",
-      url: "/workspace/tool-output.png",
-      filename: "tool-output.png",
-    });
-    const persisted_tool = persisted_assistant.parts.find((part) => part.type === "tool");
-    assert.deepEqual(persisted_tool.call_provider_metadata, {
-      openai: { itemId: "fc_1" },
-    });
+    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();
   }