dsh-router-core 0.4.7 → 0.4.8

package/src/client/model-choice.ts

@@ -1,37 +0,0 @@
-/**
- * 自检面板的「模型」下拉该列哪些 —— 纯函数，不碰 React。
- *
- * 为什么不能把端点返回的模型全列出来：那个端点给的是**全部**模型（含用户在
- * 供应商详情里停用的）。实测某供应商 30 个模型里只有 3 个是启用的 —— 把 30 个都
- * 塞进下拉，用户会挑到一个自己明明关掉的模型去测，测通了也不代表配置是对的。
- * 所以只列**可用**的（用户没停用的），与路由实际会用的那批保持一致。
- *
- * 顺带把「没有可选模型」拆成两种，因为**用户该做的事不一样**：
- *   - `none`（一个模型都没有）→ 该去供应商详情拉取模型；
- *   - `all-disabled`（有模型但全被停用）→ 该去供应商详情把它们打开，
- *     去拉取是白跑一趟。
- * 两种共用一句「没有模型」就是把用户往错的方向指。
- *
- * `enabled` 缺省按**未停用**读（`!== false`）：这个字段是用户的配置，缺失时不该
- * 凭空把模型藏起来。
- */
-
-/** `/suppliers/:id/models` 里的一条模型。 */
-export interface ModelRow {
-  id: string
-  enabled?: boolean
-}
-
-export interface ModelChoice {
-  /** 可用模型的 id，按端点返回的顺序（不重排 —— 端点已经按优先级排过了）。 */
-  ids: string[]
-  /** 没有可选模型时的原因；`undefined` = 有得选。 */
-  empty?: 'none' | 'all-disabled'
-}
-
-/** 从端点答复里挑出可用的模型，并说明「空的」到底是哪一种空。 */
-export function modelChoice(models: readonly ModelRow[]): ModelChoice {
-  const ids = models.filter((m) => m.enabled !== false).map((m) => m.id)
-  if (ids.length > 0) return { ids }
-  return { ids, empty: models.length === 0 ? 'none' : 'all-disabled' }
-}

package/src/ext-test/ext-test.test.ts

@@ -1,60 +0,0 @@
-/**
- * 插件自检扩展（`router.ext` 侧）测试 —— 锁住三件事：
- *   1. 登记进 `router.ext` 表，带上可显示的身份（名字/说明/就绪）；
- *   2. **幂等**：同一个 id 已在表里就不顶掉别人的登记；
- *   3. 恒为就绪 —— 自检能力不依赖外部二进制，不该提前否决（真跑一次才知道）。
- *
- * 为什么测这个：扩展的「卡片出现与否」完全取决于它在不在这张表里，而表是核心
- * provide 的**同一个 live 对象**。登记没发生的话，面板与插件页都看不到它，且不报错。
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { createTestExt, EXT_TEST_ID } from './plugin.ts'
-import { apply, name as CORDIS_NAME } from './index.ts'
-import type { RouterExtService } from '../ext/contract.ts'
-
-test('扩展器带上面板要用的身份，且恒为就绪', () => {
-  const ext = createTestExt()
-  assert.equal(ext.id, EXT_TEST_ID)
-  assert.equal(ext.name, '插件自检')
-  assert.ok((ext.description ?? '').length > 0, '没有说明，插件页那一行就没有副标题')
-  assert.equal(ext.getState().ready, true, '自检不依赖本机二进制，不该报未就绪')
-})
-
-test('cordis 身份是行 id（与 patch 里声明的逐字相同，否则 loader 认不出）', () => {
-  assert.equal(CORDIS_NAME, 'dsh-router-ext-test')
-})
-
-/** 最小 ctx：inject 立刻回调、emit 记下来。 */
-function fakeCtx(table: RouterExtService): {
-  ctx: Parameters<typeof apply>[0]
-  events: string[]
-} {
-  const events: string[] = []
-  return {
-    events,
-    ctx: {
-      inject: (deps: string[], cb: (sctx: unknown) => void) => {
-        cb({ get: (key: string) => (key === 'router.ext' ? table : undefined) })
-      },
-      emit: (event: string) => { events.push(event) },
-    } as unknown as Parameters<typeof apply>[0],
-  }
-}
-
-test('apply 把扩展登记进 router.ext 表（这张表就是「卡片出现」的唯一依据）', () => {
-  const table: RouterExtService = {}
-  const { ctx, events } = fakeCtx(table)
-  apply(ctx)
-  assert.equal(table[EXT_TEST_ID]?.name, '插件自检')
-  assert.deepEqual(events, [], '核心持有同一个 live 对象且每次请求现读，不需要广播事件')
-})
-
-test('幂等：同一个 id 已在表里时不顶掉别人的登记', () => {
-  const table: RouterExtService = {}
-  const { ctx } = fakeCtx(table)
-  apply(ctx)
-  const first = table[EXT_TEST_ID]
-  apply(ctx)
-  assert.equal(table[EXT_TEST_ID], first, '重复登记不该换成一个新对象')
-})

