mocode-ai 1.3.9 → 1.4.0

package/dist/tools/builtins/view-image.js

@@ -1,4 +1,4 @@
-import { loadImageAttachment, MAX_INLINE_BYTES_DEFAULT, } from '../../attachments/image.js';
+import { loadImageAttachment, MAX_INLINE_BYTES_DEFAULT } from '../../attachments/image.js';
 export const viewImageTool = {
     name: 'view_image',
     description: 'View a local image as visual model input. Use this whenever the user refers to a screenshot, UI error, design mockup, Figma export, diagram, or other image file. Supports PNG, JPEG, GIF, and WebP up to 4 MiB.',
@@ -37,13 +37,15 @@ export const viewImageTool = {
             code: 'OK',
             retryable: false,
             output: `Viewed image "${att.name}" (${att.mime}, ${att.bytes} bytes). Visual content is attached to the next model request.`,
-            modelAttachments: [{
+            modelAttachments: [
+                {
                     type: 'image',
                     name: att.name,
                     mime: att.mime,
                     dataUrl: att.dataUrl,
                     detail,
-                }],
+                },
+            ],
         };
     },
 };

package/dist/tools/builtins/web-fetch.js

@@ -56,9 +56,7 @@ export const webFetchTool = {
                     output: `错误:抓取失败 HTTP ${resp.status} ${resp.statusText}\n${text.slice(0, 500)}`,
                 };
             }
-            const isHtml = /html/i.test(contentType) ||
-                /^\s*<!doctype html/i.test(text) ||
-                /<html[\s>]/i.test(text.slice(0, 1000));
+            const isHtml = /html/i.test(contentType) || /^\s*<!doctype html/i.test(text) || /<html[\s>]/i.test(text.slice(0, 1000));
             const body = isHtml ? htmlToText(text) : text;
             const ct = contentType.split(';')[0].trim();
             const prefix = `${url.href} (HTTP ${resp.status}${ct ? ', ' + ct : ''})\n\n`;

package/dist/tools/builtins/web-search.js

