@downcity/agent 1.1.408 → 1.1.437

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

@@ -1,363 +0,0 @@
-/**
- * @file 验证 Turn 失败收口与最终 Assistant 快照顺序。
- */
-
-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 { SessionInteractions } from "../bin/session/control/SessionInteractions.js";
-import { SessionShellApprovalAdapter } from "../bin/session/execution/tools/SessionShellApprovalAdapter.js";
-import { JsonlSessionMessageStore } from "../bin/workspace/store/JsonlSessionMessageStore.js";
-import { LocalFileSystem } from "@downcity/workspace";
-import { SessionMessages } from "../bin/session/SessionMessages.js";
-import { SessionEventHub } from "../bin/session/runtime/SessionEventHub.js";
-import { SessionLoop } from "../bin/session/SessionLoop.js";
-import { SessionQueue } from "../bin/session/SessionQueue.js";
-
-async function create_turn_harness(execute_turn) {
-  const session_id = "session-turn-failure-test";
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-turn-failure-"));
-  const messages = new SessionMessages({
-    session_id,
-    store: new JsonlSessionMessageStore({
-      files: new LocalFileSystem(root_path),
-      session_id,
-      file_path: path.join(root_path, "active.jsonl"),
-    }),
-    publish: () => {},
-  });
-  await messages.initialize();
-  const interactions = new SessionInteractions({ session_id, messages });
-  const shell_approval_gateway = new SessionShellApprovalAdapter({
-    session_id,
-    interactions,
-  });
-
-  const turn = new SessionLoop({
-    session_id,
-    workspace_path: root_path,
-    executor: {
-      execute: async ({ turn_context }) => await execute_turn(turn_context),
-    },
-    compact_history: async () => ({ compacted: false, reason: "nothing_to_compact" }),
-    state: {
-      ensure_runnable: async () => {},
-      schedule_title_generation: () => {},
-      touch_metadata: async () => {},
-      touch_metadata_in_background: () => {},
-    },
-    messages,
-    events: new SessionEventHub(),
-    logger: { log: async () => {} },
-    queue: new SessionQueue(),
-    interactions,
-    shell_approval_gateway,
-  });
-
-  return { messages, turn };
-}
-
-/** 通过 Downcity Model Protocol 写入一个完整文本 part。 */
-async function write_text(output, content_id, text) {
-  await output.write_model_event({ type: "text_start", content_id });
-  await output.write_model_event({ type: "text_delta", content_id, delta: text });
-  await output.write_model_event({ type: "text_finish", content_id });
-}
-
-/** 通过 Downcity Model Protocol 写入一个完整工具调用。 */
-async function write_tool_call(output, input) {
-  await output.write_model_event({
-    type: "tool_call_start",
-    content_id: input.content_id,
-    tool_call_id: input.tool_call_id,
-    tool_name: input.tool_name,
-  });
-  await output.write_model_event({
-    type: "tool_call_finish",
-    content_id: input.content_id,
-    input: input.tool_input,
-  });
-}
-
-test("Provider 在输出前失败时只持久化 Error Message", async () => {
-  const { messages, turn } = await create_turn_harness(async () => ({
-    success: false,
-    text: "",
-    error: "quota exceeded",
-    deferred_persisted_user_messages: [],
-  }));
-
-  const handle = await turn.prompt({ query: "hello" });
-  const result = await handle.finished;
-  const page = await messages.list_messages();
-
-  assert.equal(result.success, false);
-  assert.equal(result.error, "quota exceeded");
-  assert.equal(result.assistant_message, undefined);
-  assert.deepEqual(page.items.map((message) => message.type), ["user", "error"]);
-  assert.equal(page.items[1].code, "turn_execution_failed");
-  assert.equal(page.items[1].message, "quota exceeded");
-});
-
-test("SessionLoop 只在 canonical 用户消息写入后返回 prompt 句柄", async () => {
-  let finish_execution;
-  const execution_finished = new Promise((resolve) => {
-    finish_execution = resolve;
-  });
-  const { messages, turn } = await create_turn_harness(async () => {
-    await execution_finished;
-    return {
-      success: true,
-      text: "done",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "已持久化的输入" });
-  const page = await messages.list_messages();
-
-  assert.equal(handle.result, null);
-  assert.deepEqual(page.items.map((message) => message.type), ["user"]);
-  assert.equal(page.items[0].parts[0].text, "已持久化的输入");
-
-  finish_execution();
-  await handle.finished;
-});
-
-test("SessionLoop 在 Turn 收口后释放其 SessionTurnContext", async () => {
-  let release_count = 0;
-  const { turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.step.replace_plugins({
-      read: () => ({ plugins: [] }),
-      run_action: async () => ({ success: true }),
-      system_blocks: async () => [],
-      release: async () => {
-        release_count += 1;
-      },
-    });
-    return {
-      success: true,
-      text: "done",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "hello" });
-  await handle.finished;
-
-  assert.equal(release_count, 1);
-});
-
-test("Provider 在部分输出后失败时保留 failed Assistant 并追加 Error Message", async () => {
-  const { messages, turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.output.assistant.begin_step();
-    await write_text(turn_context.output.assistant, "text-1", "partial response");
-    return {
-      success: false,
-      text: "partial response",
-      error: "stream interrupted",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "hello" });
-  const result = await handle.finished;
-  const page = await messages.list_messages();
-
-  assert.equal(result.success, false);
-  assert.equal(result.assistant_message, undefined);
-  assert.deepEqual(page.items.map((message) => message.type), [
-    "user",
-    "assistant",
-    "error",
-  ]);
-  assert.equal(page.items[1].status, "failed");
-  assert.equal(page.items[1].parts[0].text, "partial response");
-  assert.equal(page.items[2].message, "stream interrupted");
-});
-
-test("Assistant 失败收口时不会遗留 input-streaming Tool Part", async () => {
-  const { messages, turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.output.assistant.begin_step();
-    await turn_context.output.assistant.write_model_event({
-      type: "tool_call_start",
-      content_id: "tool-1",
-      tool_call_id: "call-1",
-      tool_name: "shell_exec",
-    });
-    await turn_context.output.assistant.write_model_event({
-      type: "tool_call_delta",
-      content_id: "tool-1",
-      input_delta: '{"cmd":"pwd"}',
-    });
-    return {
-      success: false,
-      text: "",
-      error: "stream interrupted",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "hello" });
-  await handle.finished;
-  const page = await messages.list_messages();
-  const assistant = page.items.find((message) => message.type === "assistant");
-
-  assert.equal(assistant?.status, "failed");
-  assert.equal(assistant?.parts[0]?.type, "tool");
-  assert.equal(assistant?.parts[0]?.state, "failed");
-  assert.equal(assistant?.parts[0]?.error, "stream interrupted");
-});
-
-test("Turn 使用标准模型事件保持 Tool 与最终正文顺序", async () => {
-  const { messages, turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.output.assistant.begin_step();
-    await write_tool_call(turn_context.output.assistant, {
-      content_id: "tool-1",
-      tool_call_id: "call-1",
-      tool_name: "shell_exec",
-      tool_input: { cmd: "pwd" },
-    });
-    await turn_context.output.assistant.write_tool_result({
-      tool_call_id: "call-1",
-      tool_name: "shell_exec",
-      succeeded: true,
-      output: { success: true },
-    });
-    await write_text(turn_context.output.assistant, "text-1", "最终结论");
-    const assistant_parts = [
-        {
-          part_id: "tool:call-1",
-          sequence: 1,
-          type: "tool",
-          tool_call_id: "call-1",
-          tool_name: "shell_exec",
-          state: "completed",
-          input: { cmd: "pwd" },
-          output: { success: true },
-        },
-        { part_id: "text:text-1", sequence: 2, type: "text", text: "最终结论", state: "done" },
-      ];
-    await turn_context.output.assistant.finish_step(assistant_parts);
-    return {
-      success: true,
-      text: "最终结论",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "diagnose" });
-  const result = await handle.finished;
-  const page = await messages.list_messages();
-  const assistant = page.items.find((message) => message.type === "assistant");
-
-  assert.equal(result.success, true);
-  assert.deepEqual(assistant.parts.map((part) => part.type), ["tool", "text"]);
-  assert.deepEqual(assistant.parts.map((part) => part.sequence), [1, 2]);
-});
-
-test("普通 Tool Loop 的多个 Provider Step 始终写入同一个 Assistant Message", async () => {
-  const { messages, turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.output.assistant.begin_step();
-    await write_text(turn_context.output.assistant, "text-1", "先检查项目。");
-    await write_tool_call(turn_context.output.assistant, {
-      content_id: "tool-1",
-      tool_call_id: "call-1",
-      tool_name: "shell_exec",
-      tool_input: { cmd: "pnpm typecheck" },
-    });
-    await turn_context.output.assistant.write_tool_result({
-      tool_call_id: "call-1",
-      tool_name: "shell_exec",
-      succeeded: true,
-      output: { success: true },
-    });
-    await turn_context.output.assistant.finish_step([
-        { part_id: "text:text-1", sequence: 1, type: "text", text: "先检查项目。", state: "done" },
-        {
-          part_id: "tool:call-1",
-          sequence: 2,
-          type: "tool",
-          tool_call_id: "call-1",
-          tool_name: "shell_exec",
-          state: "completed",
-          input: { cmd: "pnpm typecheck" },
-          output: { success: true },
-        },
-      ]);
-
-    await turn_context.output.assistant.begin_step();
-    await write_text(turn_context.output.assistant, "text-2", "检查完成。");
-    await turn_context.output.assistant.finish_step([
-      { part_id: "text:text-2", sequence: 1, type: "text", text: "检查完成。", state: "done" },
-    ]);
-    return {
-      success: true,
-      text: "检查完成。",
-      deferred_persisted_user_messages: [],
-    };
-  });
-
-  const handle = await turn.prompt({ query: "检查项目" });
-  await handle.finished;
-  const page = await messages.list_messages();
-  const assistant_messages = page.items.filter(
-    (message) => message.type === "assistant",
-  );
-
-  assert.equal(assistant_messages.length, 1);
-  assert.deepEqual(
-    assistant_messages[0].parts.map((part) => part.type),
-    ["text", "tool", "text"],
-  );
-  assert.deepEqual(
-    assistant_messages[0].parts
-      .filter((part) => part.type === "text")
-      .map((part) => part.text),
-    ["先检查项目。", "检查完成。"],
-  );
-});
-
-test("Turn 在 step 最终快照出现未流式写入的 Tool 时失败", async () => {
-  const { messages, turn } = await create_turn_harness(async (turn_context) => {
-    await turn_context.output.assistant.begin_step();
-    await write_text(turn_context.output.assistant, "text-1", "最终结论");
-    try {
-      await turn_context.output.assistant.finish_step([
-          {
-            part_id: "tool:call-1",
-            sequence: 1,
-            type: "tool",
-            tool_call_id: "call-1",
-            tool_name: "shell_exec",
-            state: "completed",
-            input: { cmd: "pwd" },
-            output: { success: true },
-          },
-          { part_id: "text:text-1", sequence: 2, type: "text", text: "最终结论", state: "done" },
-        ]);
-    } catch (error) {
-      await turn_context.output.assistant.abort_step();
-      return {
-        success: false,
-        text: "最终结论",
-        error: error.message,
-        deferred_persisted_user_messages: [],
-      };
-    }
-  });
-
-  const handle = await turn.prompt({ query: "diagnose" });
-  const result = await handle.finished;
-  const page = await messages.list_messages();
-  const assistant = page.items.find((message) => message.type === "assistant");
-
-  assert.equal(result.success, false);
-  assert.match(result.error, /snapshot mismatch/);
-  assert.equal(assistant.status, "failed");
-  assert.deepEqual(assistant.parts.map((part) => part.type), ["text"]);
-  assert.equal(page.items.at(-1).type, "error");
-});

