mslxdff 0.1.39 → 0.1.41

package/src/routes/helpers.js

@@ -0,0 +1,66 @@
+import { timingSafeEqual, createHash } from "node:crypto";
+
+export const errMsg = (err) => String(err?.message || err);
+
+export function clientIp(req) {
+  const fwd = req.headers["x-forwarded-for"];
+  const head = typeof fwd === "string" ? fwd.split(",")[0].trim() : "";
+  const raw = String(head || req.socket.remoteAddress || "");
+  return raw.replace(/^::ffff:/, "").replace(/^::1$/, "127.0.0.1") || null;
+}
+
+export function authorized(req, token) {
+  const header = req.headers["authorization"] || "";
+  const match = /^Bearer (.+)$/.exec(header);
+  if (!match) return false;
+  const digests = (s) => createHash("sha256").update(s).digest();
+  return timingSafeEqual(digests(match[1]), digests(token));
+}
+
+export function json(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(body));
+}
+
+export function notFound(res) {
+  return json(res, 404, { error: "Not Found" });
+}
+
+export function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (c) => (data += c));
+    req.on("end", () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+export function parseHops(header) {
+  const n = Number(header);
+  return Number.isInteger(n) && n >= 0 ? n : 0;
+}
+
+export const PROMPT_MAX_LEN = 160;
+
+export function summarizePrompt(body) {
+  const msgs = body?.messages;
+  if (!Array.isArray(msgs) || !msgs.length) return "";
+  const msg = msgs[msgs.length - 1];
+  const c = msg?.content;
+  let text = "";
+  if (typeof c === "string") text = c;
+  else if (Array.isArray(c)) {
+    text = c
+      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
+      .join(" ");
+  }
+  text = String(text || "").replace(/\s+/g, " ").trim();
+  return text.length > PROMPT_MAX_LEN ? text.slice(0, PROMPT_MAX_LEN) + "…" : text;
+}

package/src/routes/index.js

@@ -0,0 +1,91 @@
+import { timingSafeEqual, createHash } from "node:crypto";
+import { DEFAULT_MAX_HOPS } from "../peers.js";
+import { json, notFound, authorized } from "./helpers.js";
+import { chatHandler } from "./chat.js";
+import { joinHandler, leaveHandler } from "./groups.js";
+import { heartbeatHandler, pollHandler, resultHandler, forwardHandler } from "./groups-relay.js";
+import { modelsHandler, modelsStatusHandler } from "./models-route.js";
+
+export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus }) {
+  return async function router(req, res) {
+    const method = req.method || "GET";
+    const path = (req.url || "").split("?")[0];
+    const route = ROUTES.find((r) => r.method === method && r.path === path);
+    if (!route) return notFound(res);
+    if (route.requiresAuth && !authorized(req, token)) {
+      res.statusCode = 401;
+      res.setHeader("WWW-Authenticate", "Bearer");
+      return json(res, 401, { error: "Unauthorized" });
+    }
+    await route.handler({ req, res, upstream, models, auto, logs, peers, maxHops, groups, bans, token, bus });
+  };
+}
+
+const ROUTES = [
+  {
+    method: "GET",
+    path: "/health",
+    handler: ({ res }) => json(res, 200, { status: "ok" }),
+  },
+  {
+    method: "POST",
+    path: "/v1/chat/completions",
+    requiresAuth: true,
+    handler: chatHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/join",
+    requiresAuth: false,
+    handler: joinHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/leave",
+    requiresAuth: false,
+    handler: leaveHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/relay/heartbeat",
+    requiresAuth: false,
+    handler: heartbeatHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/relay/poll",
+    requiresAuth: false,
+    handler: pollHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/relay/result",
+    requiresAuth: false,
+    handler: resultHandler,
+  },
+  {
+    method: "POST",
+    path: "/v1/groups/relay/forward",
+    requiresAuth: true,
+    handler: forwardHandler,
+  },
+  {
+    method: "GET",
+    path: "/v1/models",
+    requiresAuth: true,
+    handler: modelsHandler,
+  },
+  {
+    method: "GET",
+    path: "/v1/models/status",
+    requiresAuth: true,
+    handler: modelsStatusHandler,
+  },
+];
+
+// re-export for facade & tests
+export { errMsg, PROMPT_MAX_LEN, summarizePrompt, clientIp, authorized, json, notFound, readBody, parseHops } from "./helpers.js";
+export { buildFallbackInfo, applyFallbackHeaders, enrichNonStreamJson, enrichSseChunkText } from "./fallback.js";
+export { relay, SLOW_TOTAL_MS, STREAM_TIMEOUT_MS, STALL_TIMEOUT_MS, SCORE_STALL_MS, MAX_STREAM_MS } from "./stream.js";
+export { peerHealthyModels, racePeerCandidates, PEER_RACE_LIMIT } from "./peers.js";
+export { enqueueRelay, dequeueRelayForPoll, resolveRelay, tryBroadbandRelay } from "./relay-queue.js";

