@jxgame2020/dsh-token-quota 0.1.4 → 0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jxgame2020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,34 +1,38 @@
 # @jxgame2020/dsh-token-quota
 
-DeepSeek Harness 的**每日按模型 Token 限额**插件：后端按模型累计当日 token 用量并持久化、
-达到上限时拦截请求；前端在 Web UI 右侧提供浮窗，实时显示每个被监控模型的
-「实际/上限」，可对每个模型单独设置限额，满额时一键或自动切换模型。
+DeepSeek Harness 的**每日按模型 Token 限额**插件：后端按模型累计当日 token 用量并持久化、达到上限时拦截请求；前端在 Web UI 右侧提供浮窗，实时显示每个被监控模型的「实际/上限」，可对每个模型单独设置限额，满额时一键或自动切换模型。
 
-对 DSH 核心仓库**零改动**：不修改任何核心文件、不挂载官方 bundle、不依赖转发事件
-白名单；数据通过插件自有的 HTTP 路由（`GET /token-quota`）轮询读取，配置通过
-settings 的 `token-quota` 命名空间读写。
+A daily per-model token quota plugin for the DeepSeek Harness: the host counts each model's token usage for the day (persisted), blocks requests once a cap is reached, and a floating panel on the right side of the Web UI shows live usage/limit per monitored model, lets you set per-model caps, and switches models in one click or automatically when a model is full.
 
-## 功能
+对 DSH 核心仓库**零改动**：不修改任何核心文件、不挂载官方 bundle、不依赖转发事件白名单；数据通过插件自有的 HTTP 路由（`GET /token-quota`）轮询读取，配置通过 settings 的 `token-quota` 命名空间读写。
 
-- **按模型独立计数**：输入 + 输出 + 缓存 token 全部计入当日用量；重启不丢
-  （持久化到 `$DSH_HOME/token-quota.json`）。
+Zero changes to the DSH core repo: no core file is modified, no official bundle is mounted, and no forwarded-event allowlist is required. The panel polls a plugin-owned HTTP route (`GET /token-quota`), and configuration lives in the `token-quota` settings namespace.
+
+## 功能 / Features
+
+- **按模型独立计数**：输入 + 输出 + 缓存 token 全部计入当日用量；重启不丢（持久化到 `$DSH_HOME/token-quota.json`）。
+  **Per-model counting**: input + output + cache tokens all count toward the daily usage, persisted to `$DSH_HOME/token-quota.json` across restarts.
 - **硬拦截**：达到上限后请求直接停止并提示切换，不会继续消耗额度。
-- **满额策略**（四选一，面板设置里切换，即时生效）：
-  - 停止请求并提示
-  - 自动切换到其它已监控且未满的限额模型
-  - 自动切换到其它任意可用模型（含非限额）
-  - 自动切换（优先非限额，其次未监控）
-- **每日自动重置**：默认本机时区午夜；可在设置里改为任意时区（UTC−12 ~ +14）
-  与时刻（0:00–23:55），到点清零当日计数并归档用量日志。
+  **Hard enforcement**: once a cap is hit, requests are stopped and you are prompted to switch — no extra tokens are spent.
+- **满额策略**（四选一，面板设置里切换，即时生效）/ **Full-quota strategy** (pick one in the panel settings; applies immediately):
+  - 停止请求并提示 / Stop and prompt
+  - 自动切换到其它已监控且未满的限额模型 / Auto-switch to another monitored, capped-but-available model
+  - 自动切换到其它任意可用模型（含非限额）/ Auto-switch to any other available model (incl. uncapped)
+  - 自动切换（优先非限额，其次未监控）/ Prefer uncapped models, then unmonitored ones
+- **每日自动重置**：默认本机时区午夜；可在设置里改为任意时区（UTC−12 ~ +14）与时刻（0:00–23:55），到点清零当日计数并归档用量日志。
+  **Daily auto-reset**: defaults to local midnight; pick any timezone (UTC−12 ~ +14) and time (0:00–23:55) in settings — counters reset and the finished day is archived into the usage log.
 - **用量日志**：每模型每天一条（日期 / 模型 / 用量），与监控勾选无关。
-- **浮窗面板**：实时显示各模型「今日已用 / 上限」，行内一键「选择」切换模型、
-  `⚙` 折叠设置单模型限额。
+  **Usage log**: one row per model per day (date / model / usage), independent of the monitored set.
+- **浮窗面板**：实时显示各模型「今日已用 / 上限」，行内一键「选择」切换模型、`⚙` 折叠设置单模型限额。
+  **Floating panel**: live used/limit per model, a one-click Select button per row, and a folded `⚙` per-model limit editor.
+
+## 安装 / Installation
 
-## 安装
+### 方式一：npm 安装（推荐）/ Option A: npm install (recommended)
 
-### 方式一：npm 安装（推荐）
+在你的 web profile（`~/.dsh/profiles/web`）下安装依赖：
 
-在你的 web profile（`~/.dsh/profiles/web`）下：
+Install the dependency in your web profile (`~/.dsh/profiles/web`):
 
 ```bash
 cd ~/.dsh/profiles/web
@@ -36,9 +40,12 @@ npm install @jxgame2020/dsh-token-quota
 ```
 
 > 用 pnpm 管理 profile 的话：`pnpm add @jxgame2020/dsh-token-quota`。
+> With pnpm: `pnpm add @jxgame2020/dsh-token-quota`.
 
 在 `cordis.patch.yml` 中挂载插件：
 
