dsh-router-core 0.1.0 → 0.2.0

package/src/router/account-pool.test.ts

@@ -0,0 +1,120 @@
+/**
+ * 账号池（核心策略）测试 —— 选号/冷却/禁用/错误累计/遍历回退。
+ * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { AccountPool } from './account-pool.ts'
+import type { SupplierAccountNow } from '../suppliers/contract.ts'
+
+const accs = (uids: string[]): SupplierAccountNow[] => uids.map((uid) => ({ uid, credits: 0, state: 'ok' }))
+
+test('选号：无冷却时按 poolOrder 优先，未配置的追加在后', () => {
+  const p = new AccountPool()
+  const list = accs(['a', 'b', 'c'])
+  assert.equal(p.pick(list, ['c', 'a'], 'fallback'), 'c')
+  assert.equal(p.pick(list, ['b'], 'fallback'), 'b')
+  // 未配置顺序的按自然顺序补上
+  assert.equal(p.pick(list, [], 'fallback'), 'a')
+})
+
+test('选号：冷却中的号跳过，全冷却返回 undefined', () => {
+  const p = new AccountPool()
+  const list = accs(['a', 'b'])
+  p.noteFailure('a', 'rate_limit', '429')
+  assert.equal(p.pick(list, [], 'fallback'), 'b')
+  p.noteFailure('b', 'rate_limit', '429')
+  assert.equal(p.pick(list, [], 'fallback'), undefined)
+})
+
+test('选号：round-robin 在健康号间轮转', () => {
+  const p = new AccountPool()
+  const list = accs(['a', 'b'])
+  assert.equal(p.pick(list, [], 'round-robin'), 'a')
+  assert.equal(p.pick(list, [], 'round-robin'), 'b')
+  assert.equal(p.pick(list, [], 'round-robin'), 'a')
+})
+
+test('处置：session_dead 永久禁用（不再被选中）', () => {
+  const p = new AccountPool()
+  const list = accs(['a'])
+  p.noteFailure('a', 'session_dead', '凭证失效')
+  assert.equal(p.pick(list, [], 'fallback'), undefined)
+  assert.equal(p.decorate(list)[0]?.disabled, true)
+})
+
+test('处置：连续错误攒够阈值才冷却（前两次仍可服务）', () => {
+  const p = new AccountPool()
+  const list = accs(['a'])
+  p.noteFailure('a', 'unknown', 'e1')
+  assert.equal(p.pick(list, [], 'fallback'), 'a')
+  p.noteFailure('a', 'unknown', 'e2')
+  assert.equal(p.pick(list, [], 'fallback'), 'a')
+  // 第三次触发冷却
+  p.noteFailure('a', 'unknown', 'e3')
+  assert.equal(p.pick(list, [], 'fallback'), undefined)
+})
+
+test('处置：成功清零连续错误，避免之前累积的错误把好号冷却掉', () => {
+  const p = new AccountPool()
+  const list = accs(['a'])
+  p.noteFailure('a', 'unknown', 'e1')
+  p.noteFailure('a', 'unknown', 'e2')
+  p.noteSuccess('a')
+  p.noteFailure('a', 'unknown', 'e3')
+  assert.equal(p.pick(list, [], 'fallback'), 'a')
+})
+
+test('decorate：把冷却/禁用/错误累计叠加到插件报的「现在状态」上', () => {
+  const p = new AccountPool()
+  const list: SupplierAccountNow[] = [
+    { uid: 'ok', credits: 5, state: 'ok' },
+    { uid: 'cool', credits: 5, state: 'ok' },
+    { uid: 'dead', credits: 5, state: 'ok' },
+  ]
+  p.noteFailure('cool', 'rate_limit', '429')
+  p.noteFailure('dead', 'session_dead', '凭证失效')
+  const out = p.decorate(list)
+  const by = new Map(out.map((a) => [a.uid, a]))
+  assert.equal(by.get('ok')?.cooling, false)
+  assert.equal(by.get('ok')?.disabled, false)
+  assert.equal(by.get('cool')?.cooling, true)
+  assert.equal(by.get('cool')?.until !== undefined, true)
+  assert.equal(by.get('cool')?.reason, '429')
+  assert.equal(by.get('dead')?.disabled, true)
+  // 插件报的字段要原样透出（不能被 decorate 吃掉）
+  assert.equal(by.get('ok')?.credits, 5)
+})
+
+test('no_such_model 不惩罚账号：不冷却、不计数', () => {
+  const p = new AccountPool()
+  const list = accs(['a'])
+  // 攒够阈值次也不该冷却——模型不属于本供应商不是账号的错
+  for (let i = 0; i < 10; i++) p.noteFailure('a', 'no_such_model', 'unknown model "x"')
+  assert.equal(p.pick(list, [], 'fallback'), 'a')
+  const out = p.decorate(list)[0]
+  assert.equal(out?.cooling, false)
+  assert.equal(out?.disabled, false)
+  assert.equal(out?.err_count, 0)
+})
+
+test('状态表：各 AccountState 的处置符合预期', () => {
+  const p = new AccountPool()
+  const list = accs(['rate', 'quota', 'dead', 'unavail'])
+  p.noteFailure('rate', 'rate_limit', 'x')
+  p.noteFailure('quota', 'quota', 'x')
+  p.noteFailure('dead', 'session_dead', 'x')
+  p.noteFailure('unavail', 'unavailable', 'x')
+  // rate_limit/quota 立刻冷却；session_dead 禁用；unavailable 只计错误不冷却
+  assert.equal(p.pick(list, [], 'fallback'), 'unavail')
+  const by = new Map(p.decorate(list).map((a) => [a.uid, a]))
+  assert.equal(by.get('rate')?.cooling, true)
+  assert.equal(by.get('quota')?.cooling, true)
+  assert.equal(by.get('dead')?.disabled, true)
+  assert.equal(by.get('unavail')?.cooling, false)
+  assert.equal(by.get('unavail')?.err_count, 1)
+  // 攒够阈值后才冷却（与 unknown/transport 同一条路径）
+  p.noteFailure('unavail', 'unavailable', 'x')
+  p.noteFailure('unavail', 'unavailable', 'x')
+  assert.equal(p.pick(list, [], 'fallback'), undefined)
+})

package/src/router/account-pool.ts

@@ -0,0 +1,161 @@
+/**
+ * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、错误累计、遍历回退。
+ *
+ * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里：
+ *   - 按 poolOrder 排序（未配置的按插件报告顺序追加）
+ *   - 按 poolStrategy 选号：fallback = 取第一个健康；round-robin = 轮转健康号
+ *   - 失败按插件报的 AccountState 处置（冷却/禁用/错误累计），攒够阈值自动冷却
+ *
+ * 天花板：冷却/禁用/错误计数都是**内存态**，重启归零（与旧插件行为一致，
+ * 插件的持久化只存凭证与积分，不存健康）。要跨重启保留得落盘，届时加一个
+ * stateFile 即可，接口不用变。
+ */
+import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts'
+
+/** 各 AccountState 的处置：冷却时长 / 是否禁用 / 是否计入连续错误。 */
+interface Rule {
+  /** 冷却时长（ms）；0 = 不冷却。 */
+  cooldownMs: number
+  /** 是否永久禁用（需重新登录才能恢复）。 */
+  disable: boolean
+  /** 是否计入连续错误（攒够阈值自动冷却）。 */
+  counts: boolean
+}
+
+const MINUTE = 60_000
+
+/**
+ * 状态 → 处置表。**核心策略就在这一张表里**，插件只报状态不做决策。
+ * 时长参考 9router 的 errorConfig（限流类短冷却、额度类长冷却），
+ * 但 9router 按文本/状态匹配，这里按插件解读后的语义状态匹配，更准。
+ */
+const RULES: Record<AccountState, Rule> = {
+  ok: { cooldownMs: 0, disable: false, counts: false },
+  rate_limit: { cooldownMs: 1 * MINUTE, disable: false, counts: false },
+  quota: { cooldownMs: 10 * MINUTE, disable: false, counts: false },
+  session_dead: { cooldownMs: 0, disable: true, counts: false },
+  // 404/服务下线：只计错误不立刻冷却——偶发的自己恢复，真挂了攒够阈值再冷却
+  unavailable: { cooldownMs: 0, disable: false, counts: true },
+  transport: { cooldownMs: 0, disable: false, counts: true },
+  unknown: { cooldownMs: 0, disable: false, counts: true },
+  // 模型不属于本供应商：不是账号的错，不冷却也不计数（核心据此换下一个供应商）
+  no_such_model: { cooldownMs: 0, disable: false, counts: false },
+}
+
+/** 连续错误攒够这么多次就自动冷却（防止坏号被反复重试）。 */
+const ERR_THRESHOLD = 3
+/** 攒够后的冷却时长。 */
+const ERR_COOLDOWN_MS = 10 * MINUTE
+
+interface Entry {
+  until: number
+  disabled: boolean
+  errCount: number
+  reason: string
+}
+
+export class AccountPool {
+  private entries = new Map<string, Entry>()
+  private rrCursor = 0
+
+  private entry(uid: string): Entry {
+    let e = this.entries.get(uid)
+    if (!e) {
+      e = { until: 0, disabled: false, errCount: 0, reason: '' }
+      this.entries.set(uid, e)
+    }
+    return e
+  }
+
+  /** 是否可服务：未禁用且不在冷却中。 */
+  private healthy(uid: string, now: number): boolean {
+    const e = this.entries.get(uid)
+    if (!e) return true
+    if (e.disabled) return false
+    return e.until <= now
+  }
+
+  /**
+   * 按策略选一个健康账号。
+   * @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
+   * @param poolOrder 用户在面板拖出来的顺序（核心管）
+   * @returns 选中的 uid；无健康账号返回 undefined
+   */
+  pick(accounts: SupplierAccountNow[], poolOrder: string[], strategy: string): string | undefined {
+    const now = Date.now()
+    const byUid = new Map(accounts.map((a) => [a.uid, a]))
+    // 池顺序优先，未配置的按插件自然顺序追加
+    const ordered = [
+      ...poolOrder.filter((uid) => byUid.has(uid)),
+      ...accounts.map((a) => a.uid).filter((uid) => !poolOrder.includes(uid)),
+    ]
+    const healthy = ordered.filter((uid) => this.healthy(uid, now))
+    if (healthy.length === 0) return undefined
+    if (strategy !== 'round-robin') return healthy[0]
+    const uid = healthy[this.rrCursor % healthy.length]
+    this.rrCursor = (this.rrCursor + 1) % healthy.length
+    return uid
+  }
+
+  /** 记录一次失败：按状态处置（冷却/禁用/错误累计）。 */
+  noteFailure(uid: string, state: AccountState, message: string): void {
+    const rule = RULES[state]
+    const e = this.entry(uid)
+    if (rule.disable) {
+      e.disabled = true
+      e.reason = message
+      return
+    }
+    if (rule.cooldownMs > 0) {
+      e.until = Math.max(e.until, Date.now() + rule.cooldownMs)
+      e.reason = message
+      e.errCount = 0
+      return
+    }
+    if (rule.counts) {
+      e.errCount += 1
+      e.reason = message
+      if (e.errCount >= ERR_THRESHOLD) {
+        e.until = Date.now() + ERR_COOLDOWN_MS
+        e.errCount = 0
+      }
+    }
+  }
+
+  /** 记录一次成功：清零连续错误。 */
+  noteSuccess(uid: string): void {
+    const e = this.entries.get(uid)
+    if (e) e.errCount = 0
+  }
+
+  /** 手动冷却（面板/管理用途）。 */
+  cooldown(uid: string, ms: number, reason: string): void {
+    const e = this.entry(uid)
+    e.until = Date.now() + ms
+    e.reason = reason
+    e.errCount = 0
+  }
+
+  /** 把核心的冷却/禁用/错误累计叠加到插件报告的「现在状态」上，产出面板态。 */
+  decorate(accounts: SupplierAccountNow[]): Array<SupplierAccountNow & {
+    cooling: boolean
+    disabled: boolean
+    err_count: number
+    until?: string
+    reason?: string
+  }> {
+    const now = Date.now()
+    return accounts.map((a) => {
+      const e = this.entries.get(a.uid)
+      const cooling = e !== undefined && !e.disabled && e.until > now
+      return {
+        ...a,
+        cooling,
+        disabled: e?.disabled ?? false,
+        err_count: e?.errCount ?? 0,
+        until: cooling && e ? new Date(e.until).toISOString() : undefined,
+        reason: e?.reason !== '' ? e?.reason : undefined,
+      }
+    })
+  }
+}

