mslxdff 0.1.160 → 0.1.162

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. package/package.json +1 -1
  2. package/src/autostart.js +3 -0
  3. package/src/chat-pipeline/empty-turn.js +119 -0
  4. package/src/chat-pipeline/index.js +4 -1
  5. package/src/chat-pipeline/serial-trial.js +53 -19
  6. package/src/cli/commands/daemon.js +4 -4
  7. package/src/cli/commands/model/list-providers.js +1 -1
  8. package/src/cli/commands/provider/globalqwenwork-login.js +126 -0
  9. package/src/cli/commands/provider/index.js +2 -0
  10. package/src/cli/commands/provider/models.js +3 -0
  11. package/src/cli/commands/system.js +2 -2
  12. package/src/cli/format.js +7 -0
  13. package/src/cli/policy.js +2 -2
  14. package/src/cli/provider-row.js +2 -2
  15. package/src/daemon.js +7 -2
  16. package/src/logs.js +14 -1
  17. package/src/model-trace.js +8 -4
  18. package/src/providers/classify.js +1 -1
  19. package/src/providers/dispatcher.js +26 -14
  20. package/src/providers/globalqwenwork/account-store.js +141 -0
  21. package/src/providers/globalqwenwork/constants.js +73 -0
  22. package/src/providers/globalqwenwork/cosy.js +123 -0
  23. package/src/providers/globalqwenwork/crypto.js +220 -0
  24. package/src/providers/globalqwenwork/http.js +22 -0
  25. package/src/providers/globalqwenwork/index.js +331 -0
  26. package/src/providers/globalqwenwork/payload.js +145 -0
  27. package/src/providers/globalqwenwork/rsa.js +56 -0
  28. package/src/providers/globalqwenwork/sse.js +270 -0
  29. package/src/providers/globalqwenwork/stream.js +132 -0
  30. package/src/providers/globalqwenwork/upstream.js +122 -0
  31. package/src/providers/globalqwenwork.js +1 -0
  32. package/src/providers/qoder/chat.js +16 -6
  33. package/src/providers/qoder/index.js +13 -4
  34. package/src/providers/qoder/sse.js +39 -1
  35. package/src/providers/registry.js +8 -0
  36. package/src/providers/zcode/sse.js +19 -2
  37. package/src/routes/chat/exhausted-handler.js +23 -8
  38. package/src/routes/chat/local-handler.js +3 -1
  39. package/src/routes/chat/relay-pipeline.js +22 -10
  40. package/src/routes/helpers.js +20 -4
  41. package/src/routes/stream-hold.js +138 -0
  42. package/src/routes/stream-scan.js +192 -0
  43. package/src/routes/stream.js +97 -104
  44. package/src/runtime/lifecycle-forensics.js +116 -0
  45. package/src/runtime/lifecycle-log.js +23 -0
  46. package/src/runtime/provider-gate.js +4 -3
  47. package/src/runtime/server-lifecycle.js +5 -6
  48. package/src/talk-log.js +226 -0
  49. package/src/timeline.js +5 -2
@@ -18,7 +18,11 @@ export function extractDelta(dataLine) {
18
18
  // 当普通 403;显式扫各层信号才能可靠命中(排队 10605 无 110 信号,天然不误判)。
19
19
  const quota = findQuotaSignal(wrapper);
20
20
  if (quota) return { err: { kind: "quota", status: 429, detail: quota.slice(0, 300) } };
21
- return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail } };
21
+ // 排队与额度共用 10605 容器 → 判序必须「先额度、后排队」。命中排队只在既有 upstream 上挂旗标,
22
+ // 不新增 kind:errorStatus 与流内 error 的 type 字段一律不变(对外契约零改动),
23
+ // 门面据 x-mslxdff-qoder-queued 走队列档冷却 + 同请求换号。
24
+ const queued = findQueueSignal(wrapper);
25
+ return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail, ...(queued ? { queued: true, code: queued.code } : {}) } };
22
26
  }
23
27
  const inner = wrapper.body;
