dsh-router-core 0.3.21 → 0.4.1

package/src/supplier-config.ts

@@ -4,7 +4,7 @@
  * 通用能力(所有供应商共享,供应商 js 不需要实现)：
  *   - 别名 alias(前缀,模型全名 = alias/id)
  *   - 模型管理:启用/禁用 disabled、自定义 custom
- *   - 连接池:poolOrder(拖动排序)、poolStrategy(回退/轮询)
+ *   - 连接池:poolOrder(拖动排序) —— 选号本身是会话亲和,无策略旋钮
  *   - 积分缓存 credits:按 supplier/uid 缓存最后一次拿到的剩余额度
  *
  * 持久化到 data/supplier-config.json。
@@ -12,8 +12,6 @@
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
-export type PoolStrategy = 'fallback' | 'round-robin'
-
 /**
  * 积分哨兵:插件还**没拿到过**真实额度(刚重启、积分拉取失败、或压根不支持
  * 积分)时报 `-1`,核心据此保留上一次的缓存值,而不是把 0 写进去。
@@ -25,11 +23,18 @@ export type PoolStrategy = 'fallback' | 'round-robin'
 export const CREDITS_UNKNOWN = -1
 
 export interface SupplierConfig {
+  /**
+   * 这个供应商是否参与路由（用户开关，与扩展开关同构）。
+   *
+   * **缺省 true** —— 没记录过就是开着。关掉 = 核心不把它接进路由（`Router` 的
+   * 活跃集合），请求不会落到它、模型列表/组合里也不再出现它，而它自己仍留在
+   * `/health` 与面板里（不然关掉之后就找不回来、开关也失去了开关的对象）。
+   */
+  enabled: boolean
   alias: string
   disabled: string[]
   custom: string[]
   poolOrder: string[]
-  poolStrategy: PoolStrategy
   /** 积分缓存:uid → 剩余额度(最后一次从插件拿到的非 -1 值)。 */
   credits: Record<string, number>
   /** 每连接显示别名:uid → 显示名(空/缺省用供应商原始昵称,纯展示不改路由键)。 */
