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
@@ -4,8 +4,75 @@
4
4
  // 语义钉子:detail.chars 只算正文,思考内容另计(reasoningChars)——两者相加会重复计数。
5
5
  import { extractUsageFromJson } from "../metrics.js";
6
6
 
7
+ // 环形对话日志(talk log)的正文捕获:只有 relay 建了 detail.talk 才累积,未开启时零开销。
8
+ // 口径与 chars/reasoningChars 同源(读 delta,不读聚合帧),区别是这里存原文而不是只计数。
9
+ // 同样的边界:SSE 帧被 chunk 切断时该帧内容丢失(JSON.parse 失败即跳过)—— 研究用途可接受。
10
+ const TALK_CAP_CHARS = 400_000;
11
+
12
+ function talkPush(talk, dst, v) {
13
+ if (typeof v !== "string" || !v) return;
14
+ if (talk.n >= TALK_CAP_CHARS) { talk.capped = true; return; }
15
+ talk.n += v.length;
16
+ talk[dst].push(v);
17
+ }
18
+
19
+ // 流式 tool_calls 是分片到达的(index 定位、arguments 逐段拼),按 index 合回完整调用才看得懂。
20
+ function talkMergeToolCalls(talk, tcs) {
21
+ for (const tc of tcs) {
22
+ const i = Number.isInteger(tc?.index) ? tc.index : talk.tools.length;
23
+ let slot = talk.tools[i];
24
+ if (!slot) { slot = { id: "", type: "function", function: { name: "", arguments: "" } }; talk.tools[i] = slot; }
25
+ if (tc.id) slot.id = tc.id;
26
+ const nm = tc.function?.name;
27
+ const ar = tc.function?.arguments;
28
+ if (typeof nm === "string" && nm && !slot.function.name.includes(nm)) slot.function.name += nm;
29
+ if (typeof ar === "string" && ar) slot.function.arguments += ar;
30
+ }
31
+ }
32
+
33
+ /** 新建累积桶(n/capped 防超长生成把内存吃穿)。 */
34
+ export function createTalkBucket() { return { reasoning: [], content: [], tools: [], n: 0, capped: false }; }
35
+
36
+ /** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启,直接返回。 */
37
+ export function captureTalkSse(talk, txt) {
38
+ if (!talk) return;
39
+ for (const raw of String(txt ?? "").split("\n")) {
40
+ const t = raw.trim();
41
+ if (!t.startsWith("data:")) continue;
42
+ const d = t.slice(5).trim();
43
+ if (!d || d === "[DONE]") continue;
44
+ let j = null;
45
+ try { j = JSON.parse(d); } catch { continue; }
46
+ const c0 = Array.isArray(j?.choices) ? j.choices[0] : null;
47
+ if (!c0) continue;
48
+ for (const src of [c0.delta, c0.message]) {
49
+ if (!src) continue;
50
+ talkPush(talk, "reasoning", src.reasoning_content ?? src.reasoning);
51
+ talkPush(talk, "content", src.content);
52
+ if (Array.isArray(src.tool_calls)) talkMergeToolCalls(talk, src.tool_calls);
53
+ }
54
+ }
55
+ }
56
+
57
+ /** 非流式:整块 message 直接入桶(tool_calls 参数本来就是完整的)。 */
58
+ export function captureTalkMessage(talk, msg) {
59
+ if (!talk || !msg) return;
60
+ talkPush(talk, "reasoning", msg.reasoning_content ?? msg.reasoning);
61
+ talkPush(talk, "content", msg.content);
62
+ if (Array.isArray(msg.tool_calls)) talkMergeToolCalls(talk, msg.tool_calls);
63
+ }
64
+
65
+ /** 透传兜底:无 chat 帧可解析(纯文本/未知形状)时把原文当正文收下,别让对话日志留空洞。 */
66
+ export function captureTalkFallback(talk, text) {
67
+ if (!talk || !text) return;
68
+ if (talk.reasoning.length || talk.content.length || talk.tools.length) return;
69
+ if (String(text).includes('"choices"')) return;
70
+ talkPush(talk, "content", String(text));
71
+ }
72
+
7
73
  // 逐 SSE chunk 扫描:done/finish_reason/chat 形状/工具调用/usage/正文字符
