File size: 36,757 Bytes
e48a2d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
// continue.go 截断自动续写:同一账号同一模型,把多段上游流拼成一条客户端可见的连续 SSE。
//
// 背景:上游对单次响应有硬上限(实测 cn:deepseek-v4.1-flash = 32000 输出 token,
// 请求显式 50000 也被夹回 32000)。Codex 这类客户端不带输出限额,写大文件/长分析
// 在 32000 处被截:旧行为是报 incomplete 让客户端自己重试("ERROR: Reconnecting"),
// 客户端重发几乎不带前段输出(≈重新生成)。
//
// 这里在帧级把截断点接上:某段以 finish_reason=length 结束、且本段是纯文本/推理输出
// (无工具调用分片)、客户端未带显式输出限额时,用同一账号同一模型补发
// 「已输出内容作 assistant + 续写指令」的请求(线上实测:模型从中断处无缝接续),
// 其帧直接接进同一条流;终端帧被吞、usage 跨段合并、客户端只看到一次连续输出。
//
// ponytail: 只续文本/推理段。工具参数被截断(半个 JSON)不续——拼接残缺 JSON 比
// 不续更糟,且上游管线本就丢弃残缺 tool_calls;命中该形态只记日志(等真实分布
// 决定要不要做 V2 的「剩余参数改写」)。每请求最多 maxContinueSegments 段。
//
// 续写段接缝的客户端可见性:思考在正文尚未开始时照常外泄(续着同一个 reasoning
// item 喂,见 frame()),消掉「续写段纯思考期零事件」的静默——Codex 的 provider
// 配置带 stream_idle_timeout_ms,静默超时判 responseStreamDisconnected 掐线
// (线上实测续写段静默约 122s 后客户端断开、请求记 interrupted)。正文已开始后
// 的思考仍剥离,残余空帧按 keepaliveEvery 补 SSE 注释帧(纯喂活、无语义)。
package server

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"strings"
	"time"

	"github.com/misakano7545/workbuddy2api-panel/internal/auth"
	"github.com/misakano7545/workbuddy2api-panel/internal/logfmt"
	"github.com/misakano7545/workbuddy2api-panel/internal/upstream"
)

// maxContinueSegments 单请求最多上游段数(1 段原生 + 最多 7 次续写)。
// 段数不是主要闸门——真正管住开销的是 continueTotalCap(累计输出 token);
// 这里只是防「续写自己也在截断」时无限套娃的硬上限。
const maxContinueSegments = 8

// defaultContinueTotalCap 没有档位下限时(客户端未指定档位、也就没算下限)
// 累计输出 token 的兜底上限。
const defaultContinueTotalCap = 32768

// continueTotalCapRatio 累计输出上限 = 该轮输出预算下限 × 这个系数。
//
// 为什么按 token 而不是按段数管:固定 3 段时,低档位(下限 4096)每段只有 ~4096
// 正文,写到第 3 段就撞上限收工——线上实测 effort=low + max_tokens=1024 写
// 「3000 字以上」的文档,3 段合计正文 9414 token 处还是半句(finish=length,尾
// 巴停在「### 5.3 …- 正常请求」)。同样的段数在高档位(下限 8192)够用,说明
// 该管的是「一共准写多少」,不是「允许问上游几次」。
const continueTotalCapRatio = 4

// continueThinkingShare 思考占「本段输出」的比例达到这个值,就认为这次截断是
// 思考吃光同一份额度造成的,而不是客户端要的长度。
//
// 背景(2026-11-07 本机实测,cn:deepseek-v4.1-flash):上游把思考与正文算在同一个
// max_tokens 里,没有独立思考上限。客户端给 8192、网关补 effort=max 时:
//
//	effort=max  → completion=8192 think=7612 正文≈580 token → finish=length(截断)
//	effort=high → completion=5794 think=3060 正文≈2734 token → finish=stop(完整)
//
// 即「思考吃掉 93% 预算,回答只剩半句」。此时客户端的限额语义(只要这么多)已经被
// 思考消费掉了,它真正想要的那份回答并没有得到——续写才是尊重意图,不续则是把
// 「预算被思考偷走」伪装成「客户端让它停」。
//
// 阈值 0.5 的依据:正常推理档下思考占比中位数 ~0.4(同日 43256 条样本),而触到
// length 的样本占比普遍 >0.85。取 0.5 既不会把「客户端真的要短回答」误判成需要续写,
// 又能覆盖思考失控的那一批。
const continueThinkingShare = 0.5

// continueNudge 续写指令:线上实测该措辞能让模型从断点无缝接续(不重头、不道歉)。
const continueNudge = "你上一条回复因达到输出长度上限被截断。请从中断处继续输出剩余内容;不要重复已输出过的部分,不要道歉或解释,直接继续。"

// keepaliveEvery 客户端可见静默的最大间隔:超时就向流里补一条 SSE 注释帧
// (": keepalive"),只喂活连接不带语义。≤0 = 每条被吞帧都补(测试确定性用)。
var keepaliveEvery = 10 * time.Second

