mslxdff 0.1.66 → 0.1.68

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/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 };
   }
 }

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

@@ -1,8 +1,8 @@
-import { buildFallbackInfo } from "../fallback.js";
 import { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS } from "../stream.js";
-import { runHook } from "../../plugins.js";
-import { performance } from "node:perf_hooks";
+import { buildFallbackInfo } from "../fallback.js";
+import { createRelayPipeline } from "./relay-pipeline.js";
 
+/** 薄适配：本地透传唯一经由 relay-pipeline */
 export async function handleLocalRelay({
   upRes,
   model,
@@ -25,64 +25,35 @@ export async function handleLocalRelay({
   plugins,
   res,
 }) {
-  logCall(model, upRes.status);
-  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: Boolean(body.stream), fallback });
-  const out = await relay(res, upRes, body, {
-    fallback,
-    onFirstChunk: (delta) => {
-      mark(`ttf-${model}`);
-      evt("relay-first-chunk", { reqId: handlerCtx.reqId, model, ttfMs: delta });
-      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(performance.now() - perf0), 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,
+    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, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
-  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, interrupted: true, 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: "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 });
-  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: Boolean(body.stream), durationMs: Date.now() - startedAt, via: "local", status: out.status, actual: model, fallback }).catch(() => {});
+  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
   return { handled: true };
 }

package/src/routes/chat/peer-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 { racePeerCandidates } from "../peers.js";
-import { runHook } from "../../plugins.js";
 
+/** 薄适配：peer 赛跑后经由 pipeline（via=peer） */
 export async function handlePeerRelay({
   model,
   body,
@@ -32,27 +33,35 @@ export async function handlePeerRelay({
   }
   evt("peer-race-win", { reqId: handlerCtx.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);
-  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: 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: handlerCtx.reqId, model: win.target, totalMs: Math.round(Date.now() - startedAt), 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: win.res,
+    body,
+    requested,
+    actual: win.target,
+    lastErr,
+    via: "peer",
+    lockModel,
+    useAuto,
+    handlerCtx: { ...handlerCtx, model: win.target },
+    mark,
+    perf0,
+    stages,
+    startedAt,
   });
-  evt("relay-done", { reqId: handlerCtx.reqId, model: win.target, via: "peer", 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 ?? 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 });
-  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: Boolean(body.stream), durationMs: Date.now() - startedAt, via: "peer", status: out.status, actual: win.target, fallback: peerFallback }).catch(() => {});
   return { handled: true };
 }

package/src/routes/chat/relay-pipeline.js

