@dsh-plugins/dsh-llm-hub 1.3.2 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,80 @@
 
 本项目遵循 [Semantic Versioning](https://semver.org/lang/zh-CN/)。
 
+## [1.4.0] - 2026-09-26
+
+### 🔄 多账号 key 轮换：消除独立配置区域
+
+**用户反馈**：1.3.0 的 `keyPool[provider]` 独立区域是反模式 —— 配置与已有 `apiKeyEnv` 字段脱节，
+需要去一个「多账号 key 轮换」专属 UI 卡才能加第二把 key。**正确做法是让 `apiKeyEnv` 字段直接支持 string[]**——
+DSH 在同一个 provider 字段里多填几把 env 名就完事。
+
+#### 变更
+
+- **新增 `apiKeyEnv` 字段支持 string[]**：`['KEY_1', 'KEY_2', 'KEY_3']` 自动 round-robin。
+- **向后兼容**：旧 string 配置 `apiKeyEnv: 'KEY'` 完全不变。
+- **删除** `settings.dsh-llm-hub.keyPool[provider]` 独立配置区域 —— 1.3.0 引入，1.4.0 收回。
+- **删除** host 半 `keyPoolOf()` / `rotateKeyPool()` 函数 / `keyPoolIndex` / `keyPoolLastChosen` Map。
+- **删除** 路由 `GET /api/dsh-llm-hub/keypool/status`。
+- **删除** client 半 KeyPoolCard / slot `id: dsh-llm-hub-keypool` (order 73) / keyPool locale / keyPool CSS。
+- **保留** `runtimeMarks`（401/403/402/QUOTA_EXCEEDED 失败追踪）—— 失败 key 信息
+  合并进现有可用性看板。
+
+#### 配置示例
+
+```yaml
+llm-deepseek:
+  apiKeyEnv: DEEPSEEK_API_KEY          # 单 key（向后兼容）
+# 或
+llm-deepseek:
+  apiKeyEnv:                            # 多 key 轮换
+    - DEEPSEEK_API_KEY_1
+    - DEEPSEEK_API_KEY_2
+    - DEEPSEEK_API_KEY_3
+```
+
+#### 测试
+
+- **删** `test/host-keypool.test.mjs`（测的是已删的 `keyPoolOf/rotateKeyPool`）
+- **加** `test/host-multi-key.test.mjs`（9 条 case 覆盖 `pickRotatedEnv`）：
+  单 key / 多 key round-robin / 跨 provider 互不干扰 / 空数组 / undefined / null /
+  array 含空字符串 / 全空字符串 / 单元素数组
+- 测试总数 92 → 93
+
+#### 用户故事
+
+| 用户 | 之前（1.3.0） | 现在（1.4.0） |
+|---|---|---|
+| 「给 DeepSeek 加第二把 key」 | 跳到「多账号 key 轮换」独立区 | **同一个 DeepSeek 行的 apiKeyEnv 字段加一行** |
+| 「看现在用的是哪把 key」 | keyPool 卡看 | 健康看板（avail 卡）里 `runtimeMarks` 字段 |
+| 「不用 keyPool」 | 一行多余配置 | 完全没这个概念 |
+
+#### 内部
+
+- 新增 host 函数 `pickRotatedEnv(refs, provider)` —— 输入 string | string[]，返 `{ref, index, total}` 或 undefined。
+- 索引 `keyRotationIndex: Map<provider, number>` 模块级（per-provider 独立 round-robin）。
+- `connectionFacts` 三段解析顺序（向后兼容）：
+  1. `request.apiKey` 一次性覆盖
+  2. `section.apiKeyEnv` 是 string[] → round-robin 取下一个
+  3. `section.apiKeyEnv` 是 string → 旧的单 key 路径
+
+#### 不在 1.4.0 范围
+
+- **失败 key 自动跳过**：1.4.0 收集真实失败场景再加；现在失败 key 信息进 `runtimeMarks` 标记，下一轮探测可看到。
+- **(provider, model) 级轮换**：1.4.0 粒度仍是 provider 级；细化到 model 级的场景待评估（DeepSeek-chat 和 DeepSeek-reasoner 用不同 key 池的需求场景不明确）。
+
+## [1.3.3] - 2026-09-25
+
+### ✨ 订阅制配额可视化进度条与重置倒计时
+
+- **📊 订阅制可视化进度条胶囊（Subscription Quota Gauge）**：
+  - 参考 `claude-usage-statusline` 经典轨道式设计，在 Provider 卡片中引入高质感平滑迷你进度条；
+  - 动态三色渐变指示：`> 50%` 充裕翡翠绿（`#10b981`）、`15%~50%` 预警金黄（`#f59e0b`）、`<= 15%` 告急珊瑚红（`#ef4444`）；
+  - 同时支持主限额（如 MiniMax 5 小时滚动配额、智谱 5h 配额）与次级周限额的双重进度条并列展示；
+- **⏱️ 重置时刻与倒计时精准指示（Reset Time Tracking）**：
+  - 在配额进度条后实时标注重置时刻（如 `(15:40 重置)`），悬浮卡片提供完整余量与周期说明；
+  - 适配器底层自动解析服务端返回的 `current_interval_end_time` / `next_reset_time` / `expire_time` 真实重置时刻。
+
 ## [1.3.2] - 2026-09-24
 
 ### 🐛 修复与健壮性提升

package/README.md

@@ -302,41 +302,50 @@ key 形态：`provider/model`。provider 严格（要去 settings 段查），mo
 
 未配置 aliases 段时 UI 退回只显示 `model.id`，与没装本插件时一致。
 
-## 多账号 key 轮换（1.3.0 起）
+## 多账号 key 轮换（1.4.0 改设计）
 
-同 provider 配多把 key，每次解析连接时按 round-robin 选下一把（避免单把 key
-撞 rate limit / 配额上限）。**不**自动跳过失败 key —— 用户从 debug 卡看到「上次
-失败用的是 X」后，下次请求自然轮换过去；自动跳过失败 key 等 1.4 收集真实失败场景再加。
+### 设计动机
 
-配置（`settings.dsh-llm-hub.keyPool`）：
+**之前（1.3.0）**：`settings.dsh-llm-hub.keyPool[provider] = [{name, env}, ...]` 独立配置区域。
+**1.4.0 改**：用户反馈「何必要单独做一个区域」——`apiKeyEnv` 字段直接支持 string[]，
+DSH 在同一个 provider 字段里多填几把 env 名就完事，**不需要去任何新区域**。
+keyPool 概念 / 独立 slot / 独立 UI 卡 —— 全部删除。
+
+### 配置形态
 
 ```yaml
-dsh-llm-hub:
-  keyPool:
-    deepseek-official:
-      - name: primary
-        env: DEEPSEEK_API_KEY_1
-      - name: backup
-        env: DEEPSEEK_API_KEY_2
-      - name: rotated
-        env: DEEPSEEK_API_KEY_3
-    modelgo:
-      - name: '轮换 A'
-        env: MODELGO_KEY_1
-      - name: '轮换 B'
-        env: MODELGO_KEY_2
+llm-deepseek:
+  apiKeyEnv: DEEPSEEK_API_KEY          # 老写法：1 把 key（向后兼容）
+# 或
+llm-deepseek:
+  apiKeyEnv:                            # 新写法：多把 key 轮换
+    - DEEPSEEK_API_KEY_1
+    - DEEPSEEK_API_KEY_2
+    - DEEPSEEK_API_KEY_3
 ```
 
-每条 entry 是 `{ name, env }`：name 是人话（debug 用），env 是凭据引用的环境变量名。
-host 半直接 `process.env[ref]` 解出来 —— 不走 credentials 服务，因为这些 key
-多半不会进凭据库（轮换场景通常是测试 / 临时 key，手贴环境变量更简单）。
+**用户操作**：在 DSH 设置 → 模型 → DeepSeek 行的「API Key Env」字段，**多填几个 env 名**，
+DSH 自动 round-robin。其它流程（连接、探针、余额、统计）都不变。
+
+### 行为
+
+- **单 key**（string）：行为与 1.3.0 完全一致 —— `apiKeyEnv: 'DEEPSEEK_API_KEY'`。
+- **多 key**（string[]）：host 半**按 provider 维护 round-robin 索引**，每次解析连接取下一个。
+- **失败 key 不自动跳过** —— 下次请求自然轮换过去。失败信息进 `runtimeMarks`，
+  下次探针会标出来。**不**藏、不假装能用、不静默吞请求。
+- **向后兼容**：所有 1.3.x 之前的配置（单 key）继续工作。
+
+### 为什么删独立的"多账号 key 轮换"UI 卡
 
-向后兼容：未配 keyPool 段时走旧的 `apiKeyEnv` 单 key 路径，行为完全不变。显式
-覆盖（`request.apiKey`）绕过轮换直接用它，索引不动。
+1.4.0 之前有一个「多账号 key 轮换」独立 card（在 footer order 73）。**反模式**：
+- 用户故事是「我已经在 DeepSeek 那一行填过 env 名，再加几把就行」，不需要跳到任何新区域。
+- 独立区域让用户看不到**和自己已配 provider 的关联**，新人更难看懂。
+- UI 跟 source-of-truth（settings.yaml 的 `apiKeyEnv` 字段）分离 —— 两份真相。
 
-设置 → 模型 → 页脚 order 73 处的「多账号 key 轮换」卡：每行一个 provider +
-「N keys」元信息 + 当前轮到的 key 名（带 `#M / N · HH:MM:SS」的小标，鼠标悬停看 env 名）。
-**不**显示 apiKey 实际值。
+删了之后：
+- 用户在 ModelsSection 同一个 DeepSeek 行加 env 名 → 多 key 自动轮换
+- debug 信息统一进「健康看板」卡（跟 availability / latency 一起看）
+- 没有「我不知道去哪配置」这种认知成本
 
 ## 外部 harness 子代理（装了才出现）
 

package/lib/client.js

@@ -75,8 +75,6 @@ window.__ModuleLoader__.load({
 		const ROUTING_URL = '/api/dsh-llm-hub/routing/resolve'
 		/** 模型别名：把长 id 显示成短名（人话）。 */
 		const ALIASES_URL = '/api/dsh-llm-hub/aliases'
-		/** 多账号 key 轮换：debug 路由，看每个 provider 当前轮到哪个 key。 */
-		const KEYPOOL_URL = '/api/dsh-llm-hub/keypool/status'
 
 		const LOCALES = {
 			zh: {
@@ -158,10 +156,6 @@ window.__ModuleLoader__.load({
 				routingNoRecommendation: '全部不可用',
 				routingLoading: '路由解析中…',
 				aliasesMissing: '尚未配置别名',
-				keypoolTitle: '多账号 key 轮换',
-				keypoolRound: 'round-robin',
-				keypoolActiveTip: '当前优先使用',
-				keypoolNextTip: '下次轮换目标',
 				heroTitle: 'LLM 矩阵概览',
 				heroProviders: '活跃提供方',
 				heroModels: '可用模型',
@@ -273,10 +267,6 @@ window.__ModuleLoader__.load({
 				routingNoRecommendation: 'none available',
 				routingLoading: 'resolving routing…',
 				aliasesMissing: 'no aliases configured',
-				keypoolTitle: 'Key rotation',
-				keypoolRound: 'round-robin',
-				keypoolActiveTip: 'Currently active',
-				keypoolNextTip: 'Next target',
 				heroTitle: 'LLM Matrix Overview',
 				heroProviders: 'Active providers',
 				heroModels: 'Models',
@@ -510,22 +500,6 @@ window.__ModuleLoader__.load({
 				'.dsh-llm-hub-routing__name{color:var(--dsw-alias-label-primary);font-weight:600}',
 				'.dsh-llm-hub-routing__suggestion{color:var(--dsw-alias-state-warn-primary);padding-top:2px}',
 				'.dsh-llm-hub-routing__reason{color:var(--dsw-alias-state-error-primary);padding-top:2px}',
-				// 多账号 key 轮换
-				'.dsh-llm-hub-keypool{display:flex;flex-direction:column;gap:6px;margin-top:10px;',
-				'padding:8px 10px;border-radius:6px;',
-				'border:.5px solid var(--dsw-alias-border-l1);background:transparent;',
-				'font-size:11.5px;line-height:16px;color:var(--dsw-alias-label-secondary)}',
-				'.dsh-llm-hub-keypool__head{display:flex;align-items:center;justify-content:space-between;gap:8px;flex-wrap:wrap}',
-				'.dsh-llm-hub-keypool__title{color:var(--dsw-alias-label-primary);font-weight:600;display:inline-flex;align-items:center;gap:5px}',
-				'.dsh-llm-hub-keypool__rows{display:flex;flex-direction:column;gap:3px}',
-				'.dsh-llm-hub-keypool__row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:4px 6px;border-radius:4px;background:var(--dsw-alias-bg-layer-2,#1c1f24);border:.5px solid var(--dsw-alias-border-l1)}',
-				'.dsh-llm-hub-keypool__row.is-active{border-color:var(--dsw-alias-state-success-primary,#10b981);box-shadow:0 0 8px rgba(16,185,129,.15)}',
-				'.dsh-llm-hub-keypool__name{color:var(--dsw-alias-label-primary);font-weight:600;min-width:120px;font-family:ui-monospace,SFMono-Regular,monospace}',
-				'.dsh-llm-hub-keypool__meta{font-size:10.5px;opacity:.7}',
-				'.dsh-llm-hub-keypool__chosen{display:flex;align-items:baseline;gap:4px;',
-				'color:var(--dsw-alias-label-primary)}',
-				'.dsh-llm-hub-keypool__chosen small{color:var(--dsw-alias-label-secondary);opacity:.75;font-size:10.5px}',
-				'.dsh-llm-hub-keypool__pending{color:var(--dsw-alias-label-secondary);opacity:.6}',
 				// Hero 全景统计大横条
 				'.dsh-llm-hub-hero{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:6px;margin:12px 0 6px 0}',
 				'.dsh-llm-hub-hero__card{display:flex;flex-direction:column;gap:2px;padding:8px 10px;border-radius:6px;border:.5px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-2,rgba(255,255,255,.02));backdrop-filter:blur(6px)}',
@@ -547,6 +521,18 @@ window.__ModuleLoader__.load({
 				'.dsh-llm-hub-latency-badge.is-fast{background:rgba(16,185,129,.08);color:var(--dsw-alias-state-success-primary,#10b981);border:.5px solid rgba(16,185,129,.2)}',
 				'.dsh-llm-hub-latency-badge.is-normal{background:rgba(234,179,8,.08);color:var(--dsw-alias-state-warn-primary,#eab308);border:.5px solid rgba(234,179,8,.2)}',
 				'.dsh-llm-hub-latency-badge.is-slow{background:rgba(239,68,68,.08);color:var(--dsw-alias-state-error-primary,#ef4444);border:.5px solid rgba(239,68,68,.2)}',
+				// 订阅制配额可视化进度条与重置倒计时（参考 claude-usage-statusline 规范）
+				'.dsh-llm-hub-quota-group{display:inline-flex;align-items:center;gap:6px;flex-wrap:wrap;vertical-align:middle}',
+				'.dsh-llm-hub-quota-bar{display:inline-flex;align-items:center;gap:4.5px;padding:1.5px 6px;border-radius:4px;background:var(--dsw-alias-bg-layer-2,rgba(255,255,255,.03));border:.5px solid var(--dsw-alias-border-l1,rgba(255,255,255,.08));font-size:10.5px;line-height:1;transition:all .15s ease}',
+				'.dsh-llm-hub-quota-bar:hover{border-color:var(--dsw-alias-brand-primary,rgba(59,130,246,.4));background:var(--dsw-alias-bg-layer-3,rgba(255,255,255,.06))}',
+				'.dsh-llm-hub-quota-label{font-weight:600;color:var(--dsw-alias-label-primary);font-size:10px}',
+				'.dsh-llm-hub-quota-track{width:46px;height:4.5px;border-radius:2.5px;background:rgba(255,255,255,.12);overflow:hidden;position:relative;display:inline-block;vertical-align:middle}',
+				'.dsh-llm-hub-quota-fill{height:100%;border-radius:2.5px;display:block;transition:width .3s cubic-bezier(0.4,0,0.2,1)}',
+				'.dsh-llm-hub-quota-fill.is-high{background:linear-gradient(90deg,#10b981,#34d399)}',
+				'.dsh-llm-hub-quota-fill.is-mid{background:linear-gradient(90deg,#f59e0b,#fbbf24)}',
+				'.dsh-llm-hub-quota-fill.is-low{background:linear-gradient(90deg,#ef4444,#f87171)}',
+				'.dsh-llm-hub-quota-pct{font-variant-numeric:tabular-nums;font-weight:600;color:var(--dsw-alias-label-primary);font-size:10.5px}',
+				'.dsh-llm-hub-quota-time{font-size:9.5px;color:var(--dsw-alias-label-secondary);opacity:.8;font-variant-numeric:tabular-nums;display:inline-flex;align-items:center;margin-left:1px}',
 				// Webkubor 插件全家桶互导矩阵
 				'.dsh-suite-dock{margin-top:14px;padding:14px 16px;background:var(--dsw-alias-bg-layer-2,rgba(255,255,255,0.03));border:1px solid var(--dsw-alias-border-l1,rgba(255,255,255,0.08));border-radius:10px;backdrop-filter:blur(10px)}',
 				'.dsh-suite-head{display:flex;align-items:center;justify-content:space-between;margin-bottom:10px;flex-wrap:wrap;gap:8px}',
@@ -861,14 +847,44 @@ window.__ModuleLoader__.load({
 				return `${t('balance')} ${symbol}${first.amount}${voucher}`
 			}
 			const meaning = balance.meaning === 'used' ? t('used') : t('remain')
-			const parts = []
+			const isUsed = balance.meaning === 'used'
+			const bars = []
 			for (const item of items.slice(0, 2)) {
-				let piece = `${item.label} ${meaning} ${item.percent}%`
-				if (typeof item.weeklyPercent === 'number') piece += ` · ${t('week')} ${meaning} ${item.weeklyPercent}%`
-				parts.push(piece)
+				const remainPct = isUsed ? Math.max(0, 100 - (item.percent ?? 0)) : (item.percent ?? 0)
+				const fillPct = Math.min(Math.max(remainPct, 0), 100)
+				const levelClass = fillPct > 50 ? 'is-high' : (fillPct > 20 ? 'is-mid' : 'is-low')
+				const labelText = item.label || '5h'
+				const resetTimeNote = item.resetsAt ? `(${item.resetsAt} 重置)` : ''
+				bars.push(h('span', {
+					key: labelText,
+					className: 'dsh-llm-hub-quota-bar',
+					title: `${labelText} ${meaning} ${item.percent}%${resetTimeNote ? ` · ${resetTimeNote}` : ''}`
+				},
+					h('span', { className: 'dsh-llm-hub-quota-label' }, labelText),
+					h('span', { className: 'dsh-llm-hub-quota-track' },
+						h('span', { className: `dsh-llm-hub-quota-fill ${levelClass}`, style: { width: `${fillPct}%` } })
+					),
+					h('span', { className: 'dsh-llm-hub-quota-pct' }, `${item.percent}%`),
+					resetTimeNote ? h('span', { className: 'dsh-llm-hub-quota-time' }, resetTimeNote) : null
+				))
+				if (typeof item.weeklyPercent === 'number') {
+					const weeklyRemain = isUsed ? Math.max(0, 100 - item.weeklyPercent) : item.weeklyPercent
+					const weeklyFill = Math.min(Math.max(weeklyRemain, 0), 100)
+					const weeklyClass = weeklyFill > 50 ? 'is-high' : (weeklyFill > 20 ? 'is-mid' : 'is-low')
+					bars.push(h('span', {
+						key: 'week',
+						className: 'dsh-llm-hub-quota-bar',
+						title: `${t('week')} ${meaning} ${item.weeklyPercent}%`
+					},
+						h('span', { className: 'dsh-llm-hub-quota-label' }, t('week')),
+						h('span', { className: 'dsh-llm-hub-quota-track' },
+							h('span', { className: `dsh-llm-hub-quota-fill ${weeklyClass}`, style: { width: `${weeklyFill}%` } })
+						),
+						h('span', { className: 'dsh-llm-hub-quota-pct' }, `${item.weeklyPercent}%`)
+					))
+				}
 			}
-			const level = typeof balance.level === 'string' && balance.level.length > 0 ? `${balance.level} · ` : ''
-			return `${t('planQuota')} ${level}${parts.join(' / ')}`
+			return h('span', { className: 'dsh-llm-hub-quota-group' }, bars)
 		}
 
 		/**
@@ -1378,50 +1394,6 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 多账号 key 轮换卡：展示当前轮换池状态与活跃 Key
-		 */
-		function KeyPoolCard(props) {
-			const t = typeof props.t === 'function' ? props.t : fallbackT
-			const [report, setReport] = React.useState(null)
-			React.useEffect(() => {
-				let alive = true
-				fetch(KEYPOOL_URL, { headers: { accept: 'application/json' } })
-					.then((res) => res.json())
-					.then((body) => { if (alive) setReport(body !== null && typeof body === 'object' ? body : null) })
-					.catch(() => { if (alive) setReport(null) })
-				return () => { alive = false }
-			}, [])
-			if (report === null) return null
-			const providers = Array.isArray(report.providers) ? report.providers : []
-			if (providers.length === 0) return null
-			ensureStyle()
-			const formatTime = (ms) => {
-				if (typeof ms !== 'number' || ms <= 0) return '—'
-				const d = new Date(ms)
-				return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`
-			}
-			const rows = providers.map((entry) => {
-				const chosen = entry.lastChosen
-				const isActive = chosen !== null
-				return h('div', {
-					key: entry.provider,
-					className: 'dsh-llm-hub-keypool__row' + (isActive ? ' is-active' : '')
-				},
-					h('span', { className: 'dsh-llm-hub-health-dot ' + (isActive ? 'is-ok' : '') }),
-					h('span', { className: 'dsh-llm-hub-keypool__name' }, entry.provider),
-					h('span', { className: 'dsh-llm-hub-keypool__meta' }, `${entry.total} keys`),
-					chosen === null
-						? h('span', { className: 'dsh-llm-hub-keypool__pending' }, '—')
-						: h('span', { className: 'dsh-llm-hub-keypool__chosen' },
-							h('span', null, chosen.name),
-							h('small', null, ` #${chosen.index + 1} / ${entry.total} · ${formatTime(chosen.at)}`)))
-			})
-			return h('div', { className: 'dsh-llm-hub-keypool' },
-				h('div', { className: 'dsh-llm-hub-keypool__head' },
-					h('span', { className: 'dsh-llm-hub-keypool__title' }, '🔄 ' + t('keypoolTitle')),
-					h('span', { className: 'dsh-llm-hub-subtext' }, t('keypoolRound'))),
-				h('div', { className: 'dsh-llm-hub-keypool__rows' }, rows))
-		}
 
 		/**
 		 * 当前路由卡 —— 显示用户当前激活的 (provider, model) + 状态 + 推荐的 fallback。
@@ -1951,13 +1923,6 @@ window.__ModuleLoader__.load({
 				locale: NS,
 				inject: () => ({ t, availability })
 			}, HealthCard))
-			ctx.slots.inject('settings.models.footer', () => ctx.slots.register({
-				name: 'settings.models.footer',
-				id: 'dsh-llm-hub-keypool',
-				order: 73,
-				locale: NS,
-				inject: () => ({ t })
-			}, KeyPoolCard))
 			ctx.slots.inject('settings.models.footer', () => ctx.slots.register({
 				name: 'settings.models.footer',
 				id: 'dsh-llm-hub-routing',

package/lib/index.js

@@ -180,22 +180,27 @@ const ROUTING_RESOLVE_PATH = '/api/dsh-llm-hub/routing/resolve'
 /** 模型别名：客户端渲染 model id 时显示短名（典型场景：deepseek-reasoner → 推理）。 */
 const ALIASES_PATH = '/api/dsh-llm-hub/aliases'
 /**
- * 多账号 key 轮换：settings.dsh-llm-hub.keyPool[provider] 是 entry 数组。
+ * 1.4.0 多 Key 轮换纯函数：支持 string（单 key）或 string[]（多 key round-robin）。
  *
- * 设计取舍：
- *   - **向后兼容**：未配 keyPool 段时直接走原 apiKeyEnv 单 key 路径，行为完全
- *     不变；现有 80 个测试不破。
- *   - **round-robin**（非失败感知）：每次解析按索引取下一个 entry；不加锁、不跨
- *     session 持久化（重启会从 0 开始）。失败的 key 不会自动跳过 —— 用户从
- *     debug 路由看到「上次失败的是 X」，下次请求自然轮换过去。这是 1.x 的轻量方案，
- *     真要自动跳过失败 key 等 1.1 收集了真实失败场景再加。
- *   - **不覆盖显式 key**：request.apiKey 是一次性覆盖（发现草稿用的），绕过
- *     轮换直接用它；轮换索引不动。
- *   - **provider 范围**：DeepSeek 官方直连用 NS = 'llm-deepseek' 作为 key，pi-ai
- *     provider 用 provider 自己的 id（modelgo / minimax ...）；keyPool 段里
- *     直接用 provider id 作 key。
+ * @param {string|string[]|undefined} refs - 单 Key 或多 Key 环境变量名数组
+ * @param {string} provider - Provider 标识（用于维护独立索引）
+ * @param {Map<string, number>} [stateMap] - 轮换游标存储
+ * @returns {{ ref: string, index: number, total: number } | undefined}
  */