// continueReader 读上游 SSE 并做帧级续写拼接。它在 stats/StreamHint 之下、
// 上游 body 之上:上层看到的永远是「一条完整且恰好一个终态」的流。
// 非流式(Aggregate)路径不接线——截断与重试语义由各自路径既有逻辑负责。
type continueReader struct {
	ctx      context.Context
	up       *upstream.Client
	acct     *auth.Auth
	body     []byte // 已发往上游的原始请求体(续写时在其 messages 后追加)
	clientIP string
	meta     upstream.ChatMeta

	cur io.ReadCloser
	br  *bufio.Reader
	out []byte // 已生成待输出字节

	seg      int   // 当前段序号(0 起)
	limitSet bool  // 客户端显式带了输出限额:尊重之,不续写
	limit    int64 // 该限额的值(0 = 没带或不可解析)

	finish   string   // 本段 finish_reason(续写时每段重置)
	tail     []string // finish 之后的帧:续写时丢弃,降级时原样回放
	text     strings.Builder
	reason   strings.Builder
	toolSeen bool
	errSeen  bool
	id       string

	blindRetried bool // 断流盲重试已用(每请求一次;见 canContinue)

	starvedTried bool // 空截断救援已用(每请求一次;见 tryStarvedRetry)

	// narrationTried 预告式收尾的救援续写已用(每请求一次;见 tryNarrationRetry)。
	narrationTried bool

	// toolOnlyTried 安全续写(只采纳工具调用)已用(每请求一次;见 tryToolOnlyRescue)。
	toolOnlyTried bool
	// toolOnly 当前段处于「只采纳工具调用」模式:正文/思考增量全部丢弃。
	toolOnly bool
	// toolCallBuf 只在 toolOnly 段暂存工具调用帧:判为「重发上一次调用」时整段丢弃,
	// 否则 settleToolOnly 里按原顺序补发(见那里的说明)。
	toolCallBuf []string
	// toolCallNames/toolCallArgs 按 index 累积续写段的工具调用(name 与 arguments 都
	// 分片到达),用于与请求体历史里上一次执行的调用做同名同参比较。
	toolCallNames map[int]string
	toolCallArgs  map[int]string
	// origFinish/origTail 首段的终态帧:续写段没给工具调用时原样回放。
	origFinish string
	origTail   []string

	lastClientAt time.Time // 上次客户端可见输出/keepalive 的时刻(静默节流)

	// readErr 本段结束时的读错误(nil = 上游 [DONE] 正常收尾)。用于区分「上游
	// 断流」与「客户端先断开」——两者的 err 都是非 nil,但归因完全不同:后者是
	// 人走了,不是上游故障,报成「疑似上游断流」会把排障引向错误方向。
	readErr error

	usage map[string]any // 跨段累计 usage(数字叶子求和)

	// 本段 usage 快照(每段重置):判断「预算被思考吃光」只能看当前段——
	// 跨段累计值在第二段会把第一段的思考也算进来,比率就失真了。
	segCompletion float64
	segThink      float64

	// budgetFloor 本轮生效档位对应的输出预算下限(upstream.MinOutputBudget)。
	// 续写/救援段的 max_tokens 至少是它:那些段从原始 body 重建、又常关掉思考,
	// 拿不到首段被抬过的额度,否则会继续用客户端那个装不下正文的小额度。
	budgetFloor int64

	// continueCapped 本请求因累计输出到顶而停止续写(用于日志与终态归因)。
	continueCapped bool

	done bool
}

func newContinueReader(ctx context.Context, up *upstream.Client, acct *auth.Auth, body []byte, clientIP string, meta upstream.ChatMeta, rc io.ReadCloser) *continueReader {
	return newContinueReaderWithFloor(ctx, up, acct, body, clientIP, meta, rc, 0)
}

// newContinueReaderWithFloor 同上,另外带上「本轮生效档位对应的输出预算下限」。
// 续写/救援段用它补 max_tokens:那些段是从原始 body 重建的,不会继承首段被抬过的额度
// (见 upstream.MinOutputBudget 的说明,线上实测救援段只拿到客户端原本的小额度)。
func newContinueReaderWithFloor(ctx context.Context, up *upstream.Client, acct *auth.Auth, body []byte, clientIP string, meta upstream.ChatMeta, rc io.ReadCloser, budgetFloor int64) *continueReader {
	r := &continueReader{ctx: ctx, up: up, acct: acct, body: body, clientIP: clientIP, meta: meta, cur: rc,
		lastClientAt: time.Now(), budgetFloor: budgetFloor}
	r.br = bufio.NewReaderSize(rc, 64*1024)
	r.limitSet, r.limit = bodyOutputLimit(body)
	return r
}

// clientLimitLongAnswer 客户端额度达到这个数时按「要长文」处理,而不是「只要这么短」。
//
// 实测(global:deepseek-v4.1-flash-sg,同一句「数到 20000」):max_tokens=32000 在
// completion=32000 整处 finish=length、正文停在半句;同一提示词不带额度能写 60660
// token 自然收尾。即上游是「给多少切多少」,不是有 32000 硬上限——这一档额度不代表
// 客户端只要这么短,只是它随手给的上限。
const clientLimitLongAnswer int64 = 32000

