mslxdff 0.1.45 → 0.1.55

package/src/models.js

@@ -1,128 +1,128 @@
-const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
-const CACHE_TTL_MS = 2 * 60 * 60 * 1000;
-const DEFAULT_REFRESH_MS = 2 * 60 * 60 * 1000;
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-
-export function isFreeModel(id) {
-  return (typeof id === "string" && id.endsWith("-free")) ||
-    KNOWN_FREE_OPENCODE_MODELS.includes(id);
-}
-
-export function filterFreeModels(list) {
-  const seen = new Set();
-  const out = [];
-  for (const m of list || []) {
-    if (!(m && m.id)) continue;
-    if (!isFreeModel(m.id)) continue;
-    if (seen.has(m.id)) continue;
-    seen.add(m.id);
-    out.push(m);
-  }
-  return out;
-}
-
-export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, refreshMs = DEFAULT_REFRESH_MS, cacheFile } = {}) {
-  let cache = null;
-  let fetchedAt = 0;
-  let inflight = null;
-  let timer = null;
-
-  async function load() {
-    const data = await fetchUpstreamModels({ baseUrl, headers });
-    cache = data;
-    fetchedAt = Date.now();
-    if (cacheFile) persistModels(data, cacheFile);
-    return data;
-  }
-
-  async function get() {
-    const now = Date.now();
-    if (cache && now - fetchedAt < ttlMs) return cache;
-    if (inflight) return inflight;
-
-    inflight = (async () => {
-      try {
-        return await load();
-      } catch (err) {
-        // serve stale on failure if we have it, else rethrow
-        if (cache) return cache;
-        throw err;
-      } finally {
-        inflight = null;
-      }
-    })();
-    return inflight;
-  }
-
-  function startAutoRefresh(intervalMs = refreshMs) {
-    if (timer) return stopAutoRefresh;
-    timer = setInterval(() => {
-      void load().catch(() => {
-        // keep serving stale cache on background refresh failure
-      });
-    }, intervalMs);
-    timer.unref?.();
-    return stopAutoRefresh;
-  }
-
-  function stopAutoRefresh() {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
-  }
-
-  return { get, startAutoRefresh, stopAutoRefresh };
-}
-
-async function fetchUpstreamModels({ baseUrl, headers, connectTimeoutMs = 30_000 }) {
-  const url = `${baseUrl}/zen/v1/models`;
-  for (let attempt = 0; ; attempt++) {
-    const res = await attemptFetch(url, headers, connectTimeoutMs);
-    if (res instanceof Error) {
-      if (attempt < NETWORK_RETRIES) continue;
-      throw res;
-    }
-    if (isRetryable(res.status) && attempt < STATUS_RETRIES) {
-      await sleep(2000);
-      continue;
-    }
-    if (!res.ok) throw new Error(`models fetch failed: HTTP ${res.status}`);
-    const json = await res.json().catch(() => ({}));
-    const raw = Array.isArray(json) ? json : json.data ?? json.models ?? [];
-    return { object: "list", data: filterFreeModels(raw) };
-  }
-}
-
-async function attemptFetch(url, headers, connectTimeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), connectTimeoutMs);
-  try {
-    return await fetch(url, { headers, signal: controller.signal });
-  } catch (err) {
-    return err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function isRetryable(status) {
-  return status === 429 || status === 502 || status === 503 || status === 504;
-}
-
-function persistModels(data, cacheFile) {
-  try {
-    mkdirSync(dirname(cacheFile), { recursive: true });
-    writeFileSync(cacheFile, JSON.stringify({ cachedAt: Date.now(), ...data }));
-  } catch {
-    // persistence is best-effort
-  }
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-const NETWORK_RETRIES = 2;
+const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
+const CACHE_TTL_MS = 2 * 60 * 60 * 1000;
+const DEFAULT_REFRESH_MS = 2 * 60 * 60 * 1000;
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function isFreeModel(id) {
+  return (typeof id === "string" && id.endsWith("-free")) ||
+    KNOWN_FREE_OPENCODE_MODELS.includes(id);
+}
+
+export function filterFreeModels(list) {
+  const seen = new Set();
+  const out = [];
+  for (const m of list || []) {
+    if (!(m && m.id)) continue;
+    if (!isFreeModel(m.id)) continue;
+    if (seen.has(m.id)) continue;
+    seen.add(m.id);
+    out.push(m);
+  }
+  return out;
+}
+
+export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, refreshMs = DEFAULT_REFRESH_MS, cacheFile } = {}) {
+  let cache = null;
+  let fetchedAt = 0;
+  let inflight = null;
+  let timer = null;
+
+  async function load() {
+    const data = await fetchUpstreamModels({ baseUrl, headers });
+    cache = data;
+    fetchedAt = Date.now();
+    if (cacheFile) persistModels(data, cacheFile);
+    return data;
+  }
+
+  async function get() {
+    const now = Date.now();
+    if (cache && now - fetchedAt < ttlMs) return cache;
+    if (inflight) return inflight;
+
+    inflight = (async () => {
+      try {
+        return await load();
+      } catch (err) {
+        // serve stale on failure if we have it, else rethrow
+        if (cache) return cache;
+        throw err;
+      } finally {
+        inflight = null;
+      }
+    })();
+    return inflight;
+  }
+
+  function startAutoRefresh(intervalMs = refreshMs) {
+    if (timer) return stopAutoRefresh;
+    timer = setInterval(() => {
+      void load().catch(() => {
+        // keep serving stale cache on background refresh failure
+      });
+    }, intervalMs);
+    timer.unref?.();
+    return stopAutoRefresh;
+  }
+
+  function stopAutoRefresh() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return { get, startAutoRefresh, stopAutoRefresh };
+}
+
+async function fetchUpstreamModels({ baseUrl, headers, connectTimeoutMs = 30_000 }) {
+  const url = `${baseUrl}/zen/v1/models`;
+  for (let attempt = 0; ; attempt++) {
+    const res = await attemptFetch(url, headers, connectTimeoutMs);
+    if (res instanceof Error) {
+      if (attempt < NETWORK_RETRIES) continue;
+      throw res;
+    }
+    if (isRetryable(res.status) && attempt < STATUS_RETRIES) {
+      await sleep(2000);
+      continue;
+    }
+    if (!res.ok) throw new Error(`models fetch failed: HTTP ${res.status}`);
+    const json = await res.json().catch(() => ({}));
+    const raw = Array.isArray(json) ? json : json.data ?? json.models ?? [];
+    return { object: "list", data: filterFreeModels(raw) };
+  }
+}
+
+async function attemptFetch(url, headers, connectTimeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), connectTimeoutMs);
+  try {
+    return await fetch(url, { headers, signal: controller.signal });
+  } catch (err) {
+    return err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function isRetryable(status) {
+  return status === 429 || status === 502 || status === 503 || status === 504;
+}
+
+function persistModels(data, cacheFile) {
+  try {
+    mkdirSync(dirname(cacheFile), { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify({ cachedAt: Date.now(), ...data }));
+  } catch {
+    // persistence is best-effort
+  }
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+const NETWORK_RETRIES = 2;
 const STATUS_RETRIES = 2;

package/src/reasoning.js

@@ -1,33 +1,33 @@
-const PLACEHOLDER = " ";
-
-const MODEL_RULES = [
-  { match: (m) => /^kimi-/i.test(m || ""), scope: "toolCalls" },
-  { match: (m) => /deepseek/i.test(m || ""), scope: "all" },
-];
-
-export function normalizeModel(model) {
-  return model.startsWith("oc/") ? model.slice(3) : model;
-}
-
-function shouldInject(message, scope) {
-  if (message?.role !== "assistant") return false;
-  const rc = message.reasoning_content;
-  if (typeof rc === "string" && rc.length > 0) return false;
-  if (scope === "toolCalls") {
-    return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
-  }
-  return true;
-}
-
-function applyRule(body, rule) {
-  if (!rule || !body?.messages) return body;
-  const messages = body.messages.map((m) =>
-    shouldInject(m, rule.scope) ? { ...m, reasoning_content: PLACEHOLDER } : m
-  );
-  return { ...body, messages };
-}
-
-export function injectReasoningContent(model, body) {
-  const rule = MODEL_RULES.find((r) => r.match(model));
-  return applyRule(body, rule);
+const PLACEHOLDER = " ";
+
+const MODEL_RULES = [
+  { match: (m) => /^kimi-/i.test(m || ""), scope: "toolCalls" },
+  { match: (m) => /deepseek/i.test(m || ""), scope: "all" },
+];
+
+export function normalizeModel(model) {
+  return model.startsWith("oc/") ? model.slice(3) : model;
+}
+
+function shouldInject(message, scope) {
+  if (message?.role !== "assistant") return false;
+  const rc = message.reasoning_content;
+  if (typeof rc === "string" && rc.length > 0) return false;
+  if (scope === "toolCalls") {
+    return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+  }
+  return true;
+}
+
+function applyRule(body, rule) {
+  if (!rule || !body?.messages) return body;
+  const messages = body.messages.map((m) =>
+    shouldInject(m, rule.scope) ? { ...m, reasoning_content: PLACEHOLDER } : m
+  );
+  return { ...body, messages };
+}
+
+export function injectReasoningContent(model, body) {
+  const rule = MODEL_RULES.find((r) => r.match(model));
+  return applyRule(body, rule);
 }

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

@@ -0,0 +1,88 @@
+import { buildFallbackInfo } from "../fallback.js";
+import { relay, SLOW_TOTAL_MS } from "../stream.js";
+import { tryBroadbandRelay } from "../relay-queue.js";
+import { runHook } from "../../plugins.js";
+
+export async function handleBroadbandRelay({
+  model,
+  body,
+  hops,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  groups,
+  token,
+  bus,
+  logs,
+  handlerCtx,
+  evt,
+  mark,
+  perf0,
+  stages,
+  res,
+  startedAt,
+  plugins,
+}) {
+  const bb = await tryBroadbandRelay({ groups, token, model, body, hops, bus, logs, reqId: handlerCtx.reqId, evt, res, mark, perf0, stages });
+  if (!bb) {
+    evt("relay-miss", { reqId: handlerCtx.reqId, model });
+    return { handled: false };
+  }
+  const isResponse = bb.result && typeof bb.result.status === "number" && typeof bb.result.headers?.get === "function";
+  if (isResponse) {
+    const bbFallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "broadband", useAuto, lockModel });
+    if (bbFallback?.fallback) evt("fallback-notice", { reqId: handlerCtx.reqId, requested, actual: model, reason: bbFallback.reason, notice: bbFallback.notice, via: "broadband" });
+    evt("relay-start", { reqId: handlerCtx.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: handlerCtx.reqId, model, totalMs: Math.round(Date.now() - startedAt), stages: [...stages] }),
+    });
+    evt("relay-done", { reqId: handlerCtx.reqId, model, via: "broadband", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    if (auto && out.status === 200) {
+      const latencyMs = out.totalMs ?? 0;
+      if (out.detail?.stallHits > 0 || (latencyMs && latencyMs > SLOW_TOTAL_MS)) {
+        void auto.recordError(model, { status: 200, slow: true, note: `broadband slow ${latencyMs}ms` });
+        void auto.recordLatency(model, latencyMs);
+      } else {
+        await auto.recordOk(model, { latencyMs });
+      }
+    }
+    evt("result", { model, status: out.status, via: "broadband", timing: bb.result._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback: bbFallback, requested, actual: model });
+    evt("client-response", { requested, actual: model, via: "broadband", fallback: bbFallback, status: out.status, reqId: handlerCtx.reqId });
+    if (plugins?.length) runHook(plugins, "request:completed", { reqId: handlerCtx.reqId, requested, useAuto, hops: handlerCtx.hops, stream: Boolean(body.stream), durationMs: Date.now() - startedAt, via: "broadband", status: out.status, actual: model, fallback: bbFallback }).catch(() => {});
+    return { handled: true };
+  } else if (bb.result && typeof bb.result.status === "number") {
+    const fakeRes = {
+      status: bb.result.status,
+      headers: { get: (k) => bb.result.headers?.[k] || bb.result.headers?.[k.toLowerCase()] || null },
+      text: async () => typeof bb.result.body === "string" ? bb.result.body : JSON.stringify(bb.result.body),
+      body: (() => {
+        const b = bb.result.body || "";
+        const str = typeof b === "string" ? b : JSON.stringify(b);
+        const isSSE = bb.result.headers?.["Content-Type"]?.includes("text/event-stream");
+        if (isSSE) {
+          return (async function* () { yield Buffer.from(str); })();
+        }
+        return null;
+      })(),
+    };
+    const bbLocalFallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "broadband", useAuto, lockModel });
+    if (bbLocalFallback?.fallback) evt("fallback-notice", { reqId: handlerCtx.reqId, requested, actual: model, reason: bbLocalFallback.reason, notice: bbLocalFallback.notice, via: "broadband" });
+    evt("relay-start", { reqId: handlerCtx.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: handlerCtx.reqId, model, totalMs: Math.round(Date.now() - startedAt), stages: [...stages] }),
+    });
+    evt("relay-done", { reqId: handlerCtx.reqId, model, via: "broadband-local", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    evt("result", { model, status: out.status, via: "broadband", timing: null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback: bbLocalFallback, requested, actual: model });
+    evt("client-response", { requested, actual: model, via: "broadband", fallback: bbLocalFallback, status: out.status, reqId: handlerCtx.reqId });
+    if (plugins?.length) runHook(plugins, "request:completed", { reqId: handlerCtx.reqId, requested, useAuto, hops: handlerCtx.hops, stream: Boolean(body.stream), durationMs: Date.now() - startedAt, via: "broadband", status: out.status, actual: model, fallback: bbLocalFallback }).catch(() => {});
+    return { handled: true };
+  }
+  evt("relay-miss", { reqId: handlerCtx.reqId, model });
+  return { handled: false };
+}

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