8
74
  export function scanSseChunk(detail, txt) {
75
+ if (detail.talk) captureTalkSse(detail.talk, txt);
9
76
  try {
10
77
  if (txt.includes("[DONE]")) detail.sawDone = true;
11
78
  const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);
@@ -73,6 +140,7 @@ export function scanNonStreamBody(detail, parsed) {
73
140
  if (Array.isArray(parsed?.choices)) detail.chatShaped = true;
74
141
  const _tcList = parsed.choices?.[0]?.message?.tool_calls;
75
142
  if (Array.isArray(_tcList) && _tcList.length) detail.toolCalls = _tcList.length;
143
+ if (detail.talk) captureTalkMessage(detail.talk, parsed.choices?.[0]?.message || (parsed.choices?.[0]?.text ? { content: parsed.choices[0].text } : null));
76
144
  }
77
145
 
78
146
  // 上报锚点偏移:转发入口时刻 − 本次上游尝试起点(performance.now 同源)。
@@ -84,3 +152,127 @@ export function preflightMs(t0, attemptStartMs) {
84
152
  const delta = Math.round(t0 - attemptStartMs);
85
153
  return delta > 0 ? delta : 0;
86
154
  }
155
+
156
+ /**
157
+ * 空轮判据(纯函数,唯一真相):看得 chat 形状 + 零正文 + 零工具调用 + 收尾不是工具轮。
158
+ * stream.js 用它决定「这次要不要封口」,relay-pipeline 用它决定「交不交回重试」——两处不得各写一份。
159
+ * chatShaped 是前置证据:非 chat SSE / 无 choices 的透传是正式契约,一律放行不判空。
160
+ */
161
+ export function isEmptyTurnDetail(d) {
162
+ if (!d || d.chatShaped !== true) return false;
163
+ if ((Number(d.chars) || 0) > 0 || (Number(d.toolCalls) || 0) > 0) return false;
164
+ if (["tool_calls", "function_call"].includes(d.sawFinishReason)) return false;
165
+ return true;
166
+ }
167
+
168
+ // ===== 从 stream.js 迁入(体积门:stream.js 承载 relay 本体,纯判定函数一律住这里)=====
169
+
170
+ // 错误包络 chunk 判定(纯函数):data 行 JSON 含顶层 .error 对象、或只有 finish_reason=error
171
+ // 的空帧,且整 chunk 无任何 content/tool_calls/reasoning 输出 → 返回错误摘要(建议暂扣),
172
+ // 否则返回 null(透传)。解析失败一律透传(默认保安全)。
173
+ // 背景:网关把上游失败包成 HTTP 200 SSE;暂扣后下游流式 UI 不再展示瞬时错误
174
+ //(如 Vertex 503 + google fallback 400),本轮走空转重试,客户端只看到最终结果。
175
+ // Note: 流内错误包络捕获与 retryAfterSeconds 错误直出 — 见 .agents/notes/implemented/bug-fix/2026-09-28-retry-after-surfacing-error.md
176
+ export function extractRetryAfterSec(obj) {
177
+ if (!obj) return null;
178
+ if (typeof obj === "number") return obj;
179
+ if (typeof obj === "string") {
180
+ const m = obj.match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || obj.match(/\bretryAfterSeconds\s*[:=]\s*(\d+)/i);
181
+ if (m) return Number(m[1]);
182
+ try {
183
+ const parsed = JSON.parse(obj);
184
+ return extractRetryAfterSec(parsed);
185
+ } catch {}
186
+ }
187
+ if (typeof obj === "object") {
188
+ if (Number.isFinite(obj.retryAfterSeconds)) return Number(obj.retryAfterSeconds);
189
+ if (obj.message) {
190
+ const r = extractRetryAfterSec(obj.message);
191
+ if (r != null) return r;
192
+ }
193
+ }
194
+ return null;
195
+ }
196
+
197
+ export function holdableChunk(txt) {
198
+ if (typeof txt !== "string" || !txt.includes("data:")) return null;
199
+ let sawData = false;
200
+ let sawEventError = false;
201
+ let retrySec = null;
202
+ const errs = [];
203
+ for (const rawLine of txt.split("\n")) {
204
+ const t = rawLine.trim();
205
+ if (t.startsWith("event:") && t.slice(6).trim() === "error") {
206
+ sawEventError = true;
207
+ continue;
208
+ }
209
+ if (!t.startsWith("data:")) continue;
210
+ const d = t.slice(5).trim();
211
+ if (!d || d === "[DONE]") continue;
212
+ let j = null;
213
+ try { j = JSON.parse(d); } catch { return null; }
214
+ if (!j || typeof j !== "object") return null;
215
+ sawData = true;
216
+ const c0 = (Array.isArray(j.choices) && j.choices[0]) || {};
217
+ const delta = c0.delta || {};
218
+ const msg = c0.message || {};
219
+ const out = delta.content || msg.content || delta.tool_calls || msg.tool_calls || delta.reasoning || msg.reasoning;
220
+ if (out && !(Array.isArray(out) && out.length === 0)) return null;
221
+
222
+ const r = extractRetryAfterSec(j);
223
+ if (r != null) {
224
+ retrySec = r;
225
+ continue;
226
+ }
227
+ if (j.error && typeof j.error === "object") {
228
+ const m = j.error.message || j.error.code || "";
229
+ if (m) errs.push(String(m).slice(0, 300));
230
+ } else if (sawEventError && j.message) {
231
+ errs.push(String(j.message).slice(0, 300));
232
+ } else if (c0.finish_reason === "error") {
233
+ errs.push("finish_reason=error 空帧");
234
+ }
235
+ }
236
+ if (!sawData) return null;
237
+ if (retrySec != null) return `上游供应商触发 retryAfterSeconds: ${retrySec} ,请等候重试`;
238
+ if (errs.length) return errs.join(" | ");
239
+ if (sawEventError) return "event: error 空帧";
240
+ return null;
241
+ }
242
+
243
+ /**
244
+ * 「可撤销前缀」判据(纯函数):这个 chunk 里除空 delta 帧与 [DONE] 外不含任何信息吗?
245
+ * 只有答案为是才允许暂扣不写——透传是正式契约:解析失败的帧、看不懂的形状一律立即透传(与
246
+ * holdableChunk 同一口径:默认保安全,绝不因为想救空轮而扣掉本该原样转给客户端的字节)。
247
+ */
248
+ export function isTrivialFrame(txt) {
249
+ if (typeof txt !== "string" || !txt.includes("data:")) return false;
250
+ let sawData = false;
251
+ for (const rawLine of txt.split("\n")) {
252
+ const t = rawLine.trim();
253
+ if (!t.startsWith("data:")) continue;
254
+ const d = t.slice(5).trim();
255
+ if (!d) continue;
256
+ if (d === "[DONE]") { sawData = true; continue; } // 结束符不含模型输出,可撤销
257
+ let j = null;
258
+ try { j = JSON.parse(d); } catch { return false; } // 解析失败 → 透传,绝不撤销
259
+ if (!j || typeof j !== "object" || Array.isArray(j)) return false;
260
+ // 白名单式可撤销:只认「choices 数组、且其中没有任何文本载荷」的 chat 帧。
261
+ // 其余形状(choices[].text、delta.text、顶层 usage、无 choices 的自定义帧……)一律算有信息 → 透传。
262
+ if (!Array.isArray(j.choices)) return false;
263
+ sawData = true;
264
+ if (j.choices.some((c) => c && typeof c === "object" && (c.text || c.message?.text))) return false;
265
+ for (const c of j.choices) {
266
+ if (!c || typeof c !== "object") return false;
267
+ for (const src of [c.delta, c.message]) {
268
+ if (!src || typeof src !== "object") continue;
269
+ for (const [k, v] of Object.entries(src)) {
270
+ if (k === "role" || k === "index" || k === "function_call_name") continue; // 无信息骨架字段
271
+ if (v == null || v === "") continue;
272
+ if (Array.isArray(v) ? v.length > 0 : true) return false; // 任何非空载荷都算产出
273
+ }
274
+ }
275
+ }
276
+ }
277
+ return sawData;
278
+ }
@@ -2,7 +2,9 @@ import { performance } from "node:perf_hooks";
2
2
  import { applyFallbackHeaders, enrichNonStreamJson, enrichSseChunkText } from "./fallback.js";
3
3
  import { json } from "./helpers.js";
4
4
  import { extractUsageFromSseText } from "../metrics.js";
5
- import { scanSseChunk, scanNonStreamBody, preflightMs } from "./stream-scan.js"; // 逐帧/逐体观测累加器 + 上报锚点偏移(纯函数)
5
+ import { scanSseChunk, scanNonStreamBody, preflightMs, createTalkBucket, captureTalkFallback, isEmptyTurnDetail, holdableChunk, extractRetryAfterSec, isTrivialFrame } from "./stream-scan.js"; // 逐帧/逐体观测累加器 + 锚点偏移 + 对话正文 + 空轮判据 + 错误包络暂扣 + 可撤销前缀判据(纯函数全在 stream-scan)
6
+ import { talkLogEnabled } from "../talk-log.js"; // 环形对话日志开关(默认开)
7
+ import { holdEndEnabled, createRevocablePrefix, endEmptyTurnStream } from "./stream-hold.js"; // 空轮可撤销前缀 / 延后封口 / 终局收场(拆出去是为了不破 stream.js 20KB 硬门)
6
8
  // SDK 通道(TextEncoder)产出 Uint8Array,legacy 通道为 Buffer;
7
9
  // 统一转文本,避免 [DONE]/finish_reason/usage/chars 统计在 SDK 路径下静默失效。
8
10
  function chunkText(chunk) {
@@ -30,79 +32,6 @@ function hasPayload(text) {
30
32
  return false;
31
33
  }
32
34
 
33
- // 错误包络 chunk 判定(纯函数):data 行 JSON 含顶层 .error 对象、或只有 finish_reason=error
34
- // 的空帧,且整 chunk 无任何 content/tool_calls/reasoning 输出 → 返回错误摘要(建议暂扣),
35
- // 否则返回 null(透传)。解析失败一律透传(默认保安全)。
36
- // 背景:网关把上游失败包成 HTTP 200 SSE;暂扣后下游流式 UI 不再展示瞬时错误
37
- //(如 Vertex 503 + google fallback 400),本轮走空转重试,客户端只看到最终结果。
38
- // Note: 流内错误包络捕获与 retryAfterSeconds 错误直出 — 见 .agents/notes/implemented/bug-fix/2026-09-28-retry-after-surfacing-error.md
39
- function extractRetryAfterSec(obj) {
40
- if (!obj) return null;
41
- if (typeof obj === "number") return obj;
42
- if (typeof obj === "string") {
43
- const m = obj.match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || obj.match(/\bretryAfterSeconds\s*[:=]\s*(\d+)/i);
44
- if (m) return Number(m[1]);
45
- try {
46
- const parsed = JSON.parse(obj);
47
- return extractRetryAfterSec(parsed);
48
- } catch {}
49
- }
50
- if (typeof obj === "object") {
51
- if (Number.isFinite(obj.retryAfterSeconds)) return Number(obj.retryAfterSeconds);
52
- if (obj.message) {
53
- const r = extractRetryAfterSec(obj.message);
54
- if (r != null) return r;
55
- }
56
- }
57
- return null;
58
- }
59
-
60
- function holdableChunk(txt) {
61
- if (typeof txt !== "string" || !txt.includes("data:")) return null;
62
- let sawData = false;
63
- let sawEventError = false;
64
- let retrySec = null;
65
- const errs = [];
66
- for (const rawLine of txt.split("\n")) {
67
- const t = rawLine.trim();
68
- if (t.startsWith("event:") && t.slice(6).trim() === "error") {
69
- sawEventError = true;
70
- continue;
71
- }
72
- if (!t.startsWith("data:")) continue;
73
- const d = t.slice(5).trim();
74
- if (!d || d === "[DONE]") continue;
75
- let j = null;
76
- try { j = JSON.parse(d); } catch { return null; }
77
- if (!j || typeof j !== "object") return null;
78
- sawData = true;
79
- const c0 = (Array.isArray(j.choices) && j.choices[0]) || {};
80
- const delta = c0.delta || {};
81
- const msg = c0.message || {};
82
- const out = delta.content || msg.content || delta.tool_calls || msg.tool_calls || delta.reasoning || msg.reasoning;
83
- if (out && !(Array.isArray(out) && out.length === 0)) return null;
84
-
85
- const r = extractRetryAfterSec(j);
86
- if (r != null) {
87
- retrySec = r;
88
- continue;
89
- }
90
- if (j.error && typeof j.error === "object") {
91
- const m = j.error.message || j.error.code || "";
92
- if (m) errs.push(String(m).slice(0, 300));
93
- } else if (sawEventError && j.message) {
94
- errs.push(String(j.message).slice(0, 300));
95
- } else if (c0.finish_reason === "error") {
96
- errs.push("finish_reason=error 空帧");
97
- }
98
- }
99
- if (!sawData) return null;
100
- if (retrySec != null) return `上游供应商触发 retryAfterSeconds: ${retrySec} ,请等候重试`;
101
- if (errs.length) return errs.join(" | ");
102
- if (sawEventError) return "event: error 空帧";
103
- return null;
104
- }
105
-
106
35
  // 自持 reader 优先:for-await 会锁定 ReadableStream,使 body.cancel() 必 reject(真流上等于空操作),
107
36
  // 超时/断下游要真能掐上游必须走 reader.cancel()
108
37
  async function* bodyChunks(body, reader) {
@@ -156,23 +85,29 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
156
85
  const contentType = upRes.headers.get("content-type") || "";
157
86
  // 需同时满足:客户端要流 + 上游真的是 SSE;避免 muse-spark 聚合 JSON 被误判为流式,或 workbuddy SSE 被聚合
158
87
  const isStream = Boolean(body?.stream) && contentType.includes("text/event-stream");
159
- res.statusCode = upRes.status;
160
- // propagate workbuddy uid / allowlist headers
161
- try {
162
- const uid = upRes.headers.get("x-mslxdff-workbuddy-uid");
163
- if (uid) res.setHeader("x-mslxdff-workbuddy-uid", uid);
164
- const reason = upRes.headers.get("x-mslxdff-workbuddy-reason");
165
- if (reason) res.setHeader("x-mslxdff-workbuddy-reason", reason);
166
- const allow = upRes.headers.get("x-mslxdff-allowlist");
167
- if (allow) res.setHeader("x-mslxdff-allowlist", allow);
168
- const engine = upRes.headers.get("x-mslxdff-upstream-engine");
169
- if (engine) res.setHeader("x-mslxdff-upstream-engine", engine);
170
- } catch {}
171
- if (fallback) applyFallbackHeaders(res, fallback);
88
+ // 重入同一条连接(空轮留口后同模型重拉 / 换候选)时 headers 可能已 flush(前一发发过 keepalive 注释帧):
89
+ // 此时 statusCode 与自定义头都不可再设,否则 setHeader 抛 ERR_HTTP_HEADERS_SENT,重拉直接炸在半路
90
+ if (!res.headersSent) {
91
+ res.statusCode = upRes.status;
92
+ // propagate workbuddy uid / allowlist headers
93
+ try {
94
+ const uid = upRes.headers.get("x-mslxdff-workbuddy-uid");
95
+ if (uid) res.setHeader("x-mslxdff-workbuddy-uid", uid);
96
+ const reason = upRes.headers.get("x-mslxdff-workbuddy-reason");
97
+ if (reason) res.setHeader("x-mslxdff-workbuddy-reason", reason);
98
+ const allow = upRes.headers.get("x-mslxdff-allowlist");
99
+ if (allow) res.setHeader("x-mslxdff-allowlist", allow);
100
+ const engine = upRes.headers.get("x-mslxdff-upstream-engine");
101
+ if (engine) res.setHeader("x-mslxdff-upstream-engine", engine);
102
+ } catch {}
103
+ if (fallback) applyFallbackHeaders(res, fallback);
104
+ }
172
105
 
173
106
  let ttf = null;
174
107
  let interrupted = false;
175
108
  let finishedNormally = false;
109
+ let commitPendingPrefix = () => {};
110
+ let flushHeldTail = () => {}; // 把暂扣的 [DONE] 补写出去(错误帧必须能先站在它前面)
176
111
  const detail = {
177
112
  receivedChunks: 0,
178
113
  receivedBytes: 0,
@@ -192,9 +127,11 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
192
127
  reasoningChars: 0, // 思考内容字符数(与 chars 分列,相加会重复计数)
193
128
  toolCalls: 0,
194
129
  chatShaped: false,
130
+ talk: talkLogEnabled() ? createTalkBucket() : null, // 环形对话日志正文桶(关闭时为 null,零开销)
195
131
  heldErrorChunks: 0,
196
132
  upstreamErrorText: null,
197
133
  recoveries: 0,
134
+ wrotePayload: false, // 是否已向下游写出真实数据帧(注释帧不算):决定空转还能不能靠重试救
198
135
  };
199
136
  let prevChunkAt = t0;
200
137
  // 断下游即掐上游:流式分支装配真实取消,非流式保持 no-op
@@ -207,6 +144,8 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
207
144
  }
208
145
  };
209
146
  res.on("close", onClose);
147
+ // 入口即已断开/已收场:先落账,否则这一发会把留口当成「下游还活着」,重拉写给消失的读者
148
+ if (res.writableEnded || res.destroyed) detail.downstreamClosed = true;
210
149
 
211
150
  if (isStream) {
212
151
  // failover 重入时 headers 可能已发(前一个候选只发过 keepalive 注释帧就被掐)——已发则不可再设
@@ -227,6 +166,12 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
227
166
  let first = true;
228
167
  let wroteAny = false;
229
168
  let wrotePayload = false; // 真实数据帧(注释帧不算):决定能否安全 failover
169
+ const revocableHold = holdEndEnabled(); // HOLD_END=0 时连缓冲都不做(逐字节复现旧行为,含时机)
170
+ // 可撤销前缀缓冲(策略见 stream-hold.js):模型产出出现前,空 delta 帧与 [DONE] 先不入下游,
171
+ // 这样同模型重拉 / 换候选的正文还能顺着同一条连接送出去;上限兜底防异常形状囤内存。
172
+ const prefix = createRevocablePrefix(res, detail);
173
+ commitPendingPrefix = () => prefix.commit();
174
+ flushHeldTail = () => prefix.flushTail();
230
175
  let timedOut = false;
231
176
  let stalled = false;
232
177
  let tooLong = false;
@@ -292,7 +237,11 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
292
237
  if (!detail.upstreamErrorText) detail.upstreamErrorText = String(holdErr).slice(0, 500);
293
238
  }
294
239
  const isPayload = hasPayload(txt);
240
+ const prevChars = detail.chars, prevTools = detail.toolCalls, prevReason = detail.reasoningChars;
295
241
  scanSseChunk(detail, txt);
242
+ // 「模型产出」=正文/工具调用/思考三者本轮有新增。思考也算:已发出的思考撤不回,
243
+ // 从它出现的那刻起这次尝试就提交了(现网空轮多数正是「思考刷满、正文为零」)。
244
+ const gained = Number(detail.chars) > prevChars || Number(detail.toolCalls) > prevTools || Number(detail.reasoningChars) > prevReason;
296
245
  // 首块/空闲超时后上游仍吐出了真实数据 → 只是慢,不是死:撤销超时判定,照常转发
297
246
  //(cancel 是异步的,竞态窗口内已到达的数据是纯收益;丢掉是纯损失)
298
247
  // 注释帧(keepalive)不算:否则对端只要在发心跳,闸门就永远解除
@@ -324,11 +273,24 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
324
273
  } catch {}
