@downcity/agent 1.1.338 → 1.1.400

package/scripts/session-shell-approval.test.mjs

@@ -12,9 +12,11 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { MockLanguageModelV3 } from "ai/test";
-import { Agent, Workspace } from "@downcity/agent";
-import { Shell } from "@downcity/shell";
+import { MockModelClient } from "./ModelClientMock.mjs";
+import { Agent } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { Shell } from "@downcity/workspace";
 import { create_platform_sandbox } from "./PlatformSandbox.mjs";
 
 /** 构造 AI SDK V3 usage。 */
@@ -100,7 +102,7 @@ test("unrestricted Shell 审批保留当前 Turn 并等待用户决定", async (
     path.join(os.tmpdir(), "downcity-session-shell-approval-"),
   );
   let stream_count = 0;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "session-shell-approval-model",
     doStream: async (options) => {
       if (!Array.isArray(options.tools) || options.tools.length === 0) {
@@ -120,15 +122,16 @@ test("unrestricted Shell 审批保留当前 Turn 并等待用户决定", async (
   });
   const agent = new Agent({
     id: "session_shell_approval_agent",
-    workspace: new Workspace({
-      path: project_root,
-      shell: new Shell({ sandbox }),
-    }),
     model,
   });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "test_workspace",
+    path: project_root, data_root_path: path.join(project_root, "data"),
+    shell: new Shell({ sandbox }),
+  }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "session_shell_approval",
     });
     let interaction_snapshot;
@@ -139,13 +142,13 @@ test("unrestricted Shell 审批保留当前 Turn 并等待用户决定", async (
         mutation.type !== "interaction" ||
         mutation.part.interaction_type !== "approval" ||
         mutation.part.status !== "pending" ||
-        mutation.part.request.kind !== "approval" ||
-        mutation.part.request.source.type !== "tool"
+        mutation.part.request.type !== "approval" ||
+        mutation.part.request.source.type !== "shell"
       ) return;
       interaction_snapshot = mutation.part;
       interaction_result = session.respond({
         interaction_id: mutation.part.interaction_id,
-        response: { kind: "approval", decision: "approved" },
+        response: { type: "approval", outcome: "resolved", payload: { decision: "approved" } },
       });
     });
 
