dsh-router-core 0.3.2 → 0.3.3

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,6 +22,8 @@ interface ChatTrace {
   attempts: number
   /** 最后一次失败原因。 */
   lastError?: string
+  /** 最后一次失败的状态（组合据此判断要不要「喘口气」再降级）。 */
+  lastState?: AccountState
 }
 
 /** 模型列表缓存有效期。 */
@@ -38,6 +41,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 +196,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 +213,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 +235,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 +296,9 @@ function fixFrame(frame: string): string {
  * 先写头就等于把自己锁死在这一个账号上，组合就没法回退了——而客户端只拿到
  * 一个空/截断的 SSE，表现为工具调用名是空串（`unknown tool ""`）。
  *
+ * 截断时**补发终止帧**（见末尾 finally）：客户端严格等 `[DONE]`，缺了就
+ * 整轮判失败，已流式吐出的内容全废。
+ *
  * 天花板：一旦写出第一个字节就绑死（HTTP 语义），中途断流只能截断，
  * 不能回退。要彻底解决得在写头前缓冲判定，代价是首字节延迟——未做。
  */
@@ -276,8 +329,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 +348,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 +391,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 {
@@ -696,18 +772,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 +828,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 +848,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 +898,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 +907,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 +919,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 +930,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'
       }
     }

package/src/router/models-cache.test.ts

@@ -311,7 +311,15 @@ test('流在写出第一个字节前就断 → 组合回退到下一个模型',
   assert.equal(heads, 1, '响应头只应提交一次')
 })
 
-test('已写出字节后断流 → 诚实截断，不回退也不二次写头', async () => {
+/**
+ * 已写出字节后断流：诚实截断，不回退也不二次写头 —— 但要**补一个终止帧**。
+ *
+ * 客户端（dsh-llm adapter）严格等 `[DONE]` 才认为流正常结束；缺了就抛
+ * `SSE payload stream ended without [DONE]`，整轮判失败，已经吐出去的内容
+ * 全部作废。所以核心补终止帧：断流降级为「拿到截断内容并正常收尾」，
+ * 而不是「整轮白干」。
+ */
+test('已写出字节后断流 → 截断并补 [DONE]，不回退也不二次写头', async () => {
   const router = new Router('')
   const half = supplier('half', [{ id: 'half-m' }])
   half.s.chatOnce = async (): Promise<ChatOnceResult> => ({
@@ -351,10 +359,81 @@ test('已写出字节后断流 → 诚实截断，不回退也不二次写头',
   await router.chatCompletions({ model: 'c2', stream: true, rawBody: JSON.stringify({ model: 'c2', messages: [] }) }, res)
 
   assert.ok(out.includes('半截'), '已投递的字节要送达客户端')
-  assert.ok(!out.includes('[DONE]'), '已提交就不该再接第二个模型的内容（会串流）')
+  assert.ok(out.includes('data: [DONE]'), '断流要补终止帧，否则客户端整轮判失败')
+  assert.equal(out.match(/\[DONE\]/g)?.length ?? 0, 1, '终止帧只能有一个（重复会坑客户端）')
+  assert.ok(!out.includes('兜底'), '已提交就不该再接第二个模型的内容（会串流）')
   assert.equal(heads, 1, '响应头只能提交一次')
 })
 
+/** 上游自己发了终止帧就别再补一个（重复 [DONE] 同样坑客户端）。 */
+test('上游已发 [DONE] → 不重复补', async () => {
+  const router = new Router('')
+  const s = supplier('sup', [{ id: 'm' }])
+  s.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"完整"}}]}\n\ndata: [DONE]\n\n'))
+        c.close()
+      },
+    }),
+  })
+  addSupplier(router, s.s)
+
+  let out = ''
+  const res = {
+    writeHead: (): void => {},
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'sup/m', stream: true, rawBody: JSON.stringify({ model: 'sup/m', messages: [] }) }, res)
+
+  assert.equal(out.match(/\[DONE\]/g)?.length ?? 0, 1, `终止帧不能重复，实际: ${JSON.stringify(out)}`)
+})
+
+/**
+ * 一个字节都没写出就断 → 绝不能补 [DONE]。
+ * 补了就等于把这次失败坐实成一个空响应，组合回退（换号/换模型）就废了。
+ */
+test('首字节前就断 → 不补 [DONE]，留给组合回退', async () => {
+  const router = new Router('')
+  const dead = supplier('dead', [{ id: 'dead-m' }])
+  dead.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({ start(c) { c.error(new Error('上游刚连上就断')) } }),
+  })
+  const live = supplier('live', [{ id: 'live-m' }])
+  live.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"兜底"}}]}\n\ndata: [DONE]\n\n'))
+        c.close()
+      },
+    }),
+  })
+  addSupplier(router, dead.s)
+  addSupplier(router, live.s)
+  assert.equal(router.createCombo('c3', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+
+  let out = ''
+  const res = {
+    writeHead: (): void => {},
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'c3', stream: true, rawBody: JSON.stringify({ model: 'c3', messages: [] }) }, res)
+
+  assert.equal(out.match(/\[DONE\]/g)?.length ?? 0, 1, '只有兜底那个流该有终止帧')
+  assert.ok(out.includes('兜底'), '必须回退到下一个模型')
+})
+
 /**
  * 对照组：插件若用 unavailable 表示「不是我的模型」就会污染账号——
  * 这正是当初把 no_such_model 加进契约的原因（unavailable 在 RULES 里计数）。
@@ -368,7 +447,9 @@ test('对照：用 unavailable 表示「不是我的模型」会污染账号', a
     ({ ok: false, state: 'unavailable', message: 'not my model' })
   addSupplier(router, other.s)
 
-  const req = { model: 'want-m', stream: false, rawBody: JSON.stringify({ model: 'want-m', messages: [] }) }
+  // 严格图6拓扑：路由必须带供应商前缀/别名，裸 model 不再遍历。
+  // 这里用 alias/model 精准命中 other（别名默认 = 供应商 id）。
+  const req = { model: 'other/other-m', stream: false, rawBody: JSON.stringify({ model: 'other/other-m', messages: [] }) }
   for (let i = 0; i < 5; i++) await router.chatCompletions(req, fakeRes())
 
   const acc = other.s.pool.decorate([{ uid: 'u1', credits: 0, state: 'ok' }])[0]
@@ -387,7 +468,9 @@ test('组合请求不污染无关供应商的账号（no_such_model 不记账）
   addSupplier(router, other.s)
   addSupplier(router, target.s)
 
-  const req = { model: 'want-m', stream: false, rawBody: JSON.stringify({ model: 'want-m', messages: [] }) }
+  // 严格图6拓扑：用 alias/model 精准命中 target（别名默认 = 供应商 id），
+  // other 完全不该被问到——这正是这条回归要守的。
+  const req = { model: 'target/want-m', stream: false, rawBody: JSON.stringify({ model: 'target/want-m', messages: [] }) }
   const res = fakeRes()
   // 连打 5 次（远超错误阈值 3）
   for (let i = 0; i < 5; i++) await router.chatCompletions(req, res)

package/src/router/precise-dispatch.test.ts

@@ -49,8 +49,11 @@ function spy(id: string, modelId: string, alias = id): Spy {
       chatOnce: async (_uid, req) => {
         calls.n += 1
         const m = (JSON.parse(req.rawBody) as { model?: string }).model ?? ''
-        seen.push(m)
-        if (m !== modelId) return { ok: false, state: 'no_such_model', message: `unknown model ${m}` }
+        seen.push(m) // 记核心传来的**原样**全名，剥前缀是插件内部的事
+        // 真实插件会先剥掉自己的 alias 再认模型（各 suppliers/*/plugin.ts
+        // 都有一份 stripAlias）；这里照做，否则直接调用路径永远匹配不上。
+        const base = m.startsWith(`${alias}/`) ? m.slice(alias.length + 1) : m
+        if (base !== modelId) return { ok: false, state: 'no_such_model', message: `unknown model ${m}` }
         return { ok: true, status: 200, body: '{"ok":1}' }
       },
       dispose: () => {},