24
28
  if (!inner || typeof inner !== "string") {
@@ -70,6 +74,8 @@ export function isQuotaError(code, message) {
70
74
  // 显式额度信号扫描:信封各层里找 code 110 / Billing 明确措辞。
71
75
  // 限深 4 层(实测 3 层足够,留一层余量),字符串层自动尝试 JSON.parse 后继续下钻。
72
76
  // 排队 10605(isQueued/serviceAvailable)无 110 信号 → 返回 null,天然不误判为额度。
77
+ // 排队容器码(实测与额度错共用同一容器:外层 403 → code 10605 → 内层才分额度/排队)
78
+ const QUEUE_CODE = "10605";
73
79
  const MAX_ENVELOPE_DEPTH = 4;
74
80
  export function findQuotaSignal(value, depth = 0) {
75
81
  if (value == null || depth > MAX_ENVELOPE_DEPTH) return null;
@@ -92,6 +98,38 @@ export function findQuotaSignal(value, depth = 0) {
92
98
  return null;
93
99
  }
94
100
 
101
+ /** 排队识别(与额度共用 10605 容器 → 判序必须先额度、后排队的纯函数):
102
+ * 命中条件 = 容器码 10605,或内层显式 isQueued:true / serviceAvailable:false。
103
+ * 实测形态:403 信封 → code 10605 → message 里带 isQueued:true、retryAfterSeconds:30。 */
104
+ export function isQueueSignal(code, message) {
105
+ if (String(code || "").trim() === QUEUE_CODE) return true;
106
+ const s = String(message || "");
107
+ if (!s) return false;
108
+ return /"isQueued"\s*:\s*true/.test(s) || /"serviceAvailable"\s*:\s*false/.test(s);
109
+ }
110
+
111
+ /** 排队信号扫描:与 findQuotaSignal 同构(同限深、字符串层自动 parse 下钻),命中返回 { code }。 */
112
+ export function findQueueSignal(value, depth = 0) {
113
+ if (value == null || depth > MAX_ENVELOPE_DEPTH) return null;
114
+ if (typeof value === "string") {
115
+ const s = value.trim();
116
+ if (!s) return null;
117
+ if (isQueueSignal("", s)) return { code: QUEUE_CODE };
118
+ try {
119
+ return findQueueSignal(JSON.parse(s), depth + 1);
120
+ } catch {
121
+ return null;
122
+ }
123
+ }
124
+ if (typeof value !== "object") return null;
125
+ if (isQueueSignal(value.code, value.message)) return { code: String(value.code || QUEUE_CODE) };
126
+ for (const v of Object.values(value)) {
127
+ const hit = findQueueSignal(v, depth + 1);
128
+ if (hit) return hit;
129
+ }
130
+ return null;
131
+ }
132
+
95
133
  // 错误四分类 → HTTP 状态(对齐 errors.go ErrorStatus 语义)
96
134
  export function errorStatus(err) {
97
135
  if (!err) return 500;
@@ -30,6 +30,14 @@ export const customProviders = [
30
30
  match: (id, baseUrl) => id === "qoder" || String(baseUrl).includes("qoder"),
31
31
  load: () => import("./qoder/index.js").then((m) => m.createQoderProvider),
32
32
  },
33
+ {
34
+ // ⚠ 必须排在 qwenwork 之前:qwenwork 的 match 用 `includes("qwenwork")`,
35
+ // 而 "globalqwenwork" 与 "gateway.qwenwork.ai"/"globalqwenwork://native" 都含该子串,
36
+ // 若后置会被 cn 条目抢先命中(first-match-wins),把国际站 token 打到 cn 网关。
37
+ id: "globalqwenwork",
38
+ match: (id, baseUrl) => id === "globalqwenwork" || String(baseUrl).includes("qwenwork.ai"),
39
+ load: () => import("./globalqwenwork/index.js").then((m) => m.createGlobalQwenworkProvider),
40
+ },
33
41
  {
34
42
  id: "qwenwork",
35
43
  match: (id, baseUrl) => id === "qwenwork" || String(baseUrl).includes("qwenwork"),
@@ -1,5 +1,7 @@
1
1
  // Anthropic SSE → OpenAI 形状转换(流式 / 聚合两种出口)。
2
- // 承诺字段:文本增量、tool_use 增量(tool_calls)、usage、finish_reason;thinking 块丢弃(不入历史)。
2
+ // 承诺字段:文本增量、thinking 增量(reasoning_content)、tool_use 增量(tool_calls)、usage、finish_reason。
3
+ // thinking 跨轮回填:首个 thinking block 的 signature 随 reasoning_content 挂在 assistant 历史消息上(必须,
4
+ // 上游要求 signature 与 thinking 原文一起回传;与 reasoning_content_signature 拼写不同的上游见下兼容)。
3
5
  const ENCODER = new TextEncoder();
4
6
  const DECODER = new TextDecoder();
5
7
  const STOP_REASONS = { end_turn: "stop", max_tokens: "length", tool_use: "tool_calls", stop_sequence: "stop", pause_turn: "stop" };
@@ -26,6 +28,9 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
26
28
  let inputTokens = null;
27
29
  let outputTokens = null;
28
30
  let text = "";
31
+ // thinking 全量文本(聚合出口回填 reasoning_content)与首个 signature(跨轮必需,见文件头)
32
+ let thinkingText = "";
33
+ let thinkingSig = null;
29
34
  let toolCount = 0;
30
35
  const toolIndexByBlock = new Map();
31
36
  const toolCalls = [];
@@ -55,7 +60,12 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
55
60
  }
56
61
  } else if (evt.type === "content_block_start") {
57
62
  const block = evt.content_block || {};
58
- if (block.type === "tool_use") {
63
+ if (block.type === "thinking") {
64
+ // 首个 thinking 块的 signature 留给聚合出口的跨轮回填(后续 thinking 块没有也必须回传空串占位——
65
+ // codearts 的 DeepSeek 同款要求,见 src/providers/codearts/chat.js)
66
+ if (thinkingSig === null && typeof block.signature === "string") thinkingSig = block.signature;
67
+ if (typeof block.thinking === "string" && block.thinking) thinkingText += block.thinking;
68
+ } else if (block.type === "tool_use") {
59
69
  const idx = toolCount++;
60
70
  toolIndexByBlock.set(Number(evt.index), idx);
61
71
  toolCalls.push({ id: String(block.id || `toolu_${idx}`), name: String(block.name || ""), args: "" });
@@ -66,6 +76,10 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
66
76
  if (d.type === "text_delta" && typeof d.text === "string") {
67
77
  text += d.text;
68
78
  out.push(chunkLine({ content: d.text }));
79
+ } else if (d.type === "thinking_delta" && typeof d.thinking === "string") {
80
+ thinkingText += d.thinking;
81
+ if (typeof d.signature === "string" && d.signature && thinkingSig === null) thinkingSig = d.signature;
82
+ out.push(chunkLine({ reasoning_content: d.thinking }));
69
83
  } else if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
70
84
  const idx = toolIndexByBlock.has(Number(evt.index)) ? toolIndexByBlock.get(Number(evt.index)) : Math.max(0, toolCount - 1);
71
85
  if (toolCalls[idx]) toolCalls[idx].args += d.partial_json;
@@ -113,6 +127,9 @@ export function createAnthropicTranslator({ model = "zcode", id = newId(), creat
113
127
 
114
128
  function result() {
115
129
  const message = { role: "assistant", content: text || null };
130
+ // thinking 聚合回填:跨轮必需的 signature 与原文一起带回(见文件头;codearts DeepSeek 同款)
131
+ if (thinkingText) message.reasoning_content = thinkingText;
132
+ if (thinkingSig !== null) message.reasoning_content_signature = thinkingSig;
116
133
  if (toolCalls.length) {
117
134
  message.tool_calls = toolCalls.map((t) => ({ id: t.id, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
118
135
  if (!text) message.content = null;
@@ -1,7 +1,16 @@
1
1
  // Note: 失败收尾四分支在 result 后补 client-response,与成功路径对账口径一致(result 条数 == client-response 条数)— 见 .agents/notes/implemented/bug-fix/2026-09-25-sdk-headers-timeout-and-failure-client-response.md
2
2
  import { relay } from "../stream.js";
3
+ import { endHeldFailure } from "../stream-hold.js"; // 终局收场出口(502 JSON 或 SSE 错误帧 + [DONE])
3
4
  import { json } from "../helpers.js";
4
5
  import { performance } from "node:perf_hooks";
6
+ import { recordRelayTalk } from "../../talk-log.js"; // 环形对话日志:exhausted 收尾直连 relay,落盘点必须自己补一份
7
+
8
+ // 最后一站的收场:relay 的「不写响应」路径(超时 / 空轮延后封口)都汇到这里,没有上层 failover 了,
9
+ // 必须把响应「恰好一次」地关掉。形状由 endHeldFailure 按 headers 是否已 flush 决定
10
+ // (未 flush → 502 JSON;已 flush 的 SSE → 错误帧 + [DONE]),这里不再自己 json() 打已 flush 的流。
11
+ function terminal(res, message) {
12
+ endHeldFailure(res, message || "all auto models failed");
13
+ }
5
14
 
6
15
  export async function handleExhaustedLocal({ res, body, lastErr, order, handlerCtx, evt, logCall, mark, perf0, stages, done, requested, useAuto, deps = {} }) {
7
16
  const { relay: relayImpl = relay } = deps;
@@ -15,18 +24,22 @@ export async function handleExhaustedLocal({ res, body, lastErr, order, handlerC
15
24
  onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
16
25
  });
17
26
  evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
27
+ // 绕过 relay-pipeline 的最后一站:对话日志照常落盘(正文只进 talk/*.log,不进 events.log)
28
+ try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", body, out }); } catch {}
18
29
  evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
19
30
  evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
20
- // 最后一站:relay 超时路径不写响应(设计留给上层 failover),这里没有上层,必须自己收尾
21
- if (out.timedOut) {
22
- json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
31
+ // 最后一站:relay 超时/空轮留口路径都不写响应,这里没有上层,必须自己收尾
32
+ if (out.timedOut || out.heldOpen) {
33
+ terminal(res, out.detail?.exitReason === "empty-turn-hold"
34
+ ? "EMPTY_MODEL_RESPONSE: 空轮重拉与换候选全部用尽,仍无正文"
35
+ : out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms`);
23
36
  }
24
37
  return true;
25
38
  }
26
39
  evt("result", { reqId: handlerCtx.reqId, model, status: lastErr?.status ?? 502, via: "none", timing: null });
27
40
  evt("client-response", { requested, actual: model, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
28
41
  done({ via: "none", status: lastErr?.status ?? 502, error: lastErr?.message || "all auto models failed" });
29
- json(res, 502, { error: lastErr?.message || "all auto models failed" });
42
+ terminal(res, lastErr?.message);
30
43
  return true;
31
44
  }
32
45
 
@@ -41,16 +54,18 @@ export async function handleExhaustedAll({ res, body, lastErr, order, requested,
41
54
  onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
42
55
  });
43
56
  evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
57
+ // 同上:全链耗尽的最终转发也要留下问答原文
58
+ try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", body, out }); } catch {}
44
59
  evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
45
60
  evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
46
- // 最后一站:relay 超时路径不写响应,这里没有上层 failover,必须自己收尾
47
- if (out.timedOut) {
48
- json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
61
+ // 最后一站:relay 超时/空轮留口路径不写响应,这里没有上层 failover,必须自己收尾
62
+ if (out.timedOut || out.heldOpen) {
63
+ terminal(res, out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms`);
49
64
  }
50
65
  return true;
51
66
  }
52
67
  evt("result", { reqId: handlerCtx.reqId, model: lastErr?.model ?? requested, status: lastErr?.status ?? 502, via: "none", timing: null });
53
68
  evt("client-response", { requested, actual: lastErr?.model ?? requested, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
54
- json(res, 502, { error: lastErr?.message || "all auto models failed" });
69
+ terminal(res, lastErr?.message);
55
70
  return true;
56
71
  }
@@ -56,6 +56,8 @@ export async function handleLocalRelay({
56
56
  stages,
57
57
  startedAt,
58
58
  });
59
+ // wrotePayload 是「正文真到了下游」的送达证据:serial-trial 记 empty-turn-recovered 只认它,
60
+ // 不认 handled 本身(handled 也覆盖下游已断开等零输出路径,见 ADR-0043)。
59
61
  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
60
- return { handled: true };
62
+ return { handled: true, wrotePayload: r.wrotePayload === true };
61
63
  }
@@ -5,6 +5,8 @@ import { computeMetrics } from "../../metrics.js";
5
5
  import { recordChatUsage } from "../../usage/record.js"; // 窗口报表唯一写入点(canonical 名单记防双计)— 见 .agents/notes/implemented/feature/2026-09-19-usage-report-jsonl.md
6
6
  import { recordOutput, computeOutputRow } from "../../providers/cline/usage.js"; // cline 专属旁路统计(账号×模型,流式也覆盖)
7
7
  import { upstreamEcho } from "../../model-trace.js"; // 回显头→日志字段(谁上的/哪个号/为什么/是否冷却)单一来源
8
+ import { recordRelayTalk } from "../../talk-log.js"; // 环形对话日志(问答全文,最近 1 小时):五段流水在此汇合,落盘点只这一个
9
+ import { isEmptyTurnDetail } from "../stream-scan.js"; // 空轮判据单一真相(stream.js 用它决定封不封口,这里用它决定交不交回重试)
8
10
 
9
11
  // 唯一/最后候选没有 failover 去向:首块闸门退化为纯"防连接泄漏",放宽避免误杀慢模型
10
12
  // (参考 opencode:zen 通道不设超时;openai responses 硬编码 300s headerTimeout)
@@ -127,6 +129,10 @@ export function createRelayPipeline({
127
129
  detail: out.detail ?? null,
128
130
  });
129
131
 
132
+ // 环形对话日志:只记有真实输出的轮次(空轮交给下面的空转判定另行报错)。
133
+ // 纯旁路:不改闸门、不改计时、不改返回体;任何异常都吞掉,绝不影响转发。
134
+ try { recordRelayTalk({ reqId, model: actual, via, hops, body, out, echo: upstreamEcho(upRes) }); } catch {}
135
+
130
136
  // 5a0. 空转 200:流正常结束但零正文零工具调用 → 客户端会报 EMPTY_MODEL_RESPONSE
131
137
  // ("The model ended its turn without producing any output");转 failover 而不是
132
138
  // 把空轮递给客户端。chatShaped 是前置证据:只有看得出是 chat 轮才判空,
@@ -134,23 +140,29 @@ export function createRelayPipeline({
134
140
  // 工具轮豁免:tool_calls 无正文是合法 agent 形态;
135
141
  // finish=tool_calls/function_call 兜底豁免(防计数漏检误杀);下游已断开不重试(写给谁看)。
136
142
  // 对标 dsh-cline-pass 的 EMPTY_RESPONSE 语义;不记 auto 冷却(空转≠模型坏,重试多半能好)。
143
+ // 判据单一真相在 stream-scan.js:isEmptyTurnDetail —— relay 侧「要不要封口」与这里「要不要重拉」必须同源,否则会出现留了口却不再救、或已终结却仍重拉的错拍
144
+ // heldOpen 也计入:非流式留口返回的是上游原状态码(2xx 变体或中继的 ≥400),只认 200 会漏判 → 没人收场,连接挂死
137
145
  const _d = out.detail || {};
138
- const _emptyTurn = out.status === 200 && !out.timedOut && !out.interrupted && !_d.downstreamClosed &&
139
- _d.chatShaped === true &&
140
- (Number(_d.chars) || 0) === 0 && (Number(_d.toolCalls) || 0) === 0 &&
141
- !["tool_calls", "function_call"].includes(_d.sawFinishReason);
146
+ const _emptyTurn = (out.status === 200 || out.heldOpen === true) && !out.timedOut && !out.interrupted && !_d.downstreamClosed && isEmptyTurnDetail(_d);
142
147
  if (_emptyTurn) {
143
148
  const _why = _d.sawFinishReason ? ` (finish_reason=${_d.sawFinishReason})` : " (no content, no tool calls)";
144
149
  // 错误包络暂扣后下游不再直观看到上游原文:把摘要带进最终报错(截断 200 字),排障不断线。
145
150
  const _err = _d.upstreamErrorText ? ` upstream=${String(_d.upstreamErrorText).slice(0, 200)}` : "";
146
- try { _logError(actual, 502, `empty turn${_why}${_err}`); } catch {}
147
- _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null, ...upstreamEcho(upRes) });
151
+ // 零正文的成因直接写进报错(不只给现象):finish_reason=length + 大量思考 = 额度被 reasoning 吃光
152
+ // (实测 cline-free deepseek reasoningChars=28151、completion_tokens=8192=max_tokens、chars=0)。
153
+ // 同参重拉必复现,故 serial-trial 的空转重试会顺手把 max_tokens 抬一档(见 emptyRaiseCap)。
154
+ const _lenCapped = _d.sawFinishReason === "length";
155
+ const _hint = _lenCapped && (Number(_d.reasoningChars) || 0) > 0
156
+ ? ` [思考 ${Number(_d.reasoningChars) || 0} 字刷满 max_tokens,正文 0 字]`
157
+ : "";
158
+ try { _logError(actual, 502, `empty turn${_why}${_err}${_hint}`); } catch {}
159
+ _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null, finish: _d.sawFinishReason || null, reasoningChars: Number(_d.reasoningChars) || 0, wroteFrames: Number(_d.wroteChunks) || 0, heldOpen: out.heldOpen === true, ...upstreamEcho(upRes) });
148
160
  _evt("fallback", { reqId, from: actual, to: null, reason: "empty turn" });
149
- let _errMsg = `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err} — retry or rephrase`;
161
+ let _errMsg = `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err}${_hint} — retry or rephrase`;
150
162
  if (_d.upstreamErrorText && _d.upstreamErrorText.includes("retryAfterSeconds")) {
151
163
  _errMsg = _d.upstreamErrorText;
152
164
  }
153
- return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: _errMsg } };
165
+ return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: _errMsg, emptyTurn: true, heldOpen: out.heldOpen === true } };
154
166
  }
155
167
 
156
168
  // 上报锚点偏移:relay 入口之前消耗掉的等待(上游排队、建连、provider 为取判决预读的首帧)。
@@ -186,7 +198,7 @@ export function createRelayPipeline({
186
198
  _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, interrupted: true, ...upstreamEcho(upRes), detail: out.detail ?? null, fallback, requested, actual });
187
199
  _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId, interrupted: true });
188
200
  if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, interrupted: true, fallback }).catch(() => {});
189
- return { handled: true };
201
+ return { handled: true, wrotePayload: out.detail?.wrotePayload === true };
190
202
  }
191
203
 
192
204
  // 5c. 慢速计分 + ok
@@ -257,7 +269,7 @@ export function createRelayPipeline({
257
269
  _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, ...upstreamEcho(upRes), detail: out.detail ?? null, fallback, requested, actual });
258
270
  _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId });
259
271
  if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, fallback }).catch(() => {});
