@jxgame2020/dsh-token-quota 0.1.6 → 0.1.7

package/lib/client.js

@@ -129,59 +129,59 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var TokenQuotaPanel_module_css_default = {
-			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
-			"tabLabel": "NPLLIq_tabLabel",
-			"monitorHint": "NPLLIq_monitorHint",
-			"monitorRow": "NPLLIq_monitorRow",
 			"fillOver": "NPLLIq_fillOver",
-			"bar": "NPLLIq_bar",
-			"panel": "NPLLIq_panel",
-			"header": "NPLLIq_header",
-			"controls": "NPLLIq_controls",
+			"fillIdle": "NPLLIq_fillIdle",
+			"monitorList": "NPLLIq_monitorList",
 			"switch": "NPLLIq_switch",
-			"resetSelect": "NPLLIq_resetSelect",
-			"input": "NPLLIq_input",
-			"save": "NPLLIq_save",
-			"selectBtn": "NPLLIq_selectBtn",
-			"dialogActions": "NPLLIq_dialogActions",
+			"subtitle": "NPLLIq_subtitle",
+			"monitorName": "NPLLIq_monitorName",
+			"currentBadge": "NPLLIq_currentBadge",
+			"collapse": "NPLLIq_collapse",
 			"row": "NPLLIq_row",
 			"fillWarn": "NPLLIq_fillWarn",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"dialogSection": "NPLLIq_dialogSection",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"dialogClose": "NPLLIq_dialogClose",
+			"rowHeader": "NPLLIq_rowHeader",
+			"input": "NPLLIq_input",
+			"radioRow": "NPLLIq_radioRow",
+			"logHeader": "NPLLIq_logHeader",
+			"logModelCol": "NPLLIq_logModelCol",
+			"logDayCol": "NPLLIq_logDayCol",
+			"dialogBtn": "NPLLIq_dialogBtn",
+			"dialogActions": "NPLLIq_dialogActions",
 			"logDialog": "NPLLIq_logDialog",
-			"tab": "NPLLIq_tab",
+			"notice": "NPLLIq_notice",
+			"tabLabel": "NPLLIq_tabLabel",
+			"dialog": "NPLLIq_dialog",
 			"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",
-			"dialog": "NPLLIq_dialog",
-			"currentBadge": "NPLLIq_currentBadge",
-			"subtitle": "NPLLIq_subtitle",
-			"dialogBtn": "NPLLIq_dialogBtn",
-			"logDayCol": "NPLLIq_logDayCol",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"dialogLabel": "NPLLIq_dialogLabel",
-			"gearBtn": "NPLLIq_gearBtn",
-			"logModelCol": "NPLLIq_logModelCol",
+			"tab": "NPLLIq_tab",
+			"monitorHint": "NPLLIq_monitorHint",
+			"title": "NPLLIq_title",
 			"noticeError": "NPLLIq_noticeError",
+			"monitorRow": "NPLLIq_monitorRow",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
 			"tabIcon": "NPLLIq_tabIcon",
-			"logHeader": "NPLLIq_logHeader",
+			"rowName": "NPLLIq_rowName",
+			"save": "NPLLIq_save",
 			"fullNotice": "NPLLIq_fullNotice",
-			"monitorList": "NPLLIq_monitorList",
-			"radioRow": "NPLLIq_radioRow",
-			"title": "NPLLIq_title",
-			"rowHeader": "NPLLIq_rowHeader",
-			"collapse": "NPLLIq_collapse"
+			"dialogClose": "NPLLIq_dialogClose",
+			"header": "NPLLIq_header",
+			"bar": "NPLLIq_bar",
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"headerText": "NPLLIq_headerText",
+			"selectBtn": "NPLLIq_selectBtn",
+			"resetSelect": "NPLLIq_resetSelect",
+			"logTable": "NPLLIq_logTable",
+			"panel": "NPLLIq_panel",
+			"controls": "NPLLIq_controls",
+			"headerActions": "NPLLIq_headerActions",
+			"body": "NPLLIq_body",
+			"settingsBtn": "NPLLIq_settingsBtn",
+			"gearBtn": "NPLLIq_gearBtn",
+			"logUsedCol": "NPLLIq_logUsedCol",
+			"dialogTitle": "NPLLIq_dialogTitle",
+			"dialogSection": "NPLLIq_dialogSection",
+			"dialogLabel": "NPLLIq_dialogLabel"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -220,10 +220,6 @@ window.__ModuleLoader__.load({
 			{
 				value: "switchAll",
 				labelKey: "fullSwitchAll"
-			},
-			{
-				value: "switchPriority",
-				labelKey: "fullSwitchPriority"
 			}
 		];
 		/**
@@ -765,8 +761,7 @@ window.__ModuleLoader__.load({
 			fullActionLabel: "满额后处理",
 			fullStop: "停止请求并提示",
 			fullSwitchQuota: "自动切换到其它限额模型",
-			fullSwitchAll: "自动切换到其它可用模型（含非限额）",
-			fullSwitchPriority: "自动切换（优先非限额，其次未监控）",
+			fullSwitchAll: "自动切换（优先限额模型，其次非限额）",
 			fullNotice: "当前模型今日额度已用尽，请求已停止。请选择其它模型或调整限额。",
 			fullSwitchFailed: "没有可切换的模型，请手动选择其它模型或调整限额",
 			fullSwitchTo: "已自动切换到 {model}",
@@ -811,8 +806,7 @@ window.__ModuleLoader__.load({
 			fullActionLabel: "When a model is full",
 			fullStop: "Stop and prompt",
 			fullSwitchQuota: "Switch to another quota model",
-			fullSwitchAll: "Switch to any other model (incl. uncapped)",
-			fullSwitchPriority: "Prefer uncapped, then unmonitored",
+			fullSwitchAll: "Switch models (quota models first, then uncapped)",
 			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 — pick one manually or raise a limit",
 			fullSwitchTo: "Auto-switched to {model}",
@@ -899,14 +893,13 @@ window.__ModuleLoader__.load({
 						used: entry?.used ?? 0
 					});
 				}
-				const available = (candidate) => isMonitoredKey(candidate.key) && (candidate.limit <= 0 || candidate.used < candidate.limit);
-				if (lastOnFull === "switchQuota") return candidates.filter((candidate) => isMonitoredKey(candidate.key) && candidate.limit > 0 && candidate.used < candidate.limit).sort((a, b) => a.used / a.limit - b.used / b.limit)[0];
-				if (lastOnFull === "switchAll") return candidates.filter(available)[0];
-				const uncapped = candidates.find((candidate) => isMonitoredKey(candidate.key) && candidate.limit <= 0);
-				if (uncapped !== void 0) return uncapped;
-				const unmonitored = candidates.find((candidate) => !isMonitoredKey(candidate.key));
-				if (unmonitored !== void 0) return unmonitored;
-				return candidates.find(available);
+				const cappedFree = (candidate) => isMonitoredKey(candidate.key) && candidate.limit > 0 && candidate.used < candidate.limit;
+				if (lastOnFull === "switchQuota") return candidates.filter(cappedFree).sort((a, b) => a.used / a.limit - b.used / b.limit)[0];
+				if (lastOnFull === "switchAll") {
+					const withQuota = candidates.filter(cappedFree).sort((a, b) => a.used / a.limit - b.used / b.limit);
+					if (withQuota.length > 0) return withQuota[0];
+					return candidates.find((candidate) => isMonitoredKey(candidate.key) && candidate.limit <= 0);
+				}
 			};
 			/** Run the configured full-quota strategy once per exhausted model. */
 			const actOnFull = (snapshot) => {
@@ -960,7 +953,8 @@ window.__ModuleLoader__.load({
 				pullCount += 1;
 				const doc = scope.getSnapshot().value;
 				lastMonitored = doc?.monitored !== void 0 && doc.monitored.length > 0 ? doc.monitored : null;
-				lastOnFull = doc?.onFull ?? "stop";
+				const rawOnFull = doc?.onFull ?? "stop";
+				lastOnFull = rawOnFull === "switchPriority" ? "switchAll" : rawOnFull;
 				lastReset = doc?.reset !== void 0 && doc.reset !== null && typeof doc.reset === "object" && typeof doc.reset.offsetHours === "number" ? doc.reset : null;
 				bound?.setSettings(lastMonitored, lastOnFull);
 				bound?.setReset(lastReset);

package/lib/index.js

@@ -157,7 +157,7 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 					return {
 						limits: doc.limits ?? {},
 						monitored: doc.monitored ?? [],
-						onFull: doc.onFull ?? "stop",
+						onFull: doc.onFull === "switchPriority" ? "switchAll" : doc.onFull ?? "stop",
 						reset: doc.reset ?? void 0
 					};
 				};
@@ -358,11 +358,6 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 			};
 		};
 		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);
@@ -377,13 +372,10 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 		});
 		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));
