@bolloon/bolloon-agent 0.2.4 → 0.2.6

package/dist/agents/chat-segmenter.js

@@ -0,0 +1,190 @@
+/**
+ * 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. 切 <think>...</think> (内容保留, wrap 成 think segment) ===
+    remaining = extractAndPush('think', remaining, segments, /<think>([\s\S]*?)<\/think>/g);
+    // === 2. 切 <environment_details>...</environment_details> ===
+    remaining = extractAndPush('env_details', remaining, segments, /<environment_details>([\s\S]*?)<\/environment_details>/g);
+    // === 3. 切 <final gen>...</final gen> 或单 marker ===
+    //   final 标记后面是最终答案. 整个切出, 只留 marker 之前的内容作为 text.
+    const finalIdx = remaining.indexOf('<final gen>');
+    if (finalIdx >= 0) {
+        const afterFinal = remaining.substring(finalIdx + '<final gen>'.length).trim();
+        if (afterFinal) {
+            segments.push({ type: 'final', content: afterFinal });
+        }
+        remaining = remaining.substring(0, finalIdx).trim();
+    }
+    // === 4. 切 tool_call 标记 (核心: 完全去掉, 不让前端看到) ===
+    //    parse-tool-call 知道怎么定位. 我们做类似但收集 segment.
+    remaining = stripToolCallMarkers(remaining, segments, ctx);
+    // === 5. 剩余当 text ===
+    const textContent = remaining.trim();
+    if (textContent) {
+        segments.push({ type: 'text', content: textContent });
+    }
+    return segments;
+}
+/** 提取正则匹配的 group(1) 内容, 包装为 segment; 原文位置去掉 */
+function extractAndPush(type, text, out, re) {
+    // 关键是保留顺序. 用 exec 循环 + lastIndex 累加
+    const matches = [];
+    let m;
+    // 复制正则避免 lastIndex stateful 污染
+    const localRe = new RegExp(re.source, re.flags);
+    while ((m = localRe.exec(text)) !== null) {
+        matches.push({
+            idx: m.index,
+            len: m[0].length,
+            content: m[1].trim(),
+        });
+        if (m[0].length === 0)
+            localRe.lastIndex++; // 防无限 loop
+    }
+    if (matches.length === 0)
+        return text;
+    // 反向遍历删除, 同时按原顺序 push
+    let next = text;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const { idx, len, content } = matches[i];
+        if (!content)
+            continue;
+        next = next.substring(0, idx) + next.substring(idx + len);
+        // 但 push 是正向, 倒着算 position
+    }
+    // 重新正向 push
+    for (const m of matches) {
+        if (m.content)
+            out.push({ type, content: m.content });
+    }
+    return next;
+}
+/** 去掉 tool_call 标记 (XML / JSON / Sentinel 各种形式), 留下纯 text. 识别到的 wrap 成 tool_call 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, '');
+    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;
+}

package/dist/cli-entry.js

@@ -13,6 +13,7 @@
 import { spawn } from 'child_process';
 import * as path from 'path';
 import * as fs from 'fs';
+import { fileURLToPath } from 'url';
 const isWindows = process.platform === 'win32';
 // ANSI 颜色
 const RESET = '\x1b[0m';
@@ -66,8 +67,11 @@ ${BOLD}环境变量:${RESET}
 `);
 }
 function getDistDir() {
-    // 对于打包后的应用，__dirname 是 dist 目录
-    return __dirname;
+    // 2026-07-01: ESM 模块无 __dirname, 用 import.meta.url + path.dirname 拿当前文件所在目录.
+    // 对于打包后的应用, 这是 dist 目录; 对于 tsx 跑 src/index.ts 时, 是 src/ 目录
+    // (后续 getMainScript 会优先用 dist/cli-entry.js, 不依赖这里的返回值)
+    const __filename_esm = fileURLToPath(import.meta.url);
+    return path.dirname(__filename_esm);
 }
 function getMainScript() {
     const distDir = getDistDir();

package/dist/web/input-validator.js

@@ -0,0 +1,103 @@
+/**
+ * input-validator — web 接口输入验证 (v0.2.5)
+ *
+ * 2026-07-01: 抽到独立模块, claude code / 前端都能 import 验证.
+ *   - 后端用: POST /api/validate-input 调 validate()
+ *   - 前端用: 实时 UI 反馈 (发送前预校验, 不阻塞)
+ *
+ * 验证规则 (bolloon web 当前业务):
+ *   - text 非空 (trim 后)
+ *   - text 长度 <= MAX_TEXT_LENGTH
+ *   - text 不包含 NUL / 不可打印控制字符
+ *   - channelId 非空
+ *   - channelName (新建频道) 长度 <= MAX_NAME_LENGTH
+ *   - 不含 SQL/XSS payload 触发 (sanitize-only: 不是阻止, 是 warn)
+ *
+ * 设计: 纯函数 + 返回结构化 ValidationResult.
+ *   { ok: true, reason?, severity? }
+ *   严重等级: 'info' | 'warn' | 'block'
+ */
+export const MAX_TEXT_LENGTH = 16_000; // 大约 4K tokens, 单条 user 消息够用
+export const MAX_NAME_LENGTH = 200; // channel name 上限
+export const MAX_AGENT_ID_LENGTH = 200;
+/** 校验单条 /message 请求 (text + channelId) */
+export function validateMessageInput(input) {
+    // 1. channelId
+    if (typeof input.channelId !== 'string' || input.channelId.trim() === '') {
+        return { ok: false, severity: 'block', reason: 'channelId 必填' };
+    }
+    if (input.channelId.length > 256) {
+        return { ok: false, severity: 'block', reason: `channelId 长度超过 256 字符 (${input.channelId.length})` };
+    }
+    // 2. text
+    if (typeof input.text !== 'string') {
+        return { ok: false, severity: 'block', reason: 'text 必填且必须是字符串' };
+    }
+    const trimmed = input.text.trim();
+    if (trimmed === '') {
+        return { ok: false, severity: 'block', reason: 'text 不能为空 (trim 后)' };
+    }
+    if (trimmed.length > MAX_TEXT_LENGTH) {
+        return {
+            ok: false,
+            severity: 'block',
+            reason: `text 长度 ${trimmed.length} 超过最大 ${MAX_TEXT_LENGTH} 字符`,
+        };
+    }
+    // 3. 控制字符检测 — 拒绝 NUL + 不可打印 char (< 0x20 除了 \n \r \t)
+    // eslint-disable-next-line no-control-regex
+    const controlCharRe = /[\x00-\x08\x0B-\x0C\x0E-\x1F]/g;
+    const controlMatches = trimmed.match(controlCharRe);
+    if (controlMatches && controlMatches.length > 0) {
+        return {
+            ok: false,
+            severity: 'block',
+            reason: `text 含 ${controlMatches.length} 个不可打印控制字符`,
+        };
+    }
+    // 4. 通用安全 check — 大段 HTML/JS 注入 (sanitize 是另一层, 这里只 warn)
+    const htmlRe = /<\/?[a-z][\s\S]*>/i;
+    if (htmlRe.test(trimmed) && trimmed.length > 500) {
+        return {
+            ok: true,
+            severity: 'warn',
+            reason: 'text 包含 HTML 标签 (>500 字符), 确认发送前预览',
+            cleaned: trimmed,
+        };
+    }
+    return { ok: true, severity: 'info', cleaned: trimmed };
+}
+/** 校验 channel 创建输入 */
+export function validateChannelInput(input) {
+    if (typeof input.name !== 'string' || input.name.trim() === '') {
+        return { ok: false, severity: 'block', reason: 'name 必填' };
+    }
+    const trimmedName = input.name.trim();
+    if (trimmedName.length > MAX_NAME_LENGTH) {
+        return {
+            ok: false,
+            severity: 'block',
+            reason: `name 长度 ${trimmedName.length} 超过最大 ${MAX_NAME_LENGTH}`,
+        };
+    }
+    if (typeof input.agentId === 'string' && input.agentId.length > MAX_AGENT_ID_LENGTH) {
+        return {
+            ok: false,
+            severity: 'block',
+            reason: `agentId 长度 ${input.agentId.length} 超过最大 ${MAX_AGENT_ID_LENGTH}`,
+        };
+    }
+    return { ok: true, severity: 'info', cleaned: trimmedName };
+}
+const BOOT_TIME = Date.now();
+export function healthCheck(version) {
+    return {
+        ok: true,
+        version,
+        uptime_sec: Math.floor((Date.now() - BOOT_TIME) / 1000),
+        validators_loaded: [
+            'validateMessageInput',
+            'validateChannelInput',
+        ],
+    };
+}

