dsh-router-core 0.3.21 → 0.4.1

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

@@ -66,6 +66,12 @@ function addSupplier(router: Router, s: unknown): void {
   ;(router as unknown as { suppliers: unknown[] }).suppliers.push(s)
 }
 
+/** 禁用某供应商的一个模型（store 是私有的，测试按同文件惯例断言访问）。 */
+function disableModel(router: Router, supplierId: string, modelId: string): void {
+  ;(router as unknown as { store: { setModelEnabled(id: string, m: string, enabled: boolean): void } })
+    .store.setModelEnabled(supplierId, modelId, false)
+}
+
 /**
  * 把某供应商的缓存标记成「已过期」（TTL 现在 10 分钟，测试不能真等）。
  * 白盒改 fetchedAt，模拟插件重启/TTL 到期的冷路径。
@@ -357,7 +363,7 @@ test('每次 chat 记一行：组合名 → 供应商/模型 (账号) 结果', a
   const router = new Router('', undefined, (m) => lines.push(m))
   const ok = supplier('supA', [{ id: 'a-m' }])
   addSupplier(router, ok.s)
-  assert.equal(router.createCombo('combo1', 'fallback', ['supA,a-m']).ok, true)
+  assert.equal(router.createCombo('combo1', ['supA,a-m']).ok, true)
 
   const res = {
     writeHead: (): void => {},
@@ -370,7 +376,7 @@ test('每次 chat 记一行：组合名 → 供应商/模型 (账号) 结果', a
   await router.chatCompletions({ model: 'combo1', stream: false, rawBody: JSON.stringify({ model: 'combo1', messages: [] }) }, res)
 
   assert.equal(lines.length, 1)
-  assert.match(lines[0] ?? '', /^chat "combo1" → supA\/a-m \(u1\) ok \d+ms$/, `日志格式不对: ${lines[0]}`)
+  assert.match(lines[0] ?? '', /^chat "combo1" → supA\/a-m \(u1\) ok( \[选号: .+?\])? \d+ms$/, `日志格式不对: ${lines[0]}`)
 })
 
 test('失败的成员也要记，且带真实原因（不能笼统写 no account）', async () => {
@@ -384,7 +390,7 @@ test('失败的成员也要记，且带真实原因（不能笼统写 no account
   const live = supplier('live', [{ id: 'live-m' }])
   addSupplier(router, dead.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c1', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c1', ['dead,dead-m', 'live,live-m']).ok, true)
 
   const res = {
     writeHead: (): void => {},
@@ -428,7 +434,7 @@ test('流在写出第一个字节前就断 → 组合回退到下一个模型',
   })
   addSupplier(router, dead.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c1', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c1', ['dead,dead-m', 'live,live-m']).ok, true)
 
   let out = ''
   let heads = 0
@@ -479,7 +485,7 @@ test('已写出字节后断流 → 截断并补 [DONE]，不回退也不二次
   })
   addSupplier(router, half.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c2', 'fallback', ['half,half-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c2', ['half,half-m', 'live,live-m']).ok, true)
 
   let out = ''
   let heads = 0
@@ -552,7 +558,7 @@ test('首字节前就断 → 不补 [DONE]，留给组合回退', async () => {
   })
   addSupplier(router, dead.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c3', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c3', ['dead,dead-m', 'live,live-m']).ok, true)
 
   let out = ''
   const res = {
@@ -683,7 +689,7 @@ test('组合窗口：取组合内模型的最小值，单位 K → token', async
     { id: 'a-2', context_length: 1000 },  // 1M
   ]).s)
   await router.modelsOf('a') // 填缓存
-  const w = router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1', 'a,a-2'] })
+  const w = router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1', 'a,a-2'] })
   assert.equal(w, 128_000, '取最小的那个（fallback 到任意一条分支都得成立）')
 })
 
@@ -692,7 +698,7 @@ test('组合窗口：供应商还没缓存过 → undefined（不猜，绝不打
   addSupplier(router, supplier('a', [{ id: 'a-1', context_length: 128 }]).s)
   // 故意不调 modelsOf：模拟冷启动
   assert.equal(
-    router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1'] }),
+    router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1'] }),
     undefined,
     '没缓存就报 undefined —— 压缩这轮跳过，下次就有，比撒谎安全',
   )
@@ -703,8 +709,47 @@ test('组合窗口：模型都没报 context_length → undefined', async () =>
   addSupplier(router, supplier('a', [{ id: 'a-1' }]).s)
   await router.modelsOf('a')
   assert.equal(
-    router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1'] }),
+    router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1'] }),
     undefined,
     '一家都没报就别编一个数（traework/nvidia 目前就是如此）',
   )
 })
+
+
+/* ---- 核心不替违约插件兜底 ----
+ *
+ * 起因：插件在 listModels 里把用户禁用的模型过滤掉（越权 —— 启用状态归核心合并），
+ * 面板的「已禁用」列表于是空了。曾想过在核心按配置把缺的 id 补回来，**这是错的**：
+ *
+ *  1. 那是替有问题的插件擦屁股，插件永远不会被修；
+ *  2. 更糟的是**它会把体检的越权检测一起掩盖掉** —— 模型被补全之后，
+ *     probe.ts 的 hiddenDisabledIds 找不到「少报的 id」，报告变成 OK，
+ *     第三方那个 bug 就再也没人知道了。
+ *
+ * 所以核心只负责：自己不合并不掩饰（插件少报就是少报），并让体检把违约报出来。
+ * 下面两条判据钉住这个方向，防止以后有人（我）再犯同样的错。
+ */
+
+test('核心不替违约插件补回已禁用的模型（要留着证据给体检）', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }, { id: 'a-2' }])
+  // 越权实现：listModels 自己过滤掉了已禁用的
+  a.s.listModels = async (): Promise<ModelInfo[]> => [{ id: 'a-1' }]
+  addSupplier(router, a.s)
+  disableModel(router, 'a', 'a-2')
+
+  const models = await router.modelsOf('a')
+  assert.deepEqual(models.map((m) => m.id), ['a-1'],
+    '核心不该把插件藏掉的模型补回来 —— 补回来就等于替它兜底，越权检测也会失效')
+})
+
+test('正常供应商（listModels 全量返回）：列表内容与启用状态照旧', async () => {
+  const router = new Router('')
+  const a = supplier('a', [{ id: 'a-1' }, { id: 'a-2' }])
+  addSupplier(router, a.s)
+  disableModel(router, 'a', 'a-2')
+
+  const models = await router.modelsOf('a')
+  assert.deepEqual(models.map((m) => m.id).sort(), ['a-1', 'a-2'])
+  assert.deepEqual(models.map((m) => m.enabled).sort(), [false, true], '启用状态仍由核心合并')
+})