-const KEYPOOL_STATUS_PATH = '/api/dsh-llm-hub/keypool/status'
+export function pickRotatedEnv(refs, provider, stateMap) {
+	if (typeof refs === 'string' && refs.length > 0) {
+		return { ref: refs, index: 0, total: 1 }
+	}
+	if (Array.isArray(refs)) {
+		const list = refs.filter((r) => typeof r === 'string' && r.trim().length > 0)
+		if (list.length === 0) return undefined
+		const current = stateMap ? (stateMap.get(provider) ?? 0) : 0
+		const index = current % list.length
+		if (stateMap) stateMap.set(provider, (current + 1) % list.length)
+		return { ref: list[index], index, total: list.length }
+	}
+	return undefined
+}
 /** 路由配置从 settings 哪一段读 —— 顶层 dsh-llm-hub 段下，与 warning 同级。 */
 const ROUTING_KEY = 'routing'
 /** 探针结论的保鲜期；过期后下次读取顺手在后台重探，不阻塞下拉。 */
@@ -522,56 +527,23 @@ export function apply(ctx) {
 	/**
 	 * 读 `settings.dsh-llm-hub.keyPool[provider]` 段。
 	 *
-	 * 每条 entry 是 `{ name, env }` —— name 是人话（debug 用），env 是
-	 * 凭据服务引用的环境变量名；后者用 `process.env[ref]` 直接读，**不**走
-	 * credentials 服务，因为这些 key 多半不会进凭据库（轮换场景通常是
-	 * 测试 / 临时 key，手贴环境变量更简单）。
-	 *
-	 * @returns 规范化后的 entry 数组（缺 name 或 env 的过滤掉）；没配或非数组返 `undefined`。
-	 */
-	const keyPoolOf = (provider) => {
-		const section = sectionOf() ?? {}
-		const raw = section.keyPool
-		if (raw === null || typeof raw !== 'object') return undefined
-		const entries = raw[provider]
-		if (!Array.isArray(entries)) return undefined
-		const out = []
-		for (const entry of entries) {
-			if (entry === null || typeof entry !== 'object') continue
-			const name = typeof entry.name === 'string' && entry.name.trim().length > 0 ? entry.name.trim() : undefined
-			const env = typeof entry.env === 'string' && entry.env.trim().length > 0 ? entry.env.trim() : undefined
-			if (env === undefined) continue
-			out.push({ name: name ?? env, env })
-		}
-		return out.length > 0 ? out : undefined
-	}
-
 	/**
-	 * 给一个 provider 取轮换到的下一个 entry + 索引推进 +1。
-	 * @returns `{ entry, index }` —— entry 是 { name, env }；index 是 0-based 位置。
+	 * 多 Key 自动轮换索引 —— per provider 维护独立的自增游标。
+	 * @type {Map<string, number>}
 	 */
-	const rotateKeyPool = (provider) => {
-		const entries = keyPoolOf(provider)
-		if (entries === undefined) return undefined
-		const current = keyPoolIndex.current.get(provider) ?? 0
-		const index = current % entries.length
-		keyPoolIndex.current.set(provider, (current + 1) % entries.length)
-		const entry = entries[index]
-		keyPoolLastChosen.current.set(provider, { entry, index, at: Date.now() })
-		return { entry, index }
-	}
+	const keyRotationIndex = new Map()
 
 	/**
 	 * 解析本次调用要用的连接事实。
 	 *
 	 * 解析顺序（向后兼容）：
 	 *   1) request.apiKey 一次性覆盖 —— 跳过轮换、原样返回（不污染索引）
-	 *   2) keyPool[provider] 命中 → round-robin 取下一个，env var 解析密钥
-	 *   3) 旧的 `apiKeyEnv` 单 key 路径（行为完全不变）
+	 *   2) section.apiKeyEnv 是 string[] → 按 provider 轮换取下一个 ref，
+	 *      再走 credentials 服务或 process.env 解析密钥
+	 *   3) section.apiKeyEnv 是 string → 原单 key 路径（行为完全不变）
 	 *
-	 * 返 ref 不变 —— 客户端拿到的是凭据引用（keyPool 的 env 名），实际值是
-	 * `process.env[ref]` 解出来的字符串；下游诊断（探针 / 余额路由）能继续
-	 * 看到当前用的是哪个 env。
+	 * 返 ref 不变 —— 客户端拿到的是凭据引用；下游诊断（探针 / 余额路由）
+	 * 能继续看到当前用的是哪个 env。
 	 * @param request - 可选的一次性覆盖（发现草稿会带 baseURL / apiKey / provider）。
 	 * @returns baseURL、凭据引用与可用密钥。
 	 */
@@ -590,14 +562,10 @@ export function apply(ctx) {
 			return { baseURL, ref, apiKey: explicit }
 		}
 		const providerKey = label(request.provider) ?? DEEPSEEK_PROVIDER
-		const pool = rotateKeyPool(providerKey)
-		if (pool !== undefined) {
-			const apiKey = label(process.env[pool.entry.env])
-			if (apiKey !== undefined) return { baseURL, ref: pool.entry.env, apiKey }
-			// 配了 keyPool 但 env var 没值 —— 退回旧单 key 路径，不让 keyPool
-			// 静默吞掉请求。
-		}
-		const ref = label(request.apiKeyEnv, section.apiKeyEnv) ?? DEFAULT_API_KEY_ENV
+		const picked = pickRotatedEnv(section.apiKeyEnv, providerKey, keyRotationIndex)
+		const ref = picked === undefined
+			? (label(request.apiKeyEnv, section.apiKeyEnv) ?? DEFAULT_API_KEY_ENV)
+			: picked.ref
 		let apiKey
 		const credentials = ctx.get('credentials')
 		if (credentials !== undefined) {
@@ -923,10 +891,21 @@ export function apply(ctx) {
 					if (row === null || typeof row !== 'object') continue
 					const percent = percentage(row.current_interval_remaining_percent)
 					if (percent === undefined) continue
+					let resetsAt = undefined
+					const rawTime = row.current_interval_end_time ?? row.end_time ?? row.reset_time
+					if (typeof rawTime === 'number' && rawTime > 0) {
+						const date = new Date(rawTime > 1e11 ? rawTime : rawTime * 1000)
+						if (!isNaN(date.getTime())) {
+							resetsAt = `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`
+						}
+					} else if (typeof rawTime === 'string' && rawTime.trim() !== '') {
+						resetsAt = rawTime.trim()
+					}
 					items.push({
 						label: label(row.model_name) ?? 'plan',
 						percent,
-						weeklyPercent: percentage(row.current_weekly_remaining_percent)
+						weeklyPercent: percentage(row.current_weekly_remaining_percent),
+						resetsAt
 					})
 				}
 				return { items }
@@ -953,7 +932,17 @@ export function apply(ctx) {
 					if (tier === undefined) continue
 					const percent = percentage(lim.percentage)
 					if (percent === undefined) continue
-					items.push({ label: tier, percent })
+					let resetsAt = undefined
+					const rawTime = lim.reset_time ?? lim.next_reset_time ?? body?.data?.expire_time
+					if (typeof rawTime === 'number' && rawTime > 0) {
+						const date = new Date(rawTime > 1e11 ? rawTime : rawTime * 1000)
+						if (!isNaN(date.getTime())) {
+							resetsAt = `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`
+						}
+					} else if (typeof rawTime === 'string' && rawTime.trim() !== '') {
+						resetsAt = rawTime.trim()
+					}
+					items.push({ label: tier, percent, resetsAt })
 				}
 				return { level: label(body?.data?.level), items }
 			}
@@ -1841,10 +1830,6 @@ export function apply(ctx) {
 	// 对照官方价目表，CSV 导出（`GET /api/dsh-llm-hub/usage/export`）已经做了。
 	const usageTable = { current: null }
 	const usageReady = { current: false }
-	// 多账号 key 轮换：每个 provider 一个 round-robin 索引。重启后归零，跨 session
-	// 不持久化 —— 失败的 key 不会自动跳过，下次自然轮换过去（看 debug 路由查清）。
-	const keyPoolIndex = { current: new Map() }
-	const keyPoolLastChosen = { current: new Map() }
 	const recordUsage = (entry) => {
 		const table = usageTable.current
 		if (table === null) return
@@ -2371,55 +2356,6 @@ export function apply(ctx) {
 		}
 	}), 'dsh-llm-hub: aliases route')
 