package/dist/web/server.js

@@ -6,6 +6,33 @@ import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { validateMessageInput, validateChannelInput, healthCheck, } from './input-validator.js';
+import { segmentChatReply } from '../agents/chat-segmenter.js';
+// 读自身 package.json 拿 version (health endpoint 用)
+//   路径: src/web/server.ts → ../../package.json (编译后 dist/web/server.js)
+let cachedVersion = null;
+function getPackageVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const here = fileURLToPath(import.meta.url);
+        const hereDir = path.dirname(here);
+        // 试 ../package.json (相对 dist/web/) 或 ../../package.json (相对 src/web/)
+        let raw = null;
+        for (const rel of ['../package.json', '../../package.json']) {
+            try {
+                raw = fsSync.readFileSync(path.join(hereDir, rel), 'utf-8');
+                break;
+            }
+            catch { }
+        }
+        cachedVersion = raw ? (JSON.parse(raw).version ?? '0.0.0') : 'unknown';
+    }
+    catch {
+        cachedVersion = 'unknown';
+    }
+    return cachedVersion;
+}
 // 2026-06-17: 终端静默 — server.ts 高频 spam (LLM 流式每个 token 一次 broadcast,
 // 每次 P2P 收发 [v3]/[v3-meta]/[v3-cross]/[v3-friend] 各一次) 全部走 console.log proxy,
 // 默认 (BOLLOON_VERBOSE != '1') 完全不打;VERBOSE=1 时恢复.