// bodyOutputLimit 请求体显式带的输出限额(任一别名,取第一个有效值)与「是否带了」。
// 带限额 = 客户端有意只要这么多(如 Claude 客户端必带 max_tokens),截断是它的预期
// 语义,不续写;但额度 ≥ clientLimitLongAnswer 时按「要长文」处理(见 canContinue)。
// 解析失败按「有限额」处理(不续),宁可少续不可续错。
func bodyOutputLimit(body []byte) (bool, int64) {
	var obj map[string]any
	if json.Unmarshal(body, &obj) != nil {
		return true, 0
	}
	for _, k := range []string{"max_tokens", "max_completion_tokens", "max_output_tokens"} {
		v, ok := obj[k]
		if !ok || v == nil {
			continue
		}
		if f, ok := v.(float64); ok && f > 0 {
			return true, int64(f)
		}
		return true, 0
	}
	return false, 0
}

// bodyHasOutputLimit 请求体是否显式带输出限额(见 bodyOutputLimit)。
func bodyHasOutputLimit(body []byte) bool {
	has, _ := bodyOutputLimit(body)
	return has
}

func (r *continueReader) Read(p []byte) (int, error) {
	for len(r.out) == 0 && !r.done {
		r.step()
	}
	if len(r.out) > 0 {
		n := copy(p, r.out)
		r.out = r.out[n:]
		return n, nil
	}
	return 0, io.EOF
}

// Close 关闭当前段 body(续写切换时已关旧段;abandon 场景由 handler defer 兜底)。
func (r *continueReader) Close() error {
	if r.cur != nil {
		return r.cur.Close()
	}
	return nil
}

// step 处理当前段的一行。与 upstream.StreamHint 的行约定保持一致:
// `data: [DONE]` 段结束;`data: <payload>` 帧;其他非空行原样透传;空行吞掉
// (帧分隔由本层自产 "\n\n")。
func (r *continueReader) step() {
	line, err := r.br.ReadString('\n')
	trimmed := strings.TrimRight(line, "\r\n")
	switch {
	case strings.HasPrefix(trimmed, "data: [DONE]"):
		r.endSegment(true)
		return
	case strings.HasPrefix(trimmed, "data: "):
		r.frame(strings.TrimPrefix(trimmed, "data: "))
	case trimmed != "":
		// 注释/心跳等非 data 行原样透传。必须**补一个空行**恢复帧边界:
		// 上游的 ": heartbeat\n" 后面跟着的是下一帧的 "data: ..."(本层吞掉了
		// 上游的分隔空行),不补的话 Responses/Messages 适配器按 "\n\n" 切帧
		// 会拿到 ": heartbeat\ndata: {...}" 粘连帧——没有 "data: " 前缀整帧
		// 被丢,恰好吞掉紧随其后的那个 content/tool_calls 增量(实测 GLM 的
		// 工具调用首帧带 id+name,被吞后整个调用消失、output 变 null)。
		r.out = append(r.out, line...)
		r.out = append(r.out, '\n')
	}
	if err != nil {
		r.readErr = err // 含 io.EOF 与读错误:交给 endSegment 归因并决定续/降级/结束
		r.endSegment(false)
	}
}