-	/**
-	 * KeyPool 调试路由 —— 让 client 看到每个 provider 当前轮到了哪个 entry。
-	 * 不暴露 apiKey 实际值（只有 name + env 名）；401 / 403 类失败时用户从
-	 * 这里看「轮到哪个 env 上次失败」，下次请求轮换过去。
-	 */
-	const keyPoolDebugPayload = () => {
-		const section = sectionOf() ?? {}
-		const raw = section.keyPool
-		const pool = raw !== null && typeof raw === 'object' ? raw : {}
-		const providers = []
-		for (const [provider, entries] of Object.entries(pool)) {
-			if (!Array.isArray(entries)) continue
-			const lastChosen = keyPoolLastChosen.current.get(provider)
-			providers.push({
-				provider,
-				total: entries.length,
-				lastChosen: lastChosen === undefined ? null : {
-					name: lastChosen.entry.name,
-					env: lastChosen.entry.env,
-					index: lastChosen.index,
-					at: lastChosen.at
-				},
-				nextIndex: keyPoolIndex.current.get(provider) ?? 0
-			})
-		}
-		return { ok: true, providers }
-	}
-
-	ctx.effect(() => ctx.webServer.register({
-		kind: 'exact',
-		path: KEYPOOL_STATUS_PATH,
-		handler: (request, response) => {
-			if (request.method !== 'GET' && request.method !== 'HEAD') {
-				response.writeHead(405, { allow: 'GET, HEAD' })
-				response.end()
-				return
-			}
-			if (!sameOrigin(request)) {
-				sendJson(response, 403, { ok: false, error: 'cross-origin reads are refused' })
-				return
-			}
-			if (request.method === 'HEAD') {
-				response.writeHead(200, { 'content-type': 'application/json; charset=utf-8' })
-				response.end()
-				return
-			}
-			sendJson(response, 200, keyPoolDebugPayload())
-		}
-	}), 'dsh-llm-hub: keypool status route')
 
 	// ── harness 子代理 ────────────────────────────────────────────────────────
 

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@dsh-plugins/dsh-llm-hub",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "DSH 模型管理层：网关可达性探测、模型目录拉取、DeepSeek + MiniMax/智谱/Moonshot/StepFun 余额与配额、本月用量统计、余额预警、Provider 健康看板，再把本机装好的 codex / claude / agy 注册成子代理（装了才出现）。零运行时依赖，不改动 DSH 安装。",
   "type": "module",
   "main": "lib/index.js",
