dsh-router-core 0.3.3 → 0.3.5

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

@@ -66,6 +66,21 @@ function addSupplier(router: Router, s: unknown): void {
   ;(router as unknown as { suppliers: unknown[] }).suppliers.push(s)
 }
 
+/**
+ * 把某供应商的缓存标记成「已过期」（TTL 现在 10 分钟，测试不能真等）。
+ * 白盒改 fetchedAt，模拟插件重启/TTL 到期的冷路径。
+ */
+function expire(router: Router, id: string): void {
+  const cache = (router as unknown as { modelsCache: Map<string, { fetchedAt: number }> }).modelsCache
+  const hit = cache.get(id)
+  if (hit !== undefined) hit.fetchedAt = 0
+}
+
+/** 等一轮 microtask/定时器，让 fire-and-forget 的后台刷新跑完。 */
+function tick(ms = 20): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms))
+}
+
 test('组合面板连开两次只拉一次上游（缓存生效）', async () => {
   const router = new Router('')
   const a = supplier('a', [{ id: 'a-1' }])
@@ -137,9 +152,129 @@ test('单个供应商拉模型失败不影响其它供应商', async () => {
   assert.equal(groups[0]?.supplier.id, 'good')
 })
 
-test('未知供应商返回空，不抛错', async () => {
+/**
+ * 冷启动慢的回归（2026-09-03 实测）：插件的 listModels 大多无条件打上游
+ * （0.3~1.0s/供应商），TTL 一过就穿透到插件，组合页取最慢那家 = 1s+ 白屏。
+ * 现在核心走 stale-while-revalidate：过期先返回旧值，后台刷新。
+ */
+test('过期后不等上游：立刻返回旧值，后台刷新', async () => {
+  const router = new Router('')
+  // 慢供应商：真等它就是 300ms
+  const a = supplier('a', [{ id: 'a-1' }], 300)
+  addSupplier(router, a.s)
+
+  await router.modelsOf('a')
+  assert.equal(a.state.calls, 1)
+  expire(router, 'a')
+
+  const t0 = Date.now()
+  const models = await router.modelsOf('a')
+  const dt = Date.now() - t0
+
+  assert.ok(dt < 100, `过期后不该同步等上游（实测 ${dt}ms）`)
+  assert.deepEqual(models.map((m) => m.id), ['a-1'], '旧值要立刻返回，面板不空')
+  await tick(400)
+  assert.equal(a.state.calls, 2, '后台要真的刷新一次')
+})
+
+test('后台刷新后缓存变新：再取不再触发拉取', async () => {
   const router = new Router('')
-  assert.deepEqual(await router.modelsOf('nonexistent'), [])
+  const a = supplier('a', [{ id: 'a-1' }])
+  addSupplier(router, a.s)
+
+  await router.modelsOf('a')
+  expire(router, 'a')
+  await router.modelsOf('a') // 触发后台刷新
+  await tick()
+  assert.equal(a.state.calls, 2)
+
+  await router.modelsOf('a') // 已刷新过，不该再拉
+  await tick()
+  assert.equal(a.state.calls, 2)
+})
+
+test('并发刷新共享一次上游请求（不去重会把上游按 N 倍打）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }], 50)
+  addSupplier(router, a.s)
+  await router.modelsOf('a')
+  expire(router, 'a')
+
+  // 组合页的实际情况：多个入口同时触发同一个供应商
+  await Promise.all([router.modelsOf('a'), router.modelsOf('a'), router.modelsOf('a')])
+  await tick(200)
+  assert.equal(a.state.calls, 2, `并发只应多拉一次，实测 ${a.state.calls}`)
+})
+
+test('force 仍然同步等（用户主动点「获取模型」，要看到结果）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }], 150)
+  addSupplier(router, a.s)
+  await router.modelsOf('a')
+  expire(router, 'a')
+
+  const t0 = Date.now()
+  await router.modelsOf('a', true)
+  assert.ok(Date.now() - t0 >= 100, 'force 必须等上游拉完')
+  assert.equal(a.state.calls, 2)
+})
+
+test('拉到空列表不覆盖旧值（上游抖一下不该清空面板）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  addSupplier(router, a.s)
+  await router.modelsOf('a')
+
+  a.s.listModels = async (): Promise<ModelInfo[]> => []
+  expire(router, 'a')
+  const models = await router.modelsOf('a', true)
+
+  assert.deepEqual(models.map((m) => m.id), ['a-1'], '空结果不该冲掉旧列表')
+})
+
+test('后台刷新失败 → 保留旧值，不抛（fire-and-forget 没人接异常）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  addSupplier(router, a.s)
+  await router.modelsOf('a')
+
+  a.s.listModels = async (): Promise<ModelInfo[]> => {
+    throw new Error('upstream down')
+  }
+  expire(router, 'a')
+  const models = await router.modelsOf('a')
+  assert.deepEqual(models.map((m) => m.id), ['a-1'], '失败也要保住旧值')
+})
+
+test('首次就失败且无旧值 → 抛错（让 supplierModels 剔除该供应商，别显示空壳）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [])
+  a.s.listModels = async (): Promise<ModelInfo[]> => {
+    throw new Error('upstream down')
+  }
+  addSupplier(router, a.s)
+
+  await assert.rejects(() => router.modelsOf('a'), /upstream down/)
+})
+
+/**
+ * 回归（2026-09-03 契约精简）：删了插件 lastError() 后，testModel 的失败原因
+ * 必须从 chatOnce 返回值的 message 取（经 trace.lastError 透传）。以前问插件
+ * 的 lastError() 是个「最后一次失败」的可变全局，可能串别的请求，也有插件
+ * 压根没实现照样能走到。锁住：chatOnce 报的 message 能作为诊断呈现。
+ */
+test('testModel 失败 → 用 chatOnce 返回的 message 作诊断，不依赖插件 lastError()', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }])
+  // 明确不实现 lastError()——合约删了它
+  a.s.chatOnce = async (): Promise<ChatOnceResult> =>
+    ({ ok: false, state: 'quota', message: 'no quota for this plan' })
+  addSupplier(router, a.s)
+
+  const r = await router.testModel('a', 'a-1')
+  assert.equal(r.ok, false)
+  assert.match(r.error ?? '', /no quota for this plan/, '失败原因要来自 chatOnce 的 message')
+  assert.match(r.error ?? '', /账号\/额度\/限流问题/, '要带上可诊断的归类提示')
 })
 
 /**

package/src/router/types.ts

@@ -80,8 +80,6 @@ export interface Supplier {
   accounts(): SupplierAccountNow[]
   /** 对单个账号调一次上游。不遍历账号、不管冷却、不写 res。 */
   chatOnce(uid: string, req: ChatRequest): Promise<ChatOnceResult>
