@downcity/agent 1.1.400 → 1.1.408

package/city-test/group.test.mjs

@@ -116,6 +116,8 @@ test("Group.model uses AI dispatch to select only the returned members", async (
   await group_session.prompt({ query: "请审查这个变更" });
   await wait_for_group_idle(group_session);
   assert.deepEqual(RecordingSession.created.map((entry) => entry.agent_id), ["reviewer"]);
+  assert.match(RecordingSession.created[0].query, /你已被 Group 调度选中，必须直接回复当前消息/);
+  assert.doesNotMatch(RecordingSession.created[0].query, /判断是否需要回复|如果不需要你发言/);
   await city.close();
 });
 
@@ -208,6 +210,50 @@ test("AI Dispatch 未调用 dispatch_group 时记录协议错误", async () => {
   await city.close();
 });
 
+test("AI Dispatch 在同一调度 Turn 内纠正未调用工具的响应", async () => {
+  RecordingSession.created = [];
+  let dispatch_calls = 0;
+  const dispatch_model = new MockModelClient({
+    modelId: "recovering-dispatch-model",
+    doGenerate: async (call) => {
+      dispatch_calls += 1;
+      if (dispatch_calls === 1) {
+        return {
+          content: [{ type: "text", text: "我建议让 responder 回复。" }],
+          finishReason: { unified: "stop", raw: "stop" },
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+          warnings: [],
+        };
+      }
+      assert.equal(call.messages.some((message) => (
+        message.role === "user" && message.content.some((part) => (
+          part.type === "text" && part.text.includes("上一响应不符合调度协议")
+        ))
+      )), true);
+      return {
+        content: [create_dispatch_tool_call({ steps: [["responder"]], next: "stop" })],
+        finishReason: { unified: "tool-calls", raw: "tool_calls" },
+        usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        warnings: [],
+      };
+    },
+  });
+  const city = new City();
+  const agent = new Agent({ id: "responder", session_class: RecordingSession });
+  city.agents.add(agent);
+  const group = new Group({ id: "recovering-dispatch-group", model: dispatch_model, members: [agent] });
+  city.groups.add(group);
+  const group_session = await group.sessions.create();
+
+  await group_session.prompt({ query: "请回答" });
+  await wait_for_group_idle(group_session);
+
+  assert.equal(dispatch_calls, 2);
+  assert.deepEqual(RecordingSession.created.map((entry) => entry.agent_id), ["responder"]);
+  assert.equal((await group_session.messages()).some((message) => message.sender_type === "system"), false);
+  await city.close();
+});
+
 test("AI Dispatch 拒绝未知成员并允许跨阶段重复投递", async () => {
   const inputs = [
     { input: { steps: [["unknown"]], next: "stop" }, expected_agent_ids: [] },
@@ -414,6 +460,157 @@ test("GroupSession 使用 City Storage 持久化并可恢复", async () => {
   await fs.rm(root_path, { recursive: true, force: true });
 });
 
+test("GroupSession 持久化独享 Dispatch Session 的调度 Turn", async () => {
+  RecordingSession.created = [];
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-dispatch-session-"));
+  const city = new City({ storage: new LocalStorageProvider(root_path) });
+  const agent = new Agent({ id: "dispatch-member", session_class: RecordingSession });
+  city.agents.add(agent);
+  const group = new Group({ id: "dispatch-session-group", members: [agent], dispatch_strategy: test_dispatch_strategy });
+  city.groups.add(group);
+  const session = await group.sessions.create();
+
+  await session.prompt({ query: "persist dispatch" });
+  await wait_for_group_idle(session);
+
+  const turns_path = path.join(
+    root_path,
+    "groups",
+    "dispatch-session-group",
+    "sessions",
+    encodeURIComponent(session.id),
+    "dispatch",
+    "turns.jsonl",
+  );
+  const records = (await fs.readFile(turns_path, "utf8"))
+    .trim()
+    .split("\n")
+    .map((line) => JSON.parse(line));
+  const user_records = records.filter((record) => record.trigger === "user");
+  assert.deepEqual(user_records.map((record) => record.status), ["queued", "running", "completed"]);
+  assert.deepEqual(user_records.at(-1).decision.nodes[0].member_ids, ["dispatch-member"]);
+  assert.equal(
+    (await session.messages()).find((message) => message.sender_type === "agent").dispatch_id,
+    user_records.at(-1).dispatch_id,
+  );
+  await city.close();
+  await fs.rm(root_path, { recursive: true, force: true });
+});
+
+test("GroupSession stop 会中断 Dispatch Session 且不记录失败消息", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-dispatch-stop-"));
+  let dispatch_started = false;
+  let dispatch_aborted = false;
+  let dispatch_invocations = 0;
+  const strategy = {
+    async decide_dispatch({ abort_signal }) {
+      dispatch_invocations += 1;
+      dispatch_started = true;
+      await new Promise((resolve, reject) => {
+        const abort = () => {
+          dispatch_aborted = true;
+          reject(abort_signal.reason);
+        };
+        if (abort_signal.aborted) abort();
+        else abort_signal.addEventListener("abort", abort, { once: true });
+      });
+      return { nodes: [], terminal: true };
+    },
+  };
+  const city = new City({ storage: new LocalStorageProvider(root_path) });
+  const agent = new Agent({ id: "unused-member", session_class: RecordingSession });
+  city.agents.add(agent);
+  const group = new Group({ id: "dispatch-stop-group", members: [agent], dispatch_strategy: strategy });
+  city.groups.add(group);
+  const session = await group.sessions.create();
+  await session.prompt({ query: "stop dispatch" });
+  await session.prompt({ query: "cancel queued dispatch" });
+  for (let attempt = 0; attempt < 200 && !dispatch_started; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+
+  await session.stop();
+
+  assert.equal(dispatch_aborted, true);
+  assert.equal(dispatch_invocations, 1);
+  assert.deepEqual((await session.messages()).map((message) => message.text), [
+    "stop dispatch",
+    "cancel queued dispatch",
+  ]);
+  const turns_path = path.join(
+    root_path,
+    "groups",
+    "dispatch-stop-group",
+    "sessions",
+    encodeURIComponent(session.id),
+    "dispatch",
+    "turns.jsonl",
+  );
+  const records = (await fs.readFile(turns_path, "utf8"))
+    .trim()
+    .split("\n")
+    .map((line) => JSON.parse(line));
+  const latest_records = new Map(records.map((record) => [record.dispatch_id, record]));
+  assert.equal(latest_records.size, 2);
+  assert.deepEqual([...latest_records.values()].map((record) => record.status), ["stopped", "stopped"]);
+  await city.close();
+  await fs.rm(root_path, { recursive: true, force: true });
+});
+
+test("GroupSession 恢复时重新执行中断的用户调度", async () => {
+  RecordingSession.created = [];
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-dispatch-recovery-"));
+  let original_abort_signal;
+  let original_dispatch_started = false;
+  const original_city = new City({ storage: new LocalStorageProvider(root_path) });
+  const original_agent = new Agent({ id: "recovery-member", session_class: RecordingSession });
+  original_city.agents.add(original_agent);
+  const original_group = new Group({
+    id: "dispatch-recovery-group",
+    members: [original_agent],
+    dispatch_strategy: {
+      async decide_dispatch({ abort_signal }) {
+        original_abort_signal = abort_signal;
+        original_dispatch_started = true;
+        await new Promise((resolve, reject) => {
+          abort_signal.addEventListener("abort", () => reject(abort_signal.reason), { once: true });
+        });
+        return { nodes: [], terminal: true };
+      },
+    },
+  });
+  original_city.groups.add(original_group);
+  const original_session = await original_group.sessions.create();
+  await original_session.prompt({ query: "recover dispatch" });
+  for (let attempt = 0; attempt < 200 && !original_dispatch_started; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+
+  const restored_city = new City({ storage: new LocalStorageProvider(root_path) });
+  const restored_agent = new Agent({ id: "recovery-member", session_class: RecordingSession });
+  restored_city.agents.add(restored_agent);
+  const restored_group = new Group({
+    id: "dispatch-recovery-group",
+    members: [restored_agent],
+    dispatch_strategy: test_dispatch_strategy,
+  });
+  restored_city.groups.add(restored_group);
+  const restored_session = await restored_group.sessions.get(original_session.id);
+  assert.ok(restored_session);
+  await wait_for_group_idle(restored_session);
+
+  assert.deepEqual(RecordingSession.created.map((entry) => entry.agent_id), ["recovery-member"]);
+  assert.deepEqual((await restored_session.messages()).map((message) => message.text), [
+    "recover dispatch",
+    "reply:recovery-member",
+  ]);
+  await original_session.stop();
+  assert.equal(original_abort_signal.aborted, true);
+  await restored_city.close();
+  await original_city.close();
+  await fs.rm(root_path, { recursive: true, force: true });
+});
+
 test("GroupSession 持久化调度检查点并在收口后清理", async () => {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-checkpoint-"));
   const storage = new LocalStorageProvider(root_path);
@@ -450,6 +647,56 @@ test("GroupSession 持久化调度检查点并在收口后清理", async () => {
   await fs.rm(root_path, { recursive: true, force: true });
 });
 
+test("GroupSession 列表首次读取时将 v1 metadata 原子迁移为 v2", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-metadata-migration-"));
+  const group_id = "metadata-migration-group";
+  const session_id = "legacy-session";
+  const session_path = path.join(root_path, "groups", group_id, "sessions", session_id);
+  const meta_path = path.join(session_path, "meta.json");
+  await fs.mkdir(session_path, { recursive: true });
+  await fs.writeFile(meta_path, `${JSON.stringify({
+    v: 1,
+    session_id,
+    group_id,
+    created_at: 1,
+    updated_at: 2,
+    message_count: 1,
+    preview_text: "legacy message",
+    pending_turns: [{
+      turn_id: "legacy-turn",
+      root_message_id: "legacy-message",
+      context_message_ids: [],
+    }],
+    auto_frontier_message_ids: ["legacy-reply"],
+  }, null, 2)}\n`);
+
+  const city = new City({ storage: new LocalStorageProvider(root_path) });
+  const agent = new Agent({ id: "metadata-agent", session_class: RecordingSession });
+  city.agents.add(agent);
+  const group = new Group({ id: group_id, members: [agent], dispatch_strategy: test_dispatch_strategy });
+  city.groups.add(group);
+
+  assert.deepEqual(await group.sessions.list(), [{
+    id: session_id,
+    group_id,
+    created_at: 1,
+    updated_at: 2,
+    message_count: 1,
+    preview_text: "legacy message",
+  }]);
+  const migrated_metadata = JSON.parse(await fs.readFile(meta_path, "utf8"));
+  assert.equal(migrated_metadata.v, 2);
+  assert.deepEqual(migrated_metadata.pending_turns, [{
+    turn_id: "legacy-turn",
+    root_message_id: "legacy-message",
+    context_message_ids: [],
+    dispatch_stage: "auto",
+  }]);
+  assert.deepEqual(migrated_metadata.auto_frontier_message_ids, ["legacy-reply"]);
+  await city.close();
+  await fs.rm(root_path, { recursive: true, force: true });
+});
+
 test("GroupSession 恢复时修复尾部损坏的消息记录", async () => {
   const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-group-tail-"));
   const storage = new LocalStorageProvider(root_path);
@@ -628,7 +875,7 @@ test("唯一 auto dispatch 等待并合并并发输入批次", async () => {
   await city.close();
 });
 
-test("响应图依赖没有有效回复时不会继续投递下游节点", async () => {
+test("成员返回空内容时记录失败且不继续投递下游节点", async () => {
   RecordingSession.created = [];
   class EmptySession extends Session {
     async prompt() {
@@ -665,6 +912,10 @@ test("响应图依赖没有有效回复时不会继续投递下游节点", async
   await group_session.prompt({ query: "请分析并审查" });
   await wait_for_group_idle(group_session);
   assert.deepEqual(RecordingSession.created.map((entry) => entry.agent_id), ["architect"]);
+  assert.deepEqual((await group_session.messages()).map((message) => [message.sender_type, message.text]), [
+    ["user", "请分析并审查"],
+    ["system", "architect 执行失败：未生成有效回复"],
+  ]);
   await city.close();
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@downcity/agent",
-  "version": "1.1.400",
+  "version": "1.1.408",
   "type": "module",
   "description": "Downcity 单 Agent SDK 与执行运行时",
   "main": "./bin/index.js",
@@ -27,19 +27,10 @@
       "types": "./bin/internal/index.d.ts"
     }
   },
-  "scripts": {
-    "build": "node scripts/agent-compiler.mjs build",
-    "dev": "node scripts/agent-compiler.mjs dev",
-    "test": "pnpm build && pnpm --filter '@downcity/sandbox-*' build && pnpm -C ../plugins build && node --test scripts/*.test.mjs city-test/*.test.mjs",
-    "test:executor-runtime": "pnpm build && node --test scripts/session-prompt-runtime.test.mjs",
-    "typecheck": "node scripts/agent-compiler.mjs typecheck",
-    "prepack": "npm run build && node ../../scripts/rewrite-workspace-dependencies.mjs prepare ./package.json",
-    "postpack": "node ../../scripts/rewrite-workspace-dependencies.mjs restore ./package.json"
-  },
   "dependencies": {
-    "@downcity/workspace": "^0.1.5",
-    "@downcity/type": "0.1.199",
-    "@downcity/federation": "^0.1.9",
+    "@downcity/workspace": "^0.1.7",
+    "@downcity/type": "0.1.202",
+    "@downcity/federation": "^0.1.15",
     "commander": "^15.0.0",
     "dotenv": "^17.4.2",
     "execa": "^9.6.1",
@@ -53,9 +44,9 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@downcity/sandbox-linux": "^0.1.37",
-    "@downcity/sandbox-macos": "^0.1.37",
-    "@downcity/sandbox-windows-mxc": "^0.1.37",
+    "@downcity/sandbox-linux": "^0.1.38",
+    "@downcity/sandbox-macos": "^0.1.38",
+    "@downcity/sandbox-windows-mxc": "^0.1.38",
     "@types/fs-extra": "^11.0.4",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.9.1",
@@ -63,5 +54,12 @@
     "@types/ws": "^8.18.1",
     "tsc-alias": "^1.8.17",
     "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "node scripts/agent-compiler.mjs build",
+    "dev": "node scripts/agent-compiler.mjs dev",
+    "test": "pnpm build && pnpm --filter '@downcity/sandbox-*' build && pnpm -C ../plugins build && node --test scripts/*.test.mjs city-test/*.test.mjs",
+    "test:executor-runtime": "pnpm build && node --test scripts/session-prompt-runtime.test.mjs",
+    "typecheck": "node scripts/agent-compiler.mjs typecheck"
   }
-}
+}

package/scripts/agent-multi-workspace.test.mjs

@@ -77,6 +77,73 @@ test("one Agent enters multiple Workspaces with contextual Plugin execution", as
 
 });
 
+test("PluginContext sessions keep the current Workspace binding", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-sessions-"));
+  let linked_session_id = "";
+  const plugin = create_plugin({
+    name: "session_probe",
+    title: "Session Probe",
+    description: "Validates the current Workspace Session view.",
+    actions: {
+      inspect: {
+        description: "Restore one Session and create another in the current Workspace.",
+        execute: async ({ context }) => {
+          const linked_session = await context.sessions.get(linked_session_id);
+          const task_session = await context.sessions.create();
+          await context.sessions.runtime(linked_session_id).append_assistant_message({
+            text: "task completed",
+          });
+          return {
+            success: true,
+            data: {
+              linked_workspace_id: linked_session.workspace_id,
+              task_workspace_id: task_session.workspace_id,
+            },
+          };
+        },
+      },
+    },
+  });
+  const agent = new Agent({ id: "plugin-session-agent", plugins: [plugin] });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "plugin-session-workspace",
+    path: root,
+    data_root_path: path.join(root, "data"),
+  }));
+
+  try {
+    const linked_session = await entry.sessions.create();
+    linked_session_id = linked_session.id;
+    const mutations = [];
+    const unsubscribe = linked_session.subscribe((mutation) => {
+      mutations.push(mutation);
+    });
+    const result = await entry.plugins.run_action({
+      plugin: "session_probe",
+      action: "inspect",
+    });
+    unsubscribe();
+    assert.equal(result.success, true);
+    assert.deepEqual(result.data, {
+      linked_workspace_id: "plugin-session-workspace",
+      task_workspace_id: "plugin-session-workspace",
+    });
+    const messages = await linked_session.messages();
+    assert.equal(messages.items.at(-1)?.type, "assistant");
+    assert.equal(messages.items.at(-1)?.parts.at(-1)?.type, "text");
+    assert.equal(messages.items.at(-1)?.parts.at(-1)?.text, "task completed");
+    assert.equal(
+      mutations.some((mutation) =>
+        mutation.variant === "message" && mutation.type === "assistant"
+      ),
+      true,
+    );
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
 test("Plugin runtime data is isolated by Agent and shared across Workspaces", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-plugin-data-"));
   const contexts = [];

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

@@ -146,6 +146,55 @@ test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
   assert.equal(second.compact_required, undefined);
 });
 
+test("Provider 在输出前发生可重试流错误时自动重试", async () => {
+  let call_count = 0;
+  const model = {
+    id: "retryable-stream-model",
+    async stream() {
+      call_count += 1;
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: `request_${call_count}`,
+            model_id: "retryable-stream-model",
+          });
+          if (call_count === 1) {
+            controller.enqueue({
+              type: "model_error",
+              error: {
+                code: "transport_error",
+                message: "temporary disconnect",
+                retryable: true,
+              },
+            });
+          } else {
+            controller.enqueue({ type: "text_start", content_id: "text_1" });
+            controller.enqueue({ type: "text_delta", content_id: "text_1", delta: "done" });
+            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();
+        },
+      });
+    },
+  };
+  const messages = [{
+    role: "user",
+    content: [{ type: "text", text: "latest request" }],
+  }];
+
+  const result = await create_runner().execute(create_turn_input(model, messages));
+
+  assert.equal(call_count, 2);
+  assert.equal(result.success, true);
+  assert.equal(result.text, "done");
+});
+
 test("显式 compact 后在下一次 provider 调用前重载 canonical history", async () => {
   const provider_prompts = [];
   const compacted_messages = [{

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

@@ -85,3 +85,72 @@ test("Agent 拒绝不合法的 Downcity 模型流状态", async () => {
     }), /Invalid Downcity model stream/);
   }
 });
+
+test("模型生成无效工具输入时向下一 Step 返回 failed tool_result", async () => {
+  let executed = false;
+  const model = {
+    id: "invalid-tool-input-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "invalid-tool-input-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "write" });
+          controller.enqueue({ type: "tool_call_delta", content_id: "tool_1", input_delta: "{\"content\":\"partial" });
+          controller.enqueue({
+            type: "tool_call_finish",
+            content_id: "tool_1",
+            input: {},
+            input_error: "Tool call arguments are invalid JSON: Unterminated string",
+          });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+
+  const result = await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "write" }] }],
+    tools: { write: { execute: async () => { executed = true; } } },
+    abort_signal: new AbortController().signal,
+  });
+
+  assert.equal(executed, false);
+  assert.equal(result.step_result.tool_results[0].success, false);
+  const tool_message = result.step_result.response.messages[1];
+  assert.equal(tool_message.content[0].outcome, "failed");
+  assert.match(tool_message.content[0].content[0].value.error, /invalid JSON/);
+});
+
+test("Tool 返回 success false 时不会被标记为成功", async () => {
+  const model = {
+    id: "structured-tool-failure-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "structured-tool-failure-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "shell" });
+          controller.enqueue({ type: "tool_call_finish", content_id: "tool_1", input: {} });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+
+  const result = await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "run" }] }],
+    tools: { shell: { execute: async () => ({ success: false, exit_code: 1, error: "command failed" }) } },
+    abort_signal: new AbortController().signal,
+  });
+
+  assert.equal(result.step_result.tool_results[0].success, false);
+  assert.equal(result.assistant_parts[0].state, "failed");
+  assert.equal(result.step_result.response.messages[1].content[0].outcome, "failed");
+});