325
274
  }
326
275
  if (!holdErr) {
327
- wroteAny = true;
328
- if (isPayload) wrotePayload = true;
329
- detail.wroteChunks += 1;
330
- detail.wroteBytes += Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
331
- try { res.write(outChunk); } catch { /* 下游已断开:onClose 已掐上游 */ }
276
+ const size = Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
277
+ if (!isPayload) {
278
+ // 注释帧等非数据帧:与改前一致直写(客户端视作噪声,不影响可撤销性)
279
+ wroteAny = true;
280
+ prefix.writeNow(outChunk, size);
281
+ } else if (gained || !revocableHold || !isTrivialFrame(txt)) {
282
+ // 有模型产出(正文/工具/思考)、留口已关、或看不懂的异形帧:按序补写暂扣前缀 + 本帧,
283
+ // 这条流就此提交不可撤销(透传契约要求解析失败的帧必须原样走,绝不为救空轮扣下)
284
+ wroteAny = true;
285
+ wrotePayload = true; detail.wrotePayload = true;
286
+ prefix.submit(outChunk, size);
287
+ } else if (!prefix.hold(outChunk, size, txt.includes("[DONE]"))) {
288
+ // 可撤销前缀:空 delta 暂扣(判为空轮时整段撤销,留给重拉的正文);
289
+ // [DONE] 无论是否已提交都进 tail 槽 —— 错误帧必须能排在它前面,否则客户端一见 [DONE] 就收尾
290
+ wroteAny = true;
291
+ wrotePayload = true; detail.wrotePayload = true;
292
+ prefix.submit(outChunk, size); // 暂扣超上限(异常形状)→ 被迫提交,退回旧行为
293
+ }
332
294
  }