package/src/router/index.ts

@@ -7,6 +7,12 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
 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 { AccountPool } from './account-pool.ts'
+import { SupplierConfigStore } from '../supplier-config.ts'
+
+/** 模型列表缓存有效期。 */
+const MODELS_TTL_MS = 60 * 1000
 
 function openAIError(code: string, msg: string): Record<string, unknown> {
   return { error: { message: msg, type: 'api_error', code } }
@@ -20,6 +26,88 @@ function writeJson(res: ServerResponse, status: number, body: unknown): void {
   res.end(JSON.stringify(body))
 }
 
+/** 丢弃响应的假 ServerResponse（测试模型用：记录状态+内容，用于判定成败）。 */
+function sinkRes(): ServerResponse & { status(): number; body(): string } {
+  let status = 200
+  let text = ''
+  const self = {
+    headersSent: false,
+    writableEnded: false,
+    writeHead: (code: number): unknown => {
+      status = code
+      return self
+    },
+    write: (chunk?: unknown): boolean => {
+      if (chunk !== undefined) text += String(chunk)
+      return true
+    },
+    end: (chunk?: unknown): unknown => {
+      if (chunk !== undefined) text += String(chunk)
+      return self
+    },
+    flushHeaders: (): void => {},
+    status: (): number => status,
+    body: (): string => text,
+  }
+  return self as unknown as ServerResponse & { status(): number; body(): string }
+}
+
+/**
+ * 把 chatOnce 的结果写进 res（核心独占响应写入权）。
+ * 流式：SSE 头 + pipe 上游已转好的 OpenAI SSE；非流式：原样写 JSON。
+ */
+async function writeChatResult(res: ServerResponse, r: ChatOnceResult): Promise<void> {
+  if (!r.ok) return // 失败不该走到这里（核心先判 ok 才写）
+  if (!('stream' in r)) {
+    res.writeHead(r.status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' })
+    res.end(r.body)
+    return
+  }
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  })
+  if (typeof (res as { flushHeaders?: () => void }).flushHeaders === 'function') {
+    ;(res as { flushHeaders: () => void }).flushHeaders()
+  }
+  // 流中途出错（客户端断开/上游断流）也要结束响应，否则连接悬挂
+  const onError = (): void => {
+    res.destroy()
+  }
+  res.once('error', onError)
+  try {
+    await r.stream.pipeTo(
+      new WritableStream<Uint8Array>({
+        write: (chunk) =>
+          new Promise<void>((resolve) => {
+            if (res.write(chunk)) resolve()
+            else res.once('drain', resolve)
+          }),
+      }),
+    )
+  } catch {
+    // 尽力而为：流断了也要收尾
+  } finally {
+    res.removeListener('error', onError)
+    res.end()
+  }
+}
+
+/** 从上游响应体提取错误信息（OpenAI {error:{message}} 或 {code,msg}/{message}）。 */
+function extractUpstreamError(body: string): string {
+  try {
+    const j = JSON.parse(body) as { error?: { message?: string }; message?: string; msg?: string; code?: number }
+    if (typeof j.error?.message === 'string') return j.error.message
+    if (typeof j.message === 'string') return j.message
+    if (typeof j.msg === 'string') return j.msg
+  } catch {
+    // 非 JSON（可能是 SSE 文本）→ 走下面截断
+  }
+  return body.slice(0, 200)
+}
+
 /** 路由器。 */
 export class Router {
   private suppliers: Supplier[] = []
@@ -27,9 +115,14 @@ export class Router {
   private customCombos: Combo[] = []
   /** round-robin 轮转游标（按组合 id 记忆）。 */
   private rrCursors = new Map<string, number>()
+  /** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+  private store: SupplierConfigStore
+  /** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
+  private modelsCache = new Map<string, { models: ModelWithEnabled[]; fetchedAt: number }>()
 
-  constructor(stateFile = '') {
+  constructor(stateFile = '', store?: SupplierConfigStore) {
     this.combosFp = stateFile ? join(dirname(stateFile), 'combos.json') : ''
+    this.store = store ?? new SupplierConfigStore(stateFile)
     this.loadCombos()
   }
 
@@ -50,9 +143,11 @@ export class Router {
                     .map((s) => s.supplier)
                     .filter((m) => typeof m === 'string' && m !== '')
                 : []
-            // 兼容旧版存的全名 alias/id：剥掉前缀存裸 id（前缀随供应商动态变）
+            // 兼容旧版存的全名 alias/id：剥掉第一段前缀存裸 id（前缀随供应商动态变）。
+            // 用 indexOf 而非 lastIndexOf：模型 id 本身可含斜杠（如 nvidia 的
+            // deepseek-ai/xxx），剥最后一段会把命名空间吃掉。
             const models = raw.map((m) => {
-              const slash = m.lastIndexOf('/')
+              const slash = m.indexOf('/')
               return slash >= 0 ? m.slice(slash + 1) : m
             })
             return {
@@ -93,6 +188,7 @@ export class Router {
     const i = this.suppliers.findIndex((s) => s.id === id)
     if (i < 0) return false
     const [s] = this.suppliers.splice(i, 1)
+    this.modelsCache.delete(id)
     s?.dispose()
     return true
   }
@@ -142,18 +238,61 @@ export class Router {
     return [...this.customCombos]
   }
 
-  /** 可用模型（按供应商分组，仅启用），面板加模型用。 */
+  /**
+   * 取某供应商的模型（核心统一缓存）。
+   *
+   * 模型列表只在这里缓存一次：`/suppliers/:id/models`（供应商详情）和
+   * `/combos`（组合加模型）共用。组合面板**不主动打上游**——它只是读缓存，
+   * 冷启动（缓存还没建）时才拉一次；真正刷新由详情页打开或「获取模型」
+   * 按钮（force）触发。
+   *
+   * 天花板：TTL 60s 是拍的。若上游模型列表变更很频繁，可调小；要彻底实时
+   * 就得让供应商暴露 etag/版本号，目前没有这个需求。
+   */
+  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 })
+      }
+    }
+    this.modelsCache.set(supplierId, { models, fetchedAt: Date.now() })
+    return models
+  }
+
+  /** 失效某供应商的模型缓存（增删改模型后调用）。 */
+  invalidateModels(supplierId: string): void {
+    this.modelsCache.delete(supplierId)
+  }
+
+  /** 可用模型（按供应商分组，仅启用），面板加模型用。
+   *  各供应商**并行**拉取——串行会把每个上游的延迟累加起来。 */
   async supplierModels(): Promise<Array<{ supplier: { id: string; name: string; alias: string }; models: ModelWithEnabled[] }>> {
-    const out: Array<{ supplier: { id: string; name: string; alias: string }; models: ModelWithEnabled[] }> = []
-    for (const s of this.suppliers) {
+    const groups = await Promise.all(this.suppliers.map(async (s) => {
       try {
-        const models = (await s.modelsWithEnabled()).filter((m) => m.enabled)
-        out.push({ supplier: { id: s.id, name: s.name, alias: s.getAlias() }, models })
+        const models = (await this.modelsOf(s.id)).filter((m) => m.enabled)
+        return { supplier: { id: s.id, name: s.name, alias: s.getAlias() }, models }
       } catch {
         // 单供应商失败不影响其它
+        return undefined
       }
-    }
-    return out
+    }))
+    return groups.filter((g): g is NonNullable<typeof g> => g !== undefined)
   }
 
   private validModels(models: string[]): boolean {
@@ -165,11 +304,15 @@ export class Router {
     return strategy === 'fallback' || strategy === 'round-robin'
   }
 
-  /** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。 */
+  /** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。
+   *  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
+   *  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
+   *  命名空间一起吃掉，后面请求必然 404。 */
   private normalizeModelIds(models: string[]): string[] {
+    const aliases = this.suppliers.map((s) => s.getAlias()).filter((a) => a !== '')
     return models.map((m) => {
-      const slash = m.lastIndexOf('/')
-      return slash >= 0 ? m.slice(slash + 1) : m
+      const prefix = aliases.find((a) => m.startsWith(`${a}/`))
+      return prefix === undefined ? m : m.slice(prefix.length + 1)
     })
   }
 
@@ -242,14 +385,12 @@ export class Router {
       writeJson(res, 503, openAIError('no_healthy_supplier', `combo ${JSON.stringify(req.model)}: all models unavailable`))
       return
     }
-    for (const s of this.suppliers) {
-      const served = await s.chatCompletions(req, res)
-      if (served) return
-    }
+    const served = await this.chatWithModel(req, res, req.model)
+    if (served) return
     writeJson(res, 503, openAIError('no_healthy_supplier', 'all suppliers unavailable'))
   }
 