package/scripts/workspace.test.mjs

@@ -1,260 +0,0 @@
-/**
- * @file 验证 Workspace 的资源边界、工具装配与独立生命周期。
- */
-
-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";
-
-test("Agent runtime uses memory data when no City is attached", async (t) => {
-  const fixture_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-root-"));
-  const project_path = path.join(fixture_root, "project");
-  await fs.mkdir(project_path);
-  const agent = new Agent({ id: "internal-root-agent" });
-  const entry = create_workspace_entry(agent, new Workspace({
-    id: "internal-root-workspace",
-    path: project_path,
-  }));
-  t.after(async () => {
-    await agent.dispose();
-    await fs.rm(fixture_root, { recursive: true, force: true });
-  });
-
-  assert.equal(entry.data_path, "/memory/agents/internal-root-agent");
-});
-
-test("Workspace exposes file tools without requiring Shell", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-"));
-
-  const workspace = new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") });
-  const agent = new Agent({ id: "workspace-files" });
-  const entry = create_workspace_entry(agent, workspace);
-  t.after(async () => {
-    await agent.dispose();
-    await fs.rm(root_path, { recursive: true, force: true });
-  });
-
-  assert.equal(workspace.path, await fs.realpath(root_path));
-  assert.deepEqual(Object.keys(workspace.tools).sort(), [
-    "edit",
-    "find",
-    "grep",
-    "read",
-    "write",
-  ]);
-  assert.equal(entry.workspace, workspace);
-  assert.equal(entry.get_shell(), undefined);
-});
-
-test("one unbound Workspace instance belongs to one Agent", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-shared-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  let dispose_count = 0;
-  const shell = {
-    tools: { shell_exec: {} },
-    bind(binding) {
-      assert.equal(binding.root_path, workspace_path);
-      assert.equal(binding.data_path, workspace_path);
-    },
-    set_env(env) {
-      assert.deepEqual(env, {});
-    },
-    async run_safe_command() {
-      throw new Error("not used");
-    },
-    async dispose() {
-      dispose_count += 1;
-    },
-  };
-  const workspace_path = await fs.realpath(root_path);
-  const workspace = new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data"), shell });
-  const agent = new Agent({ id: "workspace-first" });
-  const second_agent = new Agent({ id: "workspace-second" });
-  create_workspace_entry(agent, workspace);
-  assert.throws(
-    () => create_workspace_entry(second_agent, workspace),
-    /already bound to another scope/,
-  );
-
-  await agent.dispose();
-  await second_agent.dispose();
-  assert.equal(dispose_count, 1);
-});
-
-test("separate Workspace instances may use the same directory", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-directory-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const first_agent = new Agent({ id: "workspace-directory-first" });
-  const second_agent = new Agent({ id: "workspace-directory-second" });
-  const first_entry = create_workspace_entry(first_agent, new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }));
-  const second_entry = create_workspace_entry(second_agent, new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }));
-  assert.notEqual(first_entry.data_path, second_entry.data_path);
-  const first_session = await first_entry.sessions.create();
-  const second_session = await second_entry.sessions.create();
-  assert.deepEqual(
-    (await first_entry.sessions.list()).items.map((item) => item.session_id),
-    [first_session.id],
-  );
-  assert.deepEqual(
-    (await second_entry.sessions.list()).items.map((item) => item.session_id),
-    [second_session.id],
-  );
-
-  await first_agent.dispose();
-  await second_agent.dispose();
-});
-
-test("同一 Agent 的 Workspace Session 列表彼此隔离", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-session-filter-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const agent = new Agent({ id: "workspace-session-filter" });
-  const first_entry = create_workspace_entry(agent, new Workspace({
-    id: "workspace-first",
-    path: root_path,
-    data_root_path: path.join(root_path, "data"),
-  }));
-  const second_entry = create_workspace_entry(agent, new Workspace({
-    id: "workspace-second",
-    path: root_path,
-    data_root_path: path.join(root_path, "data"),
-  }));
-  t.after(async () => await agent.dispose());
-
-  const first_session = await first_entry.sessions.create();
-  const second_session = await second_entry.sessions.create();
-  assert.deepEqual((await first_entry.sessions.list()).items.map((item) => item.session_id), [first_session.id]);
-  assert.deepEqual((await second_entry.sessions.list()).items.map((item) => item.session_id), [second_session.id]);
-});
-
-test("恢复绑定 Workspace 的 Session 必须提供同一个 Workspace", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-workspace-restore-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const agent = new Agent({ id: "workspace-restore-agent" });
-  const workspace = new Workspace({
-    id: "restore-workspace",
-    path: root_path,
-    data_root_path: path.join(root_path, "data"),
-  });
-  const entry = create_workspace_entry(agent, workspace);
-  try {
-    const session = await entry.sessions.create();
-    await assert.rejects(
-      agent.sessions.get(session.id),
-      /requires Workspace "restore-workspace"/u,
-    );
-    assert.equal((await entry.sessions.get(session.id, { workspace })).id, session.id);
-  } finally {
-    await agent.dispose();
-  }
-});
-
-test("Session IDs are isolated by Agent in one Workspace", async (t) => {
-  const root_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-workspace-session-owner-"),
-  );
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const data_root_path = path.join(root_path, "data");
-  const first_agent = new Agent({ id: "session-owner-first" });
-  const second_agent = new Agent({ id: "session-owner-second" });
-  const first_entry = create_workspace_entry(first_agent, new Workspace({
-    id: "test_workspace",
-    path: root_path,
-    data_root_path,
-  }));
-  const second_entry = create_workspace_entry(second_agent, new Workspace({
-    id: "test_workspace",
-    path: root_path,
-    data_root_path,
-  }));
-
-  const results = await Promise.allSettled([
-    first_entry.sessions.create({ session_id: "shared-session" }),
-    second_entry.sessions.create({ session_id: "shared-session" }),
-  ]);
-  assert.equal(results.every((result) => result.status === "fulfilled"), true);
-
-  await first_agent.dispose();
-  await second_agent.dispose();
-});
-
-test("Workspace owns env and publishes only real changes", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-env-"));
-  await fs.writeFile(path.join(root_path, ".env"), "FROM_FILE=file\nOVERRIDE=file\n");
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const shell_env_snapshots = [];
-  const shell = {
-    tools: {},
-    bind() {},
-    set_env(env) {
-      shell_env_snapshots.push({ ...env });
-    },
-    async run_safe_command() {
-      throw new Error("not used");
-    },
-    async dispose() {},
-  };
-
-  const workspace = new Workspace({ id: "test_workspace",
-    path: root_path, data_root_path: path.join(root_path, "data"),
-    shell,
-    env: { OVERRIDE: "explicit", EXPLICIT: "value" },
-  });
-  const changes = [];
-  const unsubscribe = workspace.subscribe_env((env) => changes.push({ ...env }));
-
-  assert.deepEqual(workspace.get_env(), {
-    FROM_FILE: "file",
-    OVERRIDE: "explicit",
-    EXPLICIT: "value",
-  });
-  assert.deepEqual(shell_env_snapshots, [workspace.get_env()]);
-  workspace.patch_env({ OVERRIDE: "explicit" });
-  assert.equal(changes.length, 0);
-
-  workspace.patch_env({ FROM_FILE: null, NEXT: "next" });
-  assert.deepEqual(changes, [{
-    OVERRIDE: "explicit",
-    EXPLICIT: "value",
-    NEXT: "next",
-  }]);
-  assert.deepEqual(shell_env_snapshots.at(-1), changes.at(-1));
-
-  unsubscribe();
-  workspace.set_env({ ONLY: "one" });
-  assert.deepEqual(workspace.get_env(), { ONLY: "one" });
-  assert.equal(changes.length, 1);
-  assert.deepEqual(shell_env_snapshots.at(-1), { ONLY: "one" });
-  await workspace.dispose();
-});
-
-test("Agent rejects Workspace, Plugin and custom Tool name conflicts", async (t) => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-workspace-tools-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-
-  const workspace_conflict_agent = new Agent({
-    id: "workspace-tool-conflict",
-    tools: { read: {} },
-  });
-  assert.throws(
-    () => create_workspace_entry(workspace_conflict_agent,
-      new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }),
-    ),
-    /Agent tool name conflict: "read"/,
-  );
-  const plugin_conflict_agent = new Agent({
-    id: "plugin-tool-conflict",
-    tools: { plugin_call: {} },
-  });
-  assert.throws(
-    () => create_workspace_entry(plugin_conflict_agent,
-      new Workspace({ id: "test_workspace", path: root_path, data_root_path: path.join(root_path, "data") }),
-    ),
-    /reserved for PluginRegistry/,
-  );
-  await Promise.all([workspace_conflict_agent.dispose(), plugin_conflict_agent.dispose()]);
-});

