mslxdff 0.1.227 → 0.1.228

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.227",
+  "version": "0.1.228",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/chat-pipeline/index.js

@@ -101,7 +101,11 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     }
     if (!order.length) order = [""];
     const canFallback = order.length > 1;
-    const canForwardPeers = Boolean(peers) && hops < (maxHops ?? 3);
+    // hi 探针（x-mslxdff-probe:1）只问「这台机器此刻能不能打通上游」，不代表真实业务：
+    // 它绝不能再触发本机的组员/宽带接力——否则探针会跟着走完整条接力链（最坏 45s 预算），
+    // 而调用方只看它几百毫秒内活不活。组员侧就地直连，成败如实回给调用方。
+    const isProbe = String(req?.headers?.["x-mslxdff-probe"] || "") === "1";
+    const canForwardPeers = !isProbe && Boolean(peers) && hops < (maxHops ?? 3);
     mark("ordered");
 
     const reqIp = clientIp(req); // 一次解析两处用：request 事件的 ip 字段 + 回路语料的 clientIp（routes/helpers.js 取 x-forwarded-for 首段）
@@ -125,7 +129,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     const clientSession = String(req?.headers?.["x-session-affinity"] || req?.headers?.["x-session-id"] || "").trim() || null;
     // triedUrls 挂请求级并**按引用**共享：同一请求内"同一组员不重复试"的契约跨候选生效
     // （peer 阶段各分支会 spread 出上下文副本，集合在这里建一次才不会各存一份）。
-    const handlerCtx = { reqId, api, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession, clientIp: reqIp, triedUrls: new Set() };
+    const handlerCtx = { reqId, api, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession, clientIp: reqIp, triedUrls: new Set(), isProbe };
     if (clientSession) evt("client-session", { reqId, sessionId: clientSession.slice(0, 24) });
 
     await engine.run({

package/src/chat-pipeline/serial-trial.js

@@ -100,7 +100,9 @@ export async function runSerialTrial(ctx, deps = {}) {
     const chatOptsArg = Object.keys(chatOpts).length ? chatOpts : undefined;
     // 空转 200（模型无输出）同模型暂停重试：默认 3 次、阶梯 [2s,8s,30s]；仅 EMPTY_MODEL_RESPONSE，
     // 429/403/500 与 fetch 异常走原有切号/failover（防烧额度）。MSLXDFF_EMPTY_TURN_RETRIES=0 关闭。
-    const emptyCfg = emptyRetryCfg();
+    // 探针（x-mslxdff-probe:1）不重试：调用方只要一个「活不活」的答案，重试阶梯会把它吊 40s。
+    const isProbe = handlerCtx?.isProbe === true;
+    const emptyCfg = isProbe ? { max: 0, steps: null, delayMs: 0 } : emptyRetryCfg();
     const raiseCap = emptyRaiseCap();
     const nudgeCfg = emptyNudgeCfg();
     let emptyRetried = 0;

package/src/cli/format.js

@@ -62,6 +62,8 @@ export function fmtEvent(e) {
       return `${head} peer check    ${e.peer} -> ${e.count ? e.healthy.join(", ") : "no healthy models"}${e.strict ? " (strict)" : ""}`;
     case "peer-request":
       return `${head} peer req      并发发出 peer=${e.peer} model=${m(e.model)} hops=${e.hops}`;
+    case "peer-probe":
+      return `${head} peer hi       备选探活 peer=${e.peer} ${e.ok ? "ok" : `fail HTTP ${e.status ?? "network"}`} model=${m(e.model)} ${e.latencyMs ? `${e.latencyMs}ms` : ""}${e.action === "skip" ? " → 跳过换下一个" : ""}`;
     case "peer-forward":
       return `${head} peer resp     收到响应 peer=${e.peer} model=${m(e.model)} ${e.ok ? "ok" : "fail"} ${e.latencyMs ? `${e.latencyMs}ms` : ""} hops=${e.hops}${e.retry ? " (retry)" : ""}`;
     case "peer-error":

package/src/routes/peer-probe.js

@@ -0,0 +1,53 @@
+// 组员「打一个 hi」探针：备选时打一次、轮到它时再打一次，回不来就当它不行。
+//
+// 为什么要打 hi 而不是 /health：额度只体现在真实 chat 调用上。实测（2026-10-20，本机出口已知 429）
+//   GET /health 与 GET /zen/v1/models **都照样 200**，只有 POST chat 才回 429 FreeUsageLimitError。
+// 为什么要挑在「备选」和「轮到」两个时刻：
+//   备选是上一次切换时定的，中间上一个节点可能已在大 body 上撞墙几十秒（实测 1.5MB 撞 429 要
+//   28~62s），那时有额度不代表现在还有 ⇒ 轮到它时必须再确认一次。
+// 开销：hi + max_tokens=8，拿响应头即掐断，不等正文，也不触发对端空轮重试。
+import { compatFetch, timeoutSignal } from "../compat.js";
+import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
+
+// 等 hi 的上限。超时按「没判过」处理（交主流程照常试），绝不因为探针慢就错杀一个能用的节点。
+export function peerProbeTimeoutMs(env = process.env) {
+  const n = Number(env.MSLXDFF_PEER_PROBE_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 10_000;
+}
+
+/**
+ * 给一个组员打一句 hi，只关心它活不活。
+ * @returns {Promise<{ok: boolean, status: number, ms: number, unknown?: boolean}>} 永不抛
+ *   ok=false 只在「明确不该再试」时给：拿到 4xx/5xx 响应。
+ *   连不上/超时一律 ok=true + unknown=true（那是主流程 forwardToPeer 的账，探针不越权判死）。
+ */
+export async function probePeer(peer, { model, timeoutMs = peerProbeTimeoutMs(), dispatcher, fetchImpl = compatFetch } = {}) {
+  const t0 = Date.now();
+  if (!peer?.url || !model) return { ok: true, status: 0, ms: 0, unknown: true };
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${peer.token || ""}`,
+    "x-mslxdff-hops": "1",
+    "x-mslxdff-model-lock": model,
+    // 探针必须可识别：组员侧据此知道这是「体检」不是真实业务（不落 usage、不参与空轮重试），
+    // 日志/测试也能把它与真实转发分开，否则「一次请求打了几次组员」这类断言会被探针污染。
+    "x-mslxdff-probe": "1",
+    "Accept": "text/event-stream",
+  };
+  const share = buildShareKeysHeader(model);
+  if (share) headers[SHARE_KEYS_HEADER] = share;
+  try {
+    const res = await fetchImpl(`${String(peer.url).replace(/\/+$/, "")}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ model, stream: true, max_tokens: 8, messages: [{ role: "user", content: "hi" }] }),
+      signal: timeoutSignal(timeoutMs),
+      ...(dispatcher ? { dispatcher } : {}),
+    });
+    // 拿到响应头就够判了：立刻掐断，不等正文
+    try { const c = res.body?.cancel?.(); if (c && typeof c.catch === "function") c.catch(() => {}); } catch {}
+    return { ok: res.status < 400, status: res.status, ms: Date.now() - t0 };
+  } catch {
+    return { ok: true, status: 0, ms: Date.now() - t0, unknown: true };
+  }
+}