package/src/ext-test/index.ts

@@ -1,35 +0,0 @@
-/**
- * 插件自检扩展的 **cordis 行** —— 官方插件页（设置 → 插件 → dsh-router-core）详情页
- * 原生「包含的组件」里的那一行。
- *
- * 壳存在的理由与内置供应商那三层一样：`plugin.ts` 已经把 `name` 用作**面板显示名**
- * （扩展契约的字段，所有扩展都这么写），而 cordis 的插件身份也要一个 `name`，两者抢
- * 同一个名字。所以行 = 这一层壳（cordis 身份 + 登记），实现 = `plugin.ts`。
- *
- * **默认关闭**（patch 里 `disabled: true`）：行关闭时 loader 根本不 import 这个模块，
- * 扩展也就没进 `router.ext` 表 —— 所以「打开才出现这张卡片」是天然的，不需要额外的
- * 状态位。用户在这一行打开后，卡片出现在插件页的「路由组件 → 扩展」组与面板的
- * 「扩展」页。
- *
- * 登记时把扩展开关置为开：本扩展**没有独立的运行期开关**，它的开关就是这一行
- * （宿主管的那个）。不置上的话，用户开了行还要再点一次，两级开关说同一件事。
- */
-import type { Context } from '@deepseek-ai/cordis'
-import { currentExts, currentExtStore } from '../ext/contract.ts'
-import { createTestExt, EXT_TEST_ID } from './plugin.ts'
-
-/** cordis 插件身份（配置树里这一行的技术名；显示名走同目录的 locale）。 */
-export const name = 'dsh-router-ext-test'
-
-/** 登记本扩展。幂等：同一个 id 已在表里就直接返回，不顶掉别人的登记。 */
-export function apply(ctx: Context): void {
-  ctx.inject(['router.ext'], (sctx) => {
-    const table = currentExts(sctx)
-    if (table === undefined) return
-    if (table[EXT_TEST_ID] !== undefined) return
-    table[EXT_TEST_ID] = createTestExt()
-    currentExtStore(sctx)?.setEnabled(EXT_TEST_ID, true)
-    // 核心持有的是**同一个 live 对象**（它 provide 的空表），且 `/ext` 每次请求都
-    // 现读这张表 —— 所以往里 append 就够了，不需要（也不存在）广播事件。
-  })
-}

package/src/ext-test/locale/en.json

@@ -1,6 +0,0 @@
-{
-  "meta": {
-    "title": "Plugin self-check",
-    "description": "Run a real access test against a supplier/model/connection, or run a contract check over an external supplier plugin (every member: implemented / usable / not executed)"
-  }
-}

package/src/ext-test/locale/zh.json

@@ -1,6 +0,0 @@
-{
-  "meta": {
-    "title": "插件自检",
-    "description": "选供应商、模型与连接跑一次真实访问测试；或对外部供应商插件做契约体检，逐个成员报告实现与可用情况"
-  }
-}

package/src/ext-test/plugin.ts

