mslxdff 0.1.162 → 0.1.163
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.
- package/package.json +1 -1
- package/src/chat-pipeline/index.js +3 -2
- package/src/cli/commands/stats.js +21 -9
- package/src/cli/help.js +1 -1
- package/src/providers/globalworkbuddy/account-store.js +198 -0
- package/src/providers/globalworkbuddy/auth.js +97 -0
- package/src/providers/globalworkbuddy/catalog.js +138 -0
- package/src/providers/globalworkbuddy/constants.js +73 -0
- package/src/providers/globalworkbuddy/device-auth.js +120 -0
- package/src/providers/globalworkbuddy/errors.js +98 -0
- package/src/providers/globalworkbuddy/headers.js +89 -0
- package/src/providers/globalworkbuddy/models.js +96 -0
- package/src/providers/globalworkbuddy/payload.js +80 -0
- package/src/providers/qoder/aggregate.js +12 -3
- package/src/providers/qoder/chat.js +9 -2
- package/src/providers/qoder/index.js +13 -3
- package/src/providers/qoder/models.js +7 -3
- package/src/providers/qoder/payload.js +7 -1
- package/src/providers/qoder/request.js +2 -1
- package/src/providers/qoder/sse.js +5 -1
- package/src/providers/qoder/stream.js +16 -4
- package/src/routes/chat/exhausted-handler.js +13 -2
- package/src/routes/chat/relay-pipeline.js +18 -2
- package/src/routes/stream-scan.js +22 -5
- package/src/routes/stream.js +2 -3
- package/src/server.js +5 -0
- package/src/talk-full-redact.js +129 -0
- package/src/talk-full.js +130 -0
- package/src/talk-log.js +42 -15
- package/src/upstream-engine/sdk/responses.js +5 -0
- package/src/usage/report.js +14 -8
|
@@ -5,7 +5,7 @@ import { buildCosyHeaders, pathSigFrom } from "./session.js";
|
|
|
5
5
|
import { cosyEncode } from "./encode.js";
|
|
6
6
|
import { buildQoderBody, mapModel } from "./payload.js";
|
|
7
7
|
|
|
8
|
-
export function buildUpstreamRequest({ sess, region, model, messages, tools, maxTokens }) {
|
|
8
|
+
export function buildUpstreamRequest({ sess, region, model, messages, tools, maxTokens, isReasoning }) {
|
|
9
9
|
const upstreamModel = mapModel(model);
|
|
10
10
|
const { body, mcSource } = buildQoderBody({
|
|
11
11
|
template: undefined,
|
|
@@ -14,6 +14,7 @@ export function buildUpstreamRequest({ sess, region, model, messages, tools, max
|
|
|
14
14
|
messages,
|
|
15
15
|
tools,
|
|
16
16
|
maxTokens,
|
|
17
|
+
isReasoning,
|
|
17
18
|
});
|
|
18
19
|
const ep = getEndpoints(normalizeRegion(region));
|
|
19
20
|
const url = ep.chatStreamURL;
|
|
@@ -40,7 +40,10 @@ export function extractDelta(dataLine) {
|
|
|
40
40
|
usageOut = Math.trunc(Number(j.usage.completion_tokens) || 0);
|
|
41
41
|
}
|
|
42
42
|
const choices = Array.isArray(j.choices) ? j.choices : [];
|
|
43
|
+
let finishReason = "";
|
|
43
44
|
for (const ch of choices) {
|
|
45
|
+
const fr = ch?.finish_reason;
|
|
46
|
+
if (typeof fr === "string" && fr) finishReason = fr;
|
|
44
47
|
const delta = ch?.delta;
|
|
45
48
|
if (!delta) continue;
|
|
46
49
|
const role = typeof delta.role === "string" ? delta.role : "";
|
|
@@ -48,7 +51,7 @@ export function extractDelta(dataLine) {
|
|
|
48
51
|
const reasoning = typeof delta.reasoning_content === "string" ? delta.reasoning_content : "";
|
|
49
52
|
const toolCalls = Array.isArray(delta.tool_calls) && delta.tool_calls.length ? delta.tool_calls : null;
|
|
50
53
|
if (role || content || reasoning || toolCalls) {
|
|
51
|
-
return { role, content, reasoning, toolCalls, usageIn, usageOut };
|
|
54
|
+
return { role, content, reasoning, toolCalls, usageIn, usageOut, ...(finishReason ? { finishReason } : {}) };
|
|
52
55
|
}
|
|
53
56
|
}
|
|
54
57
|
if (typeof j.code === "string" && j.code && j.code !== "0") {
|
|
@@ -58,6 +61,7 @@ export function extractDelta(dataLine) {
|
|
|
58
61
|
if (isQuotaError(j.code, msg)) return { err: { kind: "quota", status: 429, code: j.code, detail: msg || `code=${j.code}` } };
|
|
59
62
|
return { err: { kind: /inappropriate|DataInspection|Sensitive|ContentFilter/i.test(msg) ? "content_policy" : "business", code: j.code, detail: msg } };
|
|
60
63
|
}
|
|
64
|
+
if (finishReason) return { finishReason, usageIn, usageOut };
|
|
61
65
|
if (usageIn > 0 || usageOut > 0) return { usageIn, usageOut };
|
|
62
66
|
// 走到这里 = 帧既无 content/tool_calls、也无业务错、也无 usage。空轮排查的关键取证点:
|
|
63
67
|
// 把内层 JSON 的顶层键与 choices 原样打出来,一眼看出上游改了什么字段名。
|
|
@@ -3,6 +3,9 @@
|
|
|
3
3
|
// usage 只在尾帧出现:收到即记,附在 finish chunk 上一次发出(与旧回放语义一致)。
|
|
4
4
|
import { extractDelta } from "./sse.js";
|
|
5
5
|
|
|
6
|
+
// SSE 缓冲上限:未完结行超 2MiB 立即中断(内存保护,对齐外部参照实现 defaultMaxSseBufferChars)
|
|
7
|
+
const MAX_BUFFER_CHARS = 2 * 1024 * 1024;
|
|
8
|
+
|
|
6
9
|
// 空轮排障用的临时日志开关:QODER_DEBUG_STREAM=1 才输出,默认静默(问题定位后可摘)
|
|
7
10
|
const DBG_STREAM = () => process.env.QODER_DEBUG_STREAM === "1";
|
|
8
11
|
const sdbg = (...a) => { if (DBG_STREAM()) console.log("[qoder-stream]", ...a); };
|
|
@@ -30,7 +33,9 @@ export function reshapeQoderStream(upstreamRes, { model, chatId, prefetched = []
|
|
|
30
33
|
// 判决帧会在这里被正常解析并抛错,同时 chat.js 已用同一批帧定出状态码挂上门面。
|
|
31
34
|
let buf = prefetched.map((b) => dec.decode(b, { stream: true })).join("");
|
|
32
35
|
let usage = null;
|
|
33
|
-
|
|
36
|
+
// 收尾判定与 aggregate 同构:上游给过 finish_reason 一律优先,全程没给才兜底(tool_calls > stop)
|
|
37
|
+
let upstreamFinish = "";
|
|
38
|
+
let sawToolCalls = false;
|
|
34
39
|
let sawContent = false;
|
|
35
40
|
let finishSent = false;
|
|
36
41
|
const stream = new ReadableStream({
|
|
@@ -67,21 +72,28 @@ export function reshapeQoderStream(upstreamRes, { model, chatId, prefetched = []
|
|
|
67
72
|
usage = { prompt_tokens: d.usageIn, completion_tokens: d.usageOut, total_tokens: d.usageIn + d.usageOut };
|
|
68
73
|
sdbg(`[usage] ${JSON.stringify(usage)}`);
|
|
69
74
|
}
|
|
75
|
+
if (d.finishReason) upstreamFinish = d.finishReason;
|
|
70
76
|
const delta = {};
|
|
71
77
|
if (!sawContent) delta.role = "assistant";
|
|
72
78
|
if (d.content) { delta.content = d.content; contentLen += d.content.length; sawContent = true; }
|
|
73
79
|
if (d.reasoning) { delta.reasoning_content = d.reasoning; sawContent = true; }
|
|
74
|
-
if (d.toolCalls) { delta.tool_calls = d.toolCalls;
|
|
80
|
+
if (d.toolCalls) { delta.tool_calls = d.toolCalls; sawToolCalls = true; sawContent = true; }
|
|
75
81
|
if (Object.keys(delta).length) send(openaiChunk({ model, chatId, delta }));
|
|
76
|
-
sdbg(`[acc] line#=${lineIdx} sawContent=${sawContent} contentLen=${contentLen}
|
|
82
|
+
sdbg(`[acc] line#=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} upstreamFinish=${upstreamFinish} usage=${JSON.stringify(usage)}`);
|
|
83
|
+
}
|
|
84
|
+
// 完整行消费完毕后再判越限:leftover 超大不得把同 chunk 里的合法帧连坐丢弃(评审路1 P1#4)
|
|
85
|
+
if (buf.length > MAX_BUFFER_CHARS) {
|
|
86
|
+
sdbg(`[buffer-limit] leftover=${buf.length} chars → abort stream`);
|
|
87
|
+
throw { kind: "upstream", status: 502, detail: "qoder SSE buffer exceeded 2MiB limit" };
|
|
77
88
|
}
|
|
78
89
|
if (done) break;
|
|
79
90
|
}
|
|
80
|
-
sdbg(`[end] totalChunks=${chunkIdx} totalLines=${lineIdx} sawContent=${sawContent} contentLen=${contentLen}
|
|
91
|
+
sdbg(`[end] totalChunks=${chunkIdx} totalLines=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} upstreamFinish=${upstreamFinish} usage=${JSON.stringify(usage)}`);
|
|
81
92
|
if (!sawContent && !usage) {
|
|
82
93
|
sdbg(`[empty-stream] sawContent=false usage=null → throw 502 empty upstream stream`);
|
|
83
94
|
throw { kind: "upstream", status: 502, detail: "empty upstream stream" };
|
|
84
95
|
}
|
|
96
|
+
const finish = upstreamFinish || (sawToolCalls ? "tool_calls" : "stop");
|
|
85
97
|
send(openaiChunk({ model, chatId, delta: {}, finish, usage }));
|
|
86
98
|
send("data: [DONE]\n\n");
|
|
87
99
|
finishSent = true;
|
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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 而不是
|
|
@@ -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
|
-
//
|
|
9
|
+
// 响应正文捕获桶(talk log + agent 回路共用一只):只有 relay 建了 detail.talk 才累积,未开启时零开销。
|
|
8
10
|
// 口径与 chars/reasoningChars 同源(读 delta,不读聚合帧),区别是这里存原文而不是只计数。
|
|
9
11
|
// 同样的边界:SSE 帧被 chunk 切断时该帧内容丢失(JSON.parse 失败即跳过)—— 研究用途可接受。
|
|
10
|
-
|
|
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 >=
|
|
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() {
|
|
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) {
|
package/src/routes/stream.js
CHANGED
|
@@ -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,
|
|
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:
|
|
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) => {
|
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
// talk-full 的纯函数核(redact):写前处理链 + 会话标识归一,无 IO、无 env 读取(阈值由调用方传入),可独立单测。
|
|
2
|
+
// 处理链顺序冻结:结构摘要化 → 递归字段黑名单抹凭据 → JSON.stringify → 整串过 maskText 正则 → 单条超限降级。
|
|
3
|
+
import { createHash } from "node:crypto";
|
|
4
|
+
import { maskText } from "./talk-log.js";
|
|
5
|
+
|
|
6
|
+
const NO_CAP = Number.MAX_SAFE_INTEGER; // 只借 maskText 的正则,不套它的字节截断(截断会把 JSON 语法层切坏)
|
|
7
|
+
const REDACTED = "[已脱敏]";
|
|
8
|
+
// 凭据键名黑名单(键名归一化后比对):命中即整值抹掉,同层其它字段原样保留。
|
|
9
|
+
const DENY = new Set(["apikey", "accesstoken", "refreshtoken", "token", "secret", "password", "clientsecret", "cookie", "authorization", "xapikey"]);
|
|
10
|
+
// 字符串叶同款键值正则:覆盖 tool 结果 / tool_calls.arguments 这类「JSON 文本塞在字符串里」的凭据。
|
|
11
|
+
const LEAF_CRED = /"(apiKey|api_key|accessToken|refreshToken|token|secret|password|client_secret|cookie|authorization|x-api-key)"(\s*:\s*)"[^"]*"/gi;
|
|
12
|
+
const SKIP_PARAM = new Set(["messages", "tools", "functions", "model"]);
|
|
13
|
+
|
|
14
|
+
export const sha1 = (s) => createHash("sha1").update(String(s)).digest("hex");
|
|
15
|
+
const normKey = (k) => String(k).toLowerCase().replace(/[^a-z0-9]/g, "");
|
|
16
|
+
const clip = (v, n) => { const s = String(v ?? ""); return s.length > n ? `${s.slice(0, n)}…[已截断]` : s; };
|
|
17
|
+
// 循环引用 / BigInt 兜底:诊断材料宁可标「已循环」也不能抛出去影响请求。
|
|
18
|
+
export function stringifySafe(v) {
|
|
19
|
+
const seen = new WeakSet();
|
|
20
|
+
return JSON.stringify(v, (k, x) => {
|
|
21
|
+
if (typeof x === "bigint") return String(x);
|
|
22
|
+
if (x && typeof x === "object") { if (seen.has(x)) return "[已循环]"; seen.add(x); }
|
|
23
|
+
return x;
|
|
24
|
+
});
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
const imgTag = (p) => `[图片 ${String(p?.image_url?.url ?? p?.image_url ?? "").slice(0, 60)}]`;
|
|
28
|
+
/** 非文本部件只留形不留料(沿用 talk-log.js 的 60 字口径);全程造新对象,不改调用方的 body。 */
|
|
29
|
+
function summarizeParts(v, d = 0) {
|
|
30
|
+
if (d > 24) return v;
|
|
31
|
+
if (Array.isArray(v)) return v.map((x) => (x && typeof x === "object" && (x.image_url !== undefined || x.type === "image_url")) ? imgTag(x) : summarizeParts(x, d + 1));
|
|
32
|
+
if (v && typeof v === "object") { const o = {}; for (const [k, x] of Object.entries(v)) o[k] = summarizeParts(x, d + 1); return o; }
|
|
33
|
+
return v;
|
|
34
|
+
}
|
|
35
|
+
/** 递归字段黑名单:命中键名整值抹掉;字符串叶另走键值正则。 */
|
|
36
|
+
function redactDeep(v, d = 0) {
|
|
37
|
+
if (d > 24) return REDACTED;
|
|
38
|
+
if (Array.isArray(v)) return v.map((x) => redactDeep(x, d + 1));
|
|
39
|
+
if (v && typeof v === "object") { const o = {}; for (const [k, x] of Object.entries(v)) o[k] = DENY.has(normKey(k)) ? REDACTED : redactDeep(x, d + 1); return o; }
|
|
40
|
+
if (typeof v === "string") return v.replace(LEAF_CRED, '"$1"$2"[已脱敏]"');
|
|
41
|
+
return v;
|
|
42
|
+
}
|
|
43
|
+
/** 结构层安全的兜底:逐字符串叶过 maskText 正则(整串跑法偶尔会吃掉 JSON 闭引号)。 */
|
|
44
|
+
function maskLeaves(v) {
|
|
45
|
+
if (Array.isArray(v)) return v.map(maskLeaves);
|
|
46
|
+
if (v && typeof v === "object") { const o = {}; for (const [k, x] of Object.entries(v)) o[k] = maskLeaves(x); return o; }
|
|
47
|
+
return typeof v === "string" ? maskText(v, NO_CAP) : v;
|
|
48
|
+
}
|
|
49
|
+
/** 序列化 + 整串脱敏;结果不是合法 JSON 就退回逐叶脱敏 —— 落盘行必须可独立解析。 */
|
|
50
|
+
export function lineOf(rec) {
|
|
51
|
+
const whole = maskText(stringifySafe(rec), NO_CAP);
|
|
52
|
+
try { JSON.parse(whole); return whole; } catch { return stringifySafe(maskLeaves(rec)); }
|
|
53
|
+
}
|
|
54
|
+
/** 超长字符串叶(含超限标量 params,如 completions 的巨型 prompt):地板兜底,逐层截短。 */
|
|
55
|
+
function clipLongStrings(v, max = 200) {
|
|
56
|
+
if (Array.isArray(v)) return v.map((x) => clipLongStrings(x, max));
|
|
57
|
+
if (v && typeof v === "object") { const o = {}; for (const [k, x] of Object.entries(v)) o[k] = clipLongStrings(x, max); return o; }
|
|
58
|
+
return typeof v === "string" && v.length > max ? `${v.slice(0, max)}…[已截断]` : v;
|
|
59
|
+
}
|
|
60
|
+
/** 三级钳制:二级摘要自身也超限时(极端 message 条数)再削 —— 先丢 head 只留 role/chars/hash,再折半只留末尾 N 条。 */
|
|
61
|
+
function clampSummaries(rec, limitBytes, line) {
|
|
62
|
+
if (Buffer.byteLength(line, "utf8") <= limitBytes) return line;
|
|
63
|
+
const rows = (Array.isArray(rec.request.messages) ? rec.request.messages : []).map(({ head, ...rest }) => rest); // ① 逐条退化:只留 role + chars + hash(无 head)
|
|
64
|
+
rec.meta.summaryTrimmed = true; // 读侧:摘要被削过(② 末尾 N 条 + messagesOmitted 读数)
|
|
65
|
+
let n = rows.length;
|
|
66
|
+
for (let i = 0; i < 64; i++) { // 折半削减,上限 64 轮 = 有界(绝不死循环)
|
|
67
|
+
rec.request.messages = n > 0 ? rows.slice(-n) : [];
|
|
68
|
+
rec.meta.messagesOmitted = rows.length - rec.request.messages.length;
|
|
69
|
+
line = lineOf(rec);
|
|
70
|
+
if (Buffer.byteLength(line, "utf8") <= limitBytes) return line;
|
|
71
|
+
if (n === 0) break;
|
|
72
|
+
n = n === 1 ? 0 : Math.floor(n / 2);
|
|
73
|
+
}
|
|
74
|
+
return lineOf(Object.assign(rec, clipLongStrings(rec))); // ③ 地板兜底:messages 清空仍超限(超长标量 params)→ 长字符串叶截短
|
|
75
|
+
}
|
|
76
|
+
/** 超限降级的结构摘要:每条只留 role + 字符数 + sha1尾8 + 首500字。 */
|
|
77
|
+
function summarizeMessages(msgs) {
|
|
78
|
+
return (Array.isArray(msgs) ? msgs : []).map((m, i) => {
|
|
79
|
+
const t = typeof m?.content === "string" ? m.content : stringifySafe(m?.content ?? "");
|
|
80
|
+
return { i, role: String(m?.role || "?"), chars: t.length, hash: sha1(t).slice(-8), head: t.slice(0, 500) };
|
|
81
|
+
});
|
|
82
|
+
}
|
|
83
|
+
/** 单条超 limitBytes 时原地降级(记录不得丢),返回最终行。二级降级只给极端体量兜底。 */
|
|
84
|
+
export function composeLine(rec, limitBytes) {
|
|
85
|
+
let line = lineOf(rec);
|
|
86
|
+
if (Buffer.byteLength(line, "utf8") <= limitBytes) return line;
|
|
87
|
+
rec.request.messages = summarizeMessages(rec.request.messages);
|
|
88
|
+
rec.meta.truncated = true;
|
|
89
|
+
line = lineOf(rec);
|
|
90
|
+
if (Buffer.byteLength(line, "utf8") <= limitBytes) return line;
|
|
91
|
+
rec.request.tools = null;
|
|
92
|
+
rec.response = { reasoning: clip(rec.response.reasoning, 2000), content: clip(rec.response.content, 2000), toolCalls: [] };
|
|
93
|
+
return clampSummaries(rec, limitBytes, lineOf(rec)); // 二级之后仍超限 → 三级钳制,保证最终行 ≤ limitBytes
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
/** 采样参数:body 里除 messages/tools/functions/model 外的标量键逐个收(对象键不 dump,避免整身重复)。 */
|
|
97
|
+
export function scalarParams(body) {
|
|
98
|
+
const o = {};
|
|
99
|
+
for (const [k, v] of Object.entries(body && typeof body === "object" ? body : {})) {
|
|
100
|
+
if (SKIP_PARAM.has(k)) continue;
|
|
101
|
+
if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") o[k] = v;
|
|
102
|
+
}
|
|
103
|
+
return o;
|
|
104
|
+
}
|
|
105
|
+
/** request/response 两侧的落盘形状(已结构摘要化 + 黑名单脱敏)。 */
|
|
106
|
+
export function shapeForCapture({ body, model, msgs, reasoning, content, toolCalls }) {
|
|
107
|
+
return redactDeep(summarizeParts({
|
|
108
|
+
request: { model: body?.model ?? model ?? null, messages: msgs, tools: body?.tools ?? body?.functions ?? null, params: scalarParams(body) },
|
|
109
|
+
response: { reasoning, content, toolCalls },
|
|
110
|
+
}));
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
// 会话标识(Session hint):客户端头 > 首条 system+user 派生 > 进程级兜底;落盘一律归一化。
|
|
114
|
+
export const PROCESS_SESSION = `ses_${sha1(`${process.pid}:${Math.random()}`)}`;
|
|
115
|
+
/** 形态同 upstream.js:17 的兜底公式,自成一份(不 import 未合并的会话身份变更)。 */
|
|
116
|
+
function sessionFromMessages(msgs) {
|
|
117
|
+
const pick = (role) => {
|
|
118
|
+
const m = (msgs || []).find((x) => x?.role === role);
|
|
119
|
+
if (!m) return "";
|
|
120
|
+
return typeof m.content === "string" ? m.content : stringifySafe(m.content ?? "");
|
|
121
|
+
};
|
|
122
|
+
const seed = `${pick("system")}|${pick("user")}`.slice(0, 4000);
|
|
123
|
+
return seed === "|" ? null : `ses_${sha1(seed)}`;
|
|
124
|
+
}
|
|
125
|
+
/** 归一化短标识:sha1尾12 + "-" + 原值前 8 字(同一原值→同一标识,跨轮稳定、换模型不漂)。 */
|
|
126
|
+
export function normSessionKey(raw, msgs) {
|
|
127
|
+
const v = String(raw ?? "").trim() || sessionFromMessages(msgs) || PROCESS_SESSION;
|
|
128
|
+
return `${sha1(v).slice(-12)}-${v.slice(0, 8)}`;
|
|
129
|
+
}
|
package/src/talk-full.js
ADDED
|
@@ -0,0 +1,130 @@
|
|
|
1
|
+
// agent 回路全量捕获(talk/full lane):每轮 agent↔模型的完整请求/响应以 JSONL 只读语料落盘,供人调试 agent 与 skill。
|
|
2
|
+
// 与 talk-log.js 分工:那边「人读环形稿、只留最后一问」,这里「机读全量、一条自足」—— 缺省开(opt-out),只有显式关闭词 MSLXDFF_TALK_FULL=0/off/false/no/disable 才停写。
|
|
3
|
+
// 纯旁路:不改响应字节/状态码/闸门与空轮判据,异常一律吞掉返回 false;写盘走模块内单 promise 链串行 appendFile(design D11)。
|
|
4
|
+
// 处理链(写前,顺序冻结)在 ./talk-full-redact.js;执行时机在写队列任务内、不在请求收场路径(P1-C)。
|
|
5
|
+
import { chmodSync, mkdirSync } from "node:fs";
|
|
6
|
+
import { appendFile, rename, rm, stat } from "node:fs/promises";
|
|
7
|
+
import { dirname, join } from "node:path";
|
|
8
|
+
import { logDir } from "./logs.js";
|
|
9
|
+
import { talkLogName } from "./talk-log.js";
|
|
10
|
+
import { fmtShanghaiYMDHMS } from "./time.js";
|
|
11
|
+
import { composeLine, normSessionKey, shapeForCapture, stringifySafe } from "./talk-full-redact.js";
|
|
12
|
+
|
|
13
|
+
const MB = 1024 * 1024;
|
|
14
|
+
function envInt(name, dflt) { const n = Number(process.env[name]); return Number.isFinite(n) && n > 0 ? Math.floor(n) : dflt; }
|
|
15
|
+
const maxLineBytes = () => envInt("MSLXDFF_TALK_FULL_MAX_LINE_MB", 16) * MB; // 单条超限降级阈值
|
|
16
|
+
const maxFileBytes = () => envInt("MSLXDFF_TALK_FULL_MAX_MB", 50) * MB; // 单文件轮转阈值(按字节不按时间)
|
|
17
|
+
const keepCount = () => { const n = Number(process.env.MSLXDFF_TALK_FULL_KEEP); return Number.isInteger(n) && n >= 0 ? n : 3; };
|
|
18
|
+
|
|
19
|
+
/** 缺省开(opt-out,ADR-0046):只有显式关闭词 0/off/false/no/disable(trim+lowercase)才关;未设、1、true、on、yes 与任意其它值一律开 —— 写错的值不得静默变关。 */
|
|
20
|
+
export function agentLoopEnabled() {
|
|
21
|
+
const v = String(process.env.MSLXDFF_TALK_FULL ?? "").trim().toLowerCase();
|
|
22
|
+
return !(v === "0" || v === "off" || v === "false" || v === "no" || v === "disable");
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/** 响应正文桶上限的单一真相:MSLXDFF_TALK_CAP_CHARS 正数覆盖 > 缺省开 200 万 > 显式关 40 万(两档数字逐字不变,档位随 agentLoopEnabled 连动,避免两处真相)。 */
|
|
26
|
+
export function talkCapChars() {
|
|
27
|
+
const n = Number(process.env.MSLXDFF_TALK_CAP_CHARS);
|
|
28
|
+
if (Number.isFinite(n) && n > 0) return Math.floor(n);
|
|
29
|
+
return agentLoopEnabled() ? 2_000_000 : 400_000;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
export function agentLoopDir() { return join(logDir(), "talk", "full"); }
|
|
33
|
+
/** 与 talk.log 命名同源:<dir>/<供应商>-<模型>-talkfull.jsonl(talkLogName 的 -talk.log 换成 -talkfull.jsonl)。 */
|
|
34
|
+
export function agentLoopFile(model) { return join(agentLoopDir(), `${talkLogName(model).replace(/(?:-talk)?\.log$/, "")}-talkfull.jsonl`); }
|
|
35
|
+
|
|
36
|
+
// ── 落盘:模块内单队列(写与轮转同队、不抢跑)+ 按字节 rename 轮转 ──────────
|
|
37
|
+
let queue = Promise.resolve();
|
|
38
|
+
const readyDirs = new Set();
|
|
39
|
+
const chmodded = new Set();
|
|
40
|
+
function enqueue(task) { queue = queue.then(task).catch(() => {}); return queue; }
|
|
41
|
+
async function rotate(file, keep) {
|
|
42
|
+
await rm(`${file}.${keep}`, { force: true }).catch(() => {});
|
|
43
|
+
for (let i = keep - 1; i >= 1; i--) await rename(`${file}.${i}`, `${file}.${i + 1}`).catch(() => {});
|
|
44
|
+
await rename(file, `${file}.1`).catch(() => {});
|
|
45
|
+
}
|
|
46
|
+
/** 单次写尝试:仅缓存未命中才 mkdir;appendFile 失败返回 false(不抛),由 queueWrite 决定是否重试一次。 */
|
|
47
|
+
async function writeOnce(file, line) {
|
|
48
|
+
const dir = dirname(file);
|
|
49
|
+
if (!readyDirs.has(dir)) { try { mkdirSync(dir, { recursive: true }); readyDirs.add(dir); } catch { return false; } } // 目录只在受理后出现
|
|
50
|
+
const st = await stat(file).catch(() => null);
|
|
51
|
+
if (st && st.size > maxFileBytes()) {
|
|
52
|
+
const keep = keepCount();
|
|
53
|
+
if (keep < 1) await rm(file, { force: true }).catch(() => {});
|
|
54
|
+
else await rotate(file, keep);
|
|
55
|
+
}
|
|
56
|
+
try { await appendFile(file, `${line}\n`, { mode: 0o600 }); } catch { return false; }
|
|
57
|
+
if (!chmodded.has(file)) { chmodded.add(file); try { chmodSync(file, 0o600); } catch {} } // mode 只在新建生效,存量补一次
|
|
58
|
+
return true;
|
|
59
|
+
}
|
|
60
|
+
// 读数口径单一真相(design D3):本次尝试墙钟优先;起点不可得时回退 relay 内部 totalMs(此时 elapsedMs 与 relayMs 同值,不伪造)。
|
|
61
|
+
function elapsedOf(attempt, total) {
|
|
62
|
+
const a = Number(attempt);
|
|
63
|
+
if (Number.isFinite(a)) return a;
|
|
64
|
+
const t = Number(total);
|
|
65
|
+
return Number.isFinite(t) ? t : null;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
// 失败分支重试一次(正常路径零额外成本):readyDirs 缓存过期(用户手工 rm -r / 移走 talk/full)时
|
|
69
|
+
// 先清掉目录缓存重走 mkdir + chmod,仍失败才彻底放弃(继续吞,契约:捕获失败绝不打扰请求)。
|
|
70
|
+
// 重活全在已排队的异步任务里做(P1-C):整 body 序列化算 requestBytes + composeLine(递归黑名单串化 → 整串 6 条正则
|
|
71
|
+
// → 整记录 JSON.parse 回验 → 超限时最多 64 趟三级钳制重序列化)。留在同步段等于每条请求收场都付这份 CPU
|
|
72
|
+
// (4MB body 实测 ~21ms、16MB 级可到百毫秒事件循环停顿),与 design「纯旁路不占请求路径」相抵。
|
|
73
|
+
// 落盘逐字不变的前提:① rec 里派生自 body 的结构(request/response)已由 shapeForCapture 在同步段深拷定稿,
|
|
74
|
+
// 队列任务只读 body 算长度、不再读它的结构(recordAgentLoop 之后无任何生产调用方改写 body:空转抬额走的
|
|
75
|
+
// withRaisedMaxTokens 也是产新对象);② 键序按字面量插入序冻结 → requestBytes 先占位再回填,事后补键会被
|
|
76
|
+
// JSON.stringify 排到 meta 末尾;③ 队列内异常照旧由 enqueue 的 .catch(() => {}) 吞掉(受理即返回 true,与写盘失败同语义);
|
|
77
|
+
// ④ limitBytes 与 agentLoopFile 仍在受理时刻算:env 阈值若挪到队列里读,测试/关停路径的 env 还原会把降级档位读错。
|
|
78
|
+
function queueWrite(file, rec, body, limitBytes) {
|
|
79
|
+
return enqueue(async () => {
|
|
80
|
+
rec.meta.requestBytes = Buffer.byteLength(stringifySafe(body ?? {}), "utf8");
|
|
81
|
+
const line = composeLine(rec, limitBytes);
|
|
82
|
+
if (await writeOnce(file, line)) return;
|
|
83
|
+
readyDirs.delete(dirname(file)); chmodded.delete(file);
|
|
84
|
+
await writeOnce(file, line);
|
|
85
|
+
});
|
|
86
|
+
}
|
|
87
|
+
/** 排空写队列:测试断言前与进程退出前调用。 */
|
|
88
|
+
export async function flushAgentLoop() {
|
|
89
|
+
for (let i = 0; i < 1000; i++) { const q = queue; await q; if (q === queue) return; }
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
/**
|
|
93
|
+
* 一条上游尝试 = 一行自包含 JSONL。判据顺序即契约:
|
|
94
|
+
* ① 开关 ② hops>0(组员转发的对话不落盘,spec「只捕获本机自发流量」)③ 两侧全空且 status≠200 ④ 受理。
|
|
95
|
+
* 任何异常吞掉返回 false,MUST NOT 抛出影响请求。
|
|
96
|
+
*/
|
|
97
|
+
export function recordAgentLoop({ reqId, model, via, hops, body, out, sessionKey, clientIp, echo, attemptMs, relayMs } = {}) {
|
|
98
|
+
if (!agentLoopEnabled()) return false;
|
|
99
|
+
try {
|
|
100
|
+
if (Number(hops) > 0) return false;
|
|
101
|
+
const talk = out?.detail?.talk || {};
|
|
102
|
+
const msgs = Array.isArray(body?.messages) ? body.messages : [];
|
|
103
|
+
const reasoning = (talk.reasoning || []).join("");
|
|
104
|
+
const content = (talk.content || []).join("");
|
|
105
|
+
const toolCalls = Array.isArray(talk.tools) ? talk.tools : [];
|
|
106
|
+
const status = out?.status == null || !Number.isFinite(Number(out.status)) ? null : Number(out.status);
|
|
107
|
+
if (!msgs.length && !reasoning && !content && !toolCalls.length && status !== 200) return false;
|
|
108
|
+
const at = Date.now();
|
|
109
|
+
const rec = {
|
|
110
|
+
ts: at, time: fmtShanghaiYMDHMS(new Date(at)),
|
|
111
|
+
reqId: reqId ?? null, sessionKey: normSessionKey(sessionKey, msgs), clientIp: clientIp ?? null,
|
|
112
|
+
model: String(model || "unknown"), via: via ?? null,
|
|
113
|
+
hops: hops == null || hops === "" || !Number.isFinite(Number(hops)) ? null : Number(hops),
|
|
114
|
+
status, stream: body?.stream ? 1 : 0, elapsedMs: elapsedOf(attemptMs, out?.totalMs),
|
|
115
|
+
usage: out?.detail?.usage ?? null, finishReason: out?.detail?.sawFinishReason ?? null,
|
|
116
|
+
upstream: echo?.upstream ?? null, account: echo?.account ?? null, pick: echo?.pick ?? null,
|
|
117
|
+
...shapeForCapture({ body, model, msgs, reasoning, content, toolCalls }),
|
|
118
|
+
meta: {
|
|
119
|
+
requestBytes: 0, // 占位只冻键序(P1-C):真值在 queueWrite 的队列任务里按整 body 序列化回填
|
|
120
|
+
responseChars: Number.isFinite(Number(talk.n)) ? Number(talk.n) : content.length, // 桶的 n 显式写进读数
|
|
121
|
+
reasoningChars: reasoning.length, // 思考与正文分列,不互相吞并
|
|
122
|
+
truncated: Boolean(talk.capped), // 撞顶必须看得见
|
|
123
|
+
cap: talkCapChars(),
|
|
124
|
+
relayMs: elapsedOf(relayMs, out?.totalMs), // relay 内部计时恒写:与 elapsedMs(尝试墙钟)分列,「上游多久 vs 写给客户端多久」可各自判读
|
|
125
|
+
},
|
|
126
|
+
};
|
|
127
|
+
queueWrite(agentLoopFile(rec.model), rec, body, maxLineBytes()); // 阈值与目标文件在受理时刻定档,序列化/降级/回验全在队列内
|
|
128
|
+
return true;
|
|
129
|
+
} catch { return false; }
|
|
130
|
+
}
|