kongdeqiang
2026-10-09 9af621d181217a03b1b3dce208a163915db974a3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
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;
    }
}