mslxdff 0.1.152 → 0.1.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.152",
+  "version": "0.1.154",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/chat-pipeline/index.js

@@ -4,6 +4,8 @@ import { createEngine } from "./engine.js";
 import { runHook } from "../plugins.js";
 import { isFreeModel } from "../models.js";
 import { clientIp, summarizePrompt } from "../routes/helpers.js";
+import { formatTimeline } from "../timeline.js";
+import { summarizeRequest, shouldTraceModel } from "../model-trace.js";
 
 /**
  * ChatPipeline 深模块门面 — 对外 execute(req) 单一 inlet
@@ -25,6 +27,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     mark("parsed");
     if (aliasInfo) { try { res?.setHeader?.("x-mslxdff-alias", aliasInfo); } catch {} }
     // mslxdff/ 前缀或 alias 命中时，把 body.model 改写为还原后的模型（与原 gateway 语义一致）
+    const timeline = { direct: [], peers: [], retries: 0, result: null };
     if (aliasInfo && req?.body && req.body.model !== requested) {
       req.body = { ...req.body, model: requested };
     }
@@ -35,6 +38,25 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     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] };
+      const traceModel = entry.model || requested;
+      if (shouldTraceModel(type)) {
+        // Note: 模型日志只投影安全字段，不能把含 prompt 的 entry 原样下传 — 见 .agents/notes/implemented/feature/2026-09-25-model-trace-log.md
+        const safeTraceData = { ...entry };
+        if (safeTraceData.prompt !== undefined) delete safeTraceData.prompt;
+        logs?.appendModelTrace?.(traceModel, { type, reqId, model: traceModel, data: safeTraceData, request: type === "request" ? summarizeRequest(req?.body) : null, totalMs: entry.durationMs });
+      }
+      if (type === "peer-forward") timeline.peers.push({ peer: entry.peer, ok: entry.ok === true, status: entry.status, latencyMs: entry.latencyMs, message: entry.message || entry.error || "" });
+      if (type === "upstream-done" || type === "upstream-error") timeline.direct.push({ status: entry.status, reason: entry.message || entry.error || "" });
+      if (type === "peer-error") {
+        const known = timeline.peers.find((p) => p.peer === entry.peer);
+        if (known) { known.ok = false; known.status = entry.status ?? known.status; known.message = entry.message || entry.error || known.message; }
+        else timeline.peers.push({ peer: entry.peer, ok: false, status: entry.status, message: entry.message || entry.error || "" });
+      }
+      if (type === "empty-turn-retry") timeline.retries += 1;
+      if (type === "result" || (type === "client-response" && !timeline.result)) {
+        timeline.result = { status: entry.status, detail: entry.detail || null };
+        try { logs?.appendTimeline?.(formatTimeline({ reqId, model: entry.model || requested, ...timeline, totalMs: Date.now() - startedAt })); } catch {}
+      }
       if (bus) bus.emit(entry);
       logs?.appendEvent?.(entry);
     };

package/src/chat-pipeline/serial-trial.js

@@ -10,6 +10,7 @@ import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
 import { handleViaRoute } from "../routes/chat/via-route-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
 import { shouldUseGroupForModel, isHardLocalOnly, isKeyProviderDirectOnly } from "../state/schemas/use-group.js";
+import { summarizeRequest } from "../model-trace.js";
 import { isEmptyTurnError } from "../routes/chat/relay-pipeline.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -97,7 +98,7 @@ export async function runSerialTrial(ctx, deps = {}) {
     let emptyRetried = 0;
     for (;;) {
       const tUp = performance.now();
-      evt("upstream-try", { reqId, model, attempt: idx + 1, emptyRetry: emptyRetried });
+      evt("upstream-try", { reqId, model, attempt: idx + 1, emptyRetry: emptyRetried, payload: summarizeRequest(forwarded) });
       try {
         upRes = await upstream.chat(forwarded, chatOptsArg);
         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 });

package/src/cli/commands/system.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { defaultStateFile } from "../../state.js";
 import { loadToken, refreshToken } from "../../state.js";
 import { stopDaemon, pidFile, logFile } from "../../daemon.js";
-import { logDir, eventsFile, callsFile, errorsFile, recentEvents } from "../../logs.js";
+import { logDir, eventsFile, callsFile, errorsFile, recentEvents, timelineFile, recentTimeline } from "../../logs.js";
 import { fmtEvent } from "../format.js";
 import { fmtShanghaiYMDHMS, fmtShanghaiHMS } from "../../time.js";
 import { printHelp } from "../help.js";
@@ -95,6 +95,7 @@ export async function handleUninstall(args) {
     join(dir, "calls.log"),
     join(dir, "errors.log"),
     join(dir, "events.log"),
+    join(dir, "timeline.log"),
   ]) {
     try {
       rmSync(f, { force: true });
@@ -128,6 +129,13 @@ export async function handleLog(args) {
   if (count <= 10) {
     console.log(`\nhint: mslxdff -log 100  |  calls: ${callsFile()}  errors: ${errorsFile()}  daemon: ${logFile()}`);
   }
+  const timeline = recentTimeline(count);
+  if (timeline.length) {
+    console.log(`--- last ${timeline.length} timeline line(s) ---`);
+    for (const line of timeline) console.log(line);
+  }
+  console.log(`timeline: ${timelineFile()}`);
+  console.log(`model logs: ${dir}\\<provider>-<model>.log`);
   process.exit(0);
 }
 

package/src/logs.js

@@ -25,6 +25,10 @@ export function eventsFile() {
   return join(logDir(), "events.log");
 }
 
+export function timelineFile() {
+  return join(logDir(), "timeline.log");
+}
+
 function ensureDir(dir) {
   mkdirSync(dir, { recursive: true });
 }
@@ -86,6 +90,13 @@ function appendLine(file, entry) {
     .then(() => trimIfOversizedAsync(file).catch(() => {}));
 }
 
+export function recentTimeline(n = 10, { file = timelineFile() } = {}) {
+  try {
+    if (!existsSync(file)) return [];
+    return readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-n);
+  } catch { return []; }
+}
+
 export function appendCall(entry, { file = callsFile() } = {}) {
   appendLine(file, entry);
 }
@@ -132,3 +143,14 @@ export function lastError({ file = errorsFile() } = {}) {
 export function recentErrors(n = 5, { file = errorsFile() } = {}) {
   return readLines(file).slice(-n);
 }
+
+export function appendTimeline(entry, { file = timelineFile() } = {}) {
+  const line = `${fmtShanghaiYMDHMS(new Date())} ${String(entry || "")}\n`;
+  ensureDir(dirname(file));
+  if (shouldSync(file)) {
+    appendFileSync(file, line);
+    trimIfOversized(file);
+    return;
+  }
+  appendFile(file, line).catch(() => {}).then(() => trimIfOversizedAsync(file).catch(() => {}));
+}

package/src/model-trace.js

@@ -0,0 +1,97 @@
+// Per-model request trace formatting. Never include prompt, response body, headers or credentials.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logDir } from "./logs.js";
+import { fmtShanghaiYMDHMS } from "./time.js";
+
+const MAX_TRACE_BYTES = 1024 * 1024;
+
+export function modelLogName(model) {
+  const s = String(model || "unknown").trim().toLowerCase();
+  const safe = s.replace(/[^a-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 180);
+  return `${safe || "unknown"}.log`;
+}
+
+export function modelLogFile(model) {
+  return join(logDir(), modelLogName(model));
+}
+
+
+function count(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+export function summarizeRequest(body = {}) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const roles = {};
+  for (const m of messages) roles[String(m?.role || "unknown")] = (roles[String(m?.role || "unknown")] || 0) + 1;
+  return {
+    stream: body.stream === true,
+    messages: messages.length,
+    roles,
+    tools: Array.isArray(body.tools) ? body.tools.length : 0,
+    maxTokens: count(body.max_tokens ?? body.max_completion_tokens),
+    temperature: Number.isFinite(Number(body.temperature)) ? Number(body.temperature) : null,
+    topP: Number.isFinite(Number(body.top_p)) ? Number(body.top_p) : null,
+  };
+}
+
+function hostPort(value) {
+  try { const u = new URL(String(value)); return u.port ? `${u.hostname}:${u.port}` : u.hostname; } catch { return "-"; }
+}
+const TRACE_STAGES = new Set([
+  "request", "alias", "ordered", "model-try", "upstream-try", "upstream-done", "upstream-error",
+  "peer-request", "peer-forward", "peer-error", "relay-start", "relay-first-chunk", "relay-done",
+  "client-response", "result", "exhausted-local", "exhausted-all",
+]);
+
+export function shouldTraceModel(type) {
+  return TRACE_STAGES.has(String(type || ""));
+}
+
+function safeText(value, n = 140) {
+  return String(value ?? "")
+    .replace(/([?&](?:token|refreshToken|access[_-]?token|refresh[_-]?token|api[_-]?key|apikey|key|secret|password|cookie)=)[^&\s]+/gi, "$1[redacted]")
+    .replace(/(authorization|bearer|access[_-]?token|refresh[_-]?token|cookie|api[-_]?key|password|secret)\s*[:=]\s*[^,; ]+/gi, "$1=[redacted]")
+    .replace(/\s+/g, " ").trim().slice(0, n);
+}
+
+function kv(obj) {
+  return Object.entries(obj).filter(([, v]) => v != null && v !== "").map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+}
+
+export function formatModelTrace({ type, reqId, model, data = {}, request = null, totalMs = null } = {}) {
+  const base = { time: fmtShanghaiYMDHMS(new Date()), req: reqId || "-", model: model || "-", stage: type || "-" };
+  let detail = "";
+  if (type === "request") detail = `incoming ${kv({ ...(request || summarizeRequest(data.body)), hops: data.hops, useAuto: data.useAuto })}`;
+  else if (type === "ordered") detail = `route order=${(data.order || []).join(" | ")} hops=${data.hops ?? "-"} fallback=${data.canFallback ? 1 : 0}`;
+  else if (type === "model-try") detail = `target=${data.model || model || "-"} idx=${data.idx ?? "-"} remaining=${data.remaining ?? "-"}`;
+  else if (type === "alias") detail = `rawModel=${data.rawModel || "-"} requested=${data.requested || model || "-"}`;
+  else if (type === "exhausted-local" || type === "exhausted-all") detail = `last=${data.lastModel || model || "-"} status=${data.lastStatus ?? "-"} order=${(data.order || []).join(" | ")}`;
+  else if (type === "upstream-try") detail = `target=${data.model || model || "-"} attempt=${data.attempt ?? "-"} payload=${kv(data.payload || {})}`;
+  else if (type === "upstream-done" || type === "upstream-error") detail = `upstream status=${data.status ?? "-"} timing=${data.timing?.totalMs ?? "-"}ms ${safeText(data.message || data.error || "")}`;
+  else if (type === "peer-request" || type === "peer-forward" || type === "peer-error") detail = `peer=${hostPort(data.peer)} status=${data.status ?? "-"} latency=${data.latencyMs ?? "-"}ms payload=${kv(data.payload || {})} ${safeText(data.message || data.error || "")}`;
+  else if (type === "relay-done") {
+    const d = data.detail || {};
+    const u = d.usage || {};
+    detail = `upstream_response status=${data.status ?? "-"} finish=${d.sawFinishReason || "-"} chunks=${d.receivedChunks ?? "-"} bytes=${d.receivedBytes ?? "-"} tools=${d.toolCalls ?? 0} chars=${d.chars ?? 0} usage(prompt=${u.prompt_tokens ?? "-"}/completion=${u.completion_tokens ?? "-"}) elapsed=${data.totalMs ?? "-"}ms`;
+  } else if (type === "result" || type === "client-response") {
+    detail = `client status=${data.status ?? "-"} via=${data.via || "-"} actual=${data.actual || model || "-"} fallback=${data.fallback?.fallback ? 1 : 0} total=${totalMs ?? data.durationMs ?? "-"}ms`;
+  } else detail = safeText(data.message || data.reason || data.error || "");
+  return `[${base.time}] [req=${base.req}] [model=${base.model}] [stage=${base.stage}] ${detail}`;
+}
+
+export function appendModelTrace(model, entry, { file = modelLogFile(model) } = {}) {
+  const line = `${formatModelTrace(entry)}\n`;
+  try {
+    mkdirSync(logDir(), { recursive: true });
+    if (existsSync(file) && statSync(file).size > MAX_TRACE_BYTES) {
+      const lines = readFileSync(file, "utf8").split("\n").filter(Boolean);
+      writeFileSync(file, lines.slice(-100).join("\n") + "\n");
+    }
+    appendFileSync(file, line);
+  } catch {
+    // Logging must never affect the chat request.
+  }
+}

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

@@ -15,6 +15,7 @@ export async function handleExhaustedLocal({ res, body, lastErr, order, handlerC
     });
     evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-exhausted", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
     evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
+    evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
     // 最后一站：relay 超时路径不写响应（设计留给上层 failover），这里没有上层，必须自己收尾
     if (out.timedOut) {
       json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
@@ -22,6 +23,7 @@ export async function handleExhaustedLocal({ res, body, lastErr, order, handlerC
     return true;
   }
   evt("result", { reqId: handlerCtx.reqId, model, status: lastErr?.status ?? 502, via: "none", timing: null });
+  evt("client-response", { requested, actual: model, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
   done({ via: "none", status: lastErr?.status ?? 502, error: lastErr?.message || "all auto models failed" });
   json(res, 502, { error: lastErr?.message || "all auto models failed" });
   return true;
@@ -39,6 +41,7 @@ export async function handleExhaustedAll({ res, body, lastErr, order, requested,
     });
     evt("relay-done", { reqId: handlerCtx.reqId, model: lastErr.model, via: "local-final", status: out.status, ttfMs: out.ttfMs, totalMs: out.totalMs, aborted: out.aborted, interrupted: out.interrupted ?? false, detail: out.detail ?? null });
     evt("result", { reqId: handlerCtx.reqId, model: lastErr.model, status: out.status, via: "local", timing: lastErr.upstream._t ?? null, ttfMs: out.ttfMs, totalMs: out.totalMs, detail: out.detail ?? null });
+    evt("client-response", { requested, actual: lastErr.model, via: "local", fallback: false, status: out.status, reqId: handlerCtx.reqId });
     // 最后一站：relay 超时路径不写响应，这里没有上层 failover，必须自己收尾
     if (out.timedOut) {
       json(res, 502, { error: out.detail?.upstreamError ? `upstream error: ${out.detail.upstreamError}` : `stream timed out after ${out.totalMs}ms` });
@@ -46,6 +49,7 @@ export async function handleExhaustedAll({ res, body, lastErr, order, requested,
     return true;
   }
   evt("result", { reqId: handlerCtx.reqId, model: lastErr?.model ?? requested, status: lastErr?.status ?? 502, via: "none", timing: null });
+  evt("client-response", { requested, actual: lastErr?.model ?? requested, via: "none", fallback: false, status: lastErr?.status ?? 502, reqId: handlerCtx.reqId });
   json(res, 502, { error: lastErr?.message || "all auto models failed" });
   return true;
 }

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

@@ -137,10 +137,12 @@ export function createRelayPipeline({
       !["tool_calls", "function_call"].includes(_d.sawFinishReason);
     if (_emptyTurn) {
       const _why = _d.sawFinishReason ? ` (finish_reason=${_d.sawFinishReason})` : " (no content, no tool calls)";
-      try { _logError(actual, 502, `empty turn${_why}`); } catch {}
+      // 错误包络暂扣后下游不再直观看到上游原文：把摘要带进最终报错（截断 200 字），排障不断线。
+      const _err = _d.upstreamErrorText ? ` upstream=${String(_d.upstreamErrorText).slice(0, 200)}` : "";
+      try { _logError(actual, 502, `empty turn${_why}${_err}`); } catch {}
       _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null });
       _evt("fallback", { reqId, from: actual, to: null, reason: "empty turn" });
-      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why} — retry or rephrase` } };
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err} — retry or rephrase` } };
     }
 
     // 5a. 首块超时未写字节 → 回退（显式 timedOut 字段，status 只是 HTTP 语义展示）

package/src/routes/peers.js

@@ -12,6 +12,7 @@ const DEFAULT_PEER_CONNECT_TIMEOUT_MS = 3_000;
 // 沿用 30s 会把组内转发的中继活流掐成 "terminated"（实测首块后 ~31s 必断，本地直连
 // 无此限制——组内因此比直连"不流畅"）。与应用层 MAX_STREAM_MS(120s) 对齐：
 // undici 层只做最后兜底，掐流交给应用层的首块/总时长策略。
+import { summarizeRequest } from "../model-trace.js";
 const PEER_BODY_TIMEOUT_MS = 120_000;
 export { PEER_BODY_TIMEOUT_MS };
 
@@ -203,7 +204,7 @@ export async function racePeerCandidates(candidates, ctx) {
         tried.add(peer.url);
         const ctrl = new AbortController();
         ctrls.set(peer.url, ctrl);
-        ctx.evt("peer-request", { peer: peer.url, model: target, hops: ctx.hops + 1 });
+        ctx.evt("peer-request", { peer: peer.url, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body) });
         // 插件 hook：peer:beforeForward — 转发给组员前观察
         if (ctx.plugins?.length) {
           runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});

package/src/routes/stream.js

@@ -30,6 +30,40 @@ function hasPayload(text) {
   return false;
 }
 
+// 错误包络 chunk 判定（纯函数）：data 行 JSON 含顶层 .error 对象、或只有 finish_reason=error
+// 的空帧，且整 chunk 无任何 content/tool_calls/reasoning 输出 → 返回错误摘要（建议暂扣），
+// 否则返回 null（透传）。解析失败一律透传（默认保安全）。
+// 背景：网关把上游失败包成 HTTP 200 SSE；暂扣后下游流式 UI 不再展示瞬时错误
+//（如 Vertex 503 + google fallback 400），本轮走空转重试，客户端只看到最终结果。
+function holdableChunk(txt) {
+  if (typeof txt !== "string" || !txt.includes("data:")) return null;
+  let sawData = false;
+  const errs = [];
+  for (const line of txt.split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("data:")) continue;
+    const d = t.slice(5).trim();
+    if (!d || d === "[DONE]") continue;
+    let j = null;
+    try { j = JSON.parse(d); } catch { return null; }
+    if (!j || typeof j !== "object") return null;
+    sawData = true;
+    const c0 = (Array.isArray(j.choices) && j.choices[0]) || {};
+    const delta = c0.delta || {};
+    const msg = c0.message || {};
+    const out = delta.content || msg.content || delta.tool_calls || msg.tool_calls || delta.reasoning || msg.reasoning;
+    if (out && !(Array.isArray(out) && out.length === 0)) return null;
+    if (j.error && typeof j.error === "object") {
+      const m = j.error.message || j.error.code || "";
+      if (m) errs.push(String(m).slice(0, 300));
+    } else if (c0.finish_reason !== "error") {
+      return null;
+    }
+  }
+  if (!sawData) return null;
+  return errs.length ? errs.join(" | ") : "finish_reason=error 空帧";
+}
+
 // 自持 reader 优先：for-await 会锁定 ReadableStream，使 body.cancel() 必 reject（真流上等于空操作），
 // 超时/断下游要真能掐上游必须走 reader.cancel()
 async function* bodyChunks(body, reader) {
@@ -116,6 +150,8 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
     chars: 0,
     toolCalls: 0,
     chatShaped: false,
+    heldErrorChunks: 0,
+    upstreamErrorText: null,
     recoveries: 0,
   };
   let prevChunkAt = t0;
@@ -206,6 +242,13 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
           if (gap > SCORE_STALL_MS) detail.stallHits += 1;
           prevChunkAt = now;
           const txt = chunkText(chunk);
+          // 错误包络暂扣：本轮尚未写出真实输出时错误帧不写下游（下游 UI 不再展示瞬时错误），
+          // 摘要记 detail.upstreamErrorText 供空转判定与最终报错；已写出真实内容后的错误帧照常透传。
+          const holdErr = !wrotePayload ? holdableChunk(txt) : null;
+          if (holdErr) {
+            detail.heldErrorChunks += 1;
+            if (!detail.upstreamErrorText) detail.upstreamErrorText = String(holdErr).slice(0, 500);
+          }
           const isPayload = hasPayload(txt);
           try {
             if (txt.includes("[DONE]")) detail.sawDone = true;
@@ -252,7 +295,7 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
           // 首块/空闲超时后上游仍吐出了真实数据 → 只是慢，不是死：撤销超时判定，照常转发
           //（cancel 是异步的，竞态窗口内已到达的数据是纯收益；丢掉是纯损失）
           // 注释帧（keepalive）不算：否则对端只要在发心跳，闸门就永远解除
-          if (isPayload && (timedOut || stalled)) {
+          if (isPayload && !holdErr && (timedOut || stalled)) {
             timedOut = false;
             stalled = false;
             detail.recoveries = (detail.recoveries || 0) + 1;
@@ -260,7 +303,7 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
             if (firstTimer) { clearTimeout(firstTimer); firstTimer = null; }
           }
           if (timedOut || stalled || tooLong) break;
-          if (isPayload && first) {
+          if (isPayload && first && !holdErr) {
             first = false;
             ttf = Math.round(now - t0);
             onFirstChunk?.(ttf);
@@ -279,11 +322,13 @@ export async function relay(res, upRes, body, { onFirstChunk, onDownstreamAbort,
               }
             } catch {}
           }
-          wroteAny = true;
-          if (isPayload) wrotePayload = true;
-          detail.wroteChunks += 1;
-          detail.wroteBytes += Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
-          try { res.write(outChunk); } catch { /* 下游已断开：onClose 已掐上游 */ }
+          if (!holdErr) {
+            wroteAny = true;
+            if (isPayload) wrotePayload = true;
+            detail.wroteChunks += 1;
+            detail.wroteBytes += Buffer.isBuffer(outChunk) ? outChunk.length : (outChunk?.length ?? len);
+            try { res.write(outChunk); } catch { /* 下游已断开：onClose 已掐上游 */ }
+          }
           armStall();
         }
         if (!detail.exitReason) detail.exitReason = detail.downstreamClosed ? "downstream-closed" : "normal";

