@arcaneorion/dsh-model-channel-manager 0.1.0 → 0.2.0

package/README.md

@@ -3,7 +3,7 @@
 DSH 原生模型渠道管理。两半结构：
 
 - **host 半** `src/index.js`：轮询故障转移引擎（`llm.registerAdapter` 虚拟路由 `roundrobin/<组id>`）+ 7 天健康流水 + 测速排序 + 单模型真实请求测试通道。
-- **client 半** `src/client.js`：`conversation.view` 顶级页签「模型配置」，内含三个子页：**模型配置**（llm-pi-ai providers 全字段编辑、拉取上游、单模型 ⚡ 测试、供应商搜索过滤）、**轮询渠道**（groups 编辑 + ⚡测速 + 输入模态编辑；新建组默认呈现名 = 组 id、模态含图片——host 对当前会话模型做 resolveModelInfo，缺 image 时附加图片直接被拒）、**健康统计**（7 天聚合）。
+- **client 半** `src/client.js`：`conversation.view` 顶级页签「模型配置」，内含三个子页：**模型配置**（llm-pi-ai providers 全字段编辑、拉取上游、单模型 ⚡ 测试、供应商搜索过滤）、**轮询渠道**（groups 编辑 + ⚡测速 + 输入模态编辑；**命名单一身份：显示名 = 组唯一 ID**，保存时归一化 `virtualModel.name = id`，改 ID 即改名，永不漂移）、**健康统计**（7 天聚合）。
 - **会话模型选择器已拆出**为独立 cordis client 插件 [`@arcaneorion/dsh-model-selector-search`](../model-selector-search/)（一个占座者一个插件单元，可独立启停/替换；座位遮蔽 + 搜索 + 近 7 天置顶 + 菜单向上展开都在该仓）。
 
 语义参考 pi 的 `pi-provider-manager`，但完全走 DSH 原生 seam（无独立 HTTP 服务/端口/token）：
@@ -19,7 +19,14 @@ DSH 原生模型渠道管理。两半结构：
 
 ## 挂载
 
-`profiles/web/package.json`：
+从 npm 装（发布版）：
+
+```bash
+dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
+# 然后重启 dsh --profile web 并刷新页面
+```
+
+本地开发用 `link:`（改源码即时生效）——`profiles/web/package.json`：
 - `dependencies` 加 `"@arcaneorion/dsh-model-channel-manager": "link:/home/arcaneorion/AI/AI-DSH/plugin/model-channel-manager"`
 - `dsh.profile.bundles` 加 `"@arcaneorion/dsh-model-channel-manager"`
 - `pnpm install` 后重启 `dsh --profile web`
@@ -29,6 +36,22 @@ DSH 原生模型渠道管理。两半结构：
 - `llm.providers` 出现 `roundrobin/<组id>`
 - settings describe 含 `model-channels` / `model-channel-health` 命名空间
 
+## 兼容性（DSH 版本）
+
+本包在 **DSH `0.1.1-rc.2`**（`dsh --version`）上开发与实测，宿主侧依赖按该版本**精确钉住**：
+
+| 宿主包 | 声明 | 用途 |
+|---|---|---|
+| `@deepseek-ai/dsh-llm` | `0.1.1-rc.2` | `llm.registerAdapter` / `llm.stream`（轮询引擎与健康采集） |
+| `@deepseek-ai/dsh-settings` | `0.1.1-rc.2` | `model-channels` / `model-channel-health` 命名空间读写 |
+| `@deepseek-ai/dsh-client-connection` | `0.1.1-rc.2` | client 半的 `connection.api` 调用 |
+| `@deepseek-ai/dsh-client-ui-conversation` | `0.1.1-rc.2` | `conversation.view` 页签座位 |
+| `@deepseek-ai/cordis` | `^4.0.2` | 插件生命周期 |
+| `@deepseek-ai/schemastery` | `>=3.18.2` | 配置 schema |
+
+**换 DSH 版本（例如 `0.1.2-rc.1`）必须先重新验证、再放宽 peer**：宿主服务与座位契约跨版本会变，
+精确钉住的 peer 会在安装时报冲突——这正是它存在的意义，好过装上去静默失效。
+
 ## 数据通道（全走公共 seam，无私有 RPC）
 
 - 读配置/健康/运行态 = `api.settings.describe()` 过滤命名空间
@@ -50,6 +73,14 @@ DSH 原生模型渠道管理。两半结构：
 
 **不要把 `result.value` 当 `result` 读**——曾因少解一层导致整个面板静默空数据（describe 返回 namespaces 但全面板 0 provider，无任何错误提示）。
 