+			case "switchAll": {
+				const cappedFree = candidates.filter((c) => c.monitored && c.limit > 0 && c.used < c.limit).sort((a, b) => a.used / a.limit - b.used / b.limit);
+				if (cappedFree.length > 0) return cappedFree[0];
+				return candidates.find((c) => c.monitored && c.limit <= 0);
 			}
 			default: return;
 		}

package/lib/types/client/TokenQuotaPanel.js

@@ -34,7 +34,6 @@ const FULL_ACTIONS = [
     { value: 'stop', labelKey: 'fullStop' },
     { value: 'switchQuota', labelKey: 'fullSwitchQuota' },
     { value: 'switchAll', labelKey: 'fullSwitchAll' },
-    { value: 'switchPriority', labelKey: 'fullSwitchPriority' },
 ];
 /**
  * Pointer-driven drag of a fixed-positioned element. Deltas are applied

package/lib/types/client/index.js

@@ -70,23 +70,23 @@ export function apply(ctx) {
                 });
             }
         }
-        const available = (candidate) => isMonitoredKey(candidate.key) && (candidate.limit <= 0 || candidate.used < candidate.limit);
+        const cappedFree = (candidate) => isMonitoredKey(candidate.key) && candidate.limit > 0 && candidate.used < candidate.limit;
         if (lastOnFull === 'switchQuota') {
             return candidates
-                .filter(candidate => isMonitoredKey(candidate.key) && candidate.limit > 0 && candidate.used < candidate.limit)
+                .filter(cappedFree)
                 .sort((a, b) => (a.used / a.limit) - (b.used / b.limit))[0];
         }
         if (lastOnFull === 'switchAll') {
-            return candidates.filter(available)[0];
+            // Monitored only: capped models with headroom first (lowest fill ratio),
+            // then uncapped monitored models as fallback.
+            const withQuota = candidates
+                .filter(cappedFree)
+                .sort((a, b) => (a.used / a.limit) - (b.used / b.limit));
+            if (withQuota.length > 0)
+                return withQuota[0];
+            return candidates.find(candidate => isMonitoredKey(candidate.key) && candidate.limit <= 0);
         }
-        // switchPriority: uncapped first, then unmonitored, then capped-but-free.
-        const uncapped = candidates.find(candidate => isMonitoredKey(candidate.key) && candidate.limit <= 0);
-        if (uncapped !== undefined)
-            return uncapped;
-        const unmonitored = candidates.find(candidate => !isMonitoredKey(candidate.key));
-        if (unmonitored !== undefined)
-            return unmonitored;
-        return candidates.find(available);
+        return undefined;
     };
     /** Run the configured full-quota strategy once per exhausted model. */
     const actOnFull = (snapshot) => {
@@ -159,7 +159,11 @@ export function apply(ctx) {
         pullCount += 1;
         const doc = scope.getSnapshot().value;
         lastMonitored = doc?.monitored !== undefined && doc.monitored.length > 0 ? doc.monitored : null;
-        lastOnFull = doc?.onFull ?? 'stop';
+        // Legacy `switchPriority` (removed in 0.1.7) maps to `switchAll`.
+        // The runtime document may still hold the old value until the user
+        // re-saves the settings dialog.
+        const rawOnFull = (doc?.onFull ?? 'stop');
+        lastOnFull = rawOnFull === 'switchPriority' ? 'switchAll' : rawOnFull;
         lastReset = doc?.reset !== undefined && doc.reset !== null
             && typeof doc.reset === 'object'
             && typeof doc.reset.offsetHours === 'number'

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

@@ -34,7 +34,6 @@ export declare const zh: {
     fullStop: string;
     fullSwitchQuota: string;
     fullSwitchAll: string;
-    fullSwitchPriority: string;
     fullNotice: string;
     fullSwitchFailed: string;
     fullSwitchTo: string;
@@ -82,7 +81,6 @@ export declare const en: {
     fullStop: string;
     fullSwitchQuota: string;
     fullSwitchAll: string;
-    fullSwitchPriority: string;
     fullNotice: string;
     fullSwitchFailed: string;
     fullSwitchTo: string;

package/lib/types/client/locales.js

@@ -33,8 +33,7 @@ export const zh = {
     fullActionLabel: '满额后处理',
     fullStop: '停止请求并提示',
     fullSwitchQuota: '自动切换到其它限额模型',
-    fullSwitchAll: '自动切换到其它可用模型（含非限额）',
-    fullSwitchPriority: '自动切换（优先非限额，其次未监控）',
+    fullSwitchAll: '自动切换（优先限额模型，其次非限额）',
     fullNotice: '当前模型今日额度已用尽，请求已停止。请选择其它模型或调整限额。',
     fullSwitchFailed: '没有可切换的模型，请手动选择其它模型或调整限额',
     fullSwitchTo: '已自动切换到 {model}',
@@ -79,8 +78,7 @@ export const en = {
     fullActionLabel: 'When a model is full',
     fullStop: 'Stop and prompt',
     fullSwitchQuota: 'Switch to another quota model',
-    fullSwitchAll: 'Switch to any other model (incl. uncapped)',
-    fullSwitchPriority: 'Prefer uncapped, then unmonitored',
+    fullSwitchAll: 'Switch models (quota models first, then uncapped)',
     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 \u2014 pick one manually or raise a limit',
     fullSwitchTo: 'Auto-switched to {model}',

package/lib/types/index.js

@@ -45,6 +45,10 @@ import { assertTokenQuotaLimit, splitTokenQuotaKey } from "./invariant.js";
 const TOKEN_QUOTA_SETTINGS_SCHEMA = z.object({
     limits: z.dict(z.number().step(1).min(0)).default({}),
     monitored: z.array(z.string()).default([]),
+    // `switchPriority` is a legacy value accepted for documents saved by older
+    // plugin versions; the runtime normalizes it to `switchAll` (see
+    // settingsSource below) so existing users keep auto-switching behavior
+    // without reconfiguring.
     onFull: z.union(['stop', 'switchQuota', 'switchAll', 'switchPriority']).default('stop'),
     // `reset` is a user-facing preference outside the validated surface: the
     // panel writes it and the host validates the shape at runtime. `z.any` with
@@ -147,7 +151,9 @@ export class TokenQuotaService extends Service {
                     return {
                         limits: doc.limits ?? {},
                         monitored: doc.monitored ?? [],
-                        onFull: doc.onFull ?? 'stop',
+                        // Legacy `switchPriority` (removed in 0.1.7) maps to `switchAll`:
+                        // capped models first, then uncapped — both monitored-only.
+                        onFull: doc.onFull === 'switchPriority' ? 'switchAll' : (doc.onFull ?? 'stop'),
                         reset: doc.reset ?? undefined,
                     };
                 };
@@ -362,12 +368,6 @@ export class TokenQuotaService extends Service {
             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)
@@ -386,21 +386,16 @@ export class TokenQuotaService extends Service {
                 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;
+                // Monitored models only. Capped models with headroom first (lowest
+                // fill ratio wins, spreading load), then uncapped monitored models as
+                // fallback — quotas are preferred, uncapped only when every capped
+                // monitored model is exhausted.
+                const cappedFree = candidates
+                    .filter(c => c.monitored && c.limit > 0 && c.used < c.limit)
+                    .sort((a, b) => (a.used / a.limit) - (b.used / b.limit));
+                if (cappedFree.length > 0)
+                    return cappedFree[0];
+                return candidates.find(c => c.monitored && c.limit <= 0);
             }
             default:
                 return undefined;

package/lib/types/types.d.ts

@@ -16,10 +16,10 @@ export declare const TOKEN_QUOTA_NAMESPACE = "token-quota";
 export declare const TOKEN_QUOTA_EXCEEDED_CODE = "TOKEN_QUOTA_EXCEEDED";
 /**
  * What to do once a monitored, quota-capped model reaches its daily cap.
- * Selected in the panel's settings dialog; the panel acts on it (b/c/d auto
+ * Selected in the panel's settings dialog; the panel acts on it (b/c auto
  * switch, a stops and prompts).
  */
-export declare const TOKEN_QUOTA_FULL_ACTIONS: readonly ["stop", "switchQuota", "switchAll", "switchPriority"];
+export declare const TOKEN_QUOTA_FULL_ACTIONS: readonly ["stop", "switchQuota", "switchAll"];
 /** One of the {@link TOKEN_QUOTA_FULL_ACTIONS} values. */
 export type TokenQuotaFullAction = typeof TOKEN_QUOTA_FULL_ACTIONS[number];
 /**
@@ -58,8 +58,9 @@ export interface TokenQuotaSettings {
     /**
      * Behavior when a monitored, capped model hits its daily cap:
      * `'stop'` stops and prompts, `'switchQuota'` auto-switches to another
-     * capped-but-available model, `'switchAll'` switches to any other available
-     * model, `'switchPriority'` prefers uncapped models then unmonitored ones.
+     * monitored capped-but-available model, `'switchAll'` auto-switches to
+     * another monitored available model — capped models first, uncapped ones
+     * as fallback. Only monitored models ever participate in a switch.
      */
     onFull: TokenQuotaFullAction;
     /**

package/lib/types/types.js

@@ -16,10 +16,10 @@ export const TOKEN_QUOTA_NAMESPACE = 'token-quota';
 export const TOKEN_QUOTA_EXCEEDED_CODE = 'TOKEN_QUOTA_EXCEEDED';
 /**
  * What to do once a monitored, quota-capped model reaches its daily cap.
- * Selected in the panel's settings dialog; the panel acts on it (b/c/d auto
+ * Selected in the panel's settings dialog; the panel acts on it (b/c auto
  * switch, a stops and prompts).
  */
-export const TOKEN_QUOTA_FULL_ACTIONS = ['stop', 'switchQuota', 'switchAll', 'switchPriority'];
+export const TOKEN_QUOTA_FULL_ACTIONS = ['stop', 'switchQuota', 'switchAll'];
 /** Default reset: machine-local midnight (offset = host timezone, 00:00). */
 export const TOKEN_QUOTA_DEFAULT_RESET = { offsetHours: 0, hour: 0, minute: 0 };
 /** Build the stable per-model key shared by the counter, settings, and snapshot. */

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.6",
+  "version": "0.1.7",
   "publishConfig": {
     "access": "public"
   },