+  "types": "./types/index.d.ts",
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "default": "./lib/index.js"
     },
     "./client": {
@@ -26,7 +28,7 @@
     }
   },
   "scripts": {
-    "deploy": "rsync -av --delete lib/ ~/.dsh/profiles/web/node_modules/@dsh-plugins/dsh-llm-hub/lib/ && rsync -av package.json cordis.patch.yml README.md README.en.md LICENSE ~/.dsh/profiles/web/node_modules/@dsh-plugins/dsh-llm-hub/",
+    "deploy": "rsync -av --delete lib/ ~/.dsh/profiles/web/node_modules/@dsh-plugins/dsh-llm-hub/lib/ && rsync -av types package.json cordis.patch.yml README.md README.en.md LICENSE ~/.dsh/profiles/web/node_modules/@dsh-plugins/dsh-llm-hub/",
     "preview": "npm run deploy && open http://127.0.0.1:3080",
     "check": "for f in lib/*.js; do node --check \"$f\" || exit 1; done",
     "test": "node --test"
@@ -38,14 +40,21 @@
     "deepseek",
     "model-discovery",
     "balance",
-    "llm",
-    "model-availability",
-    "availability",
+    "quota",
+    "rate-limit",
+    "usage",
+    "tokens",
+    "cost",
+    "dashboard",
+    "routing",
+    "failover",
+    "key-rotation",
+    "api-keys",
+    "harness",
     "subagent",
     "codex",
-    "claude-code",
-    "antigravity",
-    "harness"
+    "claude",
+    "agy"
   ],
   "license": "MIT",
   "repository": {
@@ -65,6 +74,7 @@
     "README.en.md",
     "README.md",
     "cordis.patch.yml",
-    "lib"
+    "lib",
+    "types"
   ]
 }