package/src/routes/models-route.js

@@ -0,0 +1,31 @@
+import { json, errMsg } from "./helpers.js";
+
+export async function modelsHandler({ res, models }) {
+  if (!models) return json(res, 501, { error: "Models service not configured" });
+  try {
+    const data = await models.get();
+    json(res, 200, data);
+  } catch (err) {
+    json(res, 502, { error: errMsg(err) });
+  }
+}
+
+export async function modelsStatusHandler({ res, models, auto }) {
+  const statuses = auto?.statuses?.() || {};
+  let ids = [];
+  try {
+    ids = (await models?.get?.())?.data?.map((m) => m.id) || [];
+  } catch {}
+  const seen = new Set();
+  const data = [];
+  for (const id of [...ids, ...Object.keys(statuses)]) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const e = statuses[id];
+    const entry = typeof e === "number"
+      ? { id, status: "error", at: e }
+      : { id, status: e?.status || "normal", at: e?.at ?? null, code: e?.code ?? null };
+    data.push(entry);
+  }
+  json(res, 200, { object: "list", data });
+}

package/src/routes/peers.js

@@ -0,0 +1,125 @@
+import { performance } from "node:perf_hooks";
+import { isAutoModel } from "../auto.js";
+import { errMsg } from "./helpers.js";
+
+const PEER_TIMEOUT_MS = 30_000;
+const PEER_STATUS_TIMEOUT_MS = 2_000;
+
+export async function peerHealthyModels(peer, { timeoutMs = PEER_STATUS_TIMEOUT_MS, fetchImpl = fetch } = {}) {
+  try {
+    const res = await fetchImpl(`${peer.url}/v1/models/status`, {
+      headers: {
+        "Authorization": `Bearer ${peer.token || ""}`,
+        "Accept": "application/json",
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) return [];
+    const j = await res.json().catch(() => ({}));
+    return (j.data || [])
+      .filter((m) => m && typeof m.id === "string" && m.status === "normal")
+      .map((m) => m.id);
+  } catch {
+    return [];
+  }
+}
+
+async function forwardToPeer(peer, body, model, hops) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PEER_TIMEOUT_MS);
+  try {
+    return await fetch(`${peer.url}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${peer.token}`,
+        "x-mslxdff-hops": String(hops + 1),
+        "x-mslxdff-model-lock": model,
+        "Accept": "text/event-stream",
+      },
+      body: JSON.stringify({ ...body, model }),
+      signal: controller.signal,
+    });
+  } catch (err) {
+    return err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function resolvePeerTarget(ctx, peer) {
+  const prevModel = ctx.peers.stat(peer.url)?.model;
+  const hot = ctx.peers.isHot(peer.url) && prevModel === ctx.model;
+  if (hot) return { peer, target: prevModel };
+  const isExplicit = !!ctx.model && !isAutoModel(ctx.model);
+  if (isExplicit) {
+    const healthy = await peerHealthyModels(peer);
+    if (!healthy.length) {
+      ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0, strict: true });
+      return { peer, target: ctx.model };
+    }
+    ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length, strict: true });
+    return { peer, target: ctx.model };
+  }
+  const healthy = await peerHealthyModels(peer);
+  if (!healthy.length) {
+    await ctx.peers.recordError(peer.url);
+    ctx.logError(ctx.model, 0, `peer ${peer.url} has no healthy models`);
+    ctx.evt("peer-health", { peer: peer.url, healthy: [], count: 0 });
+    return null;
+  }
+  ctx.evt("peer-health", { peer: peer.url, healthy, count: healthy.length });
+  return { peer, target: healthy.includes(ctx.model) ? ctx.model : healthy[0] };
+}
+
+export const PEER_RACE_LIMIT = Number(process.env.MSLXDFF_PEER_RACE_LIMIT) > 0
+  ? Number(process.env.MSLXDFF_PEER_RACE_LIMIT)
+  : 3;
+
+export async function racePeerCandidates(candidates, ctx) {
+  for (let i = 0; i < candidates.length; i += PEER_RACE_LIMIT) {
+    const batch = candidates.slice(i, i + PEER_RACE_LIMIT);
+    const prepared = (await Promise.all(batch.map((peer) => resolvePeerTarget(ctx, peer)))).filter(Boolean);
+    if (!prepared.length) continue;
+    const completed = await new Promise((resolve) => {
+      const order = [];
+      const total = prepared.length;
+      for (const { peer, target } of prepared) {
+        ctx.evt("peer-request", { peer: peer.url, model: target, hops: ctx.hops + 1 });
+        const t0 = performance.now();
+        forwardToPeer(peer, ctx.body, target, ctx.hops).then((res) => {
+          const latencyMs = Math.round(performance.now() - t0);
+          const failed = res instanceof Error || res.status >= 400;
+          ctx.evt("peer-forward", { peer: peer.url, model: target, hops: ctx.hops + 1, latencyMs, ok: !failed });
+          if (failed) {
+            const status = res instanceof Error ? 502 : res.status;
+            ctx.logError(ctx.model, status, res instanceof Error ? errMsg(res) : `peer ${status}`);
+            ctx.evt("peer-error", { peer: peer.url, model: target, status, message: res instanceof Error ? errMsg(res) : null });
+            order.push({ ok: false, peer, target, res, status });
+          } else {
+            order.push({ ok: true, peer, target, res, latencyMs });
+          }
+          if (order.length === total) resolve(order);
+        });
+      }
+    });
+    const winner = completed.find((o) => o.ok);
+    if (winner) {
+      for (const o of completed) {
+        if (o === winner) continue;
+        if (!o.ok) {
+          await ctx.peers.recordError(o.peer.url);
+          await ctx.peers.recordResult(o.peer.url, { ok: false });
+        } else {
+          await ctx.peers.recordResult(o.peer.url, { ok: true, latencyMs: o.latencyMs, model: o.target });
+        }
+      }
+      return { peer: winner.peer, target: winner.target, res: winner.res, latencyMs: winner.latencyMs };
+    }
+    for (const o of completed) {
+      await ctx.peers.recordError(o.peer.url);
+      await ctx.peers.recordResult(o.peer.url, { ok: false });
+    }
+  }
+  return null;
+}