// frame 处理一个 data 帧:解析状态(正文/推理/工具/usage),决定透传、吞掉或入 tail。
func (r *continueReader) frame(payload string) {
	var obj map[string]any
	if json.Unmarshal([]byte(payload), &obj) != nil {
		// 非法 JSON:原样透传(不解析状态,防抖)
		r.emit(payload)
		return
	}
	if _, hasErr := obj["error"]; hasErr {
		r.errSeen = true
		r.emit(payload)
		return
	}
	// 同型的「流内失败帧」:上游把安全策略拦截这类失败塞在顶层 {code,msg,displayMsg}、
	// 无 choices、无 error。若不认它,这帧会走完常规路径后什么都不命中(errSeen 不置位)
	// —— 于是 (a) 日志把它记成「段无 finish 结束(疑似上游断流)」,(b) 续写段还会白跑
	// 一次盲重试去撞同一个已被拦的账号。按显式失败处理:如实透传 + 终止续写。
	if code, msg, ok := upstream.StreamErrorFrame(obj); ok {
		log.Printf("WARN: [continue] acct=%s 流内失败帧 code=%d msg=%q → 按显式失败终止(不续写)",
			logfmt.Label(r.acct.UID, r.acct.Nickname), code, msg)
		r.errSeen = true
		r.emit(payload)
		return
	}
	if id, ok := obj["id"].(string); ok && id != "" && r.id == "" {
		r.id = id
	}
	// usage 帧:消费入账(跨段合计),原始帧剥掉 usage 后再走常规路径——
	// 避免 usage 双发(本层末尾会合成一条总计帧),同时兼容与 finish/delta
	// 同帧的「bundled usage」形态(剥掉后内容照常透传)。
	hasUsage := false
	if u, ok := obj["usage"].(map[string]any); ok {
		r.mergeUsage(u)
		r.noteSegmentUsage(u)
		hasUsage = true
	}
	deltaNonEmpty := false
	rebuilt := false
	bufferedToolFrame := false // 本帧只含工具调用且处于 toolOnly 段:入缓存不下发
	if chs, ok := obj["choices"].([]any); ok && len(chs) > 0 {
		if c, ok := chs[0].(map[string]any); ok {
			if d, ok := c["delta"].(map[string]any); ok {
				if r.toolOnly && !r.toolSeen && discardToolOnlyDelta(d) {
					rebuilt = true
				}
				if s, ok := d["reasoning_content"].(string); ok && s != "" {
					r.reason.WriteString(s)
					// 续写段思考的接缝策略(两个子情形):
					//   - 正文尚未开始(r.text==0):照常外泄。此时 responses 侧的
					//     reasoning item 还开着,续写思考只是往同一个 item 里续 delta,
					//     零协议风险;同时消掉「续写段纯思考期客户端零事件」的静默——
					//     codex 的 provider 带 stream_idle_timeout_ms,实测续写段静默
					//     约 122s 后客户端断开、请求记 interrupted(观测到的截断全是
					//     text=0B 的纯思考段,正是这条路径)。
					//   - 正文已开始(message item 开着):剥离(照旧)。此时再喂思考
					//     responses 侧会开第二个 reasoning item,codex 后续文本 delta
					//     全报 "OutputTextDelta without active item"(实测 1.2 万条)。
					if r.seg > 0 && r.text.Len() > 0 {
						delete(d, "reasoning_content")
						rebuilt = true
					}
					deltaNonEmpty = true
				}
				if s, ok := d["content"].(string); ok && s != "" {
					r.text.WriteString(s)
					deltaNonEmpty = true
				}
				if tcs, ok := d["tool_calls"].([]any); ok && len(tcs) > 0 {
					r.toolSeen = true
					deltaNonEmpty = true
					// 「只采纳工具调用」段:先攒着不下发——settleToolOnly 要拿它跟历史上
					// 上一次执行过的调用比对,判为重发就整段丢弃(见那里的说明)。
					if r.toolOnly {
						r.captureToolCallDeltas(tcs)
						bufferedToolFrame = true
					}
				}
			}
			if fr, ok := c["finish_reason"].(string); ok && fr != "" {
				r.finish = fr
			}
		}
	}
	if hasUsage {
		delete(obj, "usage")
		rebuilt = true
	}
	if rebuilt {
		if raw, err := json.Marshal(obj); err == nil {
			payload = string(raw)
		}
	}
	// 空帧(各字段皆空的 no-op 帧、且非终态)→ 吞掉;这是残余的静默源,
	// 按需补 keepalive(chat 路径注释帧直达;codex 路径的续写思考帧已改为
	// 直通,见上面 reasoning 分支,不再走这里)。
	if r.seg > 0 && !deltaNonEmpty && r.finish == "" {
		r.maybeKeepalive()
		return
	}
	if r.finish != "" {
		// finish 已见:后续帧全部入 tail(续写成功则丢弃;否则原样回放)。
		r.tail = append(r.tail, payload)
		return
	}
	if hasUsage && !deltaNonEmpty {
		return // 纯 usage 帧(已入账):不再下发
	}
	if bufferedToolFrame {
		r.toolCallBuf = append(r.toolCallBuf, payload)
		return
	}
	r.emit(payload)
}

// noteSegmentUsage 记下当前段的 usage 快照(每段重置),供 starvedByThinking 判
// 「这一段的额度是不是被思考吃掉了」。上游两个字段都给过同一数值:
// 顶层 completion_thinking_tokens 与 completion_tokens_details.reasoning_tokens。
func (r *continueReader) noteSegmentUsage(u map[string]any) {
	if v, ok := u["completion_tokens"].(float64); ok {
		r.segCompletion = v
	}
	if v, ok := u["completion_thinking_tokens"].(float64); ok {
		r.segThink = v
		return
	}
	if d, ok := u["completion_tokens_details"].(map[string]any); ok {
		if v, ok := d["reasoning_tokens"].(float64); ok {
			r.segThink = v
		}
	}
}

// starvedByThinking 本段是否「思考吃掉预算」:思考 token 占本段输出 ≥
// continueThinkingShare,**且已经写出正文**。判据只看本段(见 segCompletion 注释)。
//
// 为什么要正文非空:纯思考、零正文的形态由 tryStarvedRetry 的「关思考重发」处理,
// 那条路径把预算从思考手里拿回来重写一遍;而这里若也放行,续写请求的 assistant
// 前缀是「空 content + 一堆 reasoning_content」,模型只会接着想,既写不出答案
// 又白烧一次额度(线上 starved 救援后仍零正文的那批就是这种)。
func (r *continueReader) starvedByThinking() bool {
	if r.text.Len() == 0 {
		return false
	}
	if r.segCompletion <= 0 || r.segThink <= 0 {
		return false
	}
	return r.segThink >= continueThinkingShare*r.segCompletion
}

