mslxdff 0.1.200 → 0.1.207

package/src/runtime/keep-warm.js

@@ -0,0 +1,120 @@
+// 保热心跳（用户 2026-10-18 拍板）：每 ≤120s 主动访问一次「每个组员 + 每个在 picks 的上游供应商」，
+// 保持连接热度，防「久未使用 → 首发 fetch failed / 上游冷启动 26s」。
+//
+// ⚠ 必须用**与 chat 完全相同的那条连接池**，否则白热（用户 2026-10-18 纠正）：
+//   - 组员 → warmPeerHealth()（getPeerDispatcher，正是 peer 转发复用的池）；
+//   - 供应商 → provider.preheat()（各家 preheat 经各自 agent/extDispatcher 打自己的 models 端点，
+//     与 chat 同池：opencode 走 v6/warp 池、generic/custom 走各自 agent）。
+//   绝不能裸 compatFetch / directProbe——那热的是全局池的 socket，真流量复用的是另一条，等于没热。
+//
+// 为什么需要它（现网取证 2026-10-18 16:16，req mvdjwol5-aysc）：三个组员同时 `fetch failed`（TCP 都没建立），
+// 根因是两端 keep-alive 打架——服务端 Node 默认 5s 掐闲置连接，而组长 undici 池账面 30s 内以为 socket 还活着，
+// 复用死 socket 即失败。已把服务端 keepAliveTimeout 提到 65s（server.js）治本；本心跳是**补强**：
+// ① 间隔 120s < 家里 NAT/防火墙更短的空闲回收窗（很多路由 60~120s 就丢映射，单靠 65s keep-alive 挡不住）；
+// ② 顺带让上游对我们出口保持"温热"（opencode 实测固定 session 1.2s、冷机器 26s+）。
+//
+// 零额度消耗（全部经各家 preheat：GET models / GET /health，不打 chat）。永不抛，只记事件。
+import { warmPeerHealth } from "../routes/peers.js";
+
+export function keepWarmIntervalMs(env = process.env) {
+  const n = Number(env.MSLXDFF_KEEP_WARM_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 120_000; // 0 = 关闭
+}
+
+/**
+ * 从 picks 里算出要保热的「供应商头」集合：裸 id（无 `/`）归 opencode（免费池）；带前缀取首段。
+ * 只保留出现过的供应商，天然覆盖"每个在 picks 的接口"。opencode 恒排第一（免费池是主力、最该保热）。
+ * @param {string[]} picks
+ * @returns {string[]} 供应商 id 列表（含 "opencode"），已去重、opencode 置顶
+ */
+export function providerHeadsFromPicks(picks = []) {
+  const heads = new Set();
+  for (const id of picks) {
+    const s = String(id || "").trim();
+    if (!s) continue;
+    heads.add(s.includes("/") ? s.slice(0, s.indexOf("/")) : "opencode");
+  }
+  const out = [...heads];
+  if (out.includes("opencode")) return ["opencode", ...out.filter((h) => h !== "opencode")];
+  return out;
+}
+
+/**
+ * 单轮保热：组员各 warmPeerHealth、picks 供应商各 preheat。返回汇总（供事件取证）。绝不抛。
+ * @param {{peers:{url:string}[], picks:string[], byId?:Map<string,{preheat?:Function}>, upstream?:{preheat?:Function},
+ *          warmPeer?:Function, evt?:Function}} deps
+ */
+export async function warmOnce({
+  peers = [],
+  picks = [],
+  byId = null,
+  upstream = null,
+  warmPeer = warmPeerHealth,
+  evt = () => {},
+} = {}) {
+  const staticPeers = peers.filter((p) => p?.url && !String(p.url).startsWith("relay://")); // broadband 走 relay 队列，不直连
+  let peerOk = 0, peerFail = 0;
+  for (const p of staticPeers) {
+    try {
+      const r = await warmPeer(String(p.url));
+      if (r?.ok) peerOk += 1; else peerFail += 1;
+    } catch { peerFail += 1; }
+  }
+  const heads = providerHeadsFromPicks(picks);
+  let provOk = 0, provFail = 0, provSkip = 0;
+  for (const head of heads) {
+    try {
+      // 供应商预热一律走它自己的 preheat（chat 同池）。opencode 特判：**多 provider 装配**下
+      // providers 数组里含 opencode，直接 byId 取；单 provider 模式下 byId 为空，退回 upstream.preheat。
+      const inst = byId?.get?.(head);
+      const preheat = inst?.preheat || (head === "opencode" ? upstream?.preheat : null);
+      if (typeof preheat !== "function") { provSkip += 1; continue; } // 本地号型/无域名供应商：本就没有可保热的域
+      const r = await preheat.call(inst || upstream);
+      if (r?.ok) provOk += 1; else provFail += 1;
+    } catch { provFail += 1; }
+  }
+  evt("keep-warm", { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip });
+  return { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip };
+}
+
+/**
+ * daemon 装配：起一个 unref 的定时器，每 keepWarmIntervalMs 跑一轮 warmOnce。
+ * 关（=0）返回 null。依赖注入以便测试；生产用 setupProviders 的 ctx（providers/upstream/peers）。
+ */
+export function startKeepWarm({
+  peers,
+  providers = [],
+  upstream,
+  env = process.env,
+  evt = () => {},
+  logs,
+  loadModelPicks,
+  warmPeer = warmPeerHealth,
+} = {}) {
+  const interval = keepWarmIntervalMs(env);
+  if (interval === 0) return null;
+  const byId = new Map((providers || []).map((p) => [p.id, p]));
+  const emit = (type, data) => {
+    const entry = { ts: Date.now(), type, ...data };
+    try { evt(type, data); } catch {}
+    try { logs?.appendEvent?.(entry); } catch {}
+  };
+  const runTick = async () => {
+    try {
+      const picks = loadModelPicks ? loadModelPicks() : [];
+      await warmOnce({
+        peers: peers?.all?.() || [],
+        picks: Array.isArray(picks) ? picks : [],
+        byId,
+        upstream,
+        warmPeer,
+        evt: emit,
+      });
+    } catch { /* 保热永不影响主链路 */ }
+  };
+  console.log(`[keep-warm] enabled: every ${Math.round(interval / 1000)}s 经 chat 同池访问每个组员(/health) + 每个 picks 供应商(preheat) 保热，设 MSLXDFF_KEEP_WARM_MS=0 关`);
+  void runTick(); // 启动即热一次，别等第一个间隔
+  const timer = setInterval(() => { void runTick(); }, interval);
+  timer.unref?.();
+  return { stop: () => clearInterval(timer), interval, tick: runTick };
+}

package/src/server.js

@@ -11,6 +11,13 @@ export function startServer({ router, signals = true, host, onBeforeClose }, por
       res.end(JSON.stringify({ error: String(err?.message || err) }));
     });
   });