package/src/agent/WorkspaceEntry.ts

@@ -125,7 +125,7 @@ export class WorkspaceEntry {
         return contextual_plugins;
       },
       get_sessions: () => {
-        return this.agent.sessions;
+        return this.sessions;
       },
     } satisfies Parameters<typeof create_plugin_context>[0];
     this.context = create_plugin_context(context_input);

package/src/city/types/PluginHostContext.ts

@@ -9,6 +9,7 @@
  */
 
 import type { JsonObject, Logger } from "@/index.js";
+import type { PluginNotificationPublisher } from "@/types/plugin/PluginNotification.js";
 
 /** City 可以为未来宿主能力增加的显式扩展集合。 */
 export type PluginHostExtensions = Readonly<Record<string, unknown>>;
@@ -27,6 +28,9 @@ export interface PluginHostContext {
   /** City 提供的宿主日志器。 */
   readonly logger: Logger;
 
+  /** 宿主可选提供的通知发布能力；不支持通知的宿主省略。 */
+  readonly notifications?: PluginNotificationPublisher;
+
   /** City 为未来宿主能力保留的显式扩展区。 */
   readonly extensions: PluginHostExtensions;
 }

package/src/executor/core-engine/CoreEngineError.ts

@@ -38,10 +38,16 @@ export function resolve_effective_core_engine_error(params: {
    */
   streamError?: unknown;
 }): string {
-  const outerError = String(params.error ?? "").trim();
-  const innerError = String(params.streamError ?? "").trim();
+  const outerError = read_error_message(params.error);
+  const innerError = read_error_message(params.streamError);
   if (/AI_NoOutputGeneratedError|No output generated/i.test(outerError) && innerError) {
     return innerError;
   }
   return outerError || innerError || "Unknown execution error";
 }
+
+/** 读取适合向上层展示的错误正文，避免泄漏内部 Error class 名称。 */
+function read_error_message(error: unknown): string {
+  if (error instanceof Error) return error.message.trim();
+  return String(error ?? "").trim();
+}