package/src/router/precise-dispatch.test.ts

@@ -87,7 +87,7 @@ test('组合只调目标供应商，其它供应商一次都不会被问', async
   const b = spy('supB', 'b-model')
   const c = spy('supC', 'c-model')
   add(router, a.s); add(router, b.s); add(router, c.s)
-  assert.equal(router.createCombo('my-combo', 'fallback', ['supB,b-model']).ok, true, '组合必须创建成功')
+  assert.equal(router.createCombo('my-combo', ['supB,b-model']).ok, true, '组合必须创建成功')
 
   await router.chatCompletions(reqWith('my-combo'), fakeRes())
 
@@ -140,8 +140,8 @@ test('组合存了缺供应商前缀的裸模型 id → 直接失败，不降级
   const b = spy('supB', 'b-model')
   add(router, a.s); add(router, b.s)
   // 模拟旧存储：裸 id，没有 supplierId 前缀 —— 图6 下这是配置错误，不遍历兜底
-  ;(router as unknown as { customCombos: Array<{ id: string; name: string; strategy: 'fallback'; models: string[] }> })
-    .customCombos.push({ id: 'legacy', name: 'legacy', strategy: 'fallback', models: ['b-model'] })
+  ;(router as unknown as { customCombos: Array<{ id: string; name: string; models: string[] }> })
+    .customCombos.push({ id: 'legacy', name: 'legacy', models: ['b-model'] })
 
   const errs: unknown[] = []
   const res = { ...fakeRes(), end: (x?: string): unknown => { if (x) errs.push(x); return undefined } } as unknown as ServerResponse
@@ -156,7 +156,7 @@ test('组合存了不存在的供应商 id → 调用失败，不静默落到别
   const router = new Router('')
   const a = spy('supA', 'a-model')
   add(router, a.s)
-  assert.equal(router.createCombo('broken', 'fallback', ['ghost,a-model']).ok, true, '组合必须创建成功')
+  assert.equal(router.createCombo('broken', ['ghost,a-model']).ok, true, '组合必须创建成功')
 
   const errs: unknown[] = []
   const res = { ...fakeRes(), end: (b?: string): unknown => { if (b) errs.push(b); return undefined } } as unknown as ServerResponse
@@ -274,7 +274,7 @@ test('组合：瞬时故障降级前会等一等，不是毫秒级打穿整个
   const m1 = failingSpy('s1', 'm1', 'transport')
   const m2 = failingSpy('s2', 'm2', 'unavailable')
   add(router, m1.s); add(router, m2.s)
-  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+  router.createCombo('combo', ['s1,m1', 's2,m2'])
 
   const t0 = Date.now()
   await router.chatCompletions(reqWith('combo'), fakeRes())
@@ -291,7 +291,7 @@ test('组合：no_such_model 不是故障，降级不该等', async () => {
   const m1 = failingSpy('s1', 'm1', 'no_such_model')
   const m2 = failingSpy('s2', 'm2', 'no_such_model')
   add(router, m1.s); add(router, m2.s)
-  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+  router.createCombo('combo', ['s1,m1', 's2,m2'])
 
   const t0 = Date.now()
   await router.chatCompletions(reqWith('combo'), fakeRes())

package/src/router/prefix-affinity.ts

@@ -59,7 +59,28 @@ function textOf(content: unknown): string {
 }
 
 /**
- * 算请求的前缀指纹。
+ * 算请求的亲和指纹（选号主键）。
+ *
+ * **身份优先，内容兜底**：
+ *   1. 宿主给了会话身份（`session`，来自 dsh-llm 的 `sessionId`）→ 直接用它。
+ *      精确、零撞车 —— 同一会话永不漂移，不同会话（含 team 各成员）天然隔离。
+ *   2. 没有身份（外部 OpenAI 客户端）→ 回落 {@link prefixFingerprint}。
+ *
+ * 为什么优先身份而不是内容指纹：DSH 的 system prompt 是同一个 agent preset
+ * 生成的几 KB 文本，内容指纹只取前 512 字符 → 各会话高度雷同 → 撞车导致
+ * 绑定互相覆盖、同会话漂移（team 多成员时实测过）。
+ *
+ * @param session 宿主会话身份；无则 undefined
+ * @param messages OpenAI 请求体的 `messages`（无身份时才用）
+ * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
+ */
+export function sessionFingerprint(session: string | undefined, messages: unknown): string {
+  if (session !== undefined && session !== '') return `sid:${session}`
+  return prefixFingerprint(messages)
+}
+
+/**
+ * 算请求的前缀指纹（内容兜底）。
  * @param messages OpenAI 请求体的 `messages` 字段（未校验，来自外部输入）
  * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
  */

package/src/router/supplier-switch.test.ts

@@ -0,0 +1,220 @@
+/**
+ * 供应商开关测试 —— 锁住「关掉 = 真的不参与路由」，而且是**全部入口**都拦。
+ *
+ * 为什么要有这个文件：这个开关的唯一实现是 `Router` 里的活跃集合
+ * （`active` = 装载清单里开关为开的那一份）。而路由有 15 处读供应商清单，
+ * 少收一处就出现「面板显示已关闭、请求照样打过去」——那是最坏的一种：开关说了
+ * 假话，用户以为断了流量其实在烧额度。所以这里逐个入口钉住：
+ *
+ *   1. 组合腿（`supplierId,modelId` 形态）
+ *   2. 直调（`alias/model` 形态）
+ *   3. 模型目录 / 别名前缀（关掉的不能留下「前缀存在但必然 503」的死前缀）
+ *   4. status() 仍带出关掉的（否则关掉后就没法再开，开关失去对象）
+ *   5. 关掉不能连带卸载（`removeSupplier` 是插件卸载用的另一码事）
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import type { ServerResponse } from 'node:http'
+import { Router } from './index.ts'
+import type { ModelInfo } from './types.ts'
+import { AccountPool } from './account-pool.ts'
+import { SupplierConfigStore } from '../supplier-config.ts'
+import type { AccountPool as Pool } from './account-pool.ts'
+import type { ChatOnceResult, SupplierAccountNow, SupplierStatusNow } from '../suppliers/contract.ts'
+
+interface Spy {
+  calls: number
+  seen: string[]
+  s: {
+    id: string
+    name: string
+    priority: number
+    pool: Pool
+    status: () => SupplierStatusNow
+    listModels: () => Promise<ModelInfo[]>
+    modelsWithEnabled: () => Promise<Array<ModelInfo & { enabled: boolean }>>
+    customModelIds: () => string[]
+    getAlias: () => string
+    accounts: () => SupplierAccountNow[]
+    chatOnce: (uid: string, lv: string, req: { rawBody: string }) => Promise<ChatOnceResult>
+    dispose: () => void
+  }
+}
+
+/** 带探针的供应商：只服务自己的模型，记录被问过什么。 */
+function spy(id: string, modelId: string, alias = id): Spy {
+  const calls = { n: 0 }
+  const seen: string[] = []
+  return {
+    get calls() { return calls.n },
+    seen,
+    s: {
+      id, name: id, priority: 0, pool: new AccountPool(),
+      status: () => ({ id, name: id, accounts: [{ uid: `${id}-u1`, credits: 0, state: 'ok' }] }),
+      listModels: async () => [{ id: modelId }],
+      modelsWithEnabled: async () => [{ id: modelId, enabled: true }],
+      customModelIds: () => [`${id}-custom`],
+      getAlias: () => alias,
+      accounts: () => [{ uid: `${id}-u1`, credits: 0, state: 'ok' }],
+      chatOnce: async (_uid, _lv, req) => {
+        calls.n += 1
+        const m = (JSON.parse(req.rawBody) as { model?: string }).model ?? ''
+        seen.push(m)
+        const base = m.startsWith(`${alias}/`) ? m.slice(alias.length + 1) : m
+        if (base !== modelId) return { ok: false, state: 'no_such_model', message: `unknown model ${m}` }
+        return { ok: true, status: 200, body: '{"ok":1}' }
+      },
+      dispose: () => {},
+    },
+  }
+}
+
+function add(router: Router, s: unknown): void {
+  router.add(s as Parameters<Router['add']>[0])
+}
+
+function fakeRes(): ServerResponse {
+  return {
+    writeHead: (): unknown => undefined,
+    end: (): unknown => undefined,
+    write: (): boolean => true,
+    once: (): unknown => undefined,
+    removeListener: (): unknown => undefined,
+    destroy: (): unknown => undefined,
+  } as unknown as ServerResponse
+}
+
+function reqWith(model: string) {
+  return { model, stream: false, rawBody: JSON.stringify({ model, messages: [] }) }
+}
+
+/** 路由器 + 共享 store（开关要能从 store 落盘/读回，所以显式传同一个实例）。 */
+function rig() {
+  const store = new SupplierConfigStore('')
+  return { router: new Router('', store, () => {}), store }
+}
+
+test('关掉的供应商：组合腿不会打到它（唯一的路由入口之一）', async () => {
+  const { router, store } = rig()
+  const a = spy('supA', 'a-model')
+  const b = spy('supB', 'b-model')
+  add(router, a.s); add(router, b.s)
+  assert.equal(router.createCombo('c', ['supA,a-model', 'supB,b-model']).ok, true)
+
+  store.setEnabled('supA', false)
+  await router.chatCompletions(reqWith('c'), fakeRes())
+
+  assert.equal(a.calls, 0, '已关闭的供应商不该被组合腿问到')
+  assert.equal(b.calls, 1, '开着的供应商照常服务')
+})
+
+test('关掉的供应商：alias 直调也进不去（第二条入口）', async () => {
+  const { router, store } = rig()
+  const a = spy('supA', 'a-model', 'aaa')
+  add(router, a.s)
+
+  store.setEnabled('supA', false)
+  await router.chatCompletions(reqWith('aaa/a-model'), fakeRes())
+
+  assert.equal(a.calls, 0, '已关闭的供应商不该被直调命中')
+  assert.equal(router.supplierByAlias('aaa'), undefined, '别名反查也不该命中')
+})
+
+test('关掉再打开，路由立刻恢复（开关不是卸载）', async () => {
+  const { router, store } = rig()
+  const a = spy('supA', 'a-model', 'aaa')
+  add(router, a.s)
+
+  store.setEnabled('supA', false)
+  assert.equal(a.calls, 0)
+  store.setEnabled('supA', true)
+  await router.chatCompletions(reqWith('aaa/a-model'), fakeRes())
+  assert.equal(a.calls, 1, '重新打开后应当照常服务')
+})
+
+test('关掉的供应商仍出现在 status()（关掉后要能再开）且带 enabled=false', () => {
+  const { router, store } = rig()
+  add(router, spy('supA', 'a-model').s)
+  store.setEnabled('supA', false)
+
+  const { suppliers } = router.status()
+  assert.equal(suppliers.length, 1, '关掉不等于卸载，列表里还得有它')
+  assert.equal(suppliers[0]?.enabled, false)
+  assert.equal(router.isEnabled('supA'), false)
+})
+
+test('关掉的供应商不留死前缀、不进模型目录（否则是「存在但必然 503」）', async () => {
+  const { router, store } = rig()
+  add(router, spy('supA', 'a-model', 'aaa').s)
+  store.setEnabled('supA', false)
+
+  assert.deepEqual(router.aliases(), [], '关掉的供应商不该再提供模型前缀')
+  assert.deepEqual(await router.modelsOf('supA'), [], '关掉的供应商不该还能拉模型')
+  const models = await router.listModels()
+  assert.equal(
+    models.some((m) => m.id.includes('supA-custom')),
+    false,
+    '关掉的供应商的自定义模型不该进模型目录',
+  )
+})
+
+test('没记录过的供应商默认开着（升级不把全灭变成全开）', () => {
+  const { router } = rig()
+  add(router, spy('supA', 'a-model').s)
+  assert.equal(router.isEnabled('supA'), true)
+})
+
+// ---- 指定连接自检（插件自检面板的连接测试用它） ----
+// 面板「供应商」详情里的「测试」按钮走账号池（任选可用号、失败自动换号）；
+// 面板的连接测试可以**钉死一个连接**，用来诊断单个链接到底通不通。关键性质：
+// 指定了连接就**不回退**到别的号，否则「测这个连接」测出来的是另一个号的结果。
+
+test('指定连接：只试这一个连接', async () => {
+  const { router } = rig()
+  const a = spy('supA', 'a-model')
+  a.s.accounts = () => [
+    { uid: 'u1', credits: 0, state: 'ok' },
+    { uid: 'u2', credits: 0, state: 'ok' },
+  ]
+  a.s.status = () => ({ id: 'supA', name: 'supA', accounts: a.s.accounts() })
+  add(router, a.s)
+
+  const r = await router.testModel('supA', 'a-model', 'u1')
+  assert.equal(r.ok, true)
+  assert.equal(a.calls, 1, '只该试一次')
+})
+
+test('指定连接失败时不回退到别的号（否则诊断结论是假的）', async () => {
+  const { router } = rig()
+  const a = spy('supA', 'a-model')
+  a.s.accounts = () => [
+    { uid: 'u1', credits: 0, state: 'ok' },
+    { uid: 'u2', credits: 0, state: 'ok' },
+  ]
+  a.s.status = () => ({ id: 'supA', name: 'supA', accounts: a.s.accounts() })
+  // 自己记账：spy 的 calls 计数封在原 chatOnce 里，换掉实现就得自己数。
+  const seen: string[] = []
+  a.s.chatOnce = async (uid) => {
+    seen.push(uid)
+    return { ok: false, state: 'transport', message: `link ${uid} down` }
+  }
+  add(router, a.s)
+
+  const r = await router.testModel('supA', 'a-model', 'u1')
+  assert.equal(r.ok, false)
+  assert.deepEqual(seen, ['u1'], '失败也不该换号重试')
+  assert.match(r.error ?? '', /u1/, '错误信息要点名是哪个连接挂了')
+})
+
+test('指定不存在的连接：明确报「连接不存在」，而不是静默测了别的号', async () => {
+  const { router } = rig()
+  const a = spy('supA', 'a-model')
+  a.s.accounts = () => [{ uid: 'u1', credits: 0, state: 'ok' }]
+  a.s.status = () => ({ id: 'supA', name: 'supA', accounts: a.s.accounts() })
+  add(router, a.s)
+
+  const r = await router.testModel('supA', 'a-model', 'gone')
+  assert.equal(r.ok, false)
+  assert.equal(a.calls, 0, '一个号都不该被试')
+  assert.match(r.error ?? '', /不存在/)
+})

package/src/router/types.ts

@@ -37,14 +37,10 @@ export interface ModelWithEnabled extends ModelInfo {
   custom?: boolean
 }
 
-/** 组合策略：fallback = 按顺序尝试；round-robin = 轮转。 */
-export type ComboStrategy = 'fallback' | 'round-robin'
-
-/** 组合：命名的一组模型，路由时按策略（回退/轮询）命中其中一个。 */
+/** 组合：命名的一组模型，路由时作为**降级链**按序尝试（无策略旋钮）。 */
 export interface Combo {
   id: string
   name: string
-  strategy: ComboStrategy
   models: string[]
 }
 
@@ -56,6 +52,12 @@ export interface ChatRequest {
   model: string
   /** 推理等级（reasoning effort），供应商各自决定怎么映射到上游。缺省 = 'auto'。 */
   lv?: string
+  /**
+   * 宿主盖的会话身份（dsh-llm `GenerateOptions.sessionId`），由 adapter 转成
+   * 内部头带进来。用于把用量记录**按会话归因**（「最近命中」徽章要按当前会话
+   * 显示，而不是显示别的会话的命中）。缺省 = 非宿主调用（外部 OpenAI 客户端）。
+   */
+  session?: string
 }
 
 /**

package/src/router/usage-store.ts

@@ -54,6 +54,11 @@ export interface UsageRecord {
   uid?: string
   /** 失败原因（ok=false 时）。 */
   error?: string
+  /**
+   * 宿主会话身份（有则记）。用于「最近命中」按当前会话归因 —— 徽章要显示
+   * 当前会话的命中，而不是全局最近（team 多会话下后者会张冠李戴）。
+   */
+  session?: string
 }
 
 /** 按某个维度（供应商/模型/请求名）聚合的小计。 */
@@ -389,6 +394,17 @@ export class UsageStore {
     return this.recent.slice(0, limit)
   }
 
+  /**
+   * 最近一次命中。给了 `session` 就只在该会话的记录里找（「最近命中」徽章
+   * 要显示**当前会话**的命中，team 多会话下全局最近会张冠李戴）；
+   * 不给则退回全局最近一条。
+   * @param session 宿主会话身份；undefined = 全局
+   */
+  lastHit(session?: string): UsageRecord | undefined {
+    if (session === undefined) return this.recent[0]
+    return this.recent.find((r) => r.session === session)
+  }
+
   clear(): void {
     this.days.clear()
     this.recent = []

package/src/router/usage.test.ts

@@ -674,7 +674,7 @@ test('请求路径：组合回退试了 3 个模型，只记 1 条（不是 3
   add(router, spy('s1', 'm1', { ok: false, state: 'quota', message: 'no quota' }).s)
   add(router, spy('s2', 'm2', { ok: false, state: 'quota', message: 'no quota' }).s)
   add(router, spy('s3', 'm3', { ok: true, status: 200, body: '{"usage":{"prompt_tokens":1,"completion_tokens":1}}' }).s)
-  assert.equal(router.createCombo('c1', 'fallback', ['s1,m1', 's2,m2', 's3,m3']).ok, true)
+  assert.equal(router.createCombo('c1', ['s1,m1', 's2,m2', 's3,m3']).ok, true)
   await router.chatCompletions(
     { model: 'c1', stream: false, rawBody: JSON.stringify({ model: 'c1', messages: [] }) },
     sinkRes(),

package/src/shared.ts

@@ -64,6 +64,10 @@ export interface RouterCheckinResponse {
 /** `/router/api/health` response. */
 export interface RouterHealthResponse {
   ok: boolean
+  /** 宿主 DSH 版本（读不到为空串）。 */
+  hostVersion?: string
+  /** 「最近命中」徽章是否受支持（宿主 >= 0.1.7 才有 composer.dock 正确位置）。 */
+  lastHitDock?: boolean
   suppliers?: Array<{
     id: string
     name: string
@@ -75,18 +79,20 @@ export interface RouterHealthResponse {
     capabilities?: string[]
     /** 来源：内置 / 用户目录 / 外部插件。 */
     source?: 'builtin' | 'user' | 'external'
+    /**
+     * 供应商开关（是否参与路由）。**关掉的仍出现在这个列表里** —— 否则关掉之后
+     * 就没有可指的对象、再也开不回来。缺省按开启读（老版本核心没有这个字段）。
+     */
+    enabled?: boolean
   }>
   error?: string
 }
 
-/** 组合策略。 */
-export type RouterComboStrategy = 'fallback' | 'round-robin'
-
-/** 组合。models = 该组合命中的模型列表（裸模型 id，展示时动态拼前缀）。 */
+/** 组合。models = 该组合命中的模型列表（裸模型 id，展示时动态拼前缀）。
+ *  路由时作为降级链按序尝试，无策略字段。 */
 export interface RouterCombo {
   id: string
   name: string
-  strategy: RouterComboStrategy
   models: string[]
 }
 
@@ -151,6 +157,13 @@ export interface RouterExtItem {
   ready?: boolean
   /** 一句话状态说明（如「本机未装 rtk」）。 */
   detail?: string
+  /**
+   * 来源：随核心分发的内置扩展标 `builtin`，独立安装的不标（= plugin）。
+   *
+   * 插件页那个自绘的「路由组件」节据此**只列独立安装的**：内置的已经在原生
+   * 「包含的组件」里占一行了，两处都列就是同一个东西显示两遍（与内置供应商同理）。
+   */
+  source?: 'builtin'
 }
 
 /** `/router/api/ext` response（扩展插件列表 + 开关）。 */
@@ -160,25 +173,6 @@ export interface RouterExtResponse {
   enhancers?: RouterExtItem[]
 }
 
-/** 一行 watch 进程（`/router/api/ext/watch/processes`）。 */
-export interface RouterWatchProcess {
-  pid: number
-  ppid: number
-  /** %cpu 快照 */ cpu: number
-  /** %mem 快照 */ mem: number
-  command: string
-  /** 命中的已记录 agent 命令。 */
-  match: string
-  recordedAt: number
-}
-
-/** `/router/api/ext/{id}/processes` response。 */
-export interface RouterWatchResponse {
-  ok: boolean
-  error?: string
-  processes?: RouterWatchProcess[]
-}
-
 /** 供应商模型（含启用状态）。 */
 export interface RouterSupplierModel {
   id: string
@@ -227,6 +221,13 @@ export interface RouterUsageRecord {
   durationMs: number
   /** 首字节延迟（ms）；非流式为 0。 */
   ttfbMs: number
+  /**
+   * 连接名（uid → 显示别名，后端解析好）。空串 = 无连接（失败/未服务）。
+   * 「最近请求」的「连接」列用它，而不是 supplier。
+   */
+  connection?: string
+  /** 实际服务的连接 uid（成功且有账号时）。 */
+  uid?: string
   error?: string
 }