mslxdff 0.1.65 → 0.1.67

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

@@ -1,8 +1,9 @@
+import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
 import { buildFallbackInfo } from "../fallback.js";
-import { relay, SLOW_TOTAL_MS } from "../stream.js";
+import { createRelayPipeline } from "./relay-pipeline.js";
 import { tryBroadbandRelay } from "../relay-queue.js";
-import { runHook } from "../../plugins.js";
 
+/** 薄适配：broadband 两种形态合一经由 pipeline */
 export async function handleBroadbandRelay({
   model,
   body,
@@ -30,57 +31,35 @@ export async function handleBroadbandRelay({
     evt("relay-miss", { reqId: handlerCtx.reqId, model });
     return { handled: false };
   }
+  const pipeline = createRelayPipeline({
+    relay,
+    buildFallbackInfo,
+    auto,
+    plugins,
+    evt,
+    mark,
+    logCall: () => {},
+    logError: () => {},
+    constants: { STREAM_TIMEOUT_MS, SLOW_TOTAL_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS },
+    startedAt,
+    stages,
+  });
   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(() => {});
+    await pipeline.execute({ res, upRes: bb.result, body, requested, actual: model, lastErr, via: "broadband", lockModel, useAuto, handlerCtx, mark, perf0, stages, startedAt });
     return { handled: true };
-  } else if (bb.result && typeof bb.result.status === "number") {
+  }
+  if (bb.result && typeof bb.result.status === "number") {
+    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");
     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;
-      })(),
+      text: async () => str,
+      body: isSSE ? (async function* () { yield Buffer.from(str); })() : 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(() => {});
+    await pipeline.execute({ res, upRes: fakeRes, body, requested, actual: model, lastErr, via: "broadband-local", lockModel, useAuto, handlerCtx, mark, perf0, stages, startedAt });
     return { handled: true };
   }
   evt("relay-miss", { reqId: handlerCtx.reqId, model });

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

@@ -1,6 +1,6 @@
-import { performance } from "node:perf_hooks";
-import { json } from "../helpers.js";
 import { relay } from "../stream.js";
