dsh-router-core 0.3.2 → 0.3.4

package/src/supplier-config.ts

@@ -5,6 +5,7 @@
  *   - 别名 alias(前缀,模型全名 = alias/id)
  *   - 模型管理:启用/禁用 disabled、自定义 custom
  *   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
+ *   - 积分缓存 credits:按 supplier/uid 缓存最后一次拿到的剩余额度
  *
  * 持久化到 data/supplier-config.json。
  */
@@ -13,18 +14,40 @@ import { dirname, join } from 'node:path'
 
 export type PoolStrategy = 'fallback' | 'round-robin'
 
+/**
+ * 积分哨兵:插件还**没拿到过**真实额度(刚重启、积分拉取失败、或压根不支持
+ * 积分)时报 `-1`,核心据此保留上一次的缓存值,而不是把 0 写进去。
+ *
+ * 为什么不能用 0 表示未知:积分 0 是有意义的真值(用完了),核心无法区分
+ * 「拿到 0」和「没拿到」。用 0 当哨兵会把缓存冲成 0 —— 这正是 codebuddy
+ * 重启后面板永久显示 0 积分的原因(插件只在内存里缓存积分)。
+ */
+export const CREDITS_UNKNOWN = -1
+
 export interface SupplierConfig {
   alias: string
   disabled: string[]
   custom: string[]
   poolOrder: string[]
   poolStrategy: PoolStrategy
+  /** 积分缓存:uid → 剩余额度(最后一次从插件拿到的非 -1 值)。 */
+  credits: Record<string, number>
 }
 
 interface ConfigFile {
   suppliers: Record<string, Partial<SupplierConfig>>
 }
 