-  /** 把 model 改写为组合选中的模型名后尝试供应商。 */
+  /** 把 model 改写为组合选中的模型名后，遍历供应商 + 账号（策略全在核心）。 */
   private async chatWithModel(req: ChatRequest, res: ServerResponse, model: string): Promise<boolean> {
     const clone: ChatRequest = { ...req, model }
     try {
@@ -260,12 +401,85 @@ export class Router {
       clone.rawBody = req.rawBody
     }
     for (const s of this.suppliers) {
-      const served = await s.chatCompletions(clone, res)
+      const served = await this.chatWithSupplier(s, clone, res)
       if (served) return true
     }
     return false
   }
 
+  /**
+   * 单个供应商内遍历账号（核心策略）：选号 → 调 chatOnce → 按返回的
+   * AccountState 处置 → 失败换号；写响应只在成功后发生。
+   *
+   * 流式一旦写出响应头就绑死（上游协议如此，9router 同样如此），所以
+   * 「拿到 ok:true 的流」即视为该账号成功，之后出错不再换号——要能回退
+   * 就得在写头前缓冲判定，代价是首字节延迟，目前未做。
+   */
+  private async chatWithSupplier(s: Supplier, req: ChatRequest, res: ServerResponse): Promise<boolean> {
+    const pool = s.pool
+    const cfg = this.store.get(s.id)
+    // 无账号供应商：直接调一次（uid 传空，插件忽略）
+    if (s.accounts !== undefined && s.accounts().length === 0) {
+      const r = await s.chatOnce('', req)
+      if (!r.ok) {
+        if (r.state === 'no_such_model') return false // 不是我的模型：换供应商，不记账
+        pool.noteFailure('', r.state, r.message)
+        return false
+      }
+      await writeChatResult(res, r)
+      return true
+    }
+    // 试过的号不再选：某些失败状态既不冷却也不计数（如模型不属于本供应商），
+    // 不排除试过的就会原地打转——死循环等于整个服务挂住。
+    const tried = new Set<string>()
+    for (;;) {
+      const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy)
+      if (uid === undefined) return false
+      tried.add(uid)
+      const r = await s.chatOnce(uid, req)
+      if (!r.ok) {
+        // 模型不属于本供应商：整个供应商都跳过，换号重试没有意义，
+        // 也不能记在账号头上（否则无关账号会被攒够错误冷却掉）
+        if (r.state === 'no_such_model') return false
+        pool.noteFailure(uid, r.state, r.message)
+        continue
+      }
+      pool.noteSuccess(uid)
+      await writeChatResult(res, r)
+      return true
+    }
+  }
+
+  /** 测试某供应商的某模型是否可用。
+   *  走真实的账号遍历 + chatOnce 路径：账号池回退/冷却由核心实现，自动生效；
+   *  响应丢弃到 sink，限定单一供应商（不跨供应商回退）。 */
+  async testModel(supplierId: string, model: string): Promise<{ ok: boolean; error?: string }> {
+    const s = this.suppliers.find((x) => x.id === supplierId)
+    if (s === undefined) return { ok: false, error: `unknown supplier ${JSON.stringify(supplierId)}` }
+    const sink = sinkRes()
+    const req: ChatRequest = {
+      model,
+      stream: false,
+      rawBody: JSON.stringify({ model, messages: [{ role: 'user', content: 'ping' }], stream: false, max_tokens: 1 }),
+    }
+    let served = false
+    try {
+      served = await this.chatWithSupplier(s, req, sink)
+    } 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?.()
+    return {
+      ok: false,
+      error: detail !== undefined && detail !== ''
+        ? `${detail}（账号/额度/限流问题，非模型问题）`
+        : '所有账号都失败或账号都在冷却中（稍后重试）',
+    }
+  }
+
   dispose(): void {
     for (const s of this.suppliers) s.dispose()
     this.suppliers = []