mslxdff 0.1.203 → 0.1.207

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

@@ -1,130 +1,130 @@
-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";
-
-/** 薄适配：hedge 赛跑后按 winner 调 pipeline（复用 relay-pipeline 深模块） */
-export async function handleHedge({
-  upRes,
-  model,
-  body,
-  order,
-  idx,
-  lastErr,
-  requested,
-  useAuto,
-  lockModel,
-  auto,
-  peers,
-  handlerCtx,
-  evt,
-  logCall,
-  logError,
-  mark,
-  perf0,
-  attemptStartMs,
-  stages,
-  startedAt,
-  plugins,
-  res,
-  hedgeDelayMs,
-  deps = {},
-}) {
-  const { createPipeline = createRelayPipeline, hedgedFirstChunkRace: race = hedgedFirstChunkRace } = deps;
-  const d = hedgeDelayMs;
-  try {
-    const hedged = await race({ localUpRes: upRes, peers, handlerCtx, hedgeDelayMs: d, evt });
-    if (hedged && hedged.winner) {
-      if (hedged.winner === "local") {
-        const bufferedUpRes = { ...upRes, body: hedged.bufferedBody, headers: upRes.headers, status: upRes.status, _t: upRes._t };
-        const pipeline = createPipeline({
-          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,
-          attemptStartMs,
-          stages,
-          startedAt,
-        });
-        // 保留 hedged 语义：若超时则透传 needs fallback
-        if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-        return { handled: true };
-      }
-      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 });
-        const bufferedPeerRes = { ...win.res, body: hedged.bufferedBody, headers: win.res.headers, status: win.res.status, _t: win.res._t };
-        const pipeline = createPipeline({
-          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: bufferedPeerRes,
-          body,
-          requested,
-          actual: win.target,
-          lastErr,
-          via: "peer",
-          lockModel,
-          useAuto,
-          handlerCtx: { ...handlerCtx, model: win.target },
-          mark: (n) => mark(n),
-          perf0,
-          attemptStartMs,
-          stages,
-          startedAt,
-        });
-        if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-        return { handled: true };
-      }
-    }
-    if (hedged && hedged.needsPeer) {
-      return { handled: false, upRes: null, lastErr, needsPeer: true };
-    }
-    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 };
-  }
-}
+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";
+
+/** 薄适配：hedge 赛跑后按 winner 调 pipeline（复用 relay-pipeline 深模块） */
+export async function handleHedge({
+  upRes,
+  model,
+  body,
+  order,
+  idx,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  peers,
+  handlerCtx,
+  evt,
+  logCall,
+  logError,
+  mark,
+  perf0,
+  attemptStartMs,
+  stages,
+  startedAt,
+  plugins,
+  res,
+  hedgeDelayMs,
+  deps = {},
+}) {
+  const { createPipeline = createRelayPipeline, hedgedFirstChunkRace: race = hedgedFirstChunkRace } = deps;
+  const d = hedgeDelayMs;
+  try {
+    const hedged = await race({ localUpRes: upRes, peers, handlerCtx, hedgeDelayMs: d, evt });
+    if (hedged && hedged.winner) {
+      if (hedged.winner === "local") {
+        const bufferedUpRes = { ...upRes, body: hedged.bufferedBody, headers: upRes.headers, status: upRes.status, _t: upRes._t };
+        const pipeline = createPipeline({
+          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,
+          attemptStartMs,
+          stages,
+          startedAt,
+        });
+        // 保留 hedged 语义：若超时则透传 needs fallback
+        if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+        return { handled: true };
+      }
+      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 });
+        const bufferedPeerRes = { ...win.res, body: hedged.bufferedBody, headers: win.res.headers, status: win.res.status, _t: win.res._t };
+        const pipeline = createPipeline({
+          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: bufferedPeerRes,
+          body,
+          requested,
+          actual: win.target,
+          lastErr,
+          via: "peer",
+          lockModel,
+          useAuto,
+          handlerCtx: { ...handlerCtx, model: win.target },
+          mark: (n) => mark(n),
+          perf0,
+          attemptStartMs,
+          stages,
+          startedAt,
+        });
+        if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+        return { handled: true };
+      }
+    }
+    if (hedged && hedged.needsPeer) {
+      return { handled: false, upRes: null, lastErr, needsPeer: true };
+    }
+    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 };
+  }
+}