@@ -0,0 +1,41 @@
+import { performance } from "node:perf_hooks";
+import { json } from "../helpers.js";
+import { relay } from "../stream.js";
+
+export async function handleExhaustedLocal({ res, body, lastErr, order, handlerCtx, evt, logCall, mark, perf0, stages, done, requested, useAuto }) {
+  const model = lastErr?.model ?? handlerCtx.model;
+  evt("exhausted-local", { reqId: handlerCtx.reqId, lastModel: lastErr?.model ?? model, lastStatus: lastErr?.status ?? 502, order });
+  logCall(lastErr?.model ?? model, lastErr?.status ?? 502);
+  if (lastErr?.upstream) {
+    evt("relay-start", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", isStream: Boolean(body.stream) });
+    const out = await relay(res, lastErr.upstream, body, {
+      onFirstChunk: (d) => mark(`ttf-${lastErr.model}`),
+      onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
+    });
+    evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
+    return true;
+  }
+  evt("result", { reqId: handlerCtx.reqId, model, status: lastErr?.status ?? 502, via: "none", timing: null });
+  done({ via: "none", status: lastErr?.status ?? 502, error: lastErr?.message || "all auto models failed" });
+  json(res, 502, { error: lastErr?.message || "all auto models failed" });
+  return true;
+}
+
+export async function handleExhaustedAll({ res, body, lastErr, order, requested, handlerCtx, evt, logCall, mark, perf0, stages }) {
+  evt("exhausted-all", { reqId: handlerCtx.reqId, lastModel: lastErr?.model ?? requested, lastStatus: lastErr?.status ?? 502, order });
+  logCall(lastErr?.model ?? requested, lastErr?.status ?? 502);
+  if (lastErr?.upstream) {
+    evt("relay-start", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", isStream: Boolean(body.stream) });
+    const out = await relay(res, lastErr.upstream, body, {
+      onFirstChunk: (d) => mark(`ttf-${lastErr.model}`),
+      onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: lastErr.model, totalMs: Math.round(performance.now() - perf0), stages: [...stages] }),
+    });
+    evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
+    evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
+    return true;
+  }
+  evt("result", { reqId: handlerCtx.reqId, model: lastErr?.model ?? requested, status: lastErr?.status ?? 502, via: "none", timing: null });
+  json(res, 502, { error: lastErr?.message || "all auto models failed" });
+  return true;
+}

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