+Mount the plugin in `cordis.patch.yml`:
+
 ```yaml
 - insert:
     - id: token-quota
@@ -47,87 +54,83 @@ npm install @jxgame2020/dsh-token-quota
 
 重启 `dsh web`，浏览器右侧出现「每日 Token 限额」浮窗即安装成功。
 
-### 方式二：从 GitHub 源码安装
+Restart `dsh web`; the floating panel appears on the right side once installed.
+
+### 方式二：从 GitHub 源码安装 / Option B: install from source (GitHub)
+
+适合想改源码、离线分发或审阅代码的情况。源码仓库不提交构建产物（`lib/`），clone 后需在本机构建（工具链来自 DSH 仓库的 workspace）。
 
-适合想改源码、离线分发或审阅代码的情况。源码仓库不提交构建产物（`lib/`），
-clone 后需在本机构建（工具链来自 DSH 仓库的 workspace）。
+For modifying the source, offline distribution, or code review. The source repo does not ship build output (`lib/`); clone and build locally (the toolchain resolves from the DSH repo workspace).
 
-1. 克隆到与 `deepseek-harness` 同级的开发目录：
+1. 克隆到与 `deepseek-harness` 同级的开发目录 / Clone next to your `deepseek-harness` checkout:
 
    ```bash
    git clone https://github.com/jxgame/dsh-token-quota.git deepseek-harness-package/dsh-token-quota
    ```
 
-2. 在 `deepseek-harness/pnpm-workspace.yaml` 的 `packages:` 下注册该包（让它的
-   peer 依赖从仓库 workspace 解析）：
+2. 在 `deepseek-harness/pnpm-workspace.yaml` 的 `packages:` 下注册该包（让 peer 依赖从仓库 workspace 解析）/ Register the package under `packages:` in `deepseek-harness/pnpm-workspace.yaml` so peer deps resolve from the repo workspace:
 
    ```yaml
    packages:
      - ../deepseek-harness-package/dsh-token-quota/packages/token-quota
    ```
 
-   然后在仓库根执行 `cd deepseek-harness && pnpm install`。
+   然后在仓库根执行 `cd deepseek-harness && pnpm install`。/ Then run `cd deepseek-harness && pnpm install`.
 
-3. 构建：
+3. 构建 / Build:
 
    ```bash
    cd deepseek-harness-package/dsh-token-quota/packages/token-quota
-   pnpm exec tsc -p tsconfig.json    # 类型检查 + 产出 lib/types
+   pnpm exec tsc -p tsconfig.json    # 类型检查 + 产出 lib/types / type-check + emit lib/types
    pnpm exec tsdown                  # 产出 lib/index.js + lib/client.js
    ```
 
-4. 挂载到 profile：`~/.dsh/profiles/web/package.json` 的 dependencies 使用本地路径：
+4. 挂载到 profile：`~/.dsh/profiles/web/package.json` 的 dependencies 使用本地路径 / Mount into the profile with a local path dependency:
 
    ```json
-   "@jxgame2020/dsh-token-quota": "link:/<绝对路径>/deepseek-harness-package/dsh-token-quota/packages/token-quota"
+   "@jxgame2020/dsh-token-quota": "link:/<absolute-path>/deepseek-harness-package/dsh-token-quota/packages/token-quota"
    ```
 
-   然后 `cd ~/.dsh/profiles/web && pnpm install`；`cordis.patch.yml` 挂载与
-   方式一相同；重启 `dsh web`。
+   然后 `cd ~/.dsh/profiles/web && pnpm install`；`cordis.patch.yml` 挂载与方式一相同；重启 `dsh web`。/ Then `cd ~/.dsh/profiles/web && pnpm install`; the `cordis.patch.yml` mount is the same as Option A; restart `dsh web`.
 
-## 使用
+## 使用 / Usage
 
-- 头部「设置」弹窗（改动即时自动保存，右上角 × 关闭）
-  - **监控模型**：勾选要监控的模型（默认全部）。未勾选的模型不显示、
-    不计入当日用量、不受限额拦截（切换时仍可选）。
-  - **满额后处理**：四选一（见上文「功能」）。
-  - **每日重置时间**：时区（UTC−12 ~ UTC+14）与时刻（0:00–23:55，5 分钟步进），
-    到点自动清零；不设置则沿用「本机时区午夜」。
-- 头部「日志」按钮（设置左侧）：用量日志弹窗，表格列出日期 / 模型 / 用量，
-  每模型每天一条。
-- 模型行：
-  - 名称后的「选择」按钮：一键切换当前会话到该模型。
-  - 行尾 `⚙`：展开该行限额输入框（数字，`0`=不限），保存后收起。
-  - 进度条：绿 <80%，黄 80–100%，红 = 已满额。
+- 头部「设置」弹窗（改动即时自动保存，右上角 × 关闭）/ The header Settings dialog (changes auto-save instantly; close with × at the top-right):
+  - **监控模型** / **Monitored models**：勾选要监控的模型（默认全部）。未勾选的模型不显示、不计入当日用量、不受限额拦截（切换时仍可选）。/ Check the models to monitor (all by default). Unchecked models are hidden, not metered, and never capped (they remain selectable).
+  - **满额后处理** / **When a model is full**：四选一（见上文「功能」）。/ one of four strategies (see Features above).
+  - **每日重置时间** / **Daily reset**：时区（UTC−12 ~ UTC+14）与时刻（0:00–23:55，5 分钟步进），到点自动清零；不设置则沿用「本机时区午夜」。/ timezone (UTC−12 ~ UTC+14) and time (0:00–23:55, 5-min steps); defaults to machine-local midnight.
+- 头部「日志」按钮（设置左侧）：用量日志弹窗，表格列出日期 / 模型 / 用量，每模型每天一条。/ The Logs button (left of Settings) opens the usage-log dialog: date / model / usage, one row per model per day.
+- 模型行 / Model rows:
+  - 名称后的「选择」按钮：一键切换当前会话到该模型。/ The Select button after the name switches the current session to that model.
+  - 行尾 `⚙`：展开该行限额输入框（数字，`0`=不限），保存后收起。/ The `⚙` at the row end unfolds the limit editor (number, `0` = unlimited); it folds back after saving.
+  - 进度条：绿 <80%，黄 80–100%，红 = 已满额。/ Progress bar: green <80%, yellow 80–100%, red = full.
 
-## 数据与重置
+## 数据与重置 / Data & Reset
 
-- 计数文件：`$DSH_HOME/token-quota.json`（默认 `~/.dsh/token-quota.json`）。
-- 重置周期默认「本机时区午夜」；可改为任意时区与时刻。跨过重置时刻时当日计数
-  清零并归档进用量日志。
-- 限额与面板配置保存在 `~/.dsh/settings.yaml` 的 `token-quota` 命名空间
-  （`limits` / `monitored` / `onFull` / `reset`）。
-- 面板数据读取：`GET /token-quota`（当前快照）、`GET /token-quota/log`（历史用量）。
+- 计数文件：`$DSH_HOME/token-quota.json`（默认 `~/.dsh/token-quota.json`）。/ Counter file: `$DSH_HOME/token-quota.json` (default `~/.dsh/token-quota.json`).
+- 重置周期默认「本机时区午夜」；可改为任意时区与时刻。跨过重置时刻时当日计数清零并归档进用量日志。/ The reset cycle defaults to machine-local midnight and can be changed to any timezone/time; crossing the reset moment zeroes the counters and archives the finished day into the usage log.
+- 限额与面板配置保存在 `~/.dsh/settings.yaml` 的 `token-quota` 命名空间（`limits` / `monitored` / `onFull` / `reset`）。/ Limits and panel preferences live in the `token-quota` namespace of `~/.dsh/settings.yaml` (`limits` / `monitored` / `onFull` / `reset`).
+- 面板数据读取：`GET /token-quota`（当前快照）、`GET /token-quota/log`（历史用量）。/ Panel data endpoints: `GET /token-quota` (live snapshot), `GET /token-quota/log` (usage history).
 
-## 目录结构
+## 目录结构 / Project Structure
 
 ```
 dsh-token-quota/
 └── packages/token-quota/
     ├── src/