package/src/routes/chat/index.js

@@ -1 +1 @@
-export { createChatGateway, chatHandler } from "./gateway.js";
+export { createChatGateway, chatHandler } from "./gateway.js";

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

@@ -1,63 +1,63 @@
-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";
-
-/** 薄适配：本地透传唯一经由 relay-pipeline */
-export async function handleLocalRelay({
-  upRes,
-  model,
-  body,
-  order,
-  idx,
-  lastErr,
-  requested,
-  useAuto,
-  lockModel,
-  auto,
-  handlerCtx,
-  evt,
-  logCall,
-  logError,
-  mark,
-  perf0,
-  attemptStartMs,
-  stages,
-  startedAt,
-  plugins,
-  res,
-}) {
-  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,
-    attemptStartMs,
-    stages,
-    startedAt,
-  });
-  // wrotePayload 是「正文真到了下游」的送达证据：serial-trial 记 empty-turn-recovered 只认它，
-  // 不认 handled 本身（handled 也覆盖下游已断开等零输出路径，见 ADR-0043）。
-  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-  return { handled: true, wrotePayload: r.wrotePayload === true };
-}
+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";
+
+/** 薄适配：本地透传唯一经由 relay-pipeline */
+export async function handleLocalRelay({
+  upRes,
+  model,
+  body,
+  order,
+  idx,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  handlerCtx,
+  evt,
+  logCall,
+  logError,
+  mark,
+  perf0,
+  attemptStartMs,
+  stages,
+  startedAt,
+  plugins,
+  res,
+}) {
+  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,
+    attemptStartMs,
+    stages,
+    startedAt,
+  });
+  // wrotePayload 是「正文真到了下游」的送达证据：serial-trial 记 empty-turn-recovered 只认它，
+  // 不认 handled 本身（handled 也覆盖下游已断开等零输出路径，见 ADR-0043）。
+  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+  return { handled: true, wrotePayload: r.wrotePayload === true };
+}

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