+import { json } from "../helpers.js";
+import { performance } from "node:perf_hooks";
 
 export async function handleExhaustedLocal({ res, body, lastErr, order, handlerCtx, evt, logCall, mark, perf0, stages, done, requested, useAuto }) {
   const model = lastErr?.model ?? handlerCtx.model;

package/src/routes/chat/gateway.js

@@ -0,0 +1,301 @@
+import { performance } from "node:perf_hooks";
+import { injectReasoningContent, normalizeModel } from "../../reasoning.js";
+import { isAutoModel } from "../../auto.js";
+import { toInternalId as aliasToInternal } from "../../sync-opencode.js";
+import { clientIp, json, readBody, parseHops, summarizePrompt, errMsg } from "../helpers.js";
+import { hedgeDelayMs, shouldHedge } from "../hedge.js";
+import { runHook } from "../../plugins.js";
+import { parseShareKeysHeader, SHARE_KEYS_HEADER } from "../../providers/share-keys.js";
+import { handleHedge } from "./hedge-handler.js";
+import { handleLocalRelay } from "./local-handler.js";
+import { handlePeerRelay } from "./peer-handler.js";
+import { handleBroadbandRelay } from "./broadband-handler.js";
+import { handleExhaustedLocal, handleExhaustedAll } from "./exhausted-handler.js";
+import { normalizeFullId, getModelAlias } from "../../providers/model-id.js";
+
+/**
+ * ChatGateway 深模块：对外 1 handle，内部 Policy→Selector→Executor 三段编排
+ * Policy: 别名/allowlist/header 透传
+ * Selector: order 推导 + 并发择优 + 排序
+ * Executor: 串行 trial → hedge → local → peer → broadband → exhausted
+ * 两 adapter：Provider(upstream.chat) + Clock/Latency(auto) 可注入 fake
+ */
+export function createChatGateway({ upstream, auto, logs, peers, maxHops, groups, bus, token, plugins }) {
+  async function handle({ req, res }) {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch {
+      return json(res, 400, { error: "Invalid JSON body" });
+    }
+    if (plugins?.length) {
+      const rc = await runHook(plugins, "request:received", { ip: clientIp(req), hops: parseHops(req.headers["x-mslxdff-hops"]), headers: { "content-type": req.headers["content-type"] }, body });
+      for (const e of rc.errors) logs?.appendEvent?.({ ts: Date.now(), type: "plugin-hook-error", hook: "request:received", plugin: e.plugin, error: e.error });
+      const respond = rc.value?.respond;
+      if (respond && typeof respond === "object") return json(res, respond.status || 200, respond.body ?? {});
+    }
+
+    const startedAt = Date.now();
+    const reqId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const perf0 = performance.now();
+    const stages = [];
+    const mark = (name) => stages.push([name, Math.round(performance.now() - perf0)]);
+
+    // ===== Policy =====
+    const hops = parseHops(req.headers["x-mslxdff-hops"]);
+    const shareKeys = parseShareKeysHeader(req.headers[SHARE_KEYS_HEADER] || "");
+    const workbuddyUid = (req.headers["x-mslxdff-workbuddy-uid"] || req.headers["x-workbuddy-uid"] || "").toString().trim();
+    const lockModel = req.headers["x-mslxdff-model-lock"] || "";
+    const rawModel = body.model || "";
+    let normalizedRequested = normalizeModel(lockModel || rawModel || "");
+    const aliasResolved = getModelAlias(normalizedRequested);
+    if (aliasResolved) { normalizedRequested = aliasResolved; body = { ...body, model: aliasResolved }; }
+    let requested = normalizedRequested;
+    let aliasInfo = null;
+    if (requested.startsWith("mslxdff-")) {
+      const internal = aliasToInternal(requested);
+      if (internal) { aliasInfo = `${requested} -> ${internal}`; requested = internal; }
+    } else if (requested.includes("/")) {
+      const slashIdx = requested.indexOf("/");
+      const rawPart = requested.slice(slashIdx + 1);
+      const providerPart = requested.slice(0, slashIdx);
+      if (rawPart.startsWith("mslxdff-")) {
+        const internal = aliasToInternal(rawPart);
+        if (internal) {
+          aliasInfo = `${requested} -> ${providerPart}/${internal} (alias stripped)`;
+          requested = `${providerPart}/${internal}`;
+          if (providerPart === "mslxdff") { requested = internal; aliasInfo = `${rawModel} -> ${internal} (mslxdff alias stripped)`; }
+        }
+      } else if (providerPart === "mslxdff") {
+        aliasInfo = `${requested} -> ${rawPart} (mslxdff provider stripped, 原名兼容)`;
+        requested = rawPart;
+      }
+    }
+    const useAuto = isAutoModel(requested);
+    mark("parsed");
+    if (aliasInfo) { try { res.setHeader("x-mslxdff-alias", aliasInfo); } catch {} }
+
+    // ===== Selector: order 推导 =====
+    let order;
+    if (lockModel) order = [requested];
+    else if (useAuto) order = auto ? await auto.candidates() : [""];
+    else order = auto ? await auto.candidatesFor(requested) : [requested];
+    if (!order.length) order = [""];
+    const canFallback = order.length > 1;
+    const canForwardPeers = Boolean(peers) && hops < maxHops;
+    mark("ordered");
+
+    const logCall = (model, status) => logs?.appendCall({ reqId, model, auto: useAuto, status, durationMs: Date.now() - startedAt, stream: Boolean(body.stream), stages });
+    const logError = (model, status, message) => logs?.appendError({ reqId, model, auto: useAuto, status, message, stages });
+    const evt = (type, data) => {
+      const entry = { ts: Date.now(), reqId, type, ...data, model: data.model ?? requested, auto: useAuto, durationMs: Date.now() - startedAt, stages: [...stages] };
+      if (bus) bus.emit(entry);
+      logs?.appendEvent?.(entry);
+    };
+    const done = (info) => {
+      if (!plugins?.length) return;
+      runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body.stream), durationMs: Date.now() - startedAt, ...info }).catch(() => {});
+    };
+    evt("request", { reqId, hops, ip: clientIp(req), stream: Boolean(body.stream), prompt: summarizePrompt(body), rawModel, requested, lockModel: lockModel || null });
+    if (aliasInfo) evt("alias", { reqId, alias: aliasInfo, rawModel, requested });
+    if (Object.keys(shareKeys).length) evt("share-keys", { reqId, providers: Object.keys(shareKeys) });
+    evt("ordered", { reqId, order, canFallback, canForwardPeers, useAuto, statuses: auto?.statuses?.() ?? null });
+
+    if (plugins?.length && !lockModel) {
+      const sel = await runHook(plugins, "model:select", { reqId, requested, useAuto, order: [...order], hops, stream: Boolean(body.stream) });
+      if (sel.changed && Array.isArray(sel.value) && sel.value.length) {
+        order = sel.value.filter(Boolean);
+        if (!order.length) order = [requested];
+        evt("plugin-hook", { reqId, hook: "model:select", applied: true, order: [...order] });
+      }
+      for (const e of sel.errors) evt("plugin-hook-error", { reqId, hook: "model:select", plugin: e.plugin, error: e.error });
+    }
+
+    const handlerCtx = { reqId, model: null, body, hops, peers, plugins, evt, logError, logCall, logs };
+
+    // ===== Selector: 首次 auto 并发择优 =====
+    if (useAuto && order.length > 1 && auto && !lockModel) {
+      const statuses = auto.statuses?.() ?? {};
+      const hasPriorSuccess = Object.values(statuses).some((e) => e && typeof e === "object" && e.status === "normal");
+      const nonCoolingOrder = order.filter((m) => { try { return !auto.isCooling(m); } catch { return true; } });
+      if (!hasPriorSuccess && nonCoolingOrder.length > 1) {
+        const concLimit = (() => {
+          const v = Number(process.env.MSLXDFF_AUTO_CONCURRENT);
+          if (Number.isInteger(v) && v > 0) return Math.min(v, nonCoolingOrder.length);
+          return Math.min(nonCoolingOrder.length, 5);
+        })();
+        const raceModels = nonCoolingOrder.slice(0, concLimit);
+        evt("auto-concurrent-race", { reqId, models: raceModels, skippedFaulty: order.length - nonCoolingOrder.length, limit: concLimit });
+        const raceStart = performance.now();
+        const attempts = raceModels.map(async (m) => {
+          const fwd = { ...injectReasoningContent(m, body), model: m };
+          let r = null;
+          try {
+            const chatOpts = {};
+            if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
+            if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+            r = await upstream.chat(fwd, Object.keys(chatOpts).length ? chatOpts : undefined);
+          } catch (err) {
+            return { model: m, ok: false, error: errMsg(err), status: 502, timing: err?._t ?? null };
+          }
+          if (r && r.status >= 400) {
+            const isAllow = r.status === 403 && r.headers?.get?.("x-mslxdff-allowlist") === "1";
+            if (isAllow) return { model: m, ok: false, error: "allowlist", status: 403, allowlist: true };
+            return { model: m, ok: false, error: `upstream ${r.status}`, status: r.status, res: r, timing: r._t ?? null };
+          }
+          if (r instanceof Error) return { model: m, ok: false, error: errMsg(r), status: 502 };
+          return { model: m, ok: true, res: r, status: r.status, timing: r._t ?? null };
+        });
+        const results = await Promise.allSettled(attempts);
+        const okList = results.map((r, i) => ({ r, i, model: raceModels[i] }))
+          .filter(({ r }) => r.status === "fulfilled" && r.value?.ok)
+          .map(({ r, i, model }) => ({ model, idx: i, val: r.value, t: r.value.timing?.totalMs ?? r.value.timing?.ms ?? Number.MAX_SAFE_INTEGER }));
+        if (okList.length) {
+          okList.sort((a, b) => a.t - b.t);
+          const best = okList[0];
+          const winModel = best.model;
+          evt("auto-concurrent-win", { reqId, model: winModel, timing: best.val.timing, totalMs: Math.round(performance.now() - raceStart), tried: raceModels.length });
+          for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+            const m = raceModels[i];
+            if (r.status === "fulfilled" && r.value?.ok) {
+              if (m === winModel) {
+                const latencyMs = r.value.timing?.totalMs ?? Math.round(performance.now() - raceStart);
+                await auto.recordOk(m, { latencyMs });
+                try { const { savePreferredModel } = await import("../../state.js"); savePreferredModel(m); evt("auto-concurrent-preferred", { reqId, model: m }); } catch {}
+              }
+            } else if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) await auto.recordError(m, { status: r.value.status || 502 });
+            else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
+          }
+          handlerCtx.model = winModel;
+          const { handleLocalRelay: _relay } = await import("./local-handler.js");
+          const lr = await _relay({
+            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,
+          });
+          if (lr.handled) return;
+          if (!lr.lastErr) return;
+        } else {
+          evt("auto-concurrent-all-fail", { reqId, tried: raceModels.length, totalMs: Math.round(performance.now() - raceStart) });
+          for (const { r, i } of results.map((r, i) => ({ r, i }))) {
+            const m = raceModels[i];
+            if (r.status === "fulfilled" && !r.value?.ok && !r.value?.allowlist) await auto.recordError(m, { status: r.value.status || 502 });
+            else if (r.status === "rejected") await auto.recordError(m, { status: 502 });
+          }
+        }
+        const triedSet = new Set(raceModels);
+        order = order.filter((m) => !triedSet.has(m));
+        if (!order.length) {
+          const last = { model: raceModels[0] || requested, status: 502, message: "all concurrent candidates failed" };
+          await handleExhaustedAll({ res, body, lastErr: last, order: raceModels, requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+          return;
+        }
+      }
+    }
+
+    // ===== Executor: 串行 trial =====
+    let lastErr = null;
+    for (let idx = 0; idx < order.length; idx++) {
+      const model = order[idx];
+      handlerCtx.model = model;
+      evt("model-try", { reqId, model, idx, remaining: order.length - idx });
+      if (plugins?.length) {
+        const bt = await runHook(plugins, "model:beforeTry", { reqId, requested, model, idx, hops });
+        for (const e of bt.errors) evt("plugin-hook-error", { reqId, hook: "model:beforeTry", plugin: e.plugin, error: e.error });
+        if (bt.value === false || bt.value?.skip === true) { evt("plugin-hook", { reqId, hook: "model:beforeTry", applied: true, skipped: model }); continue; }
+      }
+      let upRes = null;
+      let forwarded = { ...injectReasoningContent(model, body), model };
+      if (plugins?.length) {
+        const ur = await runHook(plugins, "upstream:request", { reqId, requested, model, payload: forwarded, stream: Boolean(body.stream) });
+        for (const e of ur.errors) evt("plugin-hook-error", { reqId, hook: "upstream:request", plugin: e.plugin, error: e.error });
+        if (ur.changed && ur.value?.payload && typeof ur.value.payload === "object") { forwarded = ur.value.payload; evt("plugin-hook", { reqId, hook: "upstream:request", applied: true, model, rewrittenModel: forwarded.model ?? null }); }
+      }
+      const tUp = performance.now();
+      evt("upstream-try", { reqId, model, attempt: idx + 1 });
+      try {
+        const chatOpts = {};
+        if (Object.keys(shareKeys).length) chatOpts.shareKeys = shareKeys;
+        if (workbuddyUid) chatOpts.workbuddyUid = workbuddyUid;
+        upRes = await upstream.chat(forwarded, Object.keys(chatOpts).length ? chatOpts : undefined);
+        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 });
+      } catch (err) {
+        if (auto) await auto.recordError(model, { message: errMsg(err) });
+        lastErr = { model, upstream: null, status: 502, message: errMsg(err) };
+        logError(model, 502, errMsg(err));
+        evt("upstream-error", { reqId, model, status: 502, message: errMsg(err), timing: err._t ?? { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - tUp) } });
+      }
+      if (plugins?.length) {
+        runHook(plugins, "upstream:response", {
+          reqId, requested, model,
+          status: upRes instanceof Error ? null : upRes instanceof Object ? (upRes.status ?? null) : null,
+          ok: !(upRes instanceof Error) && upRes ? upRes.status < 400 : false,
+          error: upRes instanceof Error ? errMsg(upRes) : null,
+          timing: upRes?._t ?? null,
+        }).catch(() => {});
+      }
+      mark(`up-${model}`);
+      if (upRes && upRes.status >= 400) {
+        const isAllowlistBlock = upRes.status === 403 && (upRes.headers?.get?.("x-mslxdff-allowlist") === "1");
+        if (isAllowlistBlock) {
+          let bodyText = null; try { bodyText = await upRes.clone().text(); } catch {}
+          let errBody = { error: `model not allowed for provider` };
+          try { errBody = bodyText ? JSON.parse(bodyText) : errBody; } catch { errBody = { error: bodyText || "model not allowed" }; }
+          if (useAuto) {
+            logError(model, 403, errBody.error || "model not allowed");
+            evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true, skipped: true });
+            lastErr = { model, upstream: upRes, status: 403, message: errBody.error || "model not allowed" };
+            if (canFallback && idx < order.length - 1) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: `allowlist skip ${errBody.error || "blocked"}` }); continue; }
+            return json(res, 403, errBody);
+          }
+          logError(model, 403, errBody.error || "model not allowed");
+          evt("upstream-error", { reqId, model, status: 403, message: errBody.error, timing: upRes._t ?? null, allowlist: true });
+          return json(res, 403, errBody);
+        }
+        if (auto) await auto.recordError(model, { status: upRes.status });
+        lastErr = { model, upstream: upRes, status: upRes.status, message: null };
+        logError(model, upRes.status, `upstream ${upRes.status}`);
+        evt("upstream-error", { reqId, model, status: upRes.status, message: null, timing: upRes._t ?? null });
+        upRes = null;
+      }
+      if (upRes) {
+        const isStream = Boolean(body.stream);
+        const d = hedgeDelayMs();
+        const hasPeers = Boolean(peers) && peers.ordered().length > 0;
+        const doHedge = shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers }) && upRes.status === 200 && upRes.body;
+        if (doHedge) {
+          const hr = await handleHedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
+          if (hr.handled) return;
+          if (hr.lastErr) lastErr = hr.lastErr;
+          if (hr.upRes === null) upRes = null;
+          else if (hr.upRes) upRes = hr.upRes;
+        }
+        if (upRes) {
+          const lr = await handleLocalRelay({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res });
+          if (lr.handled) return;
+          if (lr.lastErr) { lastErr = lr.lastErr; continue; }
+          return;
+        }
+      }
+      if (canForwardPeers) {
+        const pr = await handlePeerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
+        if (pr.handled) return;
+      }
+      if (groups) {
+        const br = await handleBroadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
+        if (br.handled) return;
+      }
+      if (canFallback) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
+      await handleExhaustedLocal({ res, body, lastErr, order, handlerCtx: { ...handlerCtx, model, reqId }, evt, logCall, mark, perf0, stages, done, requested, useAuto });
+      return;
+    }
+    await handleExhaustedAll({ res, body, lastErr, order, requested, handlerCtx: { ...handlerCtx, reqId, startedAt }, evt, logCall, mark, perf0, stages });
+  }
+
+  return { handle };
+}
+
+// 薄适配：保持原 chatHandler 签名兼容
+export async function chatHandler(ctx) {
+  const gw = createChatGateway(ctx);
+  return gw.handle(ctx);
+}

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

