@bolloon/bolloon-agent 0.2.5 → 0.2.7

package/dist/agents/chat-segmenter.js

@@ -0,0 +1,298 @@
+/**
+ * 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;
+}

package/dist/web/server.js

@@ -7,6 +7,7 @@ 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;
@@ -1408,6 +1409,12 @@ export async function createWebServer(port = 3000, options = {}) {
         next();
     });
     app.use(express.static(webRoot));
+    // 2026-07-01 (v0.2.6 修复): 前端 message-renderer import 了 src/agents/chat-segmenter.js,
+    //   浏览器加载时按相对路径解析成 /agents/chat-segmenter.js. 这个路径在 webRoot (dist/web) 之外.
+    //   解决: 把 dist/agents 也 mount 到 /agents 静态路径, 让前端 import 解析成功.
+    //   这条不破坏 segmenter 内部 import (Node 走文件系统, 浏览器走 HTTP).
+    const agentsRoot = path.join(webRoot, '..', 'agents');
+    app.use('/agents', express.static(agentsRoot));
     app.get('/', (req, res) => {
         res.sendFile(join(webRoot, 'index.html'));
     });
@@ -1466,6 +1473,31 @@ export async function createWebServer(port = 3000, options = {}) {
     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.5",
+  "version": "0.2.7",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",