@@ -1,82 +1,82 @@
-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 { racePeerCandidates, peerStageCtx } from "../peers.js";
-
-/** 薄适配：peer 赛跑后经由 pipeline（via=peer） */
-export async function handlePeerRelay({
-  model,
-  body,
-  lastErr,
-  requested,
-  useAuto,
-  lockModel,
-  auto,
-  peers,
-  handlerCtx,
-  evt,
-  logCall,
-  mark,
-  perf0,
-  attemptStartMs,
-  stages,
-  startedAt,
-  plugins,
-  res,
-  deps = {},
-}) {
-  const { createPipeline = createRelayPipeline, racePeerCandidates: race = racePeerCandidates } = deps;
-  evt("peer-race-start", { reqId: handlerCtx.reqId, model, peers: peers.ordered().length });
-  const peerErrors = [];
-  // 三批共享同一 peer 阶段总预算（同 hedge：旧行为是每批各吃满一次等头超时，串行叠加到 90s+）
-  const pctx = peerStageCtx({ ...handlerCtx, peerErrors });
-  const win =
-    (await race(peers.ordered(), pctx)) ||
-    (await race(peers.orderedByLastError(), pctx)) ||
-    (await race(peers.coolingByLastError(), pctx));
-  if (!win) {
-    evt("peer-race-lose", { reqId: handlerCtx.reqId, model });
-    // 组员全失败：把每个组员的真实返回汇总给调用者（否则只剩一个无信息的 429/502）
-    const detail = peerErrors.length
-      ? peerErrors.map((e) => `${e.peer} -> ${e.status}${e.message ? ` (${String(e.message).slice(0, 160)})` : ""}`).join("; ")
-      : "no peers available";
-    const allLimit = peerErrors.length > 0 && peerErrors.every((e) => e.status === 429);
-    return { handled: false, lastErr: { model, upstream: null, status: allLimit ? 429 : 502, message: `peers failed: ${detail}` } };
-  }
-  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 });
-
-  const pipeline = createPipeline({
-    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: win.res,
-    body,
-    requested,
-    actual: win.target,
-    lastErr,
-    via: "peer",
-    lockModel,
-    useAuto,
-    handlerCtx: { ...handlerCtx, model: win.target },
-    mark,
-    perf0,
-    attemptStartMs,
-    stages,
-    startedAt,
-  });
-  // Note: 超时/失败必须把 handled:false 交回上层换候选（丢弃 → 响应永不 end）— 见 .agents/notes/implemented/bug-fix/2026-09-17-relay-first-chunk-gate-real-cancel.md
-  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
-  return { handled: true };
+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 { racePeerCandidates, peerStageCtx } from "../peers.js";
+
+/** 薄适配：peer 赛跑后经由 pipeline（via=peer） */
+export async function handlePeerRelay({
+  model,
+  body,
+  lastErr,
+  requested,
+  useAuto,
+  lockModel,
+  auto,
+  peers,
+  handlerCtx,
+  evt,
+  logCall,
+  mark,
+  perf0,
+  attemptStartMs,
+  stages,
+  startedAt,
+  plugins,
+  res,
+  deps = {},
+}) {
+  const { createPipeline = createRelayPipeline, racePeerCandidates: race = racePeerCandidates } = deps;
+  evt("peer-race-start", { reqId: handlerCtx.reqId, model, peers: peers.ordered().length });
+  const peerErrors = [];
+  // 三批共享同一 peer 阶段总预算（同 hedge：旧行为是每批各吃满一次等头超时，串行叠加到 90s+）
+  const pctx = peerStageCtx({ ...handlerCtx, peerErrors });
+  const win =
+    (await race(peers.ordered(), pctx)) ||
+    (await race(peers.orderedByLastError(), pctx)) ||
+    (await race(peers.coolingByLastError(), pctx));
+  if (!win) {
+    evt("peer-race-lose", { reqId: handlerCtx.reqId, model });
+    // 组员全失败：把每个组员的真实返回汇总给调用者（否则只剩一个无信息的 429/502）
+    const detail = peerErrors.length
+      ? peerErrors.map((e) => `${e.peer} -> ${e.status}${e.message ? ` (${String(e.message).slice(0, 160)})` : ""}`).join("; ")
+      : "no peers available";
+    const allLimit = peerErrors.length > 0 && peerErrors.every((e) => e.status === 429);
+    return { handled: false, lastErr: { model, upstream: null, status: allLimit ? 429 : 502, message: `peers failed: ${detail}` } };
+  }
+  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 });
+
+  const pipeline = createPipeline({
+    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: win.res,
+    body,
+    requested,
+    actual: win.target,
+    lastErr,
+    via: "peer",
+    lockModel,
+    useAuto,
+    handlerCtx: { ...handlerCtx, model: win.target },
+    mark,
+    perf0,
+    attemptStartMs,
+    stages,
+    startedAt,
+  });
+  // Note: 超时/失败必须把 handled:false 交回上层换候选（丢弃 → 响应永不 end）— 见 .agents/notes/implemented/bug-fix/2026-09-17-relay-first-chunk-gate-real-cancel.md
+  if (!r.handled) return { handled: false, upRes: null, lastErr: r.lastErr };
+  return { handled: true };
 }

package/src/routes/chat.js

@@ -1,3 +1,3 @@
-// Facade — chat 逻辑已拆至 ./chat/ 子模块，按需加载保持单文件 <10KB
-export * from "./chat/index.js";
-export { chatHandler } from "./chat/index.js";
+// Facade — chat 逻辑已拆至 ./chat/ 子模块，按需加载保持单文件 <10KB
+export * from "./chat/index.js";
+export { chatHandler } from "./chat/index.js";