dsh-router-core 0.3.14 → 0.3.16

package/lib/types/suppliers/contract.d.ts

@@ -30,7 +30,7 @@ export interface SupplierEnv {
      * 不报上来，它就会继续留在池里被轮转选中，每次都白撞一次同一个错误。
      *
      * 核心实现 = `pool.noteFailure(uid, model, state, message)`，按该状态的规则
-     * 冷却/禁用。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
+     * 冷却。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
      * 流内 `code=4008`，三个号里两个如此，round-robin 下 2/3 请求直接失败
      * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出轮转。
      *
@@ -43,7 +43,7 @@ export type SupplierFactory = (env: SupplierEnv) => SupplierModule;
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
  *
- * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、是否禁用、要不要换号
+ * 插件只报「现在怎么了」，不说「该怎么办」：冷却多久、要不要换号
  * 都是核心的策略，见 `AccountState` 各值的处置表（docs/suppliers.md）。
  *
  * 天花板：目前是固定枚举。若将来某供应商需要更细的语义，再加值而不是放宽成
@@ -56,8 +56,18 @@ export type AccountState = 'ok' | 'rate_limit' | 'quota' | 'session_dead' | 'una
  * 否则组合里每有一个别人家的模型，就会给无关账号攒一次错误，攒够阈值
  * 把它冷却掉（历史上正是这个坑）。
  */
- | 'no_such_model';
-/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却/禁用由核心叠加）。 */
+ | 'no_such_model'
+/**
+ * 请求本身不合法，被上游拒（参数错、图片格式不支持、tool_call 配对断裂…）。
+ *
+ * **不是账号的错**：同一个请求对池里每个号都会失败，冷号只会让好号白白
+ * 失效，把一次「这条请求有问题」放大成「这个模型 30 秒内谁都别用」——
+ * 组合里两条腿同时被冷就是这个机制（2026-09-15 读图 11148 事故）。
+ * 核心据此**不惩罚账号**，直接跳出本供应商换下一个模型/供应商。
+ * 与 `no_such_model` 的区别：那个是「模型不归我」，这个是「请求我不认」。
+ */
+ | 'bad_request';
+/** 面板展示的账号此刻状态（插件只报它观察到的部分，冷却由核心叠加）。 */
 export interface SupplierAccountNow {
     uid: string;
     nickname?: string;
@@ -92,7 +102,7 @@ export type ChatOnceResult =
     status: number;
     body: string;
 }
-/** 失败：核心据此做冷却/禁用/换号。 */
+/** 失败：核心据此做冷却/换号。 */
  | {
     ok: false;
     state: AccountState;
@@ -114,7 +124,7 @@ export interface SupplierModule {
      * 应提供它——否则所有供应商弹窗都显示同一句通用提示（如默认会写 OpenRouter）。
      */
     readonly apiKeyHint?: string;
-    /** 报账号「现在状态」。冷却/禁用/错误累计由核心叠加，插件不算这些。 */
+    /** 报账号「现在状态」。冷却/错误累计由核心叠加，插件不算这些。 */
     status(): SupplierStatusNow;
     /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
     listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {

package/src/client/RouterView.tsx

@@ -100,7 +100,7 @@ export function RouterView({ onBack }: RouterViewProps): JSX.Element {
         <div className="dshr-supplierGrid">
           {group.map(supplier => {
             const supplierAccounts = accounts.filter(a => a.supplier === supplier.id)
-            const healthy = supplierAccounts.filter(a => !a.cooling && !a.disabled).length
+            const healthy = supplierAccounts.filter(a => !a.cooling).length
             return (
               <section key={supplier.id} className="dshr-supplierCard" onClick={() => setDetailSupplier(supplier)}>
                 <div className="dshr-supplierRow">

package/src/client/SupplierDetail.tsx

@@ -62,7 +62,6 @@ function untilLabel(account: RouterAccount): string {
 }
 
 function statusBadge(account: RouterAccount): { text: string; cls: string } {
-  if (account.disabled) return { text: '已禁用', cls: 'dshr-badge-danger' }
   if (account.cooling) return { text: '冷却中', cls: 'dshr-badge-warn' }
   return { text: '健康', cls: 'dshr-badge-ok' }
 }
@@ -666,7 +665,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
               <div className="dshr-linkList">
                 {orderedAccounts.map((account, index) => {
                   const badge = statusBadge(account)
-                  const coolingText = account.cooling || account.disabled
+                  const coolingText = account.cooling
                     ? `${account.reason ?? ''}${untilLabel(account) !== '' ? ` · ${untilLabel(account)}` : ''}`
                     : ''
                   return (

package/src/llm/adapter.test.ts

@@ -620,8 +620,110 @@ test('wire：无 attachments 时图片回退占位文本，绝不静默丢图',
     messages: [{ role: 'user', content: [{ type: 'image', attachment: ref }] }],
   }, undefined)
   const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
-  const parts = (user?.content ?? []) as Array<{ type: string; text?: string }>
-  assert.equal(parts.length, 1)
-  assert.equal(parts[0]?.type, 'text')
-  assert.ok((parts[0]?.text ?? '').includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+  // 读不到字节时 parts 只剩一个 text 占位 → 收成紧凑字符串（无图可发，别硬撑数组）
+  const text = typeof user?.content === 'string' ? user.content : JSON.stringify(user?.content)
+  assert.ok(text.includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+  assert.ok(!text.includes('image_url'), '读不到字节时不能伪造图片 part')
+})
+
+test('wire：一步两个 read_image（每条一个 user 消息，同现场）→ tool 消息紧跟 assistant，图片合并到末尾', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  // **关键**：harness 把每个 tool 结果放**各自的** user-role 消息里（现场就是
+  // 两条独立消息）。这是第一版修复漏掉的形态——按消息各发一条 user(图) 会得到
+  // `tool,user,tool,user`，上游照样 400/11148。必须跨消息攒图、发完整串再补一条。
+  const body = await captureBodyWith({
+    messages: [
+      { role: 'user', content: [{ type: 'text', text: '读这两张图' }] },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', id: 'c1', name: 'read_image', arguments: '{}' },
+          { type: 'tool-call', id: 'c2', name: 'read_image', arguments: '{}' },
+        ],
+      },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c1', content: [{ type: 'text', text: 'tree_assembly.png' }, { type: 'image', attachment: ref }] }] },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c2', content: [{ type: 'text', text: 'tree_part.png' }, { type: 'image', attachment: ref }] }] },
+    ],
+  }, fakeAttachments())
+  const messages = body.messages as Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }>; content: unknown }>
+  assertToolPairingIntact(messages)
+
+  // 两条 tool 消息必须**连续**紧跟 assistant，各自的文本标签留在自己的 tool 里
+  const ai = messages.findIndex((m) => m.role === 'assistant')
+  assert.deepEqual(messages.slice(ai + 1, ai + 3).map((m) => m.role), ['tool', 'tool'], '两条 tool 必须连续，中间不得插 user')
+  assert.equal(messages[ai + 1]?.content, 'tree_assembly.png', '第一条 tool 带自己的标签')
+  assert.equal(messages[ai + 2]?.content, 'tree_part.png', '第二条 tool 带自己的标签')
+
+  // 图片合并到全部 tool 之后的那**一条** user 消息里（两张都在，不静默丢图）
+  const userWithImage = messages.find((m) => m.role === 'user' && Array.isArray(m.content))
+  assert.ok(userWithImage !== undefined, '带图内容必须序列化成 user 消息的 content 数组')
+  const parts = userWithImage.content as Array<{ type: string; text?: string }>
+  assert.equal(parts.filter((p) => p.type === 'image_url').length, 2, '两张图都要发出去')
+  const lastTool = messages.map((m) => m.role).lastIndexOf('tool')
+  const imageAt = messages.indexOf(userWithImage)
+  assert.ok(imageAt > lastTool, `带图 user 消息必须排在全部 tool 消息之后（实际 tool 末位 ${lastTool}，图在 ${imageAt}）`)
+  // 整段 wire 里 user(带图) 只出现一次：插两次就会把 tool 串切断
+  const imageUsers = messages.filter((m) => m.role === 'user' && Array.isArray(m.content))
+  assert.equal(imageUsers.length, 1, '带图 user 消息只能有一条（多条 = 切断了 tool 配对）')
+})
+
+/**
+ * 为什么要有这一组：`read_image` 的结果是**带图的 tool-result**。适配器曾把
+ * 图片和文本一起提成一条 `user` 消息、排在 `tool` 消息**之前**，于是 wire 里
+ * 出现 `assistant(tool_calls) → user(image) → tool`。上游判定 tool_call 与
+ * tool_result 失配，回 400 网关码 11148「tool calls and tool results do not
+ * match」（实测直连复现，把 tool 提前即 200）。
+ *
+ * 后果被池策略放大：11148 当时归 `unknown` → 瞬时冷却 30s；组合 money 两条腿
+ * 都用同一份历史，一条带图请求就把它俩同时冷掉，之后**连纯文本请求**也全灭
+ * 503（用户看到的现象）。所以这条不变式必须在 wire 层锁死：
+ * **assistant 的每个 tool_call 后面必须紧跟配套 tool 消息，中间不得插任何
+ * 其它角色**。
+ */
+
+/** 断言 wire 里 tool_call / tool_result 严格配对且不被插队。 */
+function assertToolPairingIntact(messages: Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }> }>): void {
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i]
+    if (m?.role !== 'assistant' || (m.tool_calls ?? []).length === 0) continue
+    const wanted = new Set((m.tool_calls ?? []).map((c) => c.id))
+    // 紧随其后的必须**连续**是配套 tool 消息，中途混入任何别的角色都算失配
+    // （现场踩的就是 user(图) 插在两条 tool 之间，wire 成 tool,user,tool,user）
+    let j = i + 1
+    const satisfied = new Set<string>()
+    while (j < messages.length && messages[j]?.role === 'tool') {
+      const id = messages[j]?.tool_call_id ?? ''
+      assert.ok(wanted.has(id), `第 ${j} 条 tool 消息的 tool_call_id ${JSON.stringify(id)} 不在上一条 assistant 的 tool_calls 里`)
+      satisfied.add(id)
+      j += 1
+    }
+    assert.equal(
+      satisfied.size,
+      wanted.size,
+      `assistant 的 tool_calls 未被紧邻的 tool 消息配齐`
+        + `（中间插了别的角色：${messages.slice(i + 1, j).map((x) => x.role).join(',') || '—'}）`,
+    )
+    for (const id of wanted) {
+      assert.ok(satisfied.has(id), `tool_call ${id} 没有配套 tool 消息（上游会回 11148）`)
+    }
+  }
+}
+
+test('wire：纯文本 tool-result 不因图片逻辑改变顺序（tool 紧跟 assistant）', async () => {
+  const body = await captureBodyWith({
+    messages: [
+      { role: 'user', content: [{ type: 'text', text: '跑一下' }] },
+      { role: 'assistant', content: [{ type: 'tool-call', id: 'c1', name: 'bash', arguments: '{}' }] },
+      { role: 'user', content: [{ type: 'tool-result', toolCallId: 'c1', content: [{ type: 'text', text: 'out' }] }] },
+    ],
+  }, fakeAttachments())
+  const messages = body.messages as Array<{ role: string; tool_call_id?: string; tool_calls?: Array<{ id: string }> }>
+  assertToolPairingIntact(messages)
+  assert.deepEqual(messages.map((m) => m.role), ['user', 'assistant', 'tool'], '纯文本 tool 结果仍紧跟 assistant')
 })

