mslxdff 0.1.155 → 0.1.156

package/package.json

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

package/src/cli/commands/model/list-providers.js

@@ -1,7 +1,9 @@
 /**
  * 其他供应商 allowlist 段 + 遗留别名映射展示。
  * 输入均为已算好的数据；state/model-id 走动态 import（与原内联一致，避免循环依赖）。
+ * allowlist 按 compareModelIds 排序展示（只改展示顺序，不改 allowlist 落盘内容）。
  */
+import { compareModelIds } from "./list-sort.js";
 export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
   const { loadProviderConfigs, loadProviderAllowedModels, loadProviderAllowAnyModels, loadProviderBaseUrl } = await import("../../../state.js");
   const { loadModelAliases: _la2, getAliasForModel: _gaf } = await import("../../../providers/model-id.js");
@@ -38,8 +40,7 @@ export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
           console.log(`     或放行全部: mslxdff -provider ${pid} allowAny on`);
         }
       } else {
-        for (const raw of allowed) {
-          const canonical = `${pid}/${raw}`;
+        for (const canonical of allowed.map((raw) => `${pid}/${raw}`).sort(compareModelIds)) {
           let alias = null;
           try { alias = _gaf(canonical); } catch {}
           if (!alias && String(canonical).includes("/")) alias = String(canonical).replace(/\//g, "-");

package/src/cli/commands/model/list-render.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { compareModelIds, providerOf, providerRank } from "./list-sort.js";
 
 /** 构建 id → 别名映射（原 list 两处重复逻辑收敛） */
 export function buildAliasMap(ids, getAliasForModel) {
@@ -57,22 +58,19 @@ export function renderFreeList({ ids, at, pickedIds, sortedProvs, groups, aliasM
   }
 }
 
-/** 按供应商分组 + 排序（opencode/workbuddy/cline/openrouter 优先） */
+/** 按供应商分组 + 排序（opencode 段最前，已知供应商优先，组内字母序） */
 export function groupByProvider(ids) {
   const groups = {};
   for (const id of ids) {
-    const prov = String(id).includes("/") ? String(id).split("/")[0] : "opencode";
+    const prov = providerOf(id);
     if (!groups[prov]) groups[prov] = [];
     groups[prov].push(id);
   }
-  const order = ["opencode", "workbuddy", "cline", "openrouter"];
+  for (const key of Object.keys(groups)) groups[key].sort(compareModelIds);
   const sortedProvs = Object.keys(groups).sort((a, b) => {
-    const ia = order.indexOf(a), ib = order.indexOf(b);
-    if (ia !== -1 || ib !== -1) {
-      if (ia === -1) return 1;
-      if (ib === -1) return -1;
-      return ia - ib;
-    }
+    const ra = providerRank(a);
+    const rb = providerRank(b);
+    if (ra !== rb) return ra - rb;
     return a.localeCompare(b);
   });
   return { groups, sortedProvs };

package/src/cli/commands/model/list-sort.js

@@ -0,0 +1,52 @@
+// `-models` / `-model list` 展示排序：opencode free 优先 → 其余供应商分组 → 组内字母序。
+// 单一来源：本文件被 list.js（交互候选）与 list-render.js（分组渲染）共用。
+// Note: 排序只影响展示顺序，不改 picks/候选集合 — 见 .agents/notes/implemented/feature/2026-09-28-models-sort-opencode-free-first.md
+import { isFreeModel } from "../../../models.js";
+
+/** 供应商展示优先级（opencode 恒第一；未知供应商按字母序排其后） */
+export const PROVIDER_ORDER = ["opencode", "workbuddy", "cline", "openrouter", "qoder", "codearts", "traework", "bai"];
+
+/** 取模型 id 的供应商前缀；无斜杠的裸 id 归 opencode */
+export function providerOf(id) {
+  const s = String(id || "");
+  const i = s.indexOf("/");
+  return i > 0 ? s.slice(0, i).toLowerCase() : "opencode";
+}
+
+/** 供应商排序权重：opencode=0，已知供应商=其序号+1，未知=大数（按字母序兜底） */
+export function providerRank(prov) {
+  const i = PROVIDER_ORDER.indexOf(prov);
+  return i === -1 ? PROVIDER_ORDER.length : i;
+}
+
+/**
+ * 模型 id 排序比较器：
+ *  1) opencode free（isFreeModel）最前 —— 用户主诉求
+ *  2) opencode 非 free 次之
+ *  3) 其余供应商按 PROVIDER_ORDER，未知按字母序
+ *  4) 同段内 localeCompare 字母序（大小写不敏感兜底）
+ */
+export function compareModelIds(a, b) {
+  const pa = providerOf(a);
+  const pb = providerOf(b);
+  const fa = pa === "opencode" && isFreeModel(a);
+  const fb = pb === "opencode" && isFreeModel(b);
+  // 段位：0=opencode free，1=opencode 其他，2=其他供应商
+  const ga = fa ? 0 : pa === "opencode" ? 1 : 2;
+  const gb = fb ? 0 : pb === "opencode" ? 1 : 2;
+  if (ga !== gb) return ga - gb;
+  if (ga === 2) {
+    const ra = providerRank(pa);
+    const rb = providerRank(pb);
+    if (ra !== rb) return ra - rb;
+    if (pa !== pb) return pa.localeCompare(pb);
+  }
+  const la = String(a).toLowerCase();
+  const lb = String(b).toLowerCase();
+  return la === lb ? String(a).localeCompare(String(b)) : la.localeCompare(lb);
+}
+
+/** 返回排序后的新数组（不改原数组） */
+export function sortModelIds(ids) {
+  return [...(ids || [])].sort(compareModelIds);
+}

package/src/cli/commands/model/list-tty.js

@@ -0,0 +1,76 @@
+// 交互式 `-models`（TTY 多选）主流程：从 list.js 拆出以守住 ≤10KB 体积门。
+// 候选合并（allowlist + live + picks 孤儿）→ 展示排序 → 勾选落盘。
+// Note: 排序规则单一来源在 list-sort.js；候选集合语义不变（只改展示顺序）。
+import { loadModelErrors, loadModelPicks, saveModelPicks } from "../../../state.js";
+import { getPreferredModel } from "../../../auto.js";
+import { pickInteractiveMulti } from "../../interactive.js";
+import { filterStalePicks } from "../../../providers/model-id.js";
+import { mergeLiveIds } from "./list-live.js";
+import { sortModelIds } from "./list-sort.js";
+
+/**
+ * 拼交互候选：opencode live ids + 已启用 provider 的 allowlist + live 补齐 + 可见 picks。
+ * 返回 { items, pickedIds }；items 已按 sortModelIds 排序。
+ */
+export async function buildPickerItems(liveIds, pickedIds) {
+  const statuses = loadModelErrors();
+  const current = getPreferredModel();
+  const combinedIds = [...liveIds];
+  const seen = new Set(combinedIds);
+  let staleFilter = null;
+  try {
+    const { loadProviderConfigs, loadProviderAllowedModels } = await import("../../../state.js");
+    const { buildProviderRows } = await import("../../provider-row.js");
+    // 已知 = 已启用（与 -provider list 同一 enabled 口径：有 baseUrl 且有 key；
+    // openrouter 有 key 即算，opencode 内置恒启用）。未启用 provider 的 picks
+    // 不进列表，启用后自动回来（数据未动）。
+    const knownProviders = buildProviderRows({}).filter((r) => r.enabled).map((r) => r.id);
+    loadProviderConfigs();
+    const allowedIds = [];
+    for (const pid of knownProviders.filter((k) => String(k).toLowerCase() !== "opencode")) {
+      for (const raw of loadProviderAllowedModels(pid)) {
+        const canonical = `${pid}/${raw}`;
+        allowedIds.push(canonical);
+        if (!seen.has(canonical)) {
+          seen.add(canonical);
+          combinedIds.push(canonical);
+        }
+      }
+    }
+    await mergeLiveIds({ combinedIds, seen, knownProviders, liveIds });
+    staleFilter = { knownProviders, liveIds, allowedIds };
+  } catch {}
+  // provider 已不存在的 picks 孤儿不进交互列表（数据不动，status --all 仍可审计）。
+  // configs 读失败时 staleFilter 为空 → 不过滤（默认放行）。
+  const visiblePicks = staleFilter ? filterStalePicks(pickedIds, staleFilter) : pickedIds;
+  for (const pid of visiblePicks) {
+    if (!seen.has(pid)) {
+      seen.add(pid);
+      combinedIds.push(pid);
+    }
+  }
+  // 展示排序：opencode free 最前 → opencode 其他 → 各供应商分组，组内字母序。
+  const items = sortModelIds(combinedIds).map((id) => {
+    const e = statuses[id];
+    return {
+      id,
+      status: typeof e === "number" ? "error" : e?.status || "normal",
+      current: id === current,
+      picked: pickedIds.includes(id),
+    };
+  });
+  return { items, pickedIds };
+}
+
+/** 跑一轮 TTY 勾选并落盘 picks（取消则不写）。调用方负责 exit。 */
+export async function runInteractivePick(liveIds) {
+  const pickedIds = loadModelPicks();
+  const { items } = await buildPickerItems(liveIds, pickedIds);
+  const result = await pickInteractiveMulti(items, new Set(pickedIds), Math.max(0, items.findIndex((x) => x.current)));
+  if (!result) {
+    console.log("cancelled — picks unchanged");
+    return;
+  }
+  saveModelPicks([...result]);
+  console.log(`saved ${result.size} picked model(s): ${[...result].join(", ") || "(none — auto uses full list)"}`);
+}

package/src/cli/commands/model/list.js

@@ -2,16 +2,12 @@ import { join } from "node:path";
 import { createModelsService } from "../../../models.js";
 import { createUpstreamClient } from "../../../upstream.js";
 import { logDir } from "../../../logs.js";
-import { loadModelErrors, loadModelPicks, saveModelPicks } from "../../../state.js";
-import { getPreferredModel } from "../../../auto.js";
+import { loadModelPicks } from "../../../state.js";
 import { fmtShanghaiYMDHM } from "../../../time.js";
 import { readModelsCache } from "../../util.js";
-import { pickInteractiveMulti } from "../../interactive.js";
 import { buildAliasMap, readFullAliases, renderProviderList, renderFreeList, groupByProvider } from "./list-render.js";
 import { renderOtherProviders } from "./list-providers.js";
-import { filterStalePicks } from "../../../providers/model-id.js";
-import { mergeLiveIds } from "./list-live.js";
-
+import { compareModelIds } from "./list-sort.js";
 /**
  * `-model list` 全流程：参数解析 → 刷新/回退 → provider 分支 → TTY 交互 → 分组渲染。
  * 渲染下沉 list-render / list-providers，本文件只留流程编排。
@@ -104,8 +100,7 @@ export async function handleModelList(args, idx, sub) {
           const at2 = cachedAt ? ` (cached ${fmtShanghaiYMDHM(cachedAt)})` : "";
           console.log(`${allowed.length} model(s) for ${prov}${at2} (allowlist，原名 + 别名):`);
           const pickedIds2 = loadModelPicks();
-          for (const raw of allowed) {
-            const canonical = `${prov}/${raw}`;
+          for (const canonical of allowed.map((raw) => `${prov}/${raw}`).sort(compareModelIds)) {
             let alias = null;
             try { alias = getAliasForModel(canonical); } catch {}
             if (!alias && String(canonical).includes("/")) alias = String(canonical).replace(/\//g, "-");
@@ -134,60 +129,8 @@ export async function handleModelList(args, idx, sub) {
       process.exit(0);
     }
     if (sub === undefined && process.stdin.isTTY && process.stdout.isTTY) {
-      const statuses = loadModelErrors();
-      const current = getPreferredModel();
-      const pickedIds = loadModelPicks();
-      const combinedIds = [...ids];
-      const seen = new Set(combinedIds);
-      let staleFilter = null;
-      try {
-        const { loadProviderConfigs, loadProviderAllowedModels } = await import("../../../state.js");
-        const { buildProviderRows } = await import("../../provider-row.js");
-        // 已知 = 已启用（与 -provider list 同一 enabled 口径：有 baseUrl 且有 key；
-        // openrouter 有 key 即算，opencode 内置恒启用）。未启用 provider 的 picks
-        // 不进列表，启用后自动回来（数据未动）。
-        const knownProviders = buildProviderRows({}).filter((r) => r.enabled).map((r) => r.id);
-        const configs = loadProviderConfigs();
-        const allowedIds = [];
-        for (const pid of knownProviders.filter((k) => String(k).toLowerCase() !== "opencode")) {
-          const allowed = loadProviderAllowedModels(pid);
-          for (const raw of allowed) {
-            const canonical = `${pid}/${raw}`;
-            allowedIds.push(canonical);
-            if (!seen.has(canonical)) {
-              seen.add(canonical);
-              combinedIds.push(canonical);
-            }
-          }
-        }
-        await mergeLiveIds({ combinedIds, seen, knownProviders, liveIds: ids });
-        staleFilter = { knownProviders, liveIds: ids, allowedIds };
-      } catch {}
-      // provider 已不存在的 picks 孤儿不进交互列表（数据不动，status --all 仍可审计）。
-      // configs 读失败时 staleFilter 为空 → 不过滤（默认放行）。
-      const visiblePicks = staleFilter ? filterStalePicks(pickedIds, staleFilter) : pickedIds;
-      for (const pid of visiblePicks) {
-        if (!seen.has(pid)) {
-          seen.add(pid);
-          combinedIds.push(pid);
-        }
-      }
-      const items = combinedIds.map((id) => {
-        const e = statuses[id];
-        return {
-          id,
-          status: typeof e === "number" ? "error" : e?.status || "normal",
-          current: id === current,
-          picked: pickedIds.includes(id),
-        };
-      });
-      const result = await pickInteractiveMulti(items, new Set(pickedIds), Math.max(0, items.findIndex((x) => x.current)));
-      if (!result) {
-        console.log("cancelled — picks unchanged");
-        process.exit(0);
-      }
-      saveModelPicks([...result]);
-      console.log(`saved ${result.size} picked model(s): ${[...result].join(", ") || "(none — auto uses full list)"}`);
+      const { runInteractivePick } = await import("./list-tty.js");
+      await runInteractivePick(ids);
       process.exit(0);
     }
     const at = cachedAt ? ` (cached ${fmtShanghaiYMDHM(cachedAt)})` : "";

package/src/model-trace.js

@@ -1,5 +1,6 @@
 // Per-model request trace formatting. Never include prompt, response body, headers or credentials.
 // Note: 同步 appendFileSync（异步 append 会在并发下打乱同一请求的阶段行序）— 见 .agents/notes/implemented/feature/2026-09-25-model-trace-log.md
+// Note: 事件面用黑名单（默认全可见，只排除噪声/敏感面）+ 决定类事件只渲染登记过的标量字段——起因是 empty-turn-retry 曾被阶段白名单静默吞掉，"关键决定不许再被漏登记" — 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { logDir } from "./logs.js";

package/src/providers/qoder/chat.js

@@ -5,7 +5,7 @@ import { normalizeRegion } from "./constants.js";
 import { buildUpstreamRequest } from "./request.js";
 import { reshapeQoderStream } from "./stream.js";
 import { aggregateQoderStream, toCompletionJson } from "./aggregate.js";
-import { errorStatus } from "./sse.js";
+import { errorStatus, extractDelta } from "./sse.js";
 
 function hostOf(url) {
   try { return new URL(String(url)).host; } catch { return "-"; }
@@ -19,6 +19,62 @@ function mapUpstreamError(status, detail) {
   return { kind: status === 401 || status === 403 ? "auth" : "upstream", status, detail: String(detail || "").slice(0, 300) };
 }
 
+// 预读上限：判决恒在首帧（实测 457 字节），8 帧足够覆盖"角色帧先到、判决帧随后"，
+// 又不会把首字节延迟拖到不可控。超窗未得判决即放弃（退化为无冷却的流内 error，见 SPEC 已知上限）。
+const PEEK_MAX_FRAMES = 8;
+
+// 预读上游首帧只为取「流内判决」：qoder 把限流/鉴权判决裹在 HTTP 200 的 SSE 信封里
+//（statusCodeValue:403 + serviceAvailable:false），upRes.status 恒 200，判决只有读完帧才知道。
+// 不预读则状态码永远出不来流式路径 → 门面不冷却该号（ADR-0036 的粘号会把重试继续粘在它上面）。
+// 返回 { res, status, frames }：res 是把预读帧回灌后的等价上游响应，frames 交回灌用。
+// 任何异常都降级为「无判决」（status=0）：排障手段不得变成故障源。
+async function peekEnvelopeVerdict(upRes, cdbg) {
+  if (!upRes?.body) return { res: upRes, status: 0, frames: [] };
+  let reader;
+  try { reader = upRes.body.getReader(); } catch { return { res: upRes, status: 0, frames: [] }; }
+  const dec = new TextDecoder();
+  const frames = [];
+  let text = "";
+  let status = 0;
+  let decided = false;
+  try {
+    for (let i = 0; i < PEEK_MAX_FRAMES && !decided; i++) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) { frames.push(value); text += dec.decode(value, { stream: true }); }
+      // 逐行判定：先到判决（err）或先到有效载荷即停，避免无谓等待
+      for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("data:")) continue;
+        const p = line.slice(5).trim();
+        if (!p || p === "[DONE]") continue;
+        const d = extractDelta(p);
+        if (d.err) { status = Number(d.err.status) || 0; decided = true; break; }
+        if (d.content || d.reasoning || d.toolCalls || d.usageIn || d.usageOut) { decided = true; break; }
+      }
+    }
+  } catch (e) {
+    cdbg(`[peek-throw] ${String(e?.message || e).slice(0, 160)}`);
+  }
+  cdbg(`[peek] frames=${frames.length} verdict=${status || "none(正常流)"}`);
+  // 回灌：已读帧先按原样吐出，再接续同一个 reader 的剩余部分
+  const body = new ReadableStream({
+    start(ctrl) {
+      for (const f of frames) { try { ctrl.enqueue(f); } catch {} }
+      (async () => {
+        try {
+          for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value) ctrl.enqueue(value);
+          }
+        } catch {}
+        try { ctrl.close(); } catch {}
+      })();
+    },
+  });
+  return { res: new Response(body, { status: upRes.status, headers: upRes.headers }), status, frames };
+}
 export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
   if (!fetchImpl) fetchImpl = compatFetch;
 
@@ -38,6 +94,7 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
   // 上游状态回显（内部交接用，不落日志）：流式路径按对外契约把非 200 整形成 "200 + 流内 error"，
   // 真实状态码只能靠这个头带出——否则 401/403/429/5xx 到不了 provider 门面，坏号不被冷却，
   // 而"同请求粘号"（ADR-0036）会把后续重试继续粘在这个坏号上。
+  // Note: 流内判决需预读首帧才能拿到（HTTP 200 里裹 statusCodeValue）— 见 .agents/notes/implemented/bug-fix/2026-09-27-qoder-envelope-verdict-cooldown.md
   const withUpstreamStatus = (res, st) => {
     try { res.headers.set("x-mslxdff-qoder-upstream-status", String(st)); } catch {}
     return res;
@@ -53,23 +110,32 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
 
     let upRes; let reqUrl = "";
     const echo = (res) => withEcho(res, reqUrl, region, pick);
+    // 排障日志（QODER_DEBUG_STREAM=1 开）：记录出口/状态/耗时/响应头，便于对比"200 但空轮"
+    const cdbg = (...a) => { if (process.env.QODER_DEBUG_STREAM === "1") console.log("[qoder-chat]", ...a); };
+    let upMs = 0;
     try {
       const req = buildUpstreamRequest({ sess, region: normalizeRegion(region), model, messages, tools, maxTokens });
       reqUrl = req.url;
+      cdbg(`[req] url=${hostOf(req.url)} region=${normalizeRegion(region)} model=${model} msgs=${messages.length} tools=${tools?.length ?? 0} maxTokens=${maxTokens} stream=${stream} bodyBytes=${req.bodyStr?.length ?? 0}`);
+      const t0 = Date.now();
       upRes = await fetchImpl(req.url, {
         method: "POST",
         headers: req.headers,
         body: req.bodyStr,
         signal: timeoutSignal(timeoutMs || 120_000),
       });
+      upMs = Date.now() - t0;
+      cdbg(`[res] status=${upRes.status} ms=${upMs} ct=${upRes.headers.get("content-type")} host=${hostOf(reqUrl)}`);
     } catch (e) {
       const detail = String(e?.message || e).slice(0, 300);
+      cdbg(`[res-throw] ms=${upMs} err=${detail}`);
       // 网络异常（超时/连接失败）折成 502：门面据此冷却该号（否则坏号恒在轮换池里）
       if (stream) return withUpstreamStatus(echo(reshapeQoderStream(new Response("data: [DONE]\n\n"), { model, chatId })), 502);
       return withUpstreamStatus(echo(errRes(502, detail)), 502);
     }
     if (upRes.status !== 200) {
       const detail = await upRes.text().catch(() => "");
+      cdbg(`[res-non200] status=${upRes.status} body=${detail.slice(0, 300)}`);
       const e = mapUpstreamError(upRes.status, detail);
       if (stream) {
         // 首包错误也走流内 error 事件（与旧 reshapeStream catch 语义一致：200 + event:error + DONE）
@@ -86,7 +152,15 @@ export function createChatService({ id = "qoder", fetchImpl, timeoutMs } = {}) {
       }
       return withUpstreamStatus(echo(errRes(errorStatus(e), e.detail, e.kind)), upRes.status);
     }
-    if (stream) return echo(reshapeQoderStream(upRes, { model, chatId }));
+    if (stream) {
+      // 预读首帧取流内判决（qoder 把 403/429 裹在 200 的信封里），预读帧原样回灌给整形器。
+      // 判决状态码经 withUpstreamStatus 出门面 → index.js 据此 ring.onError 冷却该号 →
+      // 粘号选择器下次因 isCooling 为真而换号。对外仍恒 200（契约不变）。
+      const peek = await peekEnvelopeVerdict(upRes, cdbg);
+      const shaped = echo(reshapeQoderStream(peek.res, { model, chatId, prefetched: peek.frames }));
+      // 只在真有判决时挂状态码：正常流不写这个头（index.js 靠它区分"要不要冷却"）
+      return peek.status ? withUpstreamStatus(shaped, peek.status) : shaped;
+    }
     try {
       const agg = await aggregateQoderStream(upRes);
       const out = toCompletionJson({ model, chatId, ...agg });

package/src/providers/qoder/index.js

@@ -1,6 +1,7 @@
 // qoder provider 门面（原生直连，零桥依赖）：
 // 多号 = keys[] 里每条 device_token blob（auths/qoder-<uid>.json 落盘由 login 维护）；
-// 每请求 round-robin 选号 → 建会话 → COSY 签名直调上游；恒 local-only 不借 key。
+// 选号 → 建会话 → COSY 签名直调上游；恒 local-only 不借 key。
+// Note: 同请求粘号（一次客户端请求内复用同一个号，仅 401/403/429/5xx 冷却才换）与流式坏号冷却（真实状态码经内部头带出）— 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
 import { loadProviderKeys, loadProviderConfig } from "../../state.js";
 import { listAccountDocs } from "./account-store.js";
 import { defaultStateFile } from "../../state/store.js";

package/src/providers/qoder/sse.js

@@ -1,17 +1,30 @@
 // qoder 上游 SSE 信封解析（转译 qoder2api bridge.go ExtractDelta）
 // 帧形态：data:{"headers":{},"body":"<内层JSON>","statusCodeValue":200}
 // 信封 statusCodeValue!=200 = 瞬时上游错；内层 code!=0 = 业务错；usage 同帧合并
+// 排障日志（QODER_DEBUG_STREAM=1 开）：静默吞帧的分支必须有痕，否则"内容凭空消失"无从追
+const DBG_SSE = () => process.env.QODER_DEBUG_STREAM === "1";
+const ddbg = (...a) => { if (DBG_SSE()) console.log("[qoder-sse]", ...a); };
+
 export function extractDelta(dataLine) {
   let wrapper;
-  try { wrapper = JSON.parse(dataLine); } catch { return {}; }
+  try { wrapper = JSON.parse(dataLine); } catch (e) {
+    ddbg(`[envelope-parse-fail] ${e.message} line=${dataLine.slice(0, 300)}`);
+    return {};
+  }
   if (wrapper.statusCodeValue !== undefined && Number(wrapper.statusCodeValue) !== 200) {
     const detail = typeof wrapper.body === "string" && wrapper.body ? wrapper.body : JSON.stringify(wrapper).slice(0, 400);
     return { err: { kind: "upstream", status: Number(wrapper.statusCodeValue) || 502, detail } };
   }
   const inner = wrapper.body;
-  if (!inner || typeof inner !== "string") return {};
+  if (!inner || typeof inner !== "string") {
+    ddbg(`[body-not-string] bodyType=${typeof inner} envelopeKeys=${Object.keys(wrapper).join(",")} envelope=${dataLine.slice(0, 300)}`);
+    return {};
+  }
   let j;
-  try { j = JSON.parse(inner); } catch { return {}; }
+  try { j = JSON.parse(inner); } catch (e) {
+    ddbg(`[inner-parse-fail] ${e.message} body=${inner.slice(0, 300)}`);
+    return {};
+  }
   let usageIn = 0, usageOut = 0;
   if (j.usage && typeof j.usage === "object") {
     usageIn = Math.trunc(Number(j.usage.prompt_tokens) || 0);
@@ -33,6 +46,9 @@ export function extractDelta(dataLine) {
     return { err: { kind: /inappropriate|DataInspection|Sensitive|ContentFilter/i.test(String(j.message)) ? "content_policy" : "business", code: j.code, detail: String(j.message || "") } };
   }
   if (usageIn > 0 || usageOut > 0) return { usageIn, usageOut };
+  // 走到这里 = 帧既无 content/tool_calls、也无业务错、也无 usage。空轮排查的关键取证点：
+  // 把内层 JSON 的顶层键与 choices 原样打出来，一眼看出上游改了什么字段名。
+  ddbg(`[no-delta] innerKeys=${Object.keys(j).join(",")} choicesLen=${choices.length} inner=${JSON.stringify(j).slice(0, 400)}`);
   return {};
 }
 

package/src/providers/qoder/sticky.js

@@ -3,6 +3,7 @@
 // 背景：keyring 每次 next() 都前进一格，而 qoder 两个号分属 cn/global 两区（region 决定 URL），
 // 于是「重试」会把同一个请求甩到另一个区——排障时表现为"URL 莫名在切"。粘号把"切号"收回到
 // 唯一正当理由：该号已被冷却。无 scope（拿不到请求标识）时退化为原 round-robin，与旧行为一致。
+// Note: 切号的唯一正当理由是冷却（401/403/429/5xx）——空转等其它失败不换号，故选择器要能问 keyring "上次这个号还在冷却吗" — 见 .agents/notes/implemented/feature/2026-09-27-qoder-per-request-sticky-account.md
 export function createStickyPicker({ pick, isCooling = () => false, now = Date.now, ttlMs = 600_000, maxEntries = 200 } = {}) {
   const seen = new Map(); // scope → { key, at }
 

package/src/providers/qoder/stream.js

@@ -3,6 +3,9 @@
 // usage 只在尾帧出现：收到即记，附在 finish chunk 上一次发出（与旧回放语义一致）。
 import { extractDelta } from "./sse.js";
 
+// 空轮排障用的临时日志开关：QODER_DEBUG_STREAM=1 才输出，默认静默（问题定位后可摘）
+const DBG_STREAM = () => process.env.QODER_DEBUG_STREAM === "1";
+const sdbg = (...a) => { if (DBG_STREAM()) console.log("[qoder-stream]", ...a); };
 function openaiChunk({ model, chatId, delta, finish, usage }) {
   const c = {
     id: chatId,
@@ -19,11 +22,13 @@ function errorEvent(e) {
   return `event: error\ndata: ${JSON.stringify({ message: String(e?.detail || e?.message || e), type: e?.kind || "upstream_error" })}\n\n`;
 }
 
-export function reshapeQoderStream(upstreamRes, { model, chatId }) {
+export function reshapeQoderStream(upstreamRes, { model, chatId, prefetched = [] }) {
   const src = upstreamRes.body;
   const enc = new TextEncoder();
   const dec = new TextDecoder();
-  let buf = "";
+  // 预读帧（chat.js 为取流内判决而先读的字节）原样回灌：既不丢内容也不重复，
+  // 判决帧会在这里被正常解析并抛错，同时 chat.js 已用同一批帧定出状态码挂上门面。
+  let buf = prefetched.map((b) => dec.decode(b, { stream: true })).join("");
   let usage = null;
   let finish = "stop";
   let sawContent = false;
@@ -32,40 +37,58 @@ export function reshapeQoderStream(upstreamRes, { model, chatId }) {
     async start(ctrl) {
       const reader = src.getReader();
       const send = (t) => ctrl.enqueue(enc.encode(t));
+      let chunkIdx = 0;
+      let contentLen = 0;
+      let lineIdx = 0;
       try {
-        send(openaiChunk({ model, chatId, delta: { role: "assistant" } }));
+        sdbg(`[enter] model=${model} chatId=${chatId} ct=${upstreamRes.headers.get("content-type")} status=${upstreamRes.status}`);
+        // role: assistant will be attached on first real delta to avoid premature payload commit
         for (;;) {
           const { done, value } = await reader.read();
-          if (value) buf += dec.decode(value, { stream: !done });
+          if (value) {
+            const text = dec.decode(value, { stream: !done });
+            buf += text;
+            sdbg(`[chunk#${chunkIdx++}] bytes=${value.byteLength} done=${done} decodedLen=${text.length} raw=${JSON.stringify(text.slice(0, 500))}`);
+          }
           const lines = buf.split("\n");
           buf = lines.pop();
+          sdbg(`[buf] lines=${lines.length} leftover=${JSON.stringify(buf.slice(0, 200))}`);
           for (const raw of lines) {
             const line = raw.replace(/\r$/, "");
-            if (!line.startsWith("data:")) continue;
+            lineIdx++;
+            if (!line.startsWith("data:")) { sdbg(`[line#${lineIdx}] non-data: ${JSON.stringify(line.slice(0, 200))}`); continue; }
             const payload = line.slice(5).trim();
-            if (!payload || payload === "[DONE]") continue;
+            if (!payload || payload === "[DONE]") { sdbg(`[line#${lineIdx}] skip: ${JSON.stringify(payload)}`); continue; }
             const d = extractDelta(payload);
-            if (d.err) throw d.err;
+            sdbg(`[line#${lineIdx}] payload=${JSON.stringify(payload.slice(0, 800))}`);
+            sdbg(`[line#${lineIdx}] parsed keys=${Object.keys(d).join(",")} content=${JSON.stringify((d.content || "").slice(0, 200))} reasoning=${JSON.stringify((d.reasoning || "").slice(0, 200))} toolCalls=${(d.toolCalls || []).length} usageIn=${d.usageIn} usageOut=${d.usageOut} err=${!!d.err}`);
+            if (d.err) { sdbg(`[line#${lineIdx}] ERROR from extractDelta: ${JSON.stringify(d.err)}`); throw d.err; }
             if (d.usageIn || d.usageOut) {
               usage = { prompt_tokens: d.usageIn, completion_tokens: d.usageOut, total_tokens: d.usageIn + d.usageOut };
+              sdbg(`[usage] ${JSON.stringify(usage)}`);
             }
             const delta = {};
-            if (d.content) { delta.content = d.content; sawContent = true; }
+            if (!sawContent) delta.role = "assistant";
+            if (d.content) { delta.content = d.content; contentLen += d.content.length; sawContent = true; }
             if (d.reasoning) { delta.reasoning_content = d.reasoning; sawContent = true; }
             if (d.toolCalls) { delta.tool_calls = d.toolCalls; finish = "tool_calls"; sawContent = true; }
             if (Object.keys(delta).length) send(openaiChunk({ model, chatId, delta }));
+            sdbg(`[acc] line#=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} finish=${finish} usage=${JSON.stringify(usage)}`);
           }
           if (done) break;
         }
+        sdbg(`[end] totalChunks=${chunkIdx} totalLines=${lineIdx} sawContent=${sawContent} contentLen=${contentLen} finish=${finish} usage=${JSON.stringify(usage)}`);
         if (!sawContent && !usage) {
+          sdbg(`[empty-stream] sawContent=false usage=null → throw 502 empty upstream stream`);
           throw { kind: "upstream", status: 502, detail: "empty upstream stream" };
         }
         send(openaiChunk({ model, chatId, delta: {}, finish, usage }));
         send("data: [DONE]\n\n");
         finishSent = true;
       } catch (e) {
+        sdbg(`[catch] finishSent=${finishSent} e=${JSON.stringify(e?.message || e)}`);
         if (!finishSent) {
-          try { send(openaiChunk({ model, chatId, delta: {} })); } catch {}
+          if (sawContent) { try { send(openaiChunk({ model, chatId, delta: {} })); } catch {} }
           try { send(errorEvent(e)); } catch {}
           try { send("data: [DONE]\n\n"); } catch {}
           finishSent = true;

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

@@ -144,7 +144,11 @@ export function createRelayPipeline({
       try { _logError(actual, 502, `empty turn${_why}${_err}`); } catch {}
       _evt("upstream-error", { reqId, model: actual, status: 502, message: "empty turn", timing: null, ...upstreamEcho(upRes) });
       _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}${_err} — retry or rephrase` } };
+      let _errMsg = `EMPTY_MODEL_RESPONSE: upstream returned 200 with no content${_why}${_err} — retry or rephrase`;
+      if (_d.upstreamErrorText && _d.upstreamErrorText.includes("retryAfterSeconds")) {
+        _errMsg = _d.upstreamErrorText;
+      }
+      return { handled: false, upRes: null, lastErr: { model: actual, upstream: null, status: 502, message: _errMsg } };
     }
 
     // 5a. 首块超时未写字节 → 回退（显式 timedOut 字段，status 只是 HTTP 语义展示）

package/src/routes/stream.js

@@ -35,12 +35,40 @@ function hasPayload(text) {
 // 否则返回 null（透传）。解析失败一律透传（默认保安全）。
 // 背景：网关把上游失败包成 HTTP 200 SSE；暂扣后下游流式 UI 不再展示瞬时错误
 //（如 Vertex 503 + google fallback 400），本轮走空转重试，客户端只看到最终结果。
+// Note: 流内错误包络捕获与 retryAfterSeconds 错误直出 — 见 .agents/notes/implemented/bug-fix/2026-09-28-retry-after-surfacing-error.md
+function extractRetryAfterSec(obj) {
+  if (!obj) return null;
+  if (typeof obj === "number") return obj;
+  if (typeof obj === "string") {
+    const m = obj.match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || obj.match(/\bretryAfterSeconds\s*[:=]\s*(\d+)/i);
+    if (m) return Number(m[1]);
+    try {
+      const parsed = JSON.parse(obj);
+      return extractRetryAfterSec(parsed);
+    } catch {}
+  }
+  if (typeof obj === "object") {
+    if (Number.isFinite(obj.retryAfterSeconds)) return Number(obj.retryAfterSeconds);
+    if (obj.message) {
+      const r = extractRetryAfterSec(obj.message);
+      if (r != null) return r;
+    }
+  }
+  return null;
+}
+
 function holdableChunk(txt) {
   if (typeof txt !== "string" || !txt.includes("data:")) return null;
   let sawData = false;
+  let sawEventError = false;
+  let retrySec = null;
   const errs = [];
-  for (const line of txt.split("\n")) {
-    const t = line.trim();
+  for (const rawLine of txt.split("\n")) {
+    const t = rawLine.trim();
+    if (t.startsWith("event:") && t.slice(6).trim() === "error") {
+      sawEventError = true;
+      continue;
+    }
     if (!t.startsWith("data:")) continue;
     const d = t.slice(5).trim();
     if (!d || d === "[DONE]") continue;
@@ -53,15 +81,26 @@ function holdableChunk(txt) {
     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;
+
+    const r = extractRetryAfterSec(j);
+    if (r != null) {
+      retrySec = r;
+      continue;
+    }
     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;
+    } else if (sawEventError && j.message) {
+      errs.push(String(j.message).slice(0, 300));
+    } else if (c0.finish_reason === "error") {
+      errs.push("finish_reason=error 空帧");
     }
   }
   if (!sawData) return null;
-  return errs.length ? errs.join(" | ") : "finish_reason=error 空帧";
+  if (retrySec != null) return `上游供应商触发 retryAfterSeconds: ${retrySec} ，请等候重试`;
+  if (errs.length) return errs.join(" | ");
+  if (sawEventError) return "event: error 空帧";
+  return null;
 }
 
 // 自持 reader 优先：for-await 会锁定 ReadableStream，使 body.cancel() 必 reject（真流上等于空操作），