mslxdff 0.1.162 → 0.1.164

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 (37) hide show
  1. package/package.json +1 -1
  2. package/src/anthropic/translate.js +379 -0
  3. package/src/chat-pipeline/index.js +3 -2
  4. package/src/cli/commands/stats.js +21 -9
  5. package/src/cli/commands/sync.js +74 -2
  6. package/src/cli/help.js +2 -1
  7. package/src/providers/globalworkbuddy/account-store.js +198 -0
  8. package/src/providers/globalworkbuddy/auth.js +97 -0
  9. package/src/providers/globalworkbuddy/catalog.js +138 -0
  10. package/src/providers/globalworkbuddy/constants.js +73 -0
  11. package/src/providers/globalworkbuddy/device-auth.js +120 -0
  12. package/src/providers/globalworkbuddy/errors.js +98 -0
  13. package/src/providers/globalworkbuddy/headers.js +89 -0
  14. package/src/providers/globalworkbuddy/models.js +96 -0
  15. package/src/providers/globalworkbuddy/payload.js +80 -0
  16. package/src/providers/qoder/aggregate.js +12 -3
  17. package/src/providers/qoder/chat.js +9 -2
  18. package/src/providers/qoder/index.js +13 -3
  19. package/src/providers/qoder/models.js +7 -3
  20. package/src/providers/qoder/payload.js +7 -1
  21. package/src/providers/qoder/request.js +2 -1
  22. package/src/providers/qoder/sse.js +5 -1
  23. package/src/providers/qoder/stream.js +16 -4
  24. package/src/routes/chat/exhausted-handler.js +13 -2
  25. package/src/routes/chat/relay-pipeline.js +18 -2
  26. package/src/routes/index.js +13 -0
  27. package/src/routes/messages-route.js +290 -0
  28. package/src/routes/responses-route.js +2 -2
  29. package/src/routes/stream-scan.js +22 -5
  30. package/src/routes/stream.js +2 -3
  31. package/src/server.js +5 -0
  32. package/src/sync-claude.js +152 -0
  33. package/src/talk-full-redact.js +129 -0
  34. package/src/talk-full.js +130 -0
  35. package/src/talk-log.js +42 -15
  36. package/src/upstream-engine/sdk/responses.js +5 -0
  37. package/src/usage/report.js +14 -8
@@ -4,6 +4,7 @@ import { endHeldFailure } from "../stream-hold.js"; // 终局收场出口(502
4
4
  import { json } from "../helpers.js";
5
5
  import { performance } from "node:perf_hooks";
6
6
  import { recordRelayTalk } from "../../talk-log.js"; // 环形对话日志:exhausted 收尾直连 relay,落盘点必须自己补一份
7
+ import { recordAgentLoop } from "../../talk-full.js"; // agent 回路全量语料(talk/full):与 talk.log 并排各调一次,见 openspec add-agent-loop-capture D1
7
8
 
8
9
  // 最后一站的收场:relay 的「不写响应」路径(超时 / 空轮延后封口)都汇到这里,没有上层 failover 了,
9
10
  // 必须把响应「恰好一次」地关掉。形状由 endHeldFailure 按 headers 是否已 flush 决定
@@ -25,7 +26,13 @@ export async function handleExhaustedLocal({ res, body, lastErr, order, handlerC
25
26
  });
26
27
  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
28
  // 绕过 relay-pipeline 的最后一站:对话日志照常落盘(正文只进 talk/*.log,不进 events.log)