260
- return { handled: true };
272
+ return { handled: true, wrotePayload: out.detail?.wrotePayload === true };
261
273
  }
262
274
 
263
275
  return { execute };
@@ -18,10 +18,26 @@ export function authorized(req, token) {
18
18
  }
19
19
 
20
20
  export function json(res, status, body) {
21
- res.statusCode = status;
22
- // 已发 headers(如 failover 时前一个候选写过 SSE 注释帧)不可再设,否则抛 ERR_HTTP_HEADERS_SENT
23
- try { if (!res.headersSent) res.setHeader("Content-Type", "application/json"); } catch { /* ignore */ }
24
- res.end(JSON.stringify(body));
21
+ // 幂等守卫:已收场的响应必须 no-op(空轮 hold 后多处共用收场出口,二次 end 会抛)
22
+ if (!res || res.writableEnded) return;
23
+ if (!res.headersSent) {
24
+ res.statusCode = status;
25
+ try { res.setHeader("Content-Type", "application/json"); } catch { /* ignore */ }
26
+ try { res.end(JSON.stringify(body)); } catch { /* ignore */ }
27
+ return;
28
+ }
29
+ // headers 已 flush(failover 前候选写过 SSE 注释帧、或空轮 hold 期间发过 keepalive):
30
+ // 设 statusCode 会抛 ERR_HTTP_HEADERS_SENT,写 JSON 体更会把 application/json 混进 text/event-stream
31
+ // (客户端只会当噪声丢掉,等于悄悄吞掉错误)。SSE 一律改用 in-band 错误帧 + [DONE] 收场。
32
+ const ct = typeof res.getHeader === "function" ? String(res.getHeader("content-type") || "") : "";
33
+ if (ct.includes("text/event-stream")) {
34
+ try {
35
+ const msg = body && typeof body === "object" ? String(body.error ?? body.message ?? JSON.stringify(body)) : String(body ?? "error");
36
+ res.write(`data: ${JSON.stringify({ error: { message: msg, type: "mslxdff_error" } })}\n\n`);
37
+ res.write("data: [DONE]\n\n");
38
+ } catch { /* 下游已断 */ }
39
+ }
40
+ try { res.end(); } catch { /* ignore */ }
25
41
  }
