@steerable/agent-shell 0.6.51 → 0.6.53

package/dist/shell-process.js

@@ -0,0 +1,137 @@
+/**
+ * 本地进程启动：管道用 child_process，PTY 用 node-pty。
+ * SSH 也走这里，argv 由 shell-exec 规划好，本文件不再解释命令文本。
+ */
+import { spawn } from 'child_process';
+import * as pty from 'node-pty';
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
+export function stripAnsi(input) {
+    return input.replace(ANSI_RE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+export const nodeShellBackend = {
+    run(spec, limits) {
+        return spec.pty ? runPty(spec, limits) : runPipe(spec, limits);
+    },
+};
+function runPipe(spec, limits) {
+    return new Promise((resolve) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let truncated = false;
+        let settled = false;
+        const child = spawn(spec.file, spec.args, {
+            cwd: spec.cwd,
+            env: spec.env,
+            windowsHide: true,
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        const take = (chunks, bytes, chunk) => {
+            if (bytes >= limits.maxOutputBytes) {
+                truncated = true;
+                return bytes;
+            }
+            const remain = limits.maxOutputBytes - bytes;
+            const safe = chunk.length > remain ? chunk.subarray(0, remain) : chunk;
+            chunks.push(safe);
+            if (safe.length < chunk.length)
+                truncated = true;
+            return bytes + safe.length;
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdoutBytes = take(stdoutChunks, stdoutBytes, chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderrBytes = take(stderrChunks, stderrBytes, chunk);
+        });
+        const stdout = () => Buffer.concat(stdoutChunks).toString('utf-8');
+        const stderr = () => Buffer.concat(stderrChunks).toString('utf-8');
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                child.kill();
+            finish({
+                exitCode: -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        child.on('error', (err) => {
+            finish({ exitCode: -1, stdout: stdout(), stderr: stderr(), truncated, error: err.message });
+        });
+        child.on('close', (exitCode) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+            });
+        });
+    });
+}
+function runPty(spec, limits) {
+    return new Promise((resolve) => {
+        let output = '';
+        let truncated = false;
+        let settled = false;
+        const proc = pty.spawn(spec.file, spec.args, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 30,
+            cwd: spec.cwd,
+            env: { ...spec.env, TERM: 'xterm-256color' },
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        proc.onData((chunk) => {
+            const next = output + chunk;
+            if (Buffer.byteLength(next) > limits.maxOutputBytes) {
+                truncated = true;
+                output = trimToBytes(next, limits.maxOutputBytes);
+                return;
+            }
+            output = next;
+        });
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                proc.kill();
+            finish({
+                exitCode: -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        proc.onExit(({ exitCode }) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+            });
+        });
+    });
+}
+function trimToBytes(value, maxBytes) {
+    const buffer = Buffer.from(value);
+    return buffer.subarray(0, maxBytes).toString('utf-8');
+}

package/dist/sidecar/boot.d.ts

@@ -9,10 +9,13 @@ export interface HostSidecarDeps {
     /** W4-2 围栏：chatId → 项目家目录或无项目对话工作区。 */
     resolveProjectRoot: (chatId: string) => Promise<string | null>;
     /**
-     * 项目模式之外额外放行的只读根（会话附件目录等）。文件写入仍只受
-     * projectRoot 围栏约束；这些根只放宽 local_read_file 的读取范围。
+     * 额外只读根（会话附件目录、源文件夹）。只放宽 local_read_file，含子目录。
      */
     resolveAdditionalReadRoots?: (chatId: string) => string[] | Promise<string[]>;
+    /**
+     * 额外可写根（项目源文件夹）。放宽写入、编辑和命令 cwd，含各自子目录。
+     */
+    resolveAdditionalWriteRoots?: (chatId: string) => string[] | Promise<string[]>;
     /** W4-1 审批反向通道处理器（宿主审批弹窗的应答入口）。 */
     approvalHandler: ReturnType<typeof createApprovalBridge>['handler'];
     /**

package/dist/sidecar/boot.js

@@ -20,6 +20,7 @@ import { buildEgressProxyPlan, decideEgressProxy, ensureEgressProxyExecutable, d
 import { WEB_TOOL_RPC_TIMEOUT_MS, webToolsEnabled } from '../tool-router.js';
 import { sidecarWebSearchEnv } from '../storage/web-search-settings.js';
 import { executeHostedWebSearch } from '../hosted-web-search.js';
+import { getProductConfig } from '../product-config.js';
 let egressProxyRef = null;
 let supervisorRef = null;
 let sidecarGeneration = 0;
@@ -121,6 +122,9 @@ async function startEgressProxyIfEnabled(store) {
             ? {
                 STEERABLE_EGRESS_CONTROL_PORT: String(egressProxyRef.controlPort),
                 [plan.control.tokenEnv]: plan.control.tokenValue,
+                ...(getProductConfig().egressApproval === 'off'
+                    ? { STEERABLE_EGRESS_APPROVAL: 'off' }
+                    : {}),
             }
             : {};
         return {
@@ -214,6 +218,7 @@ export async function startHostSidecar(deps) {
             // root so ToolRouter's cwd/path confinement applies.
             resolveProjectRoot: deps.resolveProjectRoot,
             resolveAdditionalReadRoots: deps.resolveAdditionalReadRoots,
+            resolveAdditionalWriteRoots: deps.resolveAdditionalWriteRoots,
         }));
         // W4-1: approval algebra reverse channel — the sidecar's
         // ApprovalExecutor(HostApprover) asks here; the renderer modal answers

package/dist/sidecar/reverse-approval.d.ts

@@ -29,6 +29,8 @@ export interface ApprovalPromptRequest {
     mode: string;
     category: string;
     round: number;
+    /** Chat that asked. The renderer only shows the card in that composer. */
+    chatId?: string;
 }
 export interface ApprovalBridgeDeps {
     /**

package/dist/sidecar/reverse-approval.js

@@ -43,6 +43,7 @@ export function createApprovalBridge(deps) {
                 return deny('no renderer window available to approve the call');
             }
             const requestId = randomUUID();
+            const chatId = typeof p.chatId === 'string' && p.chatId ? p.chatId : undefined;
             const prompt = {
                 requestId,
                 toolName,
@@ -52,6 +53,7 @@ export function createApprovalBridge(deps) {
                 mode: typeof p.mode === 'string' ? p.mode : 'other',
                 category: typeof p.category === 'string' ? p.category : toolName,
                 round: typeof p.round === 'number' ? p.round : 0,
+                ...(chatId ? { chatId } : {}),
             };
             deps.onLog?.(`approval: prompting for ${toolName} (${prompt.mode}/${prompt.category})`);
             return await new Promise((resolve) => {

package/dist/sidecar/reverse-tools.d.ts

@@ -21,9 +21,13 @@ export interface ReverseToolDeps {
      */
     resolveProjectRoot?: (chatId: string) => Promise<string | null>;
     /**
-     * 额外放行的只读根（会话附件目录等）。写入仍只受 projectRoot 围栏约束，
-     * 这里只放宽 local_read_file 的读取范围。
+     * 额外只读根（会话附件目录、源文件夹）。只放宽读取，含各自子目录。
      */
     resolveAdditionalReadRoots?: (chatId: string) => string[] | Promise<string[]>;
+    /**
+     * 额外可写根（项目源文件夹）。放宽写入、编辑和命令 cwd，含各自子目录。
+     * 附件目录不进这里。
+     */
+    resolveAdditionalWriteRoots?: (chatId: string) => string[] | Promise<string[]>;
 }
 export declare function createToolInvokeHandler(deps: ReverseToolDeps): SidecarReverseHandler;

package/dist/sidecar/reverse-tools.js

@@ -74,6 +74,9 @@ export function createToolInvokeHandler(deps) {
         const additionalReadRoots = p.context?.chatId
             ? await Promise.resolve(deps.resolveAdditionalReadRoots?.(p.context.chatId) ?? [])
             : [];
+        const additionalWriteRoots = p.context?.chatId
+            ? await Promise.resolve(deps.resolveAdditionalWriteRoots?.(p.context.chatId) ?? [])
+            : [];
         if (name === 'local_exec_shell') {
             const classification = classifyShellCommand(String(toolArgs.command ?? ''));
             if (classification.severity === 'critical') {
@@ -94,7 +97,11 @@ export function createToolInvokeHandler(deps) {
             ? normalizeToolPolicy(p.context.toolPolicy)
             : null;
         const toolPolicy = normalizedPolicy && normalizedPolicy.mode !== 'all' ? normalizedPolicy : null;
-        const execContext = projectRoot || additionalReadRoots.length > 0 || p.context?.chatId || toolPolicy
+        const execContext = projectRoot ||
+            additionalReadRoots.length > 0 ||
+            additionalWriteRoots.length > 0 ||
+            p.context?.chatId ||
+            toolPolicy
             ? {
                 projectRoot,
                 chatId: p.context?.chatId,
@@ -102,6 +109,7 @@ export function createToolInvokeHandler(deps) {
                 // worktree_* 工具按它把任务绑定到来源对话。
                 ...(toolPolicy ? { toolPolicy } : {}),
                 ...(additionalReadRoots.length > 0 ? { additionalReadRoots } : {}),
+                ...(additionalWriteRoots.length > 0 ? { additionalWriteRoots } : {}),
             }
             : undefined;
         try {

package/dist/sidecar/types.d.ts

@@ -333,12 +333,15 @@ export interface SidecarChatStreamRequest {
      * executor with the six-tool orchestration family (agent_spawn /
      * agent_send / agent_wait / agent_close / agent_list / agent_interrupt).
      * When delegation is also on (it is by default), both surfaces share one
-     * agent pool — one maxParallel budget, one lineage space. */
+     * agent pool — one maxParallel budget, one lineage space.
+     * `childMaxRounds` / `childMaxToolErrors` default to the parent loop's
+     * limits. */
     orchestration?: {
         enabled?: boolean;
         maxDepth?: number;
         maxParallel?: number;
         childMaxRounds?: number;
+        childMaxToolErrors?: number;
     };
     /**
      * Sub-agent delegation (delegate-on-pool). ON BY DEFAULT on the sidecar —
@@ -451,6 +454,12 @@ export interface SidecarChatStreamRequest {
         mode: 'host' | 'auto';
         timeoutMs?: number;
         storePath?: string;
+        /**
+         * Project home, source folders, and other configured write roots.
+         * File tools whose targets all sit inside these directories skip the
+         * host prompt. Independent of whether the OS exec sandbox is on.
+         */
+        writableRoots?: string[];
     };
 }
 /**

package/dist/storage/write-lease-error.js

@@ -6,9 +6,12 @@ export function acquireWriteLeaseOrExit(acquire, loadElectron = () => import('el
     }
     catch (error) {
         if (error instanceof StoreAlreadyOwnedError) {
+            console.error(`[bs] 本地数据库正在被另一个进程使用（${error.lockPath}）。\n` +
+                '[bs] 再打开一次桌面应用会回到已经打开的窗口。\n' +
+                '[bs] 如果终端里的 pnpm dev:bs 占着数据库，请先在那个终端按 Ctrl+C 停掉，再重新打开。');
             void loadElectron()
                 .then(({ app, dialog }) => {
-                dialog.showErrorBox('无法启动', '另一个实例正在运行并占用本地数据库。请先关闭该实例，再重新打开应用。');
+                dialog.showErrorBox('无法再开一个', '再打开一次应用时，会回到已经打开的窗口。\n\n这次没有回到那个窗口，是因为本地数据库正被另一个进程占用。如果终端里还在跑 pnpm dev:bs，先停掉它，再重新打开。');
                 app.exit(1);
             })
                 .catch(() => exitProcess(1));

package/dist/tool-presentation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 一等工具的展示声明。
+ *
+ * 卡片种类和标题从这里按工具名取，不从名字前缀猜测。
+ * 未声明的名字（MCP、插件、场景包）落到 generic / other，`declared: false`。
+ * 宿主在 executed_actions 上盖 `view`，卡片读这份声明。
+ */
+export declare const TOOL_CARDS: readonly ["generic", "terminal", "diff", "search", "read", "web"];
+export type ToolCard = (typeof TOOL_CARDS)[number];
+export declare const TOOL_KINDS: readonly ["read", "edit", "delete", "move", "search", "execute", "fetch", "other"];
+export type ToolKind = (typeof TOOL_KINDS)[number];
+export interface ToolCallView {
+    card: ToolCard;
+    kind: ToolKind;
+    title: string;
+    /** 名字在声明表里。false 表示通用回退，不是从名字前缀推断出来的。 */
+    declared: boolean;
+}
+/**
+ * 取一次调用的展示。`result` 缺省时只根据参数出标题；结果到达后用同一声明补计数和状态。
+ */
+export declare function presentToolCall(name: string, args: unknown, result?: unknown): ToolCallView;
+export declare function declaredToolNames(): readonly string[];

package/dist/tool-presentation.js

@@ -0,0 +1,266 @@
+/**
+ * 一等工具的展示声明。
+ *
+ * 卡片种类和标题从这里按工具名取，不从名字前缀猜测。
+ * 未声明的名字（MCP、插件、场景包）落到 generic / other，`declared: false`。
+ * 宿主在 executed_actions 上盖 `view`，卡片读这份声明。
+ */
+export const TOOL_CARDS = ['generic', 'terminal', 'diff', 'search', 'read', 'web'];
+export const TOOL_KINDS = [
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'fetch',
+    'other',
+];
+function clip(text, max = 60) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    if (!trimmed)
+        return '';
+    return trimmed.length > max ? `${trimmed.slice(0, max - 1)}…` : trimmed;
+}
+function str(args, key) {
+    const value = args[key];
+    return typeof value === 'string' ? value : '';
+}
+function dataOf(result) {
+    if (!result || typeof result !== 'object')
+        return null;
+    const data = result.data;
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+        return data;
+    }
+    return result;
+}
+function failed(result) {
+    return Boolean(result && typeof result === 'object' && result.success === false);
+}
+function commandTitle(args) {
+    return clip(str(args, 'command')) || 'shell';
+}
+function pathTitle(args, fallback) {
+    return clip(str(args, 'path') || str(args, 'file') || str(args, 'target'), 72) || fallback;
+}
+function webSearchTitle(args, result) {
+    const query = str(args, 'query');
+    const head = `搜索“${clip(query, 40) || '…'}”`;
+    if (result === undefined || failed(result))
+        return head;
+    const data = dataOf(result);
+    const count = data && typeof data.result_count === 'number' ? data.result_count : null;
+    return count === null ? head : `${head} → ${count} 条结果`;
+}
+function shortUrl(raw) {
+    if (!raw)
+        return '未知地址';
+    try {
+        const url = new URL(raw);
+        const path = url.pathname === '/' ? '' : url.pathname;
+        return clip(`${url.host}${path}`, 48);
+    }
+    catch {
+        return clip(raw, 48);
+    }
+}
+function webFetchTitle(args, result) {
+    const head = `抓取 ${shortUrl(str(args, 'url'))}`;
+    if (result === undefined || failed(result))
+        return head;
+    const data = dataOf(result);
+    if (!data)
+        return head;
+    const parts = [];
+    if (typeof data.status === 'number')
+        parts.push(String(data.status));
+    if (typeof data.bytes === 'number' && Number.isFinite(data.bytes)) {
+        parts.push(data.bytes < 1024 ? `${data.bytes} B` : `${(data.bytes / 1024).toFixed(1)} KB`);
+    }
+    if (data.truncated === true)
+        parts.push('已截断');
+    return parts.length > 0 ? `${head} → ${parts.join(' · ')}` : head;
+}
+function taskRunTitle(args, result) {
+    const task = clip(str(args, 'task'));
+    if (!task)
+        return '后台任务';
+    const status = dataOf(result)?.status;
+    if (status === 'blocked')
+        return `${task} · 等待依赖`;
+    if (args.worktree === true)
+        return `${task} · 隔离工作区`;
+    return task;
+}
+function jobIdTitle(args, fallback) {
+    const id = str(args, 'job_id') || str(args, 'taskId');
+    return id ? id.slice(0, 8) : fallback;
+}
+function runCodeTitle(args, result) {
+    const description = clip(str(args, 'description'), 40) || '程序';
+    if (failed(result))
+        return `程序「${description}」失败`;
+    const calls = dataOf(result)?.calls;
+    const count = Array.isArray(calls) ? calls.length : 0;
+    return count > 0 ? `程序「${description}」· ${count} 个内层工具` : `程序「${description}」`;
+}
+function goalTitle(args, fallback) {
+    return clip(str(args, 'objective'), 72) || fallback;
+}
+const PRESENTERS = {
+    local_exec_shell: { card: 'terminal', kind: 'execute', title: commandTitle },
+    pwsh: { card: 'terminal', kind: 'execute', title: commandTitle },
+    bash: { card: 'terminal', kind: 'execute', title: commandTitle },
+    bash_session: { card: 'terminal', kind: 'execute', title: commandTitle },
+    write_stdin: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => clip(str(args, 'chars'), 40) || str(args, 'sessionId').slice(0, 8) || 'stdin',
+    },
+    local_run_snippet: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => clip(str(args, 'code'), 48) || str(args, 'language') || 'snippet',
+    },
+    local_run_script: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => str(args, 'scriptId') || 'script',
+    },
+    run_code: { card: 'generic', kind: 'execute', title: runCodeTitle },
+    run_js: { card: 'generic', kind: 'execute', title: runCodeTitle },
+    wait_js: {
+        card: 'generic',
+        kind: 'execute',
+        title: (args) => str(args, 'id').slice(0, 8) || 'wait_js',
+    },
+    local_read_file: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'read') },
+    read_file: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'read') },
+    view_image: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'image') },
+    capture_display: {
+        card: 'read',
+        kind: 'read',
+        title: (args) => clip(str(args, 'target'), 48) || 'display',
+    },
+    local_list_scripts: { card: 'read', kind: 'read', title: () => '已保存的脚本' },
+    local_write_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'write') },
+    write_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'write') },
+    local_edit_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'edit') },
+    edit_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'edit') },
+    apply_patch: { card: 'diff', kind: 'edit', title: () => 'apply_patch' },
+    grep: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'pattern')) || 'grep',
+    },
+    glob: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'pattern')) || 'glob',
+    },
+    tool_search: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'query')) || 'tool_search',
+    },
+    web_search: { card: 'web', kind: 'search', title: webSearchTitle },
+    web_fetch: { card: 'web', kind: 'fetch', title: webFetchTitle },
+    task_run: { card: 'generic', kind: 'other', title: taskRunTitle },
+    task_send: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'message')) || '转达任务',
+    },
+    task_status: {
+        card: 'generic',
+        kind: 'read',
+        title: (args, result) => {
+            const id = str(args, 'taskId');
+            if (id)
+                return id.slice(0, 8);
+            const total = dataOf(result)?.total;
+            return typeof total === 'number' ? `${total} 个任务` : '本会话';
+        },
+    },
+    task_result: {
+        card: 'generic',
+        kind: 'read',
+        title: (args) => jobIdTitle(args, '收取结果'),
+    },
+    job_list: {
+        card: 'generic',
+        kind: 'read',
+        title: (_args, result) => {
+            const total = dataOf(result)?.total;
+            return typeof total === 'number' ? `${total} 个任务` : '后台任务';
+        },
+    },
+    job_output: { card: 'generic', kind: 'read', title: (args) => jobIdTitle(args, '任务输出') },
+    job_kill: { card: 'generic', kind: 'delete', title: (args) => jobIdTitle(args, '结束任务') },
+    worktree_create: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => str(args, 'name') || '新建工作区',
+    },
+    worktree_list: { card: 'read', kind: 'read', title: () => '工作区列表' },
+    worktree_remove: {
+        card: 'generic',
+        kind: 'delete',
+        title: (args) => str(args, 'name') || '移除工作区',
+    },
+    get_goal: { card: 'generic', kind: 'read', title: () => '当前目标' },
+    create_goal: { card: 'generic', kind: 'other', title: (args) => goalTitle(args, '新建目标') },
+    update_goal: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => {
+            const action = str(args, 'action');
+            const objective = clip(str(args, 'objective'), 48);
+            return objective ? `${action || 'update'} ${objective}` : action || '更新目标';
+        },
+    },
+    present_files: { card: 'generic', kind: 'other', title: () => '交付文件' },
+    local_open_path: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => pathTitle(args, 'open'),
+    },
+    todo_write: { card: 'generic', kind: 'other', title: () => '待办' },
+    ask_user: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'intro') || str(args, 'question')) || '提问',
+    },
+    skill: { card: 'generic', kind: 'read', title: (args) => str(args, 'name') || 'skill' },
+    delegate_subagent: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'task')) || str(args, 'subagent_type') || '子代理',
+    },
+    mcp_list_tools: { card: 'generic', kind: 'fetch', title: () => 'MCP 工具' },
+    mcp_tool_exec: {
+        card: 'generic',
+        kind: 'fetch',
+        title: (args) => str(args, 'toolName') || 'MCP',
+    },
+    plugin_list: { card: 'generic', kind: 'read', title: () => '插件' },
+    plugin_enable: { card: 'generic', kind: 'other', title: (args) => str(args, 'name') || '启用插件' },
+    plugin_disable: { card: 'generic', kind: 'delete', title: (args) => str(args, 'name') || '停用插件' },
+    plugin_reload: { card: 'generic', kind: 'other', title: (args) => str(args, 'name') || '重载插件' },
+};
+/**
+ * 取一次调用的展示。`result` 缺省时只根据参数出标题；结果到达后用同一声明补计数和状态。
+ */
+export function presentToolCall(name, args, result) {
+    const record = args && typeof args === 'object' && !Array.isArray(args) ? args : {};
+    const presenter = PRESENTERS[name];
+    if (!presenter) {
+        return { card: 'generic', kind: 'other', title: name, declared: false };
+    }
+    const title = presenter.title(record, result).trim() || name;
+    return { card: presenter.card, kind: presenter.kind, title, declared: true };
+}
+export function declaredToolNames() {
+    return Object.keys(PRESENTERS);
+}