+  // 空闲 keep-alive 连接必须活得比**客户端池**（打我们的组员/peer 用 undici keepAliveTimeout=30s，
+  // routes/peers.js:64）更久，否则出现两端超时打架：服务端 Node 默认 5s 就单方面掐掉闲置连接，
+  // 而组长池里的 socket 账面上还活着（<30s），下一次真请求复用死 socket ⇒ `fetch failed`
+  //（现网 2026-10-18 16:16：三个组员同时 fetch failed，peer-race 全灭、收场 502——间歇性、下一发又好的形态）。
+  // 65s = 30s 客户端余量 + 一倍缓冲；headersTimeout 必须 > keepAliveTimeout（Node 断言要求），取 70s。
+  server.keepAliveTimeout = Number(process.env.MSLXDFF_KEEPALIVE_TIMEOUT_MS) || 65_000;
+  server.headersTimeout = Number(process.env.MSLXDFF_HEADERS_TIMEOUT_MS) || 70_000;
 
   const ready = () =>
     new Promise((resolve, reject) => {

package/src/usage/cache-fields.js

@@ -0,0 +1,58 @@
+/**
+ * 上游 usage 里的「缓存读数」候选链 —— 全仓单一来源。
+ *
+ * 为什么独立成档：同一份上游 usage 有**两个**消费方，两边的候选顺序必须一字不差，
+ * 否则「/v1/messages 的客户端 usage」与「我们自己的日志/报表」会各说一套：
+ *   · `src/anthropic/translate.js` → Anthropic 形状的 client usage；
+ *   · `src/metrics.js`（extractUsageFromJson）→ detail.usage / usage/*.jsonl / -stats。
+ *
+ * 候选顺序与语义照抄 cc-switch（`providers/transform.rs:760-798`）：
+ *  · 命中（cache read）：`cache_read_input_tokens` → `input_tokens_details.cached_tokens`
+ *    → `prompt_tokens_details.cached_tokens` → `prompt_cache_hit_tokens`（DeepSeek 系）。
+ *    **每环必须「存在且 > 0」才采信**：有些中转把靠前字段硬编码桩 0，真命中只出现在后面的
+ *    字段里（cc-switch #8045/#8041，否则命中被 0 掩蔽）。全链无 >0 命中 → 0（＝没有可用命中读数）。
+ *  · 写入（cache creation）：`cache_creation_input_tokens` → `prompt_tokens_details.cache_write_tokens`
+ *    → `input_tokens_details.cache_write_tokens`。这里**显式 0 也算已报**（与命中相反），
+ *    故全链无字段时返回 null 表示「上游没报」，0 表示「报了 0」。
+ */
+
+const num = (v) => (v == null || v === "" ? null : Number.isFinite(Number(v)) ? Number(v) : null);
+
+/**
+ * 缓存命中（读）token 数：候选须「存在且 >0」才采信，未发现命中返回 0。
+ * @param {any} usage 上游原始 usage 对象
+ * @returns {number}
+ */
+export function cacheReadTokens(usage) {
+  const u = usage && typeof usage === "object" ? usage : {};
+  const candidates = [
+    u.cache_read_input_tokens,
+    u.input_tokens_details?.cached_tokens,
+    u.prompt_tokens_details?.cached_tokens,
+    u.prompt_cache_hit_tokens,
+  ];
+  for (const v of candidates) {
+    const n = num(v);
+    if (n != null && n > 0) return n;
+  }
+  return 0;
+}
+
+/**
+ * 缓存写入（creation）token 数：任一候选字段存在即以它为准（显式 0 也算已报）；全缺返回 null。
+ * @param {any} usage 上游原始 usage 对象
+ * @returns {number|null}
+ */
+export function cacheWriteTokens(usage) {
+  const u = usage && typeof usage === "object" ? usage : {};
+  const candidates = [
+    u.cache_creation_input_tokens,
+    u.prompt_tokens_details?.cache_write_tokens,
+    u.input_tokens_details?.cache_write_tokens,
+  ];
+  for (const v of candidates) {
+    const n = num(v);
+    if (n != null) return n;
+  }
+  return null;
+}

package/src/usage/record.js

@@ -92,6 +92,9 @@ export function recordChatUsage({ model, via, usage, ttfbMs, totalMs, tps, inter
     reasoning_chars: Number.isFinite(rc) && rc > 0 ? Math.trunc(rc) : 0,
     // 上游是否明确上报过思考 tokens（metrics.js 只在数值有限时才写 reasoning_tokens）
     reasoning_reported: Number.isFinite(usage?.reasoning_tokens) ? 1 : 0,
+    // —— 缓存读数（候选链单一来源 = usage/cache-fields.js；metrics 投影里「字段缺失＝上游没报」）——
+    cache_read_tokens: Number.isFinite(Number(usage?.cache_read_input_tokens)) ? Number(usage.cache_read_input_tokens) : null,
+    cache_creation_tokens: Number.isFinite(Number(usage?.cache_creation_input_tokens)) ? Number(usage.cache_creation_input_tokens) : null,
     // 调用方没表态时整字段不落盘：「未知」≠「非流式」，覆盖度分母宁低不假高
     ...(stream === undefined ? {} : { stream: stream ? 1 : 0 }),
     ttfbMs: Number.isFinite(ttfbMs) ? ttfbMs : null,

package/src/usage/report.js

@@ -55,6 +55,9 @@ function blank(id) {
     reasoningEstimatedRows: 0,
     reasoningChars: 0,
     streamRequests: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    cacheRows: 0,
   };
 }
 
@@ -77,6 +80,13 @@ function finalize(a) {
     ttfSamples: a.ttfbN,
     streamRequests: a.streamRequests,
     avgTps: a.completionMsSum > 0 ? Number((a.tpsTokSum / (a.completionMsSum / 1000)).toFixed(1)) : null,
+    cacheReadTokens: a.cacheReadTokens,
+    cacheCreationTokens: a.cacheCreationTokens,
+    cacheRows: a.cacheRows,
+    // 命中率 = 缓存读 ÷ 输入总数（上游 prompt_tokens **含**缓存命中，故分母用输入总数；
+    // 实测佐证：cache 命中那发 prompt_tokens=429 = 客户端 input 45 + cache_read 384）。
+    // 窗口内没有任何命中读数时给 null → 渲染成 —，绝不拿 0 冒充「没缓存」。
+    cacheHitRate: a.cacheRows > 0 && a.promptTokens > 0 ? Number((a.cacheReadTokens / a.promptTokens).toFixed(4)) : null,
   };
 }
 
@@ -95,6 +105,10 @@ function fold(acc, r) {
   acc.reasoningChars += tok(r.reasoning_chars);
   // 首字样本分母：非流式行既无首字也不该摊进分母；缺 stream 的旧行按未知保守计入
   if (r.stream !== 0) acc.streamRequests++;
+  // 缓存读数：只有上游真报了命中（字段存在且 >0）才算「有读数」——分母不拿未报的请求凑
+  const cr = tok(r.cache_read_tokens);
+  if (cr > 0) { acc.cacheReadTokens += cr; acc.cacheRows++; }
+  acc.cacheCreationTokens += tok(r.cache_creation_tokens);
 
   const ttfb = ms(r.ttfbMs ?? r.ttfb_ms);
   if (ttfb != null) {