mslxdff 0.1.234 → 0.1.236

package/docs/cli_help_mini.md

@@ -92,6 +92,7 @@
 | 空轮留口与终局收场（ADR-0043） | `MSLXDFF_EMPTY_TURN_HOLD_END`（默认开）/`MSLXDFF_EMPTY_TURN_BUDGET_MS`（45000）/`MSLXDFF_EMPTY_TURN_MIN_RAISE_TO`（16384） | 「200 但零正文」的空轮曾先 `res.end()` 再判定，重拉/换候选写的是已终结响应（客户端只看到空白）。现把「可撤销」定义为**尚未提交模型产出**：空 delta 帧与 `[DONE]` 暂扣不写、流结束不封口，交回重拉续写同一条连接；思考已刷出的一类撤不回 → 不留口，改在流尾补 `EMPTY_MODEL_RESPONSE` SSE 错误帧 + `[DONE]`（客户端看到具体原因而非莫名空白）。终局按 `res.headersSent` 分叉（未 flush→502 JSON / 已 flush→SSE 错误帧），单一出口 + `writableEnded` 守卫保证恰好一次；预算=请求级跨候选累计封顶；`MIN_RAISE_TO` 给"客户端没设额度"的主流空轮兜底抬一次（`0`=回旧口径不发明）；`HOLD_END=0` 逐字节回退旧行为 |
 | 首发输出额度托底 | `MSLXDFF_EMPTY_TURN_MIN_TOKENS`（缺省 8192，`0`/负数=关）/`MSLXDFF_EMPTY_TURN_TINY_MAX`（缺省 64） | 客户端额度 < 门槛（算爆，实测 `max_completion_tokens=1` 被上游截成 1 token 碎渣、agent 循环停摆）→ 首发上游前托到托底值；只加不减、没设额度不发明、0/负数（上游默认语义）不托；serial-trial、auto-race 与宽带成员三处 `upstream.chat` 出口都托；事件 `output-floor`（`key/raiseFrom/raiseTo`） |
 | 免费层形状门禁（ADR-0020） | `MSLXDFF_FREE_LANE`（缺省 1）/`MSLXDFF_FREE_LANE_DEBUG=1` | zen 免费模型必须 `stream:true` + tools 含 bash/edit/glob/grep/read 五名且 UA≥`opencode/1.18.0`（否则 403/426）；`src/free-lane.js` 自动补形状、非流式聚合回 JSON；`0`=关（逃生阀），DEBUG 打 `[free-lane]` 日志 |
+| 指定模型 5xx 退避（ADR-0068） | `MSLXDFF_5XX_RETRIES`（缺省 `3`）/`MSLXDFF_5XX_RETRY_DELAY_MS`（缺省 `5000`） | 指定模型（非 auto）撞 5xx 后同模型等 5s 重拉、连续 3 次；仍 5xx 才换 1 个节点（组长优先→延迟升序），该节点仍 5xx 直接收场，不再全节点 fan-out、不走宽带；`RETRIES=0`=整套关闭（回旧路径）；429/4xx 与 auto 不适用；事件 `upstream-5xx-retry` |
 | WorkBuddy 摘除 | `-workbuddy remove <uid> [--keep-file]` / `-wb remove` | 按 `uid`（前缀6位）摘除，删 `keys/auths` 与 `auths/workbuddy-<uid>.json` |
 | 定号消耗 | `header x-mslxdff-workbuddy-uid: <uid>` 或 `model workbuddy/<uid>:<model>` | 钉死指定账号消耗，`x-mslxdff-workbuddy-uid` 回显实际账号 |
 | 同步 WB | `-setto workbuddy [modelId]` | 同步到 WorkBuddy（原子写 `~/.workbuddy/models.json`，`127.0.0.1/v1`，多模型累积；picks 非空时摘除失效本地条目） |

package/package.json

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

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

@@ -15,6 +15,7 @@ import { isEmptyTurnError } from "../routes/chat/relay-pipeline.js";
 import { emptyRetryCfg, emptyRaiseCap, withRaisedMaxTokens, withOutputFloor, emptyNudgeCfg, withEmptyNudge, computeNextDelay, emptyTurnBudgetMs, emptyTurnMinRaiseTo } from "./empty-turn.js";
 import { classifyTerminalUpstream, readVerdictText, terminalShortcircuitOff } from "./terminal-verdict.js";
 import { forwardOrGuard } from "./context-forward.js";