333
295
  armStall();
334
296
  }
@@ -353,7 +315,7 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
353
315
  if ((stalled || tooLong) && wrotePayload) {
354
316
  interrupted = true;
355
317
  detail.exitReason = detail.exitReason || (stalled ? "stall" : "max");
356
- res.removeListener("close", onClose);
318
+ flushHeldTail(); // 断流收场也要把 [DONE] 按序补上,别让客户端等一个不存在的终止符
357
319
  try { res.end(); } catch { /* ignore */ }
358
320
  return { status: 200, timedOut: false, ttfMs: ttf, totalMs: Math.round(performance.now() - t0), aborted: false, interrupted, preflightMs: preflight, detail };
359
321
  }
@@ -363,9 +325,30 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
363
325
  const totalMs = Math.round(performance.now() - t0);
364
326
  if (!detail.exitReason) detail.exitReason = "normal";
365
327
  finishedNormally = true;
366
- res.removeListener("close", onClose);
367
- try { res.end(); } catch { /* ignore */ }
368
- return { status: 200, timedOut: false, ttfMs: ttf, totalMs, aborted: false, interrupted: false, preflightMs: preflight, detail };
328
+ // 留口期间不摘 close 监听(close 只发一次,摘了客户端窗口内断开就永久盲窗、照烧额度)
329
+ const heldOpen = holdEndEnabled() && detail.wrotePayload !== true && !detail.downstreamClosed && isEmptyTurnDetail(detail);
330
+ if (!heldOpen) res.removeListener("close", onClose);
331
+ let terminalForm = null;
332
+ if (heldOpen) {
333
+ detail.exitReason = "empty-turn-hold";
334
+ } else {
335
+ if (!detail.downstreamClosed) {
336
+ commitPendingPrefix(); // 不留口 = 补写暂扣前缀(HOLD_END=0 时逐字节复现改前行为)
337
+ // 思考刷满 max_tokens、正文为零(现网主流):思考撤不回,错误帧必须排在 [DONE] 之前才看得见
338
+ const reasoningOnly = Number(detail.chars) === 0 && Number(detail.toolCalls) === 0 && Number(detail.reasoningChars) > 0;
339
+ if (reasoningOnly && holdEndEnabled()) {
340
+ detail.exitReason = "reasoning-only";
341
+ terminalForm = "sse-error-tail";
342
+ endEmptyTurnStream(res, `EMPTY_MODEL_RESPONSE: 只产出思考 ${detail.reasoningChars} 字、正文为零(额度被思考吃满),已重试仍无正文 — raise max_tokens or rephrase`, () => flushHeldTail());
343
+ } else {
344
+ flushHeldTail(); // 没有错误帧要插队,[DONE] 按原序发出
345
+ try { res.end(); } catch { /* ignore */ }
346
+ }
347
+ } else {
348
+ try { res.end(); } catch { /* ignore */ }
349
+ }
350
+ }
351
+ return { status: 200, timedOut: false, ttfMs: ttf, totalMs, aborted: false, interrupted: false, heldOpen, terminalForm, preflightMs: preflight, detail };
369
352
  }
