@bolloon/bolloon-agent 0.3.16 → 0.3.18

package/dist/agents/error-classifier.js

@@ -0,0 +1,118 @@
+/**
+ * error-classifier.ts — 工具错误分类 + 反射引擎
+ *
+ * 分层:
+ *   1. classifyError: 原始 error string → ErrorClass
+ *   2. buildObservation: 工具结果 → 结构化 Observation
+ *   3. buildReflection: 错误历史 → 替代策略建议
+ *   4. suggestEscalation: 阶梯升档: 重试→换参数→换工具→简化→放弃
+ */
+const ERROR_SIGNATURES = [
+    { pattern: /unknown tool|未知工具|tool.*not found|is not a function/i, cls: 'tool_not_found', label: '工具不存在' },
+    { pattern: /PreToolUse 拒绝|Harness.*拒绝|permission|not allowed|denied/i, cls: 'permission_denied', label: '权限拒绝' },
+    { pattern: /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|network|connect.*fail|fetch.*fail/i, cls: 'network_error', label: '网络错误' },
+    { pattern: /timeout|timed out/i, cls: 'timeout', label: '执行超时' },
+    { pattern: /ENOENT|not found|no such file|does not exist|invalid path|bad argument|ERR_INVALID/i, cls: 'bad_input', label: '参数错误' },
+    { pattern: /401|403|quota|rate limit|API key|unauthorized|authentication/i, cls: 'api_error', label: 'API 认证错误' },
+];
+export function classifyError(errorMsg) {
+    if (!errorMsg)
+        return { cls: 'unknown', label: '未知错误', severity: 'medium', recoverable: true };
+    for (const sig of ERROR_SIGNATURES) {
+        if (sig.pattern.test(errorMsg)) {
+            const severity = sig.cls === 'api_error' ? 'high'
+                : sig.cls === 'internal_error' ? 'high'
+                    : sig.cls === 'permission_denied' ? 'high'
+                        : sig.cls === 'tool_not_found' ? 'low'
+                            : sig.cls === 'bad_input' ? 'low'
+                                : 'medium';
+            const recoverable = sig.cls !== 'api_error' && sig.cls !== 'permission_denied';
+            return { cls: sig.cls, label: sig.label, severity, recoverable };
+        }
+    }
+    return { cls: 'unknown', label: '未知错误', severity: 'medium', recoverable: true };
+}
+export function buildObservation(tool, args, result) {
+    const obs = { tool, args, success: result.success, summary: '' };
+    if (result.success) {
+        const output = result.output || '(无输出)';
+        obs.output = output;
+        obs.summary = `✅ ${tool} 成功 (${output.length}B)`;
+    }
+    else {
+        const errMsg = result.error || '未知失败';
+        const cls = classifyError(errMsg);
+        obs.errorClass = cls.cls;
+        obs.errorLabel = cls.label;
+        obs.summary = `❌ ${tool} 失败: ${cls.label} — ${errMsg.slice(0, 120)}`;
+    }
+    return obs;
+}
+const ERROR_TO_STRATEGIES = {
+    tool_not_found: [
+        { action: 'change_tool', reason: '工具名不存在', detail: '用 list_tools 查可用工具, 使用正确的工具名' },
+        { action: 'retry', reason: '可能是别名没匹配上', detail: '尝试用标准工具名重新调用, 如 shell_exec 而非 bash' },
+    ],
+    permission_denied: [
+        { action: 'change_tool', reason: '当前工具被权限系统阻止', detail: '尝试用其他方式完成目标, 如 read_file 替代 shell_exec cat' },
+        { action: 'simplify_goal', reason: '权限持续拒绝', detail: '缩小操作范围, 选择不需要高权限的操作' },
+    ],
+    network_error: [
+        { action: 'retry', reason: '网络偶发故障', detail: '等待 2-3 秒后重试, LLM 会自动降速' },
+        { action: 'change_tool', reason: '网络不可用', detail: '尝试本地操作替代网络请求' },
+    ],
+    timeout: [
+        { action: 'retry', reason: '可能暂时性负载高', detail: '简化参数后重试, 或分多次执行' },
+        { action: 'change_tool', reason: '工具执行时间过长', detail: '换一个更轻量的工具' },
+    ],
+    bad_input: [
+        { action: 'change_params', reason: '参数格式不对', detail: '检查参数格式: 路径用绝对路径, 空格用引号包裹' },
+        { action: 'retry', reason: '参数调整后重试', detail: '用正确的参数重新调用' },
+    ],
+    api_error: [
+        { action: 'simplify_goal', reason: 'API 认证失败', detail: '检查 API 配置或使用已有的本地能力完成' },
+        { action: 'abandon', reason: 'API 不可恢复', detail: 'API key 或配额问题无法自动解决, 告知用户' },
+    ],
+    internal_error: [
+        { action: 'change_tool', reason: '工具内部异常', detail: '换另一种方式处理' },
+        { action: 'simplify_goal', reason: '工具无法正常工作', detail: '尝试用更简单的方式完成任务' },
+    ],
+    unknown: [
+        { action: 'retry', reason: '错误类型不确定', detail: '换个方式或参数再试一次' },
+        { action: 'change_tool', reason: '原方法不可行', detail: '尝试用其他工具组合达成目标' },
+    ],
+};
+export function buildReflection(toolName, errorMsg, errorCount, sameToolFailCount) {
+    if (!errorMsg)
+        return ERROR_TO_STRATEGIES.unknown.slice(0, 1);
+    const cls = classifyError(errorMsg);
+    // 阶梯升档: 根据连续失败次数选择更激进的策略
+    if (sameToolFailCount >= 3) {
+        return [
+            { action: 'abandon', reason: `工具 ${toolName} 连续失败 ${sameToolFailCount} 次`, detail: '放弃这个工具, 用其他方法或直接给用户已知信息' },
+            { action: 'simplify_goal', reason: '工具不可用', detail: '简化任务, 给出已成功执行的部分结果' },
+        ];
+    }
+    if (errorCount >= 5) {
+        return [
+            { action: 'simplify_goal', reason: `累计 ${errorCount} 次错误`, detail: '放弃复杂操作, 用已有知识回答用户' },
+        ];
+    }
+    return ERROR_TO_STRATEGIES[cls.cls] || ERROR_TO_STRATEGIES.unknown;
+}
+// ==================== 格式化为 system prompt 注入 ====================
+/**
+ * 把 Observation + Reflection 格式化成一条 system 消息,
+ * 注入到 messageHistory 中让 LLM 下一轮能看到.
+ */
+export function formatObservationWithReflection(obs, reflection) {
+    const lines = [];
+    lines.push(`[工具结果] ${obs.summary}`);
+    if (!obs.success && reflection.length > 0) {
+        lines.push(`[Reflection] 推荐策略:`);
+        for (const r of reflection.slice(0, 2)) {
+            lines.push(`  - ${r.action}: ${r.reason}. ${r.detail}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/agents/parse-tool-call.js

@@ -53,7 +53,202 @@ function defaultResolveAlias(name, tools) {
         return lower;
     return null;
 }
-/** 拆分 args.command: "git status" → { command: "git", args: "status" } */
+/**
+ * parseAllToolCalls — 从 LLM 输出中提取**所有**工具调用.
+ *
+ * 与 parseToolCall 不同, 这个函数不短路: 从多种格式中收集全部匹配.
+ * 支持 JSON 数组、多行 XML invoke、连续 tool_call 标签等.
+ *
+ * 用法:
+ *   import { parseAllToolCalls } from './parse-tool-call';
+ *   const calls = parseAllToolCalls(reply, { tools: knownTools });
+ *   for (const tc of calls) tool.execute(tc.args);
+ */
+export function parseAllToolCalls(content, ctx) {
+    if (!content)
+        return [];
+    const stripped = content.replace(/<think[\s\S]*?<\/think/g, '');
+    const results = [];
+    const seen = new Set(); // 去重: name+JSON.stringify(args)
+    // 1. JSON 数组: [{"name":"x","arguments":{...}}, ...]
+    const jsonArrayMatch = stripped.match(/\[\s*\{[\s\S]*?\}\s*\]/);
+    if (jsonArrayMatch) {
+        try {
+            const arr = JSON.parse(jsonArrayMatch[0]);
+            if (Array.isArray(arr)) {
+                for (const item of arr) {
+                    if (item && item.name) {
+                        const args = typeof item.arguments === 'object' && item.arguments
+                            ? Object.fromEntries(Object.entries(item.arguments).map(([k, v]) => [k, String(v)]))
+                            : {};
+                        const name = ctx.tools.has(item.name) ? item.name : resolve(ctx, item.name);
+                        if (!name)
+                            continue;
+                        autoSplitCommand(args);
+                        const key = name + JSON.stringify(args);
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            results.push({ name, args });
+                        }
+                    }
+                }
+                if (results.length > 0)
+                    return results;
+            }
+        }
+        catch { /* not valid JSON array, fall through */ }
+    }
+    // 2. JSON 行: 每行一个 tool_call (minimax / deepseek 多行 JSON)
+    //   也匹配连续 `{"name":"...","arguments":{...}}{"name":"...",...}` (无分隔符)
+    const jsonLineRe = /\{[^{}]*"name"\s*:\s*"(\w+)"[^{}]*"arguments"\s*:\s*(\{[^{}]*\})[^{}]*\}/g;
+    let jm;
+    while ((jm = jsonLineRe.exec(stripped)) !== null) {
+        try {
+            const name = jm[1];
+            const argsRaw = JSON.parse(jm[2]);
+            const args = typeof argsRaw === 'object' && argsRaw
+                ? Object.fromEntries(Object.entries(argsRaw).map(([k, v]) => [k, String(v)]))
+                : {};
+            const resolved = ctx.tools.has(name) ? name : resolve(ctx, name);
+            if (!resolved)
+                continue;
+            autoSplitCommand(args);
+            const key = resolved + JSON.stringify(args);
+            if (!seen.has(key)) {
+                seen.add(key);
+                results.push({ name: resolved, args });
+            }
+        }
+        catch { /* skip malformed */ }
+    }
+    // 3. 多行 XML: 连续 <invoke name="X">...</invoke>
+    const xmlRe = /<invoke\s+name=["'](\w+)["']>([\s\S]*?)<\/invoke>/g;
+    let xm;
+    while ((xm = xmlRe.exec(stripped)) !== null) {
+        const name = xm[1];
+        const rawArgs = xm[2] || '';
+        const args = parseXmlArgs(rawArgs);
+        const resolved = ctx.tools.has(name) ? name : resolve(ctx, name);
+        if (!resolved)
+            continue;
+        autoSplitCommand(args);
+        const key = resolved + JSON.stringify(args);
+        if (!seen.has(key)) {
+            seen.add(key);
+            results.push({ name: resolved, args });
+        }
+    }
+    // 4. <function_calls> 包裹
+    const fcRe = /<function_calls>[\s\S]*?<invoke\s+name=["'](\w+)["']>([\s\S]*?)<\/invoke>[\s\S]*?<\/function_calls>/g;
+    let fm;
+    while ((fm = fcRe.exec(stripped)) !== null) {
+        const name = fm[1];
+        const rawArgs = fm[2] || '';
+        const args = parseXmlArgs(rawArgs);
+        const resolved = ctx.tools.has(name) ? name : resolve(ctx, name);
+        if (!resolved)
+            continue;
+        autoSplitCommand(args);
+        const key = resolved + JSON.stringify(args);
+        if (!seen.has(key)) {
+            seen.add(key);
+            results.push({ name: resolved, args });
+        }
+    }
+    // 5. <function_calls><tool name="X">...</tool></function_calls>
+    const toolTagRe = /<function_calls>[\s\S]*?<tool\s+name=["'](\w+)["']>([\s\S]*?)<\/tool>[\s\S]*?<\/function_calls>/g;
+    let tm;
+    while ((tm = toolTagRe.exec(stripped)) !== null) {
+        const name = tm[1];
+        const rawArgs = tm[2] || '';
+        const args = parseXmlArgs(rawArgs);
+        const resolved = ctx.tools.has(name) ? name : resolve(ctx, name);
+        if (!resolved)
+            continue;
+        autoSplitCommand(args);
+        const key = resolved + JSON.stringify(args);
+        if (!seen.has(key)) {
+            seen.add(key);
+            results.push({ name: resolved, args });
+        }
+    }
+    // 6. [TOOL_CALL] 标签 — 可能有多段
+    const tcTagRe = /\[TOOL_CALL\]([\s\S]*?)\[\/TOOL_CALL\]/g;
+    let tcm;
+    while ((tcm = tcTagRe.exec(stripped)) !== null) {
+        try {
+            const inner = tcm[1].trim();
+            const parsed = JSON.parse(inner);
+            if (parsed && parsed.name) {
+                const rawArgs = (typeof parsed.args === 'object' && parsed.args) ? parsed.args
+                    : (typeof parsed.arguments === 'object' && parsed.arguments) ? parsed.arguments
+                        : {};
+                const args = Object.fromEntries(Object.entries(rawArgs).map(([k, v]) => [k, String(v)]));
+                const name = ctx.tools.has(parsed.name) ? parsed.name : resolve(ctx, parsed.name);
+                if (!name)
+                    continue;
+                autoSplitCommand(args);
+                const key = name + JSON.stringify(args);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    results.push({ name, args });
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    // 7. tool_call 标签 — <tool_call>...</tool_call>
+    const toolCallTagRe = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+    let tlcm;
+    while ((tlcm = toolCallTagRe.exec(stripped)) !== null) {
+        try {
+            const inner = tlcm[1].trim();
+            const parsed = JSON.parse(inner);
+            if (parsed && parsed.name) {
+                const rawArgs = (typeof parsed.args === 'object' && parsed.args) ? parsed.args
+                    : (typeof parsed.arguments === 'object' && parsed.arguments) ? parsed.arguments
+                        : {};
+                const args = Object.fromEntries(Object.entries(rawArgs).map(([k, v]) => [k, String(v)]));
+                const name = ctx.tools.has(parsed.name) ? parsed.name : resolve(ctx, parsed.name);
+                if (!name)
+                    continue;
+                autoSplitCommand(args);
+                const key = name + JSON.stringify(args);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    results.push({ name, args });
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return results;
+}
+/** 从 XML 子标签中提取 args */
+function parseXmlArgs(rawArgs) {
+    const args = {};
+    // <parameter name="X">value</parameter>
+    const paramRe = /<parameter\s+name=["'](\w+)["']>([\s\S]*?)<\/parameter>/g;
+    let pm;
+    while ((pm = paramRe.exec(rawArgs)) !== null) {
+        args[pm[1]] = pm[2].trim();
+    }
+    if (Object.keys(args).length > 0)
+        return args;
+    // <param name="X">value</param>
+    const pRe = /<param\s+name=["'](\w+)["']>([\s\S]*?)<\/param>/g;
+    while ((pm = pRe.exec(rawArgs)) !== null) {
+        args[pm[1]] = pm[2].trim().replace(/^["']|["']$/g, '');
+    }
+    if (Object.keys(args).length > 0)
+        return args;
+    // <tag>value</tag>
+    const xmlArgPattern = /<(\w+)>([\s\S]*?)<\/\1>/g;
+    while ((pm = xmlArgPattern.exec(rawArgs)) !== null) {
+        args[pm[1]] = pm[2].trim();
+    }
+    return args;
+}
 function autoSplitCommand(args) {
     if (typeof args.command === 'string' && args.command.includes(' ') && !args.args) {
         const parts = args.command.split(/\s+/);

package/dist/agents/pi-sdk-tools.js

@@ -1551,6 +1551,19 @@ export function registerWalletTools(ctx) {
             }
         }
     });
+    // 2026-07-28: 注册 LSP 工具 (代码智能)
+    // registerBuiltinTools 不是 async, 用同步 import 兜底
+    try {
+        // 动态 import + 立即执行, 兼容 ESM
+        import('../lsp/lsp-tools.js').then(({ registerLspTools }) => {
+            registerLspTools(ctx);
+        }).catch((e) => {
+            console.warn('[registerTools] LSP 工具注册失败 (非致命):', e);
+        });
+    }
+    catch (lspErr) {
+        console.warn('[registerTools] LSP 工具注册失败 (非致命):', lspErr);
+    }
 }
 /**
  * 监听 P2P 消息 (远端 + 本地 inbox bus), 把消息存到 _inboxMessages 供 check_inbox 读.