+## Token 用量统计（健康面板）
+
+- 健康记录条目在既有字段（ts/provider/model/ok/ttftMs/latencyMs/code）上**增量附带**上游真实 token 用量：`inputTokens` / `outputTokens` / `cacheReadTokens` / `cacheWriteTokens` / `reasoningTokens`——来自适配器在 `finish` 前发出的 `usage` StreamChunk（rc.2 运行时 `StreamChunk` 契约，pi-ai `done`/`error` 事件都带）；无 usage 则这些字段不写。
+- **计费口径与 DSH `tokenMeter` 一致**：input + cacheRead + cacheWrite + output（互斥计数，`inputTokens` 不含缓存命中）。面板「总 Token 用量」卡按统计窗口求和，副行显示 输入/输出/缓存 拆分；每模型卡底部显示该模型窗口 Tokens。
+- 采集点与健康记录**同址**（保证 token 与请求数同记录同窗口）：全局 `llm/stream` 拦截器 + 轮询引擎 `streamAttempt`（成功/失败/超时路径都尽量携带；pi-ai 的 error 事件同样上报部分 usage）。
+- 测速（⚡测速）/ 单模型测试（⚡测试）消耗的 token **不计入**——与「测速结果不入健康流水」的既有口径一致。
+- 记录 schema 无需改动（`records` 为 `z.array(z.any())`），无新 RPC / settings 字段；client 5s 轮询自动刷新。
+
 ## 测试通道（模型可用性）
 
 - 模型行「⚡测试」→ 弹窗输入自定义问题 + maxTokens → 发送
@@ -79,6 +110,12 @@ DSH 原生模型渠道管理。两半结构：
 - 历史健康流水保留在原 ID 名下（历史存档不受影响）
 - 改名后仍需点击右上「保存全部变更」落盘
 
+## 密钥写入（凭据引用虚拟化）
+
+- 面板主视图只出现「API Key」输入框：**粘贴或输入后失焦即自动写入** DSH 凭据存储（`~/.dsh/.credentials.yaml`，0600，write-only 读不回），无手动按钮；清空输入框不会删除已存 key。上游 llm-pi-ai 的供应商 profile 只有 `apiKeyEnv` 一个密钥字段（凭据引用名），不存在内联 key 的选项——secrets 不进 settings.yaml、不随 `settings.describe` 下发，是有意的安全设计。
+- 「API Key 环境变量名」已收进供应商高级选项、更名「凭据引用名 (apiKeyEnv)」：新增供应商时自动生成（`normalizeCredentialRef`），并对 **ID + 引用双重去重**——改名供应商会保留旧引用（write-only 无法搬移），只按 ID 去重会复活 `provider-1` 并继承已被占用的 `PROVIDER_1_API_KEY`（两个供应商同引用 = 共用同一把 key，写入互相覆盖）。此坑已由双重去重修复，存量撞引用靠 ⚠ 警示提示手动处理（改其中一个引用 → 重新写入）。
+- 环境优先级：启动 shell 同名变量（只读、优先）> 存储的 key > 项目 `.env` > 用户 `.env`（credentials-local 分层）；想用环境注入直接在启动环境 export 即可。
+
 **曾踩坑**：`selected` 曾初始化为 `missing`（只含"可加"），而 configured 项 checkbox 显示 `checked:true` 却不在 selected 里——应用时 `kept = models.filter(m => cs.has(m.id))` 把已配置模型全部丢弃 → **已有模型消失**。修复 = selected 初始化为 `configured ∩ 端点`。
 
 ## host 半内部接口
@@ -86,6 +123,7 @@ DSH 原生模型渠道管理。两半结构：
 - settings 接入用 **`ctx.inject(['settings'], (sctx) => {...})`**（settings 服务异步初始化，apply 时 `ctx.get('settings')` 为 undefined——曾经整个引擎静默失效，命名空间从未注册）
 - 配置 schema（schemastery）：`model-channels` 的虚模型/candidates/strategy/timeoutMs/cooldownMs/maxRetriesPerCandidate/speedTest；`model-channel-health` 的 records 7 天切片（单组 ≤2000 条）/speedResults/runtime/speedRequest+lastHandledNonce/testRequest+testResults+lastTestHandledNonce
 - 引擎：sticky/round-robin/primary 三策略；首响应超时 + 流中空闲超时（动态 = max(timeoutMs, min(120s, ttft×2))）；单候选原地重试（指数退避）耗尽才换；全炸清冷却重试一轮；测速 ttft/latency/hybrid/smart 四键（smart = 0.5×ttft_norm + 0.3×(1−reliability) + 0.2×latency_norm，reliability 贝叶斯平滑 `(success+2.5)/(total+5)`）；测速失败进冷却；请求隔离按组
+- 虚拟模型元数据：`reasoning.efforts` 七档（off…max）、**defaultEffort=max**——原生 `/model` 弹窗对新模型的自动填档与展示跟随该声明；会话内显式档位的跨会话恢复由 selector 插件的档位记忆层负责（`modelDirectories` 拦截，存 `model-channels.effortMemory`）
 - 迁移：startup 时从工作区 `.channel-manager/config.json` 一次性迁入 `model-channels`（无遗留则忽略）；完成后写 `legacyMigrated` 哨兵防止「清空组后重启复活」；fs 未就绪时 5s×6 重试
 - 遗留 `.channel-manager/` 目录不再使用
 
@@ -100,6 +138,7 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 
 - 动态超时实现了首响应 + 流中空闲；全炸后「清冷却重试一轮」回溯，未实现「等待最早冷却」的睡眠分支
 - 测速结果不入健康流水（pi 记）；smart 键只统计真实请求
