mslxdff 0.1.34 → 0.1.36

package/bin/mslxdff.js

@@ -804,36 +804,85 @@ if (broadbandGroups().length) {
 }
 
 // Auto-update: periodically check npm for a newer mslxdff and restart.
-// Enable with MSLXDFF_AUTO_UPDATE=1 (hourly) or MSLXDFF_AUTO_UPDATE_MS=<ms>.
-// Uses the same npm view/install path as `mslxdff -update`, but runs inside
-// the daemon so no manual intervention is needed.
+// Default: hourly (no env needed). Disable with MSLXDFF_AUTO_UPDATE=0/off/false.
+// Tuning: MSLXDFF_AUTO_UPDATE=1/true → hourly, or MSLXDFF_AUTO_UPDATE_MS=<ms>.
 const autoUpdateMs = autoUpdateIntervalMs();
+function emitAutoUpdate(type, data = {}) {
+  const entry = { ts: Date.now(), type, ...data };
+  try { bus?.emit(entry); } catch {}
+  try { logs?.appendEvent?.(entry); } catch {}
+  // also to daemon.log for tail
+  const line = `[auto-update] ${type} ${JSON.stringify(data)}`;
+  console.log(line);
+}
 if (autoUpdateMs) {
   console.log(`auto-update enabled: checking every ${Math.round(autoUpdateMs / 60000)}m`);
+  emitAutoUpdate("auto-update-enabled", { intervalMs: autoUpdateMs, current: VERSION });
+  // run once shortly after start (30s) so a newly deployed fix is picked up quickly,
+  // then on the regular interval
+  setTimeout(() => {
+    emitAutoUpdate("auto-update-check", { current: VERSION });
+    checkAndAutoUpdate().catch((err) => {
+      console.log(`auto-update check failed: ${errMsg(err)}`);
+      emitAutoUpdate("auto-update-failed", { error: errMsg(err) });
+    });
+  }, 30_000).unref?.();
   const autoUpdateTimer = setInterval(() => {
-    checkAndAutoUpdate().catch((err) => console.log(`auto-update check failed: ${errMsg(err)}`));
+    emitAutoUpdate("auto-update-check", { current: VERSION });
+    checkAndAutoUpdate().catch((err) => {
+      console.log(`auto-update check failed: ${errMsg(err)}`);
+      emitAutoUpdate("auto-update-failed", { error: errMsg(err) });
+    });
   }, autoUpdateMs);
   autoUpdateTimer.unref();
+} else {
+  console.log(`auto-update disabled (set MSLXDFF_AUTO_UPDATE=1 to enable hourly)`);
+  emitAutoUpdate("auto-update-disabled", { current: VERSION });
 }
 
 async function checkAndAutoUpdate() {
-  const info = await run(npmCmd(), ["view", "mslxdff", "version", "dist-tags.latest"]);
-  if (info.err) throw new Error(info.err.message);
-  const parts = (info.stdout || "").trim().split(/\s+/).filter(Boolean);
-  const latest = parts[parts.length - 1];
-  if (!latest || latest === VERSION) return;
-  // simple semver compare: skip if latest is not newer
-  if (compareSemver(latest, VERSION) <= 0) return;
+  emitAutoUpdate("auto-update-query", { current: VERSION });
+  const info = await run(npmCmd(), ["view", "mslxdff", "dist-tags.latest", "--json"]);
+  if (info.err) {
+    emitAutoUpdate("auto-update-query-failed", { error: info.err.message || String(info.stderr || "").slice(0, 500) });
+    throw new Error(info.err.message || String(info.stderr || "").slice(0, 500));
+  }
+  let latest = "";
+  try {
+    latest = JSON.parse(String(info.stdout || "").trim());
+    if (Array.isArray(latest)) latest = latest[latest.length - 1];
+    latest = String(latest || "").replace(/^v/, "").trim();
+  } catch {
+    const raw = String(info.stdout || "").trim();
+    const m = raw.match(/(\d+\.\d+\.\d+[^\s'"]*)/);
+    latest = m ? m[1] : raw.split(/\s+/).pop()?.replace(/['"]/g, "") || "";
+  }
+  latest = latest.replace(/['"]/g, "").trim();
+  emitAutoUpdate("auto-update-queried", { current: VERSION, latest, stdout: String(info.stdout || "").trim().slice(0, 200) });
+  if (!latest || latest === VERSION) {
+    emitAutoUpdate("auto-update-noop", { current: VERSION, latest });
+    return;
+  }
+  if (compareSemver(latest, VERSION) <= 0) {
+    emitAutoUpdate("auto-update-noop", { current: VERSION, latest, reason: "not newer" });
+    return;
+  }
+  emitAutoUpdate("auto-update-found", { current: VERSION, latest });
   console.log(`auto-update: v${VERSION} -> v${latest}, installing...`);
+  emitAutoUpdate("auto-update-installing", { current: VERSION, latest });
   const up = await run(npmCmd(), ["install", "-g", `mslxdff@${latest}`]);
-  if (up.err) throw new Error(up.err.message);
+  if (up.err) {
+    emitAutoUpdate("auto-update-install-failed", { current: VERSION, latest, error: up.err.message || String(up.stderr || "").slice(0, 500) });
+    throw new Error(up.err.message || String(up.stderr || "").slice(0, 500));
+  }
+  emitAutoUpdate("auto-update-installed", { current: VERSION, latest, stdout: String(up.stdout || "").slice(0, 500) });
   console.log(`auto-update: installed v${latest}, restarting daemon...`);
-  try { stopDaemon(); } catch {}
-  // startDaemon re-reads VERSION from the newly installed package on next boot;
-  // for the current process we just respawn with the new code.
+  emitAutoUpdate("auto-update-restarting", { current: VERSION, latest });
+  try { stopDaemon(); } catch (e) { emitAutoUpdate("auto-update-stop-failed", { error: errMsg(e) }); }
   const newPid = startDaemon([]);
   await waitForHealth(resolvePort(), 8000);
   console.log(`auto-update: restarted as v${latest} (pid ${newPid})`);
+  emitAutoUpdate("auto-update-restarted", { current: VERSION, latest, newPid });
 }
 
 function compareSemver(a, b) {
@@ -906,10 +955,13 @@ function groupSyncIntervalMs() {
 
 function autoUpdateIntervalMs() {
   const raw = process.env.MSLXDFF_AUTO_UPDATE_MS ?? process.env.MSLXDFF_AUTO_UPDATE;
-  if (raw === undefined || raw === null || raw === "") return 0;
-  if (raw === "1" || String(raw).toLowerCase() === "true") return 60 * 60 * 1000;
+  // default: hourly when env not set; explicit 0/off/false disables
+  if (raw === undefined || raw === null || raw === "") return 60 * 60 * 1000;
+  const s = String(raw).trim().toLowerCase();
+  if (s === "0" || s === "off" || s === "false" || s === "no" || s === "disable" || s === "disabled") return 0;
+  if (s === "1" || s === "true" || s === "on" || s === "yes" || s === "enable" || s === "enabled") return 60 * 60 * 1000;
   const n = Number(raw);
-  return Number.isInteger(n) && n > 0 ? n : 0;
+  return Number.isInteger(n) && n > 0 ? n : 60 * 60 * 1000;
 }
 
 function banWindowMs() {
@@ -979,7 +1031,7 @@ Environment:
   MSLXDFF_MAX_HOPS           max peer-forwarding depth (default 3)
   MSLXDFF_BAN_THRESHOLD   failed joins before an ip is banned (default 5)
   MSLXDFF_BAN_WINDOW_MS   ban duration after too many failures (default 48h)
-  MSLXDFF_AUTO_UPDATE   auto-update: 1/true=hourly, or ms interval (0=off)
+  MSLXDFF_AUTO_UPDATE   auto-update: hourly by default, 0/off/false to disable, 1/true or ms
   MSLXDFF_AUTO_UPDATE_MS  same as above, explicit ms (overrides AUTO_UPDATE)
 `);
 }
@@ -1148,6 +1200,32 @@ function fmtEvent(e) {
       return `${head} client abort  ${m(e.model)} total=${fmtDur(e.totalMs)}`;
     case "result":
       return `${head} result        ${e.status} ${m(e.model)} via=${e.via} 响应耗时 ${fmtDur(e.durationMs)}`;
+    case "auto-update-enabled":
+      return `${head} auto-update   enabled every ${Math.round((e.intervalMs||0)/60000)}m current=${e.current}`;
+    case "auto-update-disabled":
+      return `${head} auto-update   disabled current=${e.current}`;
+    case "auto-update-check":
+      return `${head} auto-update   checking current=${e.current}`;
+    case "auto-update-query":
+      return `${head} auto-update   querying npm current=${e.current}`;
+    case "auto-update-queried":
+      return `${head} auto-update   queried current=${e.current} latest=${e.latest} raw=${(e.stdout||"").slice(0,80)}`;
+    case "auto-update-noop":
+      return `${head} auto-update   noop current=${e.current} latest=${e.latest}${e.reason?` reason=${e.reason}`:""}`;
+    case "auto-update-found":
+      return `${head} auto-update   NEW v${e.current} -> v${e.latest} 发现新版本`;
+    case "auto-update-installing":
+      return `${head} auto-update   installing v${e.latest}...`;
+    case "auto-update-installed":
+      return `${head} auto-update   installed v${e.latest}`;
+    case "auto-update-restarting":
+      return `${head} auto-update   restarting daemon to v${e.latest}...`;
+    case "auto-update-restarted":
+      return `${head} auto-update   restarted pid=${e.newPid} v${e.current} -> v${e.latest} 升级完成`;
+    case "auto-update-failed":
+    case "auto-update-query-failed":
+    case "auto-update-install-failed":
+      return `${head} auto-update   failed ${e.type} error=${e.error||""}`;
     default:
       return `${head} ${e?.type || "?"} ${JSON.stringify(e || {})}`;
   }
@@ -1167,22 +1245,35 @@ function npmCmd() {
 }
 
 function run(cmd, args, opts = {}) {
+  const isWin = process.platform === "win32";
   return new Promise((resolve) => {
-    execFile(cmd, args, { timeout: 120_000, ...opts }, (err, stdout, stderr) => resolve({ err, stdout, stderr }));
+    // npm.cmd is a batch file on Windows — execFile needs shell:true to find it via PATHEXT
+    const execOpts = isWin ? { shell: true, windowsHide: true } : {};
+    execFile(cmd, args, { timeout: 120_000, ...execOpts, ...opts }, (err, stdout, stderr) => resolve({ err, stdout, stderr }));
   });
 }
 
 async function updateSelf() {
   console.log(`mslxdff v${VERSION} — checking for updates…`);
-  const info = await run(npmCmd(), ["view", "mslxdff", "version", "dist-tags.latest"]);
+  const info = await run(npmCmd(), ["view", "mslxdff", "dist-tags.latest", "--json"]);
   if (info.err) {
-    console.error(`could not query npm: ${info.err.message}`);
+    console.error(`could not query npm: ${info.err.message || String(info.stderr || "").slice(0, 500)}`);
     process.exit(1);
   }
-  const [version, latest] = (info.stdout || "").trim().split(/\s+/);
+  let latest = "";
+  try {
+    latest = JSON.parse(String(info.stdout || "").trim());
+    if (Array.isArray(latest)) latest = latest[latest.length - 1];
+    latest = String(latest || "").trim();
+  } catch {
+    const m = String(info.stdout || "").trim().match(/(\d+\.\d+\.\d+[^\s'"]*)/);
+    latest = m ? m[1] : "";
+  }
+  latest = String(latest || "").replace(/['"]/g, "").trim();
+  const version = VERSION;
   console.log(`  installed: ${version}`);
-  console.log(`  latest:    ${latest}`);
-  if (version === latest) {
+  console.log(`  latest:    ${latest || "unknown"}`);
+  if (!latest || version === latest || compareSemver(latest, version) <= 0) {
     console.log("already up to date");
     process.exit(0);
   }

package/package.json

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

package/src/auto.js

@@ -132,9 +132,8 @@ export function createAutoSelector({
       slowCooldownMs,
       latencies,
     });
-    if (inCooldown(requested, lastErrorAt, now(), cooldownMs, slowCooldownMs)) {
-      return [...others, requested];
-    }
+    // 显式指定模型：严格优先，永不因冷却被挤到最后（原设计：A deepseek 失败 → B/D deepseek 并发 → 都失败才 fallback）
+    // 冷却仅影响 auto 的择优，不影响指定模型的“很难被更改”语义
     return [requested, ...others];
   }
 

package/src/routes.js

@@ -193,6 +193,102 @@ function notFound(res) {
   return json(res, 404, { error: "Not Found" });
 }
 
+// --- fallback 显式提示（巧妙不破兼容）---
+// 机器可读：x-mslxdff-* headers；人类可读：mslxdff 字段 + SSE comment
+function fallbackReason(lastErr) {
+  if (!lastErr) return "cooldown";
+  const s = Number(lastErr.status);
+  if (s === 429) return "rate_limited";
+  if (lastErr.message && /timeout/i.test(String(lastErr.message))) return "timeout";
+  if (s === 502 || s === 503 || s === 504) return "upstream_error";
+  if (s >= 400) return "upstream_error";
+  return "fallback";
+}
+
+function buildFallbackInfo({ requested, actual, lastErr, via, useAuto, lockModel }) {
+  if (!requested || !actual) return null;
+  const alwaysHeaders = {
+    requested_model: requested,
+    actual_model: actual,
+    via: via || "local",
+  };
+  // auto / lock 仍告知 actual，但不算 fallback
+  if (useAuto || lockModel) {
+    return { ...alwaysHeaders, fallback: false, reason: null, notice: null };
+  }
+  const isFallback = requested !== actual;
+  if (!isFallback) {
+    return { ...alwaysHeaders, fallback: false, reason: null, notice: null };
+  }
+  const reason = fallbackReason(lastErr);
+  const reasonZh = reason === "rate_limited" ? "限流" : reason === "timeout" ? "超时" : reason === "cooldown" ? "冷却中" : "不可用";
+  const notice = `${requested} ${reasonZh}，已由 ${actual} 代答`;
+  return { ...alwaysHeaders, fallback: true, reason, notice };
+}
+
+function applyFallbackHeaders(res, info) {
+  if (!info) return;
+  // 始终告知实际与请求，客户端对比即知
+  if (info.requested_model) res.setHeader("x-mslxdff-requested-model", info.requested_model);
+  if (info.actual_model) res.setHeader("x-mslxdff-actual-model", info.actual_model);
+  if (info.via) res.setHeader("x-mslxdff-via", info.via);
+  if (info.fallback) {
+    res.setHeader("x-mslxdff-fallback", "1");
+    if (info.reason) res.setHeader("x-mslxdff-fallback-reason", info.reason);
+    // 人类 curl 可见
+    if (info.notice) res.setHeader("x-mslxdff-notice", encodeURIComponent(info.notice));
+  }
+}
+
+function enrichNonStreamJson(obj, info) {
+  if (!info || typeof obj !== "object" || obj === null) return obj;
+  // 仅当 fallback 时才注入顶层 mslxdff，避免噪音；但始终可通过 header 拿到 actual
+  if (!info.fallback) return obj;
+  if (obj.mslxdff) return obj;
+  return {
+    ...obj,
+    mslxdff: {
+      fallback: true,
+      requested_model: info.requested_model,
+      actual_model: info.actual_model,
+      reason: info.reason,
+      via: info.via,
+      notice: info.notice,
+    },
+  };
+}
+
+function enrichSseChunkText(text, info) {
+  if (!info?.fallback) return text;
+  // 行级注入：对每行 data: {json} 尝试注入 mslxdff
+  const lines = text.split("\n");
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = /^data:\s*(\{.*\})\s*$/.exec(line);
+    if (!m) continue;
+    try {
+      const obj = JSON.parse(m[1]);
+      if (obj && typeof obj === "object" && !obj.mslxdff) {
+        obj.mslxdff = {
+          fallback: true,
+          requested_model: info.requested_model,
+          actual_model: info.actual_model,
+          reason: info.reason,
+          via: info.via,
+          notice: info.notice,
+        };
+        lines[i] = `data: ${JSON.stringify(obj)}`;
+        changed = true;
+        break; // 仅注入首个 JSON 行
+      }
+    } catch {
+      continue;
+    }
+  }
+  return changed ? lines.join("\n") : text;
+}
+
 function readBody(req) {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -211,11 +307,12 @@ function readBody(req) {
 // Relay an upstream response to the client. Returns { status, ttfMs, aborted, interrupted, detail }
 // detail carries byte/chunk/sawDone diagnostics so a truncated deep-think
 // stream can be told apart from a clean EOF vs our stall/max vs client abort.
-async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS } = {}) {
+async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS, fallback } = {}) {
   const t0 = performance.now();
   const contentType = upRes.headers.get("content-type") || "";
   const isStream = Boolean(body?.stream) || contentType.includes("text/event-stream");
   res.statusCode = upRes.status;
+  if (fallback) applyFallbackHeaders(res, fallback);
 
   let ttf = null;
   let interrupted = false;
@@ -246,6 +343,13 @@ async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, stream
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
+    // SSE 注释：curl -N 可见，EventSource/SDK 自动忽略，不污染 content
+    if (fallback?.fallback) {
+      try {
+        res.write(`: mslxdff fallback ${fallback.requested_model} -> ${fallback.actual_model} (${fallback.reason})\n`);
+        res.write(`: notice ${fallback.notice}\n\n`);
+      } catch {}
+    }
     if (upRes.body) {
       let first = true;
       let wroteAny = false;
@@ -301,10 +405,24 @@ async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, stream
             onFirstChunk?.(ttf);
             if (firstTimer) { clearTimeout(firstTimer); firstTimer = null; }
           }
+          // 首块注入 mslxdff 字段（仅 fallback 时），SDK 解析 JSON 可直接发现
+          let outChunk = chunk;
+          if (first === false && fallback?.fallback && wroteAny === false) {
+            try {
+              let txt = "";
+              if (Buffer.isBuffer(chunk)) txt = chunk.toString("utf8");
+              else if (chunk instanceof Uint8Array) txt = Buffer.from(chunk).toString("utf8");
+              else if (typeof chunk === "string") txt = chunk;
+              if (txt.includes("data:")) {
+                const enriched = enrichSseChunkText(txt, fallback);
+                if (enriched !== txt) outChunk = Buffer.from(enriched, "utf8");
+              }
+            } catch {}
+          }
           wroteAny = true;
           detail.wroteChunks += 1;
-          detail.wroteBytes += len;
-          res.write(chunk);
+          detail.wroteBytes += Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
+          res.write(outChunk);
           armStall(); // no-op when STALL_TIMEOUT_MS=0; scoring uses SCORE_STALL_MS gap above
         }
         if (!detail.exitReason) detail.exitReason = "normal";
@@ -346,7 +464,9 @@ async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, stream
   detail.receivedBytes = Buffer.byteLength(text);
   detail.exitReason = "normal-non-stream";
   try {
-    json(res, upRes.status, JSON.parse(text));
+    const parsed = JSON.parse(text);
+    const enriched = enrichNonStreamJson(parsed, fallback);
+    json(res, upRes.status, enriched);
   } catch {
     res.statusCode = upRes.status;
     res.setHeader("Content-Type", contentType || "text/plain");
@@ -428,17 +548,35 @@ async function forwardToPeer(peer, body, model, hops) {
   }
 }
 
-// Resolve the model a peer should serve for this request: reuse its hot-cache
-// model only when it matches the requested one; otherwise probe /v1/models/status
-// and prefer the requested model, falling back to the peer's first healthy one.
+// Resolve the model a peer should serve for this request.
+// 原设计严格语义：显式指定模型时，永远用该模型去试 peer，不因 peer 的本地 healthy 状态而偷换成 hy3。
+// 只有 auto 模式才走 healthy 探测与择优。
 // Returns { peer, target } or null when the peer is unusable.
 async function resolvePeerTarget(ctx, peer) {
   const prevModel = ctx.peers.stat(peer.url)?.model;
   const hot = ctx.peers.isHot(peer.url) && prevModel === ctx.model;
   if (hot) return { peer, target: prevModel };
+  // 显式模型：严格用请求模型，不做 healthy 偷换（B/D 必须以 deepseek 去试，失败才算该模型在该 peer 不可用）
+  const isExplicit = !!ctx.model && !isAutoModel(ctx.model);
+  if (isExplicit) {
+    // 仅做可达性探测：轻量 ping /v1/models/status 判断 peer 是否活着，不因模型状态过滤
+    const healthy = await peerHealthyModels(peer);
+    if (!healthy.length) {
+      // 无法探活也仍尝试：让 forward 去试，失败会由 race 逻辑记错；但为保持原有“全不健康则跳过”行为，仍标记
+      // 这里改为：即使 healthy 为空，也返回 target=ctx.model，让上游去判 429，而不是直接丢弃 peer
+      // 只有当 fetch 本身异常（healthy=[] 来自网络错）才视为 peer 不可用，需区分
+      // peerHealthyModels 在网络错时返回 []，此时应视为 peer 不可用
+      // 我们通过再次轻量探测区分：若 peer 完全不可达，healthy=[] 且 peer 曾无成功记录，则跳过
+      // 简化：若 healthy 为空，直接尝试目标模型，失败再记错（更符合“严格”）
+      ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0, strict: true });
+      return { peer, target: ctx.model };
+    }
+    ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length, strict: true });
+    return { peer, target: ctx.model };
+  }
+  // auto 模式：走原有择优逻辑
   const healthy = await peerHealthyModels(peer);
   if (!healthy.length) {
-    // peer unreachable or every model unhealthy — mark it and move on
     await ctx.peers.recordError(peer.url);
     ctx.logError(ctx.model, 0, `peer ${peer.url} has no healthy models`);
     ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0 });
@@ -647,8 +785,11 @@ const ROUTES = [
         }
         if (upRes) {
           logCall(model, upRes.status);
-          evt("relay-start", { reqId, model, via: "local", isStream: Boolean(body.stream) });
+          const fallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "local", useAuto, lockModel });
+          if (fallback?.fallback) evt("fallback-notice", { reqId, requested, actual: model, reason: fallback.reason, notice: fallback.notice, via: "local" });
+          evt("relay-start", { reqId, model, via: "local", isStream: Boolean(body.stream), fallback });
           const out = await relay(res, upRes, body, {
+            fallback,
             onFirstChunk: (delta) => {
               mark(`ttf-${model}`);
               evt("relay-first-chunk", { reqId, model, ttfMs: delta });
@@ -718,8 +859,11 @@ const ROUTES = [
             evt("peer-race-win", { 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 });
             logCall(win.target, win.res.status);
-            evt("relay-start", { reqId, model: win.target, via: "peer", isStream: Boolean(body.stream) });
+            const peerFallback = buildFallbackInfo({ requested, actual: win.target, lastErr, via: "peer", useAuto, lockModel });
+            if (peerFallback?.fallback) evt("fallback-notice", { reqId, requested, actual: win.target, reason: peerFallback.reason, notice: peerFallback.notice, via: "peer" });
+            evt("relay-start", { reqId, model: win.target, via: "peer", isStream: Boolean(body.stream), fallback: peerFallback });
             const out = await relay(res, win.res, body, {
+              fallback: peerFallback,
               onFirstChunk: (d) => mark(`ttf-peer-${win.target}`),
               onDownstreamAbort: () => evt("client-abort", { reqId, model: win.target, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
             });
@@ -746,8 +890,11 @@ const ROUTES = [
             const isResponse = bb.result && typeof bb.result.status === "number" && typeof bb.result.headers?.get === "function";
             if (isResponse) {
               // streaming response from leader's forward (which waited for broadband)
-              evt("relay-start", { reqId, model, via: "broadband", target: bb.target, group: bb.group });
+              const bbFallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "broadband", useAuto, lockModel });
+              if (bbFallback?.fallback) evt("fallback-notice", { reqId, requested, actual: model, reason: bbFallback.reason, notice: bbFallback.notice, via: "broadband" });
+              evt("relay-start", { reqId, model, via: "broadband", target: bb.target, group: bb.group, fallback: bbFallback });
               const out = await relay(res, bb.result, body, {
+                fallback: bbFallback,
                 onFirstChunk: (d) => mark(`ttf-bb-${model}`),
                 onDownstreamAbort: () => evt("client-abort", { reqId, model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
               });
@@ -779,8 +926,11 @@ const ROUTES = [
                   return null;
                 })(),
               };
-              evt("relay-start", { reqId, model, via: "broadband-local", target: bb.target, group: bb.group });
+              const bbLocalFallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "broadband", useAuto, lockModel });
+              if (bbLocalFallback?.fallback) evt("fallback-notice", { reqId, requested, actual: model, reason: bbLocalFallback.reason, notice: bbLocalFallback.notice, via: "broadband" });
+              evt("relay-start", { reqId, model, via: "broadband-local", target: bb.target, group: bb.group, fallback: bbLocalFallback });
               const out = await relay(res, fakeRes, body, {
+                fallback: bbLocalFallback,
                 onFirstChunk: (d) => mark(`ttf-bb-${model}`),
                 onDownstreamAbort: () => evt("client-abort", { reqId, model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
               });