// budgetWasRaised 客户端原本给的额度是否低于本轮下限(即网关抬过额度)。
//
// 用途:抬过额度时,真正生效的上限是网关选的数,不是客户端意图——被它切断就该续写,
// 否则只是把断点从客户端的 1024 挪到 8192,长回答照样停在半句。
func (r *continueReader) budgetWasRaised() bool {
	if r.budgetFloor <= 0 {
		return false
	}
	v, ok := clientOutputBudget(r.body)
	return ok && v > 0 && v < r.budgetFloor
}

// clientOutputBudget 读客户端原始请求体里的输出额度(三个别名)。
func clientOutputBudget(body []byte) (int64, bool) {
	var obj map[string]any
	if json.Unmarshal(body, &obj) != nil {
		return 0, false
	}
	for _, k := range []string{"max_tokens", "max_completion_tokens", "max_output_tokens"} {
		switch v := obj[k].(type) {
		case float64:
			return int64(v), true
		case int:
			return int64(v), true
		case int64:
			return v, true
		}
	}
	return 0, false
}

func (r *continueReader) emit(payload string) {
	r.lastClientAt = time.Now()
	r.out = append(r.out, "data: "...)
	r.out = append(r.out, payload...)
	r.out = append(r.out, '\n', '\n')
}

// maybeKeepalive 被吞帧到达时调用:距上次客户端可见输出超过 keepaliveEvery 就
// 补一条 SSE 注释帧。注释行(":" 开头)是 SSE 规范的 no-op——StreamHint 原样
// 透传并 flush,responsesWriter 与 chat 类客户端的解析器都忽略它;唯一作用是
// 让连接保持「有数据流动」,防流静默超时掐线。
func (r *continueReader) maybeKeepalive() {
	if keepaliveEvery > 0 && time.Since(r.lastClientAt) < keepaliveEvery {
		return
	}
	r.out = append(r.out, ": keepalive\n\n"...)
	r.lastClientAt = time.Now()
}