package/src/agent/AgentModel.ts

@@ -1,66 +0,0 @@
-/**
- * AgentModel：Agent 与 Session 统一使用的运行时模型协议。
- *
- * 关键点（中文）
- * - Agent 与 Session 对外统一接收 Downcity ModelClient。
- * - CityModel 自身实现 ModelClient，executor 可以直接调用。
- * - 这里不依赖 @downcity/agent，只依赖 @downcity/type 的共享协议。
- */
-
-import {
-  isCityModel,
-  type ModelClient,
-} from "@downcity/type";
-
-/**
- * Agent SDK 可接受的模型输入。
- */
-export type AgentModel = ModelClient;
-
-/**
- * 将 Agent 可接受的模型输入归一为 Downcity ModelClient。
- */
-export function normalize_agent_model(model: AgentModel): ModelClient {
-  return model;
-}
-
-/**
- * 从 Agent 模型输入读取已声明的上下文窗口。
- *
- * 只有 CityModel 携带可信的模型目录元数据；其它 ModelClient 未声明时返回空。
- */
-export function read_agent_model_context_window(
-  model: AgentModel | undefined,
-): number | undefined {
-  if (!model || !isCityModel(model)) return undefined;
-  const context_window = model.context_window;
-  return Number.isSafeInteger(context_window) && Number(context_window) > 0
-    ? Number(context_window)
-    : undefined;
-}
-
-/**
- * 从 Agent 模型输入推导展示标签。
- */
-export function infer_agent_model_label(model: AgentModel | undefined): string | undefined {
-  if (!model) return undefined;
-  if (isCityModel(model)) return model.name || model.id;
-  if (typeof model !== "object") return undefined;
-  const record = model as unknown as Record<string, unknown>;
-  const candidates = [
-    record.modelId,
-    record.model,
-    record.id,
-    record.name,
-    record.label,
-  ];
-  for (const candidate of candidates) {
-    const label = typeof candidate === "string" ? candidate.trim() : "";
-    if (label) return label;
-  }
-  const constructorName =
-    model.constructor && typeof model.constructor.name === "string"
-      ? model.constructor.name.trim()
-      : "";
-  return constructorName || "configured-model";
-}