370
353
 
371
354
  finishedNormally = true;
@@ -373,21 +356,31 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
373
356
  const text = await upRes.text();
374
357
  detail.receivedBytes = Buffer.byteLength(text);
375
358
  detail.exitReason = "normal-non-stream";
376
- // 非流式 usage 与 chars 提取(口径与流式分支共用 metrics.js)
359
+ // 非流式同样「先判后写」:此刻 headers 还没 flush,body 一写下去就再无退路。
360
+ let enriched = null;
377
361
  try {
378
362
  const parsed = JSON.parse(text);
379
363
  scanNonStreamBody(detail, parsed);
380
- const enriched = enrichNonStreamJson(parsed, fallback);
364
+ enriched = enrichNonStreamJson(parsed, fallback);
365
+ } catch { /* 上游给的不是可解析 JSON:走下面的原文透传 */ }
366
+ if (enriched === null) {
367
+ // 纯文本时按长度估 chars;若文本其实是 SSE(client 未要流但上游给流)仍尝试提 usage
368
+ try { detail.chars = text.length; } catch {}
369
+ try { const u = extractUsageFromSseText(text); if (u) detail.usage = u; } catch {}
370
+ try { if (detail.talk) captureTalkFallback(detail.talk, text); } catch {}
371
+ } else if (holdEndEnabled() && !detail.downstreamClosed && isEmptyTurnDetail(detail)) {
372
+ detail.exitReason = "empty-turn-hold";
373
+ return { status: upRes.status, timedOut: false, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: false, interrupted: false, heldOpen: true, preflightMs: preflight, detail };
374
+ }
375
+ detail.wrotePayload = true; // 真写下去了:从此撤不回,也不再判空轮
376
+ const nsTotalMs = Math.round(performance.now() - t0);
377
+ if (enriched !== null) {
381
378
  json(res, upRes.status, enriched);
382
- } catch {
379
+ } else {
383
380
  res.statusCode = upRes.status;
384
381
  res.setHeader("Content-Type", contentType || "text/plain");
385
382
  res.end(text);
386
- // 纯文本时按长度估 chars;若文本其实是 SSE(client 未要流但上游给流)仍尝试提 usage
387
- try { detail.chars = text.length; } catch {}
388
- try { const u = extractUsageFromSseText(text); if (u) detail.usage = u; } catch {}
389
383
  }