+import { chatWith5xxRetry, http5xxRetryCfg } from "./upstream-5xx-retry.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -111,7 +112,14 @@ export async function runSerialTrial(ctx, deps = {}) {
       const tUp = performance.now();
       evt("upstream-try", { reqId, model, attempt: idx + 1, emptyRetry: emptyRetried, payload: summarizeRequest(forwarded) });
       try {
-        upRes = await upstream.chat(forwarded, chatOptsArg);
+        // 指定模型：5xx 先原地等 5s 重试（默认 3 次），仍 5xx 才交给上层换 1 个节点；auto 原样直发。
+        // 见 upstream-5xx-retry.js（用户口径 2026-10-23）。
+        upRes = await chatWith5xxRetry({
+          call: () => upstream.chat(forwarded, chatOptsArg),
+          singleModel: !useAuto,
+          evt, reqId, model,
+          isClosed: () => Boolean(res?.destroyed || res?.writableEnded),
+        });
         evt("upstream-done", { reqId, model, ok: !(upRes instanceof Error) && upRes.status < 400, status: upRes instanceof Error ? null : upRes.status, timing: upRes._t ?? null, error: null, ...upstreamEcho(upRes) });
       } catch (err) {
         if (auto) await auto.recordError(model, { message: errMsg(err) });
@@ -258,16 +266,21 @@ export async function runSerialTrial(ctx, deps = {}) {
     }
     // 转发闸门（详见 context-forward.js）：被拦即收场，不许换路重试——同一份大上下文换个目标照样撑爆。
     const gc = { res, body, order, handlerCtx, evt, logCall, logError, mark, perf0, stages, done, requested, useAuto, model, exhaustedLocal };
+    // 指定模型 5xx 重试耗尽后：只换 1 个节点（同模型换机器），该节点仍失败就直接收场，不再走宽带。
+    // 429 不在此列——额度按出口 IP 计，等待无意义，仍按原逻辑逐个问节点。
+    // retries=0 是整套功能的逃生阀：连「只换一个节点」一起关，回到旧的 5xx 全节点路径。
+    const pinned5xx = !useAuto && http5xxRetryCfg().retries > 0 && Number(lastErr?.status) >= 500;
+    const peerCtx = pinned5xx ? { ...handlerCtx, singlePeer: true } : handlerCtx;
     if (canForwardPeers) {
       if (!shouldUseGroupForModel(model)) {
         evt("group-skip", { reqId, model, reason: `${groupSkipReason(model)} (peer)` });
       } else {
-        const fr = await forwardOrGuard(() => peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, attemptStartMs: performance.now(), stages, startedAt, plugins, res }), gc);
+        const fr = await forwardOrGuard(() => peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx: peerCtx, evt, logCall, mark, perf0, attemptStartMs: performance.now(), stages, startedAt, plugins, res }), gc);
         if (fr.done) return fr;
         lastErr = fr.lastErr ?? lastErr;
       }
     }
