mslxdff 0.1.159 → 0.1.161

package/docs/cli_help_mini.md

@@ -17,7 +17,7 @@
 | 无参启动 | `mslxdff` | 已有 daemon 显示 status，否则后台启动 |
 | daemon | `-d` / `--daemon` | 后台启动（只升不降，低版本不覆盖高版本） |
 | 状态 | `-status` / `--status` / `-s` | 打印 daemon/health/port/config、upstream providers（启用/key/baseUrl/allowlist/共享）、models（含 v0.1.59 体检表 avg首字/tps/啰嗦/p95）/群组/failover/recent calls(ts/model/status/dur)/last error/autostart/plugins — 全量聚合体检 |
-| 用量报表 | `-stats` / `--stats` `[--hours N] [--json] [--model <id>]` | 近 N 小时（默认24，上限168）模型用量；默认输出 `Token 用量`（请求/输入/输出/思考/合计）与 `响应性能`（首字/总耗时/加权速度）两张自适应边框表并含合计，长模型 id 不截断；大 token 用 k/M 缩写，`--json` 为精确值。速度按窗口加权 `Σ输出÷Σ生成耗时`，只计成功请求；不含失败请求、`-chat` 直连，也不展开逐请求 via/interrupted/单次 tps；查询超过保留期会警告可能不完整 |
+| 用量报表 | `-stats` / `--stats` `[--hours N] [--json] [--model <id>]` | 近 N 小时（默认24，上限168）模型用量；输出 `Token 用量`（请求/输入/输出/思考/合计）与 `响应性能`（首字/总耗时/加权速度/**首字样本 n/N**）两张自适应边框表并含合计，长 id 不截断；k/M 缩写，`--json` 精确值。**首字 = 本次上游尝试开始 → 网关转发首个真实数据帧**（含排队/建连/判决预读，ADR-0039），`0ms` 有效、非流式不进分子与分母，N=0 显示 `—`；**思考四态**：上报值 / `~` 估算（思考字符÷4）/ `0` 真无 / `—` 未知（不再拿 0 冒充「不思考」）；与 `-status`/`-model stats` 的 EMA 首字**不同源**；速度仍为窗口加权 `Σ输出÷Σ生成耗时`；不含失败请求与 `-chat` 直连 |
 | 日志 | `-log [N]` / `--log [N]` / `-logs N` | 最近 N 条事件 + `timeline.log` 人读时间线；按模型链路日志为 `logDir/<provider>-<model>.log`，逐阶段记录 request/route/upstream/peer/relay/result（安全摘要，不落 prompt/正文/凭据）。**事件面用黑名单**：默认全部可见，只排除 `peer-health`/`heartbeat`/`client-session`/`upstream-probe*`；决定类事件只渲染登记字段，含上游回显 `upstream=`/`account=`/`pick=`/`cooled=` |
 | 调试 | `-debug` / `--debug` | 前台跟随事件流，Ctrl+C 恢复后台 |
 | 插件 | `-plugins` / `--plugins` | 列插件与 hooks |
@@ -80,6 +80,8 @@
 | 上游引擎（默认，ADR-0017） | `MSLXDFF_UPSTREAM_ENGINE`（缺省 `sdk`） | opencode 流式 chat 走 `@ai-sdk/openai-compatible`、`muse-spark*` 走 `@ai-sdk/openai` 的 responses 适配器（响应标记头 `x-mslxdff-upstream-engine: sdk`，复用 legacy 连接池）；通用 OpenAI 兼容族与 cline 同源（供应商级 `MSLXDFF_<ID>_SDK` 未设置即继承本变量）；非流式自动委派 legacy，SDK 不可用回退并告警；显式 `legacy`/关闭词回退原实现 |
 | responses 类模型路由（ADR-0032） | `MSLXDFF_<ID>_RESPONSES_PATH`（缺省 `/responses`） | 通用带 key 供应商遇 responses 类模型（`muse-spark*` 等，判定与 `/v1/models` 的 `capabilities.upstreamApi` 同源）自动改打 `<baseUrl>/responses`（此前固定打 `chatPath` → 上游 503 `Endpoint is unavailable`）；流式走 `@ai-sdk/openai` responses 适配器（含加密思考往返），非流式/SDK 不可用走原生 `chatToResponsesBody` 转换，出参恒 chat 形状；异形上游用该 env 覆盖路径 |
 | SDK 通道 headers 超时 | `MSLXDFF_SDK_HEADERS_TIMEOUT_MS`（缺省 `120000`） | 防 SDK 通道挂死：`doStream` 到点仍未返回响应头即判挂死抛错（由调用方回退/换路），`0`=关闭；错误文案**不含 "timed out"**（避免 cline runChat 按文案重试放大挂死） |
+| 空转重试阶梯 | `MSLXDFF_EMPTY_TURN_RETRY_STEPS`（缺省 `[2000,8000,30000]`）/`MSLXDFF_EMPTY_TURN_RETRIES`/`MSLXDFF_EMPTY_TURN_MAX_WAIT_MS`（缺省 60000） | 上游 200 但零正文（客户端表现为 "The model ended its turn without producing any output"）时同模型重拉：按阶梯逐档 2s→8s→30s 等待，次数缺省跟随档数（`0`=关，空串=未设）；上游报 `retryAfterSeconds` 时本次等待被抬到不低于该窗口（封顶 `MAX_WAIT_MS`，防上游文本把请求挂 1 小时）；`STEPS=[]`=逃生阀回旧式固定 2s×2；非法值告警一次并落回默认阶梯（手滑不清零恢复能力）；事件 `empty-turn-retry` 带 `step/delayMs/waitedMs(累计)` |
+| 空轮留口与终局收场（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` 逐字节回退旧行为 |
 | 免费层形状门禁（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]` 日志 |
 | 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` 回显实际账号 |

package/package.json

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

package/src/autostart.js

@@ -3,6 +3,8 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node
 import { homedir, userInfo } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { daemonDir, readPid } from "./daemon.js";
+import { writeExitMarker } from "./runtime/lifecycle-forensics.js";
 
 const TASK_NAME = "mslxdff";
 const SERVICE_NAME = "mslxdff";
@@ -203,6 +205,7 @@ async function linuxEnable() {
         }
         for (const p of pids) {
           if (p === process.pid) continue;
+          if (p === readPid()) { try { writeExitMarker(daemonDir(), { reason: "autostart-cleanup", prevPid: p, prevVersion: null, byPid: process.pid }); } catch {} }
           try { process.kill(p, "SIGTERM"); killed++; } catch {}
         }
         if (killed) await new Promise((r2) => setTimeout(r2, 400));

package/src/chat-pipeline/auto-race.js

@@ -101,7 +101,7 @@ export async function runAutoRace(ctx, deps = {}) {
       else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
     }
     handlerCtx.model = winModel;
-    const lr = await localRelay({ upRes: best.val.res, model: winModel, body, order: raceModels, idx: best.idx, lastErr: null, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
+    const lr = await localRelay({ upRes: best.val.res, model: winModel, body, order: raceModels, idx: best.idx, lastErr: null, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, attemptStartMs: raceStart, stages, startedAt, plugins, res });
     if (lr.handled) return { done: true };
     if (!lr.lastErr) return { done: true };
   } else {

package/src/chat-pipeline/empty-turn.js

@@ -0,0 +1,119 @@
+// 空转（EMPTY_MODEL_RESPONSE：上游 200 但零正文零工具调用）重试策略：阶梯等待 + 抬额度 + 末次追问。
+// 本模块只做「配置解析 + 载荷改写」的纯决策，不碰 HTTP 与下游响应；执行编排在 serial-trial.js。
+// 拆出原因：serial-trial.js 承载串行换人/hedge/peer/broadband 编排，再加政策面即破 20KB 硬门。
+import { extractRetryAfterSec } from "../routes/stream-scan.js"; // 限流窗口解析：与 relay 的「错误包络暂扣」同源，不复制第二份正则
+
+// 空转重试阶梯（用户定：网络质量差 → 2s→8s→30s；末档对齐实测 retryAfterSeconds=30 的限流窗口）。
+// MSLXDFF_EMPTY_TURN_RETRY_STEPS: JSON 数组(ms)。未设 = 用默认阶梯 [2000,8000,30000]；显式 "[]" = 逃生阀，回旧式固定延迟。
+// MSLXDFF_EMPTY_TURN_RETRIES: 重试上限。未设 = 阶梯档数（默认 3）；0 = 关闭重试（空转直接换候选/终结）。
+// 非法值（语法错/非正数）→ 每进程告警一次并按默认阶梯跑：绝不因配置手滑把重试整体关掉。
+export const DEFAULT_EMPTY_TURN_STEPS = Object.freeze([2000, 8000, 30000]);
+
+let stepsWarned = false;
+function warnBadSteps(raw) {
+  if (stepsWarned) return;
+  stepsWarned = true;
+  try { console.warn(`[mslxdff] MSLXDFF_EMPTY_TURN_RETRY_STEPS 非法(${String(raw).slice(0, 60)}) → 改用默认阶梯 [${DEFAULT_EMPTY_TURN_STEPS.join(",")}]`); } catch {}
+}
+
+export function emptyRetryCfg() {
+  // 空串/纯空白 = 未设（.env 里 `MSLXDFF_EMPTY_TURN_RETRIES=` 是常见手滑，Number("")===0 会把整条恢复静默清零）
+  const rawMax = String(process.env.MSLXDFF_EMPTY_TURN_RETRIES ?? "").trim();
+  const r = rawMax === "" ? NaN : Number(rawMax);
+  const resolveMax = (fallback) => (Number.isInteger(r) && r >= 0 ? r : fallback);
+  const raw = process.env.MSLXDFF_EMPTY_TURN_RETRY_STEPS;
+  const s = raw == null ? "" : String(raw).trim();
+  // 逃生阀：显式空数组 → 旧式固定延迟（MSLXDFF_EMPTY_TURN_RETRY_DELAY_MS，默认 2s、最多 2 次）
+  if (s === "[]") {
+    const d = Number(process.env.MSLXDFF_EMPTY_TURN_RETRY_DELAY_MS);
+    return { max: resolveMax(2), delayMs: Number.isFinite(d) && d >= 0 ? d : 2000, steps: null };
+  }
+  let steps = DEFAULT_EMPTY_TURN_STEPS;
+  if (s !== "") {
+    let parsed = null;
+    try { parsed = JSON.parse(s); } catch { warnBadSteps(s); }
+    if (Array.isArray(parsed) && parsed.length && parsed.every((v) => Number.isFinite(Number(v)) && Number(v) > 0)) {
+      steps = parsed.map(Number);
+    } else if (parsed !== null) {
+      warnBadSteps(s); // 语法过了但形状不对（非数组/空数组元素/含非正数）
+    }
+  }
+  return { max: resolveMax(steps.length), steps };
+}
+
+// retryAfterSeconds 来自上游可控文本，不设顶就会被拿捏：`retryAfterSeconds: 3600` → 单档挂 1 小时；
+// 且 ms 数超过 setTimeout 上限时 Node 会钳成 1ms 并告警 → 对刚限流的上游连开三枪，正是要防的事。
+// 顶只约束「上游能 imposed 多少」；用户自己配的更大阶梯档照办（那是显式意愿），仅保留 setTimeout 硬安全顶。
+const SET_TIMEOUT_CEILING_MS = 2_147_483_647;
+export function emptyTurnMaxWaitMs() {
+  const v = Number(process.env.MSLXDFF_EMPTY_TURN_MAX_WAIT_MS);
+  return Number.isFinite(v) && v > 0 ? Math.min(v, SET_TIMEOUT_CEILING_MS) : 60_000;
+}
+
+// 本次重试实际该等多久：按档取阶梯（超出档数循环复用），再按上游 retryAfterSeconds 抬到不低于该窗口。
+// 限流没到点就重拉等于白烧一发（实测 2s 重拉撞 retryAfterSeconds=30 → 连 2/2 全灭，正是本次改动起因）。
+export function computeNextDelay(stepIndex, steps, lastErr) {
+  const base = Number(process.env.MSLXDFF_EMPTY_TURN_RETRY_DELAY_MS);
+  let delayMs = Number.isFinite(base) && base >= 0 ? base : 2000;
+  if (Array.isArray(steps) && steps.length && Number.isInteger(stepIndex) && stepIndex >= 0) {
+    delayMs = steps[stepIndex % steps.length];
+  }
+  const after = extractRetryAfterSec(lastErr?.message || "");
+  if (after != null) delayMs = Math.max(delayMs, Math.min(after * 1000, emptyTurnMaxWaitMs()));
+  return Math.min(Math.round(delayMs), SET_TIMEOUT_CEILING_MS);
+}
+
+// 空转重试抬额度：思考型模型常把 max_tokens 全花在 reasoning 上（实测 8192 刷满 → 零正文
+// finish_reason=length），同参重拉必然复现 → 重试前把额度翻倍抬到顶，给模型"想完还能说话"的空间。
+// 只加不减、有顶；客户端没设额度时由调用方决定是否兜底发明一次（floor 参数，见 emptyTurnMinRaiseTo；floor=0 回旧口径不发明）。
+// MSLXDFF_EMPTY_TURN_RAISE_TOKENS=0 关闭抬额；默认顶 16384。
+export function emptyRaiseCap() {
+  const c = Number(process.env.MSLXDFF_EMPTY_TURN_RAISE_TOKENS);
+  return Number.isInteger(c) && c >= 0 ? c : 16384;
+}
+
+// 空转重试抬额度（含兜底）：现网三类空轮里最多的是「思考吃满 max_tokens、零正文」
+// （events.log：reasoningChars 10290/22652、wroteFrames 1972/2573、finish=length）。客户端设过额度 → 翻倍抬到 cap；
+// 客户端根本没设额度 → 同参重拉必然复现，故用 MIN_RAISE_TO 兜底发明一次上限（=0 关，回旧口径「不替它发明」）。
+export function emptyTurnMinRaiseTo() {
+  const v = Number(process.env.MSLXDFF_EMPTY_TURN_MIN_RAISE_TO);
+  if (v === 0 || (Number.isFinite(v) && v < 0)) return 0;
+  return Number.isInteger(v) && v > 0 ? v : 16384;
+}
+
+export function withRaisedMaxTokens(payload, cap, floor = 0) {
+  if (!payload || typeof payload !== "object") return payload;
+  for (const key of ["max_tokens", "max_completion_tokens"]) {
+    const cur = Number(payload[key]);
+    if (Number.isFinite(cur) && cur > 0) {
+      if (!cap || cur >= cap) return payload;       // 已到顶：只剩同参重拉（赌偶发空轮）
+      return { ...payload, [key]: Math.min(cap, cur * 2) };
+    }
+  }
+  if (floor) return { ...payload, max_tokens: Math.min(floor, cap || floor) }; // 客户端没设额度：兜底发明一次
+  return payload;
+}
+// 空转追问：最后一次空转重试前追加一句 user 兜底（content 空轮大概率是模型“收尾犹豫”，
+// 追问把它逼出一句“任务完成了”即可终结；前面重试仍原样重拉，防改写正常对话）。
+// MSLXDFF_EMPTY_NUDGE=0 关闭；MSLXDFF_EMPTY_NUDGE_TEXT 改话术。
+export function emptyNudgeCfg() {
+   const off = process.env.MSLXDFF_EMPTY_NUDGE;
+   if (off === "0" || String(off || "").toLowerCase() === "off" || String(off || "").toLowerCase() === "false") return { enabled: false, text: "" };
+   const custom = String(process.env.MSLXDFF_EMPTY_NUDGE_TEXT || "").trim();
+   return { enabled: true, text: custom || "如果你完成任务了，请简短的说：任务完成了。" };
+}
+export function withEmptyNudge(payload, text) {
+   const t = String(text || "").trim();
+   if (!t || !payload || !Array.isArray(payload.messages) || !payload.messages.length) return payload;
+   const last = payload.messages[payload.messages.length - 1];
+   if (last && last.role === "user" && String(last.content || "").includes(t)) return payload;
+   return { ...payload, messages: [...payload.messages, { role: "user", content: t }] };
+}
+
+// 请求级空轮等待预算：阶梯是「每发候选」独立算的，多候选串起来最坏 = N×(2+8+30)，
+// 客户端只是在等一个永远空白的回复。预算封顶「这一次请求最多白等多久」，超限直接收场。
+// MSLXDFF_EMPTY_TURN_BUDGET_MS 覆盖（<=0 或未设 = 默认 45s：够装下一整个阶梯 + 一发换候选）。
+export function emptyTurnBudgetMs() {
+  const v = Number(process.env.MSLXDFF_EMPTY_TURN_BUDGET_MS);
+  return Number.isFinite(v) && v > 0 ? v : 45_000;
+}

package/src/chat-pipeline/index.js

@@ -27,7 +27,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     mark("parsed");
     if (aliasInfo) { try { res?.setHeader?.("x-mslxdff-alias", aliasInfo); } catch {} }
     // mslxdff/ 前缀或 alias 命中时，把 body.model 改写为还原后的模型（与原 gateway 语义一致）
-    const timeline = { direct: [], peers: [], retries: 0, result: null };
+    const timeline = { direct: [], peers: [], retries: 0, retryResult: null, result: null };
     if (aliasInfo && req?.body && req.body.model !== requested) {
       req.body = { ...req.body, model: requested };
     }
@@ -53,6 +53,9 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
         else timeline.peers.push({ peer: entry.peer, ok: false, status: entry.status, message: entry.message || entry.error || "" });
       }
       if (type === "empty-turn-retry") timeline.retries += 1;
+      // 空转重试必须交代结局：只记次数的话，"重试后救回来"和"重试到死"在日志里长得一模一样
+      if (type === "empty-turn-recovered") timeline.retryResult = "ok";
+      if (type === "empty-turn-exhausted") timeline.retryResult = timeline.retryResult || "lost";
       if (type === "result" || (type === "client-response" && !timeline.result)) {
         timeline.result = { status: entry.status, detail: entry.detail || null };
         try { logs?.appendTimeline?.(formatTimeline({ reqId, model: entry.model || requested, ...timeline, totalMs: Date.now() - startedAt })); } catch {}