-  /** 上次 chatOnce 失败原因（诊断用，可选）。 */
-  lastError?(): string | undefined
   /** 删除链接（清理凭证；内部能力，js 契约不要求实现）。 */
   removeLink?(uid: string): Promise<boolean>
   dispose(): void

package/src/supplier-config.test.ts

@@ -0,0 +1,98 @@
+/**
+ * 积分缓存（核心统一持久化）测试 —— node --test 直接跑。
+ *
+ * 锁定的契约（2026-09-03 修的 bug：codebuddy 重启后面板永久显示 0 积分）：
+ *   - 插件报真值 → 落盘，重启后还在
+ *   - 插件报 -1（没拉到）→ 顶上次的缓存，不能显示 0
+ *   - 插件报 0（真用完了）→ 缓存被冲成 0，不能被当成「未知」保住旧值
+ *   - 删链接 → 缓存一起清
+ *   - 坏数据（负数/NaN/缺字段）读盘时不炸，当没缓存过
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { SupplierConfigStore } from './supplier-config.ts'
+
+/** 每个用例一个独立数据目录（stateFile 推导出 supplier-config.json 的位置）。 */
+function tempStore(preload?: unknown): { store: SupplierConfigStore; file: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'dshr-credits-'))
+  const stateFile = join(dir, 'state.json')
+  if (preload !== undefined) {
+    writeFileSync(join(dir, 'supplier-config.json'), JSON.stringify(preload))
+  }
+  return { store: new SupplierConfigStore(stateFile), file: join(dir, 'supplier-config.json') }
+}
+
+const UNKNOWN = -1
+
+test('报真值 → 落盘，重开还在', () => {
+  const { store, file } = tempStore()
+  assert.equal(store.putCredits('codebuddy', 'cb-1', 1234.5), 1234.5)
+  const raw = JSON.parse(readFileSync(file, 'utf8')) as {
+    suppliers: Record<string, { credits: Record<string, number> }>
+  }
+  assert.equal(raw.suppliers.codebuddy?.credits['cb-1'], 1234.5)
+  // 新实例 = 模拟重启
+  assert.equal(new SupplierConfigStore(join(file, '..', 'state.json')).getCredits('codebuddy', 'cb-1'), 1234.5)
+})
+
+test('报 -1（没拉到）→ 顶上次缓存，不是 0', () => {
+  const { store } = tempStore()
+  store.putCredits('codebuddy', 'cb-1', 900)
+  // 插件重启后内存缓存空 → 报 -1
+  assert.equal(store.putCredits('codebuddy', 'cb-1', UNKNOWN), 900)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 900)
+})
+
+test('从来没拿到过 → 就是 -1（读不到就别编 0）', () => {
+  const { store } = tempStore()
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), UNKNOWN)
+  assert.equal(store.putCredits('codebuddy', 'cb-1', UNKNOWN), UNKNOWN)
+})
+
+test('报 0（真用完了）→ 缓存被冲成 0', () => {
+  const { store } = tempStore()
+  store.putCredits('codebuddy', 'cb-1', 500)
+  assert.equal(store.putCredits('codebuddy', 'cb-1', 0), 0)
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), 0)
+})
+
+test('删链接 → 积分缓存一起清', () => {
+  const { store } = tempStore()
+  store.putCredits('codebuddy', 'cb-1', 700)
+  store.clearCredits('codebuddy', 'cb-1')
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), UNKNOWN)
+})
+
+test('同值重复写入不落盘（status() 是高频调用）', () => {
+  const { store, file } = tempStore()
+  store.putCredits('codebuddy', 'cb-1', 42)
+  const before = readFileSync(file, 'utf8')
+  store.putCredits('codebuddy', 'cb-1', 42)
+  assert.equal(readFileSync(file, 'utf8'), before)
+})
+
+test('坏数据读盘不炸：负数/NaN/非数字当没缓存过', () => {
+  const { store } = tempStore({
+    suppliers: { codebuddy: { credits: { 'cb-bad': -5, 'cb-nan': null, 'cb-ok': 300 } } },
+  })
+  assert.equal(store.getCredits('codebuddy', 'cb-bad'), UNKNOWN)
+  assert.equal(store.getCredits('codebuddy', 'cb-nan'), UNKNOWN)
+  assert.equal(store.getCredits('codebuddy', 'cb-ok'), 300)
+})
+
+test('旧配置文件（无 credits 字段）能读，不炸', () => {
+  const { store } = tempStore({ suppliers: { codebuddy: { alias: 'cb', poolOrder: ['cb-1'] } } })
+  assert.equal(store.getCredits('codebuddy', 'cb-1'), UNKNOWN)
+  assert.deepEqual(store.get('codebuddy').poolOrder, ['cb-1'])
+})
+
+test('按供应商隔离：同 uid 不同供应商互不干扰', () => {
+  const { store } = tempStore()
+  store.putCredits('codebuddy', 'key-1', 100)
+  store.putCredits('traework', 'key-1', 200)
+  assert.equal(store.getCredits('codebuddy', 'key-1'), 100)
+  assert.equal(store.getCredits('traework', 'key-1'), 200)
+})

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>
@@ -108,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 合并
@@ -129,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 }
     },