package com.custom.webui.util; /** * 流式安全的 `` 标签剥离器。 * *

为什么需要它:思考型模型(Qwen3、DeepSeek-R1 等)有两种表达思考的方式: *

    *
  1. 单独字段:{@code delta.reasoning_content}(本项目的 OpenAI 兼容实现已单独处理)
  2. *
  3. 把标签塞进正文:{@code content} 里形如 * {@code 推理过程...真正的回答}
  4. *
* 第二种如果不处理,整段推理会灌进聊天气泡、并永久写进数据库 —— * 用户看到的回答前面挂着一大段自我思考,既难看又占存储。 * *

难点在于标签可能跨 chunk 被切开。实测 vLLM 会把它拆成 * {@code ""}。因此不能对单个 chunk 做字符串替换, * 必须用一个「部分标签」缓冲区:判断当前累积内容是否是标签的前缀, * 是则暂存不输出,等后续 chunk 到齐再决定是标签还是正文。 * *

用法:每个流创建一个实例,逐块调用 {@link #accept(String)}, * 结束后调用 {@link #flush()}。 * *

流式能力的边界(重要):只有「配对标签」与「未闭合的开始标签」 * 能在流式下正确处理。**孤立的结束标签**(形如 {@code 推理回答}, * 实测 vLLM 上的 Qwen3.5 会出现)在流式下无法处理 —— * 结束标签之前的「推理」两个字早已作为正文推送给前端,而实时流 * 不可能撤回已发出的字节。要处理它必须把整个回复缓存到流结束, * 那就等于放弃打字机效果。 * *

因此分工是: *

*/ public class ThinkingTagStripper { private static final String OPEN_TAG = ""; private static final String CLOSE_TAG = ""; /** 部分标签缓冲区:只包含「可能是标签前缀」的尾巴 */ private final StringBuilder pending = new StringBuilder(); /** 是否正处于思考段内(已见到 ,还没见到 ) */ private boolean insideThinking; /** 是否把思考内容单独上报(true 时通过 thinkingSink 输出,而不是丢弃) */ private final ThinkingSink thinkingSink; /** * @param thinkingSink 思考内容的去向;传 null 表示直接丢弃 */ public ThinkingTagStripper(ThinkingSink thinkingSink) { this.thinkingSink = thinkingSink; } /** 思考内容回调 */ @FunctionalInterface public interface ThinkingSink { void accept(String thinking); } /** * 送入一个 chunk,返回应当作为**正文**输出的部分(可能为空)。 */ public String accept(String chunk) { if (chunk == null || chunk.isEmpty()) { return ""; } pending.append(chunk); StringBuilder output = new StringBuilder(); while (pending.length() > 0) { if (insideThinking) { int close = indexOf(pending, CLOSE_TAG); if (close >= 0) { // 找到结束标签:中间内容算思考 String thinking = pending.substring(0, close); emitThinking(thinking); pending.delete(0, close + CLOSE_TAG.length()); insideThinking = false; } else { // 还没结束:保留可能是部分结束标签的尾巴,其余进思考 int keep = partialSuffixLength(pending, CLOSE_TAG); int consume = pending.length() - keep; if (consume > 0) { emitThinking(pending.substring(0, consume)); pending.delete(0, consume); } break; } } else { int open = indexOf(pending, OPEN_TAG); int orphanClose = indexOf(pending, CLOSE_TAG); // 情况一:先遇到**孤立的结束标签**(没有对应的开始标签)。 // // 实测 vLLM 上的 Qwen3.5 会出现这种输出:content 直接是 // 「推理过程
真正的回答」—— 开始标签在上游被吞掉了, // 只剩结束标签。此时结束标签之前的全部内容都是推理,必须丢弃, // 否则用户的回答前面会挂着一整段自我思考。 if (orphanClose >= 0 && (open < 0 || orphanClose < open)) { emitThinking(pending.substring(0, orphanClose)); pending.delete(0, orphanClose + CLOSE_TAG.length()); insideThinking = false; continue; } if (open >= 0) { // 情况二:正常的 ... output.append(pending, 0, open); pending.delete(0, open + OPEN_TAG.length()); insideThinking = true; } else { // 情况三:都不是完整标签。 // 保留可能是**任一标签**前缀的尾巴,其余作为正文输出。 int keep = Math.max( partialSuffixLength(pending, OPEN_TAG), partialSuffixLength(pending, CLOSE_TAG)); int consume = pending.length() - keep; if (consume > 0) { output.append(pending, 0, consume); pending.delete(0, consume); } break; } } } return output.toString(); } /** * 流结束时调用。 * *

若缓冲区里还剩内容:它只是「长得像标签前缀」的普通文本 * (例如正文恰好以 {@code "<"} 结尾),必须吐出来,否则会丢字。 */ public String flush() { if (pending.length() == 0) { return ""; } String rest = pending.toString(); pending.setLength(0); if (insideThinking) { // 思考段没闭合就结束了:按思考处理,不污染正文 emitThinking(rest); return ""; } return rest; } /** 立即从一段完整文本中剥离 think 标签(非流式场景用) */ public static String stripAll(String text) { if (text == null || text.isEmpty()) { return text; } // 先处理**孤立结束标签**:出现 且它之前没有 时, // 说明前面的内容全是推理,直接截掉。这一步必须在配对处理之前做, // 否则会被当成「没有开始标签的普通文本」而原样保留。 int firstClose = indexOfIgnoreCase(text, CLOSE_TAG); int firstOpen = indexOfIgnoreCase(text, OPEN_TAG); if (firstClose >= 0 && (firstOpen < 0 || firstClose < firstOpen)) { text = text.substring(firstClose + CLOSE_TAG.length()); } String result = text; // 用循环处理多个标签段 while (true) { int open = result.indexOf(OPEN_TAG); if (open < 0) { break; } int close = result.indexOf(CLOSE_TAG, open + OPEN_TAG.length()); if (close < 0) { // 没有闭合:从 open 起全部视为思考 result = result.substring(0, open); break; } result = result.substring(0, open) + result.substring(close + CLOSE_TAG.length()); } // 有些模型用 thinking(带命名空间) result = result.replaceAll("(?is)<\\s*think\\s*>.*?", ""); return result.strip(); } private void emitThinking(String thinking) { if (thinkingSink != null && !thinking.isEmpty()) { thinkingSink.accept(thinking); } } /** 不区分大小写的 indexOf(标签可能大小写不一) */ /** 不区分大小写的字符串查找 */ private static int indexOfIgnoreCase(String text, String needle) { int limit = text.length() - needle.length(); for (int i = 0; i <= limit; i++) { boolean match = true; for (int j = 0; j < needle.length(); j++) { if (Character.toLowerCase(text.charAt(i + j)) != Character.toLowerCase(needle.charAt(j))) { match = false; break; } } if (match) { return i; } } return -1; } private static int indexOf(StringBuilder sb, String needle) { int limit = sb.length() - needle.length(); for (int i = 0; i <= limit; i++) { if (regionMatchesIgnoreCase(sb, i, needle)) { return i; } } return -1; } private static boolean regionMatchesIgnoreCase(StringBuilder sb, int offset, String needle) { for (int i = 0; i < needle.length(); i++) { char a = Character.toLowerCase(sb.charAt(offset + i)); char b = Character.toLowerCase(needle.charAt(i)); if (a != b) { return false; } } return true; } /** * 返回尾部「可能是 needle 前缀」的长度。 * *

例:needle 为 {@code ""},缓冲区以 {@code " 0; len--) { if (regionMatchesIgnoreCase(sb, sb.length() - len, needle.substring(0, len))) { return len; } } return 0; } }