package/src/runtime/bootstrap.js

@@ -1,10 +1,11 @@
-import { appendCall, appendError, appendEvent } from "../logs.js";
+import { appendCall, appendError, appendEvent, appendTimeline } from "../logs.js";
 import { setupProviders } from "./providers-setup.js";
 import { startServerLifecycle } from "./server-lifecycle.js";
+import { appendModelTrace } from "../model-trace.js";
 import { startGroupSync } from "./group-sync.js";
 import { startBroadband } from "./broadband.js";
 
-const logs = { appendCall, appendError, appendEvent };
+const logs = { appendCall, appendError, appendEvent, appendTimeline, appendModelTrace };
 
 /**
  * daemon 启动门面 — 仅编排：组装世界 → 服务生命周期 → 群组同步 → 宽带中继 → 自更新。

package/src/timeline.js

@@ -0,0 +1,22 @@
+// 人读请求时间线：只输出状态/耗时/出口，不输出 prompt、响应正文或凭据。
+function hostPort(value) {
+  try { const u = new URL(String(value)); return u.port ? `${u.hostname}:${u.port}` : u.hostname; } catch { return String(value || "-").slice(0, 80); }
+}
+function short(value, n = 90) {
+  const s = String(value ?? "").replace(/\s+/g, " ").trim();
+  return !s ? "-" : s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+function outcome(status, reason) {
+  if (status == null) return reason ? `- ${short(reason)}` : "-";
+  return `${status}${reason ? ` ${short(reason)}` : ""}`;
+}
+
+export function formatTimeline({ reqId, model, direct = [], peers = [], retries = 0, result = null, totalMs = 0 } = {}) {
+  const d = direct.length ? direct[direct.length - 1] : null;
+  const ps = peers.map((p) => `[peer=${hostPort(p.peer)} ${p.ok ? "win" : "fail"} ${p.latencyMs != null ? `${p.latencyMs}ms` : "timing-"} ${short(p.message || p.status || "", 70)}]`);
+  const r = result || {};
+  const detail = r.detail || {};
+  const res = r.status == null ? "-" : `${r.status}${detail.sawFinishReason ? ` ${detail.sawFinishReason}` : ""}${detail.toolCalls ? ` tools=${detail.toolCalls}` : ""}${detail.chars != null ? ` chars=${detail.chars}` : ""}${detail.interrupted ? " interrupted=1" : ""}${detail.timedOut ? " timedOut=1" : ""}`;
+  const directText = d ? outcome(d.status, d.reason) : "-";
+  return `[req=${reqId || "-"}] [model=${model || "-"}] [direct=${directText}]${ps.length ? ` ${ps.join(" ")}` : ""}${retries ? ` [retry=${retries}]` : ""} [result=${res}] [total=${Math.max(0, Math.round(Number(totalMs) || 0))}ms]`;
+}

package/src/upstream-engine/sdk/attempt.js

@@ -4,10 +4,39 @@
 // HTTP 错误就地映射为带状态码的 Response；装载失败抛 _sdkLoadFailed 由引擎回退 legacy。
 // responses 适配器（sdk/responses.js）复用本文件的 baseURL 解析、错误映射与流序列化。
 // 见 .scratch/ai-sdk-upstream/{SPEC.md,SPEC-p3-responses.md} 与 docs/adr/0017。
+// Headers 超时（防 SDK 通道挂死）：doStream 裸 await 曾因上游连接半死永不 resolve
+//（cline muse-spark 2026-09-25 17:48 悬空 27min+，无 upstream-done/error/result）。
+// 默认 120s（覆盖慢模型首块握手的合理上限），MSLXDFF_SDK_HEADERS_TIMEOUT_MS=0 关闭。
+// 注意错误文案不得含 "timed out"：cline runChat 靠该子串做网络重试，命中会把挂死放大 3 倍。
 import { toModelPrompt, toModelTools, toModelToolChoice, toModelParams } from "./convert.js";
 import { createSseSerializer } from "./sse.js";
 import { diagnoseToolSequence, compactSequence } from "./diagnose.js";
 import { getUndici } from "../../compat.js";
+function headersTimeoutMs(env = process.env) {
+  const n = Number(env.MSLXDFF_SDK_HEADERS_TIMEOUT_MS);
+  return Number.isFinite(n) && n >= 0 ? n : 120_000;
+}
+
+// race 包裹：超时 reject mkErr()；先赢路径清定时器并吞掉迟到的 rejection（防 unhandled）。
+export function withHeadersTimeout(promise, ms, mkErr) {
+  if (!Number.isFinite(ms) || ms <= 0) return promise;
+  let timer = null;
+  const guard = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(mkErr()), ms);
+  });
+  return Promise.race([
+    Promise.resolve(promise).then(
+      (v) => { clearTimeout(timer); return v; },
+      (e) => { clearTimeout(timer); throw e; },
+    ),
+    guard,
+  ]).catch((e) => {
+    // 超时赢后原 promise 仍可能 reject：静默兜住，不让其变成 unhandled rejection。
+    if (promise && typeof promise.catch === "function") promise.catch(() => {});
+    throw e;
+  });
+}
+
 
 let sdkPromise = null;
 
@@ -155,15 +184,23 @@ export async function attemptOnceSdk({
     ...(capturedFetch ? { fetch: capturedFetch } : {}),
   });
   const model = provider.chatModel(String(body?.model || ""));
+  const htMs = headersTimeoutMs();
+  const aborter = htMs > 0 ? new AbortController() : null;
   let res;
   try {
-    res = await model.doStream({
-      prompt: toModelPrompt(body?.messages),
-      ...toModelParams(body, providerName),
-      tools: toModelTools(body?.tools),
-      toolChoice: toModelToolChoice(body?.tool_choice),
-    });
+    res = await withHeadersTimeout(
+      model.doStream({
+        prompt: toModelPrompt(body?.messages),
+        ...toModelParams(body, providerName),
+        tools: toModelTools(body?.tools),
+        toolChoice: toModelToolChoice(body?.tool_choice),
+        ...(aborter ? { abortSignal: aborter.signal } : {}),
+      }),
+      htMs,
+      () => new Error(`sdk-channel: headers timeout after ${htMs}ms（上游未返回响应头，防挂死；MSLXDFF_SDK_HEADERS_TIMEOUT_MS=0 关闭）`),
+    );
   } catch (e) {
+     try { aborter?.abort(); } catch {}
     const mapped = errorResponseFromSdkError(e, { marker });
     if (mapped) {
       try { logRequestDiagnosis(lastBodyText, mapped.status); } catch {}