package/src/llm/adapter.ts

@@ -78,18 +78,40 @@ export interface RouterAdapterSource {
  * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
  * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
  */
+/** tool-result 里图片挂到 user 消息时用的说明文字（与官方适配器一致）。 */
+const TOOL_RESULT_IMAGE_TEXT = 'Tool result images'
+
 async function wireMessages(options: GenerateOptions, system: string | undefined, attachments: RouterAttachmentStore | undefined): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
+  /**
+   * 攒着「tool-result 里带出来的图片」，等这一串 tool 消息**发完**再合并成一条
+   * user 消息补在后面。
+   *
+   * 为什么必须跨消息攒、而不是各消息各发一条：harness 把**每个 tool 结果放
+   * 自己的 user-role 消息**里（读两张图 = 两条消息）。若每条消息各发一个
+   * `user(图)`，wire 就成 `assistant → tool → user(图) → tool → user(图)`——
+   * 中间那条 user 又把 tool_call/tool_result 配对接断了，上游照样 400/11148
+   * （实测：tool,user,tool,user = 400；tool,tool,user(两图) = 200）。
+   * 官方 dsh-llm-deepseek 的 serializeMessagesWithImages 同样这么做。
+   */
+  let pendingToolImages: Array<Record<string, unknown>> = []
+  const flushToolImages = (): void => {
+    if (pendingToolImages.length === 0) return
+    out.push({ role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages] })
+    pendingToolImages = []
+  }
   if (typeof system === 'string' && system !== '') {
     out.push({ role: 'system', content: system })
   }
   for (const message of options.messages) {
     if (message.role === 'system') {
       // 手写调用也可能把 system 塞进 messages（one-shot 场景），照旧支持
+      flushToolImages()
       out.push({ role: 'system', content: flattenText(message.content) })
       continue
     }
     if (message.role === 'assistant') {
+      flushToolImages()
       const text = flattenText(message.content)
       const toolCalls = message.content
         .filter((b) => b.type === 'tool-call')
@@ -108,24 +130,50 @@ async function wireMessages(options: GenerateOptions, system: string | undefined
     }
     // user / tool-result
     const toolResults = message.content.filter((b) => b.type === 'tool-result')
-    // 有图 → content 数组；纯文本 → 保持紧凑字符串 wire 形式不回归。
-    if (hasImageBlock(message.content)) {
-      const parts = await contentParts(message.content, attachments, options.signal)
-      if (parts.length > 0) out.push({ role: 'user', content: parts })
-      else if (toolResults.length === 0) out.push({ role: 'user', content: '' })
-    } else {
-      const text = flattenText(message.content)
-      if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    // 这条消息自己的（非 tool-result 的）user 部分：文本 + 图片。
+    const ownParts = await contentParts(
+      message.content.filter((b) => b.type !== 'tool-result'),
+      attachments,
+      options.signal,
+    )
+    // 有实质 user 内容（或压根没有 tool 结果）就先发这条 user 消息；
+    // 只有 tool 结果的「纯工具」消息不发空 user，图片留到 pending 里合并。
+    if (ownParts.length > 0 || toolResults.length === 0) {
+      flushToolImages()
+      out.push({ role: 'user', content: compactUserContent(ownParts) })
     }
     for (const result of toolResults) {
+      // **tool 消息必须紧跟 assistant(tool_calls)**：中间插进任何 user 消息，
+      // 上游都会判定 tool_call 与 tool_result 失配 —— codebuddy 直接 400 网关码
+      // 11148「tool calls and tool results do not match」。
+      // 图片不能放进 tool 消息（实测模型会把两张不同的图认成同一张），
+      // 也不能插在两条 tool 之间（同样 400），所以先攒起来、发完整串再补一条 user。
+      const parts = await contentParts(result.content, attachments, options.signal)
+      const imageParts = parts.filter((p) => p.type !== 'text')
+      const text = parts.filter((p) => p.type === 'text').map((p) => (p as { text?: string }).text ?? '').join('')
       // 空结果就发空串，不要替换成 '(no output)' 之类的字面量 —— 模型会
       // 以为工具真的打印了那句话（9router 也是补 content: ""）。
-      out.push({ role: 'tool', tool_call_id: result.toolCallId, content: flattenText(result.content) })
+      out.push({ role: 'tool', tool_call_id: result.toolCallId, content: text })
+      pendingToolImages.push(...imageParts)
     }
   }
+  flushToolImages()
   return out
 }
 
+/**
+ * 纯文本 parts 收成紧凑字符串 wire 形式（无图时不回归成数组）。
+ * 与官方适配器的 userContent 同义：只要有非 text part 就保持数组，否则 join。
+ */
+function compactUserContent(parts: Array<Record<string, unknown>>): string | Array<Record<string, unknown>> {
+  const texts: string[] = []
+  for (const p of parts) {
+    if (p.type !== 'text') return parts
+    texts.push((p as { text?: string }).text ?? '')
+  }
+  return texts.join('')
+}
+
 /**
  * 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
  * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
@@ -238,15 +286,6 @@ function flattenText(blocks: readonly { type: string; text?: string }[]): string
   return blocks.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('')
 }
 
-/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
-function hasImageBlock(blocks: readonly { type: string }[]): boolean {
-  for (const b of blocks) {
-    if (b.type === 'image') return true
-    if (b.type === 'tool-result' && hasImageBlock((b as unknown as { content: ReadonlyArray<{ type: string }> }).content)) return true
-  }
-  return false
-}
-
 interface OpenBlock {
   index: number
   kind: 'text' | 'reasoning' | 'tool-call'

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

@@ -1,10 +1,11 @@
 /**
- * 账号池（核心策略）测试 —— 选号/冷却/禁用/遍历回退。
+ * 账号池（核心策略）测试 —— 选号/冷却/遍历回退。
  *
  * 关键语义（v2）：
  *   - 冷却单元 = (supplierId, modelId, uid)。某连接在模型 A 上失败，只冷
  *     (A, 该连接)，该连接调模型 B 不受影响。
- *   - 禁用(session_dead) = 连接级(uid)：该号所有模型都不可用。
+ *   - session_dead = 连接级(uid)可恢复冷却：该号所有模型都不可用，到期自愈。
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，误伤号不该被钉死。
  *   - no_such_model 不惩罚账号（模型不属于本供应商不是号的错）。
  * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
  */
@@ -327,16 +328,18 @@ test('【颗粒度】同一连接对不同模型的退避独立累加/清零', (
   assert.equal(p.decorate(list, 'm1')[0]?.err_count, 0)
 })
 
-// ============ 连接级禁用(跨模型) ============
+// ============ 连接级冷却(跨模型, session_dead) ============
 
-test('【颗粒度】session_dead 是连接级禁用：跨该号所有模型', () => {
+test('【颗粒度】session_dead 是连接级冷却：跨该号所有模型，到期自愈', () => {
   const p = pool()
   const list = accs(['a'])
   p.noteFailure('a', 'm1', 'session_dead', '凭证失效')
   // 该号在 m1、m2 上都不可用（登录态问题，不是模型问题）
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined)
   assert.equal(p.pick(list, [], 'fallback', 'm2'), undefined)
-  assert.equal(p.decorate(list)[0]?.disabled, true)
+  const d = p.decorate(list)[0]
+  assert.equal(d?.cooling, true)
+  assert.ok(d?.until !== undefined, 'session_dead 冷却必须有 until（可恢复）')
 })
 
 test('处置：未知错误第一次就冷却（坏号不留在池里等下一次撞）', () => {
@@ -347,7 +350,7 @@ test('处置：未知错误第一次就冷却（坏号不留在池里等下一
   assert.equal(p.pick(list.filter((x) => x.uid === 'a'), [], 'fallback', 'm1'), undefined)
 })
 
-test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（聚合展示）', () => {
+test('decorate：把冷却叠加到插件报的「现在状态」上（聚合展示）', () => {
   const p = pool()
   const list: SupplierAccountNow[] = [
     { uid: 'ok', credits: 5, state: 'ok' },
@@ -359,10 +362,9 @@ test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（
   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('dead')?.disabled, true)
+  assert.equal(by.get('dead')?.cooling, true, 'session_dead 连接级冷却也展示为冷却中')
   // 插件报的字段要原样透出（不能被 decorate 吃掉）
   assert.equal(by.get('ok')?.credits, 5)
 })
@@ -375,7 +377,22 @@ test('no_such_model 不惩罚账号：不冷却、不计数', () => {
   assert.equal(p.pick(list, [], 'fallback', 'm1'), 'a')
   const out = p.decorate(list, 'm1')[0]
   assert.equal(out?.cooling, false)
-  assert.equal(out?.disabled, false)
+  assert.equal(out?.err_count, 0)
+})
+
+/**
+ * 为什么要有这一条：请求本身非法（如 11133 参数错、11148 tool_call 配对断裂）
+ * 对池里**每个号**结果都相同。曾把这类归 rate_limit → 瞬冷 30s，于是一次
+ * 带图请求把 money 组合两条腿同时冷掉，之后连纯文本请求也全灭 503。
+ * 不惩罚账号，好号才不会替一条坏请求陪葬。
+ */
+test('bad_request 不惩罚账号：不冷却、不计数（一次坏请求不该冷掉整池）', () => {
+  const p = pool()
+  const list = accs(['a'])
+  for (let i = 0; i < 10; i++) p.noteFailure('a', 'm1', 'bad_request', 'codebuddy 11148: tool calls do not match')
+  assert.equal(p.pick(list, [], 'fallback', 'm1'), 'a', '号必须仍然可用')
+  const out = p.decorate(list, 'm1')[0]
+  assert.equal(out?.cooling, false, '请求非法不该把号标成冷却')
   assert.equal(out?.err_count, 0)
 })
 
@@ -389,7 +406,7 @@ test('状态表：各 AccountState 的处置符合预期', () => {
   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('dead')?.cooling, true, 'session_dead = 连接级冷却')
   assert.equal(by.get('unavail')?.cooling, true, '瞬时错误第一次就冷却')
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined, '四个号都不可服务')
 })

package/src/router/account-pool.ts

@@ -1,5 +1,5 @@
 /**
- * 账号池 —— dsh-router 核心策略：选号、冷却、禁用、遍历回退。
+ * 账号池 —— dsh-router 核心策略：选号、冷却、遍历回退。
  *
  * 供应商插件只管「对单个账号调通上游」，账号层面的策略全在这里。
  *
@@ -11,7 +11,8 @@
  * 失败而对其它模型也不可用，这是错的。
  *
  *   - 冷却/限流退避/瞬时 → 键 = (supplierId, modelId, uid)，只冷「这个号 × 这个模型」
- *   - 禁用(session_dead)     → 键 = uid（登录态问题，该号所有模型都不可用）
+ *   - 凭证失效(session_dead) → 键 = uid 连接级冷却（登录态问题，该号所有模型都不可用）；
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，冷却到期自愈
  *   - 手动冷却(面板)         → 键 = uid（管理员整连接暂停）
  *
  * 为什么键里要带 supplierId：不同供应商**会有同名的模型 id**（如 traework 与
@@ -19,13 +20,13 @@
  * 会把跨供应商的同名模型串到一起。尽管本池实例当前是单供应商（loader 每供应商
  * 一个 AccountPool），键仍显式带 supplierId，语义自明且将来若池合并也安全。
  *
- * 天花板：冷却/禁用都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
+ * 天花板：冷却都是**内存态**，重启归零（与旧插件行为一致）。要跨重启保留
  * 得落盘，届时加 stateFile 即可，接口不用变。
  */
 import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts'
 import { prefixFingerprint } from './prefix-affinity.ts'
 
-/** 各 AccountState 的处置：冷却策略 / 是否禁用 / 是否计入连续错误。 */
+/** 各 AccountState 的处置：冷却策略 / 是否计入连续错误。 */
 interface Rule {
   /**
    * 冷却策略：
@@ -35,14 +36,19 @@ interface Rule {
    *  - `0` 不冷却
    */
   cooldown: number | 'transient' | 'backoff'
-  /** 是否永久禁用（需重新登录才能恢复）。 */
-  disable: boolean
   /** 是否计入连续错误（攒够阈值自动冷却）。 */
   counts: boolean
 }
 
 const MINUTE = 60_000
 
+/**
+ * 凭证失效（session_dead）的连接级冷却时长。
+ * 403 = 凭证死 or 风控误伤，上游语义分不清——取「足够长、但不永久」的窗口：
+ * 误伤号到点自愈（用户无需重启/重登），真死号每窗口只重试一次，不刷上游。
+ */
+const SESSION_DEAD_COOLDOWN_MS = 30 * MINUTE
+
 /**
  * 状态 → 处置表。**核心策略就在这一张表里**，插件只报状态不做决策。
  *
@@ -57,16 +63,22 @@ const MINUTE = 60_000
  * 核心不必再猜文本，更准。
  */
 const RULES: Record<AccountState, Rule> = {
-  ok: { cooldown: 0, disable: false, counts: false },
-  rate_limit: { cooldown: 'backoff', disable: false, counts: false },
-  quota: { cooldown: 10 * MINUTE, disable: false, counts: false },
-  session_dead: { cooldown: 0, disable: true, counts: false },
+  ok: { cooldown: 0, counts: false },
+  rate_limit: { cooldown: 'backoff', counts: false },
+  quota: { cooldown: 10 * MINUTE, counts: false },
+  // 凭证失效也只做**连接级冷却**（跨该号所有模型），到期自愈：上游 403 常是
+  // 风控/WAF 拦截，与凭证死活分不清（codebuddy 三号被 403 误禁的教训）。
+  // 真死号损失 = 每窗口重试一次，可接受；误伤号到点自动回来，无需重启。
+  session_dead: { cooldown: SESSION_DEAD_COOLDOWN_MS, counts: false },
   // 404/服务下线、传输中断、未知：每次都瞬时短冷却（见上方 9router 对齐说明）
-  unavailable: { cooldown: 'transient', disable: false, counts: false },
-  transport: { cooldown: 'transient', disable: false, counts: false },
-  unknown: { cooldown: 'transient', disable: false, counts: false },
+  unavailable: { cooldown: 'transient', counts: false },
+  transport: { cooldown: 'transient', counts: false },
+  unknown: { cooldown: 'transient', counts: false },
   // 模型不属于本供应商：不是账号的错，不冷却也不计数（核心据此换下一个供应商）
-  no_such_model: { cooldown: 0, disable: false, counts: false },
+  no_such_model: { cooldown: 0, counts: false },
+  // 请求本身非法（上游拒收这个 payload）：同一个请求对池里每个号都会失败，
+  // 冷号只会把「这条请求有问题」放大成「这个模型谁都别用」。不惩罚账号。
+  bad_request: { cooldown: 0, counts: false },
 }
 
 /**
@@ -112,10 +124,9 @@ interface CooldownEntry {
   reason: string
 }
 
-/** 连接级禁用/手动暂停记录（键 = uid）。 */
+/** 连接级冷却/手动暂停记录（键 = uid，跨该号所有模型）。 */
 interface UidEntry {
   until: number
-  disabled: boolean
   reason: string
 }
 
@@ -166,7 +177,7 @@ export class AccountPool {
   private supplierId: string
   /** (supplier, model, uid) → 冷却/退避。 */
   private cooldowns = new Map<string, CooldownEntry>()
-  /** uid → 连接级禁用 / 手动暂停。 */
+  /** uid → 连接级冷却 / 手动暂停。 */
   private byUid = new Map<string, UidEntry>()
   private rrCursor = 0
   /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
@@ -196,33 +207,29 @@ export class AccountPool {
     return e
   }
 
-  /** 某连接整体状态（禁用/手动暂停）。 */
+  /** 某连接整体状态（连接级冷却/手动暂停）。 */
   private uidState(uid: string): UidEntry {
     let e = this.byUid.get(uid)
     if (!e) {
-      e = { until: 0, disabled: false, reason: '' }
+      e = { until: 0, reason: '' }
       this.byUid.set(uid, e)
     }
     return e
   }
 
-  /** 该连接是否被禁用 / 手动整连接暂停中（跨模型生效）。 */
-  private uidBlocked(uid: string, now: number): { blocked: boolean; disabled: boolean } {
+  /** 该连接是否处于连接级冷却/手动暂停中（跨模型生效，到期自愈）。 */
+  private uidBlocked(uid: string, now: number): boolean {
     const e = this.byUid.get(uid)
-    if (!e) return { blocked: false, disabled: false }
-    if (e.disabled) return { blocked: true, disabled: true }
-    if (e.until > now) return { blocked: true, disabled: false }
-    return { blocked: false, disabled: false }
+    return e !== undefined && e.until > now
   }
 
   /**
    * 给定要试的模型，该连接是否可服务：
-   *  - 未被连接级禁用/手动暂停（跨模型）；
+   *  - 不处于连接级冷却/手动暂停（跨模型，到期自愈）；
    *  - 且此 (supplier, model, uid) 冷却单元不在冷却中。
    */
   private healthy(uid: string, model: string, now: number): boolean {
-    const b = this.uidBlocked(uid, now)
-    if (b.blocked) return false
+    if (this.uidBlocked(uid, now)) return false
     const c = this.cooldowns.get(this.key(model, uid))
     if (!c) return true
     return c.until <= now
@@ -367,18 +374,19 @@ export class AccountPool {
     return `${this.supplierId}${SEP}${modelId}`
   }
 
-  /** 记录一次失败：按状态处置（冷却/禁用/退避），落在「(模型, 连接)」这个冷却单元上。 */
+  /** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
   noteFailure(uid: string, modelId: string, state: AccountState, message: string): void {
     const rule = RULES[state]
-    // 禁用 / 手动暂停是连接级（登录态问题，跨模型）——但这里只处理规则本身
-    if (rule.disable) {
-      // session_dead：整个连接禁用（跨该号所有模型）
+    if (rule.cooldown === 0) return // no_such_model 等：不冷不记
+    // session_dead 是连接级冷却（登录态问题，跨该号所有模型），到期自愈——
+    // 不再有「永久禁用」：403 分不清凭证死活，误伤号不该被钉死
+    if (state === 'session_dead') {
       const e = this.uidState(uid)
-      e.disabled = true
+      const cd = rule.cooldown
+      e.until = Math.max(e.until, Date.now() + (typeof cd === 'number' ? cd : 0))
       e.reason = message
       return
     }
-    if (rule.cooldown === 0) return // no_such_model 等：不冷不记
     // 冷却/退避：记在 (model, uid) 单元上，不动该号其它模型
     const e = this.entry(modelId, uid)
     e.reason = message
@@ -396,7 +404,7 @@ export class AccountPool {
     e.until = Math.max(e.until, Date.now() + rule.cooldown)
   }
 
-  /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。不解除禁用。 */
+  /** 记录一次成功：清零「该模型」的限流退避等级（好号不背历史惩罚）。 */
   noteSuccess(uid: string, modelId: string): void {
     const e = this.cooldowns.get(this.key(modelId, uid))
     if (e) e.backoffLevel = 0
@@ -408,13 +416,12 @@ export class AccountPool {
     e.until = Date.now() + ms
     e.reason = reason
     // 手动暂停通常是想清掉这个号上的累积惩罚：把它的退避等级清零
-    // （disabled 不可由此解除——需重新登录）
     for (const [k, ce] of this.cooldowns) {
       if (k.endsWith(`${SEP}${uid}`)) ce.backoffLevel = 0
     }
   }
 
-  /** 把核心的冷却/禁用叠加到插件报的「现在状态」上，产出面板态。
+  /** 把核心的冷却叠加到插件报的「现在状态」上，产出面板态。
    *
    * 冷却现在是 (模型, 连接) 粒度的，而面板状态没有「当前模型」上下文，
    * 这里默认**聚合**：只要该连接在任一模型上有活跃冷却，就显示 cooling=true
@@ -423,7 +430,6 @@ export class AccountPool {
    */
   decorate(accounts: SupplierAccountNow[], modelId?: string): Array<SupplierAccountNow & {
     cooling: boolean
-    disabled: boolean
     err_count: number
     until?: string
     reason?: string
@@ -431,13 +437,12 @@ export class AccountPool {
     const now = Date.now()
     return accounts.map((a) => {
       const u = this.byUid.get(a.uid)
-      const disabled = u?.disabled ?? false
-      // 连接级手动暂停或禁用也算不可服务；但 disabled 单列，冷却不算它
-      const manualCooling = u !== undefined && !u.disabled && u.until > now
+      // 连接级冷却（session_dead 处置 / 手动暂停）也算 cooling
+      const uidCooling = u !== undefined && u.until > now
 
-      let cooling = manualCooling
-      let maxUntil = manualCooling ? u!.until : 0
-      let reason = manualCooling ? u!.reason : undefined
+      let cooling = uidCooling
+      let maxUntil = uidCooling ? u!.until : 0
+      let reason = uidCooling ? u!.reason : undefined
       let err = 0
       // 遍历本连接在所有模型上的冷却单元（或仅指定模型）
       for (const [k, ce] of this.cooldowns) {
@@ -459,7 +464,6 @@ export class AccountPool {
       return {
         ...a,
         cooling,
-        disabled,
         err_count: err,
         until: cooling && maxUntil > 0 ? new Date(maxUntil).toISOString() : undefined,
         reason: reason !== undefined && reason !== '' ? reason : undefined,