mocode-ai 1.1.7 → 1.1.9

package/dist/context/pipeline.js

@@ -1,19 +1,12 @@
-// Context Optimization Pipeline 单一入口。
+// Typed Context Optimization Pipeline.
 //
-// 接管"工具结果进 LLM 前"的表示优化(C1 收口,agent/core.ts pushToolResult 调)。
-// 流程:
-//   1) 解析 argsRaw(失败返 null,encoder 据此降级)。
-//   2) classify(name, output, args) → ContextKind。
-//   3) getEncoder(kind) ?? passthrough → encode(保不变量压缩,纯函数)。
-//   4) capToolResultForHistory(name, text) 作末尾长度裁剪兜底(保 head+标记+tail,与改造前一致)。
+// Normal tool insertion does not call this module: agent/core stores the raw
+// result after only capToolResultForHistory(). The pressure scheduler invokes
+// this encoder for Cold logs and retrievable searches when the opt-in switch is
+// enabled. Encoder failures always fall back to the raw hard-capped result.
 //
-// 不抛错:encoder 报错 → catch 回落原 output + capToolResultForHistory(对齐「调度器永不抛错」)。
-// 兜底零行为变化:未注册 encoder / pipeline 关闭 → passthrough identity → 末尾 cap 与改造前逐字节一致。
-//
-// 兼容:不改 Tool Calling JSON schema、不改 executeTool、不改 tool_call_id 配对、不改 TUI 渲染
-// (hooks.onToolResult 用原始 output,本函数只管进 history 的 content)。
-//
-// 依赖方向:context → {tools/constants, session/compact 的 cap, config};叶子,不反向依赖 llm/agent/tools。
+// This does not alter tool schemas, execution, tool_call_id pairing, or TUI
+// rendering; it only provides a pressure-stage representation transform.
 import { classify } from './classifier.js';
 import { getEncoder, registerAll } from './registry.js';
 import { builtinEncoders } from './encoders/index.js';