@@ -37,9 +37,7 @@ export const webSearchTool = {
             body.tag = String(args.tag);
         if (args.language)
             body.language = String(args.language);
-        if (args.params &&
-            typeof args.params === 'object' &&
-            !Array.isArray(args.params)) {
+        if (args.params && typeof args.params === 'object' && !Array.isArray(args.params)) {
             body.params = args.params;
         }
         const base = config.searchBaseUrl.replace(/\/+$/, '');
@@ -100,8 +98,7 @@ export const webSearchTool = {
                 return {
                     status: 'error',
                     code: !resp.ok || Number(code) === 429 ? 'HTTP_ERROR' : 'EXECUTION_ERROR',
-                    retryable: resp.status === 408 || resp.status === 429 ||
-                        resp.status >= 500 || Number(code) === 429,
+                    retryable: resp.status === 408 || resp.status === 429 || resp.status >= 500 || Number(code) === 429,
                     output: `错误:搜索失败 [${code}] ${message}${rid}${hint}`,
                 };
             }
@@ -122,8 +119,7 @@ export const webSearchTool = {
                     lines.push(`    ${snippet}`);
                 if (content) {
                     const c = content.length > MAX_CONTENT_CHARS
-                        ? content.slice(0, MAX_CONTENT_CHARS) +
-                            ` …(共 ${content.length} 字符)`
+                        ? content.slice(0, MAX_CONTENT_CHARS) + ` …(共 ${content.length} 字符)`
                         : content;
                     lines.push(`    ${c}`);
                 }

package/dist/tools/builtins/write-file.js

@@ -37,12 +37,14 @@ export const writeFileTool = {
                 return conflict(file, 'expected_hash 必须是 null 或 sha256:<64 hex>。');
         }
         const operation = expectedHash === null ? 'create' : 'update';
-        const result = await commitChangeSet(createChangeSet([{
+        const result = await commitChangeSet(createChangeSet([
+            {
                 path: file,
                 operation,
                 expectedHash,
                 replacement: content,
-            }]), ctx?.signal);
+            },
+        ]), ctx?.signal);
         if (result.status === 'conflict') {
             const item = result.conflicts[0];
             return conflict(file, `expected=${item?.expectedHash ?? 'missing'}, actual=${item?.actualHash ?? 'missing'}。请重新读取后再写入。`);

package/dist/tools/constants.js

@@ -1,5 +1,6 @@
 /** 工具共享的截断 / 上限 / 忽略规则。 */
-import { isMemoryEnabled, isSubAgentEnabled, isFrontendToolsEnabled } from '../config/index.js';
+import { getActiveProfile, isMemoryEnabled, isSubAgentEnabled, isFrontendToolsEnabled, isComputerUseEnabled, } from '../config/index.js';
+import { getProfileToolNames, TOOL_GROUPS } from '../config/profiles.js';
 import { getActiveSkill } from '../skills/activation.js';
 export const MAX_FILE_LINES = 2000;
 export const MAX_OUTPUT = 20000;
@@ -52,18 +53,33 @@ export const MAX_GRAPH_EDGES = 2000;
 // .codegraph:codegraph 索引目录(codegraph.db 是 SQLite 二进制 + daemon.log),
 // grep/glob 扫它无意义且会产出数 KB 的超长「行」,污染 TUI 展开渲染。
 export const IGNORE = ['**/node_modules/**', '**/.git/**', '**/.codegraph/**'];
-// ── 前端工具簇(默认关闭,显式开启)─────────────────────────────────────────
+// ── legacy profile fallback（官方 TUI/stdio 已由 ToolPolicy 控制）────────────────
+// 保留导出名以兼容未传 ToolPolicy 的嵌入调用与旧测试。
+export const FRONTEND_TOOLS = new Set(TOOL_GROUPS.frontend);
+export const COMPUTER_TOOLS = new Set(TOOL_GROUPS.computer);
 /**
- * 前端开发相关工具簇:browser / dev_server 依赖 playwright 二进制且拉起长驻进程,
- * screenshot 抓整个桌面(隐私敏感),view_image 仅视觉模型有用。这 4 个默认不进入
- * 模型工具表,由 isFrontendToolsEnabled() 单一来源控制;/fe on|off 切换。
+ * Legacy profile fallback 的屏蔽集合。仅供未传 ToolPolicy 的嵌入调用；官方 TUI/stdio
+ * 从每 turn snapshot 构造 schema 并以同一 allow-list 做运行时校验。旧 env 查询在这里
+ * 仍保留原有 true/false 覆盖语义，避免破坏兼容调用方。
  */
-export const FRONTEND_TOOLS = new Set([
-    'browser',
-    'dev_server',
-    'screenshot',
-    'view_image',
-]);
+export function getProfileDisabledTools() {
+    const all = new Set(Object.values(TOOL_GROUPS).flat());
+    for (const name of getProfileToolNames(getActiveProfile()))
+        all.delete(name);
+    const reconcile = (enabled, names) => {
+        for (const n of names) {
+            if (enabled)
+                all.delete(n);
+            else
+                all.add(n);
+        }
+    };
+    reconcile(isMemoryEnabled(), TOOL_GROUPS.memory);
+    reconcile(isFrontendToolsEnabled(), TOOL_GROUPS.frontend);
+    reconcile(isComputerUseEnabled(), TOOL_GROUPS.computer);
+    reconcile(isSubAgentEnabled(), TOOL_GROUPS.subagent);
+    return all;
+}
 // ── plan 模式(只读规划,不执行)──────────────────────────────────────────────
 /**
  * plan 模式下从工具 schema 里剔除的工具(模型根本看不到 → 调不到):
@@ -85,40 +101,25 @@ export const PLAN_DISABLED_TOOLS = new Set([
     'memory_graph', // 混合工具(add 写图),plan 只读模式整体屏蔽
     'sub-agent',
     'run_skill', // fork 子 agent 执行面;plan 模式不应派生子工作流
+    'computer', // 桌面操控:plan 只读模式无论开关状态都永远屏蔽
 ]);
 /**
- * 按当前 isMemoryEnabled() 现算 plan 模式应屏蔽的工具。
- * memoryEnabled=false 时记忆工具整体不在 builtinTools 里,plan 屏蔽集里也无须再列 ——
- * 反之留着只是死名字。统一过滤,避免 Set 里残留与已下架工具不一致的概念性冗余。
- * 调用方(agent/core 串行分支、llm/planChatTools)每次 chat 时调本函数拿当前值。
+ * Legacy plan schema 的动态清理：Memory Index 关闭时从旧 profile 屏蔽集删除不存在于该
+ * 兼容 schema 的写工具名。自动路由主路径直接对 ToolPolicy snapshot 与 PLAN_DISABLED_TOOLS
+ * 求交，不使用本函数决定 memory route eligibility。
  */
 export function getPlanDisabledTools() {
-    const next = isMemoryEnabled()
-        ? new Set(PLAN_DISABLED_TOOLS)
-        : (() => {
-            const n = new Set(PLAN_DISABLED_TOOLS);
-            n.delete('memory_save');
-            n.delete('memory_update');
-            n.delete('memory_forget');
-            return n;
-        })();
-    // 前端工具簇关闭时,plan 模式 schema 也一并剔除(与 auto 模式一致)。
-    if (!isFrontendToolsEnabled()) {
-        for (const name of FRONTEND_TOOLS)
-            next.add(name);
+    const next = new Set(PLAN_DISABLED_TOOLS);
+    if (!isMemoryEnabled()) {
+        next.delete('memory_save');
+        next.delete('memory_update');
+        next.delete('memory_forget');
     }
     return next;
 }
-/** auto/plan 共用的运行时功能开关防线；关闭时即使模型幻觉调用也不得执行。 */
-export function getRuntimeDisabledTools() {
+/** inline skill 的 disallowed-tools；自动路由 policy 在此基础上继续求交。 */
+export function getSkillRuntimeDisabledTools() {
     const disabled = new Set();
-    if (!isSubAgentEnabled())
-        disabled.add('sub-agent');
-    if (!isFrontendToolsEnabled()) {
-        for (const name of FRONTEND_TOOLS)
-            disabled.add(name);
-    }
-    // inline skill 激活态的 disallowed-tools:即便模型幻觉调用也执行不了(设计 §3.6)。
     const active = getActiveSkill();
     if (active?.disallowed) {
         for (const name of active.disallowed)
@@ -126,3 +127,15 @@ export function getRuntimeDisabledTools() {
     }
     return disabled;
 }
+/**
+ * 旧 profile 兼容路径的运行时功能开关防线。自动路由主路径改由 AgentRunOptions.toolPolicy
+ * 提供同源 snapshot；这里只服务尚未迁移的嵌入调用。
+ */
+export function getRuntimeDisabledTools() {
+    const disabled = getProfileDisabledTools();
+    if (!isSubAgentEnabled())
+        disabled.add('sub-agent');
+    for (const name of getSkillRuntimeDisabledTools())
+        disabled.add(name);
+    return disabled;
+}

package/dist/tools/policy.js

@@ -0,0 +1,221 @@
+import { ADD_TOOL_GROUPS_TOOL_NAME, COMMON_TOOL_NAMES, TOOL_ROUTE_GROUP_NAMES, TOOL_ROUTE_GROUPS, getToolRouteGroupNames, isToolRouteGroupName, } from '../config/profiles.js';
+import { PLAN_DISABLED_TOOLS } from './constants.js';
+import { tools } from './registry.js';
+const clampConfidence = (value) => (Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0);
+function envGateAllows(name) {
+    return !name || process.env[name] !== 'false';
+}
+function registeredNames() {
+    return tools.map((tool) => tool.name);
+}
+/** 当前进程真正可路由的簇；旧 env=false 只作为硬 veto，不再强制把簇常驻 schema。 */
+export function getAvailableToolRouteGroups() {
+    const names = registeredNames();
+    const registered = new Set(names);
+    return TOOL_ROUTE_GROUP_NAMES.filter((group) => {
+        const definition = TOOL_ROUTE_GROUPS[group];
+        if (!envGateAllows(definition.gateEnv))
+            return false;
+        const groupNames = getToolRouteGroupNames(group, names);
+        if (group === 'mcp')
+            return groupNames.length > 0;
+        return groupNames.length > 0 && groupNames.every((name) => registered.has(name));
+    });
+}
+export function toolRouteCatalog(groups = getAvailableToolRouteGroups()) {
+    const names = registeredNames();
+    return groups
+        .map((group) => {
+        const members = getToolRouteGroupNames(group, names);
+        return `- ${group}: ${TOOL_ROUTE_GROUPS[group].description} Tools: ${members.join(', ') || '(dynamic MCP tools)'}.`;
+    })
+        .join('\n');
+}
+export function getToolChatSchema(name) {
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool)
+        return null;
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    };
+}
+function addToolGroupsSchema(groups) {
+    return {
+        type: 'function',
+        function: {
+            name: ADD_TOOL_GROUPS_TOOL_NAME,
+            description: 'Expand the tool surface for this turn when the current tools are insufficient. Call this tool ALONE, before any dependent tool call. Added groups become available on the next model step and cannot be removed during the turn.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    groups: {
+                        type: 'array',
+                        items: { type: 'string', enum: [...groups] },
+                        minItems: 1,
+                        // 不用 uniqueItems:kimi-k3@dashscope 等服务端对含该关键字的工具 schema 整请求 400
+                        // (InternalError.Algo: Invalid request parameters)。去重语义写进 description,
+                        // 且 expand() 本身对重复组幂等(已激活的直接 rejected),不依赖 schema 约束。
+                        description: 'Additional capability groups needed to complete the current task. Do not repeat a group.',
+                    },
+                    reason: {
+                        type: 'string',
+                        description: 'Concise evidence-based reason these capabilities are now required.',
+                    },
+                },
+                required: ['groups', 'reason'],
+                additionalProperties: false,
+            },
+        },
+    };
+}
+/**
+ * 一个用户 turn 独享的版本化工具策略。每次扩容生成新 snapshot；已发出的模型请求继续用
+ * 旧 snapshot 校验其 tool_calls，因此 schema 与执行 backstop 永远同源。
+ */
+export class ToolPolicyController {
+    id;
+    selected = new Set();
+    maxExpansions;
+    expansionCount = 0;
+    version = 1;
+    reason;
+    confidence;
+    autoCache = null;
+    planCache = null;
+    constructor(init = {}) {
+        this.id = init.id ?? `route-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        this.maxExpansions = Math.max(0, init.maxExpansions ?? 3);
+        this.reason = init.reason?.trim() || 'LLM router selected common tools only.';
+        this.confidence = clampConfidence(init.confidence ?? 0);
+        const available = new Set(getAvailableToolRouteGroups());
+        const requested = process.env.MOCODE_TOOL_POLICY === 'full' ? available : new Set(init.groups ?? []);
+        for (const group of requested) {
+            if (available.has(group))
+                this.selected.add(group);
+        }
+    }
+    get groupNames() {
+        return TOOL_ROUTE_GROUP_NAMES.filter((group) => this.selected.has(group));
+    }
+    get canExpand() {
+        return this.expansionCount < this.maxExpansions && this.remainingGroups().length > 0;
+    }
+    remainingGroups() {
+        const available = new Set(getAvailableToolRouteGroups());
+        return TOOL_ROUTE_GROUP_NAMES.filter((group) => available.has(group) && !this.selected.has(group));
+    }
+    snapshot(planMode = false) {
+        const cached = planMode ? this.planCache : this.autoCache;
+        if (cached)
+            return cached;
+        const orderedNames = [];
+        const seen = new Set();
+        const append = (name) => {
+            if (!seen.has(name)) {
+                seen.add(name);
+                orderedNames.push(name);
+            }
+        };
+        for (const name of COMMON_TOOL_NAMES)
+            append(name);
+        const remaining = this.canExpand ? this.remainingGroups() : [];
+        if (remaining.length > 0)
+            append(ADD_TOOL_GROUPS_TOOL_NAME);
+        const registered = registeredNames();
+        for (const group of TOOL_ROUTE_GROUP_NAMES) {
+            if (!this.selected.has(group))
+                continue;
+            for (const name of getToolRouteGroupNames(group, registered))
+                append(name);
+        }
+        const visibleNames = planMode
+            ? orderedNames.filter((name) => name === ADD_TOOL_GROUPS_TOOL_NAME || (!PLAN_DISABLED_TOOLS.has(name) && !name.startsWith('mcp__')))
+            : orderedNames;
+        const chatTools = visibleNames.flatMap((name) => {
+            if (name === ADD_TOOL_GROUPS_TOOL_NAME)
+                return [addToolGroupsSchema(remaining)];
+            const schema = getToolChatSchema(name);
+            return schema ? [schema] : [];
+        });
+        const snapshot = {
+            id: this.id,
+            version: this.version,
+            groups: new Set(this.groupNames),
+            allowedNames: new Set(chatTools.map((tool) => tool.function.name)),
+            tools: chatTools,
+            reason: this.reason,
+            confidence: this.confidence,
+            planMode,
+        };
+        if (planMode)
+            this.planCache = snapshot;
+        else
+            this.autoCache = snapshot;
+        return snapshot;
+    }
+    expand(rawGroups, reason) {
+        const rejected = [];
+        const added = [];
+        if (this.expansionCount >= this.maxExpansions) {
+            return {
+                added,
+                rejected: ['expansion limit reached'],
+                snapshot: this.snapshot(false),
+            };
+        }
+        const available = new Set(getAvailableToolRouteGroups());
+        for (const value of rawGroups) {
+            if (!isToolRouteGroupName(value)) {
+                rejected.push(`${String(value)}: unknown group`);
+            }
+            else if (!available.has(value)) {
+                rejected.push(`${value}: capability disabled or unavailable`);
+            }
+            else if (this.selected.has(value)) {
+                rejected.push(`${value}: already active`);
+            }
+            else {
+                this.selected.add(value);
+                added.push(value);
+            }
+        }
+        if (added.length > 0) {
+            this.expansionCount++;
+            this.version++;
+            this.reason = reason.trim() || `Main agent added ${added.join(', ')}.`;
+            this.confidence = Math.max(this.confidence, 0.8);
+            this.autoCache = null;
+            this.planCache = null;
+        }
+        return { added, rejected, snapshot: this.snapshot(false) };
+    }
+    /** 注入请求尾部，不改写稳定 system prefix。 */
+    reminder(planMode = false) {
+        const snapshot = this.snapshot(planMode);
+        const active = this.groupNames.length ? this.groupNames.join(', ') : '(common only)';
+        const remaining = this.remainingGroups();
+        const lines = [
+            '## Tool route (current turn)',
+            `Policy ${snapshot.id} v${snapshot.version}; active groups: ${active}.`,
+            `Router reason: ${snapshot.reason}`,
+            'Use only the tools currently exposed. If a required capability is missing, call add_tool_groups alone; dependent calls must wait until the next step.',
+        ];
+        if (remaining.length)
+            lines.push(`Groups still available: ${remaining.join(', ')}.`);
+        if (this.selected.has('computer-control')) {
+            lines.push('Computer control: the computer tool drives the real desktop and returns a fresh screenshot after every action; inspect it before acting again and self-correct.', 'Coordinates use a normalized 0-1000 grid. Zoom into tight regions before clicking small or dense targets.', 'Require explicit user intent before destructive or sensitive targets such as submit, payment, credentials, delete, or send; every action still passes the permission gate.');
+        }
+        if (this.selected.has('memory-read')) {
+            lines.push('Memory read: use memory_search for relevant cross-session facts and memory_list only when an index overview is needed; memory_search may also return graph relations.');
+        }
+        if (this.selected.has('memory-write')) {
+            lines.push('Memory write: persist only stable, non-obvious cross-session facts. Search before saving, update instead of duplicating, and archive stale entries; add graph links only when meaningful.');
+        }
+        return lines.join('\n');
+    }
+}

package/dist/tools/registry.js

@@ -1,4 +1,5 @@
-import { builtinTools } from './builtins/index.js';
+// 注意:不顶层 import builtins——会构成 registry → builtins → task(sub-agent) → agent/spawn
+// → agent/core → registry 的模块循环。官方默认工具包由 builtins/index.ts 经 installBuiltinTools 自注册。
 import { beginPathMutation, beginWorkspaceMutation, endPathMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
 import { enforceSandbox } from '../sandbox/index.js';
 import { resolveResourceLockRequests, toolResourceLockManager } from './resource-lock.js';
@@ -8,14 +9,27 @@ import { isToolErrorOutput } from './result.js';
 /**
  * 可扩展工具注册表。数组实例始终稳定，使已经持有 tools 引用的 agent/LLM 能看到运行时新增工具。
  * 扩展按 source 替换，MCP 重连或配置刷新不会累积旧工具。
+ *
+ * 官方默认工具包不顶层 import——由装配方经 installBuiltinTools() 注入(见 builtins/index.ts 自注册)。
+ * 这是「framework 与 coding preset 分离」的装配缝:@mocode/tool-system 不含 builtin,builtin 是可替换默认包。
+ * 未 install 时 tools 为空数组;install 后 rebuild 合并 builtin + 已注册扩展。
  */
 const extensions = new Map();
-export const tools = [...builtinTools];
+let builtinTools = [];
+export const tools = [];
 /** 名字 → 工具 的 O(1) 索引，与 tools 数组在每次 rebuild 时同步重建；findTool 走此索引。 */
 let toolIndex = buildToolIndex(tools);
 function buildToolIndex(list) {
     return new Map(list.map((tool) => [tool.name, tool]));
 }
+/**
+ * 装配官方默认工具包(coding preset)。幂等:重复 install 覆盖上次,不累积。
+ * 由 builtins/index.ts 在模块初始化时调用;入口(CLI/stdio host/eval/测试)只需 import builtins 即完成装配。
+ */
+export function installBuiltinTools(list) {
+    builtinTools = list;
+    rebuildTools();
+}
 export function registerToolsExtension(sourceOrAdditions, maybeAdditions) {
     const source = typeof sourceOrAdditions === 'string' ? sourceOrAdditions : 'external';
     const additions = typeof sourceOrAdditions === 'string' ? (maybeAdditions ?? []) : sourceOrAdditions;
@@ -72,9 +86,12 @@ export function isFileMutationTool(name) {
     return isFileMutationCapabilities(getToolCapabilities(name));
 }
 function isStructuredOutcome(value) {
-    return typeof value === 'object' && value !== null &&
-        typeof value.status === 'string' && typeof value.code === 'string' &&
-        typeof value.retryable === 'boolean' && typeof value.output === 'string';
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.status === 'string' &&
+        typeof value.code === 'string' &&
+        typeof value.retryable === 'boolean' &&
+        typeof value.output === 'string');
 }
 function normalizeOutcome(value, durationMs, changedFiles) {
     if (isStructuredOutcome(value)) {
@@ -111,22 +128,21 @@ function isTransientExecutionError(error) {
     const value = error;
     if (value.name === 'AbortError' || value.name === 'APIUserAbortError')
         return false;
-    if (value.status === 408 || value.status === 429 ||
-        (typeof value.status === 'number' && value.status >= 500))
+    if (value.status === 408 || value.status === 429 || (typeof value.status === 'number' && value.status >= 500))
         return true;
-    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE']
-        .includes(value.code ?? ''))
+    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE'].includes(value.code ?? ''))
         return true;
-    return value.name === 'APIConnectionError' ||
+    return (value.name === 'APIConnectionError' ||
         value.name === 'APIConnectionTimeoutError' ||
-        (typeof value.message === 'string' && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(value.message));
+        (typeof value.message === 'string' && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(value.message)));
 }
 function executionErrorOutcome(name, error, startedAt, changedFiles) {
     const transient = isTransientExecutionError(error);
     const value = error;
-    const timeout = transient && (value?.code === 'ETIMEDOUT' ||
-        value?.name === 'APIConnectionTimeoutError' ||
-        (error instanceof Error && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(error.message)));
+    const timeout = transient &&
+        (value?.code === 'ETIMEDOUT' ||
+            value?.name === 'APIConnectionTimeoutError' ||
+            (error instanceof Error && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(error.message)));
     return {
         status: 'error',
         code: timeout ? 'TIMEOUT' : transient ? 'NETWORK_ERROR' : 'EXECUTION_ERROR',
@@ -153,18 +169,23 @@ async function executeToolOnce(tool, args, signal, opts) {
             mutationVersionBefore = mutationBefore.version;
             // Transactional tools own their full write-set capture inside ChangeSet commit.
             const pathCapture = !capabilities.delegatesResourceLocks &&
-                isFileMutationCapabilities(capabilities) && typeof args.path === 'string' && args.path
+                isFileMutationCapabilities(capabilities) &&
+                typeof args.path === 'string' &&
+                args.path
                 ? beginPathMutation(args.path)
                 : null;
             capturedPath = pathCapture?.path;
             // 工作区快照是异步的:它遍历整棵工作树,同步实现会在每次 run_command/MCP 调用前后
             // 阻塞事件循环数秒(TUI 完全冻结)。await 让 spinner / 走时 / 键鼠在扫描期间继续工作。
-            const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
-                ? await beginWorkspaceMutation()
-                : null;
+            const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown' ? await beginWorkspaceMutation() : null;
             let raw;
             try {
-                raw = await tool.execute(args, { signal, callId: opts?.callId });
+                raw = await tool.execute(args, {
+                    signal,
+                    callId: opts?.callId,
+                    allowedToolNames: opts?.allowedToolNames,
+                    delegation: opts?.delegation,
+                });
             }
             finally {
                 if (pathCapture)

package/dist/tools/resource-lock.js

@@ -100,11 +100,13 @@ export function canonicalFileResourceKey(input) {
 function modeFor(effect) {
     return effect === 'read' ? 'read' : 'write';
 }
-const workspaceWrite = () => [{
+const workspaceWrite = () => [
+    {
         key: 'workspace',
         scope: 'workspace',
         mode: 'write',
-    }];
+    },
+];
 /** Resolve declared logical resources. Any ambiguity fails closed to a workspace write lock. */
 export function resolveResourceLockRequests(capabilities, args) {
     if (capabilities.delegatesResourceLocks)