@bolloon/bolloon-agent 0.2.8 → 0.2.10

package/scripts/postinstall.js

@@ -0,0 +1,153 @@
+/**
+ * Postinstall 脚本
+ * npm 安装后自动执行
+ *
+ * 主要任务：
+ * 1. 确保 bin 目录存在且可执行
+ * 2. 初始化本地配置
+ * 3. 检查依赖完整性
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+
+function log(msg, color = RESET) {
+  console.log(color + msg + RESET);
+}
+
+function initUserDirs() {
+  // 创建用户数据目录
+  const home = process.env.HOME || process.env.USERPROFILE || '/tmp';
+  const bolloonDir = path.join(home, '.bolloon');
+
+  const dirs = [
+    bolloonDir,
+    path.join(bolloonDir, 'sessions'),
+    path.join(bolloonDir, 'peer-store'),
+  ];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      log(`  ✓ 创建目录: ${dir}`, GREEN);
+    }
+  }
+
+  // 初始化配置文件
+  const configPath = path.join(bolloonDir, 'config.json');
+  if (!fs.existsSync(configPath)) {
+    const defaultConfig = {
+      version: '0.1.12',
+      initializedAt: new Date().toISOString(),
+      defaults: {
+        port: 54188,
+        theme: 'dark',
+        autoConnect: true,
+      },
+      providers: {
+        minimax: { enabled: false },
+        openai: { enabled: false },
+        anthropic: { enabled: false },
+      }
+    };
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+    log(`  ✓ 创建配置: ${configPath}`, GREEN);
+  }
+
+  return bolloonDir;
+}
+
+function checkNativeDeps() {
+  // 检查必要的原生依赖
+  const nativeDeps = [
+    'libp2p',
+    '@diap/sdk',
+  ];
+
+  let allOk = true;
+
+  for (const dep of nativeDeps) {
+    const depPath = path.join(rootDir, 'node_modules', dep);
+    if (!fs.existsSync(depPath)) {
+      log(`  ⚠ 缺少依赖: ${dep}`, YELLOW);
+      allOk = false;
+    }
+  }
+
+  return allOk;
+}
+
+function setupPlatform() {
+  const platform = process.platform;
+
+  log(`\n  平台: ${platform}`, CYAN);
+
+  if (platform === 'win32') {
+    // Windows: 确保 .cmd 文件存在
+    const binDir = path.join(rootDir, 'bin');
+    const cmdPath = path.join(binDir, 'bolloon.cmd');
+
+    if (fs.existsSync(binDir) && !fs.existsSync(cmdPath)) {
+      const cmdContent = `@echo off
+node "%~dp0..\\dist\\cli.js" %*
+`;
+      fs.writeFileSync(cmdPath, cmdContent);
+      log('  ✓ Windows 入口已创建', GREEN);
+    }
+  } else {
+    // Unix/Linux/Mac: 确保 bin 文件可执行
+    const binDir = path.join(rootDir, 'bin');
+    const binPath = path.join(binDir, 'bolloon.js');
+
+    if (fs.existsSync(binPath)) {
+      try {
+        fs.chmodSync(binPath, 0o755);
+        log('  ✓ bin/bolloon.js 已设为可执行', GREEN);
+      } catch (err) {
+        log(`  ⚠ 无法设置执行权限: ${err.message}`, YELLOW);
+      }
+    }
+  }
+}
+
+function main() {
+  console.log('\n📦 Bolloon 安装后处理...\n');
+
+  try {
+    // 1. 初始化用户目录
+    const bolloonDir = initUserDirs();
+    log(`  ✓ 用户数据目录: ${bolloonDir}`, GREEN);
+
+    // 2. 检查依赖
+    const depsOk = checkNativeDeps();
+    if (!depsOk) {
+      log('\n  ⚠ 部分依赖缺失，建议运行: npm install', YELLOW);
+    }
+
+    // 3. 平台特定设置
+    setupPlatform();
+
+    console.log('\n✅ 安装完成！\n');
+    console.log('  使用方式:');
+    console.log('    bolloon              # 启动 GUI');
+    console.log('    bolloon --web        # 启动 Web UI');
+    console.log('    bolloon --cli        # 命令行模式');
+    console.log('    bolloon --help       # 显示帮助\n');
+    console.log(`  配置文件: ${path.join(bolloonDir, 'config.json')}\n`);
+  } catch (err) {
+    console.error('\n❌ 安装后处理失败:', err.message);
+    console.error('  这通常不影响基本功能，继续安装...\n');
+  }
+}
+
+main();

package/bin/bolloon-daemon.sh

@@ -1,207 +0,0 @@
-#!/bin/bash
-# Bolloon Daemon - 守护进程启动脚本
-# 支持自动重启、日志轮转、PID 管理
-
-set -e
-
-APP_NAME="bolloon"
-APP_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-PID_FILE="$HOME/.bolloon/daemon.pid"
-LOG_FILE="$HOME/.bolloon/daemon.log"
-MAX_RESTARTS=5
-RESTART_DELAY=5
-
-# 颜色输出
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-log() {
-    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"
-}
-
-warn() {
-    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARN:${NC} $1"
-}
-
-error() {
-    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR:${NC} $1"
-}
-
-# 获取 PID
-get_pid() {
-    if [ -f "$PID_FILE" ]; then
-        cat "$PID_FILE"
-    fi
-}
-
-# 检查进程是否运行
-is_running() {
-    local pid=$(get_pid)
-    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-        return 0
-    fi
-    return 1
-}
-
-# 启动守护进程
-start() {
-    if is_running; then
-        log "Bolloon 已在运行 (PID: $(get_pid))"
-        return 0
-    fi
-
-    log "启动 Bolloon 守护进程..."
-
-    # 确保日志目录存在
-    mkdir -p "$(dirname "$LOG_FILE")"
-
-    # 启动进程
-    cd "$APP_DIR"
-    nohup npx tsx src/index.ts >> "$LOG_FILE" 2>&1 &
-    local pid=$!
-
-    # 保存 PID
-    echo "$pid" > "$PID_FILE"
-    log "Bolloon 已启动 (PID: $pid)"
-    log "日志文件: $LOG_FILE"
-}
-
-# 停止守护进程
-stop() {
-    local pid=$(get_pid)
-
-    if [ -z "$pid" ]; then
-        warn "Bolloon 未运行"
-        return 0
-    fi
-
-    log "停止 Bolloon (PID: $pid)..."
-
-    # 发送 SIGTERM
-    kill -TERM "$pid" 2>/dev/null || true
-
-    # 等待进程退出
-    local count=0
-    while kill -0 "$pid" 2>/dev/null && [ $count -lt 10 ]; do
-        sleep 1
-        count=$((count + 1))
-    done
-
-    # 如果还在运行，强制终止
-    if kill -0 "$pid" 2>/dev/null; then
-        warn "进程未响应，发送 SIGKILL..."
-        kill -KILL "$pid" 2>/dev/null || true
-    fi
-
-    # 清理 PID 文件
-    rm -f "$PID_FILE"
-    log "Bolloon 已停止"
-}
-
-# 重启守护进程
-restart() {
-    log "重启 Bolloon..."
-    stop
-    sleep 2
-    start
-}
-
-# 查看状态
-status() {
-    if is_running; then
-        log "Bolloon 运行中 (PID: $(get_pid))"
-        # 显示资源使用
-        local pid=$(get_pid)
-        if [ -n "$pid" ]; then
-            ps -p "$pid" -o %cpu,%mem,etime 2>/dev/null | tail -1 || true
-        fi
-    else
-        warn "Bolloon 未运行"
-    fi
-}
-
-# 查看日志
-logs() {
-    if [ -f "$LOG_FILE" ]; then
-        tail -100 "$LOG_FILE"
-    else
-        warn "日志文件不存在: $LOG_FILE"
-    fi
-}
-
-# 健康检查
-health() {
-    local port=${PORT:-54188}
-    local response=$(curl -s -o /dev/null -w "%{http_code}" "http://localhost:$port/api/health" 2>/dev/null || echo "000")
-
-    if [ "$response" = "200" ]; then
-        log "健康检查通过"
-        curl -s "http://localhost:$port/api/health" 2>/dev/null | head -5
-    else
-        error "健康检查失败 (HTTP $response)"
-        return 1
-    fi
-}
-
-# 清理日志
-clean_logs() {
-    if [ -f "$LOG_FILE" ]; then
-        local size=$(du -h "$LOG_FILE" | cut -f1)
-        log "当前日志大小: $size"
-        > "$LOG_FILE"
-        log "日志已清空"
-    fi
-}
-
-# 显示帮助
-show_help() {
-    echo "Bolloon Daemon 守护进程管理脚本"
-    echo ""
-    echo "用法: $0 [命令]"
-    echo ""
-    echo "命令:"
-    echo "  start    启动 Bolloon 守护进程"
-    echo "  stop     停止 Bolloon 守护进程"
-    echo "  restart  重启 Bolloon 守护进程"
-    echo "  status   查看运行状态"
-    echo "  logs     查看最近日志"
-    echo "  health   健康检查"
-    echo "  clean    清空日志"
-    echo "  help     显示帮助"
-    echo ""
-}
-
-# 主逻辑
-case "${1:-help}" in
-    start)
-        start
-        ;;
-    stop)
-        stop
-        ;;
-    restart)
-        restart
-        ;;
-    status)
-        status
-        ;;
-    logs)
-        logs
-        ;;
-    health)
-        health
-        ;;
-    clean)
-        clean_logs
-        ;;
-    help|--help|-h)
-        show_help
-        ;;
-    *)
-        error "未知命令: $1"
-        show_help
-        exit 1
-        ;;
-esac

package/dist/agents/chat-segmenter.js

@@ -1,298 +0,0 @@
-/**
- * chat-segmenter — 把 LLM 原始输出切成结构化 segments (前后端分离核心)
- *
- * 2026-07-01 (v0.2.6): 抽到独立模块. 目标: 前端只渲染, 不做正则.
- *
- * 设计:
- *   后端跑完 LLM 一轮后, 调 segmentChatReply() 把 reply 切成:
- *     [{type: 'think', content: '...'}, {type: 'text', content: '...'}, ...]
- *   然后序列化发给前端, 前端按 type 渲染 — 不知道任何 <invoke> / <function_calls>
- *   /<tool_call> / {tool:...} 这些 LLM 输出格式细节.
- *
- * 与 parse-tool-call.ts 的区别:
- *   - parse-tool-call: 找 **第一个** tool_call, 提取 name+args (用于 dispatch)
- *   - chat-segmenter: 切**整段** reply 为展示 segments, **完全去掉** tool_call 标记
- *                     复用 parse-tool-call 的 tool_call 检测逻辑保证一致性
- *
- * 返回类型: ChatSegment[] 序列化 JSON 给前端:
- *   {type: 'think'|'text'|'env_details'|'tool_call'|'final', content?: string, tool?: {...}}
- *
- * 顺序按 LLM 输出流排, 不重排.
- */
-import { parseToolCall } from './parse-tool-call.js';
-/** 切分 LLM 输出. */
-export function segmentChatReply(reply, ctx) {
-    if (!reply)
-        return [];
-    const segments = [];
-    let remaining = reply;
-    // === 1. 启发式: 开头"让我.../First I'll.../I should..." 句子进 think 段 ===
-    //   LLM 偶尔不写 <think> 标签但直接出思考. 启发式: 文本首句以这些模式开头 → think
-    //   必须在 step 1 (显式 <think> 切分) 之前 — 因为显式切分 push 完会反序
-    if (!remaining.startsWith('<think>')) {
-        remaining = extractLeadingThinking(remaining, segments);
-    }
-    // === 2. 切 <think>...</think> (内容保留, wrap 成 think segment) ===
-    remaining = extractAndPush('think', remaining, segments, /<think>([\s\S]*?)<\/think>/g);
-    // === 3. 切 <environment_details>...</environment_details> ===
-    remaining = extractAndPush('env_details', remaining, segments, /<environment_details>([\s\S]*?)<\/environment_details>/g);
-    // === 4. 切 tool_call 标记 (核心: 完全去掉, 不让前端看到) ===
-    //   2026-07-01 修: 这步必须在 final 之前 — final 标记之前的 tool_call 是
-    //   "LLM 在 final 之前还在调工具", 这部分 content 应进 text (中间过程), 不应进 final.
-    remaining = stripToolCallMarkers(remaining, segments, ctx);
-    // === 5. 过滤 LLM 填充词 ("好了"/"完成"/"可以" 等单句 text 不上屏) ===
-    if (remaining.trim()) {
-        remaining = filterFillerText(remaining);
-    }
-    // === 6. final 之前的 text 段 (中间对话) push — 必须在 final push 之前 ===
-    //   注意: 这时 remaining 还含 <final gen> 标记 + 标记后内容. 切 final 前先把 <final gen> 之后内容清掉
-    //   实际: 切 final 后再切 text 更清楚
-    const finalIdx = remaining.indexOf('<final gen>');
-    let beforeFinalText = remaining;
-    if (finalIdx >= 0) {
-        beforeFinalText = remaining.substring(0, finalIdx);
-    }
-    const textContent = beforeFinalText.trim();
-    if (textContent) {
-        segments.push({ type: 'text', content: textContent });
-    }
-    // === 7. 切 <final gen>...</final gen> (永远最后 push, 渲染时在最后) ===
-    if (finalIdx >= 0) {
-        const afterFinal = remaining.substring(finalIdx + '<final gen>'.length).trim();
-        if (afterFinal) {
-            segments.push({ type: 'final', content: afterFinal });
-        }
-    }
-    return segments;
-}
-/**
- * 修 extractAndPush 的 reverse 删除 bug (2026-07-01)
- *   之前: 用 mutate 后的 next 算切片, idx 错位 → 多 match 时删除错
- *   现在: 用 lastIndex 累加在原文上标记删除区, 最后一次性 slice
- */
-function extractAndPush(type, text, out, re) {
-    const matches = [];
-    const localRe = new RegExp(re.source, re.flags);
-    let m;
-    while ((m = localRe.exec(text)) !== null) {
-        const content = m[1] ? m[1].trim() : '';
-        matches.push({
-            start: m.index,
-            end: m.index + m[0].length,
-            content,
-        });
-        if (m[0].length === 0)
-            localRe.lastIndex++;
-    }
-    if (matches.length === 0)
-        return text;
-    // push 正向 (保顺序)
-    for (const m of matches) {
-        if (m.content)
-            out.push({ type, content: m.content });
-    }
-    // 删除: 在原文上基于 start/end 切片, 不在 mutate 后算 idx
-    let next = '';
-    let cursor = 0;
-    for (const m of matches) {
-        next += text.substring(cursor, m.start);
-        cursor = m.end;
-    }
-    next += text.substring(cursor);
-    return next;
-}
-/**
- * 启发式: 提取开头的"思考"句子 (2026-07-01 新增)
- *   模式: 文本开头遇到这些起手式, 整句 (到下一个 \n 或 . 或 句号) 切到 think 段
- *   例子:
- *     "让我先想想用户的需求" + 正文 → think(让我先想想用户的需求) + 正文
- *     "First I'll check the project structure" → think(...)
- *   不命中 → 整段保留, 走 text
- */
-function extractLeadingThinking(text, out) {
-    // 模式 1: 显式/隐式思考句首 (一句到第一个 \n 或 \.\?\! 结束)
-    //   "让我..." / "我先..." / "先来..." / "接下来..." / "First, ..." / "I'll ..."
-    //   整句进 think, 后续 content 进 text
-    // 模式 2: 整行都是思考 (一行 \n 间隔)
-    const firstLineEnd = text.indexOf('\n');
-    const firstLine = firstLineEnd === -1 ? text : text.substring(0, firstLineEnd);
-    const rest = firstLineEnd === -1 ? '' : text.substring(firstLineEnd + 1);
-    // 中文/英文思考起手词
-    const thinkingStartRe = /^(让我|我先|我应该|先来|先|接下来|好的[,，]?\s*我|让我先|先看看|让我看看|思考|考虑)/;
-    const enThinkingStartRe = /^(Let me|I'll|I will|First,|Next,|Now,|So,|Alright[,.]\s+(?:let me|I'll|I will))/i;
-    if (firstLine.trim().length === 0) {
-        return text; // 空开头不动
-    }
-    // 单行启发式: 整行 < 120 字符 + 起始 match → 整行进 think
-    if (firstLine.length <= 120 && (thinkingStartRe.test(firstLine) || enThinkingStartRe.test(firstLine))) {
-        out.push({ type: 'think', content: firstLine.trim() });
-        return rest;
-    }
-    // 多行启发式: 第一段 (到第一个空行) 是思考
-    if (firstLine.length <= 80 && (thinkingStartRe.test(firstLine) || enThinkingStartRe.test(firstLine))) {
-        out.push({ type: 'think', content: firstLine.trim() });
-        return rest;
-    }
-    return text;
-}
-/**
- * 过滤 LLM 填充词 (2026-07-01 新增)
- *   单独的"好了"/"完成"/"可以"/"答完了"等单句不显示在气泡
- *   配合 segmentChatReply 步骤 6
- */
-function filterFillerText(text) {
-    // 整行 = filler 词 → 整行丢
-    const lines = text.split('\n');
-    const filtered = [];
-    for (const line of lines) {
-        const t = line.trim();
-        if (!t)
-            continue;
-        // 匹配: 整行 = 填充词 (可带标点)
-        if (/^(好|好了|好的|完成|完成了|任务完成|可以|可以了|答完了|说完了|就这样|完了|done|ok|OK|Okay|okay|alright|fine|let me check|我来)\.?$/i.test(t)) {
-            continue;
-        }
-        filtered.push(line);
-    }
-    return filtered.join('\n').trim();
-}
-/** 提取正则匹配的 group(1) 内容, 包装为 segment; 原文位置去掉 */
-function stripToolCallMarkers(text, out, ctx) {
-    // 1. 解析 [TOOL_CALL]...[/TOOL_CALL]
-    let result = text.replace(/\[TOOL_CALL\][\s\S]*?\[\/TOOL_CALL\]/g, (m) => {
-        const parsed = parseToolCall(m, { tools: ctx.knownToolNames });
-        if (parsed)
-            out.push({ type: 'tool_call', tool: { name: parsed.name, args: parsed.args } });
-        return '';
-    });
-    // 2.<tool_call>...</tool_call> (OpenAI Hermes)
-    result = result.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, (m) => {
-        const parsed = parseToolCall(m, { tools: ctx.knownToolNames });
-        if (parsed)
-            out.push({ type: 'tool_call', tool: { name: parsed.name, args: parsed.args } });
-        return '';
-    });
-    // 3. <invoke name="X">...</invoke> (minimax/Hermes)
-    result = result.replace(/<invoke\s+name=["']([\w]+)["']>([\s\S]*?)<\/invoke>/g, (_m, name, inner) => {
-        if (ctx.knownToolNames.has(name)) {
-            const args = extractSimpleArgs(inner);
-            out.push({ type: 'tool_call', tool: { name, args } });
-        }
-        return '';
-    });
-    // 4. <function_calls>...</function_calls> 整块
-    result = result.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, (m) => {
-        const parsed = parseToolCall(m, { tools: ctx.knownToolNames });
-        if (parsed)
-            out.push({ type: 'tool_call', tool: { name: parsed.name, args: parsed.args } });
-        return '';
-    });
-    // 5. JSON 形式 {"name": "X", "arguments": {...}}
-    result = result.replace(/\{\s*"name"\s*:\s*"([\w]+)"\s*,\s*"(?:arguments|input|args|params)"\s*:\s*(\{[\s\S]*?\})\s*\}/g, (_m, name, argsJson) => {
-        if (!ctx.knownToolNames.has(name))
-            return '';
-        let args = {};
-        try {
-            const parsed = JSON.parse(argsJson);
-            if (parsed && typeof parsed === 'object') {
-                args = Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
-            }
-        }
-        catch { }
-        out.push({ type: 'tool_call', tool: { name, args } });
-        return '';
-    });
-    // 6. tool => "X", args => {...}  (Perplexity-style 内部)
-    result = result.replace(/\{\s*tool\s*=>\s*["']([\w]+)["']\s*(?:,\s*args\s*=>\s*(\{[\s\S]*?\}))?\s*\}/g, (_m, name, argsJson) => {
-        if (!ctx.knownToolNames.has(name))
-            return '';
-        let args = {};
-        if (argsJson) {
-            try {
-                const parsed = JSON.parse(argsJson);
-                if (parsed && typeof parsed === 'object') {
-                    args = Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
-                }
-            }
-            catch { }
-        }
-        out.push({ type: 'tool_call', tool: { name, args } });
-        return '';
-    });
-    // 7. [Function calling]...[/Function calling] 旧 bolloon
-    result = result.replace(/\[Function[^\]]*\]\s*/g, '');
-    // 8. (2026-07-01) 未闭合的 tool_call 起始标签 (LLM 偶输出截断)
-    //   例子: "<tool_call><invoke name="shell_exec"><command>ls</command></invoke>" 缺少 </tool_call>
-    //   上面 1-7 步的正则都要求完整闭合对, 不闭合会留残文.
-    //   修法: 扫到孤立起始标签 (后面没有匹配的闭合) → 整段删到 \n\n 或 end
-    result = stripUnclosedToolCallTags(result);
-    return result;
-}
-/**
- * 删未闭合的 tool_call 起始标签 + 后面到段结束 (2026-07-01)
- *   例子: "<tool_call><invoke name="shell_exec"><command>ls</command></invoke>"
- *   → 检查每个起始标签 (<tool_call>, <invoke, <function_calls, [TOOL_CALL])
- *   → 如果没找到对应闭合, 删整段
- */
-function stripUnclosedToolCallTags(text) {
-    const startTags = [
-        { tag: '<tool_call>', closeTag: '</tool_call>', openRe: /<tool_call>/g },
-        { tag: '<invoke ', closeTag: '</invoke>', openRe: /<invoke\s+name=["']([\w]+)["']>/g },
-        { tag: '<function_calls>', closeTag: '</function_calls>', openRe: /<function_calls>/g },
-        { tag: '[TOOL_CALL]', closeTag: '[/TOOL_CALL]', openRe: /\[TOOL_CALL\]/g },
-    ];
-    let result = text;
-    for (const { tag, closeTag, openRe } of startTags) {
-        let m;
-        while ((m = openRe.exec(result)) !== null) {
-            // 检查 startIdx 之后是否还有 closeTag
-            const tail = result.substring(m.index);
-            const closeIdx = tail.indexOf(closeTag);
-            if (closeIdx === -1) {
-                // 未闭合 — 删起始标签 + 之后所有内容 (到 \n\n 或 end)
-                const nextBlank = result.indexOf('\n\n', m.index);
-                const endIdx = nextBlank === -1 ? result.length : nextBlank;
-                result = result.substring(0, m.index) + result.substring(endIdx);
-                break; // 重新开始本 tag 扫描
-            }
-        }
-    }
-    return result;
-}
-/** 从 <invoke>...</invoke> inner XML 抽 <command> / <args> / <parameter> 简易 args */
-function extractSimpleArgs(inner) {
-    const args = {};
-    // <parameter name="X">value</parameter>
-    const paramRe = /<parameter\s+name=["'](\w+)["']>([\s\S]*?)<\/parameter>/g;
-    let m;
-    while ((m = paramRe.exec(inner)) !== null) {
-        args[m[1]] = m[2].trim();
-    }
-    // <param name="X">value</param>
-    if (Object.keys(args).length === 0) {
-        const shortRe = /<param\s+name=["'](\w+)["']>([\s\S]*?)<\/param>/g;
-        while ((m = shortRe.exec(inner)) !== null) {
-            args[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
-        }
-    }
-    // <command>X</command> + <args>Y</args>
-    if (Object.keys(args).length === 0) {
-        const cmdM = inner.match(/<command>([\s\S]*?)<\/command>/);
-        const argsM = inner.match(/<args>([\s\S]*?)<\/args>/);
-        if (cmdM) {
-            const cmd = cmdM[1].trim();
-            // auto-split (跟 parse-tool-call 一致: 含空格 → split)
-            if (cmd.includes(' ') && !argsM) {
-                const parts = cmd.split(/\s+/);
-                args.command = parts[0];
-                args.args = parts.slice(1).join(' ');
-            }
-            else {
-                args.command = cmd;
-            }
-        }
-        if (argsM)
-            args.args = argsM[1].trim();
-    }
-    return args;
-}