@jxgame2020/dsh-token-quota 0.1.5 → 0.1.7

package/lib/client.js

@@ -129,59 +129,59 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var TokenQuotaPanel_module_css_default = {
-			"body": "NPLLIq_body",
-			"notice": "NPLLIq_notice",
-			"collapse": "NPLLIq_collapse",
-			"radioRow": "NPLLIq_radioRow",
-			"rowHeader": "NPLLIq_rowHeader",
-			"dialogClose": "NPLLIq_dialogClose",
-			"dialogActions": "NPLLIq_dialogActions",
-			"logHeader": "NPLLIq_logHeader",
-			"monitorRow": "NPLLIq_monitorRow",
-			"dialogTitle": "NPLLIq_dialogTitle",
-			"bar": "NPLLIq_bar",
-			"monitorHint": "NPLLIq_monitorHint",
+			"fillOver": "NPLLIq_fillOver",
+			"fillIdle": "NPLLIq_fillIdle",
 			"monitorList": "NPLLIq_monitorList",
-			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
-			"selectBtn": "NPLLIq_selectBtn",
-			"headerActions": "NPLLIq_headerActions",
 			"switch": "NPLLIq_switch",
-			"input": "NPLLIq_input",
-			"logModelCol": "NPLLIq_logModelCol",
-			"rowName": "NPLLIq_rowName",
-			"fillIdle": "NPLLIq_fillIdle",
 			"subtitle": "NPLLIq_subtitle",
-			"panel": "NPLLIq_panel",
-			"dialog": "NPLLIq_dialog",
-			"fullNotice": "NPLLIq_fullNotice",
-			"headerText": "NPLLIq_headerText",
-			"save": "NPLLIq_save",
-			"rowMeta": "NPLLIq_rowMeta",
-			"fillOver": "NPLLIq_fillOver",
-			"tabIcon": "NPLLIq_tabIcon",
-			"header": "NPLLIq_header",
-			"tab": "NPLLIq_tab",
-			"gearBtn": "NPLLIq_gearBtn",
-			"dialogLabel": "NPLLIq_dialogLabel",
 			"monitorName": "NPLLIq_monitorName",
+			"currentBadge": "NPLLIq_currentBadge",
+			"collapse": "NPLLIq_collapse",
+			"row": "NPLLIq_row",
+			"fillWarn": "NPLLIq_fillWarn",
+			"rowHeader": "NPLLIq_rowHeader",
+			"input": "NPLLIq_input",
+			"radioRow": "NPLLIq_radioRow",
+			"logHeader": "NPLLIq_logHeader",
+			"logModelCol": "NPLLIq_logModelCol",
+			"logDayCol": "NPLLIq_logDayCol",
 			"dialogBtn": "NPLLIq_dialogBtn",
-			"dialogHeader": "NPLLIq_dialogHeader",
+			"dialogActions": "NPLLIq_dialogActions",
+			"logDialog": "NPLLIq_logDialog",
+			"notice": "NPLLIq_notice",
+			"tabLabel": "NPLLIq_tabLabel",
+			"dialog": "NPLLIq_dialog",
 			"logScroll": "NPLLIq_logScroll",
 			"resetRow": "NPLLIq_resetRow",
-			"currentBadge": "NPLLIq_currentBadge",
-			"controls": "NPLLIq_controls",
+			"rowMeta": "NPLLIq_rowMeta",
+			"tab": "NPLLIq_tab",
+			"monitorHint": "NPLLIq_monitorHint",
 			"title": "NPLLIq_title",
-			"logUsedCol": "NPLLIq_logUsedCol",
 			"noticeError": "NPLLIq_noticeError",
+			"monitorRow": "NPLLIq_monitorRow",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"tabIcon": "NPLLIq_tabIcon",
+			"rowName": "NPLLIq_rowName",
+			"save": "NPLLIq_save",
+			"fullNotice": "NPLLIq_fullNotice",
+			"dialogClose": "NPLLIq_dialogClose",
+			"header": "NPLLIq_header",
+			"bar": "NPLLIq_bar",
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"headerText": "NPLLIq_headerText",
+			"selectBtn": "NPLLIq_selectBtn",
 			"resetSelect": "NPLLIq_resetSelect",
-			"row": "NPLLIq_row",
-			"tabLabel": "NPLLIq_tabLabel",
-			"dialogSection": "NPLLIq_dialogSection",
 			"logTable": "NPLLIq_logTable",
-			"logDialog": "NPLLIq_logDialog",
-			"logDayCol": "NPLLIq_logDayCol",
+			"panel": "NPLLIq_panel",
+			"controls": "NPLLIq_controls",
+			"headerActions": "NPLLIq_headerActions",
+			"body": "NPLLIq_body",
 			"settingsBtn": "NPLLIq_settingsBtn",
-			"fillWarn": "NPLLIq_fillWarn"
+			"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) => {
@@ -943,9 +936,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);
+							}
+						});
 					}
 				}, () => {});
 			};
@@ -953,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);
@@ -970,7 +971,7 @@ window.__ModuleLoader__.load({
 					bound?.setSnapshot(snapshot);
 					actOnFull(snapshot);
 				});
-				if (pullCount % 4 === 0) refreshCurrent();
+				if (pullCount % 2 === 0) refreshCurrent();
 			};
 			ctx.effect(() => {
 				pull();

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`). */
@@ -152,7 +157,7 @@ var TokenQuotaService = class 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
 					};
 				};
@@ -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,71 @@ 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 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": {
+				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;
+		}
+	}
 	async onRequest(payload, next) {
 		const config = await next();
 		const { provider, model } = config;
@@ -319,6 +391,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/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) => {
@@ -126,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);
+                        }
+                    });
+                }
             }
         }, () => { });
     };
@@ -143,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'
@@ -165,7 +185,7 @@ export function apply(ctx) {
             bound?.setSnapshot(snapshot);
             actOnFull(snapshot);
         });
-        if (pullCount % 4 === 0)
+        if (pullCount % 2 === 0)
             refreshCurrent();
     };
     ctx.effect(() => {

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.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

@@ -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
@@ -114,6 +118,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`). */
@@ -142,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,
                     };
                 };
@@ -194,10 +205,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 +317,90 @@ 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);
+        // 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': {
+                // 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;
+        }
+    }
     async onRequest(payload, next) {
         const config = await next();
         const { provider, model } = config;
@@ -318,6 +419,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/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.5",
+  "version": "0.1.7",
   "publishConfig": {
     "access": "public"
   },