@@ -131,19 +134,22 @@ test('模型 id 含斜杠时不被吃掉（如 deepseek-ai/xxx）', async () =>
   assert.deepEqual(a.seen, ['aaa/deepseek-ai/deepseek-v3'])
 })
 
-test('旧数据裸模型 id 仍能工作（降级为遍历）', async () => {
+test('组合存了缺供应商前缀的裸模型 id → 直接失败，不降级遍历（严格图6拓扑）', async () => {
   const router = new Router('')
   const a = spy('supA', 'a-model')
   const b = spy('supB', 'b-model')
   add(router, a.s); add(router, b.s)
-  // 模拟旧存储：裸 id，没有 supplierId 前缀
+  // 模拟旧存储：裸 id，没有 supplierId 前缀 —— 图6 下这是配置错误，不遍历兜底
   ;(router as unknown as { customCombos: Array<{ id: string; name: string; strategy: 'fallback'; models: string[] }> })
     .customCombos.push({ id: 'legacy', name: 'legacy', strategy: 'fallback', models: ['b-model'] })
 
-  await router.chatCompletions(reqWith('legacy'), fakeRes())
+  const errs: unknown[] = []
+  const res = { ...fakeRes(), end: (x?: string): unknown => { if (x) errs.push(x); return undefined } } as unknown as ServerResponse
+  await router.chatCompletions(reqWith('legacy'), res)
 
-  assert.equal(a.calls, 1, '降级路径会先问 supA（它报 no_such_model）')
-  assert.equal(b.calls, 1, '最终由 supB 服务')
+  assert.equal(a.calls, 0, '不降级遍历，不该问 supA')
+  assert.equal(b.calls, 0, '裸 id 无前缀，不该被 supB 认领')
+  assert.equal(errs.length, 1, '缺前缀的模型应判失败（组合 503）')
 })
 
 test('组合存了不存在的供应商 id → 调用失败，不静默落到别的供应商', async () => {
@@ -196,3 +202,100 @@ test('空别名 → 生效别名回落到供应商 id', () => {
   store.setAlias('supA', 'custom')
   assert.equal(store.effectiveAliases().get('supA'), 'custom')
 })
+
+/**
+ * 为什么要有这一组：用量统计记的 model 名曾把 alias 前缀套了两层
+ * （`tx/tx/hy4-preview`、`trae/trae/DeepSeek-V4-Flash-Official`）。
+ *
+ * 成因：直接调 `alias/model` 时核心**原样**把全名传给插件（剥前缀是插件
+ * 的活，见上面那条断言），但记 `probe.model` 时又拼了一次 `${alias}/`
+ * ——于是统计里出现双前缀。功能不受影响（插件拿到的名字是对的），但
+ * Top 榜会把同一个模型**分裂成两行**（`tx/hy4-preview` 和
+ * `tx/tx/hy4-preview` 各占一行），看板数据失真。
+ */
+test('用量统计：直接调 alias/model 时 model 名不重复套前缀', async () => {
+  const router = new Router('')
+  const b = spy('supB', 'b-model', 'bbb')
+  add(router, b.s)
+
+  await router.chatCompletions(reqWith('bbb/b-model'), fakeRes())
+
+  const rec = router.usage.recentList(1)[0]
+  assert.equal(rec?.model, 'bbb/b-model', '统计名必须是 alias/model，不能是 alias/alias/model')
+})
+
+test('直接调裸模型 id（无前缀）→ 判失败，不再遍历兜底（严格图6拓扑）', async () => {
+  const router = new Router('')
+  const b = spy('supB', 'b-model', 'bbb')
+  add(router, b.s)
+
+  const errs: unknown[] = []
+  const res = { ...fakeRes(), end: (x?: string): unknown => { if (x) errs.push(x); return undefined } } as unknown as ServerResponse
+  await router.chatCompletions(reqWith('b-model'), res)
+
+  assert.equal(b.calls, 0, '裸 id 不该遍历到 supB')
+  assert.equal(errs.length, 1, '无前缀的裸模型应判失败（503）')
+})
+
+/**
+ * 为什么要有这一组：学 9router combo.js 的「瞬时故障降级前先喘口气」
+ * （其注释原话：fixes: combo falls through on transient 503）。
+ *
+ * 过载的上游往往几百毫秒内就恢复。立刻换下一个模型，会让整个组合在几
+ * 毫秒内被依次打穿 —— 最后一个模型也失败时，用户看到的就是全灭 503。
+ * 等待只针对**瞬时**故障：模型不属于本供应商（no_such_model）不是故障，
+ * 等它纯属浪费时间。
+ */
+
+/** 造一个总是以指定状态失败的供应商（可记调用时刻，用于验证等待）。 */
+function failingSpy(id: string, modelId: string, state: 'transport' | 'unavailable' | 'no_such_model') {
+  const at: number[] = []
+  return {
+    calls: 0,
+    at,
+    s: {
+      id, name: id, priority: 0, pool: new AccountPool(),
+      status: () => ({ id, name: id, accounts: [{ uid: `${id}-u1`, credits: 0, state: 'ok' }] }),
+      listModels: async () => [{ id: modelId }],
+      modelsWithEnabled: async () => [{ id: modelId, enabled: true }],
+      getAlias: () => id,
+      accounts: () => [{ uid: `${id}-u1`, credits: 0, state: 'ok' }],
+      chatOnce: async (_uid: string, _req: { rawBody: string }) => {
+        at.push(Date.now())
+        return { ok: false, state, message: `${state} boom` } as ChatOnceResult
+      },
+      dispose: () => {},
+    },
+  }
+}
+
+test('组合：瞬时故障降级前会等一等，不是毫秒级打穿整个组合', async () => {
+  const router = new Router('')
+  const m1 = failingSpy('s1', 'm1', 'transport')
+  const m2 = failingSpy('s2', 'm2', 'unavailable')
+  add(router, m1.s); add(router, m2.s)
+  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+
+  const t0 = Date.now()
+  await router.chatCompletions(reqWith('combo'), fakeRes())
+  const elapsed = Date.now() - t0
+
+  // 两个都失败 → 全灭；但 s1 瞬时失败后应等一个窗口再试 s2
+  assert.equal(m1.at.length, 1)
+  assert.equal(m2.at.length, 1)
+  assert.ok(elapsed >= 1000, `瞬时故障降级前应等待（实际 ${elapsed}ms），否则组合会被瞬间打穿`)
+})
+
+test('组合：no_such_model 不是故障，降级不该等', async () => {
+  const router = new Router('')
+  const m1 = failingSpy('s1', 'm1', 'no_such_model')
+  const m2 = failingSpy('s2', 'm2', 'no_such_model')
+  add(router, m1.s); add(router, m2.s)
+  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+
+  const t0 = Date.now()
+  await router.chatCompletions(reqWith('combo'), fakeRes())
+  const elapsed = Date.now() - t0
+
+  assert.ok(elapsed < 1000, `模型不存在是配置问题不是故障，不该等（实际 ${elapsed}ms）`)
+})