@@ -165,7 +168,7 @@ test("unrestricted Shell 审批保留当前 Turn 并等待用户决定", async (
     assert.deepEqual(await interaction_result, {
       status: "resolved",
       interaction_id: interaction_snapshot.interaction_id,
-      response: { kind: "approval", decision: "approved" },
+      response: { type: "approval", outcome: "resolved", payload: { decision: "approved" } },
     });
     assert.equal(tool_part?.state, "completed");
     assert.equal(tool_part?.output?.output, "approval-ok");

package/scripts/session-system-blocks.test.mjs

@@ -22,7 +22,7 @@ test("instruction blocks keep Downcity core after custom instruction", () => {
     blocks.map((block) => `${block.source}:${block.name}`),
     ["instruction:agent", "core:default"],
   );
-  assert.match(blocks[1].content, /# Downcity Agent/);
+  assert.match(blocks[1].content, /# Harness Design/);
   assert.match(blocks[1].content, /# Harness Design/);
   assert.match(blocks[1].content, /human-owned workspace/);
   assert.match(blocks[1].content, /project structure is the control surface/);

package/scripts/session-title-event.test.mjs

@@ -13,8 +13,11 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
 
-import { MockLanguageModelV3 } from "ai/test";
-import { Agent, Workspace } from "../bin/index.js";
+import { MockModelClient } from "./ModelClientMock.mjs";
+import { Agent } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { City } from "../bin/index.js";
+import { LocalStorageProvider, Workspace } from "@downcity/workspace";
 
 function create_stream_text_result(text) {
   return {
@@ -64,14 +67,14 @@ function create_stream_text_result(text) {
 }
 
 function create_mock_title_model(title_text) {
-  return new MockLanguageModelV3({
+  return new MockModelClient({
     modelId: "mock-session-title-model",
     doStream: async () => create_stream_text_result(title_text),
   });
 }
 
 function create_failing_title_model() {
-  return new MockLanguageModelV3({
+  return new MockModelClient({
     modelId: "mock-session-title-failing-model",
     doStream: async () => {
       throw new Error("mock title generation failed");
@@ -88,7 +91,7 @@ function create_delayed_title_model(title_text) {
   const released = new Promise((resolve) => {
     resolve_release = resolve;
   });
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "mock-session-title-delayed-model",
     doStream: async () => {
       resolve_started();
@@ -103,9 +106,12 @@ function create_delayed_title_model(title_text) {
   };
 }
 
-async function read_log_lines(agent_path) {
-  const logs_path = path.join(agent_path, ".downcity", "logs");
-  const entries = await fs.readdir(logs_path);
+async function read_log_lines(data_path) {
+  const logs_path = path.join(data_path, "logs");
+  const entries = await fs.readdir(logs_path).catch((error) => {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  });
   const lines = [];
   for (const entry of entries) {
     if (!entry.endsWith(".jsonl")) continue;
@@ -128,11 +134,9 @@ test("Session keeps title empty when no model is available", async () => {
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-session-title-"),
   );
-  const agent = new Agent({
-    id: "title_agent",
-    workspace: new Workspace({ path: agent_path }),
-  });
-  const session = await agent.sessions.create();
+  const agent = new Agent({ id: "title_agent" });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
+  const session = await entry.sessions.create();
   const events = [];
   const unsubscribe = session.subscribe((event) => {
     events.push(event);
@@ -163,10 +167,10 @@ test("Session title generation does not block user message append", async () =>
   const delayed = create_delayed_title_model("异步标题");
   const agent = new Agent({
     id: "title_async_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: delayed.model,
   });
-  const session = await agent.sessions.create();
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
+  const session = await entry.sessions.create();
 
   try {
     await session.append_user_message({ text: "标题生成不应阻塞消息写入" });
@@ -183,12 +187,21 @@ test("Session logs title generation failure without blocking the session", async
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-session-title-log-"),
   );
+  const workspace = new Workspace({
+    id: "test_workspace",
+    path: agent_path,
+  });
+  const city = new City({
+    storage: new LocalStorageProvider(path.join(agent_path, "city-data")),
+    workspaces: [workspace],
+  });
   const agent = new Agent({
     id: "title_log_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: create_failing_title_model(),
   });
-  const session = await agent.sessions.create();
+  city.agents.add(agent);
+  const entry = create_workspace_entry(agent, workspace);
+  const session = await entry.sessions.create();
   await session.set({ model: create_failing_title_model() });
 
   try {
@@ -201,8 +214,8 @@ test("Session logs title generation failure without blocking the session", async
     let log_lines = [];
     const log_deadline = Date.now() + 1000;
     while (Date.now() < log_deadline) {
-      await agent.get_logger().save_all_logs();
-      log_lines = await read_log_lines(agent_path);
+      await entry.get_logger().save_all_logs();
+      log_lines = await read_log_lines(entry.data_path);
       if (log_lines.some((line) => line.includes("session_title.generate_failed"))) {
         break;
       }
@@ -214,6 +227,8 @@ test("Session logs title generation failure without blocking the session", async
 
     assert.ok(title_failure_log);
     assert.equal(title_failure_log.type, "warn");
+    assert.equal(title_failure_log.agent_id, "title_log_agent");
+    assert.equal(title_failure_log.workspace_id, "test_workspace");
     assert.equal(title_failure_log.details.session_id, session.id);
     assert.equal(
       title_failure_log.details.model_label,
@@ -229,6 +244,7 @@ test("Session logs title generation failure without blocking the session", async
     );
   } finally {
     await agent.dispose();
+    await city.close();
   }
 });
 
@@ -236,11 +252,9 @@ test("Session retries title generation after model becomes available", async ()
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-session-title-retry-"),
   );
-  const agent = new Agent({
-    id: "title_retry_agent",
-    workspace: new Workspace({ path: agent_path }),
-  });
-  const session = await agent.sessions.create();
+  const agent = new Agent({ id: "title_retry_agent" });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
+  const session = await entry.sessions.create();
   const events = [];
   const unsubscribe = session.subscribe((event) => {
     events.push(event);

package/scripts/session-tool-approval.test.mjs

@@ -1,5 +1,5 @@
 /**
- * @file 验证 AI SDK Tool needsApproval 接入 Session Interaction。
+ * @file 验证 Downcity RuntimeTool 审批接入 Session Interaction。
  *
  * 关键点（中文）
  * - Tool 自己声明审批意图，Agent 不持有审批配置。
@@ -12,9 +12,11 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { MockLanguageModelV3 } from "ai/test";
+import { MockModelClient } from "./ModelClientMock.mjs";
 import { z } from "zod";
-import { Agent, Workspace } from "@downcity/agent";
+import { Agent } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
+import { create_workspace_entry } from "../bin/internal/index.js";
 
 function create_usage() {
   return {
@@ -82,7 +84,7 @@ async function run_approval_case(decision) {
   );
   let execution_count = 0;
   let tool_stream_count = 0;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "native-tool-approval-model",
     doStream: async (options) => {
       if (!Array.isArray(options.tools) || options.tools.length === 0) {
@@ -102,13 +104,12 @@ async function run_approval_case(decision) {
   });
   const agent = new Agent({
     id: `native_tool_approval_${decision}`,
-    workspace: new Workspace({ path: project_root }),
     model,
     tools: {
       custom_approval: {
         description: "Execute a custom operation after approval.",
-        inputSchema: z.object({ value: z.string() }),
-        needsApproval: true,
+        input_schema: z.object({ value: z.string() }),
+        needs_approval: true,
         execute: async () => {
           execution_count += 1;
           return "tool-result";
@@ -116,9 +117,10 @@ async function run_approval_case(decision) {
       },
     },
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
 
   try {
-    const session = await agent.sessions.create({ session_id: "tool_approval" });
+    const session = await entry.sessions.create({ session_id: "tool_approval" });
     let pending_request;
     let response_promise;
     const unsubscribe = session.subscribe((mutation) => {
@@ -126,13 +128,13 @@ async function run_approval_case(decision) {
         mutation.variant !== "part" ||
         mutation.type !== "interaction" ||
         mutation.part.status !== "pending" ||
-        mutation.part.request.kind !== "approval" ||
-        mutation.part.request.operation !== "tool"
+        mutation.part.request.type !== "approval" ||
+        mutation.part.request.payload.operation !== "tool"
       ) return;
       pending_request = mutation.part.request;
       response_promise = session.respond({
         interaction_id: mutation.part.interaction_id,
-        response: { kind: "approval", decision },
+        response: { type: "approval", outcome: decision === "approved" ? "resolved" : "denied", payload: { decision } },
       });
     });
 
@@ -145,11 +147,11 @@ async function run_approval_case(decision) {
     assert.equal(execution_count, decision === "approved" ? 1 : 0);
     assert.ok(pending_request);
     assert.equal(pending_request.source.tool_name, "custom_approval");
-    assert.deepEqual(pending_request.validated_input, {
+    assert.deepEqual(pending_request.payload.validated_input, {
       value: "approval-value",
     });
     assert.equal(
-      pending_request.tool_description,
+      pending_request.payload.tool_description,
       "Execute a custom operation after approval.",
     );
     assert.equal("title" in pending_request, false);
@@ -162,10 +164,10 @@ async function run_approval_case(decision) {
   }
 }
 
-test("needsApproval 批准后执行 Tool 并恢复原 Turn", async () => {
+test("needs_approval 批准后执行 Tool 并恢复原 Turn", async () => {
   await run_approval_case("approved");
 });
 
-test("needsApproval 拒绝后不执行 Tool 副作用", async () => {
+test("needs_approval 拒绝后不执行 Tool 副作用", async () => {
   await run_approval_case("denied");
 });

package/scripts/session-turn-context.test.mjs

@@ -12,48 +12,49 @@ import test from "node:test";
 
 import { create_session_turn_context } from "../bin/session/runtime/SessionTurnContext.js";
 
+function create_user_message(message_id, text, created_at) {
+  return {
+    message_id,
+    session_id: "session-context-test",
+    turn_id: "turn-context-test",
+    sequence: created_at,
+    revision: 1,
+    visibility: "visible",
+    created_at,
+    updated_at: created_at,
+    type: "user",
+    input_type: "steer",
+    parts: [{
+      part_id: `${message_id}:text`,
+      type: "text",
+      text,
+      state: "done",
+    }],
+  };
+}
+
 test("SessionTurnContext 在检查点消费输入并封装输出缓冲", async () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
     turn_id: "turn-context-test",
     project_root: "/workspace",
-    merge_step_input: async () => [{
-      id: "queued-message",
-      role: "user",
-      metadata: {
-        v: 1,
-        ts: 2,
-        session_id: "session-context-test",
-        source: "ingress",
-        kind: "normal",
-      },
-      parts: [{ type: "text", text: "queued" }],
-    }],
-  });
-  context.input.inject_user_message({
-    id: "injected-message",
-    role: "user",
-    metadata: {
-      v: 1,
-      ts: 1,
-      session_id: "session-context-test",
-      source: "ingress",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: "injected" }],
+    merge_step_input: async () => [create_user_message("queued-message", "queued", 2)],
   });
+  context.input.inject_user_message(
+    create_user_message("injected-message", "injected", 1),
+  );
   context.output.enqueue_assistant_parts([{
     type: "file",
-    mediaType: "text/plain",
+    media_type: "text/plain",
     url: "/workspace/result.txt",
   }]);
 
   assert.deepEqual(
-    (await context.input.checkpoint()).map((message) => message.id),
+    (await context.input.checkpoint()).map((message) => message.message_id),
     ["injected-message", "queued-message"],
   );
   assert.deepEqual(
-    (await context.input.checkpoint()).map((message) => message.id),
+    (await context.input.checkpoint()).map((message) => message.message_id),
     ["queued-message"],
   );
   assert.equal(context.output.take_assistant_parts().length, 1);
@@ -80,16 +81,18 @@ test("SessionTurnContext 负责 Plugin lease 与只读投影生命周期", async
   await context.step.replace_plugins(create_lease("first"));
   await context.step.replace_plugins(create_lease("second"));
 
-  const plugin_execution_context = context.step.plugin_execution_context();
+  const plugin_execution_context = context.step.plugin_execution_context("call-context-test");
   assert.deepEqual(Object.keys(plugin_execution_context).sort(), [
     "abort_signal",
     "agent_systems",
+    "call_id",
     "project_root",
     "session_id",
     "turn_id",
     "workspace_env",
   ]);
   assert.equal(Object.isFrozen(plugin_execution_context), true);
+  assert.equal(plugin_execution_context.call_id, "call-context-test");
   assert.deepEqual(plugin_execution_context.workspace_env, { REGION: "cn" });
   assert.deepEqual(released, ["first"]);