mslxdff 0.1.187 → 0.1.188

package/src/routes/hedge.js

@@ -1,255 +1,253 @@
-function hedgeDelayMs() {
-  const raw = process.env.MSLXDFF_HEDGE_DELAY_MS;
-  if (raw === undefined || raw === null || raw === "") return 1000;
-  const s = String(raw).trim().toLowerCase();
-  if (s === "0" || s === "off" || s === "false" || s === "no" || s === "disable" || s === "disabled") return 0;
-  const n = Number(s);
-  if (Number.isInteger(n) && n >= 0) return n;
-  return 1000;
-}
-
-function isFastFailStatus(status) {
-  const s = Number(status);
-  return s === 429 || s === 502 || s === 503 || s === 504;
-}
-
-function shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) {
-  if (!isStream) return false;
-  if (!canForwardPeers) return false;
-  if (!hasPeers) return false;
-  if (!d || d <= 0) return false;
-  // 供应商级禁对冲在 shouldUseGroupForModel 层收敛（workbuddy local-only 硬禁，见 ADR-0015）；
-  // 这里只留 muse-spark 特判：走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
-  if (String(model || "").toLowerCase().startsWith("muse-spark")) return false;
-  return true;
-}
-
-function withTimeout(promise, ms) {
-  if (ms <= 0) return promise;
-  let timer;
-  const timeout = new Promise((_, rej) => {
-    timer = setTimeout(() => rej(new Error("hedge-timeout")), ms);
-  });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-
-function makeBufferedBody(chunk, handle, kind) {
-  if (kind === "web") {
-    const reader = handle;
-    return (async function* () {
-      yield chunk;
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        yield value;
-      }
-    })();
-  }
-  const it = handle;
-  return (async function* () {
-    yield chunk;
-    for await (const c of { [Symbol.asyncIterator]: () => it }) {
-      yield c;
-    }
-  })();
-}
-
-async function cancelBody(body, handle, kind) {
-  try {
-    if (body && typeof body.cancel === "function") await body.cancel().catch(() => {});
-    if (kind === "web" && handle && typeof handle.cancel === "function") await handle.cancel().catch(() => {});
-    else if (handle && typeof handle.return === "function") await handle.return().catch(() => {});
-  } catch {}
-}
-
-function getFirstChunkPromise(body) {
-  if (!body) throw new Error("no-body");
-  if (typeof body.getReader === "function") {
-    const reader = body.getReader();
-    const p = reader.read().then((r) => {
-      if (r.done) throw new Error("no-chunk");
-      return { chunk: r.value, handle: reader, kind: "web", reader };
-    });
-    return { promise: p, handle: reader, kind: "web" };
-  }
-  const it = body[Symbol.asyncIterator]?.();
-  if (!it) throw new Error("no-iterator");
-  const p = it.next().then((r) => {
-    if (r.done) throw new Error("no-chunk");
-    return { chunk: r.value, handle: it, kind: "node", it };
-  });
-  return { promise: p, handle: it, kind: "node" };
-}
-
-export { hedgeDelayMs, isFastFailStatus, shouldHedge };
-
-export async function hedgedFirstChunkRace({
-  localUpRes,
-  peers,
-  handlerCtx,
-  hedgeDelayMs: hedgeDelay,
-  evt,
-}) {
-  const t0 = Date.now();
-  const debugHedge = process.env.MSLXDFF_DEBUG === "1";
-  if (debugHedge) try { console.log(`[hedge] start delay=${hedgeDelay} peers=${peers?.ordered?.().length ?? 0} hasBody=${Boolean(localUpRes.body)} getReader=${typeof localUpRes.body?.getReader}`); } catch {}
-  let localHandle = null;
-  let localKind = null;
-  let localBody = localUpRes.body;
-  let localFirstPromise = null;
-  try {
-    const { promise, handle, kind } = getFirstChunkPromise(localBody);
-    localHandle = handle;
-    localKind = kind;
-    localFirstPromise = promise;
-  } catch (e) {
-    evt?.("hedge-trigger", { reason: "fast-fail-no-body", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0 });
-    return { needsPeer: true };
-  }
-
-  try {
-    const local = await withTimeout(localFirstPromise, hedgeDelay);
-    if (debugHedge) try { console.log(`[hedge] local win before hedge ttf=${Date.now() - t0}ms`); } catch {}
-    evt?.("hedge-win", { via: "local", reason: "no-hedge-needed", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay });
-    return {
-      winner: "local",
-      upRes: localUpRes,
-      bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
-      peerInfo: null,
-      ttfMs: Date.now() - t0,
-      hedged: false,
-    };
-  } catch (err) {
-    if (err.message !== "hedge-timeout") {
-      if (debugHedge) try { console.log(`[hedge] local fast-fail ${err.message}`); } catch {}
-      evt?.("hedge-trigger", { reason: "fast-fail", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0, error: String(err.message).slice(0, 200) });
-      return { needsPeer: true, localError: err };
-    }
-  }
-
-  if (debugHedge) try { console.log(`[hedge] trigger slow hedge after ${hedgeDelay}ms`); } catch {}
-  evt?.("hedge-trigger", { reason: "slow", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0 });
-
-  const { racePeerCandidates } = await import("./peers.js");
-  const candidates = handlerCtx.peers.ordered();
-  let peerWin = null;
-  try {
-    peerWin =
-      (await racePeerCandidates(candidates, handlerCtx)) ||
-      (await racePeerCandidates(handlerCtx.peers.orderedByLastError(), handlerCtx)) ||
-      (await racePeerCandidates(handlerCtx.peers.coolingByLastError(), handlerCtx));
-  } catch (_) {
-    peerWin = null;
-  }
-  if (debugHedge) try { console.log(`[hedge] peerWin=${peerWin ? peerWin.peer.url : "none"}`); } catch {}
-
-  if (!peerWin) {
-    const remaining = 25_000 - hedgeDelay;
-    try {
-      const local = await withTimeout(localFirstPromise, Math.max(0, remaining));
-      evt?.("hedge-win", { via: "local", reason: "peer-miss", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay });
-      if (debugHedge) try { console.log(`[hedge] local win after peer miss`); } catch {}
-      return {
-        winner: "local",
-        upRes: localUpRes,
-        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
-        peerInfo: null,
-        ttfMs: Date.now() - t0,
-        hedged: true,
-      };
-    } catch (e) {
-      evt?.("hedge-lose", { via: "local", reason: "both-fail", error: String(e.message).slice(0, 200) });
-      await cancelBody(localBody, localHandle, localKind);
-      return null;
-    }
-  }
-
-  let peerHandle = null;
-  let peerKind = null;
-  let peerBody = peerWin.res.body;
-  let peerFirstPromise = null;
-  try {
-    const { promise, handle, kind } = getFirstChunkPromise(peerBody);
-    peerHandle = handle;
-    peerKind = kind;
-    peerFirstPromise = promise.then((r) => ({ ...r, peer: peerWin }));
-  } catch (e) {
-    evt?.("hedge-lose", { via: "peer", reason: "peer-no-body", error: String(e.message).slice(0, 200) });
-    try {
-      const local = await localFirstPromise;
-      return {
-        winner: "local",
-        upRes: localUpRes,
-        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
-        peerInfo: null,
-        ttfMs: Date.now() - t0,
-        hedged: true,
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  try {
-    const winner = await Promise.race([
-      localFirstPromise.then((local) => ({ via: "local", data: { ...local, kind: localKind, handle: localHandle } })),
-      peerFirstPromise.then((peer) => ({ via: "peer", data: peer })),
-    ]);
-    if (debugHedge) try { console.log(`[hedge] race winner=${winner.via}`); } catch {}
-
-    if (winner.via === "local") {
-      await cancelBody(peerBody, peerHandle, peerKind);
-      evt?.("hedge-win", { via: "local", reason: "race", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay, peer: peerWin.peer.url });
-      evt?.("hedge-loser-cancel", { via: "peer", peer: peerWin.peer.url });
-      return {
-        winner: "local",
-        upRes: localUpRes,
-        bufferedBody: makeBufferedBody(winner.data.chunk, winner.data.handle, winner.data.kind),
-        peerInfo: null,
-        ttfMs: Date.now() - t0,
-        hedged: true,
-      };
-    } else {
-      await cancelBody(localBody, localHandle, localKind);
-      evt?.("hedge-win", { via: "peer", reason: "race", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay, peer: winner.data.peer.peer.url });
-      evt?.("hedge-loser-cancel", { via: "local" });
-      return {
-        winner: "peer",
-        upRes: winner.data.peer.res,
-        bufferedBody: makeBufferedBody(winner.data.chunk, winner.data.handle, winner.data.kind),
-        peerInfo: winner.data.peer,
-        ttfMs: Date.now() - t0,
-        hedged: true,
-      };
-    }
-  } catch (e) {
-    if (debugHedge) try { console.log(`[hedge] race both failed, fallback sequential`); } catch {}
-    try {
-      const local = await localFirstPromise;
-      await cancelBody(peerBody, peerHandle, peerKind);
-      return {
-        winner: "local",
-        upRes: localUpRes,
-        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
-        peerInfo: null,
-        ttfMs: Date.now() - t0,
-        hedged: true,
-      };
-    } catch {
-      try {
-        const peer = await peerFirstPromise;
-        await cancelBody(localBody, localHandle, localKind);
-        return {
-          winner: "peer",
-          upRes: peer.peer.res,
-          bufferedBody: makeBufferedBody(peer.chunk, peer.handle, peer.kind),
-          peerInfo: peer.peer,
-          ttfMs: Date.now() - t0,
-          hedged: true,
-        };
-      } catch {
-        return null;
-      }
-    }
-  }
-}
+function hedgeDelayMs() {
+  const raw = process.env.MSLXDFF_HEDGE_DELAY_MS;
+  if (raw === undefined || raw === null || raw === "") return 1000;
+  const s = String(raw).trim().toLowerCase();
+  if (s === "0" || s === "off" || s === "false" || s === "no" || s === "disable" || s === "disabled") return 0;
+  const n = Number(s);
+  if (Number.isInteger(n) && n >= 0) return n;
+  return 1000;
+}
+
+function shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) {
+  if (!isStream) return false;
+  if (!canForwardPeers) return false;
+  if (!hasPeers) return false;
+  if (!d || d <= 0) return false;
+  // 供应商级禁对冲在 shouldUseGroupForModel 层收敛（workbuddy local-only 硬禁，见 ADR-0015）；
+  // 这里只留 muse-spark 特判：走 /responses 流式（event: 包装 + 加密 reasoning），组员旧版无此整形且聚合 JSON 带错 header，必抢赢本地慢首块，需本地直出
+  if (String(model || "").toLowerCase().startsWith("muse-spark")) return false;
+  return true;
+}
+
+function withTimeout(promise, ms) {
+  if (ms <= 0) return promise;
+  let timer;
+  const timeout = new Promise((_, rej) => {
+    timer = setTimeout(() => rej(new Error("hedge-timeout")), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+function makeBufferedBody(chunk, handle, kind) {
+  if (kind === "web") {
+    const reader = handle;
+    return (async function* () {
+      yield chunk;
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        yield value;
+      }
+    })();
+  }
+  const it = handle;
+  return (async function* () {
+    yield chunk;
+    for await (const c of { [Symbol.asyncIterator]: () => it }) {
+      yield c;
+    }
+  })();
+}
+
+async function cancelBody(body, handle, kind) {
+  try {
+    if (body && typeof body.cancel === "function") await body.cancel().catch(() => {});
+    if (kind === "web" && handle && typeof handle.cancel === "function") await handle.cancel().catch(() => {});
+    else if (handle && typeof handle.return === "function") await handle.return().catch(() => {});
+  } catch {}
+}
+
+function getFirstChunkPromise(body) {
+  if (!body) throw new Error("no-body");
+  if (typeof body.getReader === "function") {
+    const reader = body.getReader();
+    const p = reader.read().then((r) => {
+      if (r.done) throw new Error("no-chunk");
+      return { chunk: r.value, handle: reader, kind: "web", reader };
+    });
+    return { promise: p, handle: reader, kind: "web" };
+  }
+  const it = body[Symbol.asyncIterator]?.();
+  if (!it) throw new Error("no-iterator");
+  const p = it.next().then((r) => {
+    if (r.done) throw new Error("no-chunk");
+    return { chunk: r.value, handle: it, kind: "node", it };
+  });
+  return { promise: p, handle: it, kind: "node" };
+}
+
+export { hedgeDelayMs, shouldHedge };
+
+export async function hedgedFirstChunkRace({
+  localUpRes,
+  peers,
+  handlerCtx,
+  hedgeDelayMs: hedgeDelay,
+  evt,
+}) {
+  const t0 = Date.now();
+  const debugHedge = process.env.MSLXDFF_DEBUG === "1";
+  if (debugHedge) try { console.log(`[hedge] start delay=${hedgeDelay} peers=${peers?.ordered?.().length ?? 0} hasBody=${Boolean(localUpRes.body)} getReader=${typeof localUpRes.body?.getReader}`); } catch {}
+  let localHandle = null;
+  let localKind = null;
+  let localBody = localUpRes.body;
+  let localFirstPromise = null;
+  try {
+    const { promise, handle, kind } = getFirstChunkPromise(localBody);
+    localHandle = handle;
+    localKind = kind;
+    localFirstPromise = promise;
+  } catch (e) {
+    evt?.("hedge-trigger", { reason: "fast-fail-no-body", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0 });
+    return { needsPeer: true };
+  }
+
+  try {
+    const local = await withTimeout(localFirstPromise, hedgeDelay);
+    if (debugHedge) try { console.log(`[hedge] local win before hedge ttf=${Date.now() - t0}ms`); } catch {}
+    evt?.("hedge-win", { via: "local", reason: "no-hedge-needed", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay });
+    return {
+      winner: "local",
+      upRes: localUpRes,
+      bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
+      peerInfo: null,
+      ttfMs: Date.now() - t0,
+      hedged: false,
+    };
+  } catch (err) {
+    if (err.message !== "hedge-timeout") {
+      if (debugHedge) try { console.log(`[hedge] local fast-fail ${err.message}`); } catch {}
+      evt?.("hedge-trigger", { reason: "fast-fail", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0, error: String(err.message).slice(0, 200) });
+      return { needsPeer: true, localError: err };
+    }
+  }
+
+  if (debugHedge) try { console.log(`[hedge] trigger slow hedge after ${hedgeDelay}ms`); } catch {}
+  evt?.("hedge-trigger", { reason: "slow", hedgeDelayMs: hedgeDelay, triggerAtMs: Date.now() - t0 });
+
+  const { racePeerCandidates, peerStageCtx } = await import("./peers.js");
+  const candidates = handlerCtx.peers.ordered();
+  // 三批共享同一「peer 阶段总预算」（peerStageCtx 设 deadline，racePeerCandidates 按剩余量裁剪等待）：
+  // 旧行为是每批各吃满一次等头超时，串行叠加可到 90s+（实测 peer 阶段 63s、total 137s）。
+  const stage = peerStageCtx(handlerCtx);
+  let peerWin = null;
+  try {
+    peerWin =
+      (await racePeerCandidates(candidates, stage)) ||
+      (await racePeerCandidates(stage.peers.orderedByLastError(), stage)) ||
+      (await racePeerCandidates(stage.peers.coolingByLastError(), stage));
+  } catch (_) {
+    peerWin = null;
+  }
+  if (debugHedge) try { console.log(`[hedge] peerWin=${peerWin ? peerWin.peer.url : "none"}`); } catch {}
+
+  if (!peerWin) {
+    const remaining = 25_000 - hedgeDelay;
+    try {
+      const local = await withTimeout(localFirstPromise, Math.max(0, remaining));
+      evt?.("hedge-win", { via: "local", reason: "peer-miss", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay });
+      if (debugHedge) try { console.log(`[hedge] local win after peer miss`); } catch {}
+      return {
+        winner: "local",
+        upRes: localUpRes,
+        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
+        peerInfo: null,
+        ttfMs: Date.now() - t0,
+        hedged: true,
+      };
+    } catch (e) {
+      evt?.("hedge-lose", { via: "local", reason: "both-fail", error: String(e.message).slice(0, 200) });
+      await cancelBody(localBody, localHandle, localKind);
+      return null;
+    }
+  }
+
+  let peerHandle = null;
+  let peerKind = null;
+  let peerBody = peerWin.res.body;
+  let peerFirstPromise = null;
+  try {
+    const { promise, handle, kind } = getFirstChunkPromise(peerBody);
+    peerHandle = handle;
+    peerKind = kind;
+    peerFirstPromise = promise.then((r) => ({ ...r, peer: peerWin }));
+  } catch (e) {
+    evt?.("hedge-lose", { via: "peer", reason: "peer-no-body", error: String(e.message).slice(0, 200) });
+    try {
+      const local = await localFirstPromise;
+      return {
+        winner: "local",
+        upRes: localUpRes,
+        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
+        peerInfo: null,
+        ttfMs: Date.now() - t0,
+        hedged: true,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  try {
+    const winner = await Promise.race([
+      localFirstPromise.then((local) => ({ via: "local", data: { ...local, kind: localKind, handle: localHandle } })),
+      peerFirstPromise.then((peer) => ({ via: "peer", data: peer })),
+    ]);
+    if (debugHedge) try { console.log(`[hedge] race winner=${winner.via}`); } catch {}
+
+    if (winner.via === "local") {
+      await cancelBody(peerBody, peerHandle, peerKind);
+      evt?.("hedge-win", { via: "local", reason: "race", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay, peer: peerWin.peer.url });
+      evt?.("hedge-loser-cancel", { via: "peer", peer: peerWin.peer.url });
+      return {
+        winner: "local",
+        upRes: localUpRes,
+        bufferedBody: makeBufferedBody(winner.data.chunk, winner.data.handle, winner.data.kind),
+        peerInfo: null,
+        ttfMs: Date.now() - t0,
+        hedged: true,
+      };
+    } else {
+      await cancelBody(localBody, localHandle, localKind);
+      evt?.("hedge-win", { via: "peer", reason: "race", ttfMs: Date.now() - t0, hedgeDelayMs: hedgeDelay, peer: winner.data.peer.peer.url });
+      evt?.("hedge-loser-cancel", { via: "local" });
+      return {
+        winner: "peer",
+        upRes: winner.data.peer.res,
+        bufferedBody: makeBufferedBody(winner.data.chunk, winner.data.handle, winner.data.kind),
+        peerInfo: winner.data.peer,
+        ttfMs: Date.now() - t0,
+        hedged: true,
+      };
+    }
+  } catch (e) {
+    if (debugHedge) try { console.log(`[hedge] race both failed, fallback sequential`); } catch {}
+    try {
+      const local = await localFirstPromise;
+      await cancelBody(peerBody, peerHandle, peerKind);
+      return {
+        winner: "local",
+        upRes: localUpRes,
+        bufferedBody: makeBufferedBody(local.chunk, local.handle, local.kind),
+        peerInfo: null,
+        ttfMs: Date.now() - t0,
+        hedged: true,
+      };
+    } catch {
+      try {
+        const peer = await peerFirstPromise;
+        await cancelBody(localBody, localHandle, localKind);
+        return {
+          winner: "peer",
+          upRes: peer.peer.res,
+          bufferedBody: makeBufferedBody(peer.chunk, peer.handle, peer.kind),
+          peerInfo: peer.peer,
+          ttfMs: Date.now() - t0,
+          hedged: true,
+        };
+      } catch {
+        return null;
+      }
+    }
+  }
+}

package/src/routes/index.js

@@ -1,4 +1,5 @@
 import { timingSafeEqual, createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { DEFAULT_MAX_HOPS } from "../peers.js";
 import { json, notFound, authorized } from "./helpers.js";
 import { chatHandler } from "./chat.js";
@@ -9,10 +10,22 @@ import { relayHandler } from "./relay.js";
 import { responsesHandler } from "./responses-route.js";
 import { messagesHandler, countTokensHandler } from "./messages-route.js";
 
-export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus, plugins }) {
+export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus, plugins, version = null }) {
+  // /health 要报版本：调用方（waitForHealth）拿它判断「应答的是不是刚起的那个」。
+  // 未显式传入时读 package.json 兜底 —— 测试直接 createRouter() 也能拿到真版本，不必逐个补参数。
+  const healthVersion = (() => {
+    if (version) return version;
+    try { return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version ?? null; } catch { return null; }
+  })();
   return async function router(req, res) {
     const method = req.method || "GET";
     const path = (req.url || "").split("?")[0];
+    // pid/version 不是装饰：调用方（`-restart`/`-port`/`-update` 的 waitForHealth）需要它判断
+    // 「应答的到底是不是我刚起的那个」。只回 {status:"ok"} 时，旧 daemon 占着端口也能让健康检查通过，
+    // 于是「新进程 EADDRINUSE 秒退、旧版仍在服务」会被谎报成重启成功（BUG-29）。
+    if (method === "GET" && path === "/health") {
+      return json(res, 200, { status: "ok", pid: process.pid, version: healthVersion });
+    }
     // dynamic provider models route: GET /v1/providers/:id/models
     if (method === "GET" && /^\/v1\/providers\/[^/]+\/models\/?$/.test(path)) {
       if (!authorized(req, token)) {
@@ -34,11 +47,6 @@ export function createRouter({ token, upstream, models, auto, logs, peers, maxHo
 }
 
 const ROUTES = [
-  {
-    method: "GET",
-    path: "/health",
-    handler: ({ res }) => json(res, 200, { status: "ok" }),
-  },
   {
     method: "POST",
     path: "/v1/chat/completions",