// endSegment 一段结束(DONE 或 EOF/读错误)时的决策:
// 能续 → 换段继续读;否则回放 tail + 合成 usage 总计 + 结束。
func (r *continueReader) endSegment(sawDone bool) {
	if r.done {
		return
	}
	if r.cur != nil {
		r.cur.Close()
	}
	// 安全续写段的裁决:拿到工具调用就采纳(继续正常收尾),否则回滚到首段终态。
	r.settleToolOnly()
	if r.tryStarvedRetry() {
		return
	}
	// 安全续写(只采纳工具调用):模型刚看完工具结果却只写一句就收尾。
	if r.tryToolOnlyRescue() {
		return
	}
	// 预告式收尾(finish=stop + 正文停在「……:」上 + 工具类请求):续写剩余内容。
	// 这条必须排在 canContinue 之前判断,但两者互斥(后者要求 finish=length 或断流)。
	if r.tryNarrationRetry() {
		return
	}
	if r.canContinue(sawDone) {
		// 必须是「断流盲重试」还是「length 截断续写」(r.finish 在续写成功后被重置)。
		blind := !sawDone && r.finish == ""
		body, err := r.continuationBody()
		if err == nil {
			rc, status, _, terr := r.up.ChatStreamContext(r.ctx, r.acct, body, r.clientIP, r.meta, nil)
			if terr == nil && status < 400 && rc != nil {
				r.seg++
				if blind {
					r.blindRetried = true
				}
				r.cur, r.br = rc, bufio.NewReaderSize(rc, 64*1024)
				blindNote := ""
				if blind {
					blindNote = " (断流盲重试)"
				}
				starvedNote := ""
				if r.limitSet && r.starvedByThinking() {
					starvedNote = fmt.Sprintf(" (思考吃光预算 think=%d/%d,关思考续写)", int(r.segThink), int(r.segCompletion))
				} else if r.budgetWasRaised() {
					starvedNote = fmt.Sprintf(" (额度已被网关抬到下限 %d,续接被该上限切断的正文)", r.budgetFloor)
				}
				log.Printf("[continue] seg=%d model=%s text=%dB reason=%dB%s%s -> 续写",
					r.seg, bareModelOf(r.body), r.text.Len(), r.reason.Len(), blindNote, starvedNote)
				r.finish, r.tail = "", nil
				// 本段 usage 快照归零:下一段的思考/正文构成要重新测(见 segCompletion)。
				r.segCompletion, r.segThink = 0, 0
				return
			}
			if rc != nil {
				rc.Close()
			}
			log.Printf("WARN: [continue] acct=%s seg=%d 续写失败(status=%d err=%v)→ 降级为截断终态",
				logfmt.Label(r.acct.UID, r.acct.Nickname), r.seg+1, status, terr)
		} else {
			log.Printf("WARN: [continue] acct=%s 续写请求体构造失败: %v",
				logfmt.Label(r.acct.UID, r.acct.Nickname), err)
		}
	} else if r.continueCapped {
		// 撞的是网关自己的累计输出上限,不是上游故障——写清楚,免得排障时
		// 把它当成「又在半句处断了」。
		log.Printf("INFO: [continue] acct=%s 累计输出 %d token 已达上限(下限 %d × %d)→ 停止续写,按截断收尾",
			logfmt.Label(r.acct.UID, r.acct.Nickname), int(r.totalOutput()),
			r.budgetFloor, continueTotalCapRatio)
	}
	// 段在没有任何 finish 的情况下以 EOF/读错误结束:疑似上游断流(正常收尾都带
	// finish_reason)。客户端此前会看到「被标 completed 的中途截断」——这里把
	// 本层早就知道的事实落到客户端可见的协议字段里(本文件开头那条契约:上层看到
	// 的永远是「一条完整且恰好一个终态」的流;此前只记日志、没落帧)。
	if r.cutNoFinish(sawDone) {
		// 归因分流:读错误是「客户端先断开」时,上游只是被动跟着断——报成「疑似
		// 上游断流」会把排障引向错误方向(实测就踩过:189s 那条被当成上游故障,
		// 实际是客户端 189s 后放弃、上游随之 cancel)。客户端断开也不补截断终态:
		// 连接已经没人读了,补帧没意义。真正的上游断流才降级为截断终态。
		if r.clientGone() {
			log.Printf("INFO: [continue] acct=%s 客户端先断开,段随之结束(非上游故障,不补截断终态)",
				logfmt.Label(r.acct.UID, r.acct.Nickname))
		} else {
			log.Printf("WARN: [continue] acct=%s 段无 finish 结束(疑似上游断流,按截断终态降级)",
				logfmt.Label(r.acct.UID, r.acct.Nickname))
			// 有真实输出才补终态:零输出段不能补——否则 StreamHint 的 validEvents 从 0
			// 变 1,空流本该收敛的 502 观测会被伪装成「有内容的 200」。
			if r.text.Len() > 0 || r.reason.Len() > 0 || r.toolSeen {
				r.emitTruncationTerminal()
			}
		}
	}
	// 不续/续写失败:回放 tail(含 finish/末端帧,客户端行为与未接线时一致),
	// 再补一条跨段合计 usage,最后 EOF([DONE] 由 StreamHint 统一补)。
	for _, f := range r.tail {
		r.emit(f)
	}
	r.tail = nil
	if r.usage != nil {
		raw, _ := json.Marshal(map[string]any{"id": r.id, "object": "chat.completion.chunk", "choices": []any{}, "usage": r.usage})
		r.emit(string(raw))
	}
	// 救援效果的可观测性:本次命中的是「预告句收尾」时,记录续写后到底拿到了什么。
	// 没有这行就分不清「救回来是工具调用(回合继续)」和「只是多打了一段正文」——
	// 线上实测命中率能到请求量的三成,必须能算清楚收益再决定判据要不要收。
	if r.narrationTried {
		log.Printf("[narration] acct=%s model=%s 结果:共 %d 段,工具调用=%v,正文合计=%dB",
			logfmt.Label(r.acct.UID, r.acct.Nickname), bareModelOf(r.body), r.seg+1, r.toolSeen, r.text.Len())
	}
	r.done = true
}

// clientGone 报告本段结束是否由「客户端先断开」引起:只看客户端自己的请求 ctx。
//
// 不能看读错误是不是 context.Canceled:上游空闲看门狗(upstream/idle.go)静默超时
// 时 cancel 的是派生的上游请求 ctx,读错误同样是 context canceled,可客户端还在等——
// 那是上游断流,该按截断降级、照常盲重试。客户端真断开时 r.ctx 必然已取消,单看它就够。
func (r *continueReader) clientGone() bool {
	return r.ctx != nil && r.ctx.Err() != nil
}

// cutNoFinish 本段是否「没有任何正常收尾就结束」(上游断流):既没给 finish_reason、
// 也没发 data: [DONE],且不是流内 error 帧(那是上游明说失败,客户端已收到 error 帧,
// 不能再补一条截断终态与之矛盾)。三处共用同一判据:续写资格、终态降级、WARN 日志。
func (r *continueReader) cutNoFinish(sawDone bool) bool {
	return !sawDone && r.finish == "" && !r.errSeen
}