@@ -1,34 +0,0 @@
-/**
- * 插件自检扩展（`router.ext` 侧的实现）—— 声明与状态都在这里，**不做任何拦截**。
- *
- * 它和 rtk 那类扩展的区别要写清楚：本扩展**不挂任何监听、不改写任何命令**，
- * 唯一作用是让用户在官方插件页里打开一块自检面板（选供应商 / 模型 / 连接，跑一次
- * 真实的访问测试并看到底报了什么）。所以它复用 `router.ext` 这条通道只是为了拿到
- * **发现 + 开关**两件事，而不是为了拦截。
- *
- * 面板本身在浏览器侧（`src/client/ExtTestPanel.tsx`），通过原生行的
- * `plugins.row.config` 座位挂在「包含的组件」里那一行的详情页上；这里只负责让它在
- * 列表里有个身份、以及报出运行时就绪状态。
- */
-import type { RouterExt } from '../ext/contract.ts'
-
-/** 扩展开关表里的注册键（也是 URL 面板读它的 id）。 */
-export const EXT_TEST_ID = 'test'
-
-/**
- * 构造这个扩展器。
- *
- * `getState()` 恒为就绪：自检能力不依赖外部二进制（不像 rtk 需要本机装 rtk），
- * 「能不能测」取决于用户选的供应商/模型/连接，不该由扩展提前否决 —— 真跑一次
- * 才知道，那时错误信息比一个「未就绪」有用得多。
- */
-export function createTestExt(): RouterExt {
-  return {
-    id: EXT_TEST_ID,
-    name: '插件自检',
-    description: '选供应商、模型与连接跑一次真实访问测试；或对外部供应商插件做契约体检，逐个成员报告实现与可用情况',
-    // 随核心分发 -> 插件页的原生「包含的组件」里有它一行，自绘节里不再重复列。
-    source: 'builtin' as const,
-    getState: () => ({ ready: true }),
-  }
-}

package/src/ext-test/row.json

@@ -1,5 +0,0 @@
-{
-  "name": "dsh-router-core-ext-test",
-  "type": "module",
-  "description": "插件自检扩展（随 dsh-router 核心分发）"
-}

package/src/suppliers/probe.test.ts