package/types/globals.d.ts

@@ -0,0 +1,3 @@
+declare module '@deepseek-ai/dsh-subagent'
+declare module '@deepseek-ai/dsh-session'
+declare module '@deepseek-ai/dsh-storage-domain'

package/types/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @dsh-plugins/dsh-llm-hub TypeScript Definitions
+ */
+
+export const name: 'dsh-llm-hub'
+export const inject: string[]
+
+export const MAX_RESPONSE_BYTES: number
+export const AVAILABILITY_TTL_MS: number
+export const STUCK_PROBE_MS: number
+export const REQUEST_TIMEOUT_MS: number
+
+export interface UsageRecord {
+	id: string
+	provider: string
+	model: string
+	month: string
+	tokensIn: number
+	tokensOut: number
+	tokensTotal: number
+	costUsd: number
+	calls: number
+	updatedAt: number
+}
+
+export const UsageRecordSchema: {
+	readonly id: 'string'
+	readonly provider: 'string'
+	readonly model: 'string'
+	readonly month: 'string'
+	readonly tokensIn: 'number'
+	readonly tokensOut: 'number'
+	readonly tokensTotal: 'number'
+	readonly costUsd: 'number'
+	readonly calls: 'number'
+	readonly updatedAt: 'number'
+}
+
+export function normalizeUsageForTest(usage: any): {
+	tokensIn: number
+	tokensOut: number
+	tokensTotal: number
+}
+
+export function recordUsageInto(table: any, entry: any): void
+export function readBounded(response: any, url: string): Promise<string>
+export function maskKey(key: string | null | undefined): string
+
+export interface RotatedEnvResult {
+	ref: string
+	index: number
+	total: number
+}
+
+export function pickRotatedEnv(
+	refs: string | string[] | undefined,
+	provider: string,
+	stateMap?: Map<string, number>
+): RotatedEnvResult | undefined
+
+export function apply(ctx: any): void
+