package/src/routes/peer-serial.js

@@ -45,7 +45,7 @@ export function warmPeer(peer, deps = {}) {
 export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried, deps }) {
   const {
     resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
-    perAttemptCap, deadline, budgetMs,
+    perAttemptCap, deadline, budgetMs, probePeer,
   } = deps;
   const warm = deps.warmPeer || warmPeer;
   const failed = [];
@@ -71,22 +71,51 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
   const ipv4Chain = filterSlow(fresh(candidates));
   const ipv6Chain = filterSlow(fresh(v6Candidates));
 
-  // —— 预取：进循环前就把「下一个」定好，并顺手预热连接 ——
+  // —— 预取 + 探针（用户 2026-10-20 口径）——
+  // 「某个节点当备选的时候打一个 hi，准备轮到它了也打一个 hi；hi 都回不来就当它不行，直接换。」
+  // 两个 hi 都打，不做结果复用：备选是上一次切换时定的，中间可能已过了几十秒
+  // （上一个节点在大 body 上撞墙，实测 1.5MB 要 28~62s），那时活不代表现在活。
+  // 备选那个 hi 的作用是暖连接 + 提前暴露死节点，轮到时的那个才决定去留。
   let pending = null;
-  const prime = (peer) => {
+  // resolvePeerTarget 会打 /v1/models/status，别为探针白测两次：这里记住解析结果给下一轮复用。
+  const resolved = new Map(); // url -> Promise<{peer,target}|null>
+  const resolveOnce = (peer) => {
+    const hit = resolved.get(peer.url);
+    if (hit) return hit;
+    const p = Promise.resolve()
+      .then(() => resolvePeerTarget(ctx, peer))
+      .catch(() => null);
+    resolved.set(peer.url, p);
+    return p;
+  };
+  const prime = (peer, target) => {
+    if (!peer || !target || typeof probePeer !== "function") return;
+    try {
+      const p = probePeer(peer, target);
+      if (p && typeof p.then === "function") p.catch(() => {});
+    } catch { /* 预热失败不影响主流程 */ }
+  };
+  const primeAt = (peer) => {
     if (!peer) return;
-    warm(peer, deps.warmPeerDeps);
+    resolveOnce(peer)
+      .then((r) => { if (r) prime(r.peer, r.target); })
+      .catch(() => {});
   };
   const takeNext = (stage) => {
     const chain = stage === "ipv6" ? ipv6Chain : ipv4Chain;
     const p = chain.shift() || null;
-    if (p) prime(chain[0] || null); // 立即预热「再下一个」，保证永远有备选就绪
+    // 立刻给「再下一个」打 hi。模型名要现在解析——下一轮循环该它时 ctx.model 可能已变。
+    if (p) primeAt(chain[0] || null);
     return p;
   };
 
   let stage = "ipv4";
   let emptyIpv4Announced = false;
 
+  // 链头从没当过「备选」（它一上来就是主角），进入循环前先给它也打一个 hi ——
+  // 此时 ctx.model 还是本机刚失败的那个模型，解析目标与后面轮到时同源。
+  primeAt(ipv4Chain[0] || null);
+
   for (;;) {
     if (deadline > 0 && Date.now() >= deadline) {
       const remaining = ipv4Chain.length + ipv6Chain.length;
@@ -110,12 +139,33 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
     }
     if (!pending) break;
 
-    const prepared = await resolvePeerTarget(ctx, pending);
+    const prepared = await resolveOnce(pending);
     if (!prepared) continue;
     const { peer, target } = prepared;
     tried.add(peer.url);
     const ctrl = new AbortController();
     const name = peerName(peer);
+
+    // 轮到它了：再打一个 hi。回不来就当这个备选不行，直接换下一个。
+    if (typeof probePeer === "function") {
+      const t = performance.now();
+      let r;
+      try { r = await probePeer(peer, target); } catch { r = { ok: false }; }
+      const probeMs = Math.round(performance.now() - t);
+      if (r && r.ok === false) {
+        ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: false, status: r.status ?? null, latencyMs: probeMs, action: "skip" });
+        failed.push({ ok: false, peer, target, res: null, status: r.status || 502 });
+        recordLater(() => ctx.peers.recordError(peer.url, { status: r.status || 502 }));
+        recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
+        continue;
+      }
+      ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: true, status: r?.status ?? null, latencyMs: probeMs });
+      if (deadline > 0 && Date.now() >= deadline) {
+        ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽（探针后）`, budgetMs, remaining: ipv4Chain.length + ipv6Chain.length });
+        break;
+      }
+    }
+
     ctx.evt("peer-request", { peer: peer.url, name, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body), serial: 1, stage });
     if (ctx.plugins?.length) {
       runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});

package/src/routes/peers.js

@@ -5,6 +5,7 @@ import { runHook } from "../plugins.js";
 import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
 import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
 import { serialTryPeers, PEER_SERIAL } from "./peer-serial.js";
+import { probePeer, peerProbeTimeoutMs } from "./peer-probe.js";
 import { overForwardLimit, contextGuardMessage } from "../chat-pipeline/context-guard.js";
 
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
@@ -252,6 +253,13 @@ export async function racePeerCandidates(candidates, ctx) {
         perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs,
         // 连接预热：对「下一个备选」提前打 /health，复用 chat 的同一连接池（见 warmPeerHealth 注释）
         warmPeer: (peer) => { if (peer?.url) warmPeerHealth(peer.url, { timeoutMs: 1500 }).catch(() => {}); },
+        // 用户 2026-10-20：备选时打一个 hi、轮到它时再打一个 hi，hi 回不来就换下一个。
+        // 走 getPeerDispatcher 的**同一条连接池**（与 chat 转发复用 socket，裸 fetch 热的是另一条等于白热）。
+        probePeer: (peer, model) => probePeer(peer, {
+          model: model || null,
+          timeoutMs: peerProbeTimeoutMs(),
+          dispatcher: getPeerDispatcher(),
+        }),
       },
     });
   }