// emitTruncationTerminal 补一条截断终态帧(finish_reason=length)。
//
// 本层是三条适配器(chat / responses / messages)共用的唯一接缝,所以补在这一处就能
// 让三边同时如实标截断——它们各自早已把 length 映射正确(responses →
// response.incomplete + max_output_tokens,messages → stop_reason=max_tokens),此前
// 缺的只是「这段没正常收尾」这个事实没被说出来。若在三个适配器各写一份,既重复又
// 迟早漂移。取值口径见 upstream.TruncationFinishReason。
//
// 位置:必须在 tail 回放之后、usage 帧之前(OpenAI 惯例:终态帧在前,纯 usage 帧收尾)。
// 断流分支下 tail 必为空(tail 只在见到 finish 后填充),故顺序天然正确。
func (r *continueReader) emitTruncationTerminal() {
	raw, err := json.Marshal(map[string]any{
		"id":     r.id,
		"object": "chat.completion.chunk",
		"model":  bareModelOf(r.body),
		"choices": []any{map[string]any{
			"index":         0,
			"delta":         map[string]any{},
			"finish_reason": upstream.TruncationFinishReason,
		}},
	})
	if err == nil {
		r.emit(string(raw))
	}
}

// totalOutput 累计输出 token(跨段求和;mergeUsage 已按段累加 completion_tokens)。
// 段内还没有 usage 时按 0 算——续写资格主要看 finish=length,不靠这个数。
func (r *continueReader) totalOutput() float64 {
	if f, ok := r.usage["completion_tokens"].(float64); ok {
		return f
	}
	return 0
}

// outputCapped 累计输出是否已达本请求上限(下限 × continueTotalCapRatio,兜底
// defaultContinueTotalCap)。没算下限时(客户端没指定档位)用兜底值。
func (r *continueReader) outputCapped() bool {
	capTokens := float64(defaultContinueTotalCap)
	if r.budgetFloor > 0 {
		capTokens = float64(r.budgetFloor * continueTotalCapRatio)
	}
	return r.totalOutput() >= capTokens
}

// canContinue 续写资格判定(sawDone=false 表示 EOF/读错误收尾——只有显式
// finish_reason=length 才续,读错误不续,避免把故障流当截断流续错)。
func (r *continueReader) canContinue(sawDone bool) bool {
	switch {
	case r.seg >= maxContinueSegments-1:
		return false
	case r.outputCapped():
		// 累计输出到顶:再续就是无节制地烧配额了。标出来,让终态归因能区分
		// 「撞网关自己的上限」与「上游断流」。
		r.continueCapped = true
		return false
	case r.clientGone():
		// 客户端已断连:ctx 取消后重试请求发不出去,只会白烧一次上游额度。
		// 实测就踩过(15:31:24 那条 seg=1 续写失败 context canceled)——门禁
		// 在发请求前就拦掉,别让日志里出现一次注定失败的续写。
		return false
	case r.errSeen:
		return false
	case r.limitSet && r.limit < clientLimitLongAnswer && !r.starvedByThinking() && !r.budgetWasRaised():
		// 客户端显式带限额 = 它只要这么多,截断是预期语义(Claude 客户端必带
		// max_tokens,每回合 8192)。三种例外都续写:
		//   1) 额度被思考吃光(见 continueThinkingShare)——客户端要的那份回答没写出来;
		//   2) 网关把这个额度抬到过下限(budgetWasRaised)——此时生效的上限是**网关**
		//      选的数,不是客户端的意图,被它切断就该接着写(否则「抬了额度还是断」
		//      只是把断点从 1024 挪到 8192,问题没真正解决);
		//   3) 额度 ≥ clientLimitLongAnswer——这一档额度不代表「只要这么短」(见该常量)。
		return false
	case r.cutNoFinish(sawDone):
		// 段无 finish 结束 = 上游偶发断流(线上实测:15 次续写里 1 次)。已产出内容时
		// 允许一次盲重试:重试请求体把已收内容作为 assistant 前缀,幂等不重复。
		// 主段同样给(此前只给 seg>0)——主段断流不是「请求本身失败」,它已经产出过
		// 输出,把它交给截断终态正是「Codex 每次莫名中断、要手动继续」的主因(线上
		// 实测 2 天内 27 次)。零输出段不给:没有可续的东西,且
		// 客户端已断连时 ctx 已取消、重试发不出去,不会白烧额度。
		// 含工具分片同样不给(与下面 length 分支同一条理由):残缺 tool_calls 不进
		// 重试前缀,模型会重发一遍,客户端在同一块里拼两次参数 → 半截 JSON 变垃圾。
		return (r.seg > 0 || r.text.Len() > 0 || r.reason.Len() > 0) && !r.toolSeen && !r.blindRetried
	case r.finish != "length":
		return false
	case r.toolSeen:
		log.Printf("[continue] 跳过:本段含工具调用分片(参数可能残缺,拼接风险高)")
		return false
	case r.text.Len() == 0 && r.reason.Len() == 0:
		return false
	}
	return true
}

// continuationBody 构造续写请求:原请求 messages + assistant(已输出内容)+ 续写指令。
// 复用原请求其余全部字段(model/tools/采样参数等);max_tokens 类字段已在
// canContinue 阶段排除。prepareBody/thinking/缓存键等由 ChatStreamContext 内部统一套用。
func (r *continueReader) continuationBody() ([]byte, error) {
	return r.continuationBodyWithNudge(continueNudge)
}