390
384
  // 非流式 ttf 视为 total(一次性返回)
391
- const totalMs = Math.round(performance.now() - t0);
392
- return { status: upRes.status, timedOut: false, ttfMs: totalMs, totalMs, aborted: false, interrupted: false, preflightMs: preflight, detail };
385
+ return { status: upRes.status, timedOut: false, ttfMs: nsTotalMs, totalMs: nsTotalMs, aborted: false, interrupted: false, heldOpen: false, preflightMs: preflight, detail };
393
386
  }
@@ -0,0 +1,116 @@
1
+ // daemon 上一次死亡的验尸官 —— 死亡证明从来不能由死者开:Windows 的关机/TerminateProcess
2
+ // 不给被杀进程跑任何 JS 的机会,硬死在遗言层面是零痕迹的(见 crosscut 叶"四种死法")。
3
+ // 所以抓捕靠三方各出一块拼图:
4
+ // ① 杀者留牌:stopDaemon / autostart 清场等"我方所杀"在动手前写 daemon.exit-marker
5
+ // (带死者 pid/版本/意图)——反正 Windows 下被杀者说不出话,牌只能杀者挂;
6
+ // ② 活体信标:daemon 心跳同步写 daemon.alive,钉死"最后一次确证活着"的时刻(死亡窗口下界);
7
+ // ③ 开机验尸:新进程在 installLifecycleLog(早于 writePid 覆盖 pid 文件)读
8
+ // pid/alive/marker + os.uptime() 回推本机开机时刻,纯函数分桶,结论落 errors.log。
9
+ // 分类恒给 diedBetween(死亡窗口)与 detail(中文归因),unknown/reboot/kill 各归各桶,
10
+ // 宁可报"不可解释的强杀"也不假装干净。全部 IO 吞异常——验尸失败绝不挡启动。
11
+ import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
12
+ import { dirname, join } from "node:path";
13
+ import os from "node:os";
14
+
15
+ const SLACK_MS = 15_000; // 时钟/顺序抖动容差:牌的 at 不早于最后心跳−slack 才算"死于本牌"
16
+
17
+ export function aliveFile(dir) { return join(dir, "daemon.alive"); }
18
+ export function markerFile(dir) { return join(dir, "daemon.exit-marker"); }
19
+ export function pidPath(dir) { return join(dir, "daemon.pid"); }
20
+
21
+ function readJsonSafe(file) {
22
+ try { return JSON.parse(readFileSync(file, "utf8")); } catch { return null; }
23
+ }
24
+ function writeJsonSafe(file, obj) {
25
+ try {
26
+ mkdirSync(dirname(file), { recursive: true });
27
+ writeFileSync(file, JSON.stringify(obj), { mode: 0o600 });
28
+ return true;
29
+ } catch { return false; }
30
+ }
31
+
32
+ /** 活体信标:{pid, version, at, uptimeMs, rssMb}。daemon 模式专属写(debug 前台不碰,防污染死亡窗口)。 */
33
+ export function writeAlive(dir, info) { return writeJsonSafe(aliveFile(dir), { at: Date.now(), ...info }); }
34
+ export function readAlive(dir) { return readJsonSafe(aliveFile(dir)); }
35
+
36
+ /** 杀者牌:动手前写,必须自带死者身份(stopDaemon 随后会 unlink pid 文件)。 */
37
+ export function writeExitMarker(dir, { reason, prevPid, prevVersion = null, byPid = process.pid, code = null, at } = {}) {
38
+ return writeJsonSafe(markerFile(dir), { reason, prevPid, prevVersion, byPid, code, at: at ?? Date.now() });
39
+ }
40
+ /** 读后即删:一张牌只许生效一代,防止下代异常死亡被旧牌误导归因。 */
41
+ export function consumeExitMarker(dir) {
42
+ const m = readJsonSafe(markerFile(dir));
43
+ try { if (m) unlinkSync(markerFile(dir)); } catch {}
44
+ return m;
45
+ }
46
+
47
+ export function readPidFrom(dir) {
48
+ try {
49
+ const n = Number(String(readFileSync(pidPath(dir), "utf8")).trim().split("\n")[0]);
50
+ return Number.isInteger(n) && n > 0 ? n : null;
51
+ } catch { return null; }
52
+ }
53
+ export function readPidVersionFrom(dir) {
54
+ try {
55
+ const l = String(readFileSync(pidPath(dir), "utf8")).split("\n");
56
+ return l.length > 1 && l[1].trim() ? l[1].trim() : null;
57
+ } catch { return null; }
58
+ }
59
+
60
+ /** 开机时刻 = now − 整机 uptime。重启后它是硬事实,任何进程都伪造不了。 */
61
+ export function bootTimeMs(now = Date.now()) {
62
+ try { return now - Math.round(os.uptime() * 1000); } catch { return null; }
63
+ }
64
+
65
+ /**
66
+ * 纯函数分桶(可测,不碰 fs):
67
+ * none 无前任痕迹(首装 / uninstall 清干净后)
68
+ * clean-exit 死者自己跑完了 exit 钩子(Linux 信号优雅退出 / process.exit)
69
+ * killed-by-cli 新鲜杀者牌:via=stop|restart|upgrade|debug-takeover|uninstall|autostart-cleanup…
70
+ * reboot 无牌,但开机时刻晚于最后信标 → 整机重启带走
71
+ * holder-alive 旧 pid 仍活(抢端口/接管现场)
72
+ * unknown 有旧 pid 无信标(早于验尸功能的旧版本残留),死亡窗口给不出
73
+ * unexplained-kill 机器没重启、无牌、信标戛然而止 → taskkill/任务管理器/硬杀
74
+ */
75
+ export function classifyPrevExit({ prevPid = null, prevVersion = null, alive = null, marker = null, bootAtMs = null, now = Date.now(), selfPid = 0, prevStillRunning = false } = {}) {
76
+ const lastAlive = Number.isFinite(alive?.at) ? alive.at : null;
77
+ if (!prevPid && !alive && !marker) return { verdict: "none", detail: "无前任 daemon 痕迹" };
78
+ const freshMarker = marker && Number.isFinite(marker.at) && (lastAlive == null || marker.at >= lastAlive - SLACK_MS);
79
+ if (freshMarker && marker.reason === "process-exit") {
80
+ return { verdict: "clean-exit", prevPid: marker.prevPid ?? prevPid, prevVersion: marker.prevVersion ?? prevVersion, at: marker.at, diedBetween: [lastAlive, marker.at], detail: `前任进程自写遗书正常退出 (pid=${marker.prevPid ?? prevPid} exit code=${marker.code ?? "?"})` };
81
+ }
82
+ if (freshMarker) {
83
+ return { verdict: "killed-by-cli", via: marker.reason, prevPid: marker.prevPid ?? prevPid, prevVersion: marker.prevVersion ?? prevVersion, byPid: marker.byPid ?? null, at: marker.at, diedBetween: [lastAlive, marker.at], detail: `被 CLI/清理方 (pid=${marker.byPid ?? "?"}) 以 ${marker.reason} 名义主动杀死` };
84
+ }
85
+ if (lastAlive != null && bootAtMs != null && bootAtMs > lastAlive + SLACK_MS) {
86
+ return { verdict: "reboot", prevPid, prevVersion, lastAliveAt: lastAlive, bootAt: bootAtMs, diedBetween: [lastAlive, bootAtMs], detail: "死者零遗言,且本机开机时刻晚于最后心跳 → 整机重启带走(Windows 关机不跑 exit 钩子,属预期盲区,靠本桶收口)" };
87
+ }
88
+ if (prevPid && prevStillRunning && prevPid !== selfPid) {
89
+ return { verdict: "holder-alive", prevPid, prevVersion, detail: `旧 pid=${prevPid} 仍在世(抢端口/接管现场,本进程=${selfPid})` };
90
+ }
91
+ if (lastAlive == null) {
92
+ return { verdict: "unknown", prevPid, prevVersion, detail: "有旧 pid 无活体信标(前任早于验尸功能上线),只能确认已死" };
93
+ }
94
+ return { verdict: "unexplained-kill", prevPid, prevVersion, lastAliveAt: lastAlive, diedBetween: [lastAlive, now], detail: "机器未重启、无杀者牌、信标戛然而止:taskkill/任务管理器/硬杀或断电级崩溃(exit 钩子未跑)" };
95
+ }
96
+
97
+ function defaultIsPidAlive(pid) {
98
+ try { process.kill(pid, 0); return true; } catch (err) { return err.code !== "ESRCH"; }
99
+ }
100
+
101
+ /** 开机验尸入口:读齐三方证据 → 收牌(读后即删)→ 分桶。collect 与 report 一起回,供调用方落日志。 */
102
+ export function collectAutopsy({ dir, selfPid = process.pid, now = Date.now(), isPidAliveFn } = {}) {
103
+ const prevPid = readPidFrom(dir);
104
+ const alive = readAlive(dir);
105
+ const input = {
106
+ prevPid,
107
+ prevVersion: readPidVersionFrom(dir),
108
+ alive,
109
+ marker: consumeExitMarker(dir),
110
+ bootAtMs: bootTimeMs(now),
111
+ now,
112
+ selfPid,
113
+ prevStillRunning: !!prevPid && prevPid !== selfPid ? (isPidAliveFn ?? defaultIsPidAlive)(prevPid) : false,
114
+ };
115
+ return { input, report: classifyPrevExit(input) };
116
+ }