@@ -0,0 +1,151 @@
+import { runHook } from "../../plugins.js";
+
+/**
+ * RelayPipeline 深模块
+ * 把 5 个 handler 各自的 fallback→relay→scoring→事件 6段流水收敛为单一真相。
+ * 对外 1 接口：createRelayPipeline(deps) => { execute(ctx) }
+ * 设计要点：全部外部可注入，便于在 pipeline seam 上做行为测试；constants 注入便于单测加速。
+ */
+export function createRelayPipeline({
+  relay,
+  buildFallbackInfo,
+  auto,
+  plugins,
+  evt,
+  mark,
+  logCall,
+  logError,
+  constants,
+  startedAt: defaultStartedAt,
+  stages: defaultStages,
+  perfNow,
+} = {}) {
+  const C = {
+    STREAM_TIMEOUT_MS: 25_000,
+    SLOW_TOTAL_MS: 20_000,
+    STALL_TIMEOUT_MS: 0,
+    SCORE_STALL_MS: 15_000,
+    ...(constants || {}),
+  };
+  const _relay = relay;
+  const _build = buildFallbackInfo;
+  const _evt = evt || (() => {});
+  const _mark = mark || (() => {});
+  const _logCall = logCall || (() => {});
+  const _logError = logError || (() => {});
+  const _perfNow = perfNow || (() => Date.now());
+
+  async function execute({
+    res,
+    upRes,
+    body,
+    requested,
+    actual,
+    lastErr,
+    via,
+    lockModel,
+    useAuto,
+    handlerCtx,
+    mark: m2,
+    perf0,
+    stages: s2,
+    startedAt: sa2,
+  } = {}) {
+    const markFn = m2 || _mark;
+    const curStartedAt = sa2 ?? defaultStartedAt ?? Date.now();
+    const curStages = s2 ?? defaultStages ?? [];
+    const reqId = handlerCtx?.reqId;
+    const hops = handlerCtx?.hops;
+
+    // 1. logCall(pre) — 保持原 handler 的 logCall→fallback→relay-start 时序
+    try { _logCall(actual, upRes?.status); } catch {}
+    // 2. fallback + relay-start
+    let fallback = null;
+    try {
+      if (_build) fallback = _build({ requested, actual, lastErr, via, useAuto, lockModel });
+    } catch {}
+    if (fallback?.fallback) {
+      _evt("fallback-notice", { reqId, requested, actual, reason: fallback.reason, notice: fallback.notice, via, fallback: true });
+    }
+    _evt("relay-start", { reqId, model: actual, via, isStream: Boolean(body?.stream), fallback });
+
+    // 3. relay
+    const out = await _relay(res, upRes, body, {
+      fallback,
+      onFirstChunk: (delta) => {
+        try { markFn(`ttf-${actual}`); } catch {}
+        _evt("relay-first-chunk", { reqId, model: actual, ttfMs: delta, via });
+        if (plugins?.length) runHook(plugins, "relay:first-chunk", { reqId, requested, model: actual, via, ttfMs: delta }).catch(() => {});
+      },
+      onDownstreamAbort: () => {
+        _evt("client-abort", { reqId, model: actual, totalMs: Math.round(_perfNow() - (perf0 ?? 0)), stages: [...curStages] });
+      },
+    });
+
+    // 4. relay-done
+    _evt("relay-done", {
+      reqId,
+      model: actual,
+      via,
+      status: out.status,
+      ttfMs: out.ttfMs,
+      totalMs: out.totalMs,
+      aborted: out.aborted,
+      interrupted: out.interrupted ?? false,
+      detail: out.detail ?? null,
+    });
+
+    // 5a. 首块超时未写字节 → 回退
+    if (out.status === C.STREAM_TIMEOUT_MS) {
+      if (auto) try { await auto.recordError(actual, { status: 502, slow: true, note: `stream timeout ${C.STREAM_TIMEOUT_MS}ms` }); } catch {}
+      try { _logError(actual, 502, `stream timeout ${C.STREAM_TIMEOUT_MS}ms`); } catch {}
+      _evt("upstream-error", { reqId, model: actual, status: 502, message: "stream timeout", timing: null });
+      _evt("fallback", { reqId, from: actual, to: null, reason: "stream timeout" });
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `stream timed out after ${C.STREAM_TIMEOUT_MS}ms` } };
+    }
+
+    // 5b. 中断（stall 超时 / max 流时长）
+    if (out.interrupted) {
+      if (auto) {
+        try { await auto.recordError(actual, { status: 200, slow: true, note: `stall ${C.STALL_TIMEOUT_MS}ms` }); } catch {}
+        try { await auto.recordLatency(actual, out.totalMs ?? (Date.now() - curStartedAt)); } catch {}
+      }
+      _evt("slow-model", { reqId, model: actual, elapsedMs: out.totalMs ?? (Date.now() - curStartedAt), threshold: C.STALL_TIMEOUT_MS, interrupted: true, detail: out.detail ?? null });
+      try { _logCall(actual, 200); } catch {}
+      _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, interrupted: true, detail: out.detail ?? null, fallback, requested, actual });
+      _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId, interrupted: true });
+      if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, interrupted: true, fallback }).catch(() => {});
+      return { handled: true };
+    }
+
+    // 5c. 慢速计分 + ok
+    const elapsed = Date.now() - curStartedAt;
+    const latencyMs = out.totalMs ?? elapsed;
+    let scoredSlow = false;
+
+    if (C.SLOW_TOTAL_MS && auto && elapsed > C.SLOW_TOTAL_MS && out.status === 200) {
+      try { await auto.recordError(actual, { status: 200, slow: true, note: `slow ${elapsed}ms` }); } catch {}
+      try { await auto.recordLatency(actual, latencyMs); } catch {}
+      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.SLOW_TOTAL_MS, reason: "total", detail: out.detail ?? null });
+      scoredSlow = true;
+    }
+    if (out.detail?.stallHits > 0 && auto && out.status === 200) {
+      try { await auto.recordError(actual, { status: 200, slow: true, note: `stall ${out.detail.stallHits}x gap>${C.SCORE_STALL_MS}ms maxGap ${out.detail.maxGapMs}ms` }); } catch {}
+      try { await auto.recordLatency(actual, latencyMs); } catch {}
+      _evt("slow-model", { reqId, model: actual, elapsedMs: elapsed, threshold: C.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) {
+      try { await auto.recordOk(actual, { latencyMs }); } catch {}
+    } else if (!scoredSlow && auto) {
+      try { await auto.recordLatency(actual, latencyMs); } catch {}
+    }
+
+    _evt("result", { reqId, model: actual, status: out.status, via, timing: upRes?._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null, fallback, requested, actual });
+    _evt("client-response", { requested, actual, via, fallback, status: out.status, reqId });
+    if (plugins?.length) runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body?.stream), durationMs: Date.now() - curStartedAt, via, status: out.status, actual, fallback }).catch(() => {});
+    return { handled: true };
+  }
+
+  return { execute };
+}