+- **Token 字段只在新记录上出现**：host 升级重启前的存量健康记录无 token 字段，7 天视图对重启前的调用会低估 token（请求数/可用率不受影响）；数据自重启后开始累积
 - 配置里 provider 必须非虚拟路由（防自引用）
 - 轮询渠道/健康统计面板需要 host 新代码（重启后生效）；健康流水的数据在**实际请求过轮询组**后才出现
 - `reasoningEfforts` 缺失（undefined）的 model 正确渲染（`|| {}` 兜底）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcaneorion/dsh-model-channel-manager",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.js",
   "exports": {
@@ -13,7 +13,7 @@
   "author": "arcanexis",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/arcanexis/dsh-model-channel-manager.git"
+    "url": "git+https://github.com/ArcaneOrion/dsh-model-channel-manager.git"
   },
   "keywords": [
     "deepseek",
@@ -34,7 +34,13 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@deepseek-ai/schemastery": ">=3.18.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.1.1-rc.2",
+    "@deepseek-ai/schemastery": ">=3.18.2",
+    "react": "^18.3.1"
   },
   "dsh": {
     "bundle": {

package/src/client.js

@@ -549,7 +549,8 @@ window.__ModuleLoader__.load({
       const saveKey = (name) => {
         const ref = (providers[name] || {}).apiKeyEnv || ''
         const val = (keyInput[name] || '').trim()
-        if (!ref || !val || !apiRef) return
+        if (!val || !apiRef) return
+        if (!ref) { setLive((l) => Object.assign({}, l, { [name + '_key']: 'err: 缺少凭据引用名（见高级选项）' })); return }
         savedKeys[name] = val
         apiRef.credentials.set({ ref, value: val }).then((resp) => {
           const r = resp && resp.result ? resp.result : resp
@@ -570,6 +571,13 @@ window.__ModuleLoader__.load({
           if (p.displayName && String(p.displayName).toLowerCase().includes(pqLower)) return true
           return (p.models || []).some((m) => m && ((m.id || '').toLowerCase().includes(pqLower) || (m.name || '').toLowerCase().includes(pqLower)))
         })
+      // 凭据引用占用计数：同一 apiKeyEnv 被多个供应商引用 = 共用同一把 key（任一处
+      // 「写入存储」覆盖共享引用，全部共引供应商随之同 key）——用于卡片 ⚠ 警示
+      const refUsage = new Map()
+      for (const p of Object.values(providers || {})) {
+        const ref = p && typeof p.apiKeyEnv === 'string' ? p.apiKeyEnv.trim() : ''
+        if (ref) refUsage.set(ref, (refUsage.get(ref) || 0) + 1)
+      }
       const cards = visibleEntries.map(({ name, p, realIdx }) => {
         const isOpen = pqLower ? true : !!exp[name]
         const models = p.models || []
@@ -619,21 +627,23 @@ window.__ModuleLoader__.load({
               sel('协议架构 (API)', '当前支持的请求格式', p.api || 'openai-completions', APIS, (v) => updateP(name, { api: v }))
             ),
             el('div', { className: 'mcm-row' },
-              tf('Base URL', 'API 端点基础地址', p.baseURL || '', (v) => updateP(name, { baseURL: v }), true),
-              tf('API Key 环境变量名', '凭据存储引用名', p.apiKeyEnv || '', (v) => updateP(name, { apiKeyEnv: v }), true)
+              tf('Base URL', 'API 端点基础地址', p.baseURL || '', (v) => updateP(name, { baseURL: v }), true)
             ),
-            field('快速写入密钥', '将 API Key 安全存入 DSH 凭据存储', false,
+            field('API Key', '粘贴或输入后失焦即自动写入 DSH 凭据存储（~/.dsh/.credentials.yaml，0600，write-only 读不回）；清空输入框不会删除已存 key；启动环境若有同名变量则其只读优先', false,
               el('div', { style: { display: 'flex', gap: 8, alignItems: 'center' } },
-                el('input', { type: 'password', className: 'mcm-in mono', style: { flex: 1 }, placeholder: '输入并覆盖 API Key (sk-...)', value: keyInput[name] || '', onChange: (e) => setKeyInput((k) => Object.assign({}, k, { [name]: e.target.value })) }),
-                btn('写入存储', () => saveKey(name)),
-                live[name + '_key'] === 'saved' ? el('span', { style: { color: 'var(--dsw-alias-state-success-primary)', fontSize: 12 } }, '✓ 已保存') : null
+                el('input', { type: 'password', className: 'mcm-in mono', style: { flex: 1 }, placeholder: '粘贴 API Key (sk-...)，失焦自动保存', value: keyInput[name] || '', onChange: (e) => setKeyInput((k) => Object.assign({}, k, { [name]: e.target.value })), onBlur: () => { const v = (keyInput[name] || '').trim(); if (v && v !== savedKeys[name]) saveKey(name) } }),
+                live[name + '_key'] === 'saved' ? el('span', { style: { color: 'var(--dsw-alias-state-success-primary)', fontSize: 12 } }, '✓ 已保存') : (live[name + '_key'] && String(live[name + '_key']).indexOf('err') === 0 ? el('span', { style: { color: 'var(--dsw-alias-state-error-primary)', fontSize: 12 } }, live[name + '_key']) : null)
               )
             ),
+            (p.apiKeyEnv && (refUsage.get(p.apiKeyEnv) || 0) > 1) ? el('div', { style: { color: 'var(--dsw-alias-state-warn-primary)', fontSize: 11, lineHeight: 1.6 } }, '⚠ 该引用被 ' + refUsage.get(p.apiKeyEnv) + ' 个供应商共用 = 共用同一把 Key，任一处写入会同时覆盖所有供应商；若非有意，请在高级选项中修改其中一个「凭据引用名」并重新写入') : null,
             el('div', { style: { borderTop: '1px dashed var(--dsw-alias-border-l2)', paddingTop: 10 } },
               el('div', { style: { cursor: 'pointer', fontSize: 12, fontWeight: 600, color: 'var(--dsw-alias-label-secondary)', display: 'flex', alignItems: 'center', gap: 6 }, onClick: () => setSa((s) => Object.assign({}, s, { [name]: !s[name] })) },
                 el('span', null, sa[name] ? '▼' : '▶'), '供应商高级选项 (Headers, 传输, 超时, 图片预算, 重试策略, Compat)'
               ),
               sa[name] ? el('div', { style: { display: 'flex', flexDirection: 'column', gap: 12, marginTop: 10 } },
+                el('div', { className: 'mcm-row' },
+                  tf('凭据引用名 (apiKeyEnv)', 'key 在凭据存储（~/.dsh/.credentials.yaml）中的引用名，write-only 读不回已存值；启动环境同名变量只读优先；修改后需重新写入 key', p.apiKeyEnv || '', (v) => updateP(name, { apiKeyEnv: v }), true)
+                ),
                 el('div', { className: 'mcm-row' },
                   nf('默认 Context Window', '未单独配置模型时的默认窗口', p.defaultContextWindow || 0, (v) => updateP(name, { defaultContextWindow: v })),
                   nf('默认 Max Tokens', '未单独配置模型时的最大输出', p.defaultMaxTokens || 0, (v) => updateP(name, { defaultMaxTokens: v }))
@@ -768,7 +778,14 @@ window.__ModuleLoader__.load({
         ...cards,
         visibleEntries.length === 0 && pqLower ? el('div', { className: 'mcm-empty' }, '无匹配「' + pq.trim() + '」的供应商或模型') : null,
         btn('＋新增提供商 (Provider)', () => {
-          const nm = uniqueSuffixName('provider-', (n) => Object.prototype.hasOwnProperty.call(providers, n))
+          // 双重去重：provider ID 与凭据引用都不得与现有草稿冲突。改名供应商会保留旧
+          // 引用（write-only 无法搬移），只按 ID 去重会复活 provider-1 并继承已被占用
+          // 的 PROVIDER_1_API_KEY——两个供应商同引用 = 共用同一把 key（写入互相覆盖）
+          const idsTaken = new Set(Object.keys(providers || {}))
+          const refsTaken = new Set(Object.values(providers || {}).map((p) => p && p.apiKeyEnv).filter(Boolean))
+          let i = 1
+          while (idsTaken.has('provider-' + i) || refsTaken.has(normalizeCredentialRef('provider-' + i + '_api_key'))) i++
+          const nm = 'provider-' + i
           const keyRef = normalizeCredentialRef(nm + '_api_key')
           setDraft((d) => Object.assign({}, d || {}, { [nm]: { api: 'openai-completions', baseURL: '', apiKeyEnv: keyRef, displayName: nm, models: [], headers: Object.assign({}, DEFAULT_HEADERS) } }))
           setExp((e) => Object.assign({}, e, { [nm]: true }))
@@ -823,10 +840,9 @@ window.__ModuleLoader__.load({
         const id = uniqueSuffixName('group-', (n) => base.some((g) => g && g.id === n))
         return base.concat([{
           id,
-          // 默认呈现名 = 组 id：多个轮询组在目录/选择器里靠名字区分（固定
-          // 'RoundRobin' 会全部撞名，实测反馈），需要别的名字在「虚拟模型呈现名」改；
-          // 默认模态含 image：host 对当前会话模型做 resolveModelInfo，缺 image 时
-          // 附加图片直接被拒（MODEL_DOES_NOT_SUPPORT_IMAGES），按直觉默认放开
+          // 单一身份：显示名 = 组唯一 ID（save 时统一归一化 virtualModel.name = id，
+          // 不会漂移）。默认模态含 image：host 对当前会话模型做 resolveModelInfo，
+          // 缺 image 时附加图片直接被拒（MODEL_DOES_NOT_SUPPORT_IMAGES），按直觉默认放开
           virtualModel: { name: id, reasoning: true, input: ['text', 'image'], contextWindow: 1048576, maxTokens: 131072 },
           candidates: [],
           strategy: 'sticky',
@@ -871,7 +887,7 @@ window.__ModuleLoader__.load({
           return el('div', { className: 'mcm-card', key: 'rr_card_' + i },
             el('div', { className: 'mcm-card-h', onClick: () => setExpanded((e) => Object.assign({}, e, { [i]: !e[i] })) },
               el('span', { style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary)' } }, isOpen ? '▼' : '▶'),
-              el('div', { className: 'mcm-card-title' }, el('span', null, vm.name || g.id), el('span', { className: 'mcm-badge brand' }, 'roundrobin/' + g.id)),
+              el('div', { className: 'mcm-card-title' }, el('span', null, g.id), el('span', { className: 'mcm-badge brand' }, 'roundrobin/' + g.id)),
               el('span', { className: 'mcm-badge' }, (g.candidates || []).length + ' 候选'),
               el('span', { className: 'mcm-badge' }, g.strategy || 'sticky'),
               el('div', { style: { marginLeft: 'auto', display: 'flex', gap: 6 }, onClick: (e) => e.stopPropagation() },
@@ -882,8 +898,7 @@ window.__ModuleLoader__.load({
             ),
             isOpen ? el('div', { className: 'mcm-editor' },
               el('div', { className: 'mcm-row' },
-                tf('组唯一 ID', '对应虚拟路由 roundrobin/<id>', g.id || '', (v) => patchGroup(i, { id: v }), true),
-                tf('虚拟模型呈现名', '对话侧栏显示的名字', vm.name || '', (v) => patchGroupPath(i, ['virtualModel', 'name'], v))
+                tf('组唯一 ID', '对应虚拟路由 roundrobin/<id>，也是模型选择器里显示的名字（改这里即改名）', g.id || '', (v) => patchGroup(i, { id: v }), true)
               ),
               field('输入模态', '声明虚拟模型接受的输入；不含图片时附加图片会被 host 直接拒绝（MODEL_DOES_NOT_SUPPORT_IMAGES）', false,
                 el('div', { style: { display: 'flex', gap: 16, alignItems: 'center', height: 32 } },
@@ -979,12 +994,18 @@ window.__ModuleLoader__.load({
               lastTs: 0,
               lastOk: null,
               lastCode: null,
-              recentErrors: 0
+              recentErrors: 0,
+              tokSum: 0
             })
           }
         }
       }
 
+      // 窗口级 token 聚合（计费口径 = input + cacheRead + cacheWrite + output，与 dsh-token-meter 一致）
+      let totalTokIn = 0
+      let totalTokOut = 0
+      let totalTokCache = 0
+
       // 累加时间窗口内的真实流水记录
       for (const e of allEvents) {
         if (!e || !e.provider || !e.model) continue
@@ -1004,11 +1025,19 @@ window.__ModuleLoader__.load({
             lastTs: 0,
             lastOk: null,
             lastCode: null,
-            recentErrors: 0
+            recentErrors: 0,
+            tokSum: 0
           }
           pMap.set(e.model, a)
         }
         a.total++
+        const tokIn = (e && e.inputTokens) || 0
+        const tokOut = (e && e.outputTokens) || 0
+        const tokCache = ((e && e.cacheReadTokens) || 0) + ((e && e.cacheWriteTokens) || 0)
+        totalTokIn += tokIn
+        totalTokOut += tokOut
+        totalTokCache += tokCache
+        a.tokSum += tokIn + tokOut + tokCache
         if (e.ok) {
           a.success++
           if (e.ttftMs != null && e.ttftMs >= 0) a.ttftSum += e.ttftMs
@@ -1088,6 +1117,14 @@ window.__ModuleLoader__.load({
             el('span', { className: 'mcm-metric-value' }, totalRequests),
             el('span', { style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary)' } }, '真实上游交互捕获')
           ),
+          el('div', { className: 'mcm-metric-card' },
+            el('span', { className: 'mcm-metric-label' }, '总 Token 用量'),
+            el('span', { className: 'mcm-metric-value' }, (totalTokIn + totalTokOut + totalTokCache).toLocaleString('zh-CN')),
+            el('span', { style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary)' } },
+              '输入 ' + totalTokIn.toLocaleString('zh-CN') + ' · 输出 ' + totalTokOut.toLocaleString('zh-CN') +
+              (totalTokCache > 0 ? ' · 缓存 ' + totalTokCache.toLocaleString('zh-CN') : '')
+            )
+          ),
           el('div', { className: 'mcm-metric-card' },
             el('span', { className: 'mcm-metric-label' }, '窗口可用率'),
             el('span', { className: 'mcm-metric-value', style: { color: totalSuccess === totalRequests ? 'var(--dsw-alias-state-success-primary)' : 'var(--dsw-alias-label-primary)' } }, globalRate),
@@ -1135,7 +1172,7 @@ window.__ModuleLoader__.load({
                 )
               ),
               el('div', { style: { display: 'flex', justifyContent: 'space-between', fontSize: 11, color: 'var(--dsw-alias-label-tertiary)', borderTop: '1px solid var(--dsw-alias-border-l1)', paddingTop: 8 } },
-                el('span', null, 'TTFT: ', el('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, m.avgTtft)),
+                el('span', null, 'TTFT: ', el('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, m.avgTtft), ' · Tokens: ', el('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, (m.tokSum || 0).toLocaleString('zh-CN'))),
                 el('span', null, '最近: ', el('span', { style: { color: 'var(--dsw-alias-label-secondary)' } }, m.lastTimeStr))
               )
             ))
@@ -1350,7 +1387,9 @@ window.__ModuleLoader__.load({
         const orderPatch = draft ? { providerOrder: Object.keys(cleanProviders) } : {}
         const p2 = apiRef.settings.update({
           ns: 'model-channels',
-          patch: Object.assign({ groups: channelsDraft || [] }, orderPatch)
+          // 命名单一身份：写入时统一 virtualModel.name = 组 id——旧的独立呈现名
+          // （如遗留的 group-1）在下一次保存时自动归一，无需迁移
+          patch: Object.assign({ groups: (channelsDraft || []).map((g) => Object.assign({}, g, { virtualModel: Object.assign({}, g.virtualModel, { name: g.id }) })) }, orderPatch)
         }).then((resp) => {
           const r = resp && resp.result ? resp.result : resp
           if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'model-channels save failed')

package/src/index.js

@@ -266,9 +266,22 @@ export function apply(ctx) {
         const now = Date.now();
         const key = gid || 'global';
         const list = state.records[key] || (state.records[key] = []);
-        list.push({ ts: now, provider: cand.provider, model: cand.model, ok: entry.ok, ttftMs: entry.ttftMs, latencyMs: entry.latencyMs, code: entry.code || null });
+        const rec = { ts: now, provider: cand.provider, model: cand.model, ok: entry.ok, ttftMs: entry.ttftMs, latencyMs: entry.latencyMs, code: entry.code || null };
+        // 上游真实 token 用量（来自 usage StreamChunk，计费口径与 dsh-token-meter 一致）：
+        // 展平写入记录条目；缺失/非法字段不写，旧记录按 0 处理（向后兼容）。
+        const u = entry.usage;
+        if (u && typeof u === 'object') {
+            if (Number.isFinite(u.inputTokens)) rec.inputTokens = u.inputTokens;
+            if (Number.isFinite(u.outputTokens)) rec.outputTokens = u.outputTokens;
+            if (Number.isFinite(u.cacheReadTokens)) rec.cacheReadTokens = u.cacheReadTokens;
+            if (Number.isFinite(u.cacheWriteTokens)) rec.cacheWriteTokens = u.cacheWriteTokens;
+            if (Number.isFinite(u.reasoningTokens)) rec.reasoningTokens = u.reasoningTokens;
+        }
+        list.push(rec);
         const cutoff = now - 7 * 24 * 3600 * 1000;
-        state.records[key] = list.filter((e) => e.ts >= cutoff).slice(-2000);
+        // 每键保留 300 条：健康页签 30m/24h 视图与选择器置顶绰绰有余，同时把
+        // settings.yaml 的体量压到可读（2000 条/键时该文件一度膨胀到 2 万行）
+        state.records[key] = list.filter((e) => e.ts >= cutoff).slice(-300);
         persistHealth();
     };
     const persistSpeedResults = async (r) => {
@@ -315,6 +328,7 @@ export function apply(ctx) {
         let started = false;
         let ttftMs = null;
         let lastAt = Date.now();
+        let lastUsage = null;
         const closeInner = async () => { try {
             const c = inner.return ? inner.return() : null;
             if (c && c.then)
@@ -341,6 +355,10 @@ export function apply(ctx) {
                 }
                 lastAt = Date.now();
                 const chunk = next.value;
+                // 适配器在 finish 前发 usage 块（pi-ai done/error 都带）；捕获后随记录写入，
+                // 与请求/健康计数保持同一记录、同一窗口口径
+                if (chunk && chunk.type === 'usage' && chunk.usage && typeof chunk.usage === 'object')
+                    lastUsage = chunk.usage;
                 if (chunk === undefined)
                     throw { code: 'STREAM_CLOSED', message: 'channel stream ended without a terminal chunk' };
                 if (!started) {
@@ -355,11 +373,11 @@ export function apply(ctx) {
                         const reason = chunk.reason || {};
                         // 引擎提前终止的内层流不会被全局拦截器完整排水记账，这里自行记录
                         if (isSuccessReason(reason)) {
-                            recordHealth(cand.provider, cand, { ok: false, ttftMs: null, latencyMs: null, code: 'EMPTY_RESPONSE' });
+                            recordHealth(cand.provider, cand, { ok: false, ttftMs: null, latencyMs: null, code: 'EMPTY_RESPONSE', usage: lastUsage });
                             throw { code: 'EMPTY_RESPONSE', message: 'model returned a completed response with no content' };
                         }
                         const preCode = (reason.failure && reason.failure.code) || 'STREAM_ERROR';
-                        recordHealth(cand.provider, cand, { ok: false, ttftMs: null, latencyMs: null, code: preCode });
+                        recordHealth(cand.provider, cand, { ok: false, ttftMs: null, latencyMs: null, code: preCode, usage: lastUsage });
                         throw { code: preCode, message: (reason.failure && reason.failure.message) || 'candidate stream failed' };
                     }
                     else {
@@ -370,14 +388,14 @@ export function apply(ctx) {
                     if (isTerminalChunk(chunk)) {
                         const reason = chunk.reason || {};
                         if (isSuccessReason(reason)) {
-                            recordHealth(cand.provider, cand, { ok: true, ttftMs, latencyMs: Date.now() - attemptStart, code: null });
+                            recordHealth(cand.provider, cand, { ok: true, ttftMs, latencyMs: Date.now() - attemptStart, code: null, usage: lastUsage });
                             yield chunk;
                             return;
                         }
                         // 内容已向下游输出：绝不能再下发该失败终止块（否则出现 finish 后继续输出/双 finish），
                         // 改为抛错并标记 emitted，由组层直接终结本次请求
                         const midCode = (reason.failure && reason.failure.code) || 'STREAM_ERROR';
-                        recordHealth(cand.provider, cand, { ok: false, ttftMs, latencyMs: null, code: midCode });
+                        recordHealth(cand.provider, cand, { ok: false, ttftMs, latencyMs: null, code: midCode, usage: lastUsage });
                         throw { code: midCode, message: (reason.failure && reason.failure.message) || 'candidate stream failed mid-stream' };
                     }
                     yield chunk;
@@ -389,7 +407,7 @@ export function apply(ctx) {
             if (started && err && typeof err === 'object')
                 err.emitted = true;
             if (err && err.code === 'TIMEOUT')
-                recordHealth(cand.provider, cand, { ok: false, ttftMs, latencyMs: null, code: 'TIMEOUT' });
+                recordHealth(cand.provider, cand, { ok: false, ttftMs, latencyMs: null, code: 'TIMEOUT', usage: lastUsage });
             throw err;
         }
     }
@@ -503,7 +521,7 @@ export function apply(ctx) {
     // ---------- 测速 ----------
     async function measureCandidate(cfg, cand, st) {
         const llm = ctx.llm;
-        const inner = llm.stream({ provider: cand.provider, model: cand.model, messages: [{ role: 'user', content: [{ type: 'text', text: st.prompt }] }], maxTokens: st.maxTokens });
+        const inner = llm.stream({ provider: cand.provider, model: cand.model, messages: [{ role: 'user', content: [{ type: 'text', text: st.prompt }] }], maxTokens: st.maxTokens, sessionId: 'mcm-speedtest-' + (st.nonce ?? Date.now()) });
         const start = Date.now();
         let ttft = null;
         const closeInner = async () => { try {
@@ -601,7 +619,10 @@ export function apply(ctx) {
             context: { contextWindow: cfg.virtualModel.contextWindow },
             defaultMaxTokens: cfg.virtualModel.maxTokens,
             inputModalities: cfg.virtualModel.input.slice(),
-            reasoning: levels.length > 0 ? { efforts: levels.map((l) => ({ id: l, name: l })), defaultEffort: 'medium' } : undefined,
+            // defaultEffort=max：原生 /model 弹窗对新模型自动填与列表展示都跟随该声明
+            // （此前 medium 导致新会话选组即 medium）；会话内显式档位由 selector 插件的
+            // 档位记忆层（modelDirectories 拦截）恢复
+            reasoning: levels.length > 0 ? { efforts: levels.map((l) => ({ id: l, name: l })), defaultEffort: 'max' } : undefined,
         };
     }
     const adapter = {
@@ -649,7 +670,7 @@ export function apply(ctx) {
     // ---------- 单模型真实请求测试（client 经 settings 总线下发，走 DSH 真实 llm.stream 链路） ----------
     async function runModelTest(provider, model, prompt, maxTokens) {
         const llm = ctx.llm;
-        const inner = llm.stream({ provider, model, messages: [{ role: 'user', content: [{ type: 'text', text: prompt || '你好' }] }], maxTokens: maxTokens || 512 });
+        const inner = llm.stream({ provider, model, messages: [{ role: 'user', content: [{ type: 'text', text: prompt || '你好' }] }], maxTokens: maxTokens || 512, sessionId: 'mcm-modeltest-' + Date.now() });
         const start = Date.now();
         let ttft = null;
         let text = '';
@@ -700,12 +721,29 @@ export function apply(ctx) {
         const last = next.lastTestHandledNonce || 0;
         if (!req || typeof req.provider !== 'string' || typeof req.model !== 'string' || typeof req.nonce !== 'number' || req.nonce === last)
             return;
-        settings.update(NS_HEALTH, { lastTestHandledNonce: req.nonce }).catch(() => { });
-        // 结果写入走 mutate path-ops 原子设置单 nonce：read-merge-write 整包 update 在
-        // 两个测试并发完成时会互相覆盖（读旧包→写入丢掉对方 nonce）；path-ops 对
-        // settings 队列中的 section 现势作用，不再依赖调用方快照
-        const setResult = (entry) => {
-            settings.mutate(NS_HEALTH, [{ op: 'set', path: ['testResults', String(req.nonce)], value: Object.assign({}, entry, { nonce: req.nonce, provider: req.provider, model: req.model }) }]).catch(() => { });
+        settings.update(NS_HEALTH, { lastTestHandledNonce: req.nonce }).catch((e) => console.error('[model-channel-manager] lastTestHandledNonce 写入失败:', e));
+        // 结果写入：首选 mutate path-ops 原子设置单 nonce（并发测试互不覆盖）。
+        // 实测踩坑（#21 同源）：部分运行时（rc.2 file provider）会静默拒绝 mutate——
+        // promise 正常 resolve 但条目未落盘。故写后回读校验，未落上则回退 update
+        // 合并写（现势整段 + 本条目），保证结果必然可被 client 轮询读到。
+        let mutateWorks = null;
+        const setResult = async (entry) => {
+            const key = String(req.nonce);
+            const value = Object.assign({}, entry, { nonce: req.nonce, provider: req.provider, model: req.model });
+            const cur = (bus && bus.healthScope ? bus.healthScope.get().testResults : null) || {};
+            if (mutateWorks !== false) {
+                try {
+                    await settings.mutate(NS_HEALTH, [{ op: 'set', path: ['testResults', key], value }]);
+                    const landed = ((bus && bus.healthScope ? bus.healthScope.get().testResults : null) || {})[key];
+                    if (landed) { mutateWorks = true; return; }
+                    mutateWorks = false;
+                    console.error('[model-channel-manager] testResults mutate 未生效，回退 update 合并写');
+                } catch (e) {
+                    mutateWorks = false;
+                    console.error('[model-channel-manager] testResults mutate 失败，回退 update 合并写:', e);
+                }
+            }
+            await settings.update(NS_HEALTH, { testResults: Object.assign({}, cur, { [key]: value }) }).catch((e) => console.error('[model-channel-manager] testResults update 兜底写入失败:', e));
         };
         // 修剪低频执行：只在条目数超限时砍到 50（不在每次写入时整包重写）
         const maybePrune = () => {
@@ -713,17 +751,23 @@ export function apply(ctx) {
             const entries = Object.entries(all);
             if (entries.length <= 50) return;
             const drop = entries.sort((a, b) => ((b[1] && b[1].finishedAt) || 0) - ((a[1] && a[1].finishedAt) || 0)).slice(50).map(([k]) => ({ op: 'unset', path: ['testResults', String(k)] }));
-            if (drop.length > 0)
-                settings.mutate(NS_HEALTH, drop).catch(() => { });
+            if (drop.length === 0) return;
+            if (mutateWorks === false) {
+                const kept = {};
+                for (const [k, v] of entries.slice(0, 50)) kept[k] = v;
+                settings.update(NS_HEALTH, { testResults: kept }).catch((e) => console.error('[model-channel-manager] testResults 修剪 update 失败:', e));
+                return;
+            }
+            settings.mutate(NS_HEALTH, drop).catch((e) => console.error('[model-channel-manager] testResults 修剪失败:', e));
         };
         const done = async (r) => {
             try {
-                setResult(Object.assign({}, r, { finishedAt: Date.now() }));
+                await setResult(Object.assign({}, r, { finishedAt: Date.now() }));
                 maybePrune();
             }
             catch (_e) { }
         };
-        setResult({ status: 'running', startedAt: Date.now() });
+        void setResult({ status: 'running', startedAt: Date.now() });
         runModelTest(req.provider, req.model, req.prompt, req.maxTokens).then(async (r) => {
             await done(Object.assign({ status: 'ok' }, r));
         }).catch(async (e) => {
@@ -800,6 +844,7 @@ export function apply(ctx) {
         let ttft = null;
         let lastError = null;
         let isSuccess = false;
+        let usage = null;
         // 用户主动中止不是渠道故障：AbortError / code ABORTED / signal 已 aborted
         // 三种形态都不进健康流水，否则污染成功率与 smart 键的 reliability 权重
         const isAbortLike = (err) => {
@@ -813,6 +858,9 @@ export function apply(ctx) {
         };
         try {
             for await (const chunk of next()) {
+                // 适配器在 finish 前发 usage 块（done/error 都带）；捕获后随记录写入
+                if (chunk && chunk.type === 'usage' && chunk.usage && typeof chunk.usage === 'object')
+                    usage = chunk.usage;
                 if (ttft === null && isContentChunk(chunk)) {
                     ttft = Date.now() - startTs;
                 }
@@ -835,6 +883,7 @@ export function apply(ctx) {
                     ttftMs: isSuccess ? ttft : null,
                     latencyMs: isSuccess ? latency : null,
                     code: isSuccess ? null : (lastError || 'UNKNOWN_TERMINAL'),
+                    usage,
                 });
             }
         } catch (err) {
@@ -843,6 +892,7 @@ export function apply(ctx) {
                 recordHealth(p, { provider: p, model: options.model }, {
                     ok: false,
                     code: (err && err.code) || (err && err.message) || 'EXCEPTION',
+                    usage,
                 });
             }
             throw err;