package/src/routes/relay-queue.js

@@ -0,0 +1,127 @@
+import { loadGroupsJoined } from "../state.js";
+
+const relayPending = new Map();
+const relayPendingByReqId = new Map();
+
+export function enqueueRelay({ group, target, reqId, body, hops }) {
+  const key = `${group}::${target}`;
+  const list = relayPending.get(key) || [];
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const idx = list.findIndex((e) => e.reqId === reqId);
+      if (idx >= 0) list.splice(idx, 1);
+      relayPendingByReqId.delete(reqId);
+      reject(new Error("relay timeout"));
+    }, 30_000);
+    timer.unref?.();
+    const entry = { reqId, body, hops, resolve, reject, timer };
+    list.push(entry);
+    relayPending.set(key, list);
+    relayPendingByReqId.set(reqId, entry);
+  });
+}
+
+export function dequeueRelayForPoll({ group, target, limit = 10 }) {
+  const key = `${group}::${target}`;
+  const list = relayPending.get(key) || [];
+  const batch = list.splice(0, limit);
+  if (list.length) relayPending.set(key, list);
+  else relayPending.delete(key);
+  return batch.map((e) => ({ reqId: e.reqId, body: e.body, hops: e.hops }));
+}
+
+export function resolveRelay(reqId, result) {
+  const entry = relayPendingByReqId.get(reqId);
+  if (!entry) return false;
+  clearTimeout(entry.timer);
+  relayPendingByReqId.delete(reqId);
+  entry.resolve(result);
+  return true;
+}
+
+export function getRelayPending() { return relayPending; }
+export function getRelayPendingByReqId() { return relayPendingByReqId; }
+
+export async function tryBroadbandRelay({ groups, token: myToken, model, body, hops, bus, logs, reqId, evt, res, mark, perf0, stages }) {
+  try {
+    const joined = loadGroupsJoined();
+    const broadbandGroups = joined.filter((g) => g.kind === "broadband" || g.myUrl?.startsWith("relay://"));
+    const allCandidates = [];
+    if (groups) {
+      const localGroups = groups.list();
+      for (const [gName, g] of Object.entries(localGroups)) {
+        for (const [id, m] of Object.entries(g.members || {})) {
+          if (id === "leader") continue;
+          const isBb = m?.kind === "broadband" || String(m?.url || "").startsWith("relay://");
+          if (!isBb) continue;
+          const staleMs = Number(process.env.MSLXDFF_BROADBAND_STALE_MS) > 0 ? Number(process.env.MSLXDFF_BROADBAND_STALE_MS) : 90_000;
+          if (typeof m.lastSeen === "number" && Date.now() - m.lastSeen > staleMs) continue;
+          allCandidates.push({ group: gName, target: m.url, member: m, via: "local-leader", leaderUrl: null });
+        }
+      }
+    }
+    for (const g of joined) {
+      if (!g.leaderUrl) continue;
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5000);
+        const r = await fetch(`${g.leaderUrl}/v1/groups/join`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": `Bearer ${myToken}` },
+          body: JSON.stringify({ name: g.name, memberName: g.memberName, url: g.myUrl, token: myToken }),
+          signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!r.ok) continue;
+        const data = await r.json().catch(() => ({}));
+        const members = data.members || {};
+        for (const [id, m] of Object.entries(members)) {
+          if (id === "leader") continue;
+          const isBb = m?.kind === "broadband" || String(m?.url || "").startsWith("relay://");
+          if (!isBb) continue;
+          if (m.url === g.myUrl) continue;
+          const staleMs = Number(process.env.MSLXDFF_BROADBAND_STALE_MS) > 0 ? Number(process.env.MSLXDFF_BROADBAND_STALE_MS) : 90_000;
+          if (typeof m.lastSeen === "number" && Date.now() - m.lastSeen > staleMs) continue;
+          allCandidates.push({ group: g.name, target: m.url, member: m, via: "via-leader", leaderUrl: g.leaderUrl });
+        }
+      } catch {}
+    }
+    if (!allCandidates.length) return null;
+    for (const cand of allCandidates) {
+      try {
+        evt?.("relay-try", { reqId, model, via: cand.via, target: cand.target, group: cand.group });
+        if (!cand.leaderUrl) {
+          const fwdBody = { model, ...body, model };
+          const reqIdLocal = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+          const promise = enqueueRelay({ group: cand.group, target: cand.target, reqId: reqIdLocal, body: fwdBody, hops });
+          const result = await promise;
+          if (result && result.status) {
+            return { via: "broadband-local", result, target: cand.target, group: cand.group };
+          }
+        } else {
+          const ctrl = new AbortController();
+          const t = setTimeout(() => ctrl.abort(), 35_000);
+          const r = await fetch(`${cand.leaderUrl}/v1/groups/relay/forward`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${myToken}`, "x-mslxdff-hops": String(hops + 1) },
+            body: JSON.stringify({ group: cand.group, target: cand.target, body: { ...body, model }, hops: hops + 1, reqId }),
+            signal: ctrl.signal,
+          });
+          clearTimeout(t);
+          if (!r.ok) {
+            const txt = await r.text().catch(() => "");
+            evt?.("relay-fail", { reqId, model, via: cand.via, target: cand.target, status: r.status, message: txt.slice(0, 200) });
+            continue;
+          }
+          return { via: "broadband-via-leader", result: r, target: cand.target, group: cand.group };
+        }
+      } catch (err) {
+        evt?.("relay-fail", { reqId, model, via: cand.via, target: cand.target, message: String(err?.message || err).slice(0, 200) });
+        continue;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/routes/stream.js

@@ -0,0 +1,194 @@
+import { performance } from "node:perf_hooks";
+import { applyFallbackHeaders, enrichNonStreamJson, enrichSseChunkText } from "./fallback.js";
+import { json } from "./helpers.js";
+
+export const SLOW_TOTAL_MS = (() => {
+  const n = Number(process.env.MSLXDFF_SLOW_TOTAL_MS);
+  return Number.isInteger(n) && n > 0 ? n : 20_000;
+})();
+
+export const STREAM_TIMEOUT_MS = (() => {
+  const n = Number(process.env.MSLXDFF_STREAM_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 25_000;
+})();
+
+export const STALL_TIMEOUT_MS = (() => {
+  const n = Number(process.env.MSLXDFF_STALL_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+})();
+
+export const SCORE_STALL_MS = (() => {
+  const raw = process.env.MSLXDFF_SCORE_STALL_MS ?? process.env.MSLXDFF_STALL_TIMEOUT_MS;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : 15_000;
+})();
+
+export const MAX_STREAM_MS = (() => {
+  const n = Number(process.env.MSLXDFF_MAX_STREAM_MS);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+})();
+
+export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort, streamTimeoutMs = STREAM_TIMEOUT_MS, fallback } = {}) {
+  const t0 = performance.now();
+  const contentType = upRes.headers.get("content-type") || "";
+  const isStream = Boolean(body?.stream) || contentType.includes("text/event-stream");
+  res.statusCode = upRes.status;
+  if (fallback) applyFallbackHeaders(res, fallback);
+
+  let ttf = null;
+  let interrupted = false;
+  let finishedNormally = false;
+  const detail = {
+    receivedChunks: 0,
+    receivedBytes: 0,
+    wroteChunks: 0,
+    wroteBytes: 0,
+    sawDone: false,
+    sawFinishReason: null,
+    lastChunkAtMs: null,
+    lastChunkGapMs: null,
+    maxGapMs: 0,
+    stallHits: 0,
+    exitReason: null,
+    upstreamError: null,
+    downstreamClosed: false,
+  };
+  let prevChunkAt = t0;
+  const onClose = () => {
+    detail.downstreamClosed = true;
+    if (!finishedNormally && onDownstreamAbort) onDownstreamAbort();
+  };
+  res.on("close", onClose);
+
+  if (isStream) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    if (fallback?.fallback) {
+      try {
+        res.write(`: mslxdff fallback ${fallback.requested_model} -> ${fallback.actual_model} (${fallback.reason})\n`);
+        res.write(`: notice ${fallback.notice}\n\n`);
+      } catch {}
+    }
+    if (upRes.body) {
+      let first = true;
+      let wroteAny = false;
+      let timedOut = false;
+      let stalled = false;
+      let tooLong = false;
+      let stallTimer = null;
+      const armStall = () => {
+        if (stallTimer) clearTimeout(stallTimer);
+        stallTimer = STALL_TIMEOUT_MS
+          ? setTimeout(() => {
+              stalled = true;
+              detail.exitReason = "stall";
+              if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
+            }, STALL_TIMEOUT_MS)
+          : null;
+      };
+      let firstTimer = setTimeout(() => {
+        timedOut = true;
+        detail.exitReason = "first-timeout";
+        if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
+      }, streamTimeoutMs);
+      const maxTimer = MAX_STREAM_MS
+        ? setTimeout(() => {
+            tooLong = true;
+            detail.exitReason = "max";
+            if (typeof upRes.body.cancel === "function") upRes.body.cancel().catch(() => {});
+          }, MAX_STREAM_MS)
+        : null;
+      try {
+        for await (const chunk of upRes.body) {
+          const now = performance.now();
+          detail.receivedChunks += 1;
+          const len = chunk?.length ?? chunk?.byteLength ?? 0;
+          detail.receivedBytes += len;
+          const gap = Math.round(now - prevChunkAt);
+          detail.lastChunkAtMs = Math.round(now - t0);
+          detail.lastChunkGapMs = gap;
+          if (gap > detail.maxGapMs) detail.maxGapMs = gap;
+          if (gap > SCORE_STALL_MS) detail.stallHits += 1;
+          prevChunkAt = now;
+          try {
+            const txt = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : typeof chunk === "string" ? chunk : "";
+            if (txt.includes("[DONE]")) detail.sawDone = true;
+            const m = txt.match(/"finish_reason"\s*:\s*"([^"]+)"/);
+            if (m) detail.sawFinishReason = m[1];
+          } catch { /* ignore */ }
+          if (timedOut || stalled || tooLong) break;
+          if (first) {
+            first = false;
+            ttf = Math.round(now - t0);
+            onFirstChunk?.(ttf);
+            if (firstTimer) { clearTimeout(firstTimer); firstTimer = null; }
+          }
+          let outChunk = chunk;
+          if (first === false && fallback?.fallback && wroteAny === false) {
+            try {
+              let txt = "";
+              if (Buffer.isBuffer(chunk)) txt = chunk.toString("utf8");
+              else if (chunk instanceof Uint8Array) txt = Buffer.from(chunk).toString("utf8");
+              else if (typeof chunk === "string") txt = chunk;
+              if (txt.includes("data:")) {
+                const enriched = enrichSseChunkText(txt, fallback);
+                if (enriched !== txt) outChunk = Buffer.from(enriched, "utf8");
+              }
+            } catch {}
+          }
+          wroteAny = true;
+          detail.wroteChunks += 1;
+          detail.wroteBytes += Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
+          res.write(outChunk);
+          armStall();
+        }
+        if (!detail.exitReason) detail.exitReason = "normal";
+      } catch (err) {
+        detail.upstreamError = String(err?.message || err).slice(0, 300);
+        detail.exitReason = "upstream-error";
+        if (!wroteAny) timedOut = true;
+        else stalled = true;
+      } finally {
+        if (firstTimer) clearTimeout(firstTimer);
+        if (maxTimer) clearTimeout(maxTimer);
+        if (stallTimer) clearTimeout(stallTimer);
+      }
+      if (timedOut && !wroteAny) {
+        res.removeListener("close", onClose);
+        return { status: STREAM_TIMEOUT_MS, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: true, interrupted: false, detail };
+      }
+      if ((stalled || tooLong) && wroteAny) {
+        interrupted = true;
+        detail.exitReason = detail.exitReason || (stalled ? "stall" : "max");
+        res.removeListener("close", onClose);
+        try { res.end(); } catch { /* ignore */ }
+        return { status: 200, ttfMs: ttf, totalMs: Math.round(performance.now() - t0), aborted: false, interrupted, detail };
+      }
+    } else {
+      detail.exitReason = "empty-body";
+    }
+    const totalMs = Math.round(performance.now() - t0);
+    if (!detail.exitReason) detail.exitReason = "normal";
+    finishedNormally = true;
+    res.removeListener("close", onClose);
+    try { res.end(); } catch { /* ignore */ }
+    return { status: 200, ttfMs: ttf, totalMs, aborted: false, interrupted: false, detail };
+  }
+
+  finishedNormally = true;
+  res.removeListener("close", onClose);
+  const text = await upRes.text();
+  detail.receivedBytes = Buffer.byteLength(text);
+  detail.exitReason = "normal-non-stream";
+  try {
+    const parsed = JSON.parse(text);
+    const enriched = enrichNonStreamJson(parsed, fallback);
+    json(res, upRes.status, enriched);
+  } catch {
+    res.statusCode = upRes.status;
+    res.setHeader("Content-Type", contentType || "text/plain");
+    res.end(text);
+  }
+  return { status: upRes.status, ttfMs: null, totalMs: Math.round(performance.now() - t0), aborted: false, interrupted: false, detail };
+}