+/** 读盘时的积分字段校验：只留有限非负数（负数一律当没缓存过）。 */
+function readCredits(raw: unknown): Record<string, number> {
+  const out: Record<string, number> = {}
+  if (typeof raw !== 'object' || raw === null) return out
+  for (const [uid, v] of Object.entries(raw as Record<string, unknown>)) {
+    if (typeof v === 'number' && Number.isFinite(v) && v >= 0) out[uid] = v
+  }
+  return out
+}
+
 /** 通用供应商配置存储。 */
 export class SupplierConfigStore {
   private fp = ''
@@ -55,7 +78,7 @@ export class SupplierConfigStore {
   get(supplierId: string): SupplierConfig {
     let cfg = this.bySupplier.get(supplierId)
     if (!cfg) {
-      cfg = { alias: '', disabled: [], custom: [], poolOrder: [], poolStrategy: 'fallback' }
+      cfg = { alias: '', disabled: [], custom: [], poolOrder: [], poolStrategy: 'fallback', credits: {} }
       this.bySupplier.set(supplierId, cfg)
     }
     return cfg
@@ -116,6 +139,40 @@ export class SupplierConfigStore {
     this.saveLocked()
   }
 
+  // ---- 积分缓存（核心统一持久化，插件只管报） ----
+
+  /**
+   * 读缓存的积分。没缓存过返回 `CREDITS_UNKNOWN`(-1),让调用方自己决定
+   * 显示什么——不要把 -1 当 0 展示。
+   */
+  getCredits(supplierId: string, uid: string): number {
+    const v = this.get(supplierId).credits[uid]
+    return typeof v === 'number' && Number.isFinite(v) ? v : CREDITS_UNKNOWN
+  }
+
+  /**
+   * 合并插件报的积分:非 -1 就写入并返回它;-1(未知)则回落到上次缓存值。
+   * @returns 面板该显示的积分(仍可能是 -1 = 从来没拿到过)
+   */
+  putCredits(supplierId: string, uid: string, reported: number): number {
+    if (typeof reported !== 'number' || !Number.isFinite(reported) || reported < 0) {
+      return this.getCredits(supplierId, uid)
+    }
+    const prev = this.getCredits(supplierId, uid)
+    if (prev === reported) return reported // 值没变,不写盘(status() 是高频调用)
+    this.get(supplierId).credits[uid] = reported
+    this.saveLocked()
+    return reported
+  }
+
+  /** 删除链接时清掉它的积分缓存(不写盘:下一行 removeLink 会带出保存)。 */
+  clearCredits(supplierId: string, uid: string): void {
+    const credits = this.get(supplierId).credits
+    if (credits[uid] === undefined) return
+    delete credits[uid]
+    this.saveLocked()
+  }
+
   private load(): void {
     if (this.fp === '') return
     let f: ConfigFile
@@ -131,6 +188,7 @@ export class SupplierConfigStore {
         custom: Array.isArray(c.custom) ? c.custom.filter((m) => typeof m === 'string') : [],
         poolOrder: Array.isArray(c.poolOrder) ? c.poolOrder.filter((u) => typeof u === 'string') : [],
         poolStrategy: c.poolStrategy === 'round-robin' ? 'round-robin' : 'fallback',
+        credits: readCredits(c.credits),
       })
     }
   }
@@ -145,6 +203,7 @@ export class SupplierConfigStore {
         custom: [...cfg.custom],
         poolOrder: [...cfg.poolOrder],
         poolStrategy: cfg.poolStrategy,
+        credits: { ...cfg.credits },
       }
     }
     try {

package/src/suppliers/contract.ts

@@ -57,6 +57,12 @@ export type AccountState =
 export interface SupplierAccountNow {
   uid: string
   nickname?: string
+  /**
+   * 剩余额度。**拿不到就报 `-1`**，不是 0：
+   * 插件刚重启（内存缓存空）、积分拉取失败、或压根不支持积分时都是 `-1`。
+   * 核心据此保留上一次持久化下来的值 —— 报 0 会把缓存冲成 0（0 是真值
+   * 「用完了」，核心分不清「拿到 0」和「没拿到」）。
+   */
   credits: number
   /** 插件观察到的上游状态。 */
   state: AccountState
@@ -96,25 +102,19 @@ export interface SupplierModule {
   status(): SupplierStatusNow
   /** 模型来源。`force=true` 时强制刷新来源（核心「获取模型」按钮调用）。 */
   listModels(force?: boolean): Promise<ModelInfo[]> | ModelInfo[]
-  /** 默认前缀（可被通用层 alias 覆盖）。 */
-  getAlias(): string
   /**
    * 对**单个账号**调一次上游。插件不遍历账号、不管冷却、不写 res——
    * 选号/回退/健康判定全是核心的活。
    * 无账号供应商（如 opencode）传空 uid，忽略即可。
+   *
+   * 失败原因通过返回值的 `message` 报（核心在测试模型时直接用它做诊断提示），
+   * 插件不必自己存一份「上次失败」的状态。
    */
   chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>
   dispose(): void
 
   // ---- 差异化能力（可选，按存在性暴露端点/UI） ----
 
-  /** 上次 chatOnce 失败的原因（诊断用）。
-   *  测试模型由 dsh-router 核心统一走 chatOnce 路径（账号池回退/冷却自动生效），
-   *  插件只需把失败原因暴露出来供核心汇总；不实现则测试失败时只有通用提示。 */
-  lastError?(): string | undefined
-
-  // ---- 差异化能力（可选，按存在性暴露端点/UI） ----
-
   /** 生成登录链接（加账号）。有它才显示连接池（账号池）。 */
   generateLoginUrl?(): string | { ok: boolean; error?: string; loginUrl?: string } | Promise<string | { ok: boolean; error?: string; loginUrl?: string }>
   /** 回调完成登录。 */

package/src/suppliers/loader.test.ts

@@ -0,0 +1,118 @@
+/**
+ * 积分回灌（loader 层）测试 —— 锁住 2026-09-03 那个 bug：
+ *
+ * codebuddy 插件只在内存里缓存积分，重启后 status() 报 0（当时还没有 -1 哨兵），
+ * 核心又没有持久化 → 面板每次重启都显示 0 积分，而 traework 因为自己落盘
+ * state.json 所以有值。现在由核心统一持久化：插件报 -1 就顶上次的缓存。
+ *
+ * 这里测的是 wrapModule 包装后的 status()（面板真正读的那个）。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { wrapModule } from './loader.ts'
+import { SupplierConfigStore } from '../supplier-config.ts'
+import type { CredentialStore } from '../credential-store.ts'
+import type { SupplierModule, SupplierAccountNow, ChatOnceResult } from './contract.ts'
+import type { ChatRequest } from '../router/types.ts'
+
+const UNKNOWN = -1
+
+/** 造一个 env（真实 SupplierConfigStore 落临时目录，CredentialStore 用不着的空壳）。 */
+function env(): { env: Parameters<typeof wrapModule>[1]; store: SupplierConfigStore; file: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'dshr-hydrate-'))
+  const stateFile = join(dir, 'state.json')
+  const store = new SupplierConfigStore(stateFile)
+  return {
+    env: { dataDir: dir, log: () => {}, store, credentials: {} as CredentialStore },
+    store,
+    file: join(dir, 'supplier-config.json'),
+  }
+}
+
+/**
+ * 造一个插件：第 N 次 status() 报什么由脚本决定（模拟「重启后第一次拿不到，
+ * 异步拉完才有值」）。
+ */
+function plugin(id: string, script: Array<SupplierAccountNow[]>): SupplierModule & { calls: () => number } {
+  let n = 0
+  return {
+    calls: () => n,
+    id,
+    name: id,
+    // 脚本放完就停在最后一帧（模拟「第一次还没拉到 → 异步拉完有值」）
+    status: () => ({ id, name: id, accounts: script[Math.min(n++, script.length - 1)]! }),
+    listModels: () => [],
+    getAlias: () => id,
+    chatOnce: async (_uid: string, _req: ChatRequest): Promise<ChatOnceResult> => ({ ok: true, status: 200, body: '{}' }),
+    dispose: () => {},
+  } as unknown as SupplierModule & { calls: () => number }
+}
+
+const acct = (uid: string, credits: number): SupplierAccountNow => ({ uid, credits, state: 'ok' })
+
+test('插件报 -1（刚重启还没拉到）→ 顶上次缓存，面板不显示 0', () => {
+  const { env: e, store } = env()
+  // 先跑一轮拿到真值（模拟上次运行）
+  const first = wrapModule(plugin('codebuddy', [[acct('cb-1', 1500)]]), e, 'test')
+  assert.equal(first.supplier.status().accounts[0]?.credits, 1500)
+
+  // 再换个实例（模拟重启）：插件报 -1，核心应该顶出 1500
+  const restarted = wrapModule(plugin('codebuddy', [[acct('cb-1', UNKNOWN)]]), e, 'test')
+  assert.equal(restarted.supplier.status().accounts[0]?.credits, 1500)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 1500)
+})
+
+test('插件报真值 → 缓存被刷新（不是一直吃旧值）', async () => {
+  const { env: e, store } = env()
+  store.putCredits('codebuddy', 'cb-1', 1500)
+  const loaded = wrapModule(plugin('codebuddy', [[acct('cb-1', 900)]]), e, 'test')
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, 900)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 900)
+})
+
+test('插件报 0（真用完了）→ 缓存被冲成 0，不被当成未知', async () => {
+  const { env: e, store } = env()
+  store.putCredits('codebuddy', 'cb-1', 500)
+  const loaded = wrapModule(plugin('codebuddy', [[acct('cb-1', 0)]]), e, 'test')
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, 0)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 0)
+})
+
+test('从没缓存过 + 插件报 -1 → 就是 -1（面板显示「积分未知」，不编 0）', async () => {
+  const { env: e } = env()
+  const loaded = wrapModule(plugin('codebuddy', [[acct('cb-1', UNKNOWN)]]), e, 'test')
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, UNKNOWN)
+})
+
+test('异步落地：第一帧 -1（顶旧值）→ 第二帧真值（覆盖）', async () => {
+  const { env: e, store } = env()
+  store.putCredits('codebuddy', 'cb-1', 800)
+  // 模拟插件 fire-and-forget：第一次 status() 报 -1，异步拉完第二次报真值
+  const loaded = wrapModule(plugin('codebuddy', [[acct('cb-1', UNKNOWN)], [acct('cb-1', 1234)]]), e, 'test')
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, 800)
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, 1234)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 1234)
+})
+
+test('多账号各自独立回灌', async () => {
+  const { env: e, store } = env()
+  store.putCredits('codebuddy', 'cb-1', 100)
+  store.putCredits('codebuddy', 'cb-2', 200)
+  const loaded = wrapModule(
+    plugin('codebuddy', [[acct('cb-1', UNKNOWN), acct('cb-2', 250)]]),
+    e,
+    'test',
+  )
+  const by = new Map(loaded.supplier.status().accounts.map((a) => [a.uid, a.credits]))
+  assert.equal(by.get('cb-1'), 100) // 顶缓存
+  assert.equal(by.get('cb-2'), 250) // 用真值
+})
+
+test('不持久化（store fp 为空）时也不炸', async () => {
+  const e = { dataDir: '', log: () => {}, store: new SupplierConfigStore(''), credentials: {} as CredentialStore }
+  const loaded = wrapModule(plugin('codebuddy', [[acct('cb-1', 50)]]), e, 'test')
+  assert.equal(loaded.supplier.status().accounts[0]?.credits, 50)
+})