@@ -90,7 +95,7 @@ export class SupplierConfigStore {
   get(supplierId: string): SupplierConfig {
     let cfg = this.bySupplier.get(supplierId)
     if (!cfg) {
-      cfg = { alias: '', disabled: [], custom: [], poolOrder: [], poolStrategy: 'fallback', credits: {}, accountNames: {} }
+      cfg = { enabled: true, alias: '', disabled: [], custom: [], poolOrder: [], credits: {}, accountNames: {} }
       this.bySupplier.set(supplierId, cfg)
     }
     return cfg
@@ -113,6 +118,26 @@ export class SupplierConfigStore {
     return { ok: true }
   }
 
+  // ---- 供应商开关（用户对核心面板的操作，归核心持久化，与 ext.json 同一层） ----
+
+  /** 这个供应商是否参与路由（未记录过 = 开）。 */
+  isEnabled(supplierId: string): boolean {
+    return this.get(supplierId).enabled
+  }
+
+  /**
+   * 置供应商开关。**不写盘**时值不变也要返回，让调用方知道是否需要重连路由。
+   * @returns 值确实变了
+   */
+  setEnabled(supplierId: string, enabled: boolean): boolean {
+    if (supplierId === '') return false
+    const cfg = this.get(supplierId)
+    if (cfg.enabled === enabled) return false
+    cfg.enabled = enabled
+    this.saveLocked()
+    return true
+  }
+
   setModelEnabled(supplierId: string, modelId: string, enabled: boolean): void {
     const cfg = this.get(supplierId)
     cfg.disabled = enabled
@@ -145,12 +170,6 @@ export class SupplierConfigStore {
     this.saveLocked()
   }
 
-  setPoolStrategy(supplierId: string, strategy: string): void {
-    if (strategy !== 'fallback' && strategy !== 'round-robin') return
-    this.get(supplierId).poolStrategy = strategy
-    this.saveLocked()
-  }
-
   // ---- 每连接显示别名（连接池改名，纯展示；uid 仍是路由/匹配键） ----
 
   /** 读某连接的显示别名;没设或为空返回 `undefined`(用供应商原始昵称)。 */
@@ -217,11 +236,12 @@ export class SupplierConfigStore {
     }
     for (const [id, c] of Object.entries(f.suppliers ?? {})) {
       this.bySupplier.set(id, {
+        // 老配置没有这个字段（写盘早于本开关）→ 视为开着，不让升级把全灭变成全开
+        enabled: typeof c.enabled === 'boolean' ? c.enabled : true,
         alias: typeof c.alias === 'string' ? c.alias : '',
         disabled: Array.isArray(c.disabled) ? c.disabled.filter((m) => typeof m === 'string') : [],
         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),
         accountNames: readNames(c.accountNames),
       })
@@ -233,11 +253,11 @@ export class SupplierConfigStore {
     const f: ConfigFile = { suppliers: {} }
     for (const [id, cfg] of this.bySupplier) {
       f.suppliers[id] = {
+        enabled: cfg.enabled,
         alias: cfg.alias,
         disabled: [...cfg.disabled],
         custom: [...cfg.custom],
         poolOrder: [...cfg.poolOrder],
-        poolStrategy: cfg.poolStrategy,
         credits: { ...cfg.credits },
         accountNames: { ...cfg.accountNames },
       }

package/src/suppliers/contract.ts

@@ -9,6 +9,7 @@
  * 用户自定义供应商 js 放到 `~/.dsh/profiles/web/suppliers/*.js`，重启后自动加载。
  * 内置供应商与用户 js 同构（差异化能力驱动）。
  */
+import type { Context } from '@deepseek-ai/cordis'
 import type { ChatRequest, ModelInfo, SupplierAccount } from '../router/types.ts'
 import type { SupplierConfigStore } from '../supplier-config.ts'
 import type { CredentialStore } from '../credential-store.ts'
@@ -32,16 +33,24 @@ export interface SupplierEnv {
    *
    * 核心实现 = `pool.noteFailure(uid, model, state, message)`，按该状态的规则
    * 冷却。真实案例：TRAE 免费通道对某账号拒绝某模型时发 HTTP 200 +
-   * 流内 `code=4008`，三个号里两个如此，round-robin 下 2/3 请求直接失败
-   * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出轮转。
+   * 流内 `code=4008`，三个号里两个如此，选号一旦落到坏号就 2/3 请求直接失败
+   * （2026-09-08 实测）——有了这条通道，坏号被冷一次就退出选号。
    *
    * 插件拿不到也不用兜底：不调用就退化成今天的行为，不影响正确性。
    */
   onLateFailure?: (uid: string, model: string, state: AccountState, message: string) => void
 }
 
-/** 通用供应商工厂：一个 js 模块 export 它（或 default export 它），loader 调用得到实例。 */
-export type SupplierFactory = (env: SupplierEnv) => SupplierModule
+/**
+ * 通用供应商工厂：一个 js 模块 export 它（或 default export 它），loader 调用得到实例。
+ *
+ * `source` 是**可选标签**，声明这个供应商是从哪儿来的。核心用它把 `/health` 的
+ * `source` 报准（面板按它分「内置 / 插件」两组，面板和插件页都看这个值）。
+ * 不声明 = `external`（独立安装的供应商插件的现状，一个字段都不用改）。
+ */
+export type SupplierFactory = ((env: SupplierEnv) => SupplierModule) & {
+  source?: 'builtin'
+}
 
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
@@ -170,3 +179,46 @@ export interface SupplierModule {
 
 /** 供应商账号（复用 router 类型，供 loader 包装）。 */
 export type { SupplierAccount }
+
+/**
+ * `router.suppliers` 共享聚合表的取值：一个供应商工厂。
+ *
+ * 核心 provide 空表；**谁都可以往里 append** —— 内置供应商（core 自己的插件行）
+ * 与独立安装的供应商插件走的是同一条通道、同一套契约，核心那边不区分内外，
+ * 只看工厂上的 `source` 标签。
+ */
+export type SupplierRegistry = Record<string, SupplierFactory>
+
+/**
+ * 读当前 `router.suppliers` 表（同一 live 对象，可追加）——供应商行用它登记自己。
+ *
+ * 读法与 `ext/contract.ts` 的 `currentExts` 同一套（cordis 的 ctx 是 Proxy，
+ * 未声明的服务直接 get 会抛，所以走 `get()` 兜底）。
+ */
+export function currentSuppliers(ctx: unknown): SupplierRegistry | undefined {
+  const c = ctx as {
+    get?: (key: string) => unknown
+    router?: { suppliers?: SupplierRegistry }
+  }
+  return (c.get?.('router.suppliers') ?? c.router?.suppliers) as SupplierRegistry | undefined
+}
+
+/**
+ * 把一个供应商工厂登记进 `router.suppliers`，并通知核心去装载它。
+ *
+ * 为什么自己 emit `internal/service`：核心靠这个事件发现「表里多了供应商」
+ * （同 `router.ext` 的做法）。**幂等** —— 同一个 id 已经在表里就直接返回，
+ * 不会把别人的登记顶掉（内置行与用户目录 js 同名时由核心按优先级裁决，
+ * 这里不越权覆盖）。
+ */
+export function registerSupplierRow(ctx: Context, id: string, factory: SupplierFactory): void {
+  ctx.inject(['router.suppliers'], (sctx) => {
+    const table = currentSuppliers(sctx)
+    if (table === undefined) return
+    if (table[id] !== undefined) return
+    table[id] = factory
+    // 核心只 provide 空表、**不监听表的变更**（表里放的是工厂，实例化要它的
+    // env），所以新增条目必须自己喊一声，否则核心只在启动时扫过一遍。
+    ctx.emit('internal/service', 'router.suppliers', table)
+  })
+}

package/src/suppliers/loader.test.ts

@@ -9,10 +9,10 @@
  */
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtempSync } from 'node:fs'
+import { mkdtempSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { wrapModule } from './loader.ts'
+import { loadSuppliers, supplierWins, wrapModule } from './loader.ts'
 import { SupplierConfigStore } from '../supplier-config.ts'
 import type { CredentialStore } from '../credential-store.ts'
 import type { SupplierEnv, SupplierModule, SupplierAccountNow, ChatOnceResult } from './contract.ts'
@@ -159,8 +159,8 @@ test('onLateFailure 挂到 env 上，且冷却作用于本供应商的池（坏
   assert.equal(after.get('u1'), true, '上报后该号应进入冷却')
   assert.equal(after.get('u2'), false, '冷却是 (模型,号) 粒度，不能连坐同供应商其它号')
   // 且真的退出选号：只剩 u2
-  assert.equal(loaded.supplier.pool.pick(loaded.supplier.accounts(), [], 'fallback', 'm1'), 'u2')
-  assert.equal(loaded.supplier.pool.pick(loaded.supplier.accounts(), [], 'fallback', 'm2'), 'u1', '换个模型不受影响')
+  assert.equal(loaded.supplier.pool.pick(loaded.supplier.accounts(), [], 'm1'), 'u2')
+  assert.equal(loaded.supplier.pool.pick(loaded.supplier.accounts(), [], 'm2'), 'u1', '换个模型不受影响')
 })
 
 test('onLateFailure 不串供应商：各自落到自己的池', () => {
@@ -181,3 +181,37 @@ test('onLateFailure 空 uid（无账号供应商）→ 不记，不炸', () => {
   assert.doesNotThrow(() => e.onLateFailure?.('', 'm1', 'quota', 'boom'))
   assert.deepEqual(loaded.supplier.status().accounts.map((a) => a.cooling), [false, false])
 })
+
+// ---- 同 id 冲突的优先级：用户目录 js > 内置行 > 外部插件供应商 ----
+// 规则错了不抛异常，只会让用户的覆盖悄悄失效，所以必须有闸门。
+
+test('优先级：用户目录的 js 压过内置行（内置改行之后不能反过来）', () => {
+  assert.equal(supplierWins('user', 'builtin'), true)
+  assert.equal(supplierWins('user', 'external'), true)
+})
+
+test('优先级：内置行压过外部插件供应商，同级不顶替', () => {
+  assert.equal(supplierWins('builtin', 'external'), true)
+  assert.equal(supplierWins('builtin', 'builtin'), false)
+  assert.equal(supplierWins('external', 'builtin'), false)
+  assert.equal(supplierWins('external', 'external'), false)
+  assert.equal(supplierWins('user', 'user'), false)
+})
+
+test('用户目录只加载 *.js，且同 id 后者覆盖前者（按文件名序）', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'sup-dir-'))
+  writeFileSync(join(dir, 'a-first.js'), 'export const id = "dup"\nexport const name = "First"\nexport const accounts = () => []\n')
+  writeFileSync(join(dir, 'b-second.js'), 'export const id = "dup"\nexport const name = "Second"\nexport const accounts = () => []\n')
+  writeFileSync(join(dir, 'notes.txt'), '不是 js，不该被加载')
+  const { suppliers, errors } = await loadSuppliers({
+    userDir: dir,
+    dataDir: dir,
+    store: new SupplierConfigStore(join(dir, 'cfg.json')),
+    credentials: {} as CredentialStore,
+    log: () => {},
+  })
+  assert.deepEqual(errors, [])
+  assert.deepEqual(suppliers.map((s) => s.supplier.id), ['dup'])
+  assert.equal(suppliers[0]?.supplier.name, 'Second')
+  assert.equal(suppliers[0]?.source, 'user')
+})

package/src/suppliers/loader.ts

@@ -1,10 +1,16 @@
 /**
- * 供应商 loader —— 扫描 suppliers 目录下的 *.js，动态 import，按契约包装成
+ * 供应商 loader —— 扫描 **用户目录**下的 *.js，动态 import，按契约包装成
  * 内部 Supplier，并暴露"能力检测"(capabilities)供通用路由/前端按能力渲染。
  *
- * 加载来源（两处，profile 优先）：
- *   1. 内置：<plugin>/lib/suppliers/*.js（随插件分发）
- *   2. 用户：~/.dsh/profiles/web/suppliers/*.js（用户自定义）
+ * 加载来源（两处）：
+ *   1. 用户：`~/.dsh/profiles/<profile>/suppliers/*.js`（自定义供应商）
+ *   2. 内置：**插件页「包含的组件」里的行** —— core 自己的 cordis.patch.yml
+ *      insert 了三个子路径模块，经 `router.suppliers` 表进来，与独立安装的
+ *      供应商插件同一条通道，核心不区分内外，只看工厂上的 `source` 标签。
+ *
+ * 内置曾经也是「扫 `<plugin>/lib/suppliers/*.js`」（本文件早先的 builtinDir）。
+ * 改成行之后那条路径已删：扫目录拿不到行的身份（插件页的开关/显示名/说明），
+ * 而且关一个内置供应商要手改配置才生效 —— 行才有宿主管的开关。
  */
 import { readdirSync } from 'node:fs'
 import { join, dirname, basename } from 'node:path'
@@ -196,10 +202,23 @@ function scanDir(dir: string): string[] {
   }
 }
 
+/**
+ * 同 id 冲突时的优先级：**用户目录 js > 内置行 > 外部插件供应商**。
+ *
+ * 为什么用户目录最高：用户放一个同 id 的 js 就是想替换它，这是「扫目录时代」
+ * 就有的语义（见本文件早先的 `loadSuppliers`：内置被用户版覆盖），内置改成行
+ * 之后不能悄悄反过来。
+ *
+ * 纯函数 + 有测试：这条规则错了不会抛异常，只会让用户的覆盖悄悄失效。
+ */
+const SUPPLIER_RANK: Record<LoadedSupplier['source'], number> = { user: 2, builtin: 1, external: 0 }
+
+export function supplierWins(incoming: LoadedSupplier['source'], existing: LoadedSupplier['source']): boolean {
+  return SUPPLIER_RANK[incoming] > SUPPLIER_RANK[existing]
+}
+
 export interface LoadSuppliersOptions {
-  /** 内置供应商目录（<plugin>/lib/suppliers）。 */
-  builtinDir: string
-  /** 用户供应商目录（~/.dsh/profiles/web/suppliers）。 */
+  /** 用户供应商目录（~/.dsh/profiles/<profile>/suppliers）。 */
   userDir: string
   /** 数据目录。 */
   dataDir: string
@@ -210,7 +229,10 @@ export interface LoadSuppliersOptions {
   log: (msg: string) => void
 }
 
-/** 加载全部供应商（内置 + 用户，用户覆盖内置同 id）。 */
+/**
+ * 加载用户目录下的供应商。同一个 id 出现多个文件时**后者覆盖前者**（按文件名序），
+ * 与内置共存的裁决交给核心（`registerLoaded` 的优先级：用户目录 js > 行）。
+ */
 export async function loadSuppliers(opts: LoadSuppliersOptions): Promise<{
   suppliers: LoadedSupplier[]
   errors: SupplierLoadError[]
@@ -219,18 +241,11 @@ export async function loadSuppliers(opts: LoadSuppliersOptions): Promise<{
   const byId = new Map<string, LoadedSupplier>()
   const errors: SupplierLoadError[] = []
 
-  const files = [
-    ...scanDir(opts.builtinDir).map((f) => ({ f, builtin: true })),
-    ...scanDir(opts.userDir).map((f) => ({ f, builtin: false })),
-  ]
-  for (const { f, builtin } of files) {
+  for (const f of scanDir(opts.userDir).sort()) {
     try {
-      const loaded = await loadOne(f, env, builtin ? 'builtin' : 'user')
-      // 用户目录覆盖内置
-      const existing = byId.get(loaded.supplier.id)
-      if (existing && builtin) continue // 内置已被用户版覆盖
+      const loaded = await loadOne(f, env, 'user')
       byId.set(loaded.supplier.id, loaded)
-      opts.log(`supplier ${loaded.supplier.id} loaded (${builtin ? 'builtin' : 'user'}) from ${basename(f)}`)
+      opts.log(`supplier ${loaded.supplier.id} loaded (user) from ${basename(f)}`)
     } catch (err) {
       errors.push({ id: basename(f, '.js'), file: f, error: (err as Error).message })
       opts.log(`supplier load failed ${basename(f)}: ${(err as Error).message}`)

package/src/suppliers/nvidia/index.ts

@@ -0,0 +1,27 @@
+/**
+ * NVIDIA NIM 的 **cordis 行** —— 官方插件页（设置 → 插件 → dsh-router-core）详情页
+ * 「包含的组件」里的那一行。
+ *
+ * 为什么多一层壳：`plugin.ts` 已经把 `name` 用作**面板显示名**（供应商契约的
+ * 字段，所有供应商插件都这么写），而 cordis 的插件身份也要一个 `name`，两者
+ * 抢同一个名字。所以行 = 这一层壳（cordis 身份 + 登记），实现 = `plugin.ts`。
+ *
+ * 这一行只做一件事：把供应商工厂登记进核心的 `router.suppliers` 表。**通道和
+ * 契约与独立安装的供应商插件完全一样**（core 不区分内外，只看工厂上的
+ * `source: 'builtin'` 标签），因此这一行在插件页能拿到宿主管的开关：关掉它 =
+ *  loader 不 import 这个模块 = 供应商压根没注册 = 路由不会落到它。
+ */
+import type { Context } from '@deepseek-ai/cordis'
+import { registerSupplierRow, type SupplierEnv, type SupplierFactory } from '../contract.ts'
+import factory, { id } from './plugin.ts'
+
+/** cordis 插件身份（配置树里这一行的技术名；显示名走同目录的 locale）。 */
+export const name = 'dsh-router-supplier-nvidia'
+
+/** 登记本供应商。幂等：同一个 id 已在表里就直接返回，不顶掉别人的登记。 */
+export function apply(ctx: Context): void {
+  // `source: 'builtin'` 让 /health 如实报出「内置」，面板的「内置 / 插件」
+  // 两组才不会把随核心分发的供应商误标成插件提供的。
+  const row: SupplierFactory = Object.assign((env: SupplierEnv) => factory(env), { source: 'builtin' as const })
+  registerSupplierRow(ctx, id, row)
+}

package/src/suppliers/nvidia/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "NVIDIA NIM",
+    "description": "NVIDIA 官方推理通道，API key 制"
+  }
+}

package/src/suppliers/nvidia/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "NVIDIA NIM",
+    "description": "NVIDIA 官方推理通道，API key 制"
+  }
+}

package/src/suppliers/nvidia/row.json

@@ -0,0 +1,5 @@
+{
+  "name": "dsh-router-core-supplier-nvidia",
+  "type": "module",
+  "description": "NVIDIA 官方推理通道，API key 制（随 dsh-router 核心分发）"
+}

package/src/suppliers/opencode/index.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenCode 的 **cordis 行** —— 官方插件页（设置 → 插件 → dsh-router-core）详情页
+ * 「包含的组件」里的那一行。
+ *
+ * 为什么多一层壳：`plugin.ts` 已经把 `name` 用作**面板显示名**（供应商契约的
+ * 字段，所有供应商插件都这么写），而 cordis 的插件身份也要一个 `name`，两者
+ * 抢同一个名字。所以行 = 这一层壳（cordis 身份 + 登记），实现 = `plugin.ts`。
+ *
+ * 这一行只做一件事：把供应商工厂登记进核心的 `router.suppliers` 表。**通道和
+ * 契约与独立安装的供应商插件完全一样**（core 不区分内外，只看工厂上的
+ * `source: 'builtin'` 标签），因此这一行在插件页能拿到宿主管的开关：关掉它 =
+ *  loader 不 import 这个模块 = 供应商压根没注册 = 路由不会落到它。
+ */
+import type { Context } from '@deepseek-ai/cordis'
+import { registerSupplierRow, type SupplierEnv, type SupplierFactory } from '../contract.ts'
+import factory, { id } from './plugin.ts'
+
+/** cordis 插件身份（配置树里这一行的技术名；显示名走同目录的 locale）。 */
+export const name = 'dsh-router-supplier-opencode'
+
+/** 登记本供应商。幂等：同一个 id 已在表里就直接返回，不顶掉别人的登记。 */
+export function apply(ctx: Context): void {
+  // `source: 'builtin'` 让 /health 如实报出「内置」，面板的「内置 / 插件」
+  // 两组才不会把随核心分发的供应商误标成插件提供的。
+  const row: SupplierFactory = Object.assign((env: SupplierEnv) => factory(env), { source: 'builtin' as const })
+  registerSupplierRow(ctx, id, row)
+}

package/src/suppliers/opencode/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "OpenCode",
+    "description": "Zen 免费档（无需账号）"
+  }
+}

package/src/suppliers/opencode/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "OpenCode",
+    "description": "Zen 免费档（无需账号）"
+  }
+}

package/src/suppliers/opencode/row.json

@@ -0,0 +1,5 @@
+{
+  "name": "dsh-router-core-supplier-opencode",
+  "type": "module",
+  "description": "Zen 免费档（无需账号）（随 dsh-router 核心分发）"
+}

package/src/suppliers/openrouter/index.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenRouter 的 **cordis 行** —— 官方插件页（设置 → 插件 → dsh-router-core）详情页
+ * 「包含的组件」里的那一行。
+ *
+ * 为什么多一层壳：`plugin.ts` 已经把 `name` 用作**面板显示名**（供应商契约的
+ * 字段，所有供应商插件都这么写），而 cordis 的插件身份也要一个 `name`，两者
+ * 抢同一个名字。所以行 = 这一层壳（cordis 身份 + 登记），实现 = `plugin.ts`。
+ *
+ * 这一行只做一件事：把供应商工厂登记进核心的 `router.suppliers` 表。**通道和
+ * 契约与独立安装的供应商插件完全一样**（core 不区分内外，只看工厂上的
+ * `source: 'builtin'` 标签），因此这一行在插件页能拿到宿主管的开关：关掉它 =
+ *  loader 不 import 这个模块 = 供应商压根没注册 = 路由不会落到它。
+ */
+import type { Context } from '@deepseek-ai/cordis'
+import { registerSupplierRow, type SupplierEnv, type SupplierFactory } from '../contract.ts'
+import factory, { id } from './plugin.ts'
+
+/** cordis 插件身份（配置树里这一行的技术名；显示名走同目录的 locale）。 */
+export const name = 'dsh-router-supplier-openrouter'
+
+/** 登记本供应商。幂等：同一个 id 已在表里就直接返回，不顶掉别人的登记。 */
+export function apply(ctx: Context): void {
+  // `source: 'builtin'` 让 /health 如实报出「内置」，面板的「内置 / 插件」
+  // 两组才不会把随核心分发的供应商误标成插件提供的。
+  const row: SupplierFactory = Object.assign((env: SupplierEnv) => factory(env), { source: 'builtin' as const })
+  registerSupplierRow(ctx, id, row)
+}

package/src/suppliers/openrouter/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "OpenRouter",
+    "description": "OpenRouter 聚合通道，API key 制"
+  }
+}

package/src/suppliers/openrouter/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "OpenRouter",
+    "description": "OpenRouter 聚合通道，API key 制"
+  }
+}

package/src/suppliers/openrouter/row.json

@@ -0,0 +1,5 @@
+{
+  "name": "dsh-router-core-supplier-openrouter",
+  "type": "module",
+  "description": "OpenRouter 聚合通道，API key 制（随 dsh-router 核心分发）"
+}