mslxdff 0.1.234 → 0.1.235

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.235",
   "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/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）

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 都回不来就当它不行，直接换。」