@@ -1,266 +0,0 @@
-/**
- * 契约体检的判据测试。三条，缺一条这个功能就不该存在：
- *
- *  1. **清单跟契约一起长** —— 契约加了成员而清单没加，体检就静默漏检。编译期类型
- *     抓不到（清单是运行时数组，契约成员是类型），只能解析契约源码来钉。
- *  2. **会毁掉体检前提的成员绝不被调用** —— `dispose` 卸载自己、`addApiKey` 写凭证等，
- *     一律移出清单（见 PROBE_EXCLUDED_MEMBERS），既不出现也不被调。
- *  3. **必填成员缺失要报错**（fail），可选成员缺失只是 absent。
- *  4. **「全部启用/全部禁用」真跑**（并还原）—— 它是唯一能抓出「插件在 listModels
- *     里过滤已禁用模型」越权的路径：全部禁用之后违规插件把模型全藏起来，核心就再也
- *     拉不到列表、用户「全部启用」时没有 id 可传。
- */
-import test from 'node:test'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import assert from 'node:assert/strict'
-import { join } from 'node:path'
-import { probeSupplier, SUPPLIER_CONTRACT_MEMBERS, PROBE_EXCLUDED_MEMBERS } from './probe.ts'
-import type { LoadedSupplier } from './loader.ts'
-
-// 本文件在 src/suppliers/ 下，所以 '../..' 才是仓库根
-const root = fileURLToPath(new URL('../..', import.meta.url))
-
-/** 从契约源码里抠出 `SupplierModule` 的成员名（编译期不存在的形状，只能这么拿）。 */
-function contractMemberNames(): string[] {
-  const src = readFileSync(join(root, 'src', 'suppliers', 'contract.ts'), 'utf8')
-  const body = src.slice(src.indexOf('export interface SupplierModule'), src.indexOf('\n}', src.indexOf('export interface SupplierModule')))
-  const names = new Set<string>()
-  for (const m of body.matchAll(/^\s{2}(?:readonly\s+)?([a-zA-Z][a-zA-Z0-9]*)\??\s*[(:]/gm)) names.add(m[1]!)
-  return [...names]
-}
-
-test('清单覆盖契约的全部成员，除了有意排除的那几个（契约加了成员而清单没加 = 体检漏检）', () => {
-  const declared = new Set([...SUPPLIER_CONTRACT_MEMBERS.map((m) => m.key), ...Object.keys(PROBE_EXCLUDED_MEMBERS)])
-  const missing = contractMemberNames().filter((k) => !declared.has(k))
-  assert.deepEqual(missing, [], `契约里有、清单里和排除名单里都没有的成员：${missing.join('、')}`)
-})
-
-test('有意排除的成员都写了排除理由（不能无声消失）', () => {
-  for (const [key, why] of Object.entries(PROBE_EXCLUDED_MEMBERS)) {
-    assert.ok(why.length > 0, `${key} 必须写清为什么不测`)
-  }
-})
-
-test('不测的成员不出现在报告清单里（不占篇幅）', () => {
-  const keys = new Set(SUPPLIER_CONTRACT_MEMBERS.map((m) => m.key))
-  for (const key of Object.keys(PROBE_EXCLUDED_MEMBERS)) {
-    assert.equal(keys.has(key), false, `${key} 说好不测，就不该出现在清单里`)
-  }
-})
-
-test('清单里没有契约里不存在的成员（写错名字 = 永远探不到，且不报错）', () => {
-  const inContract = new Set(contractMemberNames())
-  const extra = SUPPLIER_CONTRACT_MEMBERS.map((m) => m.key).filter((k) => !inContract.has(k))
-  assert.deepEqual(extra, [], `清单里写了契约中不存在的成员：${extra.join('、')}`)
-})
-
-/** 会记账的假模块：任何被调用的成员都会被记下来。 */
-function spyModule(implemented: readonly string[]): { m: Record<string, unknown>; called: string[] } {
-  const called: string[] = []
-  const record = <T>(key: string, value: T) => (): T => { called.push(key); return value }
-  const m: Record<string, unknown> = { id: record('id', 'spy'), name: record('name', 'Spy') }
-  for (const key of implemented) {
-    if (key === 'status') m.status = record('status', { id: 'spy', name: 'Spy', accounts: [{ uid: 'u1', credits: 0, state: 'ok' }] })
-    else if (key === 'listModels') m.listModels = record('listModels', [{ id: 'mm' }])
-    else if (key === 'chatOnce') m.chatOnce = record('chatOnce', { ok: true })
-    else if (key === 'dispose') m.dispose = record('dispose', undefined)
-    else if (key === 'generateLoginUrl') m.generateLoginUrl = record('generateLoginUrl', 'https://x')
-    else if (key === 'completeLogin') m.completeLogin = record('completeLogin', { uid: 'u', nickname: 'n' })
-    else if (key === 'addApiKey') m.addApiKey = record('addApiKey', { ok: true })
-    else if (key === 'removeLink') m.removeLink = record('removeLink', true)
-    else if (key === 'pollLogin') m.pollLogin = record('pollLogin', true)
-    else if (key === 'checkinNow') m.checkinNow = record('checkinNow', { ok: true, status: 'ok' })
-    else m[key] = record(key, 'v')
-  }
-  return { m, called }
-}
-
-function loaded(m: Record<string, unknown>): LoadedSupplier {
-  return {
-    supplier: { id: 'spy', name: 'Spy', __module: m },
-    capabilities: new Set<string>(),
-    source: 'external',
-  } as unknown as LoadedSupplier
-}
-
-test('留在清单里的成员都有明确的 probe 方式', () => {
-  for (const m of SUPPLIER_CONTRACT_MEMBERS) {
-    assert.ok(m.probe === 'safe' || m.probe === 'skip', `${m.key} 的 probe 类型不明确`)
-    if (m.probe === 'skip') {
-      assert.ok((m.skipReason ?? '').length > 0, `${m.key} 标了 skip 必须写清为什么不自动跑`)
-    }
-  }
-})
-
-test('probe 输入的成员会实跑（单档全自动：能安全试的就是要试）', async () => {
-  const { m, called } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  await probeSupplier(loaded(m), { models: [{ id: 'm1', enabled: true }] })
-  // 清单里的成员该跑的都要跑（需要真实连接的用连接池的 token）
-  assert.equal(called.includes('checkinNow'), true, 'checkinNow 该对真实连接实跑')
-  assert.ok(called.includes('status'), 'safe 成员确实跑了')
-})
-
-test('dispose 不出现在报告里（调用它就是卸载自己，体检没法在自己身上验自己）', async () => {
-  const { m } = spyModule([...SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key), 'dispose'])
-  const report = await probeSupplier(loaded(m), { models: [{ id: 'a', enabled: true }] })
-  assert.equal(
-    report.members.some((x) => x.key === 'dispose'), false,
-    'dispose 已移出清单：占一行只为说「没验」，是用篇幅淹掉真问题',
-  )
-  assert.ok(PROBE_EXCLUDED_MEMBERS.dispose, '要留在「有意不测」名单里，并写清理由')
-})
-
-test('必填成员缺失 = fail（插件不完整），可选成员缺失 = absent', async () => {
-  const { m } = spyModule(['status', 'listModels'])  // 缺 chatOnce/dispose，也缺全部可选
-  const report = await probeSupplier(loaded(m))
-  const chatOnce = report.members.find((x) => x.key === 'chatOnce')
-  assert.equal(chatOnce?.state, 'fail', '必填成员缺失要报 fail')
-  assert.equal(report.members.find((x) => x.key === 'checkinNow')?.state, 'absent', '可选成员缺失只是 absent')
-})
-
-test('safe 成员抛错只让那一条 fail，不连坐', async () => {
-  const { m } = spyModule(['status', 'listModels'])
-  m.listModels = () => { throw new Error('boom') }
-  const report = await probeSupplier(loaded(m))
-  const listModels = report.members.find((x) => x.key === 'listModels')
-  const status = report.members.find((x) => x.key === 'status')
-  assert.equal(listModels?.state, 'fail')
-  assert.match(listModels?.detail ?? '', /boom/)
-  assert.equal(status?.state, 'ok')
-  assert.equal(report.summary.fail, report.members.filter((x) => x.state === 'fail').length, 'summary 与明细一致')
-})
-
-/* ---------------- 核心侧：模型启用/禁用只「报」不「改」 ---------------- */
-
-test('核心区：「全部启用/全部禁用」实跑，并如实写「拿不到」而不是冒充 0', async () => {
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const withModels = await probeSupplier(loaded(m), { models: [
-    { id: 'a', enabled: true }, { id: 'b', enabled: true }, { id: 'c', enabled: false },
-  ] })
-  assert.deepEqual(withModels.core.models, { total: 3, enabled: 2, disabled: 1 })
-
-  const without = await probeSupplier(loaded(m))
-  assert.equal(without.core.models.total, null, '拿不到就是 null，不能当成 0 个模型')
-  assert.match(without.core.models.note ?? '', /拿不到|不可用/)
-  assert.equal(without.core.operations[0]?.ran, false, '拿不到模型时这一项不跑')
-})
-
-test('核心区：全部启用/禁用是真跑的（不是只报可用性）', async () => {
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const calls: string[] = []
-  const report = await probeSupplier(loaded(m), {
-    models: [{ id: 'a', enabled: true }, { id: 'b', enabled: true }],
-    runBulkToggleRoundTrip: async () => { calls.push('bulk'); return { ok: true, detail: '全部禁用后 2 个模型都在' } },
-  })
-  assert.deepEqual(calls, ['bulk'], '这条必须真跑 —— 它是唯一能抓出越权的路径')
-  const bulk = report.core.operations.find((o) => o.key === 'models.bulk')
-  assert.equal(bulk?.ran, true)
-  assert.equal(bulk?.ok, true)
-})
-
-test('核心区：全部启用/禁用实跑发现问题 = 报出来（Loomy 那种）', async () => {
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const report = await probeSupplier(loaded(m), {
-    models: [{ id: 'a', enabled: true }],
-    runBulkToggleRoundTrip: async () => ({ ok: false, detail: '全部禁用之后只剩 0/1 个模型 —— 插件把已禁用的藏起来了' }),
-  })
-  const bulk = report.core.operations.find((o) => o.key === 'models.bulk')
-  assert.equal(bulk?.ok, false, '必须报出问题')
-  assert.match(bulk?.detail ?? '', /藏起来了/)
-  assert.equal(report.summary.bulk, 'fail', '核心区实跑失败要能被数字看见（不是只藏在 detail 里）')
-})
-
-test('status 的账号摘要给真实数量与状态分布（链接全过期正是要靠它看出来）', async () => {
-  const { m } = spyModule(['status'])
-  m.status = () => ({ id: 'spy', name: 'Spy', accounts: [
-    { uid: 'a', credits: 0, state: 'ok' },
-    { uid: 'b', credits: 0, state: 'ok' },
-    { uid: 'c', credits: 0, state: 'session_dead' },
-  ] })
-  const report = await probeSupplier(loaded(m))
-  const status = report.members.find((x) => x.key === 'status')
-  assert.equal(status?.state, 'ok')
-  assert.match(status?.detail ?? '', /3 个账号/, '要给真实数量，不是「≥1」')
-  assert.match(status?.detail ?? '', /session_dead 1/, '要把失效的号点出来')
-})
-
-/* ---------------- 单档全自动：能跑的都跑，跑不了的写清为什么 ---------------- */
-
-test('不测的成员不会被调用（就算插件实现了）', async () => {
-  const { m, called } = spyModule([...SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key), ...Object.keys(PROBE_EXCLUDED_MEMBERS)])
-  await probeSupplier(loaded(m), { models: [{ id: 'a', enabled: true }] })
-  for (const key of Object.keys(PROBE_EXCLUDED_MEMBERS)) {
-    assert.equal(called.includes(key), false, `${key} 说好不测，就不该被调用`)
-  }
-})
-
-test('单档全自动：chatOnce 真跑一次（前提是调用方给了 runChatOnce）', async () => {
-  const { m, called } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const tried: string[] = []
-  const report = await probeSupplier(loaded(m), {
-    models: [{ id: 'm1', enabled: true }, { id: 'm2', enabled: true }],
-    runChatOnce: async (model) => { tried.push(model); return { ok: true, detail: '通了' } },
-  })
-  assert.deepEqual(tried, ['m1'], '用第一个已启用的模型真跑')
-  const chat = report.members.find((x) => x.key === 'chatOnce')
-  assert.equal(chat?.executed, 'ran')
-  assert.equal(chat?.state, 'ok')
-  assert.match(chat?.detail ?? '', /真实调用 m1/)
-  assert.equal(called.includes('chatOnce'), false, '走的是核心 testModel 那条真实路径，不该直调插件的 chatOnce')
-})
-
-test('chatOnce 跑不通就是 fail（出厂体检最该抓住的就是这个）', async () => {
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const report = await probeSupplier(loaded(m), {
-    models: [{ id: 'm1', enabled: true }],
-    runChatOnce: async () => ({ ok: false, detail: '401 unauthorized' }),
-  })
-  const chat = report.members.find((x) => x.key === 'chatOnce')
-  assert.equal(chat?.state, 'fail')
-  assert.ok(report.summary.fail > 0, 'listModels 越权要计入失败数')
-})
-
-test('单档全自动：checkinNow 对连接池里的真实连接真签到', async () => {
-  const seen: string[] = []
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  m.status = () => ({ id: 'spy', name: 'Spy', accounts: [{ uid: 'u1', credits: 0, state: 'ok' }] })
-  m.checkinNow = (uid: string) => { seen.push(uid); return Promise.resolve({ ok: true, status: 'ok' }) }
-  const report = await probeSupplier(loaded(m), { models: [{ id: 'm1', enabled: true }] })
-  assert.deepEqual(seen, ['u1'], '用连接池里第一个真实连接')
-  assert.equal(report.members.find((x) => x.key === 'checkinNow')?.executed, 'ran')
-})
-
-test('dispose 一次都不被调用（哪怕它实现了）', async () => {
-  const { m, called } = spyModule([...SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key), 'dispose'])
-  await probeSupplier(loaded(m), { models: [{ id: 'a', enabled: true }] })
-  assert.equal(called.includes('dispose'), false, '调用 dispose 就是把这个供应商卸载掉')
-})
-
-test('没有 token / 没有模型时，数字要如实说「未验」而不是「通过」', async () => {
-  const full = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  full.m.checkinNow = (uid: string) => Promise.resolve({ ok: true, status: 'ok' })
-  // 假模块没有 runChatOnce → chatOnce 无法验证 → 记 unverified
-  const noAccount = await probeSupplier(loaded(full.m), { models: [{ id: 'm1', enabled: true }] })
-  assert.equal(noAccount.summary.unverified, 1, '没条件验就是未验，不能混进通过里')
-  assert.equal(noAccount.members.find((x) => x.key === 'chatOnce')?.state, 'unverified')
-
-  const withToken = await probeSupplier(loaded(full.m), {
-    models: [{ id: 'm1', enabled: true }],
-    runChatOnce: async () => ({ ok: true, detail: '通了' }),
-  })
-  assert.equal(withToken.summary.unverified, 0, '有 token 且全跑通 → 没有未验项')
-  assert.equal(withToken.summary.fail, 0)
-
-  const missing = spyModule(['status', 'listModels'])
-  const m = await probeSupplier(loaded(missing.m), { models: [] })
-  assert.ok(m.summary.fail > 0, '必填成员缺失要体现在失败数里')
-})
-
-test('summary.ran 只数真的跑过的成员（清单里全部实跑）', async () => {
-  const { m } = spyModule(SUPPLIER_CONTRACT_MEMBERS.map((x) => x.key))
-  const report = await probeSupplier(loaded(m), { models: [{ id: 'a', enabled: true }] })
-  assert.equal(report.summary.ran, report.summary.total,
-    '清单里的成员一律实跑（会毁掉前提的早已移出清单），所以 ran 应等于 total')
-})
-