@@ -60,7 +53,7 @@ function budgetFor(name) {
  */
 export function optimizeToolResult(name, output, argsRaw, context = {}) {
     boot();
-    // 总开关关闭:完全走老路径,零行为变化(Phase 1 默认 true,但保留紧急回退开关)。
+    // Disabled by default: normal history is raw apart from the hard cap.
     if (!config.contextOptimize) {
         return capToolResultForHistory(name, output);
     }

package/dist/context/relevance.js

@@ -1,6 +1,6 @@
 // Relevance Pruner: statically removes tool results that a newer observation supersedes.
 // It never deletes messages or changes tool_call_id pairing; only tool content is stubbed.
-import { canonicalizePath, extractPath, isToolResultSuccess, lastUserIndex, toText, } from './utils.js';
+import { canonicalizePath, extractPath, isToolResultSuccess, toText, } from './utils.js';
 /** Shared prefix lets /context count read and observation supersession together. */
 const STUB_PREFIX = '⌦[已过时:';
 const READ_STUB_REASON = '同 path 已有新 read / 已被 mutation 覆写';
@@ -72,7 +72,6 @@ export class RelevancePruner {
                 const path = canonicalizePath(extractPath(call.argsRaw));
                 if (!path)
                     return;
-                this.stubPriorReads(history, path, idx);
                 const list = this.readByPath.get(path) ?? [];
                 list.push(idx);
                 this.readByPath.set(path, list);
@@ -81,7 +80,6 @@ export class RelevancePruner {
             const key = observationKey(call);
             if (!key)
                 return;
-            this.stubPriorObservations(history, call.name, key, idx);
             const list = this.observationByKey.get(key) ?? [];
             list.push(idx);
             this.observationByKey.set(key, list);
@@ -107,85 +105,109 @@ export class RelevancePruner {
         }
         return null;
     }
-    observeMutation(history, path) {
+    observeMutation(_history, _path) {
+        // Mutations are retained as provenance. pruneSuperseded() derives their
+        // impact only when the scheduler enters real context pressure.
+    }
+    /**
+     * Pressure-only cleanup. Scan the complete history to identify evidence that
+     * has an exact newer replacement, but only rewrite messages before the Cold
+     * boundary. This keeps the latest four user turns and current work intact.
+     */
+    pruneSuperseded(history, coldBoundary) {
         try {
-            const canonicalPath = canonicalizePath(path);
-            if (!canonicalPath)
-                return;
-            const idx = history.length - 1;
-            if (idx < 1)
-                return;
-            this.stubPriorReads(history, canonicalPath, idx);
-            this.readByPath.delete(canonicalPath);
+            const latestRead = new Map();
+            const latestObservation = new Map();
+            const mutations = [];
+            for (let idx = 1; idx < history.length; idx++) {
+                const message = history[idx];
+                const content = toText(message.content);
+                if (message.role !== 'tool' || content.startsWith('⌦[') || !isToolResultSuccess(content))
+                    continue;
+                const call = this.callAt(history, idx);
+                if (!call)
+                    continue;
+                if (call.name === 'read_file') {
+                    const path = canonicalizePath(extractPath(call.argsRaw));
+                    if (path)
+                        latestRead.set(path, idx);
+                }
+                else if (call.name === 'edit_file' || call.name === 'write_file') {
+                    const path = canonicalizePath(extractPath(call.argsRaw));
+                    if (path)
+                        mutations.push({ path, index: idx });
+                }
+                const key = observationKey(call);
+                if (key)
+                    latestObservation.set(key, { tool: call.name, index: idx });
+            }
+            let pruned = 0;
+            for (const [path, index] of latestRead) {
+                pruned += this.stubPriorReads(history, path, index, coldBoundary);
+            }
+            for (const mutation of mutations) {
+                pruned += this.stubPriorReads(history, mutation.path, mutation.index, coldBoundary);
+            }
+            for (const [key, latest] of latestObservation) {
+                pruned += this.stubPriorObservations(history, latest.tool, key, latest.index, coldBoundary);
+            }
+            return pruned;
         }
         catch {
-            // Never throw from mutation cleanup.
+            return 0;
         }
     }
-    stubPriorReads(history, path, beforeIdx) {
+    stubPriorReads(history, path, beforeIdx, coldBoundary) {
         const targetPath = canonicalizePath(path);
         if (!targetPath)
-            return;
-        const protectedFrom = Math.max(0, lastUserIndex(history));
-        const stubOne = (idx) => {
-            if (idx >= beforeIdx || (protectedFrom > 0 && idx >= protectedFrom))
-                return;
+            return 0;
+        let pruned = 0;
+        for (let idx = 1; idx < Math.min(beforeIdx, coldBoundary); idx++) {
             const message = history[idx];
             if (!message || message.role !== 'tool')
-                return;
+                continue;
             const content = toText(message.content);
-            if (content.startsWith(STUB_PREFIX))
-                return;
+            if (content.startsWith('⌦['))
+                continue;
             const call = this.callAt(history, idx);
             if (call?.name !== 'read_file')
-                return;
-            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath)
-                return;
-            if (!message.tool_call_id)
-                return;
+                continue;
+            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath || !message.tool_call_id)
+                continue;
             message.content =
                 `${STUB_PREFIX}${READ_STUB_REASON}] read_file(${targetPath}) ${content.length} 字符 ` +
                     `→ 已被新 read / mutation 替代 · id …${message.tool_call_id.slice(-6)}⌫`;
-        };
-        for (const idx of this.readByPath.get(targetPath) ?? [])
-            stubOne(idx);
-        const scanEnd = Math.min(beforeIdx, protectedFrom > 0 ? protectedFrom : beforeIdx);
-        for (let idx = 1; idx < scanEnd; idx++)
-            stubOne(idx);
+            pruned++;
+        }
+        return pruned;
     }
-    stubPriorObservations(history, toolName, key, beforeIdx) {
-        const protectedFrom = Math.max(0, lastUserIndex(history));
-        const stubOne = (idx) => {
-            if (idx >= beforeIdx || (protectedFrom > 0 && idx >= protectedFrom))
-                return;
+    stubPriorObservations(history, toolName, key, beforeIdx, coldBoundary) {
+        let pruned = 0;
+        for (let idx = 1; idx < Math.min(beforeIdx, coldBoundary); idx++) {
             const message = history[idx];
             if (!message || message.role !== 'tool')
-                return;
+                continue;
             const content = toText(message.content);
-            if (content.startsWith(STUB_PREFIX) || !isToolResultSuccess(content))
-                return;
+            if (content.startsWith('⌦[') || !isToolResultSuccess(content))
+                continue;
             const call = this.callAt(history, idx);
-            if (!call || call.name !== toolName || observationKey(call) !== key)
-                return;
-            if (!message.tool_call_id)
-                return;
-            const reason = '相同 grep 查询已有更新结果';
+            if (!call || call.name !== toolName || observationKey(call) !== key || !message.tool_call_id)
+                continue;
             message.content =
-                `${STUB_PREFIX}${reason}] ${observationLabel(call)} ${content.length} 字符 ` +
+                `${STUB_PREFIX}相同 grep 查询已有更新结果] ${observationLabel(call)} ${content.length} 字符 ` +
                     `→ 已被更新查询替代 · id …${message.tool_call_id.slice(-6)}⌫`;
-        };
-        for (const idx of this.observationByKey.get(key) ?? [])
-            stubOne(idx);
-        // The fallback scan restores correctness after resume/compact when this instance
-        // has no index for older messages.
-        const scanEnd = Math.min(beforeIdx, protectedFrom > 0 ? protectedFrom : beforeIdx);
-        for (let idx = 1; idx < scanEnd; idx++)
-            stubOne(idx);
+            pruned++;
+        }
+        return pruned;
     }
 }
 export function createRelevancePruner() {
     return new RelevancePruner();
 }
+/** Pressure-only convenience entry point for scheduler-owned pruning. */
+export function pruneSuperseded(history, coldBoundary) {
+    return new RelevancePruner().pruneSuperseded(history, coldBoundary);
+}
 /** Parse the original content length recorded by any relevance stub. */
 function parseStubOriginalLen(stub) {
     const match = /\) (\d+) 字符 →/.exec(stub);

package/dist/host/stdio.js

@@ -8,7 +8,6 @@ import { initializeAllMcp, getMcpTools, getMcpWarnings, closeAllMcp } from '../m
 import { setSandboxRoot } from '../sandbox/index.js';
 import { createContextState, loadSession, newSessionId, saveSession } from '../session/index.js';
 import { setCurrentSessionId } from '../session/state.js';
-import { buildActiveNotesPlanReminder } from '../session/notes-plan.js';
 import { manualCompact } from '../session/scheduler.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { registerToolsExtension } from '../tools/registry.js';
@@ -91,8 +90,6 @@ function hooksFor(runId) {
         onToolHeader: (tool) => emit('tool_started', { id: tool.id, name: tool.name, arguments: tool.arguments }, runId),
         onToolStart: (name) => emit('status', { value: 'running_tool', tool: name }, runId),
         onToolResult: (tool, output) => emit('tool_completed', { id: tool.id, name: tool.name, output }, runId),
-        onValidationStart: (command) => emit('validation_started', { command }, runId),
-        onValidationResult: (result) => emit('validation_completed', { result }, runId),
         onAbort: () => emit('run_aborted', {}, runId),
         onDone: (elapsedMs, usage) => emit('run_finished', { elapsedMs, usage }, runId),
     };
@@ -126,10 +123,8 @@ async function run(command) {
             history,
             userInput,
             signal: controller.signal,
-            dynamicSystemSuffix: buildActiveNotesPlanReminder,
             hooks: hooksFor(command.id),
             contextState,
-            autoValidate: config.autoValidate,
             permissionPrompt: (request) => waitForApproval(command.id, request),
         });
         saveSession(history, sessionId, queryHistory);
@@ -138,7 +133,6 @@ async function run(command) {
             completed: result.completed,
             terminationReason: result.terminationReason,
             changedFiles: result.changedFiles ?? [],
-            validation: result.validation,
             usage: result.usage,
             usagePercent: Math.round(contextUsagePercent() * 100),
             contextWindow: config.contextWindowTokens,

package/dist/i18n/index.js

@@ -23,6 +23,10 @@ const zhCN = {
     'commands.subagentOn': '开启子 Agent',
     'commands.subagentOff': '关闭子 Agent',
     'commands.subagentStatus': '查看子 Agent 状态',
+    'commands.fe': '前端工具簇开关 browser/dev_server/screenshot/view_image（默认关闭）',
+    'commands.feOn': '开启前端工具簇',
+    'commands.feOff': '关闭前端工具簇',
+    'commands.feStatus': '查看前端工具簇状态',
     'commands.theme': '切换颜色主题（↑↓·Enter）',
     'commands.model': '模型配置与预设管理',
     'commands.modelConfigure': '配置新模型（向导）',
@@ -156,9 +160,6 @@ const zhCN = {
     'agent.noReply': '(无回复)',
     'agent.maxSteps': '达到最大步数({count})，本轮停止。',
     'agent.aborted': '(已中断)',
-    'agent.validating': '自动验证 {command}',
-    'agent.validationNoCommand': '未发现验证命令',
-    'agent.validationResult': '自动验证 {command} → {status}',
     'agent.workedFor': '耗时 {elapsed}',
     'agent.toolsRunning': '正在探索',
     'agent.toolsComplete': '探索',
@@ -214,6 +215,12 @@ const zhCN = {
     'subagent.changedOn': '已开启子 Agent；sub-agent 将从下一次模型请求起可用。',
     'subagent.changedOff': '已关闭子 Agent；sub-agent 已从模型工具表移除。',
     'subagent.usage': '用法：/subagent on|off|status',
+    'fe.status': '前端工具簇：{state}',
+    'fe.stateOn': '开启',
+    'fe.stateOff': '关闭',
+    'fe.changedOn': '已开启前端工具簇；browser / dev_server / screenshot / view_image 将从下一次模型请求起可用。',
+    'fe.changedOff': '已关闭前端工具簇；browser / dev_server / screenshot / view_image 已从模型工具表移除。',
+    'fe.usage': '用法：/fe on|off|status',
     'plan.ready': '计划已就绪',
     'plan.approvalDetail': '切换到 auto 模式按上述计划执行？（plan 模式只读探查，执行需切 auto）',
     'plan.execute': '切 auto 执行',
@@ -268,6 +275,10 @@ const en = {
     'commands.subagentOn': 'Enable sub-agents',
     'commands.subagentOff': 'Disable sub-agents',
     'commands.subagentStatus': 'Show sub-agent status',
+    'commands.fe': 'Frontend tools: browser/dev_server/screenshot/view_image (disabled by default)',
+    'commands.feOn': 'Enable frontend tools',
+    'commands.feOff': 'Disable frontend tools',
+    'commands.feStatus': 'Show frontend tools status',
     'commands.theme': 'Switch color theme (↑↓·Enter)',
     'commands.model': 'Model configuration and presets',
     'commands.modelConfigure': 'Configure a new model (wizard)',
@@ -401,9 +412,6 @@ const en = {
     'agent.noReply': '(no reply)',
     'agent.maxSteps': 'Maximum steps reached ({count}); this turn has stopped.',
     'agent.aborted': '(aborted)',
-    'agent.validating': 'Validating {command}',
-    'agent.validationNoCommand': 'no validation command',
-    'agent.validationResult': 'Automatic validation {command} → {status}',
     'agent.workedFor': 'Worked for {elapsed}',
     'agent.toolsRunning': 'Exploring',
     'agent.toolsComplete': 'Exploration',
@@ -459,6 +467,12 @@ const en = {
     'subagent.changedOn': 'Sub-agents enabled; sub-agent will be available from the next model request.',
     'subagent.changedOff': 'Sub-agents disabled; sub-agent has been removed from the model tool list.',
     'subagent.usage': 'Usage: /subagent on|off|status',
+    'fe.status': 'Frontend tools: {state}',
+    'fe.stateOn': 'enabled',
+    'fe.stateOff': 'disabled',
+    'fe.changedOn': 'Frontend tools enabled; browser / dev_server / screenshot / view_image will be available from the next model request.',
+    'fe.changedOff': 'Frontend tools disabled; browser / dev_server / screenshot / view_image have been removed from the model tool list.',
+    'fe.usage': 'Usage: /fe on|off|status',
     'plan.ready': 'Plan ready',
     'plan.approvalDetail': 'Switch to auto mode and execute the plan above? (Plan mode is read-only; execution requires auto mode.)',
     'plan.execute': 'Switch to auto and execute',

package/dist/index.js

@@ -1,16 +1,24 @@
 import { exitAltScreen } from './ui/layout.js';
 import { readConfigFile } from './config/file.js';
 import { detectLanguage, setLanguage, t } from './i18n/index.js';
+import { shutdownRuntime, shutdownRuntimeSync } from './runtime/shutdown.js';
 // 终端恢复兜底:任一退出 / 中断 / 未捕获异常路径都要恢复 alt screen,避免残留备用屏 + 滚动区域。
 // exitAltScreen 幂等(未激活时空操作),故全局注册安全——进 alt screen 前的路径(如 --resume 列表、缺环境变量、`mocode config`)调用它无副作用。
 // 仅 layout 是叶子(不依赖 config),故静态导入安全;repl / session 依赖 config(模块加载触发 loadEnvFiles + config 单例初始化),
 // 改动态按需加载——`mocode config` 向导只需读写文件(走 config/file.ts 叶子),不经 config 单例初始化,零配置也能跑。
-process.on('exit', () => exitAltScreen());
+// dev_server 拉起的后台进程不随父进程退出而消失(Windows 无 job object),故每条退出路径
+// 都同步树杀一次;shutdownRuntimeSync 幂等。
+process.on('exit', () => {
+    shutdownRuntimeSync();
+    exitAltScreen();
+});
 process.on('SIGINT', () => {
+    shutdownRuntimeSync();
     exitAltScreen();
     process.exit(130);
 });
 process.on('uncaughtException', (e) => {
+    shutdownRuntimeSync();
     try {
         process.stderr.write(`\n[uncaught] ${e instanceof Error ? e.stack || e.message : String(e)}\n`);
     }
@@ -85,6 +93,8 @@ async function main() {
         const { startRepl } = await import('./repl/index.js');
         await startRepl(undefined, undefined, sandboxRootOverride);
     }
+    // 正常退出:优雅关闭浏览器与后台进程(同步兜底仍在 exit 钩子里)。
+    await shutdownRuntime();
     process.exit(0);
 }
 main();

package/dist/llm/index.js

@@ -1,7 +1,7 @@
 import OpenAI from 'openai';
-import { config, isSubAgentEnabled } from '../config/index.js';
+import { config, isSubAgentEnabled, isFrontendToolsEnabled } from '../config/index.js';
 import { tools } from '../tools/registry.js';
-import { getPlanDisabledTools } from '../tools/constants.js';
+import { getPlanDisabledTools, FRONTEND_TOOLS } from '../tools/constants.js';
 import { ThinkTagFilter } from './think-filter.js';
 // 强制关闭第三方调试日志泄漏:openai SDK 在 process.env.DEBUG === 'true' 时用裸
 // console.log 把请求/响应直写 stdout,会污染 TUI 输入框(并泄露 headers/URL)。
@@ -159,10 +159,14 @@ export function __setChatCreateImpl(impl) {
 export const chatTools = [];
 export const planChatTools = [];
 export function refreshChatTools() {
-    // sub-agent 常驻内部 registry，运行时开关只控制模型可见 schema，因而 on/off 可即时生效。
-    const visibleTools = isSubAgentEnabled()
-        ? tools
-        : tools.filter((tool) => tool.name !== 'sub-agent');
+    // sub-agent 与前端工具簇常驻内部 registry，运行时开关只控制模型可见 schema，因而 on/off 可即时生效。
+    const visibleTools = tools.filter((tool) => {
+        if (tool.name === 'sub-agent')
+            return isSubAgentEnabled();
+        if (FRONTEND_TOOLS.has(tool.name))
+            return isFrontendToolsEnabled();
+        return true;
+    });
     const next = visibleTools.map((t) => ({
         type: 'function',
         function: {
@@ -286,6 +290,42 @@ toolsOverride) {
     // 循环要么 return 要么 throw,理论上走不到这里;写出来让 TS 控制流分析满意。
     throw lastErr;
 }
+/**
+ * 发送前规范化多模态 image_url:去掉 `detail:"auto"`。
+ *
+ * `auto` 是 OpenAI 的合法枚举,但 MiniMax 等兼容后端只认 low/default/high,收到 auto 直接
+ * 400(invalid image detail: auto, 2013)。省略该字段时各家都会用自己的默认值,是唯一
+ * 在所有后端都安全的写法;显式 low/high 属通用取值,原样保留。
+ *
+ * 放在 transport 边界而非构造点:历史里可能已经存着旧版本(或续接会话 / 外部注入)写下的
+ * `auto`,那种消息每轮都会被重发,只修构造点无法自愈。
+ *
+ * 无需改写时返回原数组引用 —— 图片消息含大段 base64,不能无条件深拷贝。
+ */
+export function normalizeImageDetail(messages) {
+    let changed = false;
+    const next = messages.map((message) => {
+        const content = message.content;
+        if (!Array.isArray(content))
+            return message;
+        let messageChanged = false;
+        const parts = content.map((part) => {
+            const image = part.image_url;
+            if (part.type !== 'image_url' || !image)
+                return part;
+            if (image.detail !== 'auto')
+                return part;
+            messageChanged = true;
+            const { detail: _dropped, ...rest } = image;
+            return { ...part, image_url: rest };
+        });
+        if (!messageChanged)
+            return message;
+        changed = true;
+        return { ...message, content: parts };
+    });
+    return changed ? next : messages;
+}
 /** 单次流式 LLM 请求(无重试);chat() 的内部实现,可被 __setChatCreateImpl 注入桩以做单测。 */
 async function chatOnce(messages, handlers, signal, toolsOverride) {
     // signal 透传给 SDK 第二参(RequestOptions);abort 后 for await 抛错,chat 不 catch,透传 runAgent 处理。
@@ -296,7 +336,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
     const activeTools = toolsOverride ?? chatTools;
     const stream = await create({
         model: config.model,
-        messages,
+        messages: normalizeImageDetail(messages),
         tools: activeTools,
         stream: true,
         // 显式声明允许一次响应携带多个 tool_call(OpenAI 兼容协议标准字段)。
@@ -319,6 +359,24 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         handlers.onText?.(text);
         consumedAny = true;
     };
+    // 实时 completion 估算(onProgress 提供时才统计,零开销兜底):
+    // 按 chunk 累加 CJK/other 字符数、汇总时才 ceil——逐片段 ceil 会把大量小 chunk 各向上
+    // 取整造成严重过估。统计口径 = raw content(含 think 段)+ tool_call 参数,与后端真实
+    // completion 计费范围一致(reasoning 也计费)。
+    let liveCjk = 0;
+    let liveOther = 0;
+    const countLive = (text) => {
+        for (const ch of text) {
+            const cp = ch.codePointAt(0) ?? 0;
+            if (isCJK(cp))
+                liveCjk++;
+            else
+                liveOther++;
+        }
+    };
+    const reportProgress = () => {
+        handlers.onProgress?.({ completionTokens: Math.ceil(liveCjk + liveOther / 4) });
+    };
     for await (const chunk of stream) {
         // usage:末尾 chunk(choices 可能为空)在 include_usage 时携带;先读再 continue。
         if (chunk.usage) {
@@ -330,12 +388,21 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
                 cachedTokens: extras.cachedTokens,
                 reasoningTokens: extras.reasoningTokens,
             };
+            // 末尾 chunk 把实测 prompt / completion / cache 命中即时推给实时 chip(无 delta,下方 continue 不会再报)。
+            handlers.onProgress?.({
+                completionTokens: usage.completionTokens,
+                promptTokens: usage.promptTokens,
+                cachedTokens: usage.cachedTokens,
+            });
         }
         const delta = chunk.choices?.[0]?.delta;
         if (!delta)
             continue; // 末尾 usage-only chunk 等无 delta
-        if (delta.content)
+        if (delta.content) {
+            if (handlers.onProgress)
+                countLive(delta.content);
             emitVisible(thinkFilter.push(delta.content));
+        }
         if (delta.tool_calls) {
             // 不在这里 flush thinkFilter：其内部若有残留，只可能是 `<th` / `</thi` 一类
             // 潜在标签前缀。旧实现把这段在工具转折点强制送进 onText，正是 `k>` 等残片
@@ -355,10 +422,16 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
                         handlers.onToolCall?.(fname); // 首次得知工具名:通知调用方启生成中 spinner
                     entry.name += fname;
                 }
-                if (tc.function?.arguments)
+                if (tc.function?.arguments) {
+                    if (handlers.onProgress)
+                        countLive(tc.function.arguments);
                     entry.arguments += tc.function.arguments;
+                }
             }
         }
+        // 流式实时用量:每个带 delta 的 chunk 后回调累计估算,驱动底栏实时 chip。
+        if (handlers.onProgress)
+            reportProgress();
     }
     // 流结束后只释放普通态下真实的文本尾；未闭合思考段继续丢弃。
     emitVisible(thinkFilter.finish());

package/dist/mcp/index.js

@@ -46,7 +46,6 @@ export function getMcpTools() {
                 capabilities: {
                     effect: 'unknown',
                     concurrency: 'serial',
-                    retry: 'never',
                     resources: () => ['workspace'],
                     supportsAbort: true,
                 },