-    │   ├── index.ts            # Host 服务：计量/持久化/拦截/HTTP 快照路由
-    │   ├── types.ts            # 共享类型与 wire 常量
-    │   ├── invariant.ts        # 运行时守卫
-    │   └── client/             # 浏览器面板（shell.overlay 浮窗）
-    │       ├── index.ts        # apply：轮询 + 满额策略 + 面板注册
+    │   ├── index.ts            # Host 服务：计量/持久化/拦截/HTTP 快照路由 / host service: metering, persistence, enforcement, snapshot route
+    │   ├── types.ts            # 共享类型与 wire 常量 / shared types and wire constants
+    │   ├── invariant.ts        # 运行时守卫 / runtime guards
+    │   └── client/             # 浏览器面板（shell.overlay 浮窗）/ browser panel (shell.overlay)
+    │       ├── index.ts        # apply：轮询 + 满额策略 + 面板注册 / polling + full-quota strategy + registration
     │       ├── TokenQuotaPanel.tsx
     │       ├── store.ts
     │       ├── locales.ts
     │       └── TokenQuotaPanel.module.css
-    ├── tsconfig.json           # host + client 一起编译
-    └── tsdown.config.ts        # host 库 + 浏览器 bundle（closure-factory）
+    ├── tsconfig.json           # host + client 一起编译 / compiles host + client
+    └── tsdown.config.ts        # host 库 + 浏览器 bundle（closure-factory）/ host lib + browser bundle
 ```
 
-## License
+## License / 许可证
 
 MIT

package/lib/client.js

@@ -129,59 +129,59 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var TokenQuotaPanel_module_css_default = {
-			"logUsedCol": "NPLLIq_logUsedCol",
-			"fillIdle": "NPLLIq_fillIdle",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"tabLabel": "NPLLIq_tabLabel",
 			"monitorHint": "NPLLIq_monitorHint",
-			"logScroll": "NPLLIq_logScroll",
-			"title": "NPLLIq_title",
-			"body": "NPLLIq_body",
-			"row": "NPLLIq_row",
-			"gearBtn": "NPLLIq_gearBtn",
-			"monitorName": "NPLLIq_monitorName",
-			"radioRow": "NPLLIq_radioRow",
-			"header": "NPLLIq_header",
+			"monitorRow": "NPLLIq_monitorRow",
 			"fillOver": "NPLLIq_fillOver",
-			"tabLabel": "NPLLIq_tabLabel",
-			"selectBtn": "NPLLIq_selectBtn",
+			"bar": "NPLLIq_bar",
+			"panel": "NPLLIq_panel",
+			"header": "NPLLIq_header",
+			"controls": "NPLLIq_controls",
+			"switch": "NPLLIq_switch",
+			"resetSelect": "NPLLIq_resetSelect",
 			"input": "NPLLIq_input",
-			"notice": "NPLLIq_notice",
-			"dialogSection": "NPLLIq_dialogSection",
-			"dialogLabel": "NPLLIq_dialogLabel",
+			"save": "NPLLIq_save",
+			"selectBtn": "NPLLIq_selectBtn",
 			"dialogActions": "NPLLIq_dialogActions",
+			"row": "NPLLIq_row",
+			"fillWarn": "NPLLIq_fillWarn",
+			"settingsBtn": "NPLLIq_settingsBtn",
+			"dialogSection": "NPLLIq_dialogSection",
+			"dialogTitle": "NPLLIq_dialogTitle",
+			"dialogClose": "NPLLIq_dialogClose",
+			"logDialog": "NPLLIq_logDialog",
+			"tab": "NPLLIq_tab",
+			"logScroll": "NPLLIq_logScroll",
+			"fillIdle": "NPLLIq_fillIdle",
+			"logTable": "NPLLIq_logTable",
+			"body": "NPLLIq_body",
+			"logUsedCol": "NPLLIq_logUsedCol",
+			"resetRow": "NPLLIq_resetRow",
+			"headerText": "NPLLIq_headerText",
+			"notice": "NPLLIq_notice",
 			"headerActions": "NPLLIq_headerActions",
+			"monitorName": "NPLLIq_monitorName",
 			"rowName": "NPLLIq_rowName",
 			"rowMeta": "NPLLIq_rowMeta",
-			"collapse": "NPLLIq_collapse",
-			"save": "NPLLIq_save",
-			"resetSelect": "NPLLIq_resetSelect",
-			"logDialog": "NPLLIq_logDialog",
-			"dialogClose": "NPLLIq_dialogClose",
 			"dialog": "NPLLIq_dialog",
-			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
-			"rowHeader": "NPLLIq_rowHeader",
-			"controls": "NPLLIq_controls",
 			"currentBadge": "NPLLIq_currentBadge",
-			"tabIcon": "NPLLIq_tabIcon",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"tab": "NPLLIq_tab",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"logDayCol": "NPLLIq_logDayCol",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"fillWarn": "NPLLIq_fillWarn",
-			"fullNotice": "NPLLIq_fullNotice",
-			"bar": "NPLLIq_bar",
+			"subtitle": "NPLLIq_subtitle",
 			"dialogBtn": "NPLLIq_dialogBtn",
-			"switch": "NPLLIq_switch",
-			"panel": "NPLLIq_panel",
-			"headerText": "NPLLIq_headerText",
-			"monitorRow": "NPLLIq_monitorRow",
+			"logDayCol": "NPLLIq_logDayCol",
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"dialogLabel": "NPLLIq_dialogLabel",
+			"gearBtn": "NPLLIq_gearBtn",
+			"logModelCol": "NPLLIq_logModelCol",
+			"noticeError": "NPLLIq_noticeError",
+			"tabIcon": "NPLLIq_tabIcon",
 			"logHeader": "NPLLIq_logHeader",
-			"resetRow": "NPLLIq_resetRow",
+			"fullNotice": "NPLLIq_fullNotice",
 			"monitorList": "NPLLIq_monitorList",
-			"logTable": "NPLLIq_logTable",
-			"subtitle": "NPLLIq_subtitle",
-			"noticeError": "NPLLIq_noticeError",
-			"logModelCol": "NPLLIq_logModelCol"
+			"radioRow": "NPLLIq_radioRow",
+			"title": "NPLLIq_title",
+			"rowHeader": "NPLLIq_rowHeader",
+			"collapse": "NPLLIq_collapse"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -768,7 +768,8 @@ window.__ModuleLoader__.load({
 			fullSwitchAll: "自动切换到其它可用模型（含非限额）",
 			fullSwitchPriority: "自动切换（优先非限额，其次未监控）",
 			fullNotice: "当前模型今日额度已用尽，请求已停止。请选择其它模型或调整限额。",
-			fullSwitchFailed: "没有可切换的模型（所有限额模型均已满额）",
+			fullSwitchFailed: "没有可切换的模型，请手动选择其它模型或调整限额",
+			fullSwitchTo: "已自动切换到 {model}",
 			close: "关闭",
 			logs: "日志",
 			logsTitle: "用量日志",
@@ -813,7 +814,8 @@ window.__ModuleLoader__.load({
 			fullSwitchAll: "Switch to any other model (incl. uncapped)",
 			fullSwitchPriority: "Prefer uncapped, then unmonitored",
 			fullNotice: "Today’s quota for the current model is exhausted; the request was stopped. Pick another model or raise its limit.",
-			fullSwitchFailed: "No switchable model (all quota models are full)",
+			fullSwitchFailed: "No switchable model — pick one manually or raise a limit",
+			fullSwitchTo: "Auto-switched to {model}",
 			close: "Close",
 			logs: "Logs",
 			logsTitle: "Usage Log",
@@ -868,6 +870,19 @@ window.__ModuleLoader__.load({
 				return `${selection.provider}/${selection.model}`;
 			};
 			const isMonitoredKey = (key) => lastMonitored === null || lastMonitored.includes(key);
+			/** Transient auto-switch confirmation: shows for a few seconds, then clears. */
+			let fullNoticeTimer;
+			const flashFullNotice = (message) => {
+				if (fullNoticeTimer !== void 0) {
+					clearTimeout(fullNoticeTimer);
+					fullNoticeTimer = void 0;
+				}
+				bound?.setFullNotice(message);
+				fullNoticeTimer = setTimeout(() => {
+					bound?.setFullNotice(null);
+					fullNoticeTimer = void 0;
+				}, 6e3);
+			};
 			/** Pick an auto-switch target for the configured strategy. */
 			const pickSwitchTarget = (snapshot, currentKey) => {
 				const entryByKey = new Map(snapshot.entries.map((entry) => [entry.key, entry]));
@@ -916,7 +931,7 @@ window.__ModuleLoader__.load({
 				}).then(({ result }) => {
 					if (result.ok) {
 						lastCurrent = result.value.selected;
-						bound?.setFullNotice(null);
+						flashFullNotice(t("fullSwitchTo").replace("{model}", target.model));
 						pull();
 					} else bound?.setFullNotice(t("fullSwitchFailed"));
 				}, () => {
@@ -928,9 +943,16 @@ window.__ModuleLoader__.load({
 				if (lastSessionId === void 0) return;
 				connection.api.sessions.models({ sessionId: lastSessionId }).then(({ result }) => {
 					if (result.ok) {
+						const currentChanged = lastCurrent?.provider !== result.value.current?.provider || lastCurrent?.model !== result.value.current?.model;
 						lastGroups = result.value.groups;
 						lastCurrent = result.value.current;
 						bound?.setDirectory(result.value.groups, result.value.current);
+						if (currentChanged) fetch("/token-quota", { headers: { accept: "application/json" } }).then((response) => response.ok ? response.json() : void 0, () => void 0).then((snapshot) => {
+							if (snapshot !== void 0) {
+								bound?.setSnapshot(snapshot);
+								actOnFull(snapshot);
+							}
+						});
 					}
 				}, () => {});
 			};
@@ -955,7 +977,7 @@ window.__ModuleLoader__.load({
 					bound?.setSnapshot(snapshot);
 					actOnFull(snapshot);
 				});
-				if (pullCount % 4 === 0) refreshCurrent();
+				if (pullCount % 2 === 0) refreshCurrent();
 			};
 			ctx.effect(() => {
 				pull();
@@ -1013,6 +1035,7 @@ window.__ModuleLoader__.load({
 				}).then(({ result }) => {
 					if (result.ok) {
 						lastCurrent = result.value.selected;
+						bound?.setFullNotice(null);
 						bound?.setDirectory(lastGroups, result.value.selected);
 						pull();
 					} else bound?.setError(`${result.error.code}: ${result.error.message}`);

package/lib/index.js

@@ -110,7 +110,7 @@ function usageTokens(usage) {
 * Mount it beside the other rows (`@jxgame2020/dsh-token-quota`) and write
 * per-model limits through the `token-quota` settings namespace.
 */
-var TokenQuotaService = class extends Service {
+var TokenQuotaService = class TokenQuotaService extends Service {
 	static Config = z.object({ storagePath: z.string().default("") });
 	storagePath;
 	reset = {
@@ -131,6 +131,11 @@ var TokenQuotaService = class extends Service {
 	/** Per-session folded model key from the latest `request/header`. */
 	headerKeys = /* @__PURE__ */ new WeakMap();
 	writeTimer;
+	/** Cached model directory: list of providers and their models, refreshed lazily. */
+	cachedModels = [];
+	modelsCachedAt = 0;
+	/** How long to reuse the cached model directory before refreshing (30s). */
+	static MODEL_CACHE_TTL_MS = 3e4;
 	/** Disposer for the optional HTTP snapshot route (`GET /token-quota`). */
 	disposeRoute;
 	/** Disposer for the optional usage-history route (`GET /token-quota/log`). */
@@ -192,7 +197,9 @@ var TokenQuotaService = class extends Service {
 		ctx.on("session/event", (session, event) => {
 			this.onSessionEvent(session, event);
 		});
-		ctx.on("agent/request", async (payload, next) => this.onRequest(payload, next));
+		ctx.on("agent/created", ({ agent }) => {
+			agent.ctx.on("agent/request", async (payload, next) => this.onRequest(payload, next));
+		});
 		ctx.effect(() => () => {
 			this.disposeLocal();
 		}, "token-quota: flush on unload");
@@ -308,6 +315,79 @@ var TokenQuotaService = class extends Service {
 			this.scheduleWrite();
 		}
 	}
+	/**
+	* Refresh the cached list of all registered providers and their advertised
+	* models. Re-uses a still-fresh cache; any provider discovery failure is
+	* swallowed — we'd rather miss a candidate than crash the request waterfall.
+	*/
+	async refreshModels() {
+		const now = Date.now();
+		if (this.cachedModels.length > 0 && now - this.modelsCachedAt < TokenQuotaService.MODEL_CACHE_TTL_MS) return;
+		const llm = this.ctx.get("llm");
+		if (llm === void 0) {
+			this.cachedModels = [];
+			this.modelsCachedAt = now;
+			return;
+		}
+		const next = [];
+		for (const provider of llm.listProviders()) try {
+			const models = await llm.listModels(provider.id);
+			for (const model of models) next.push({
+				provider: provider.id,
+				model: model.id
+			});
+		} catch (error) {
+			this.ctx.logger.debug?.("token-quota: failed to list models for provider \"%s\": %o", provider.id, error);
+		}
+		this.cachedModels = next;
+		this.modelsCachedAt = now;
+	}
+	/**
+	* Choose a replacement model for the exhausted current model according to
+	* the configured `onFull` strategy. Returns `undefined` when no eligible
+	* candidate exists (caller falls back to the historical stop-and-throw).
+	*/
+	pickReplacementModel(currentKey) {
+		const onFull = this.settingsSource().onFull ?? "stop";
+		if (onFull === "stop") return void 0;
+		if (this.cachedModels.length === 0) return void 0;
+		const availability = (key) => {
+			return {
+				limit: this.limitOf(key),
+				used: this.usage[key] ?? 0
+			};
+		};
+		const isMonitored = (key) => this.isMonitored(key);
+		const isAvailable = (key) => {
+			if (!isMonitored(key)) return false;
+			const { limit, used } = availability(key);
+			return limit <= 0 || used < limit;
+		};
+		const candidates = this.cachedModels.filter(({ provider, model }) => tokenQuotaKey(provider, model) !== currentKey).map(({ provider, model }) => {
+			const key = tokenQuotaKey(provider, model);
+			const { limit, used } = availability(key);
+			return {
+				provider,
+				model,
+				key,
+				limit,
+				used,
+				monitored: isMonitored(key)
+			};
+		});
+		switch (onFull) {
+			case "switchQuota": return candidates.filter((c) => c.monitored && c.limit > 0 && c.used < c.limit).sort((a, b) => a.used / a.limit - b.used / b.limit)[0];
+			case "switchAll": return candidates.filter((c) => isAvailable(c.key))[0];
+			case "switchPriority": {
+				const uncapped = candidates.find((c) => c.monitored && c.limit <= 0);
+				if (uncapped !== void 0) return uncapped;
+				const unmonitored = candidates.find((c) => !c.monitored);
+				if (unmonitored !== void 0) return unmonitored;
+				return candidates.find((c) => isAvailable(c.key));
+			}
+			default: return;
+		}
+	}
 	async onRequest(payload, next) {
 		const config = await next();
 		const { provider, model } = config;
@@ -319,6 +399,19 @@ var TokenQuotaService = class extends Service {
 		if (limit <= 0) return config;
 		const used = this.usage[key] ?? 0;
 		if (used < limit) return config;
+		await this.refreshModels();
+		const replacement = this.pickReplacementModel(key);
+		if (replacement !== void 0) {
+			this.ctx.logger.info("token-quota: \"%s\" is full (%d/%d); auto-switching to \"%s\" (%s strategy).", key, used, limit, replacement.key, this.settingsSource().onFull);
+			this.headerKeys.set(payload.agent.session, replacement.key);
+			this.modelsCachedAt = 0;
+			this.cachedModels = [];
+			return {
+				...config,
+				provider: replacement.provider,
+				model: replacement.model
+			};
+		}
 		throw new LlmError(`Daily token limit reached for "${provider}/${model}": ${used}/${limit} tokens used today. Switch model in the quota panel or raise its limit.`, TOKEN_QUOTA_EXCEEDED_CODE);
 	}
 	/**

package/lib/types/client/index.js

@@ -38,6 +38,19 @@ export function apply(ctx) {
         return `${selection.provider}/${selection.model}`;
     };
     const isMonitoredKey = (key) => lastMonitored === null || lastMonitored.includes(key);
+    /** Transient auto-switch confirmation: shows for a few seconds, then clears. */
+    let fullNoticeTimer;
+    const flashFullNotice = (message) => {
+        if (fullNoticeTimer !== undefined) {
+            clearTimeout(fullNoticeTimer);
+            fullNoticeTimer = undefined;
+        }
+        bound?.setFullNotice(message);
+        fullNoticeTimer = setTimeout(() => {
+            bound?.setFullNotice(null);
+            fullNoticeTimer = undefined;
+        }, 6000);
+    };
     /** Pick an auto-switch target for the configured strategy. */
     const pickSwitchTarget = (snapshot, currentKey) => {
         const entryByKey = new Map(snapshot.entries.map(entry => [entry.key, entry]));
@@ -101,7 +114,7 @@ export function apply(ctx) {
         }).then(({ result }) => {
             if (result.ok) {
                 lastCurrent = result.value.selected;
-                bound?.setFullNotice(null);
+                flashFullNotice(t('fullSwitchTo').replace('{model}', target.model));
                 pull();
             }
             else {
@@ -113,16 +126,32 @@ export function apply(ctx) {
     // single fact source for usage AND the resolved per-model caps; the panel
     // converges within one poll interval (plus an immediate first pull). Every
     // few pulls we re-read the model directory so a model switch made OUTSIDE
-    // this panel (the official selector, /model) moves the 「当前」 badge too.
+    // this panel (the official selector, /model, or an automatic server-side
+    // switch on full quota) moves the 「当前」 badge without waiting the full
+    // directory-refresh cadence.
     let pullCount = 0;
     const refreshCurrent = () => {
         if (lastSessionId === undefined)
             return;
         void connection.api.sessions.models({ sessionId: lastSessionId }).then(({ result }) => {
             if (result.ok) {
+                const currentChanged = lastCurrent?.provider !== result.value.current?.provider
+                    || lastCurrent?.model !== result.value.current?.model;
                 lastGroups = result.value.groups;
                 lastCurrent = result.value.current;
                 bound?.setDirectory(result.value.groups, result.value.current);
+                // If the server silently switched to a different model (e.g. the
+                // auto-switch on quota exhaustion), re-run the full-quota strategy
+                // immediately against the new current model so any further fallback
+                // happens without waiting the next poll.
+                if (currentChanged) {
+                    void fetch('/token-quota', { headers: { accept: 'application/json' } }).then(response => response.ok ? response.json() : undefined, () => undefined).then(snapshot => {
+                        if (snapshot !== undefined) {
+                            bound?.setSnapshot(snapshot);
+                            actOnFull(snapshot);
+                        }
+                    });
+                }
             }
         }, () => { });
     };
@@ -152,7 +181,7 @@ export function apply(ctx) {
             bound?.setSnapshot(snapshot);
             actOnFull(snapshot);
         });
-        if (pullCount % 4 === 0)
+        if (pullCount % 2 === 0)
             refreshCurrent();
     };
     ctx.effect(() => {
@@ -203,6 +232,8 @@ export function apply(ctx) {
         void connection.api.sessions.selectModel({ sessionId, provider, model }).then(({ result }) => {
             if (result.ok) {
                 lastCurrent = result.value.selected;
+                // A manual pick clears any leftover auto-switch / exhausted notice.
+                bound?.setFullNotice(null);
                 bound?.setDirectory(lastGroups, result.value.selected);
                 // Immediately re-pull the snapshot so the previous model's final
                 // usage (credited around the switch) shows without waiting 3 s.

package/lib/types/client/locales.d.ts

@@ -37,6 +37,7 @@ export declare const zh: {
     fullSwitchPriority: string;
     fullNotice: string;
     fullSwitchFailed: string;
+    fullSwitchTo: string;
     close: string;
     logs: string;
     logsTitle: string;
@@ -84,6 +85,7 @@ export declare const en: {
     fullSwitchPriority: string;
     fullNotice: string;
     fullSwitchFailed: string;
+    fullSwitchTo: string;
     close: string;
     logs: string;
     logsTitle: string;

package/lib/types/client/locales.js

@@ -36,7 +36,8 @@ export const zh = {
     fullSwitchAll: '自动切换到其它可用模型（含非限额）',
     fullSwitchPriority: '自动切换（优先非限额，其次未监控）',
     fullNotice: '当前模型今日额度已用尽，请求已停止。请选择其它模型或调整限额。',
-    fullSwitchFailed: '没有可切换的模型（所有限额模型均已满额）',
+    fullSwitchFailed: '没有可切换的模型，请手动选择其它模型或调整限额',
+    fullSwitchTo: '已自动切换到 {model}',
     close: '关闭',
     logs: '日志',
     logsTitle: '用量日志',
@@ -81,7 +82,8 @@ export const en = {
     fullSwitchAll: 'Switch to any other model (incl. uncapped)',
     fullSwitchPriority: 'Prefer uncapped, then unmonitored',
     fullNotice: 'Today\u2019s quota for the current model is exhausted; the request was stopped. Pick another model or raise its limit.',
-    fullSwitchFailed: 'No switchable model (all quota models are full)',
+    fullSwitchFailed: 'No switchable model \u2014 pick one manually or raise a limit',
+    fullSwitchTo: 'Auto-switched to {model}',
     close: 'Close',
     logs: 'Logs',
     logsTitle: 'Usage Log',

package/lib/types/index.d.ts

@@ -58,6 +58,11 @@ export declare class TokenQuotaService extends Service {
     /** Per-session folded model key from the latest `request/header`. */
     private readonly headerKeys;
     private writeTimer;
+    /** Cached model directory: list of providers and their models, refreshed lazily. */
+    private cachedModels;
+    private modelsCachedAt;
+    /** How long to reuse the cached model directory before refreshing (30s). */
+    private static readonly MODEL_CACHE_TTL_MS;
     /** Disposer for the optional HTTP snapshot route (`GET /token-quota`). */
     private disposeRoute;
     /** Disposer for the optional usage-history route (`GET /token-quota/log`). */
@@ -82,6 +87,18 @@ export declare class TokenQuotaService extends Service {
     /** Resolve one model's daily cap: positive = capped, `0` = unlimited. */
     limitOf(key: string): number;
     private onSessionEvent;
+    /**
+     * Refresh the cached list of all registered providers and their advertised
+     * models. Re-uses a still-fresh cache; any provider discovery failure is
+     * swallowed — we'd rather miss a candidate than crash the request waterfall.
+     */
+    private refreshModels;
+    /**
+     * Choose a replacement model for the exhausted current model according to
+     * the configured `onFull` strategy. Returns `undefined` when no eligible
+     * candidate exists (caller falls back to the historical stop-and-throw).
+     */
+    private pickReplacementModel;
     private onRequest;
     /**
      * Roll over to a new reset cycle, archiving the finished cycle's counters

package/lib/types/index.js

@@ -114,6 +114,11 @@ export class TokenQuotaService extends Service {
     /** Per-session folded model key from the latest `request/header`. */
     headerKeys = new WeakMap();
     writeTimer;
+    /** Cached model directory: list of providers and their models, refreshed lazily. */
+    cachedModels = [];
+    modelsCachedAt = 0;
+    /** How long to reuse the cached model directory before refreshing (30s). */
+    static MODEL_CACHE_TTL_MS = 30_000;
     /** Disposer for the optional HTTP snapshot route (`GET /token-quota`). */
     disposeRoute;
     /** Disposer for the optional usage-history route (`GET /token-quota/log`). */
@@ -194,10 +199,16 @@ export class TokenQuotaService extends Service {
         ctx.on('session/event', (session, event) => {
             this.onSessionEvent(session, event);
         });
-        // Enforcement + accounting lock: the waterfall's resolved config is the
-        // authoritative model for this request — bind it to the agent's session
-        // so a model switch mid-flight never misattributes the in-flight reply.
-        ctx.on('agent/request', async (payload, next) => this.onRequest(payload, next));
+        // For every newly created agent, install an agent-scoped enforcement
+        // listener that runs AFTER the api-proxy's model-selection listener (so
+        // user selections always apply first), and is therefore the last word on
+        // the chosen provider/model. When the resolved model is at its cap and
+        // the configured strategy allows an automatic switch, it rewrites the
+        // call config to a suitable replacement model instead of throwing, so
+        // the turn proceeds uninterrupted.
+        ctx.on('agent/created', ({ agent }) => {
+            agent.ctx.on('agent/request', async (payload, next) => this.onRequest(payload, next));
+        });
         ctx.effect(() => () => { this.disposeLocal(); }, 'token-quota: flush on unload');
     }
     /** Serve the current snapshot over the plugin-owned HTTP route. */
@@ -300,6 +311,101 @@ export class TokenQuotaService extends Service {
             this.scheduleWrite();
         }
     }
+    /**
+     * Refresh the cached list of all registered providers and their advertised
+     * models. Re-uses a still-fresh cache; any provider discovery failure is
+     * swallowed — we'd rather miss a candidate than crash the request waterfall.
+     */
+    async refreshModels() {
+        const now = Date.now();
+        if (this.cachedModels.length > 0 && now - this.modelsCachedAt < TokenQuotaService.MODEL_CACHE_TTL_MS) {
+            return;
+        }
+        const llm = this.ctx.get('llm');
+        if (llm === undefined) {
+            this.cachedModels = [];
+            this.modelsCachedAt = now;
+            return;
+        }
+        const next = [];
+        for (const provider of llm.listProviders()) {
+            try {
+                const models = await llm.listModels(provider.id);
+                for (const model of models) {
+                    next.push({ provider: provider.id, model: model.id });
+                }
+            }
+            catch (error) {
+                // Transient provider failure — keep whatever we already have for that
+                // provider and continue with the others.
+                this.ctx.logger.debug?.('token-quota: failed to list models for provider "%s": %o', provider.id, error);
+            }
+        }
+        this.cachedModels = next;
+        this.modelsCachedAt = now;
+    }
+    /**
+     * Choose a replacement model for the exhausted current model according to
+     * the configured `onFull` strategy. Returns `undefined` when no eligible
+     * candidate exists (caller falls back to the historical stop-and-throw).
+     */
+    pickReplacementModel(currentKey) {
+        const doc = this.settingsSource();
+        const onFull = doc.onFull ?? 'stop';
+        if (onFull === 'stop')
+            return undefined;
+        if (this.cachedModels.length === 0)
+            return undefined;
+        const availability = (key) => {
+            const limit = this.limitOf(key);
+            const used = this.usage[key] ?? 0;
+            return { limit, used };
+        };
+        const isMonitored = (key) => this.isMonitored(key);
+        const isAvailable = (key) => {
+            if (!isMonitored(key))
+                return false;
+            const { limit, used } = availability(key);
+            return limit <= 0 || used < limit;
+        };
+        // Build candidate list excluding the currently exhausted model.
+        const candidates = this.cachedModels
+            .filter(({ provider, model }) => tokenQuotaKey(provider, model) !== currentKey)
+            .map(({ provider, model }) => {
+            const key = tokenQuotaKey(provider, model);
+            const { limit, used } = availability(key);
+            return { provider, model, key, limit, used, monitored: isMonitored(key) };
+        });
+        switch (onFull) {
+            case 'switchQuota': {
+                // Another monitored, capped model that still has headroom, sorted by
+                // lowest fill ratio so we spread load across capped models evenly.
+                const eligible = candidates
+                    .filter(c => c.monitored && c.limit > 0 && c.used < c.limit)
+                    .sort((a, b) => (a.used / a.limit) - (b.used / b.limit));
+                return eligible[0];
+            }
+            case 'switchAll': {
+                // Any monitored model that has headroom (capped or unlimited).
+                const eligible = candidates.filter(c => isAvailable(c.key));
+                return eligible[0];
+            }
+            case 'switchPriority': {
+                // 1. Unlimited monitored models. 2. Unmonitored models (never capped).
+                // 3. Capped-but-free monitored models.
+                const uncapped = candidates.find(c => c.monitored && c.limit <= 0);
+                if (uncapped !== undefined)
+                    return uncapped;
+                const unmonitored = candidates.find(c => !c.monitored);
+                if (unmonitored !== undefined)
+                    return unmonitored;
+                const free = candidates.find(c => isAvailable(c.key));
+                return free;
+            }
+            default:
+                return undefined;
+        }
+    }
     async onRequest(payload, next) {
         const config = await next();
         const { provider, model } = config;
@@ -318,6 +424,25 @@ export class TokenQuotaService extends Service {
         const used = this.usage[key] ?? 0;
         if (used < limit)
             return config;
+        // Current model is at or over cap. Try an automatic switch when the
+        // configured strategy allows it and a candidate exists; otherwise fall
+        // through to the historical hard stop.
+        await this.refreshModels();
+        const replacement = this.pickReplacementModel(key);
+        if (replacement !== undefined) {
+            this.ctx.logger.info('token-quota: "%s" is full (%d/%d); auto-switching to "%s" (%s strategy).', key, used, limit, replacement.key, this.settingsSource().onFull);
+            this.headerKeys.set(payload.agent.session, replacement.key);
+            // Invalidate the cached directory so the next request re-discovers any
+            // newly-registered models and so the next client-side poll sees the
+            // switch reflected without waiting a full TTL.
+            this.modelsCachedAt = 0;
+            this.cachedModels = [];
+            return {
+                ...config,
+                provider: replacement.provider,
+                model: replacement.model,
+            };
+        }
         throw new LlmError(`Daily token limit reached for "${provider}/${model}": ${used}/${limit} tokens used today. `
             + 'Switch model in the quota panel or raise its limit.', TOKEN_QUOTA_EXCEEDED_CODE);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jxgame2020/dsh-token-quota",
   "description": "Daily per-model token quota accounting, enforcement, and a floating quota panel for the DeepSeek Harness — a fully self-contained plugin (no core-Harness wiring, no generated RPC contract)",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "publishConfig": {
     "access": "public"
   },