@@ -1,8 +1,9 @@
-import { buildFallbackInfo } from "../fallback.js";
 import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
+import { buildFallbackInfo } from "../fallback.js";
+import { createRelayPipeline } from "./relay-pipeline.js";
 import { hedgedFirstChunkRace } from "../hedge.js";
-import { runHook } from "../../plugins.js";
 
+/** 薄适配：hedge 赛跑后按 winner 调 pipeline（复用 relay-pipeline 深模块） */
 export async function handleHedge({
   upRes,
   model,
@@ -27,104 +28,86 @@ export async function handleHedge({
   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] });
-          },
+        const pipeline = createRelayPipeline({
+          relay,
+          buildFallbackInfo,
+          auto,
+          plugins,
+          evt,
+          mark,
+          logCall,
+          logError,
+          constants: { STREAM_TIMEOUT_MS, SLOW_TOTAL_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS },
+          startedAt,
+          stages,
+        });
+        const r = await pipeline.execute({
+          res,
+          upRes: bufferedUpRes,
+          body,
+          requested,
+          actual: model,
+          lastErr,
+          via: "local",
+          lockModel,
+          useAuto,
+          handlerCtx,
+          mark,
+          perf0,
+          stages,
+          startedAt,
         });
-        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(() => {});
+        // 保留 hedged 语义：若超时则透传 needs fallback
+        if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
         return { handled: true };
-      } else if (hedged.winner === "peer" && hedged.peerInfo) {
+      }
+      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] }),
+        const pipeline = createRelayPipeline({
+          relay,
+          buildFallbackInfo,
+          auto,
+          plugins,
+          evt,
+          mark,
+          logCall,
+          logError: () => {},
+          constants: { STREAM_TIMEOUT_MS, SLOW_TOTAL_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS },
+          startedAt,
+          stages,
+        });
+        await pipeline.execute({
+          res,
+          upRes: bufferedPeerRes,
+          body,
+          requested,
+          actual: win.target,
+          lastErr,
+          via: "peer",
+          lockModel,
+          useAuto,
+          handlerCtx: { ...handlerCtx, model: win.target },
+          mark: (n) => mark(n),
+          perf0,
+          stages,
+          startedAt,
         });
-        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) {
+    }
+    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" });
@@ -136,7 +119,6 @@ export async function handleHedge({
     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 };
   }
 }