package com.custom.webui.util;
/**
* 流式安全的 `` 标签剥离器。
*
* 为什么需要它:思考型模型(Qwen3、DeepSeek-R1 等)有两种表达思考的方式:
*
* - 单独字段:{@code delta.reasoning_content}(本项目的 OpenAI 兼容实现已单独处理)
* - 把标签塞进正文:{@code content} 里形如
* {@code 推理过程...真正的回答}
*
* 第二种如果不处理,整段推理会灌进聊天气泡、并永久写进数据库 ——
* 用户看到的回答前面挂着一大段自我思考,既难看又占存储。
*
* 难点在于标签可能跨 chunk 被切开。实测 vLLM 会把它拆成
* {@code ""}。因此不能对单个 chunk 做字符串替换,
* 必须用一个「部分标签」缓冲区:判断当前累积内容是否是标签的前缀,
* 是则暂存不输出,等后续 chunk 到齐再决定是标签还是正文。
*
* 用法:每个流创建一个实例,逐块调用 {@link #accept(String)},
* 结束后调用 {@link #flush()}。
*
*
流式能力的边界(重要):只有「配对标签」与「未闭合的开始标签」
* 能在流式下正确处理。**孤立的结束标签**(形如 {@code 推理
回答},
* 实测 vLLM 上的 Qwen3.5 会出现)在流式下无法处理 ——
* 结束标签之前的「推理」两个字早已作为正文推送给前端,而实时流
* 不可能撤回已发出的字节。要处理它必须把整个回复缓存到流结束,
* 那就等于放弃打字机效果。
*
*
因此分工是:
*
* - 流式路径:处理配对/未闭合标签,保证**正文一个字都不丢**
* - {@code stripReasoningLeak}(默认关):在流末对整段正文做启发式判定,
* 覆盖孤立结束标签这类协议层无法区分的情况
* - {@link #stripAll(String)}:非流式路径使用,能完整处理孤立结束标签
*
*/
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*>.*?\\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;
}
}