Download internal/server/continue.go from a3216/gcli2api: direct link, hf CLI and curl.
- Browser
- Download file 36.8 kB
-
https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/server/continue.go
- Command line
-
hf download hf://spaces/a3216/gcli2api/internal/server/continue.go
-
curl -L -o continue.go https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/server/continue.go
36.8 kB
| // 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 | |
| } | |