dsh-router-core 0.3.2 → 0.3.4

package/src/router/index.ts

@@ -8,6 +8,7 @@ import { dirname, join } from 'node:path'
 import type { ServerResponse } from 'node:http'
 import type { Supplier, ChatRequest, ModelInfo, ModelWithEnabled, SupplierStatus, Combo } from './types.ts'
 import type { ChatOnceResult } from '../suppliers/contract.ts'
+import type { AccountState } from '../suppliers/contract.ts'
 import { AccountPool } from './account-pool.ts'
 import { SupplierConfigStore } from '../supplier-config.ts'
 import { UsageStore } from './usage-store.ts'
@@ -21,10 +22,19 @@ interface ChatTrace {
   attempts: number
   /** 最后一次失败原因。 */
   lastError?: string
+  /** 最后一次失败的状态（组合据此判断要不要「喘口气」再降级）。 */
+  lastState?: AccountState
 }
 
-/** 模型列表缓存有效期。 */
-const MODELS_TTL_MS = 60 * 1000
+/**
+ * 模型列表缓存有效期。
+ *
+ * 取 10 分钟而不是 60s：模型列表本来很少变（上游上新/下线才动），而每次
+ * TTL 过期都会穿透到插件真打一次上游——实测冷路径 0.3~1.0s/供应商，组合页
+ * 取最慢那家就是 1s+ 的白屏。拉长 TTL 直接把这个穿透频率降一个量级；真要
+ * 立刻看新模型，点「获取模型」走 force 即可。
+ */
+const MODELS_TTL_MS = 10 * 60 * 1000
 
 function openAIError(code: string, msg: string): Record<string, unknown> {
   return { error: { message: msg, type: 'api_error', code } }
@@ -38,6 +48,36 @@ function writeJson(res: ServerResponse, status: number, body: unknown): void {
   res.end(JSON.stringify(body))
 }
 
+/**
+ * 剥掉本供应商自己的 alias 前缀（只剥一层，且只认完整 `alias/` 开头）。
+ *
+ * 为什么不能用 lastIndexOf：模型 id 本身可以含斜杠（nvidia 的
+ * `deepseek-ai/deepseek-v4-flash-0731`），剥最后一段会把命名空间吃掉，
+ * 后面请求必然 404。只认「已知 alias + /」开头，其他原样返回。
+ *
+ * 注意：核心**只在记统计名时**用它。传给插件的 model 全名保持原样——
+ * 剥前缀是插件自己的事（各供应商插件都有一份同名实现）。
+ */
+function stripAlias(model: string, alias: string): string {
+  return alias !== '' && model.startsWith(`${alias}/`) ? model.slice(alias.length + 1) : model
+}
+
+/**
+ * 组合降级前的「喘口气」等待：瞬时故障给上游一个恢复窗口再换下一个模型。
+ *
+ * 学 9router combo.js 的同名处理（注释原话：fixes: combo falls through on
+ * transient 503）—— 过载的上游往往几百毫秒内就恢复，立刻换下一个模型会
+ * 让整个组合在几毫秒内被打穿，最后全灭返回 503。
+ *
+ * 只对**瞬时**故障等：连接层失败 / 上游不可用（对应 9router 的 502/503/504）。
+ * 模型不属于本供应商（no_such_model）绝不能等 —— 它不是故障，等纯属浪费。
+ */
+const TRANSIENT_SETTLE_MS = 2_000
+
+function isTransient(state: AccountState): boolean {
+  return state === 'transport' || state === 'unavailable'
+}
+
 /** 丢弃响应的假 ServerResponse（测试模型用：记录状态+内容，用于判定成败）。 */
 function sinkRes(): ServerResponse & { status(): number; body(): string } {
   let status = 200
@@ -163,7 +203,9 @@ async function aggregateSSE(stream: ReadableStream<Uint8Array>): Promise<string>
 }
 
 /**
- * 流式 SSE 逐帧归一化：剥掉上游多发一次的**空** tool_call 字段。
+ * 流式 SSE 逐帧归一化：剥掉上游多发一次的**空** tool_call 字段，
+ * 并记住上游有没有发终止帧（`data: [DONE]`）—— 断流时核心要据此补发，
+ * 见 `writeChatResult`。
  *
  * 为什么必须做：CodeBuddy 上游的工具调用第二个 delta 会**显式发空串**
  *   `{"function":{"name":"","arguments":"{...}"},"index":0}`（以及 `"id":""`）。
@@ -178,11 +220,16 @@ async function aggregateSSE(stream: ReadableStream<Uint8Array>): Promise<string>
  * 只动 tool_calls 的空 name/id，其余原样透传；逐帧流式处理，不缓冲整条流
  * （首字节延迟不受影响）。解析失败一律原样透传——宁可不改，也不能改坏。
  */
-function normalizeSSEStream(stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {
+function normalizeSSEStream(stream: ReadableStream<Uint8Array>): {
+  stream: ReadableStream<Uint8Array>
+  /** 上游（或最后一帧残留）里出现过终止帧？调用方在流结束后读。 */
+  sawDone: () => boolean
+} {
   const enc = new TextEncoder()
   const dec = new TextDecoder()
   let buf = ''
-  return new ReadableStream<Uint8Array>({
+  let sawDone = false
+  const out = new ReadableStream<Uint8Array>({
     start: async (ctrl) => {
       const reader = stream.getReader()
       try {
@@ -195,16 +242,26 @@ function normalizeSSEStream(stream: ReadableStream<Uint8Array>): ReadableStream<
           while ((sep = buf.indexOf('\n\n')) >= 0) {
             const frame = buf.slice(0, sep + 2)
             buf = buf.slice(sep + 2)
+            if (isDoneFrame(frame)) sawDone = true
             ctrl.enqueue(enc.encode(fixFrame(frame)))
           }
         }
-        if (buf !== '') ctrl.enqueue(enc.encode(fixFrame(buf)))
+        if (buf !== '') {
+          if (isDoneFrame(buf)) sawDone = true
+          ctrl.enqueue(enc.encode(fixFrame(buf)))
+        }
       } finally {
         reader.releaseLock()
       }
       ctrl.close()
     },
   })
+  return { stream: out, sawDone: () => sawDone }
+}
+
+/** 一帧 SSE 里有没有终止帧（宽松匹配：跨 chunk 的残留尾帧也认）。 */
+function isDoneFrame(frame: string): boolean {
+  return /(^|\n)data:[ \t]*\[DONE\][ \t]*(\n|$)/.test(frame)
 }
 
 /** 修一帧 SSE：只剥空的 name/id，出任何问题都原样返回。 */
@@ -246,6 +303,9 @@ function fixFrame(frame: string): string {
  * 先写头就等于把自己锁死在这一个账号上，组合就没法回退了——而客户端只拿到
  * 一个空/截断的 SSE，表现为工具调用名是空串（`unknown tool ""`）。
  *
+ * 截断时**补发终止帧**（见末尾 finally）：客户端严格等 `[DONE]`，缺了就
+ * 整轮判失败，已流式吐出的内容全废。
+ *
  * 天花板：一旦写出第一个字节就绑死（HTTP 语义），中途断流只能截断，
  * 不能回退。要彻底解决得在写头前缓冲判定，代价是首字节延迟——未做。
  */
@@ -276,8 +336,11 @@ async function writeChatResult(res: ServerResponse, r: ChatOnceResult, wantsStre
   // 流式：边透传边统计（统计在 tee 之外的旁路做，首字节延迟不受影响）
   const tapped = probe === undefined ? undefined : tapStreamUsage(r.stream, startedAt)
   let wroteAny = false
+  /** 响应已死（客户端断开/res 已销毁）：等 drain 的写入要立刻放弃，别吊死。 */
+  let dead = false
   const writeChunk = (chunk: Uint8Array): Promise<void> =>
     new Promise<void>((resolve) => {
+      if (dead) { resolve(); return }
       if (!wroteAny) {
         // 第一个字节到手，此刻才提交响应头
         res.writeHead(200, {
@@ -292,20 +355,37 @@ async function writeChatResult(res: ServerResponse, r: ChatOnceResult, wantsStre
         wroteAny = true
       }
       if (res.write(chunk)) resolve()
-      else res.once('drain', resolve)
+      else {
+        // 背压：等 drain。但连接可能在这期间断掉 —— 那时 'drain' 永不到来，
+        // 得靠 dead 标志（onError 里置位）兜住，否则这次请求会永远挂着。
+        const onDrain = (): void => { res.removeListener('error', onDrain); resolve() }
+        res.once('drain', onDrain)
+      }
     })
 
   // 流中途出错（客户端断开/上游断流）也要结束响应，否则连接悬挂
   const onError = (): void => {
+    dead = true
     res.destroy()
   }
   res.once('error', onError)
+  const norm = normalizeSSEStream(tapped?.stream ?? r.stream)
   try {
-    await normalizeSSEStream(tapped?.stream ?? r.stream).pipeTo(new WritableStream<Uint8Array>({ write: writeChunk }))
+    await norm.stream.pipeTo(new WritableStream<Uint8Array>({ write: writeChunk }))
   } catch {
     // 流断了：一个字节都没写的话，调用方还能换号重试——交给上层决定
   } finally {
     res.removeListener('error', onError)
+    // 断流也要给客户端一个终止帧。客户端（dsh-llm adapter）严格等
+    // `[DONE]`，缺了就整轮判失败（`SSE payload stream ended without
+    // [DONE]`），已经流式吐出去的内容全部作废。上游自己发了就不重复发
+    // （多发一个 [DONE] 同样坑客户端）。
+    //
+    // 只在**已提交响应**时补：一个字节都没写 = 还能换号重试，补了就等于
+    // 把这次失败坐实成一个空响应，组合回退就没了。
+    if (wroteAny && !norm.sawDone() && !dead && !res.writableEnded && !res.destroyed) {
+      await writeChunk(DONE_FRAME)
+    }
     if (wroteAny) res.end()
     // 流走完才出得了 usage（上游多在最后一帧才发 usage）
     if (probe !== undefined && tapped !== undefined) {
@@ -318,6 +398,9 @@ async function writeChatResult(res: ServerResponse, r: ChatOnceResult, wantsStre
   return wroteAny
 }
 
+/** SSE 终止帧（断流兜底补发用）。 */
+const DONE_FRAME = new TextEncoder().encode('data: [DONE]\n\n')
+
 /** 从上游响应体提取错误信息（OpenAI {error:{message}} 或 {code,msg}/{message}）。 */
 function extractUpstreamError(body: string): string {
   try {
@@ -368,6 +451,11 @@ export class Router {
   private store: SupplierConfigStore
   /** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
   private modelsCache = new Map<string, { models: ModelWithEnabled[]; fetchedAt: number }>()
+  /**
+   * 正在拉模型的供应商 → in-flight promise。
+   * 组合页会同时从多个入口触发同一个供应商的刷新，不去重上游就被按 N 倍打。
+   */
+  private modelsInflight = new Map<string, Promise<ModelWithEnabled[]>>()
   /** 请求日志出口（面板/宿主 logger）。 */
   private log: (msg: string) => void
   /** 用量统计（概览看板）。 */
@@ -516,37 +604,80 @@ export class Router {
    * 取某供应商的模型（核心统一缓存）。
    *
    * 模型列表只在这里缓存一次：`/suppliers/:id/models`（供应商详情）和
-   * `/combos`（组合加模型）共用。组合面板**不主动打上游**——它只是读缓存，
-   * 冷启动（缓存还没建）时才拉一次；真正刷新由详情页打开或「获取模型」
-   * 按钮（force）触发。
+   * `/combos`（组合加模型）共用。
+   *
+   * **过期后走 stale-while-revalidate**:先返回旧值让面板立刻有内容,后台
+   * 重新拉,拉完下次请求就是新的。为什么必须这样:插件的 `listModels` 大多
+   * 无条件打上游(实测冷路径 0.3~1.0s/供应商),而组合页要拉全部供应商、
+   * 取最慢那家——同步等就是 1s+ 的白屏。旧值只可能「少列了新模型」,
+   * 比白屏划算;想立刻看新模型点「获取模型」(force)即可。
    *
-   * 天花板：TTL 60s 是拍的。若上游模型列表变更很频繁，可调小；要彻底实时
-   * 就得让供应商暴露 etag/版本号，目前没有这个需求。
+   * 只有两种情况会真的等:`force`(用户主动刷新)和**从来没有过缓存值**
+   * (冷启动,没有旧值可给)。后者只发生一次。
    */
   async modelsOf(supplierId: string, force = false): Promise<ModelWithEnabled[]> {
     const s = this.suppliers.find((x) => x.id === supplierId)
     if (s === undefined) return []
     const hit = this.modelsCache.get(supplierId)
-    if (!force && hit !== undefined && Date.now() - hit.fetchedAt < MODELS_TTL_MS) return hit.models
-    const cfg = this.store.get(supplierId)
-    const custom = new Set(cfg.custom)
-    const disabled = new Set(cfg.disabled)
-    const list = await Promise.resolve(s.listModels())
-    const models: ModelWithEnabled[] = list.map((mm) => ({
-      ...mm,
-      enabled: !disabled.has(mm.id),
-      custom: custom.has(mm.id) ? true : undefined,
-    }))
-    // 自定义模型（listModels 之外的）并入显示
-    const seen = new Set(models.map((mm) => mm.id))
-    for (const id of custom) {
-      if (!seen.has(id)) {
-        seen.add(id)
-        models.push({ id, enabled: !disabled.has(id), custom: true })
-      }
+    const fresh = hit !== undefined && Date.now() - hit.fetchedAt < MODELS_TTL_MS
+    if (!force && fresh) return hit!.models
+    // 有旧值(只是过期了):立刻返回旧值,后台刷新
+    if (!force && hit !== undefined) {
+      // 后台刷新的失败不能冒出来:这是 fire-and-forget,没人接
+      void this.refreshModels(supplierId, s).catch(() => {})
+      return hit.models
     }
-    this.modelsCache.set(supplierId, { models, fetchedAt: Date.now() })
-    return models
+    return await this.refreshModels(supplierId, s)
+  }
+
+  /**
+   * 真拉一次上游并写缓存。并发调用共享同一个 in-flight promise——
+   * 组合页会同时触发多个入口,不去重会把上游按 N 倍打(各家插件自己没做这层)。
+   *
+   * 失败时:**有旧值就退回旧值**(宁可显示几分钟前的列表,也别让面板空掉),
+   * **没旧值就把错误抛回去**——调用方(`supplierModels`)据此把该供应商整个
+   * 剔除,而不是显示一个「有 0 个模型」的空壳。
+   */
+  private refreshModels(supplierId: string, s: Supplier): Promise<ModelWithEnabled[]> {
+    const inflight = this.modelsInflight.get(supplierId)
+    if (inflight !== undefined) return inflight
+    const p = (async (): Promise<ModelWithEnabled[]> => {
+      const cfg = this.store.get(supplierId)
+      const custom = new Set(cfg.custom)
+      const disabled = new Set(cfg.disabled)
+      const list = await Promise.resolve(s.listModels())
+      const models: ModelWithEnabled[] = list.map((mm) => ({
+        ...mm,
+        enabled: !disabled.has(mm.id),
+        custom: custom.has(mm.id) ? true : undefined,
+      }))
+      // 自定义模型（listModels 之外的）并入显示
+      const seen = new Set(models.map((mm) => mm.id))
+      for (const id of custom) {
+        if (!seen.has(id)) {
+          seen.add(id)
+          models.push({ id, enabled: !disabled.has(id), custom: true })
+        }
+      }
+      const stale = this.modelsCache.get(supplierId)
+      // 拉到空列表当「上游抖了一下」:有旧值就保住旧值并返回它,别把面板清空。
+      // 真的一家模型都没有的供应商,第一次(无旧值)就该拿到空,不受影响。
+      if (models.length === 0 && stale !== undefined && stale.models.length > 0) {
+        return stale.models
+      }
+      this.modelsCache.set(supplierId, { models, fetchedAt: Date.now() })
+      return models
+    })()
+      .catch((err: unknown) => {
+        const stale = this.modelsCache.get(supplierId)
+        if (stale !== undefined) return stale.models
+        throw err instanceof Error ? err : new Error(String(err))
+      })
+      .finally(() => {
+        this.modelsInflight.delete(supplierId)
+      })
+    this.modelsInflight.set(supplierId, p)
+    return p
   }
 
   /** 失效某供应商的模型缓存（增删改模型后调用）。 */
@@ -696,18 +827,26 @@ export class Router {
       for (let i = 0; i < combo.models.length; i++) {
         const model = combo.models[(start + i) % combo.models.length]
         if (model === undefined) continue
-        const served = await this.chatWithModel(req, res, model, probe)
+        const trace: ChatTrace = { attempts: 0 }
+        const served = await this.chatWithModel(req, res, model, probe, trace)
         if (served) {
           settle(true)
           return
         }
+        // 瞬时故障：先给上游一个恢复窗口再换下一个模型。否则过载的上游
+        // 会被整个组合在几毫秒内依次打穿 —— 最后一次失败就是全灭 503。
+        if (trace.lastState !== undefined && isTransient(trace.lastState) && i < combo.models.length - 1) {
+          await new Promise((r) => setTimeout(r, TRANSIENT_SETTLE_MS))
+        }
       }
       settle(false, 'combo: all models unavailable')
       writeJson(res, 503, openAIError('no_healthy_supplier', `combo ${JSON.stringify(req.model)}: all models unavailable`))
       return
     }
-    // 直接调用：模型全名 = alias/model。用别名反查供应商，精准调用；
-    // 别名查不到（拼错 / 供应商没加载）才退化为遍历，保持旧行为可用。
+    // 直接调用：模型全名 = alias/model。用别名反查供应商，精准调用。
+    // 查不到别名（无 `alias/` 前缀）就走 chatWithModel，那里会要求
+    // `supplierId,modelId` 形态；两者都不满足 = 缺供应商前缀 → 直接 503，
+    // 不再遍历所有供应商兜底（严格图6拓扑）。
     const slash = req.model.indexOf('/')
     const alias = slash > 0 ? req.model.slice(0, slash) : ''
     const target = alias === '' ? undefined : this.supplierByAlias(alias)
@@ -744,7 +883,12 @@ export class Router {
    *  不再挨个问供应商「这是不是你的模型」——精准调用，也避免同名模型串台。
    *  兼容旧的裸 `modelId`（没有逗号）：降级为遍历，行为同以前。
    */
-  private async chatWithModel(req: ChatRequest, res: ServerResponse, model: string, probe?: UsageProbe): Promise<boolean> {
+  /**
+   * @param outTrace 可选出参：把这次调用的追踪信息带回去（组合据此判断
+   *   要不要「喘口气」再降级）。裸 id 遍历路径不填（多供应商混在一起，
+   *   失败状态没有单一归属）。
+   */
+  private async chatWithModel(req: ChatRequest, res: ServerResponse, model: string, probe?: UsageProbe, outTrace?: ChatTrace): Promise<boolean> {
     const comma = model.indexOf(',')
     const supplierId = comma > 0 ? model.slice(0, comma) : undefined
     // 组合存的是供应商 id，但插件认的是自己的模型 id
@@ -759,29 +903,32 @@ export class Router {
       clone.rawBody = req.rawBody
     }
 
-    if (supplierId !== undefined) {
-      // 精准：只调这一个供应商。查不到就是配置错了，直接失败（不遍历兜底——
-      // 遍历会让拼错的 id 静默落到别的供应商上，更难查）
-      const s = this.suppliers.find((x) => x.id === supplierId)
-      if (s === undefined) {
-        this.logChat(req.model, `supplier ${JSON.stringify(supplierId)} 不存在`, 0)
-        return false
-      }
-      const t0 = Date.now()
-      const trace: ChatTrace = { attempts: 0 }
-      const served = await this.chatWithSupplier(s, clone, res, trace, probe)
-      this.logChat(req.model, served
-        ? `${s.id}/${modelId} (${trace.uid ?? '?'}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ''}`
-        : `${s.id}/${modelId} 失败 ${trace.lastError ?? 'no account'}`, Date.now() - t0)
-      return served
+    // 图6 严格拓扑：组合/路由里的每个模型都必须带 `supplierId,modelId` 前缀。
+    // 无逗号 = 配置缺供应商前缀（旧版裸 id 遗留），不再遍历所有供应商兜底——
+    // 遍历会让拼错的/缺前缀的模型静默落到某个供应商上，更难查。直接判失败。
+    if (supplierId === undefined) {
+      const msg = `model ${JSON.stringify(model)} 缺供应商前缀（应为 supplierId,modelId）`
+      this.logChat(req.model, msg, 0)
+      return false
     }
-
-    // 旧格式裸模型 id：退化为遍历
-    for (const s of this.suppliers) {
-      const served = await this.chatWithSupplier(s, clone, res, undefined, probe)
-      if (served) return true
+    // 精准：只调这一个供应商。查不到就是配置错了，直接失败（不遍历兜底）
+    const s = this.suppliers.find((x) => x.id === supplierId)
+    if (s === undefined) {
+      this.logChat(req.model, `supplier ${JSON.stringify(supplierId)} 不存在`, 0)
+      return false
+    }
+    const t0 = Date.now()
+    const trace: ChatTrace = { attempts: 0 }
+    const served = await this.chatWithSupplier(s, clone, res, trace, probe)
+    if (outTrace !== undefined) {
+      outTrace.attempts = trace.attempts
+      outTrace.lastError = trace.lastError
+      outTrace.lastState = trace.lastState
     }
-    return false
+    this.logChat(req.model, served
+      ? `${s.id}/${modelId} (${trace.uid ?? '?'}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ''}`
+      : `${s.id}/${modelId} 失败 ${trace.lastError ?? 'no account'}`, Date.now() - t0)
+    return served
   }
 
   /** 按别名找供应商（对外模型全名 = alias/model）。别名唯一，故最多命中一个。 */
@@ -806,7 +953,8 @@ export class Router {
       const r = await s.chatOnce('', req)
       if (!r.ok) {
         if (r.state === 'no_such_model') return false // 不是我的模型：换供应商，不记账
-        pool.noteFailure('', r.state, r.message)
+        if (trace !== undefined) trace.lastState = r.state
+        pool.noteFailure('', req.model, r.state, r.message)
         return false
       }
       if (trace !== undefined) trace.uid = '(no-account)'
@@ -814,7 +962,10 @@ export class Router {
         probe.supplier = s.id
         // 记对外全名 alias/model：与直接调用路径一致。组合里存的是裸
         // modelId，直接记会把同一个模型在 Top 榜上分裂成两行。
-        probe.model = `${s.getAlias()}/${req.model}`
+        // 直接调 `alias/model` 时 req.model 已带前缀，先剥掉再拼——
+        // 否则会套成 `alias/alias/model`（插件会再剥一次，功能是好的，
+        // 只是统计名多一层，Top 榜照样分裂）。
+        probe.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`
         probe.uid = ''
       }
       return await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0)
@@ -823,7 +974,7 @@ export class Router {
     // 不排除试过的就会原地打转——死循环等于整个服务挂住。
     const tried = new Set<string>()
     for (;;) {
-      const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy)
+      const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy, req.model)
       if (uid === undefined) return false
       tried.add(uid)
       const r = await s.chatOnce(uid, req)
@@ -834,28 +985,31 @@ export class Router {
           if (trace !== undefined) trace.lastError = 'no_such_model'
           return false
         }
-        pool.noteFailure(uid, r.state, r.message)
+        pool.noteFailure(uid, req.model, r.state, r.message)
         if (trace !== undefined) {
           trace.attempts += 1
+          trace.lastState = r.state
           trace.lastError = `${r.state}: ${r.message}`
         }
         continue
       }
-      pool.noteSuccess(uid)
+      pool.noteSuccess(uid, req.model)
       if (trace !== undefined) trace.uid = uid
       if (probe !== undefined) {
         probe.supplier = s.id
         // 记对外全名 alias/model：与直接调用路径一致。组合里存的是裸
         // modelId，直接记会把同一个模型在 Top 榜上分裂成两行。
-        probe.model = `${s.getAlias()}/${req.model}`
+        // 剥一次自己的前缀：直接调 `alias/model` 时 req.model 已带前缀。
+        probe.model = `${s.getAlias()}/${stripAlias(req.model, s.getAlias())}`
         probe.uid = uid
       }
       const committed = await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0)
       // 一个字节都没写（上游刚连上就断）→ 这个号不算数，换下一个重试
       if (committed) return true
-      pool.noteFailure(uid, 'transport', 'stream failed before first byte')
+      pool.noteFailure(uid, req.model, 'transport', 'stream failed before first byte')
       if (trace !== undefined) {
         trace.attempts += 1
+        trace.lastState = 'transport'
         trace.lastError = 'stream failed before first byte'
       }
     }
@@ -874,15 +1028,20 @@ export class Router {
       rawBody: JSON.stringify({ model, messages: [{ role: 'user', content: 'ping' }], stream: false, max_tokens: 1 }),
     }
     let served = false
+    const trace: ChatTrace = { attempts: 0 }
     try {
-      served = await this.chatWithSupplier(s, req, sink)
+      served = await this.chatWithSupplier(s, req, sink, trace)
     } catch (err) {
       return { ok: false, error: (err as Error).message }
     }
     // 供应商可能「服务了但写出错误响应」（如 opencode：唯一能处理该模型的供应商，错误自己上报）
     if (served && sink.status() < 400) return { ok: true }
     const fromSink = served && sink.status() >= 400 ? extractUpstreamError(sink.body()) : ''
-    const detail = fromSink !== '' ? fromSink : s.lastError?.()
+    // 失败原因优先从上游响应体取，其次用 chatOnce 返回的 message（trace.lastError）。
+    // 以前这里问插件的 lastError()——那是「最后一次失败」的可变全局，既可能串到
+    // 别的账号/别的请求，也有插件压根没实现（codebuddy 就漏了，于是永远拿不到兜底）。
+    // chatOnce 的返回值本身就带 message，用它更准，插件也不必再维护一份状态。
+    const detail = fromSink !== '' ? fromSink : trace.lastError
     return {
       ok: false,
       error: detail !== undefined && detail !== ''