package com.custom.webui.util;
|
|
/**
|
* 流式安全的 `<think>` 标签剥离器。
|
*
|
* <p><b>为什么需要它</b>:思考型模型(Qwen3、DeepSeek-R1 等)有两种表达思考的方式:
|
* <ol>
|
* <li>单独字段:{@code delta.reasoning_content}(本项目的 OpenAI 兼容实现已单独处理)</li>
|
* <li><b>把标签塞进正文</b>:{@code content} 里形如
|
* {@code <think>推理过程...</think>真正的回答}</li>
|
* </ol>
|
* 第二种如果不处理,整段推理会灌进聊天气泡、并永久写进数据库 ——
|
* 用户看到的回答前面挂着一大段自我思考,既难看又占存储。
|
*
|
* <p><b>难点在于标签可能跨 chunk 被切开</b>。实测 vLLM 会把它拆成
|
* {@code "<thi"} + {@code "nk>"}。因此不能对单个 chunk 做字符串替换,
|
* 必须用一个「部分标签」缓冲区:判断当前累积内容是否是标签的前缀,
|
* 是则暂存不输出,等后续 chunk 到齐再决定是标签还是正文。
|
*
|
* <p>用法:每个流创建一个实例,逐块调用 {@link #accept(String)},
|
* 结束后调用 {@link #flush()}。
|
*
|
* <p><b>流式能力的边界(重要)</b>:只有「配对标签」与「未闭合的开始标签」
|
* 能在流式下正确处理。**孤立的结束标签**(形如 {@code 推理</think>回答},
|
* 实测 vLLM 上的 Qwen3.5 会出现)在流式下无法处理 ——
|
* 结束标签之前的「推理」两个字早已作为正文推送给前端,而实时流
|
* 不可能撤回已发出的字节。要处理它必须把整个回复缓存到流结束,
|
* 那就等于放弃打字机效果。
|
*
|
* <p>因此分工是:
|
* <ul>
|
* <li>流式路径:处理配对/未闭合标签,保证**正文一个字都不丢**</li>
|
* <li>{@code stripReasoningLeak}(默认关):在流末对整段正文做启发式判定,
|
* 覆盖孤立结束标签这类协议层无法区分的情况</li>
|
* <li>{@link #stripAll(String)}:非流式路径使用,能完整处理孤立结束标签</li>
|
* </ul>
|
*/
|
public class ThinkingTagStripper {
|
|
private static final String OPEN_TAG = "<think>";
|
private static final String CLOSE_TAG = "</think>";
|
|
/** 部分标签缓冲区:只包含「可能是标签前缀」的尾巴 */
|
private final StringBuilder pending = new StringBuilder();
|
|
/** 是否正处于思考段内(已见到 <think>,还没见到 </think>) */
|
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 直接是
|
// 「推理过程</think>真正的回答」—— 开始标签在上游被吞掉了,
|
// 只剩结束标签。此时结束标签之前的全部内容都是推理,必须丢弃,
|
// 否则用户的回答前面会挂着一整段自我思考。
|
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) {
|
// 情况二:正常的 <think>...</think>
|
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();
|
}
|
|
/**
|
* 流结束时调用。
|
*
|
* <p>若缓冲区里还剩内容:它只是「长得像标签前缀」的普通文本
|
* (例如正文恰好以 {@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;
|
}
|
|
// 先处理**孤立结束标签**:出现 </think> 且它之前没有 <think> 时,
|
// 说明前面的内容全是推理,直接截掉。这一步必须在配对处理之前做,
|
// 否则会被当成「没有开始标签的普通文本」而原样保留。
|
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*>.*?</\\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 前缀」的长度。
|
*
|
* <p>例:needle 为 {@code "<think>"},缓冲区以 {@code "<thi"} 结尾时返回 4。
|
*/
|
private static int partialSuffixLength(StringBuilder sb, String needle) {
|
int max = Math.min(needle.length() - 1, sb.length());
|
for (int len = max; len > 0; len--) {
|
if (regionMatchesIgnoreCase(sb, sb.length() - len, needle.substring(0, len))) {
|
return len;
|
}
|
}
|
return 0;
|
}
|
}
|