-    if (groups) {
+    if (groups && !pinned5xx) {
       if (!shouldUseGroupForModel(model)) {
         evt("group-skip", { reqId, model, reason: `${groupSkipReason(model)} (broadband)` });
       } else {

package/src/chat-pipeline/upstream-5xx-retry.js

@@ -0,0 +1,72 @@
+// 指定模型撞 5xx 的原地重试（用户口径，2026-10-23）：
+//   5xx → 等 5s → 同模型重拉，连续重试 3 次；仍 5xx 才交给上层换 1 个节点。
+// 为什么不在 auto 里用：auto 的候选是不同模型池，换模型比等待更划算；指定模型的模型不能换，
+// 只能先等上游缓过来，避免「一失败就换节点」把一次故障放大成整组节点同时打上游。
+// 只处理 HTTP 5xx；429（按出口 IP 的额度）与 4xx 一律不等待，交回上层走原有路径。
+const DEFAULTS = Object.freeze({ retries: 3, delayMs: 5000 });
+
+function envIntOrZero(env, name, fallback) {
+  const raw = String(env[name] ?? "").trim();
+  if (raw === "") return fallback;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : fallback;
+}
+
+/** 读配置：次数与间隔都允许 0（0 次 = 关闭；0ms = 不等待）。空串/非法值回落默认。 */
+export function http5xxRetryCfg(env = process.env) {
+  return {
+    retries: envIntOrZero(env, "MSLXDFF_5XX_RETRIES", DEFAULTS.retries),
+    delayMs: envIntOrZero(env, "MSLXDFF_5XX_RETRY_DELAY_MS", DEFAULTS.delayMs),
+  };
+}
+
+export function isHttp5xx(status) {
+  return Number.isInteger(Number(status)) && Number(status) >= 500 && Number(status) <= 599;
+}
+
+function sleep(ms) {
+  return ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+}
+
+// 上一发失败的 5xx 响应体没有被业务消费（判据只读 clone），重试前主动取消，防连接空占。
+function cancelBody(res) {
+  try {
+    const p = res?.body?.cancel?.();
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch { /* 取消失败不影响重试 */ }
+}
+
+/**
+ * 包一层 upstream.chat：指定模型 + 5xx 时原地退避重试。
+ * @param {object} p
+ * @param {() => Promise<any>} p.call 真正发上游（每次调用都重新发）
+ * @param {boolean} p.singleModel 是否指定模型（false=auto，原样返回）
+ * @param {object} [p.cfg] http5xxRetryCfg()
+ * @param {(name:string, data:object)=>void} [p.evt]
+ * @param {string} [p.reqId]
+ * @param {string} [p.model]
+ * @param {() => boolean} [p.isClosed] 客户端是否已断开；断开即停止重试
+ * @returns {Promise<any>} 最后一发响应（可能是 5xx，也可能是成功）
+ */
+export async function chatWith5xxRetry({
+  call,
+  singleModel = false,
+  cfg = http5xxRetryCfg(),
+  evt,
+  reqId,
+  model,
+  isClosed,
+} = {}) {
+  let res = await call();
+  if (!singleModel || !cfg.retries) return res;
+  let retried = 0;
+  while (isHttp5xx(res?.status) && retried < cfg.retries) {
+    if (typeof isClosed === "function" && isClosed()) break;
+    retried += 1;
+    cancelBody(res);
+    try { evt?.("upstream-5xx-retry", { reqId, model, retry: retried, max: cfg.retries, delayMs: cfg.delayMs, status: res.status }); } catch {}
+    await sleep(cfg.delayMs);
+    res = await call();
+  }
+  return res;
+}

package/src/cli/status.js

@@ -229,6 +229,9 @@ export async function printStatus(VERSION) {
       const s = peers.stat(p.url);
       if (s?.latencyMs != null) tags.push(`${s.latencyMs}ms`);
       if (s?.fails) tags.push(`${s.fails} fail(s)`);
+      if (s?.wins) tags.push(`${s.wins} 成功`);
+      const today = s?.days?.[peers.todayKey()];
+      if (today && (today.ok || today.fail)) tags.push(`今天 ${today.ok || 0}成/${today.fail || 0}败`);
       const tag = tags.length ? `  [${tags.join(", ")}]` : "";
       console.log(`  ${p.name || p.url}  ${p.url}${tag}`);
     }

package/src/peers.js

@@ -263,10 +263,39 @@ export function createPeersService({
     return avail[cursor++];
   }
 
+  // ——— 累计计数（排障读数，不参与选路） ———
+  // 为什么单列而不是复用 fails/okAt：那两个是**瞬时**量（成功把 fails 清零、失败把 okAt 晾着），
+  // 用来判"现在好不好用"；而"这个节点一共替我扛了多少次"必须只增不减，否则永远读不出分布。
+  // day 分桶让「今天是不是某节点突然不干活了」一眼可见，历史桶只留 DAY_KEEP 天。
+  const DAY_KEEP = 14;
+
+  function todayKey() {
+    const d = new Date(now());
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+  }
+
+  // 只在 acc（{wins,failTotal,days}）上加计数，不碰 stats[url]：
+  // recordResult 的成功分支会**整体重建**该节点条目，早先那种"先写进 stats 再重建"
+  // 的写法会把刚累加的计数直接抹掉（成功一次 = 归零一次，统计恒为 0）。
+  function accOf(prev) {
+    return { wins: prev.wins || 0, failTotal: prev.failTotal || 0, days: prev.days || {} };
+  }
+
+  function bumpDayInto(acc, field) {
+    const days = { ...acc.days };
+    const k = todayKey();
+    const cur = days[k] || { ok: 0, fail: 0 };
+    days[k] = { ok: cur.ok || 0, fail: cur.fail || 0, [field]: (cur[field] || 0) + 1 };
+    const keys = Object.keys(days).sort();
+    for (const old of keys.slice(0, Math.max(0, keys.length - DAY_KEEP))) delete days[old];
+    acc.days = days;
+  }
+
   // Long-lived error memory: a peer keeps its last-error timestamp until a
   // subsequent success resets it (success clears the failure record) or the
   // error is no longer in the persist store on next load.
-  async function recordError(url, { status, message } = {}) {
+  async function recordError(url, { status, message } = { }) {
     if (!url) return;
     lastErrorAt[url] = now();
     await persistErrors({ ...lastErrorAt });
@@ -287,7 +316,10 @@ export function createPeersService({
   // Outcome of a forwarded request: ok updates the hot-cache (EMA latency,
   // last successful model) and clears the error memory; failures keep the
   // error timestamp so the retry pass can order by recovery time.
-  async function recordResult(url, { ok, latencyMs, model } = {}) {
+  // 累计计数（用户 2026-10-23）：okAt/fails 是**瞬时**状态（成功清 fails、失败清 okAt），
+  // 看不出「这个节点一共替我扛了多少次」。故另立只增不减的 wins/failTotal 与今日分桶，
+  // 用于回答「各节点成功转发次数是否合理」——它是排障读数，不参与选路打分。
+  async function recordResult(url, { ok, latencyMs, model, provisional = false } = {}) {
     if (!url) return;
     if (ok) {
       if (lastErrorAt[url] != null) {
@@ -295,6 +327,9 @@ export function createPeersService({
         await persistErrors({ ...lastErrorAt });
       }
       const prev = stats[url] || {};
+      // ⚠ 成功分支用 next **整体重建**该节点条目（清 fails/streak429/deadFails 等瞬时量），
+      // 所以累计量 wins/failTotal/days 必须经 acc 显式带回去——早先"先写 stats 再重建"的
+      // 写法等于每次成功把累计抹掉（成功一次归零一次，统计恒为 0）。
       const next = {
         okAt: now(),
         latencyMs: prev.latencyMs != null && typeof latencyMs === "number"
@@ -307,11 +342,19 @@ export function createPeersService({
       };
       // 探测死亡标记：请求成功 = 节点活着，冷却窗口立即解除。
       // next 本身不含 probeDeadAt 键，天然清除；这里只兜底确保没有残留。
-      stats[url] = next;
+      const acc = accOf(prev);
+      if (!provisional) {
+        acc.wins += 1;
+        bumpDayInto(acc, "ok");
+      }
+      stats[url] = { ...next, ...acc };
       delete stats[url].probeDeadAt;
     } else {
       const prev = stats[url] || {};
-      stats[url] = { ...prev, fails: (prev.fails || 0) + 1 };
+      const acc = accOf(prev);
+      acc.failTotal += 1;
+      bumpDayInto(acc, "fail");
+      stats[url] = { ...prev, fails: (prev.fails || 0) + 1, ...acc };
     }
     await persistStats({ ...stats });
   }
@@ -341,5 +384,6 @@ export function createPeersService({
     }, isHot, stat, ordered, orderedByLastError, coolingByLastError, available, next,
     standbyChain, nextStandby, isLeaderPeer,
     recordError, recordResult, recordProbeDead, recordProbeOk, errors: () => ({ ...lastErrorAt }), stats: () => ({ ...stats }),
+    todayKey,
   };
 }

package/src/routes/chat/hedge-handler.js

@@ -74,7 +74,8 @@ export async function handleHedge({
       if (hedged.winner === "peer" && hedged.peerInfo) {
         const win = hedged.peerInfo;
         evt("peer-race-win", { reqId: handlerCtx.reqId, model, winPeer: win.peer.url, winTarget: win.target, latencyMs: win.latencyMs, hedged: true, ttfMs: hedged.ttfMs });
-        await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target });
+        // 同 peer-handler：此处只拿到响应头，先记 provisional；送达后（r.handled）再记真正的成功。
+        await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target, provisional: true });
         const bufferedPeerRes = { ...win.res, body: hedged.bufferedBody, headers: win.res.headers, status: win.res.status, _t: win.res._t };
         const pipeline = createPipeline({
           relay,
@@ -107,6 +108,8 @@ export async function handleHedge({
           startedAt,
         });
         if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+        // 真正送达才算这个节点成功转发一次（口径见 peers.js bumpWins 注释）
+        await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target });
         return { handled: true };
       }
     }

package/src/routes/chat/peer-handler.js

@@ -30,10 +30,20 @@ export async function handlePeerRelay({
   const peerErrors = [];
   // 三批共享同一 peer 阶段总预算（同 hedge：旧行为是每批各吃满一次等头超时，串行叠加到 90s+）
   const pctx = peerStageCtx({ ...handlerCtx, peerErrors });
-  const win =
-    (await race(peers.ordered(), pctx)) ||
-    (await race(peers.orderedByLastError(), pctx)) ||
-    (await race(peers.coolingByLastError(), pctx));
+  // singlePeer：指定模型 5xx 重试耗尽后只换 1 个节点，该节点仍失败就交回上层收场。
+  // 选人仍按「组长第一 → 延迟升序」，只是取链头一个；三批候选不叠加，也不进 IPv6 阶段。
+  const singlePeer = handlerCtx?.singlePeer === true;
+  let win = null;
+  if (singlePeer) {
+    pctx.peerMaxPeers = 1;
+    const pick = peers.ordered()[0] || peers.orderedByLastError?.()?.[0] || peers.coolingByLastError?.()?.[0] || null;
+    win = pick ? await race([pick], pctx) : null;
+  } else {
+    win =
+      (await race(peers.ordered(), pctx)) ||
+      (await race(peers.orderedByLastError(), pctx)) ||
+      (await race(peers.coolingByLastError(), pctx));
+  }
   if (!win) {
     evt("peer-race-lose", { reqId: handlerCtx.reqId, model });
     // 组员全失败：把每个组员的真实返回汇总给调用者（否则只剩一个无信息的 429/502）
@@ -44,7 +54,9 @@ export async function handlePeerRelay({
     return { handled: false, lastErr: { model, upstream: null, status: allLimit ? 429 : 502, message: `peers failed: ${detail}` } };
   }
   evt("peer-race-win", { reqId: handlerCtx.reqId, model, winPeer: win.peer.url, winTarget: win.target, latencyMs: win.latencyMs });
-  await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target });
+  // 这里只拿到**响应头**，pipeline 后面还可能超时/空轮。故先记 provisional（只暖热缓存、参与选路），
+  // 真正的成功计数等 pipeline 报 handled:true 再记——否则"收到 200 但零正文"也被算成转发成功。
+  await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target, provisional: true });
 
   const pipeline = createPipeline({
     relay,
@@ -78,5 +90,7 @@ export async function handlePeerRelay({
   });
   // Note: 超时/失败必须把 handled:false 交回上层换候选（丢弃 → 响应永不 end）— 见 .agents/notes/implemented/bug-fix/2026-09-17-relay-first-chunk-gate-real-cancel.md
   if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+  // 真正送达才算这个节点成功转发一次（口径见 peers.js 的 bumpWins 注释）
+  await peers.recordResult(win.peer.url, { ok: true, latencyMs: win.latencyMs, model: win.target });
   return { handled: true };
 }

package/src/routes/chat/via-route-handler.js

@@ -116,8 +116,8 @@ export async function handleViaRoute({
     // 502/429 等可 fallback 到 direct
     return { handled: false, lastErr: { model, upstream: upRes, status, message: msg } };
   }
-  // 成功：记录并走 pipeline 中继（复用 peer 的 streaming 逻辑）
-  try { await peers.recordResult(peer.url, { ok: true, latencyMs: 0, model }); } catch {}
+  // 成功：只拿到响应头，先记 provisional（只暖热缓存）；送达后（r.handled）再记真正的成功
+  try { await peers.recordResult(peer.url, { ok: true, latencyMs: 0, model, provisional: true }); } catch {}
   evt("via-route-win", { reqId: handlerCtx.reqId, peer: peer.url, model });
   const pipeline = createRelayPipeline({
     relay,
@@ -152,5 +152,7 @@ export async function handleViaRoute({
     streamTimeoutMs: LAST_CANDIDATE_TIMEOUT_MS,
   });
   if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+  // 真正送达才算这个节点成功转发一次（口径见 peers.js bumpWins 注释）
+  try { await peers.recordResult(peer.url, { ok: true, latencyMs: 0, model }); } catch {}
   return { handled: true };
 }

package/src/routes/peer-serial.js

@@ -68,8 +68,11 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
   // 两段链：先 IPv4（组长→组员延迟升序），IPv4 全败才进 IPv6（同样组长优先 + hasV6 过滤）。
   // 只保留本次还没试过的。
   const fresh = (list) => list.filter((p) => !tried.has(p.url));
-  const ipv4Chain = filterSlow(fresh(candidates));
-  const ipv6Chain = filterSlow(fresh(v6Candidates));
+  // 指定模型 5xx 场景只要 1 个节点：peerMaxPeers=1 时 IPv4 链截断、IPv6 阶段直接跳过。
+  // 缺省 Infinity = 现有行为（整链 + v6 阶段）。
+  const maxPeers = Number(ctx.peerMaxPeers) > 0 ? Math.floor(Number(ctx.peerMaxPeers)) : Infinity;
+  const ipv4Chain = filterSlow(fresh(candidates)).slice(0, maxPeers);
+  const ipv6Chain = Number.isFinite(maxPeers) ? [] : filterSlow(fresh(v6Candidates));
 
   // —— 预取 + 探针（用户 2026-10-20 口径）——
   // 「某个节点当备选的时候打一个 hi，准备轮到它了也打一个 hi；hi 都回不来就当它不行，直接换。」