28
- try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", body, out }); } catch {}
29
+ // 本收尾点没有 attemptStartMs 可取(绕过 relay-pipeline 直连 relay)→ 不传 attemptMs,按回退路径走:
30
+ // elapsed=relay 内部计时(与 relayMs 同值,spec 降级 scenario);finishReason 传 out.detail.sawFinishReason 与 3.3 同源。
31
+ try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", body, out, finishReason: out.detail?.sawFinishReason }); } catch {}
32
+ // 回路语料另起一条独立 try:talk.log 是人读环形稿、capture 是机读全量语料,两者生死独立。
33
+ // hops 走 handlerCtx.hops(serial-trial 以 {...handlerCtx} 展开传进来,与 reqId 同源);缺值时不兜 0 ——
34
+ // 交给 talk-full 落 null(「hops 未知」在语料里看得见,比伪造成 0 诚实),组员流量拦截靠真值。
35
+ try { recordAgentLoop({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", hops: handlerCtx?.hops, body, out, sessionKey: handlerCtx?.sessionId, clientIp: handlerCtx?.clientIp }); } catch {} // attemptMs 缺省 → 回退 out.totalMs;缺 echo 的既有形状本期不补(tasks 3.4)
29
36
  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 });
30
37
  evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
31
38
  // 最后一站:relay 超时/空轮留口路径都不写响应,这里没有上层,必须自己收尾
@@ -55,7 +62,11 @@ export async function handleExhaustedAll({ res, body, lastErr, order, requested,
55
62
  });
56
63
  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
64
  // 同上:全链耗尽的最终转发也要留下问答原文
58
- try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", body, out }); } catch {}
65
+ // 同上:本收尾点没有 attemptStartMs 可取(relay 直连、无尝试起点)→ 不传 attemptMs,
66
+ // recordRelayTalk/recordAgentLoop 内部按回退路径走 elapsed=relay 计时(与 relayMs 同值,spec 降级 scenario);finishReason 同源传 out.detail.sawFinishReason。
67
+ try { recordRelayTalk({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", body, out, finishReason: out.detail?.sawFinishReason }); } catch {}
68
+ // 同上:全链耗尽的最终转发也要进语料(这条往往是「客户端只看到 502」时唯一的现场材料)
69
+ try { recordAgentLoop({ reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", hops: handlerCtx?.hops, body, out, sessionKey: handlerCtx?.sessionId, clientIp: handlerCtx?.clientIp }); } catch {} // attemptMs 缺省 → 回退 out.totalMs(见上行注释;缺 echo 的形状本期不补)
59
70
  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 });
60
71
  evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
61
72
  // 最后一站:relay 超时/空轮留口路径不写响应,这里没有上层 failover,必须自己收尾
@@ -6,7 +6,9 @@ import { recordChatUsage } from "../../usage/record.js"; // 窗口报表唯一
6
6
  import { recordOutput, computeOutputRow } from "../../providers/cline/usage.js"; // cline 专属旁路统计(账号×模型,流式也覆盖)
7
7
  import { upstreamEcho } from "../../model-trace.js"; // 回显头→日志字段(谁上的/哪个号/为什么/是否冷却)单一来源
8
8
  import { recordRelayTalk } from "../../talk-log.js"; // 环形对话日志(问答全文,最近 1 小时):五段流水在此汇合,落盘点只这一个
9
+ import { recordAgentLoop } from "../../talk-full.js"; // agent 回路全量语料(talk/full JSONL,缺省开):与 talk.log 并排各调一次,见 openspec default-on-agent-loop-capture D3
9
10
  import { isEmptyTurnDetail } from "../stream-scan.js"; // 空轮判据单一真相(stream.js 用它决定封不封口,这里用它决定交不交回重试)
11
+ import { performance } from "node:perf_hooks"; // attemptMs 相减必须与 attemptStartMs 的创建点同钟(performance.now 原钟),不得走 :61 的 _perfNow —— 那个位置容得下测试桩钟(P0 混钟回归)
10
12
 
11
13
  // 唯一/最后候选没有 failover 去向:首块闸门退化为纯"防连接泄漏",放宽避免误杀慢模型
12
14
  // (参考 opencode:zen 通道不设超时;openai responses 硬编码 300s headerTimeout)
@@ -53,7 +55,10 @@ export function createRelayPipeline({
53
55
  const _mark = mark || (() => {});
54
56
  const _logCall = logCall || (() => {});
55
57
  const _logError = logError || (() => {});
56
- const _perfNow = perfNow || (() => Date.now());
58
+ // 兜底即真实钟(P1-A):生产无任何调用方传 perfNow(只有测试传桩)→ 缺省必须与 perf0(chat-pipeline/index.js:21)、
59
+ // attemptStartMs 同钟。曾兜底 Date.now,:118 的 client-abort.totalMs = Date.now − performance.now ≈ 1.79e12 的假值;
60
+ // 注入 perfNow 仍可覆盖(测试桩钟)。防回归见 test/agent-loop-wiring.test.js 真钟三例(含 client-abort 那条)。
61
+ const _perfNow = perfNow || (() => performance.now());
57
62
 
58
63
  async function execute({
59
64
  res,
@@ -129,9 +134,20 @@ export function createRelayPipeline({
129
134
  detail: out.detail ?? null,
130
135
  });
131
136
 
137
+ // 本次上游尝试墙钟(design D3):attemptStartMs 的全部创建点都在 performance.now 钟上 ——
138
+ // serial-trial.js:51(viaRoute)、:97(tUp → hedge/localRelay)、:225(peerRelay)、:234(broadbandRelay)、auto-race.js:56(raceStart → localRelay);
139
+ // relay 内部 totalMs/preflight 同钟(stream.js:81 t0=performance.now)。相减必须用 performance.now 原钟,不得走 _perfNow:
140
+ // 生产 5 个 handler 构造本管线都不传 perfNow → 兜底一旦退回 Date.now,一相减就是 Date.now − performance.now ≈ epoch 天文数字
141
+ //(P0 回归实锤:落盘 elapsedMs=1791249258686;测试喂了同钟 perfNow 桩才把混钟掩盖住 —— 防回归见 test/agent-loop-wiring.test.js 真时钟两例)。
142
+ // attemptStartMs 非有限(调用方未给该 ctx,如管线直调)→ 回退 out.totalMs,此时 elapsed 与 relayMs 同值(spec 降级 scenario),不伪造。
143
+ const attemptMs = Number.isFinite(attemptStartMs) ? Math.round(performance.now() - attemptStartMs) : out.totalMs;
132
144
  // 环形对话日志:只记有真实输出的轮次(空轮交给下面的空转判定另行报错)。
133
145
  // 纯旁路:不改闸门、不改计时、不改返回体;任何异常都吞掉,绝不影响转发。
134
- try { recordRelayTalk({ reqId, model: actual, via, hops, body, out, echo: upstreamEcho(upRes) }); } catch {}
146
+ try { recordRelayTalk({ reqId, model: actual, via, hops, body, out, echo: upstreamEcho(upRes), attemptMs, finishReason: out.detail?.sawFinishReason }); } catch {}
147
+ // 回路语料(talk/full)另起一条独立 try,不与上面合并:talk.log 是人读环形稿、capture 是机读全量语料,
148
+ // 两者生死独立 —— 一边不落另一边照落,判据也不同(capture 只认 hops=0,且要带 sessionKey/clientIp 供分组与来源核对)。
149
+ // 纯旁路同上:不改闸门、不改计时、不改返回体;out.detail.talk 是原桶(logs.js 的 dropTalk 剥的是副本),这里不再剥。
150
+ try { recordAgentLoop({ reqId, model: actual, via, hops, body, out, sessionKey: handlerCtx?.sessionId, clientIp: handlerCtx?.clientIp, echo: upstreamEcho(upRes), attemptMs, relayMs: out.totalMs }); } catch {}
135
151
 
136
152
  // 5a0. 空转 200:流正常结束但零正文零工具调用 → 客户端会报 EMPTY_MODEL_RESPONSE
137
153
  // ("The model ended its turn without producing any output");转 failover 而不是
@@ -7,6 +7,7 @@ import { heartbeatHandler, pollHandler, resultHandler, forwardHandler, streamHan
7
7
  import { modelsHandler, modelsStatusHandler, providerModelsHandler, capabilitiesHandler } from "./models-route.js";
8
8
  import { relayHandler } from "./relay.js";
9
9
  import { responsesHandler } from "./responses-route.js";
10
+ import { messagesHandler, countTokensHandler } from "./messages-route.js";
10
11
 
11
12
  export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus, plugins }) {
12
13
  return async function router(req, res) {
@@ -50,6 +51,18 @@ const ROUTES = [
50
51
  requiresAuth: true,
51
52
  handler: responsesHandler,
52
53
  },
54
+ {
55
+ method: "POST",
56
+ path: "/v1/messages",
57
+ requiresAuth: true,
58
+ handler: messagesHandler,
59
+ },
60
+ {
61
+ method: "POST",
62
+ path: "/v1/messages/count_tokens",
63
+ requiresAuth: true,
64
+ handler: countTokensHandler,
65
+ },
53
66
  {
54
67
  method: "POST",
55
68
  path: "/v1/groups/join",
@@ -0,0 +1,290 @@
1
+ /**
2
+ * POST /v1/messages + /v1/messages/count_tokens — 给 Claude Code 用的 Anthropic Messages 外壳(ADR-0047)。
3
+ * 复用 ChatPipeline 全链路(auto/hedge/failover/tool_calls/空轮重试),只做形状翻译:
4
+ * 非流式:收集 chat JSON → 转 Anthropic message;流式:逐块实时翻成 Anthropic 具名事件。
5
+ *
6
+ * 出站格式与 /v1/responses **不兼容**,故不能复用 createLiveForwarder(它写死 `data:` + `[DONE]`):
7
+ * Anthropic 用 `event: <type>` 具名帧、无 `[DONE]`,且需网关自发 `ping` 扛过客户端 idle watchdog。
8
+ *
9
+ * 三条收口纪律(第 1 轮评审 P0-2/P0-3 立下的,别改回去):
10
+ * 1. 上游一有动静(含 pipeline 的 keepalive 注释帧)就发头 + `message_start` + 武装 ping —— 首块前的静默期正是客户端 watchdog 咬人的窗口;
11
+ * 2. `headersSent`/`getHeader` 必须真反映已发头,否则 `helpers.js:32` 的「已 flush 走 in-band 错误帧」守卫永远判假,
12
+ * 错误会被当成普通文本喂进 push() 后静默消失;
13
+ * 3. 没等到 `finish_reason`(也没有 `[DONE]`)就收线 = 截断,发 `event: error`,**不伪装成功收场**。
14
+ */
15
+ import { json, readBody } from "./helpers.js";
16
+ import { createChatPipeline } from "../chat-pipeline/index.js";
17
+ import { withBody, createCollector, createEmitter } from "./responses-route.js";
18
+ import {
19
+ messagesToChatBody,
20
+ chatJsonToAnthropic,
21
+ createAnthropicChunkTranslator,
22
+ estimateTokens,
23
+ anthropicError,
24
+ } from "../anthropic/translate.js";
25
+
26
+ const ADEBUG = process.env.MSLXDFF_ANTHROPIC_DEBUG === "1";
27
+ function alog(...a) {
28
+ if (ADEBUG) console.log("[messages]", ...a);
29
+ }
30
+
31
+ const THINKING = process.env.MSLXDFF_ANTHROPIC_THINKING === "1";
32
+ // 空闲 ping 周期(ms):`0` 关闭;客户端长思考期靠它扛过 streaming idle timeout
33
+ const PING_MS = (() => {
34
+ const raw = Number(process.env.MSLXDFF_ANTHROPIC_PING_MS);
35
+ return Number.isFinite(raw) && raw >= 0 ? raw : 15000;
36
+ })();
37
+
38
+ function frameOf(type, data) {
39
+ return `event: ${type}\ndata: ${JSON.stringify(data)}\n\n`;
40
+ }
41
+
42
+ // pipeline 在已 flush 的流里用 OpenAI 形状收口(`{error:{...}}` + `[DONE]`):
43
+ // 检出后改发 Anthropic 的 `error` 帧,别把错误伪装成正常收场(grill-decisions Q2)
44
+ function detectInBandError(text) {
45
+ let msg = null;
46
+ for (const line of String(text || "").split("\n")) {
47
+ const t = line.trim();
48
+ if (!t.startsWith("data:")) continue;
49
+ const payload = t.slice(5).trim();
50
+ if (!payload || payload === "[DONE]") continue;
51
+ try {
52
+ const j = JSON.parse(payload);
53
+ const e = j?.error;
54
+ if (e) msg = String(e?.message || e).slice(0, 500);
55
+ } catch { /* 非 JSON 帧忽略 */ }
56
+ }
57
+ return msg;
58
+ }
59
+
60
+
61
+ // pipeline 未 flush 时用 json() 直写聚合错误体(无 `data:` 前缀):认出来只取 message,
62
+ // 别把整坨 OpenAI JSON 当人话塞进 Anthropic error.message。
63
+ function jsonErrorText(text) {
64
+ const t = String(text || "").trim();
65
+ if (!t || t.startsWith(":") || t.includes("data:")) return null;
66
+ try {
67
+ const j = JSON.parse(t);
68
+ const e = j?.error;
69
+ if (!e) return null;
70
+ return String(e?.message || e).slice(0, 500);
71
+ } catch {
72
+ return null;
73
+ }
74
+ }
75
+
76
+ /** 两种上游收场形状(in-band `data:` 帧 / 聚合 JSON 体)统一取错误文案。 */
77
+ function errorText(text) {
78
+ return detectInBandError(text) || jsonErrorText(text);
79
+ }
80
+ // 客户端要流式而上游给了聚合 JSON(muse-spark / workbuddy 聚合 / zcode 非流式聚合都是现网常态):
81
+ // 那体没有 `data:` 前缀,会被 push() 当噪声整段丢掉 → 正文静默消失。认出来交给 fromChatJson 兜底。
82
+ function tryAggregate(text) {
83
+ const t = String(text || "").trim();
84
+ if (!t || t.includes("data:") || t.startsWith(":")) return null;
85
+ try {
86
+ const j = JSON.parse(t);
87
+ // 只认「非空 choices」:`{choices:[]}` 之类的空包什么也带不来,若当合法聚合包会跳过截断检测 → 零正文还谎报成功
88
+ return j && Array.isArray(j.choices) && j.choices.length > 0 ? j : null;
89
+ } catch {
90
+ return null;
91
+ }
92
+ }
93
+
94
+ /**
95
+ * Anthropic 出站垫片:具名事件 + 无 [DONE] + 空闲自发 ping + 真 headersSent。
96
+ * @param realRes 真 HTTP response
97
+ * @param translator createAnthropicChunkTranslator 实例
98
+ * @param opts { pingMs?: number } 测试注入口,缺省读 env
99
+ */
100
+ export function createAnthropicForwarder(realRes, translator, opts = {}) {
101
+ const pingMs = opts.pingMs ?? PING_MS;
102
+ let status = 200;
103
+ let headSent = false;
104
+ let ended = false;
105
+ let timer = null;
106
+ let pendingError = null;
107
+ let aggregate = null;
108
+ let rawAcc = ""; // 攒住无事件字节,供聚合回落识别
109
+ const sent = () => headSent || realRes.headersSent === true; // headersSent 与 getHeader 的唯一口径
110
+ // 上游按字节粒度喂 Buffer/Uint8Array:非流式解码会把多字节汉字切成 U+FFFD 并永久固化在行缓冲里
111
+ const decoder = new TextDecoder("utf-8");
112
+ const decode = (c, flush) => {
113
+ if (c == null) return flush ? String(decoder.decode()) : "";
114
+ if (typeof c === "string") return c;
115
+ const bytes = (typeof Buffer !== "undefined" && Buffer.isBuffer(c)) || c instanceof Uint8Array ? c : null;
116
+ if (bytes) return decoder.decode(bytes, { stream: !flush });
117
+ return String(c);
118
+ };
119
+ const dead = () => ended || realRes.writableEnded === true || realRes.destroyed === true;
120
+ const raw = (type, data) => { if (dead()) return; try { realRes.write(frameOf(type, data)); } catch { /* 下游已断 */ } };
121
+ const stopPing = () => { if (timer) { clearTimeout(timer); timer = null; } };
122
+ const armPing = () => {
123
+ if (!pingMs || dead()) return;
124
+ stopPing();
125
+ timer = setTimeout(() => { if (dead()) return; raw("ping", { type: "ping" }); armPing(); }, pingMs);
126
+ if (typeof timer.unref === "function") timer.unref();
127
+ };
128
+ const sendHead = () => {
129
+ if (headSent) return;
130
+ headSent = true;
131
+ try { realRes.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" }); } catch { /* 已发 */ }
132
+ for (const e of translator.begin()) raw(e.type, e);
133
+ armPing();
134
+ };
135
+ const finish = () => { if (ended) return; ended = true; stopPing(); try { realRes.end(); } catch { /* ignore */ } };
136
+ // 错误收场:一帧 error 后关连接,不补 message_delta/message_stop(真 Anthropic API 即此行为)
137
+ const closeError = (msg) => { sendHead(); raw("error", { type: "error", error: { type: "api_error", message: String(msg || "upstream error").slice(0, 500) } }); finish(); };
138
+
139
+ // 整包聚合体可能被分多次 write:攒住「没产出任何事件」的字节再判一次(有事件即清空,防陈旧拼接)
140
+ const RAW_ACC_CAP = 262144;
141
+ let rawOverflow = false;
142
+ const tryAccumulate = (text) => {
143
+ if (aggregate || !text || rawOverflow) return;
144
+ rawAcc += text;
145
+ if (rawAcc.length > RAW_ACC_CAP) {
146
+ // 超上限就停手并留标记:继续攒也拼不出完整 JSON,静默攒下去只会让错误文案说谎
147
+ rawAcc = rawAcc.slice(0, RAW_ACC_CAP);
148
+ rawOverflow = true;
149
+ }
150
+ const agg = tryAggregate(rawAcc);
151
+ if (agg) aggregate = agg;
152
+ };
153
+ const res = {
154
+ ...createEmitter(),
155
+ set statusCode(v) { status = v; },
156
+ get statusCode() { return status; },
157
+ // helpers.js 的 json() 靠 headersSent + getHeader("content-type") 判「能不能回头」;
158
+ // 两者必须同源说真话,否则会出现「判成已 flush、却又拿不到 event-stream」的全静默窗口(错误既不 in-band 也不 JSON)。
159
+ get headersSent() { return sent(); },
160
+ // json() 的幂等早退判据;补上它才不会在我们已收场后再被当「可写」的响应对待
161
+ get writableEnded() { return ended || realRes.writableEnded === true; },
162
+ setHeader() { /* Anthropic SSE 的头由 sendHead 统一发,逐键 set 无意义 */ },
163
+ getHeader(name) {
164
+ if (String(name).toLowerCase() === "content-type" && sent()) return "text/event-stream";
165
+ return undefined;
166
+ },
167
+ write(c) {
168
+ if (ended) { alog("late-write-ignored", JSON.stringify({ id: translator.id, bytes: String(c?.length ?? 0) })); return true; }
169
+ const text = decode(c);
170
+ const err = errorText(text);
171
+ if (err) { pendingError = err; return true; } // 留给 end() 统一收口,不在这里半截发
172
+ // 上游一有动静(连 pipeline 的 keepalive 注释帧都算)就落头 + message_start + 武装 ping:
173
+ // 首块前的静默期正是客户端 idle watchdog 咬人的窗口。没收到任何字节时错误仍走干净 JSON(见 end())。
174
+ sendHead();
175
+ const evs = translator.push(text);
176
+ for (const e of evs) raw(e.type, e);
177
+ if (evs.length) rawAcc = ""; else tryAccumulate(text);
178
+ armPing();
179
+ return true;
180
+ },
181
+ end(c) {
182
+ if (ended) return;
183
+ const tail = decode(c, true);
184
+ const err = pendingError || errorText(tail);
185
+ if (status >= 400 && !headSent) {
186
+ ended = true;
187
+ stopPing();
188
+ json(realRes, status, anthropicError("api_error", err || String(tail).slice(0, 500) || "upstream error"));
189
+ return;
190
+ }
191
+ if (err) { closeError(err); return; }
192
+ // 客户端要的是流:先落头 + message_start + 武装 ping,再处理残余
193
+ sendHead();
194
+ if (tail) {
195
+ const evs = translator.push(tail);
196
+ for (const e of evs) raw(e.type, e);
197
+ if (evs.length) rawAcc = ""; else tryAccumulate(tail);
198
+ }
199
+ // 末帧常常没有收尾换行:补一个 `\n` 把残行逼出来,否则合法正文与 finish_reason 会一起烂在缓冲里(被误判成截断)
200
+ for (const e of translator.push("\n")) raw(e.type, e);
201
+ // 上游整包聚合(无 SSE 帧):喂同一套状态机兜底,别让正文静默消失
202
+ if (aggregate && !translator.stats().blocks) { for (const e of translator.fromChatJson(aggregate)) raw(e.type, e); }
203
+ const fin = translator.getFinal();
204
+ if (!fin.finish && !aggregate) {
205
+ alog("truncated", JSON.stringify({ id: translator.id, ...translator.stats() }));
206
+ closeError(rawOverflow
207
+ ? "upstream sent an oversized non-SSE body that could not be aggregated (no finish_reason)"
208
+ : "upstream stream ended before the model finished its turn (no finish_reason)");
209
+ return;
210
+ }
211
+ for (const e of translator.end({ finish: fin.finish, usage: fin.usage })) raw(e.type, e);
212
+ finish();
213
+ },
214
+ };
215
+ // 客户端提前断开:pipeline 会感知 close,但 ping 定时器归本垫片管,必须自己停
216
+ try { realRes.on?.("close", () => { if (!ended) { ended = true; stopPing(); } }); } catch { /* ignore */ }
217
+ return res;
218
+ }
219
+
220
+ export async function messagesHandler(ctx) {
221
+ const { req, res } = ctx;
222
+ const t0 = Date.now();
223
+ let body;
224
+ try {
225
+ body = await readBody(req);
226
+ } catch {
227
+ return json(res, 400, anthropicError("invalid_request_error", "Invalid JSON body"));
228
+ }
229
+ let chatBody;
230
+ try {
231
+ chatBody = messagesToChatBody(body);
232
+ } catch (e) {
233
+ alog("translate-req-400", String(e?.message || e));
234
+ return json(res, 400, anthropicError("invalid_request_error", String(e?.message || e)));
235
+ }
236
+ alog("req", JSON.stringify({
237
+ model: chatBody.model, stream: chatBody.stream,
238
+ msgs: chatBody.messages.map((m) => `${m.role}:${(typeof m.content === "string" ? m.content : "[parts]").length}${m.tool_calls ? `+${m.tool_calls.length}tc` : ""}`),
239
+ tools: Array.isArray(chatBody.tools) ? chatBody.tools.length : 0,
240
+ }));
241
+ const pipeline = createChatPipeline(ctx);
242
+ const fakeReq = withBody(req, chatBody);
243
+ const forwardClose = (shim) => { try { req.on?.("close", () => shim.emit("close")); } catch { /* ignore */ } };
244
+ try {
245
+ if (chatBody.stream) {
246
+ const translator = createAnthropicChunkTranslator(chatBody.model, { thinking: THINKING });
247
+ const live = createAnthropicForwarder(res, translator);
248
+ forwardClose(live);
249
+ await pipeline.execute({ req: fakeReq, res: live });
250
+ alog("done-stream", JSON.stringify({ ms: Date.now() - t0, id: translator.id, ...translator.stats(), ...translator.getFinal() }));
251
+ } else {
252
+ const cap = createCollector();
253
+ forwardClose(cap.res);
254
+ await pipeline.execute({ req: fakeReq, res: cap.res });
255
+ const { status, text } = cap.get();
256
+ if (status >= 400) return json(res, status, anthropicError("api_error", errorText(text) || String(text).slice(0, 500)));
257
+ let chatJson = null;
258
+ try { chatJson = JSON.parse(text); } catch { /* 非 JSON */ }
259
+ if (!chatJson || chatJson.error || chatJson.object === "error") {
260
+ return json(res, status >= 400 ? status : 502, anthropicError("api_error", errorText(text) || String(text).slice(0, 500)));
261
+ }
262
+ // 上游偶发非 chat 形状(无 choices):包成单 text 块,绝不 500(照 responses-route.js 先例)
263
+ if (!Array.isArray(chatJson.choices)) {
264
+ const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model);
265
+ alog("done-nonchat", JSON.stringify({ ms: Date.now() - t0, bytes: text.length }));
266
+ return json(res, 200, r);
267
+ }
268
+ const out = chatJsonToAnthropic(chatJson, chatBody.model);
269
+ alog("done-json", JSON.stringify({ ms: Date.now() - t0, status, blocks: out.content.length, stop: out.stop_reason, usage: out.usage }));
270
+ return json(res, 200, out);
271
+ }
272
+ } catch (err) {
273
+ alog("execute-throw", String(err?.message || err).slice(0, 300));
274
+ if (!res.headersSent) return json(res, 502, anthropicError("api_error", String(err?.message || err)));
275
+ try { res.end(); } catch { /* ignore */ }
276
+ }
277
+ }
278
+
279
+ export async function countTokensHandler(ctx) {
280
+ const { req, res } = ctx;
281
+ let body;
282
+ try {
283
+ body = await readBody(req);
284
+ } catch {
285
+ return json(res, 400, anthropicError("invalid_request_error", "Invalid JSON body"));
286
+ }
287
+ const out = estimateTokens(body);
288
+ alog("count-tokens", JSON.stringify({ model: body?.model, input_tokens: out.input_tokens }));
289
+ return json(res, 200, out);
290
+ }
@@ -8,7 +8,7 @@ import { responsesToChatBody, chatJsonToResponse, createChunkTranslator, chunkTo
8
8
  * 非流式:收集 chat JSON → 转 Response 对象;流式:逐块实时翻成 responses SSE。
9
9
  */
10
10
 
11
- function withBody(req, body) {
11
+ export function withBody(req, body) {
12
12
  return Object.assign(Object.create(Object.getPrototypeOf(req)), req, { body });
13
13
  }
14
14
 
@@ -22,7 +22,7 @@ function errorShape(text, status) {
22
22
  }
23
23
 
24
24
  // 最小事件发射器:pipeline 靠 res.on("close") 感知下游断开,垫片必须有
25
- function createEmitter() {
25
+ export function createEmitter() {
26
26
  const map = new Map();
27
27
  const self = {
28
28
  on(ev, fn) { if (typeof fn === "function") { if (!map.has(ev)) map.set(ev, []); map.get(ev).push(fn); } return self; },
@@ -3,15 +3,19 @@
3
3
  // 纯函数契约:只读写传入的 detail,不碰 res / 定时器 / 闸门 / 网络,因此可离线单测。
4
4
  // 语义钉子:detail.chars 只算正文,思考内容另计(reasoningChars)——两者相加会重复计数。
5
5
  import { extractUsageFromJson } from "../metrics.js";
6
+ import { talkLogEnabled } from "../talk-log.js"; // 建桶判据之一(两模块都是按调用读 env,无 import 期冻结)
7
+ import { agentLoopEnabled, talkCapChars } from "../talk-full.js"; // 上限单一真相:本文件不得再写第二份数字
6
8
 
7
- // 环形对话日志(talk log)的正文捕获:只有 relay 建了 detail.talk 才累积,未开启时零开销。
9
+ // 响应正文捕获桶(talk log + agent 回路共用一只):只有 relay 建了 detail.talk 才累积,未开启时零开销。
8
10
  // 口径与 chars/reasoningChars 同源(读 delta,不读聚合帧),区别是这里存原文而不是只计数。
9
11
  // 同样的边界:SSE 帧被 chunk 切断时该帧内容丢失(JSON.parse 失败即跳过)—— 研究用途可接受。
10
- const TALK_CAP_CHARS = 400_000;
12
+ // 上限真相是 talkCapChars()(MSLXDFF_TALK_CAP_CHARS > full 开 200 万 > full 关 40 万);
13
+ // 下面的常数只是 createTalkBucket 未传 cap 时的历史缺省,必须与「full 关」档逐字相同(有测试锁死)。
14
+ const TALK_CAP_DEFAULT = 400_000;
11
15
 
12
16
  function talkPush(talk, dst, v) {
13
17
  if (typeof v !== "string" || !v) return;
14
- if (talk.n >= TALK_CAP_CHARS) { talk.capped = true; return; }
18
+ if (talk.n >= (talk.cap ?? TALK_CAP_DEFAULT)) { talk.capped = true; return; } // 撞顶只置位不静默:读侧靠它标 truncated
15
19
  talk.n += v.length;
16
20
  talk[dst].push(v);
17
21
  }
@@ -30,8 +34,21 @@ function talkMergeToolCalls(talk, tcs) {
30
34
  }
31
35
  }
32
36
 
33
- /** 新建累积桶(n/capped 防超长生成把内存吃穿)。 */
34
- export function createTalkBucket() { return { reasoning: [], content: [], tools: [], n: 0, capped: false }; }
37
+ /** 新建累积桶(n/capped 防超长生成把内存吃穿)。cap = 字符上限,未传/非法 → 400_000(现状逐字不变)。 */
38
+ export function createTalkBucket(cap) {
39
+ const c = Math.floor(Number(cap));
40
+ const use = Number.isFinite(c) && c > 0 ? c : TALK_CAP_DEFAULT;
41
+ return { reasoning: [], content: [], tools: [], n: 0, capped: false, cap: use };
42
+ }
43
+
44
+ /**
45
+ * 「该不该建桶 + 建多大」的唯一判据,收在这里是为了给 stream.js 让体积(20KB 硬门)。
46
+ * talk.log 与 agent 回路任一开启都必须建桶:只认 talkLogEnabled() 会让「talk.log 关 + full 开」
47
+ * 的响应正文全丢(detail.talk 为 null,capture 全程记到空气)。上限取 talkCapChars() 单一真相。
48
+ */
49
+ export function createTalkBucketIfEnabled() {
50
+ return talkLogEnabled() || agentLoopEnabled() ? createTalkBucket(talkCapChars()) : null;
51
+ }
35
52
 
36
53
  /** 逐 chunk 累积一轮对话的思考/正文/工具调用。talk 为空 = 未开启,直接返回。 */
37
54
  export function captureTalkSse(talk, txt) {
@@ -2,8 +2,7 @@ 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, createTalkBucket, captureTalkFallback, isEmptyTurnDetail, holdableChunk, extractRetryAfterSec, isTrivialFrame } from "./stream-scan.js"; // 逐帧/逐体观测累加器 + 锚点偏移 + 对话正文 + 空轮判据 + 错误包络暂扣 + 可撤销前缀判据(纯函数全在 stream-scan)
6
- import { talkLogEnabled } from "../talk-log.js"; // 环形对话日志开关(默认开)
5
+ import { scanSseChunk, scanNonStreamBody, preflightMs, createTalkBucketIfEnabled, captureTalkFallback, isEmptyTurnDetail, holdableChunk, extractRetryAfterSec, isTrivialFrame } from "./stream-scan.js"; // 逐帧/逐体观测累加器 + 锚点偏移 + 对话正文 + 空轮判据 + 错误包络暂扣 + 可撤销前缀判据(纯函数与建桶判据全在 stream-scan)
7
6
  import { holdEndEnabled, createRevocablePrefix, endEmptyTurnStream } from "./stream-hold.js"; // 空轮可撤销前缀 / 延后封口 / 终局收场(拆出去是为了不破 stream.js 20KB 硬门)
8
7
  // SDK 通道(TextEncoder)产出 Uint8Array,legacy 通道为 Buffer;
9
8
  // 统一转文本,避免 [DONE]/finish_reason/usage/chars 统计在 SDK 路径下静默失效。
@@ -127,7 +126,7 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
127
126
  reasoningChars: 0, // 思考内容字符数(与 chars 分列,相加会重复计数)
128
127
  toolCalls: 0,
129
128
  chatShaped: false,
130
- talk: talkLogEnabled() ? createTalkBucket() : null, // 环形对话日志正文桶(关闭时为 null,零开销)
129
+ talk: createTalkBucketIfEnabled(), // 正文桶:talk.log 或回路捕获任一开就建,上限单一真相 talkCapChars()
131
130
  heldErrorChunks: 0,
132
131
  upstreamErrorText: null,
133
132
  recoveries: 0,
package/src/server.js CHANGED
@@ -1,5 +1,6 @@
1
1
  import { createServer as httpCreateServer } from "node:http";
2
2
  import { DEFAULT_PORT, getPort } from "./state.js";
3
+ import { flushAgentLoop } from "./talk-full.js"; // 关停收尾:talk/full 捕获是异步队列落盘,退出前排空(空队列时近似 O(1),且自身不抛)
3
4
 
4
5
  export function startServer({ router, signals = true, host, onBeforeClose }, port = resolvePort()) {
5
6
  const listenHost = host ?? resolveHost();
@@ -19,6 +20,10 @@ export function startServer({ router, signals = true, host, onBeforeClose }, por
19
20
  });
20
21
 
21
22
  const close = async () => {
23
+ // 关停序列里唯一的新增步:先排空 agent 回路捕获(talk/full)的异步写队列,再走既有顺序
24
+ // (server:stop hook → server.close/closeAllConnections)。既有关停顺序语义一字未动;
25
+ // 队列空时 flush 即刻返回,且 flushAgentLoop 自身不抛(外层 try 只为兜住 import 侧意外)。
26
+ try { await flushAgentLoop(); } catch {}
22
27
  // 插件 hook:server:stop — 关闭前触发(fire-and-forget,不阻塞关停)
23
28
  try { await onBeforeClose?.(); } catch {}
24
29
  await new Promise((resolve) => {