@jxgame2020/dsh-token-quota 0.1.5 → 0.1.6

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",
+			"dialogBtnPrimary": "NPLLIq_dialogBtnPrimary",
+			"tabLabel": "NPLLIq_tabLabel",
+			"monitorHint": "NPLLIq_monitorHint",
 			"monitorRow": "NPLLIq_monitorRow",
-			"dialogTitle": "NPLLIq_dialogTitle",
+			"fillOver": "NPLLIq_fillOver",
 			"bar": "NPLLIq_bar",
-			"monitorHint": "NPLLIq_monitorHint",
-			"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",
-			"dialogBtn": "NPLLIq_dialogBtn",
-			"dialogHeader": "NPLLIq_dialogHeader",
-			"logScroll": "NPLLIq_logScroll",
-			"resetRow": "NPLLIq_resetRow",
-			"currentBadge": "NPLLIq_currentBadge",
 			"controls": "NPLLIq_controls",
-			"title": "NPLLIq_title",
-			"logUsedCol": "NPLLIq_logUsedCol",
-			"noticeError": "NPLLIq_noticeError",
+			"switch": "NPLLIq_switch",
 			"resetSelect": "NPLLIq_resetSelect",
+			"input": "NPLLIq_input",
+			"save": "NPLLIq_save",
+			"selectBtn": "NPLLIq_selectBtn",
+			"dialogActions": "NPLLIq_dialogActions",
 			"row": "NPLLIq_row",
-			"tabLabel": "NPLLIq_tabLabel",
+			"fillWarn": "NPLLIq_fillWarn",
+			"settingsBtn": "NPLLIq_settingsBtn",
 			"dialogSection": "NPLLIq_dialogSection",
-			"logTable": "NPLLIq_logTable",
+			"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",
+			"dialog": "NPLLIq_dialog",
+			"currentBadge": "NPLLIq_currentBadge",
+			"subtitle": "NPLLIq_subtitle",
+			"dialogBtn": "NPLLIq_dialogBtn",
 			"logDayCol": "NPLLIq_logDayCol",
-			"settingsBtn": "NPLLIq_settingsBtn",
-			"fillWarn": "NPLLIq_fillWarn"
+			"dialogHeader": "NPLLIq_dialogHeader",
+			"dialogLabel": "NPLLIq_dialogLabel",
+			"gearBtn": "NPLLIq_gearBtn",
+			"logModelCol": "NPLLIq_logModelCol",
+			"noticeError": "NPLLIq_noticeError",
+			"tabIcon": "NPLLIq_tabIcon",
+			"logHeader": "NPLLIq_logHeader",
+			"fullNotice": "NPLLIq_fullNotice",
+			"monitorList": "NPLLIq_monitorList",
+			"radioRow": "NPLLIq_radioRow",
+			"title": "NPLLIq_title",
+			"rowHeader": "NPLLIq_rowHeader",
+			"collapse": "NPLLIq_collapse"
 		};
 		//#endregion
 		//#region lib/types/client/TokenQuotaPanel.js
@@ -943,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);
+							}
+						});
 					}
 				}, () => {});
 			};
@@ -970,7 +977,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`). */
@@ -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

@@ -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);
+                        }
+                    });
+                }
             }
         }, () => { });
     };
@@ -165,7 +181,7 @@ export function apply(ctx) {
             bound?.setSnapshot(snapshot);
             actOnFull(snapshot);
         });
-        if (pullCount % 4 === 0)
+        if (pullCount % 2 === 0)
             refreshCurrent();
     };
     ctx.effect(() => {

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