@@ -1410,6 +1437,61 @@ export async function createWebServer(port = 3000, options = {}) {
     }
     app.get('/', serveStaticHtml('index.html', 'index.html not found; please run `npm run build:web`', 'index'));
     app.get('/api-config', serveStaticHtml('api-config.html', 'api-config.html not found; please run `npm run build:web`', 'api-config'));
+    // 2026-07-01 (v0.2.5): 输入验证 + 健康检查 API
+    //   - POST /api/validate-input: 前端发送前预校验, 避免后端 reject
+    //   - GET  /api/health: liveness probe + validators 清单
+    //   这些端点不依赖 LLM / P2P, 永远可以响应.
+    app.post('/api/validate-input', async (req, res) => {
+        try {
+            const body = req.body ?? {};
+            const kind = body.kind || 'message';
+            let result;
+            if (kind === 'channel') {
+                result = validateChannelInput({ name: body.name, agentId: body.agentId });
+            }
+            else {
+                result = validateMessageInput({ text: body.text, channelId: body.channelId });
+            }
+            res.json({
+                ok: result.ok,
+                severity: result.severity ?? (result.ok ? 'info' : 'block'),
+                reason: result.reason,
+                cleaned: result.cleaned,
+                kind,
+            });
+        }
+        catch (e) {
+            res.status(400).json({ ok: false, severity: 'block', reason: e?.message ?? 'parse error' });
+        }
+    });
+    app.get('/api/health', (_req, res) => {
+        res.json(healthCheck(getPackageVersion()));
+    });
+    // 2026-07-01 (v0.2.6): 前后端分离核心 — 后端切 LLM 输出为结构化 segments
+    //   - POST /api/segment-reply { reply, knownTools }
+    //   - 返回 ChatSegment[] (think / text / env_details / tool_call / final)
+    //   前端拿到 segments 后只渲染, 不知道任何 LLM 格式 (minimax <invoke>, Hermes <tool_call>, Qwen function_calls, JSON 形式)
+    app.post('/api/segment-reply', async (req, res) => {
+        try {
+            const body = req.body ?? {};
+            const reply = typeof body.reply === 'string' ? body.reply : '';
+            const knownToolsArr = Array.isArray(body.knownTools) ? body.knownTools : [];
+            const knownToolNames = new Set(knownToolsArr.filter((s) => typeof s === 'string'));
+            const segments = segmentChatReply(reply, { knownToolNames });
+            res.json({
+                ok: true,
+                input_length: reply.length,
+                segments,
+                segments_count: segments.length,
+                has_think: segments.some(s => s.type === 'think'),
+                has_tool_call: segments.some(s => s.type === 'tool_call'),
+                has_final: segments.some(s => s.type === 'final'),
+            });
+        }
+        catch (e) {
+            res.status(400).json({ ok: false, reason: e?.message ?? 'parse error' });
+        }
+    });
     // 全局兜底: 任何 next(err) 走到这里, 给出结构化 4xx/5xx 而不是默认 HTML
     app.use((err, req, res, _next) => {
         console.error('[server] unhandled error on', req.method, req.path, '-', err?.message || err);

package/dist/web/ui/message-renderer.js

@@ -40,6 +40,9 @@
 // 类型定义
 // ---------------------------------------------------------------------------
 import { mountStepTimeline, pushStepToTimeline, migrateStepTimeline, getStepTimeline, } from './step-timeline.js';
+// 2026-07-01 (v0.2.6): 共享后端切 LLM 输出. 消除 <invoke>/<function_calls>/<tool_call>
+//   等各种 LLM 格式在前端气泡里出现的 bug.
+import { segmentChatReply } from '../../agents/chat-segmenter.js';
 // ---------------------------------------------------------------------------
 // 模块私有状态
 // ---------------------------------------------------------------------------
@@ -117,55 +120,63 @@ export function addMessage(content, type, save = true, container, usedJudgmentId
     }
     const div = document.createElement('div');
     div.className = `message message-${type}`;
-    // 清理: 移除 tool_call 标记
-    let cleanContent = content
-        .replace(/\[TOOL_CALL\][\s\S]*?\[\/TOOL_CALL\]/g, '')
-        .replace(/TOOL_CALL[\s\S]*?\/TOOL_CALL/g, '')
-        .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
-        .replace(/\{\s*"tool":[\s\S]*?\}/g, '')
-        .replace(/\{\s*tool\s*=>\s*["'][^"']+["']\s*(?:,\s*args\s*=>\s*\{[\s\S]*?\})?\s*\}/g, '')
-        .replace(/\[Function[^\]]*\]\s*/g, '')
-        .trim();
-    // think 折叠
-    const thinkMatch = cleanContent.match(/<think>([\s\S]*?)<\/think>/);
-    let mainContent = cleanContent;
-    let thinkContainer = null;
-    if (thinkMatch) {
-        const thinkContent = thinkMatch[1].trim();
-        mainContent = cleanContent.replace(/<think>[\s\S]*?<\/think>/, '').trim();
-        thinkContainer = buildThinkContainer(thinkContent);
-    }
-    // environment_details 折叠 + 身份头
-    const envMatch = mainContent.match(/^(.+?)\n<environment_details>([\s\S]*?)<\/environment_details>\n([\s\S]*)$/);
-    if (envMatch) {
-        const identity = envMatch[1].trim();
-        const envDetails = envMatch[2].trim();
-        const messageBody = envMatch[3].trim();
-        const header = document.createElement('div');
-        header.className = 'message-header';
-        header.textContent = identity;
-        div.appendChild(header);
-        div.appendChild(buildEnvContainer(envDetails));
-        if (thinkContainer)
-            div.appendChild(thinkContainer);
-        if (messageBody)
-            div.appendChild(buildBubble(messageBody, type));
+    // 2026-07-01 (v0.2.6 前后端分离): 改用 chat-segmenter 纯函数切 LLM 输出.
+    //   之前 8 行正则漏 minimax <invoke> / Qwen function_calls / <tool_call> / {tool:..}.
+    //   单一来源: src/agents/chat-segmenter.ts (server + client 共享).
+    //   knownToolNames: 用 ctx 传入的注册表, fallback 空集 (不识别 tool_call 就 strip 不显示).
+    const knownToolNames = (ctx && ctx.knownToolNames) || new Set();
+    const segments = segmentChatReply(content, { knownToolNames });
+    // 没有可显示的 segment, 不上屏
+    if (segments.length === 0) {
+        return;
     }
-    else if (cleanContent) {
-        if (thinkContainer)
+    // 渲染各 segment (按 type 走不同容器)
+    let thinkContainer = null;
+    let renderedAny = false;
+    for (const seg of segments) {
+        if (seg.type === 'think' && seg.content) {
+            thinkContainer = buildThinkContainer(seg.content);
             div.appendChild(thinkContainer);
-        div.appendChild(buildBubble(cleanContent, type));
+            renderedAny = true;
+        }
+        else if (seg.type === 'env_details' && seg.content) {
+            div.appendChild(buildEnvContainer(seg.content));
+            renderedAny = true;
+        }
+        else if (seg.type === 'text' && seg.content) {
+            if (thinkContainer)
+                div.appendChild(thinkContainer);
+            thinkContainer = null;
+            div.appendChild(buildBubble(seg.content, type));
+            renderedAny = true;
+        }
+        else if (seg.type === 'final' && seg.content) {
+            if (thinkContainer)
+                div.appendChild(thinkContainer);
+            thinkContainer = null;
+            // final 段渲染为特殊气泡 (顶部有标记, 表示 LLM 显式终止)
+            const finalEl = buildBubble(seg.content, type);
+            finalEl.classList.add('bubble-final');
+            div.appendChild(finalEl);
+            renderedAny = true;
+        }
+        else if (seg.type === 'tool_call' && seg.tool) {
+            // tool_call segment 不渲染文字 — 走 step-timeline (步骤状态条)
+            //   这里只记录到 ctx 让外层在 addMessage 后挂到 timeline
+            if (ctx && ctx.toolCallCallback) {
+                ctx.toolCallCallback(seg.tool, div);
+            }
+            renderedAny = true; // 即使没文字, tool_call 也算"有意义"
+        }
     }
-    else {
-        return; // 空内容, 不上屏
+    if (!renderedAny) {
+        return; // 没有渲染任何东西, 不上屏
     }
-    // 纯文本用于复制按钮
-    const rawContent = cleanContent
-        .replace(/<[^>]+>/g, '')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&amp;/g, '&')
-        .replace(/&nbsp;/g, ' ');
+    // 纯文本用于复制按钮 — 现在从 segments 拼, 不再依赖 cleanContent 变量
+    const rawContent = segments
+        .filter(s => s.type === 'text' || s.type === 'final')
+        .map(s => s.content || '')
+        .join('\n');
     // 时间
     const time = document.createElement('div');
     time.className = 'time';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",