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.
- package/package.json +1 -1
- package/src/anthropic/translate.js +379 -0
- package/src/chat-pipeline/index.js +3 -2
- package/src/cli/commands/stats.js +21 -9
- package/src/cli/commands/sync.js +74 -2
- package/src/cli/help.js +2 -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/index.js +13 -0
- package/src/routes/messages-route.js +290 -0
- package/src/routes/responses-route.js +2 -2
- package/src/routes/stream-scan.js +22 -5
- package/src/routes/stream.js +2 -3
- package/src/server.js +5 -0
- package/src/sync-claude.js +152 -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
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
import { readFileSync, writeFileSync, mkdirSync, renameSync, existsSync, unlinkSync, copyFileSync, chmodSync } from "node:fs";
|
|
2
|
+
import { dirname, join } from "node:path";
|
|
3
|
+
import os from "node:os";
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* -setto claude:把本机网关写进 Claude Code 的用户设置文件。
|
|
7
|
+
* 键面依据 code.claude.com/docs/en/settings-reference(model / modelPicker / env 三节):
|
|
8
|
+
* - `ANTHROPIC_BASE_URL` **不带 /v1** —— 客户端自己拼 `/v1/messages`(参考仓库 README 写 /v1 是它的错)
|
|
9
|
+
* - `env.ANTHROPIC_MODEL` 必须删 —— 它压过顶层 `model` 键,留着会让设置失效
|
|
10
|
+
* - `CLAUDE_CODE_ATTRIBUTION_HEADER=0` —— 我们把 system 折叠成单条,归因块必须在客户端就不发
|
|
11
|
+
* - `modelPicker.options[].behavesAs` 实测必需 —— 见下方 DEFAULT_BEHAVES_AS 注释
|
|
12
|
+
* 只动上述键,其余键与键序原样保留;解析失败一律拒写(那是用户手写的 hooks/permissions)。
|
|
13
|
+
*/
|
|
14
|
+
|
|
15
|
+
const OUR_ENV_KEYS = [
|
|
16
|
+
"ANTHROPIC_BASE_URL",
|
|
17
|
+
"ANTHROPIC_AUTH_TOKEN",
|
|
18
|
+
"ANTHROPIC_MODEL", // 只删不写
|
|
19
|
+
"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
|
|
20
|
+
"CLAUDE_CODE_ATTRIBUTION_HEADER",
|
|
21
|
+
"CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
|
|
22
|
+
];
|
|
23
|
+
|
|
24
|
+
// 本机 Claude Code 对「不认识且无 behavesAs 映射」的 model id 直接拒跑,连请求都不发
|
|
25
|
+
// (实测 2026-10-09:`"big-pickle" isn't described by this version's model catalog; …map it with
|
|
26
|
+
// behavesAs on a modelPicker row`,加 behavesAs 后 `claude -p` 正常走通工具往返)。
|
|
27
|
+
// behavesAs 只改客户端的**本地能力推断**(effort / auto-compact 口径),不改变发给上游的模型;
|
|
28
|
+
// 上游不认的字段由 messagesToChatBody 统一丢,所以锚一个通用已知 id 即可。`--behaves-as ""` 可关。
|
|
29
|
+
const DEFAULT_BEHAVES_AS = "claude-sonnet-5";
|
|
30
|
+
|
|
31
|
+
/** Claude Code 用户设置文件路径(`CLAUDE_CONFIG_DIR` 优先,与 Claude Code 自身口径一致)。 */
|
|
32
|
+
export function claudeSettingsPath() {
|
|
33
|
+
const dir = process.env.CLAUDE_CONFIG_DIR;
|
|
34
|
+
if (typeof dir === "string" && dir.trim()) return join(dir.trim(), "settings.json");
|
|
35
|
+
return join(os.homedir(), ".claude", "settings.json");
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
/** 纯函数:existing 对象 + 上下文 → 新对象。除我们的键外一律原样保留(含键序,JSON 键序随插入顺序)。 */
|
|
39
|
+
export function buildClaudeSettings(existing, ctx = {}) {
|
|
40
|
+
const out = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
|
|
41
|
+
const env = { ...(out.env && typeof out.env === "object" && !Array.isArray(out.env) ? out.env : {}) };
|
|
42
|
+
env.ANTHROPIC_BASE_URL = String(ctx.baseUrl || "");
|
|
43
|
+
env.ANTHROPIC_AUTH_TOKEN = String(ctx.token || "");
|
|
44
|
+
env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
|
|
45
|
+
env.CLAUDE_CODE_ATTRIBUTION_HEADER = "0";
|
|
46
|
+
env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS = "1";
|
|
47
|
+
delete env.ANTHROPIC_MODEL;
|
|
48
|
+
out.env = env;
|
|
49
|
+
out.model = String(ctx.model || "");
|
|
50
|
+
const picks = Array.isArray(ctx.picks) && ctx.picks.length ? ctx.picks : [ctx.model];
|
|
51
|
+
// behavesAs 的含义是「该 id 不在客户端模型目录里,请按 X 的能力口径推断」。
|
|
52
|
+
// 客户端本来就认识的 claude-* id 不该被这么标:把 claude-opus 标成 behavesAs=claude-sonnet-5,
|
|
53
|
+
// 客户端就会按 sonnet 的 effort / auto-compact 口径去推断它。显式 --behaves-as 仍覆盖一切。
|
|
54
|
+
const override = ctx.behavesAs == null ? null : String(ctx.behavesAs);
|
|
55
|
+
const anchorOf = (m) => (override != null ? override : /^claude[-.]/i.test(String(m)) ? "" : DEFAULT_BEHAVES_AS);
|
|
56
|
+
out.modelPicker = {
|
|
57
|
+
options: picks.filter(Boolean).map((m) => {
|
|
58
|
+
const row = { model: String(m), label: String(m) };
|
|
59
|
+
const anchor = anchorOf(m);
|
|
60
|
+
if (anchor) row.behavesAs = anchor;
|
|
61
|
+
return row;
|
|
62
|
+
}),
|
|
63
|
+
};
|
|
64
|
+
return out;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
// 归一化用于幂等比较(忽略换行符与首尾空白差异)
|
|
68
|
+
function norm(text) {
|
|
69
|
+
return String(text || "").replace(/\r\n/g, "\n").trim();
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/**
|
|
73
|
+
* 写盘。返回 { action, file, id, backup, changed, rows }。
|
|
74
|
+
* @param {{id?:string, token?:string, port?:number, picks?:string[], file?:string, baseUrl?:string, behavesAs?:string}} p
|
|
75
|
+
*/
|
|
76
|
+
export function syncToClaude(p = {}) {
|
|
77
|
+
const targetFile = p.file || claudeSettingsPath();
|
|
78
|
+
const model = String(p.id ?? p.model ?? "").trim();
|
|
79
|
+
if (!model) throw new Error("claude settings: model id required");
|
|
80
|
+
const token = String(p.token || "");
|
|
81
|
+
if (!token) throw new Error("claude settings: token required(先跑 mslxdff -showtoken)");
|
|
82
|
+
const baseUrl = p.baseUrl || `http://127.0.0.1:${Number(p.port) || 8989}`;
|
|
83
|
+
const picks = Array.isArray(p.picks) && p.picks.length ? p.picks : [model];
|
|
84
|
+
|
|
85
|
+
let existed = false;
|
|
86
|
+
let originalText = "";
|
|
87
|
+
try {
|
|
88
|
+
originalText = readFileSync(targetFile, "utf8");
|
|
89
|
+
existed = true;
|
|
90
|
+
} catch {
|
|
91
|
+
existed = false;
|
|
92
|
+
}
|
|
93
|
+
let originalObj = null;
|
|
94
|
+
if (existed) {
|
|
95
|
+
try {
|
|
96
|
+
originalObj = JSON.parse(originalText);
|
|
97
|
+
} catch {
|
|
98
|
+
throw new Error(`claude settings 解析失败,拒绝覆盖:${targetFile}`);
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
const next = buildClaudeSettings(originalObj, { baseUrl, token, model, picks, behavesAs: p.behavesAs });
|
|
103
|
+
const nextText = `${JSON.stringify(next, null, 2)}\n`;
|
|
104
|
+
if (existed && norm(originalText) === norm(nextText)) {
|
|
105
|
+
return { action: "updated", file: targetFile, id: model, backup: null, changed: false, rows: next.modelPicker.options.length };
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
// 备份只保留「mslxdff 首次接管前」那一份:已存在就不覆盖(代价:用户后来手改的内容不进备份)
|
|
109
|
+
let backup = null;
|
|
110
|
+
if (existed) {
|
|
111
|
+
const backupFile = join(dirname(targetFile), "settings.pre-mslxdff.json");
|
|
112
|
+
if (!existsSync(backupFile)) {
|
|
113
|
+
try { copyFileSync(targetFile, backupFile); backup = backupFile; } catch { /* 复制失败不阻塞写入,但绝不谎报「已备份」 */ }
|
|
114
|
+
}
|
|
115
|
+
// 只在**本次真复制过**时返回路径(spec R6「打印备份路径(若本次生成)」);已有旧备份时返回 null,
|
|
116
|
+
// 由 CLI 换成「已存在更早的备份」提示 —— 免得用户拿首份旧备份去覆盖自己后来的手改。
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
mkdirSync(dirname(targetFile), { recursive: true });
|
|
120
|
+
const tmp = `${targetFile}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
|
|
121
|
+
// 凭据落地红线:文件里有明文 token → 0600(mode 只在新建时生效,故存量补 chmod)
|
|
122
|
+
let written = false;
|
|
123
|
+
let tmpLeftover = null;
|
|
124
|
+
// 半截 tmp 里带明文 token:unlink 也可能被占用(Windows 上正是 rename 失败的同因),
|
|
125
|
+
// 所以先擦内容再试一次;仍清不掉就把路径如实交出去,让 CLI 告警,绝不静默。
|
|
126
|
+
const sweepTmp = () => {
|
|
127
|
+
if (!existsSync(tmp)) return;
|
|
128
|
+
try { unlinkSync(tmp); return; } catch { /* 占用,走擦除 */ }
|
|
129
|
+
try { writeFileSync(tmp, "", { encoding: "utf8" }); } catch { /* 擦不动也继续试删 */ }
|
|
130
|
+
try { unlinkSync(tmp); } catch { tmpLeftover = tmp; }
|
|
131
|
+
};
|
|
132
|
+
try {
|
|
133
|
+
try { writeFileSync(tmp, nextText, { encoding: "utf8", mode: 0o600 }); } catch { writeFileSync(tmp, nextText, "utf8"); }
|
|
134
|
+
try { chmodSync(tmp, 0o600); } catch { /* Windows 无 posix mode,忽略 */ }
|
|
135
|
+
try {
|
|
136
|
+
renameSync(tmp, targetFile);
|
|
137
|
+
written = true;
|
|
138
|
+
} catch {
|
|
139
|
+
// rename 失败多见于目标被别的进程占用(Windows 常态):退回直写;仍失败就报错,绝不谎报「已同步」
|
|
140
|
+
try { writeFileSync(targetFile, nextText, { encoding: "utf8", mode: 0o600 }); written = true; } catch { /* 交给下面的 throw */ }
|
|
141
|
+
}
|
|
142
|
+
} finally {
|
|
143
|
+
sweepTmp();
|
|
144
|
+
}
|
|
145
|
+
if (!written) {
|
|
146
|
+
throw new Error(`无法写入 ${targetFile}(文件可能被其他进程占用)——配置未更新;原文见同目录 settings.pre-mslxdff.json${tmpLeftover ? `;另有清理失败的临时文件 ${tmpLeftover}(内含明文 token,请手动删除)` : ""}`);
|
|
147
|
+
}
|
|
148
|
+
try { chmodSync(targetFile, 0o600); } catch { /* ignore */ }
|
|
149
|
+
return { action: existed ? "updated" : "inserted", file: targetFile, id: model, backup, changed: true, rows: next.modelPicker.options.length, tmpLeftover };
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
export { OUR_ENV_KEYS, DEFAULT_BEHAVES_AS };
|
|
@@ -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
|
+
}
|
package/src/talk-log.js
CHANGED
|
@@ -43,12 +43,14 @@ const MASKS = [
|
|
|
43
43
|
[/\b(token|accessToken|refreshToken|api[_-]?key|apiKey|secret|password|cookie|client_secret|authorization)\s*[:=]\s*[\w./+-]{12,}/gi, "$1=[已脱敏]"],
|
|
44
44
|
];
|
|
45
45
|
|
|
46
|
-
|
|
47
|
-
|
|
46
|
+
const CUT_MARK = "\n…[已截断]";
|
|
47
|
+
|
|
48
|
+
/** 脱敏 + 按字节封顶截断(中文 3 字节/字,逐字累加才不会超预算),并报告这一刀是否真的落下。 */
|
|
49
|
+
function maskCut(v, cap = 100000) {
|
|
48
50
|
let s = String(v ?? "");
|
|
49
51
|
for (const [re, repl] of MASKS) s = s.replace(re, repl);
|
|
50
|
-
if (Buffer.byteLength(s, "utf8") <= cap) return s;
|
|
51
|
-
const tail = Buffer.from(
|
|
52
|
+
if (Buffer.byteLength(s, "utf8") <= cap) return { text: s, capped: false };
|
|
53
|
+
const tail = Buffer.from(CUT_MARK, "utf8");
|
|
52
54
|
const budget = Math.max(0, cap - tail.length);
|
|
53
55
|
let bytes = 0, i = 0;
|
|
54
56
|
for (const ch of s) {
|
|
@@ -57,9 +59,12 @@ export function maskText(v, cap = 100000) {
|
|
|
57
59
|
bytes += n;
|
|
58
60
|
i += ch.length;
|
|
59
61
|
}
|
|
60
|
-
return s.slice(0, i) +
|
|
62
|
+
return { text: s.slice(0, i) + CUT_MARK, capped: true };
|
|
61
63
|
}
|
|
62
64
|
|
|
65
|
+
/** 脱敏 + 按字节封顶截断(对外口径与改前逐字一致;要知道是否砍过用 maskCut/pushBlock)。 */
|
|
66
|
+
export function maskText(v, cap = 100000) { return maskCut(v, cap).text; }
|
|
67
|
+
|
|
63
68
|
function textOf(content) {
|
|
64
69
|
if (typeof content === "string") return content;
|
|
65
70
|
if (Array.isArray(content)) return content.map((p) => p?.text || (p?.image_url ? `[图片 ${String(p.image_url.url).slice(0, 60)}]` : "")).filter(Boolean).join("\n");
|
|
@@ -78,26 +83,44 @@ export function lastUserQuestion(body) {
|
|
|
78
83
|
|
|
79
84
|
const CUT_IN = "----8<----", CUT_OUT = "---->8----";
|
|
80
85
|
|
|
86
|
+
// 标签行的「N 字」在字节封顶之后只是**已落盘**的字数;不带封顶标记,就会被读成「模型只说了这么多」。
|
|
81
87
|
function pushBlock(out, label, text, cap) {
|
|
82
|
-
const m =
|
|
83
|
-
if (!m.trim()) return;
|
|
84
|
-
out.push(`[${label} · ${m.length}
|
|
88
|
+
const { text: m, capped } = maskCut(text, cap);
|
|
89
|
+
if (!m.trim()) return false;
|
|
90
|
+
out.push(`[${label} · ${m.length} 字${capped ? " · 已封顶" : ""}]`, CUT_IN, m, CUT_OUT, "");
|
|
91
|
+
return capped;
|
|
85
92
|
}
|
|
86
93
|
|
|
87
|
-
|
|
88
|
-
|
|
94
|
+
// 撞捕获上限时紧跟头部行的人类可读提醒:不必先认识 truncated=1 这个键名也能一眼看出「可能不完整」。
|
|
95
|
+
const TRUNC_NOTE = "[!] 本轮已撞捕获上限(truncated=1):思考/正文后半段未落盘,内容可能不完整 —— 别当成模型的完整回答";
|
|
96
|
+
|
|
97
|
+
/** 一条对话 = 一个可读块:头部一行元信息(ts= 是环形淘汰的唯一依据),正文三段。elapsed= 取本次尝试墙钟(design D3),finish=/relayMs= 为 ADR-0046 新读数。 */
|
|
98
|
+
export function formatTalkEntry({ reqId, model, via, hops, status, stream, elapsedMs, question, thinking, answer, tools, usage, upstream, account, pick, ts, talkCapped = false, talkChars, talkCap, finishReason, relayMs } = {}) {
|
|
99
|
+
const fval = finishReason || "-"; // 缺值占位(grill Q5):「没给 finish」不得被读成 stop;字段恒在场
|
|
89
100
|
const now = Number.isFinite(ts) && ts > 0 ? ts : Date.now();
|
|
101
|
+
const trunc = talkCapped === true;
|
|
90
102
|
const head = [
|
|
91
103
|
`${MARK} ts=${now}`, `time=${fmtShanghaiYMDHMS(new Date(now))}`, `req=${reqId || "-"}`, `model=${model || "-"}`,
|
|
92
104
|
via ? `via=${via}` : "", hops != null ? `hops=${hops}` : "", `status=${status ?? "-"}`,
|
|
93
105
|
stream ? "stream=1" : "stream=0", Number.isFinite(elapsedMs) ? `elapsed=${Math.round(elapsedMs)}ms` : "",
|
|
106
|
+
// 尝试墙钟与 relay 内部计时同值时不重复打印(头行噪音克制,grill Q3);两值不同(hedge/缓冲重放)才另列 relayMs
|
|
107
|
+
Number.isFinite(relayMs) && Number.isFinite(elapsedMs) && Math.round(relayMs) !== Math.round(elapsedMs) ? `relayMs=${Math.round(relayMs)}ms` : "",
|
|
108
|
+
`finish=${fval}`,
|
|
94
109
|
usage ? `usage(prompt=${usage.prompt_tokens ?? "-"},completion=${usage.completion_tokens ?? "-"})` : "",
|
|
95
110
|
upstream ? `upstream=${upstream}` : "", account ? `account=${account}` : "", pick ? `pick=${pick}` : "",
|
|
111
|
+
// 截断读数只在真截断时出现(未截断不得新增噪音字段):cap= 上限、chars= 已捕获字符数
|
|
112
|
+
trunc ? `truncated=1 cap=${Number.isFinite(talkCap) && talkCap > 0 ? talkCap : "-"} chars=${Number.isFinite(talkChars) ? talkChars : "-"}` : "",
|
|
96
113
|
].filter(Boolean).join(" ");
|
|
97
|
-
const out = [head
|
|
114
|
+
const out = [head];
|
|
115
|
+
if (trunc) out.push(TRUNC_NOTE);
|
|
116
|
+
out.push("");
|
|
98
117
|
pushBlock(out, "我问", question, 20000);
|
|
99
118
|
pushBlock(out, "思考", thinking, 100000);
|
|
100
|
-
|
|
119
|
+
// 零正文不再静默跳块(spec「零输出轮必须可判读」/grill Q4):缺块与「正文该有却没落盘」同形,缺席必须是可读读数。
|
|
120
|
+
// 只落一行标注 + 空行(没有内容可围,不套 CUT 围栏);有真实正文的字符串照旧走 pushBlock,该段与改动前逐字节一致。
|
|
121
|
+
// 判据看 trim 不看长度(P1-B):" "/"\n" 进 pushBlock 也会被 !m.trim() 整块跳过 → 与「正文丢盘」再度同形,而「只调工具 + 吐个换行」是真实 agent 形态。
|
|
122
|
+
if (!String(answer ?? "").trim()) out.push(`[回答 · 0 字 · 本轮无正文(finish=${fval})]`, "");
|
|
123
|
+
else pushBlock(out, "回答", answer, 200000);
|
|
101
124
|
const t = tools == null || tools === "" ? "" : String(tools);
|
|
102
125
|
pushBlock(out, "工具调用", t, 20000);
|
|
103
126
|
out.push("[END]", "");
|
|
@@ -177,8 +200,10 @@ export function trimTalkLog(file, nowTs = Date.now()) {
|
|
|
177
200
|
/**
|
|
178
201
|
* relay 落盘的唯一入口:把 relay() 累积的 detail.talk(思考/正文/工具分片)拼成一条对话。
|
|
179
202
|
* 空轮(零正文零思考零工具)不占环形窗口 —— 那是 relay-pipeline 已经另行报错的场景。
|
|
203
|
+
* 桶的 capped/n/cap 必须一路传到 formatTalkEntry:撞顶的那条要能看出「后半截没了」。
|
|
204
|
+
* attemptMs(本次上游尝试墙钟)由调用点传入;未传(拿不到尝试起点)回退 out.totalMs —— 此时 elapsed 与 relayMs 同值(spec 降级 scenario)。
|
|
180
205
|
*/
|
|
181
|
-
export function recordRelayTalk({ reqId, model, via, hops, body, out, echo = {} } = {}) {
|
|
206
|
+
export function recordRelayTalk({ reqId, model, via, hops, body, out, echo = {}, attemptMs, finishReason } = {}) {
|
|
182
207
|
if (!talkLogEnabled()) return false;
|
|
183
208
|
try {
|
|
184
209
|
const talk = out?.detail?.talk;
|
|
@@ -190,9 +215,11 @@ export function recordRelayTalk({ reqId, model, via, hops, body, out, echo = {}
|
|
|
190
215
|
if (!answer && !thinking && !tools) return false;
|
|
191
216
|
const ts = Date.now();
|
|
192
217
|
const block = formatTalkEntry({
|
|
193
|
-
reqId, model, via, hops, status, stream: Boolean(body?.stream),
|
|
194
|
-
elapsedMs: out?.totalMs,
|
|
218
|
+
reqId, model, via, hops, status, stream: Boolean(body?.stream), finishReason: finishReason ?? out?.detail?.sawFinishReason,
|
|
219
|
+
elapsedMs: Number.isFinite(Number(attemptMs)) ? Number(attemptMs) : out?.totalMs, // 新口径:本次尝试墙钟优先(design D3)
|
|
220
|
+
relayMs: out?.totalMs, question: lastUserQuestion(body || {}),
|
|
195
221
|
thinking, answer, tools, usage: out?.detail?.usage, ...echo, ts,
|
|
222
|
+
talkCapped: talk?.capped === true, talkChars: talk?.n, talkCap: talk?.cap,
|
|
196
223
|
});
|
|
197
224
|
appendTalkEntry({ file: talkLogFile(model), block, atMs: ts });
|
|
198
225
|
return true;
|
|
@@ -141,6 +141,11 @@ export async function attemptOnceResponsesSdk({
|
|
|
141
141
|
}
|
|
142
142
|
}
|
|
143
143
|
if (mapped) return mapped;
|
|
144
|
+
// 非 HTTP 类错误(网络断/超时/无 statusCode)经 errorResponseFromSdkError 映射为 null:
|
|
145
|
+
// 必须 rethrow,否则 res 保持 undefined 掉到下面 res.stream,把真实网络错误伪装成
|
|
146
|
+
// "Cannot read properties of undefined" 的 TypeError 502(2026-10-07 muse-spark 实测)。
|
|
147
|
+
// 不可无条件 throw:400(encrypted) 剥态重试成功也走到这里(res 已赋值、mapped 置 null)。
|
|
148
|
+
if (res === undefined) throw e;
|
|
144
149
|
}
|
|
145
150
|
const out = streamResponseFromParts(res.stream, { marker, clock, t0, captured });
|
|
146
151
|
if (encRetry) { try { out._t.encRetry = true; } catch {} }
|
package/src/usage/report.js
CHANGED
|
@@ -118,11 +118,15 @@ function fold(acc, r) {
|
|
|
118
118
|
}
|
|
119
119
|
|
|
120
120
|
// 纯函数:只做过滤 + 归并,不碰磁盘。
|
|
121
|
-
export function aggregateUsage(rows, { hours = 24, now = Date.now(), model = null } = {}) {
|
|
122
|
-
const windowHours = Number.isFinite(Number(hours)) && Number(hours) > 0 ? Number(hours) : 24;
|
|
121
|
+
export function aggregateUsage(rows, { hours = 24, since: sinceOpt = null, now = Date.now(), model = null } = {}) {
|
|
123
122
|
const untilN = Number(now);
|
|
124
123
|
const until = Number.isFinite(untilN) ? untilN : Date.now();
|
|
125
|
-
|
|
124
|
+
// since(绝对窗口起点,毫秒)优先于 hours:CLI 默认窗口「今日 0 点 → 现在」靠它精确落在 0 点,不随查询时刻漂移
|
|
125
|
+
const sinceMs = sinceOpt == null ? NaN : Number(sinceOpt);
|
|
126
|
+
const hasSince = Number.isFinite(sinceMs);
|
|
127
|
+
const hoursN = Number(hours);
|
|
128
|
+
const windowHours = hasSince ? (until - sinceMs) / HOUR_MS : Number.isFinite(hoursN) && hoursN > 0 ? hoursN : 24;
|
|
129
|
+
const since = hasSince ? sinceMs : until - windowHours * HOUR_MS;
|
|
126
130
|
const byModel = new Map();
|
|
127
131
|
const sum = blank(null);
|
|
128
132
|
let scanned = 0;
|
|
@@ -156,8 +160,10 @@ export function aggregateUsage(rows, { hours = 24, now = Date.now(), model = nul
|
|
|
156
160
|
}
|
|
157
161
|
|
|
158
162
|
// 读保留期内的日文件并只留窗口内的行(保留期默认 2 天,文件数很少,全读即可)。
|
|
159
|
-
export async function readUsageRows({ dir, hours = 24, now = Date.now() } = {}) {
|
|
160
|
-
const
|
|
163
|
+
export async function readUsageRows({ dir, hours = 24, since: sinceOpt = null, now = Date.now() } = {}) {
|
|
164
|
+
const sinceMs = sinceOpt == null ? NaN : Number(sinceOpt);
|
|
165
|
+
const hoursN = Number(hours);
|
|
166
|
+
const since = Number.isFinite(sinceMs) ? sinceMs : Number(now) - (Number.isFinite(hoursN) && hoursN > 0 ? hoursN : 24) * HOUR_MS;
|
|
161
167
|
let files = [];
|
|
162
168
|
try {
|
|
163
169
|
files = (await readdir(usageDir({ dir }))).filter((f) => f.endsWith(".jsonl")).sort();
|
|
@@ -183,7 +189,7 @@ export async function readUsageRows({ dir, hours = 24, now = Date.now() } = {})
|
|
|
183
189
|
return rows;
|
|
184
190
|
}
|
|
185
191
|
|
|
186
|
-
export async function usageReport({ dir, hours = 24, now = Date.now(), model = null } = {}) {
|
|
187
|
-
const rows = await readUsageRows({ dir, hours, now });
|
|
188
|
-
return aggregateUsage(rows, { hours, now, model });
|
|
192
|
+
export async function usageReport({ dir, hours = 24, since = null, now = Date.now(), model = null } = {}) {
|
|
193
|
+
const rows = await readUsageRows({ dir, hours, since, now });
|
|
194
|
+
return aggregateUsage(rows, { hours, since, now, model });
|
|
189
195
|
}
|