26
42
 
27
43
  export function notFound(res) {
@@ -0,0 +1,138 @@
1
+ // 空轮的可挽救性策略(relay 的三个问题在这里回答,stream.js 只负责转发循环):
2
+ // ① 哪些帧还能撤销?—— 一次尝试在「出现任何模型产出」之前写下去的只有空 delta 帧与 [DONE],
3
+ // 这些字节一旦入下游就撤不回(重拉的正文会接在一个已完成的流后面),所以一律暂扣;
4
+ // 攒爆上限(异常形状)才被迫提交,行为退回改前。
5
+ // ② 撤销窗口留不留?—— 流结束仍零产出且下游还活着 → 不 res.end(),把这次尝试交回同模型重拉 /
6
+ // 换候选,让后面那发的正文还能顺着同一条连接送出去。
7
+ // ③ 全部救不回来怎么收场?—— 恰好一次、形状与已发出的字节相容(见 endHeldFailure / endEmptyTurnStream)。
8
+ // 另有一条次序铁律:`[DONE]` 是流的终点,客户端解析器一见它就收尾 —— 所以**任何要补在它前面的错误帧
9
+ // 都必须先把 [DONE] 暂扣住**(tail 槽),否则错误永不可见、还会留下两个终止符。
10
+ // 拆出原因:这些策略与 relay 本体同处一文件会破仓库 20KB 硬门,且语义本就独立(不碰上游读取与闸门计时)。
11
+ import { json } from "./helpers.js";
12
+
13
+ // 暂扣上限:正常空轮的前缀就是几帧空 delta + 一个 [DONE];超过即说明不是这个形状,别为它囤内存。
14
+ export const HOLD_MAX_FRAMES = 64;
15
+ export const HOLD_MAX_BYTES = 32 * 1024;
16
+
17
+ // 空轮「延后封口 + 前缀暂扣」总开关(默认开)。0/off/false = 关:连缓冲都不做,流一结束立即 end(),
18
+ // 逐字节复现改前行为(代价:之后的空轮重拉/换候选写的是一次已终结的响应,只省额度、救不回正文)。
19
+ export function holdEndEnabled() {
20
+ const s = String(process.env.MSLXDFF_EMPTY_TURN_HOLD_END ?? "").trim().toLowerCase();
21
+ return !(s === "0" || s === "off" || s === "false");
22
+ }
23
+
24
+ /**
25
+ * 可撤销前缀缓冲。帧分三类:
26
+ * - 注释帧(非数据帧):直写,不影响可撤销性(客户端视作噪声);
27
+ * - 可撤销前缀(空 delta / finish-only 帧):暂扣,出现模型产出时按序补写;
28
+ * - `[DONE]`:即使已提交也暂扣在 tail 槽,直到确认没有错误帧要补在它前面。
29
+ * 记账(detail.wroteChunks/wroteBytes)由本模块负责,调用方不必自己数字节。
30
+ */
31
+ export function createRevocablePrefix(res, detail, { maxFrames = HOLD_MAX_FRAMES, maxBytes = HOLD_MAX_BYTES } = {}) {
32
+ let pending = [];
33
+ let pendingBytes = 0;
34
+ let tail = null; // [DONE] 槽:必须最后写,且要让位给错误帧
35
+ let committed = false;
36
+ let draining = false;
37
+ const writeNow = (buf, size) => {
38
+ if (!draining && tail) flushTail(); // 保持帧序:先补已暂扣的 [DONE],再写新到的
39
+ detail.wroteChunks += 1;
40
+ detail.wroteBytes += size;
41
+ try { res.write(buf); } catch { /* 下游已断开:onClose 已掐上游 */ }
42
+ };
43
+ const drainPending = () => {
44
+ draining = true;
45
+ try {
46
+ for (const p of pending) writeNow(p.buf, p.size);
47
+ } finally {
48
+ draining = false;
49
+ }
50
+ pending = [];
51
+ pendingBytes = 0;
52
+ };
53
+ const flushTail = () => {
54
+ if (!tail) return false;
55
+ const t = tail;
56
+ tail = null;
57
+ detail.wroteChunks += 1;
58
+ detail.wroteBytes += t.size;
59
+ try { res.write(t.buf); } catch { /* 下游已断开 */ }
60
+ return true; // 告诉收场方:[DONE] 已经由这一帧发出去了,别再补第二个
61
+ };
62
+ return {
63
+ get committed() { return committed; },
64
+ get heldFrames() { return pending.length + (tail ? 1 : 0); },
65
+ /**
66
+ * 暂扣一帧。isDone=true 的帧进 tail 槽(无论是否已提交);否则进 pending(未提交时可整段撤销)。
67
+ * 返回 false = pending 超上限放不下,调用方必须改为提交,别默默丢字节。
68
+ */
69
+ hold(buf, size, isDone = false) {
70
+ if (isDone) {
71
+ if (tail) flushTail();
72
+ tail = { buf, size };
73
+ return true;
74
+ }
75
+ if (committed) { writeNow(buf, size); return true; }
76
+ if (pending.length >= maxFrames || pendingBytes + size > maxBytes) return false;
77
+ pending.push({ buf, size });
78
+ pendingBytes += size;
79
+ return true;
80
+ },
81
+ /** 提交:按序补写 pending(不含 tail),再写本帧,此后一律直写。 */
82
+ submit(buf, size) {
83
+ committed = true;
84
+ drainPending();
85
+ writeNow(buf, size);
86
+ },
87
+ /** 收尾前补写 pending;tail 留给 flushTail 决定时机(错误帧要先站上去)。 */
88
+ commit() {
89
+ committed = true;
90
+ drainPending();
91
+ },
92
+ flushTail,
93
+ writeNow,
94
+ };
95
+ }
96
+
97
+ /**
98
+ * 终局收场:把响应「恰好一次」关掉,形状必须与已经发出去的东西相容。
99
+ * - headers 未 flush → 502 JSON(干净的 OpenAI 形错误);
100
+ * - headers 已 flush(hold 期间发过 keepalive 注释帧,状态码锁死 200 text/event-stream)
101
+ * → SSE 错误帧 + [DONE]:绝不把 JSON 体混进 event-stream,也绝不抛 ERR_HTTP_HEADERS_SENT。
102
+ * 错误文案带 EMPTY_MODEL_RESPONSE 前缀(与 errors.log / isEmptyTurnError 判据同源,可 grep 对账)。
103
+ */
104
+ export function endHeldFailure(res, message, flushTail) {
105
+ if (!res || res.writableEnded) return false;
106
+ const msg = String(message || "EMPTY_MODEL_RESPONSE: empty turn, no recovery");
107
+ if (!res.headersSent) {
108
+ // headers 都没发出去 ⇒ 这一发的暂扣帧全部作废(它们属于失败的那一发,客户端从没收到)
109
+ json(res, 502, { error: msg });
110
+ return true;
111
+ }
112
+ return closeSseWithError(res, msg, flushTail);
113
+ }
114
+
115
+ /**
116
+ * 已经提交过内容、但正文为零的流(现网主流:思考刷满 max_tokens):错误帧必须排在
117
+ * 上游的 `[DONE]` **之前**,否则客户端一见 [DONE] 就收尾,原因永不可见。
118
+ * flushTail = 把暂扣的 [DONE] 补写出去(由调用方在错误帧之后、end() 之前触发)。
119
+ */
120
+ export function endEmptyTurnStream(res, message, flushTail) {
121
+ if (!res || res.writableEnded) return false;
122
+ return closeSseWithError(res, String(message || "EMPTY_MODEL_RESPONSE: empty turn"), flushTail);
123
+ }
124
+
125
+ /**
126
+ * SSE 收场:错误帧 → 上游原 [DONE](若被暂扣过)→ end。
127
+ * 铁律:终止符只能有一个,且必须排在错误帧之后 —— 否则客户端在错误帧到达前就已收尾。
128
+ */
129
+ function closeSseWithError(res, msg, flushTail) {
130
+ try {
131
+ res.write(`data: ${JSON.stringify({ error: { message: msg, type: "mslxdff_empty_turn" } })}\n\n`);
132
+ } catch { /* 下游已断:收不到是它的权利 */ }
133
+ let emittedDone = false;
134
+ try { emittedDone = typeof flushTail === "function" ? !!flushTail() : false; } catch { /* ignore */ }
135
+ if (!emittedDone) { try { res.write("data: [DONE]\n\n"); } catch { /* ignore */ } }
136
+ try { res.end(); } catch { /* ignore */ }
137
+ return true;
138
+ }