// continuationBodyWithNudge 同上,续写指令可替换(预告式收尾的救援用另一条指令,
// 见 narrationNudge:那条要说明「你停在一句预告上」,否则模型会以为已经说完)。
func (r *continueReader) continuationBodyWithNudge(nudge string) ([]byte, error) {
	var obj map[string]any
	if err := json.Unmarshal(r.body, &obj); err != nil {
		return nil, err
	}
	msgs, _ := obj["messages"].([]any)
	asst := map[string]any{"role": "assistant"}
	if t := r.text.String(); t != "" {
		asst["content"] = t
	} else {
		asst["content"] = ""
	}
	if rc := r.reason.String(); rc != "" {
		asst["reasoning_content"] = rc
	}
	msgs = append(msgs, asst, map[string]any{"role": "user", "content": nudge})
	obj["messages"] = msgs
	// 续写段至少带上本轮档位的输出预算下限:这一层是从原始 body 重建的,拿不到首段
	// 被 upstream 抬过的 max_tokens(见 newContinueReaderWithFloor 的说明)。
	upstream.EnsureMinBudget(obj, r.budgetFloor)
	// 思考吃光预算的续写段:把思考关掉再续。否则续写段拿同一份 max_tokens、
	// 以同一思路再烧一遍思考,三个段合计还是只写出半句(实测每段正文 ~580 token)。
	// 关思考后整份额度留给正文,一次续写就能收尾(与 starved.go 的救援同一手法:
	// 不放大客户端额度,只把预算从思考手里拿回来)。
	// 额度被网关抬过(budgetWasRaised)同样关思考:这一档的思考本身就要吃掉大半
	// 额度,继续开着只会让第二段卡在同一个上限上。
	if r.limitSet && (r.starvedByThinking() || r.budgetWasRaised()) {
		model, _ := obj["model"].(string)
		if _, has := obj["thinking"].(map[string]any); has || upstream.ThinkingSwitchSupported(model) {
			obj["thinking"] = map[string]any{"type": "disabled"}
			// disabled 与 effort 不共存(thinking.go 的 disabled 分支要求两者不共存:
			// 上游对「关思考 + 指定档位」的语义未取证)。
			delete(obj, "reasoning_effort")
			delete(obj, "reasoningEffort")
		}
	}
	return json.Marshal(obj)
}

// mergeUsage 跨段合并 usage。输出/计费侧数字叶子求和(completion、credit 等
// 跨段真实累加);prompt 侧取末段值——续写段的 prompt 天然包含整个上下文,
// 求和会把上下文重复计入 N 段倍,客户端按 usage 判断上下文占用时会被虚高
// 值误触发压缩(与真实上下文长度无关地提前全量压缩)。total_tokens 按
// 「末段 prompt + 累计 completion」重算,保持口径自洽。
func (r *continueReader) mergeUsage(u map[string]any) {
	if r.usage == nil {
		r.usage = map[string]any{}
	}
	for k, v := range u {
		switch k {
		case "prompt_tokens", "prompt_cache_hit_tokens", "prompt_cache_miss_tokens", "prompt_tokens_details":
			r.usage[k] = v // 末段值
		case "total_tokens":
			// 先按末段留作兜底(段里没有 prompt_tokens 时不会重算),末尾统一
			// 按 prompt(末段)+completion(累计) 覆盖。
			r.usage[k] = v
		default:
			if f, ok := v.(float64); ok {
				if d, ok2 := r.usage[k].(float64); ok2 {
					r.usage[k] = d + f
					continue
				}
				r.usage[k] = f
				continue
			}
			if m, ok := v.(map[string]any); ok {
				if dm, ok2 := r.usage[k].(map[string]any); ok2 {
					sumInto(dm, m)
				} else {
					nm := map[string]any{}
					sumInto(nm, m)
					r.usage[k] = nm
				}
				continue
			}
			r.usage[k] = v
		}
	}
	if p, ok := r.usage["prompt_tokens"].(float64); ok {
		c, _ := r.usage["completion_tokens"].(float64)
		r.usage["total_tokens"] = p + c
	}
}

func sumInto(dst, src map[string]any) {
	for k, v := range src {
		switch sv := v.(type) {
		case float64:
			if dv, ok := dst[k].(float64); ok {
				dst[k] = dv + sv
			} else {
				dst[k] = sv
			}
		case map[string]any:
			if dm, ok := dst[k].(map[string]any); ok {
				sumInto(dm, sv)
			} else {
				nm := map[string]any{}
				sumInto(nm, sv)
				dst[k] = nm
			}
		default:
			dst[k] = v
		}
	}
}

// bareModelOf 从请求体取裸模型名(续写日志与合成帧的 model 字段)。
// 请求体可能带 cn:/global: 路由前缀(handler 不再提前改写,出站由
// prepareBody 剥),这里必须同样剥掉,否则客户端会在续写帧里看到前缀。
func bareModelOf(body []byte) string {
	var obj struct {
		Model string `json:"model"`
	}
	if json.Unmarshal(bytes.TrimSpace(body), &obj) != nil {
		return "?"
	}
	_, bare := resolveModel(obj.Model)
	return bare
}