@@ -0,0 +1,142 @@
+import { buildFallbackInfo } from "../fallback.js";
+import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
+import { hedgedFirstChunkRace } from "../hedge.js";
+import { runHook } from "../../plugins.js";
+
+export async function handleHedge({
+  upRes,
+  model,
+  body,
+  order,
+  idx,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  peers,
+  handlerCtx,
+  evt,
+  logCall,
+  logError,
+  mark,
+  perf0,
+  stages,
+  startedAt,
+  plugins,
+  res,
+  hedgeDelayMs,
+}) {
+  const isStream = Boolean(body.stream);
+  const d = hedgeDelayMs;
+  // hedge 已在外层判断 doHedge，这里直接执行赛跑
+  try {
+    const hedged = await hedgedFirstChunkRace({ localUpRes: upRes, peers, handlerCtx, hedgeDelayMs: d, evt });
+    if (hedged && hedged.winner) {
+      if (hedged.winner === "local") {
+        const fallback = buildFallbackInfo({ requested, actual: model, lastErr, via: "local", useAuto, lockModel });
+        if (fallback?.fallback) evt("fallback-notice", { reqId: handlerCtx.reqId, requested, actual: model, reason: fallback.reason, notice: fallback.notice, via: "local" });
+        evt("relay-start", { reqId: handlerCtx.reqId, model, via: "local", isStream, fallback, hedged: true });
+        const bufferedUpRes = { ...upRes, body: hedged.bufferedBody, headers: upRes.headers, status: upRes.status, _t: upRes._t };
+        logCall(model, bufferedUpRes.status);
+        const out = await relay(res, bufferedUpRes, body, {
+          fallback,
+          onFirstChunk: (delta) => {
+            mark(`ttf-${model}`);
+            evt("relay-first-chunk", { reqId: handlerCtx.reqId, model, ttfMs: delta, hedged: true, via: "local" });
+            if (plugins?.length) runHook(plugins, "relay:first-chunk", { reqId: handlerCtx.reqId, requested, model, via: "local", ttfMs: delta }).catch(() => {});
+          },
+          onDownstreamAbort: () => {
+            evt("client-abort", { reqId: handlerCtx.reqId, model, totalMs: Math.round(perf0 ? (Date.now() - startedAt) : 0), stages: [...stages] });
+          },
+        });
+        evt("relay-done", { reqId: handlerCtx.reqId, model, via: "local", status: out.status, ttfMs: out.ttfMs ?? hedged.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null, hedged: true });
+        if (out.status === STREAM_TIMEOUT_MS) {
+          if (auto) await auto.recordError(model, { status: 502, slow: true, note: `stream timeout ${STREAM_TIMEOUT_MS}ms` });
+          const err = { model, upstream: null, status: 502, message: `stream timed out after ${STREAM_TIMEOUT_MS}ms` };
+          logError(model, 502, `stream timeout ${STREAM_TIMEOUT_MS}ms`);
+          evt("upstream-error", { reqId: handlerCtx.reqId, model, status: 502, message: "stream timeout", timing: null });
+          evt("fallback", { reqId: handlerCtx.reqId, from: model, to: order[idx + 1] ?? null, reason: "stream timeout" });
+          return { handled: false, upRes: null, lastErr: err };
+        }
+        if (out.interrupted) {
+          if (auto) {
+            await auto.recordError(model, { status: 200, slow: true, note: `stall ${STALL_TIMEOUT_MS}ms` });
+            await auto.recordLatency(model, out.totalMs ?? (Date.now() - startedAt));
+          }
+          evt("slow-model", { model, elapsedMs: out.totalMs ?? (Date.now() - startedAt), threshold: STALL_TIMEOUT_MS, interrupted: true, detail: out.detail ?? null });
+          logCall(model, 200);
+          evt("result", { model, status: out.status, via: "local", timing: upRes._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, interrupted: true, detail: out.detail ?? null, fallback, requested, actual: model });
+          evt("client-response", { requested, actual: model, via: "local", fallback, status: out.status, reqId: handlerCtx.reqId });
+          if (plugins?.length) runHook(plugins, "request:completed", { reqId: handlerCtx.reqId, requested, useAuto, hops: handlerCtx.hops, stream: isStream, durationMs: Date.now() - startedAt, via: "local", status: out.status, actual: model, interrupted: true, fallback }).catch(() => {});
+          return { handled: true };
+        }
+        const elapsed = Date.now() - startedAt;
+        const latencyMs = out.totalMs ?? elapsed;
+        let scoredSlow = false;
+        if (SLOW_TOTAL_MS && auto && elapsed > SLOW_TOTAL_MS && out.status === 200) {
+          void auto.recordError(model, { status: 200, slow: true, note: `slow ${elapsed}ms` });
+          void auto.recordLatency(model, latencyMs);
+          evt("slow-model", { model, elapsedMs: elapsed, threshold: SLOW_TOTAL_MS, reason: "total", detail: out.detail ?? null });
+          scoredSlow = true;
+        }
+        if (out.detail?.stallHits > 0 && auto && out.status === 200) {
+          void auto.recordError(model, { status: 200, slow: true, note: `stall ${out.detail.stallHits}x gap>${SCORE_STALL_MS}ms maxGap ${out.detail.maxGapMs}ms` });
+          void auto.recordLatency(model, latencyMs);
+          evt("slow-model", { model, elapsedMs: elapsed, threshold: SCORE_STALL_MS, reason: "stall", stallHits: out.detail.stallHits, maxGapMs: out.detail.maxGapMs, detail: out.detail ?? null });
+          scoredSlow = true;
+        }
+        if (!scoredSlow && auto && out.status === 200) await auto.recordOk(model, { latencyMs });
+        else if (!scoredSlow && auto) await auto.recordLatency(model, latencyMs);
+        evt("result", { model, status: out.status, via: "local", timing: upRes._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback, requested, actual: model, hedged: true });
+        evt("client-response", { requested, actual: model, via: "local", fallback, status: out.status, reqId: handlerCtx.reqId });
+        if (plugins?.length) runHook(plugins, "request:completed", { reqId: handlerCtx.reqId, requested, useAuto, hops: handlerCtx.hops, stream: isStream, durationMs: Date.now() - startedAt, via: "local", status: out.status, actual: model, fallback }).catch(() => {});
+        return { handled: true };
+      } else 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 });
+        logCall(win.target, win.res.status);
+        const peerFallback = buildFallbackInfo({ requested, actual: win.target, lastErr, via: "peer", useAuto, lockModel });
+        if (peerFallback?.fallback) evt("fallback-notice", { reqId: handlerCtx.reqId, requested, actual: win.target, reason: peerFallback.reason, notice: peerFallback.notice, via: "peer" });
+        evt("relay-start", { reqId: handlerCtx.reqId, model: win.target, via: "peer", isStream, fallback: peerFallback, hedged: true });
+        const bufferedPeerRes = { ...win.res, body: hedged.bufferedBody, headers: win.res.headers, status: win.res.status, _t: win.res._t };
+        const out = await relay(res, bufferedPeerRes, body, {
+          fallback: peerFallback,
+          onFirstChunk: (d) => mark(`ttf-peer-${win.target}`),
+          onDownstreamAbort: () => evt("client-abort", { reqId: handlerCtx.reqId, model: win.target, totalMs: Math.round(perf0 ? (Date.now() - startedAt) : 0), stages: [...stages] }),
+        });
+        evt("relay-done", { reqId: handlerCtx.reqId, model: win.target, via: "peer", status: out.status, ttfMs: out.ttfMs ?? hedged.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null, hedged: true });
+        if (auto && out.status === 200) {
+          const latencyMs = out.totalMs ?? win.latencyMs;
+          if (out.detail?.stallHits > 0 || (latencyMs && latencyMs > SLOW_TOTAL_MS)) {
+            void auto.recordError(win.target, { status: 200, slow: true, note: `peer slow ${latencyMs}ms` });
+            void auto.recordLatency(win.target, latencyMs);
+          } else {
+            await auto.recordOk(win.target, { latencyMs });
+          }
+        }
+        evt("result", { model: win.target, status: out.status, via: "peer", timing: win.res._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback: peerFallback, requested, actual: win.target, hedged: true });
+        evt("client-response", { requested, actual: win.target, via: "peer", fallback: peerFallback, status: out.status, reqId: handlerCtx.reqId });
+        if (plugins?.length) runHook(plugins, "request:completed", { reqId: handlerCtx.reqId, requested, useAuto, hops: handlerCtx.hops, stream: isStream, durationMs: Date.now() - startedAt, via: "peer", status: out.status, actual: win.target, fallback: peerFallback }).catch(() => {});
+        return { handled: true };
+      }
+    }
+    if (hedged && hedged.needsPeer) {
+      return { handled: false, upRes: null, lastErr, needsPeer: true };
+    } else if (!hedged || !hedged.winner) {
+      evt("hedge-both-fail", { reqId: handlerCtx.reqId, model });
+      if (!hedged) {
+        if (auto) await auto.recordError(model, { status: 502, slow: false, note: "hedge both fail" });
+        const err = { model, upstream: null, status: 502, message: "hedge both failed" };
+        return { handled: false, upRes: null, lastErr: err };
+      }
+      return { handled: false, upRes: null, lastErr };
+    }
+    return { handled: false, upRes: null, lastErr };
+  } catch (hedgeErr) {
+    evt("hedge-error", { reqId: handlerCtx.reqId, model, error: String(hedgeErr?.message || hedgeErr).slice(0, 300) });
+    // 回退到串行
+    return { handled: false, upRes, lastErr };
+  }
+}