package/src/suppliers/loader.ts

@@ -36,6 +36,24 @@ function isFn(v: unknown): v is (...args: unknown[]) => unknown {
   return typeof v === 'function'
 }
 
+/**
+ * 积分回灌（核心统一持久化，插件不落盘）。
+ *
+ * 插件的积分是异步拉的：重启后第一次 status() 拿不到真值，报 `CREDITS_UNKNOWN`
+ * (-1)。这里做两件事：
+ *   - 报了真值 → 写入 supplier-config.json（下次重启还在）
+ *   - 报了 -1 → 用上次存的顶上，面板不会闪 0
+ *
+ * 插件不该自己把 0 当「未知」报上来 —— 0 是真值（用完了），核心分不清，
+ * 会把缓存冲成 0。这条是本层存在的理由（2026-09-03）。
+ */
+function hydrateCredits(supplierId: string, store: SupplierConfigStore, accounts: SupplierAccountNow[]): SupplierAccountNow[] {
+  return accounts.map((a) => {
+    const merged = store.putCredits(supplierId, a.uid, a.credits)
+    return merged === a.credits ? a : { ...a, credits: merged }
+  })
+}
+
 /** 从模块导出解析出供应商模块对象（支持 export default / 命名导出 / factory）。 */
 function resolveModule(mod: Record<string, unknown>, file: string): SupplierModule {
   const cand = (mod.default ?? mod) as Record<string, unknown>
@@ -98,7 +116,8 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
 
   // 账号池由核心持有（选号/冷却/禁用/错误累计），插件不参与。
   // 挂在 supplier 上：status() 叠加状态与 Router 的 chat 循环共用同一实例。
-  const pool = new AccountPool()
+  // 冷却键带 supplierId（跨供应商同名模型不串），故构造时注入本供应商 id。
+  const pool = new AccountPool(instance.id)
 
   const supplier: Supplier = {
     id: instance.id,
@@ -107,7 +126,7 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
     icon: (instance as { icon?: string }).icon,
     status: (): SupplierStatus => {
       const now = instance.status()
-      return { id: now.id, name: now.name, accounts: pool.decorate(now.accounts) }
+      return { id: now.id, name: now.name, accounts: pool.decorate(hydrateCredits(instance.id, env.store, now.accounts)) }
     },
     listModels: (force?: boolean): Promise<ModelInfo[]> | ModelInfo[] => instance.listModels(force),
     // 通用能力：模型启用状态/自定义由核心 SupplierConfigStore 合并
@@ -128,9 +147,6 @@ export function wrapModule(instance: SupplierModule, env: SupplierEnv, source: s
     customModelIds: (): string[] => [...env.store.get(instance.id).custom],
     accounts: (): SupplierAccountNow[] => instance.status().accounts,
     chatOnce: (uid: string, req: ChatRequest): Promise<ChatOnceResult> => instance.chatOnce(uid, req),
-    lastError: isFn((instance as unknown as Record<string, unknown>).lastError)
-      ? (): string | undefined => (instance as unknown as { lastError(): string | undefined }).lastError()
-      : undefined,
     // 删除链接：数据删除是通用能力，凭证清理由供应商内部实现（js 契约不要求）
     removeLink: isFn((instance as unknown as Record<string, unknown>).removeLink)
       ? (uid: string): Promise<boolean> => (instance as unknown as { removeLink(uid: string): Promise<boolean> }).removeLink(uid)

package/src/suppliers/nvidia/plugin.ts

@@ -54,7 +54,6 @@ export default function factory(env: SupplierEnv): SupplierModule {
   // 模型缓存由 dsh-router 核心统一管；插件每次拉取，失败回退上次成功结果
   let modelsCache: ModelInfo[] | undefined
   /** 上次 chatOnce 失败原因（供核心测试模型汇总诊断）。 */
-  let lastErr: string | undefined
   function listKeys(): string[] {
     return env.credentials.list(id)
   }
@@ -223,7 +222,6 @@ export default function factory(env: SupplierEnv): SupplierModule {
       return { id, name, accounts }
     },
     listModels: (force?: boolean): Promise<ModelInfo[]> => allModels(!!force),
-    getAlias: (): string => id,
     async addApiKey(input: { name: string; apiKey: string }): Promise<{ ok: boolean; error?: string; account?: { uid: string; nickname: string } }> {
       const key = input.apiKey.trim()
       if (key === '') return { ok: false, error: 'API key 不能为空' }
@@ -246,18 +244,17 @@ export default function factory(env: SupplierEnv): SupplierModule {
       env.credentials.remove(id, uid)
       return true
     },
-    lastError: (): string | undefined => lastErr,
     /** 对单个 key 调一次上游。选号/冷却/换号是核心的活，这里只报结果。 */
     async chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult> {
       const base = stripAlias(req.model, currentAlias())
       if (!(await allModels(false)).some((m) => m.id === base)) {
-        lastErr = `unknown model ${JSON.stringify(req.model)}`
-        return { ok: false, state: 'no_such_model', message: lastErr }
+        const msg = `unknown model ${JSON.stringify(req.model)}`
+        return { ok: false, state: 'no_such_model', message: msg }
       }
       const acct = getKey(uid)
       if (acct === undefined) {
-        lastErr = `unknown account ${JSON.stringify(uid)}`
-        return { ok: false, state: 'no_such_model', message: lastErr }
+        const msg = `unknown account ${JSON.stringify(uid)}`
+        return { ok: false, state: 'no_such_model', message: msg }
       }
 
       let body = req.rawBody
@@ -278,33 +275,33 @@ export default function factory(env: SupplierEnv): SupplierModule {
           signal: AbortSignal.timeout(120000),
         })
       } catch (err) {
-        lastErr = (err as Error).message
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = (err as Error).message
+        return { ok: false, state: 'transport', message: msg }
       }
 
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
-        lastErr = `upstream ${upstream.status}: ${text.slice(0, 120)}`
+        const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`
         const state: AccountState =
           upstream.status === 429 ? 'rate_limit'
             : upstream.status === 401 || upstream.status === 403 ? 'session_dead'
               : upstream.status === 404 ? 'unavailable'
                 : 'unknown'
-        return { ok: false, state, message: lastErr }
+        return { ok: false, state, message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心写
       if (req.stream) {
         if (!upstream.body) {
-          lastErr = 'nvidia upstream: empty stream body'
-          return { ok: false, state: 'transport', message: lastErr }
+          const msg = 'nvidia upstream: empty stream body'
+          return { ok: false, state: 'transport', message: msg }
         }
         return { ok: true, stream: upstream.body }
       }
       const text = await upstream.text().catch(() => '')
       if (text === '') {
-        lastErr = 'nvidia upstream: empty body'
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = 'nvidia upstream: empty body'
+        return { ok: false, state: 'transport', message: msg }
       }
       return { ok: true, status: upstream.status, body: text }
     },

package/src/suppliers/opencode/plugin.ts

@@ -30,7 +30,6 @@ export default function factory(env: SupplierEnv): SupplierModule {
   // 模型缓存由 dsh-router 核心统一管；插件每次拉取，失败回退上次成功结果
   let modelsCache: ModelInfo[] | undefined
   /** 上次 chatOnce 失败原因（供核心测试模型汇总诊断）。 */
-  let lastErr: string | undefined
 
   async function refreshModels(): Promise<ModelInfo[]> {
     try {
@@ -81,15 +80,13 @@ export default function factory(env: SupplierEnv): SupplierModule {
     icon,
     status: (): SupplierStatusNow => ({ id, name, accounts: [] }),
     listModels: (force?: boolean): Promise<ModelInfo[]> => allModels(!!force),
-    getAlias: (): string => id,
     // testModel 由 dsh-router 核心统一走 chatOnce 路径（无账号，无需回退）
-    lastError: (): string | undefined => lastErr,
     /** 无账号供应商：uid 恒为空，只认 free 模型。 */
     async chatOnce(_uid: string, req: ChatRequest): Promise<ChatOnceResult> {
       // 只认 free 模型，其他模型交给别的供应商
       if (!isFreeModel(req.model)) {
-        lastErr = `unknown free model ${JSON.stringify(req.model)}`
-        return { ok: false, state: 'no_such_model', message: lastErr }
+        const msg = `unknown free model ${JSON.stringify(req.model)}`
+        return { ok: false, state: 'no_such_model', message: msg }
       }
       // 模型名规范化：剥 alias 前缀，body.model 用裸 id
       let body = req.rawBody
@@ -115,24 +112,24 @@ export default function factory(env: SupplierEnv): SupplierModule {
           signal: AbortSignal.timeout(120000),
         })
       } catch (err) {
-        lastErr = `opencode upstream: ${(err as Error).message}`
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = `opencode upstream: ${(err as Error).message}`
+        return { ok: false, state: 'transport', message: msg }
       }
 
       // 非 2xx：按状态归类，核心据此冷却/换号（本供应商无号可换，直接放弃）
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
-        lastErr = `upstream ${upstream.status}: ${text.slice(0, 200)}`
+        const msg = `upstream ${upstream.status}: ${text.slice(0, 200)}`
         const state: AccountState =
           upstream.status === 429 ? 'rate_limit' : upstream.status === 404 ? 'unavailable' : 'unknown'
-        return { ok: false, state, message: lastErr }
+        return { ok: false, state, message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心（核心负责写响应）
       if (req.stream) {
         if (!upstream.body) {
-          lastErr = 'opencode upstream: empty stream body'
-          return { ok: false, state: 'transport', message: lastErr }
+          const msg = 'opencode upstream: empty stream body'
+          return { ok: false, state: 'transport', message: msg }
         }
         return { ok: true, stream: upstream.body }
       }
@@ -140,8 +137,8 @@ export default function factory(env: SupplierEnv): SupplierModule {
       // 非流式：透传 JSON（空 body 视为上游异常）
       const text = await upstream.text().catch(() => '')
       if (text === '') {
-        lastErr = 'opencode upstream: empty body'
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = 'opencode upstream: empty body'
+        return { ok: false, state: 'transport', message: msg }
       }
       return { ok: true, status: upstream.status, body: text }
     },

package/src/suppliers/openrouter/plugin.ts

@@ -50,7 +50,6 @@ export default function factory(env: SupplierEnv): SupplierModule {
   let modelsCache: ModelInfo[] | undefined
   let freeIds = new Set<string>()
   /** 上次 chatOnce 失败原因（供核心测试模型汇总诊断）。 */
-  let lastErr: string | undefined
   function listKeys(): string[] {
     return env.credentials.list(id)
   }
@@ -121,7 +120,6 @@ export default function factory(env: SupplierEnv): SupplierModule {
       return { id, name, accounts }
     },
     listModels: (force?: boolean): Promise<ModelInfo[]> => allModels(!!force),
-    getAlias: (): string => id,
     async addApiKey(input: { name: string; apiKey: string }): Promise<{ ok: boolean; error?: string; account?: { uid: string; nickname: string } }> {
       const key = input.apiKey.trim()
       if (key === '') return { ok: false, error: 'API key 不能为空' }
@@ -151,18 +149,17 @@ export default function factory(env: SupplierEnv): SupplierModule {
       env.credentials.remove(id, uid)
       return true
     },
-    lastError: (): string | undefined => lastErr,
     /** 对单个 key 调一次上游。选号/冷却/换号是核心的活，这里只报结果。 */
     async chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult> {
       const base = stripAlias(req.model, currentAlias())
       if (!freeIds.has(base) && !(await allModels(false)).some((m) => m.id === base)) {
-        lastErr = `unknown free model ${JSON.stringify(req.model)}`
-        return { ok: false, state: 'no_such_model', message: lastErr }
+        const msg = `unknown free model ${JSON.stringify(req.model)}`
+        return { ok: false, state: 'no_such_model', message: msg }
       }
       const acct = getKey(uid)
       if (acct === undefined) {
-        lastErr = `unknown account ${JSON.stringify(uid)}`
-        return { ok: false, state: 'no_such_model', message: lastErr }
+        const msg = `unknown account ${JSON.stringify(uid)}`
+        return { ok: false, state: 'no_such_model', message: msg }
       }
 
       let body = req.rawBody
@@ -188,34 +185,34 @@ export default function factory(env: SupplierEnv): SupplierModule {
           signal: AbortSignal.timeout(120000),
         })
       } catch (err) {
-        lastErr = (err as Error).message
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = (err as Error).message
+        return { ok: false, state: 'transport', message: msg }
       }
 
       if (upstream.status < 200 || upstream.status >= 300) {
         const text = await upstream.text().catch(() => '')
-        lastErr = `upstream ${upstream.status}: ${text.slice(0, 120)}`
+        const msg = `upstream ${upstream.status}: ${text.slice(0, 120)}`
         // 401/403 = 这个 key 本身不可用；429 = 限流；其余归为说不清
         const state: AccountState =
           upstream.status === 429 ? 'rate_limit'
             : upstream.status === 401 || upstream.status === 403 ? 'session_dead'
               : upstream.status === 404 ? 'unavailable'
                 : 'unknown'
-        return { ok: false, state, message: lastErr }
+        return { ok: false, state, message: msg }
       }
 
       // 流式：上游已是 OpenAI SSE，原样交回核心写
       if (req.stream) {
         if (!upstream.body) {
-          lastErr = 'openrouter upstream: empty stream body'
-          return { ok: false, state: 'transport', message: lastErr }
+          const msg = 'openrouter upstream: empty stream body'
+          return { ok: false, state: 'transport', message: msg }
         }
         return { ok: true, stream: upstream.body }
       }
       const text = await upstream.text().catch(() => '')
       if (text === '') {
-        lastErr = 'openrouter upstream: empty body'
-        return { ok: false, state: 'transport', message: lastErr }
+        const msg = 'openrouter upstream: empty body'
+        return { ok: false, state: 'transport', message: msg }
       }
       return { ok: true, status: upstream.status, body: text }
     },

package/src/suppliers/registry.test.ts

@@ -4,7 +4,10 @@
  * 锁定的契约：checkinNow 是**单账号**能力，遍历所有链接 + 汇总是核心的活：
  *   - 禁用链接不签（不动它）
  *   - 某个链接抛错 → 记成 error，不带垮其它链接
- *   - succeeded / already 按 status 统计，ok = 有任一成功或今日已签
+ *   - succeeded / already / failed 按 status 统计
+ *   - **ok = 全部链接都成功（含已签）**；有任一失败 → HTTP 400 + ok:false，
+ *     让面板把失败如实亮出来（2026-09-02 修正：旧口径「有任一成功就算 ok」
+ *     会把部分失败吞成整体成功，UI 谎报「签到完成」）
  */
 import test from 'node:test'
 import assert from 'node:assert/strict'
@@ -84,6 +87,7 @@ interface CheckinPayload {
   total: number
   succeeded: number
   already: number
+  failed: number
   results?: CheckinResult[]
   error?: string
 }
@@ -120,20 +124,36 @@ test('签到：禁用链接照样签（禁用由插件自己判定，核心不
   assert.equal(body.results?.[0]?.status, 'disabled')
 })
 
-test('签到：单链接抛错记成 error，其余照签', async () => {
+test('签到：单链接抛错记成 error 不连坐；有失败 → 400 不算整体成功', async () => {
   const { status, body } = await postCheckin(
     fixture([{ uid: 'a' }, { uid: 'b' }], async (uid) => {
       if (uid === 'a') throw new Error('boom')
       return { ok: true, status: 'ok' }
     }),
   )
-  assert.equal(status, 200)
+  // 有任一失败整体就不是 ok（否则 UI 会谎报「签到完成」）——a 的错照记，不连坐 b
+  assert.equal(status, 400)
+  assert.equal(body.ok, false)
   assert.equal(body.succeeded, 1)
+  assert.equal(body.failed, 1)
   assert.equal(body.results?.[0]?.status, 'error')
   assert.equal(body.results?.[0]?.message, 'boom')
   assert.equal(body.results?.[1]?.status, 'ok')
 })
 
+test('签到：全部成功（含 already）才算整体 ok', async () => {
+  const { status, body } = await postCheckin(
+    fixture([{ uid: 'a' }, { uid: 'b' }], async (uid) =>
+      uid === 'a' ? { ok: true, status: 'ok', message: '+200' } : { ok: true, status: 'already', message: '今日已签到' },
+    ),
+  )
+  assert.equal(status, 200)
+  assert.equal(body.ok, true)
+  assert.equal(body.succeeded, 1)
+  assert.equal(body.already, 1)
+  assert.equal(body.failed, 0)
+})
+
 test('签到：今日已签（already）算成功，不计入 succeeded', async () => {
   const { status, body } = await postCheckin(
     fixture([{ uid: 'a' }], async () => ({ ok: true, status: 'already', message: '今日已签到' })),

package/src/suppliers/registry.ts

@@ -327,7 +327,10 @@ export function supplierRoutes(base: string, loaded: LoadedSupplier, store: Supp
         return
       }
       const body = JSON.parse(await readBody(req)) as { uid?: string }
-      const ok = await s.removeLink(body.uid ?? '')
+      const uid = body.uid ?? ''
+      const ok = await s.removeLink(uid)
+      // 链接没了，它的积分缓存也得跟着走（不然删号再重登会顶着一个旧数字）
+      if (ok) store.clearCredits(s.id, uid)
       writeJson(res, ok ? 200 : 404, ok ? { ok: true } : { ok: false, error: 'link not found' })
     },
   })
@@ -375,8 +378,13 @@ export function supplierRoutes(base: string, loaded: LoadedSupplier, store: Supp
         }
         const succeeded = results.filter((r) => r.status === 'ok').length
         const already = results.filter((r) => r.status === 'already').length
-        const payload = { ok: succeeded + already > 0, total: uids.length, succeeded, already, results }
-        writeJson(res, payload.ok ? 200 : 400, payload)
+        // 全部链接都成功（含已签）才算整体成功；有任一失败 → ok:false + HTTP 400，
+        // 让面板把失败如实亮出来。别学旧逻辑「有成功就算 ok」——部分失败被
+        // 当成整体成功，UI 会谎报「签到完成」（2026-09-02 实测踩到）。
+        const failed = results.length - succeeded - already
+        const ok = failed === 0 && results.length > 0
+        const payload = { ok, total: uids.length, succeeded, already, failed, results }
+        writeJson(res, ok ? 200 : 400, payload)
       },
     })
   }