@jxgame2020/dsh-token-quota 0.1.0

package/lib/index.js

@@ -0,0 +1,387 @@
+import { assertTokenQuotaLimit, splitTokenQuotaKey } from "./invariant.js";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import "@deepseek-ai/dsh-agent";
+import { LlmError } from "@deepseek-ai/dsh-llm";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+//#region lib/types/types.js
+/**
+* Shared wire/type vocabulary for the daily token-quota plugin.
+*
+* The Host half owns the durable per-model daily counter and the enforcement
+* gate; the browser half renders a floating panel from the snapshot it pulls
+* over a plugin-owned HTTP route, and writes per-model limits and panel
+* preferences through the settings document. This module is the one meeting
+* point of the two planes: it carries strings and shapes only, never a
+* runtime import from the other half.
+*
+* @module @jxgame2020/dsh-token-quota/types
+*/
+/** Settings namespace owning the per-model daily limits document. */
+const TOKEN_QUOTA_NAMESPACE = "token-quota";
+/** Stable machine code thrown from `agent/request` when a model is over its daily cap. */
+const TOKEN_QUOTA_EXCEEDED_CODE = "TOKEN_QUOTA_EXCEEDED";
+/** Build the stable per-model key shared by the counter, settings, and snapshot. */
+function tokenQuotaKey(provider, model) {
+	return `${provider}/${model}`;
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Daily per-model token quota enforcement and accounting for the harness.
+*
+* The service owns three responsibilities, all driven by the existing agent
+* and session extension points — no loop modification:
+*
+* 1. **Accounting** — folds each live session's `request/header` to learn the
+*    `provider/model` in use, and credits the combined input + output + cache
+*    token count of every `assistant/message` that reports provider usage into
+*    that model's current-UTC-day bucket. Counters persist to a JSON file
+*    under the Harness home and roll over automatically at UTC midnight.
+*
+* 2. **Enforcement** — on the `agent/request` waterfall it awaits the resolved
+*    call config, and when the selected model's daily usage is at or above its
+*    configured cap (a positive limit), it throws an {@link LlmError} with
+*    `TOKEN_QUOTA_EXCEEDED`, ending the turn before any provider request is
+*    dispatched. A limit of `0` (or no entry) leaves the model unlimited.
+*
+* 3. **Limits + pull** — per-model limits live in the settings document
+*    (`token-quota` namespace, written by the Web panel through the settings
+*    scope); every change re-reads them. The current snapshot is served to
+*    consumers over a plugin-owned HTTP route (`GET /token-quota`, registered
+*    on the existing `webServer` service when one exists); the browser panel
+*    polls it, so no core-Harness wiring or generated RPC contract is needed.
+*
+* The browser half (`src/client/`) renders a floating panel from the polled
+* snapshot and writes limits back through the settings scope; this module
+* stays browser-free (the optional route is plain node:http).
+*
+* @module @jxgame2020/dsh-token-quota
+*/
+/** Settings schema resolving the per-model daily caps document. */
+const TOKEN_QUOTA_SETTINGS_SCHEMA = z.object({
+	limits: z.dict(z.number().step(1).min(0)).default({}),
+	monitored: z.array(z.string()).default([]),
+	onFull: z.union([
+		"stop",
+		"switchQuota",
+		"switchAll",
+		"switchPriority"
+	]).default("stop"),
+	reset: z.any().default(null)
+});
+/** Two-digit zero-pad helper. */
+function pad2(value) {
+	return String(value).padStart(2, "0");
+}
+/** The machine's own UTC offset in whole hours (default reset timezone). */
+function localOffsetHours(now = /* @__PURE__ */ new Date()) {
+	return -now.getTimezoneOffset() / 60;
+}
+/**
+* Resolve the reset-cycle key a timestamp belongs to: the `YYYY-MM-DD@HH:MM`
+* label (in the configured timezone) of the cycle whose `hour:minute` reset
+* moment contains the timestamp. With the default config (machine timezone,
+* 00:00) this reproduces the historical "resets at machine midnight".
+*/
+function cycleKey(now, reset) {
+	const offsetMs = reset.offsetHours * 36e5;
+	const zoned = new Date(now.getTime() + offsetMs);
+	const cycleStartToday = Date.UTC(zoned.getUTCFullYear(), zoned.getUTCMonth(), zoned.getUTCDate()) - offsetMs + (reset.hour * 60 + reset.minute) * 6e4;
+	const cycleStartUtc = now.getTime() >= cycleStartToday ? cycleStartToday : cycleStartToday - 864e5;
+	const startZoned = new Date(cycleStartUtc + offsetMs);
+	return `${startZoned.getUTCFullYear()}-${pad2(startZoned.getUTCMonth() + 1)}-${pad2(startZoned.getUTCDate())}@${pad2(reset.hour)}:${pad2(reset.minute)}`;
+}
+/** Default counter file under the Harness home (overridable through config). */
+function defaultStoragePath() {
+	const home = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	return join(home, "token-quota.json");
+}
+/** Combined input + output + cache token count of one provider usage report. */
+function usageTokens(usage) {
+	return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + usage.outputTokens;
+}
+/**
+* Daily token-quota service.
+*
+* 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 {
+	static Config = z.object({ storagePath: z.string().default("") });
+	storagePath;
+	reset = {
+		offsetHours: localOffsetHours(),
+		hour: 0,
+		minute: 0
+	};
+	cycle = cycleKey(/* @__PURE__ */ new Date(), this.reset);
+	usage = {};
+	history = {};
+	limits = {};
+	monitored = void 0;
+	settingsSource = () => ({
+		limits: {},
+		monitored: [],
+		onFull: "stop"
+	});
+	/** Per-session folded model key from the latest `request/header`. */
+	headerKeys = /* @__PURE__ */ new WeakMap();
+	writeTimer;
+	/** Disposer for the optional HTTP snapshot route (`GET /token-quota`). */
+	disposeRoute;
+	/** Disposer for the optional usage-history route (`GET /token-quota/log`). */
+	disposeRouteLog;
+	/** Disposer for the webServer-arrival watcher when the service mounts later. */
+	disposeRouteWatcher;
+	/**
+	* @param ctx - owning context (events and the settings section register on it).
+	* @param config - optional counter path.
+	*/
+	constructor(ctx, config = {}) {
+		super(ctx, "tokenQuota");
+		this.storagePath = config.storagePath !== void 0 && config.storagePath.length > 0 ? config.storagePath : defaultStoragePath();
+		this.load();
+		installSettingsSection(ctx, settingsNamespace(TOKEN_QUOTA_NAMESPACE), TOKEN_QUOTA_SETTINGS_SCHEMA, { limits: {} }, {
+			setSource: (current) => {
+				this.settingsSource = () => {
+					const doc = current();
+					return {
+						limits: doc.limits ?? {},
+						monitored: doc.monitored ?? [],
+						onFull: doc.onFull ?? "stop",
+						reset: doc.reset ?? void 0
+					};
+				};
+			},
+			validate: (value) => {
+				for (const [key, limit] of Object.entries(value.limits ?? {})) {
+					assertTokenQuotaLimit(limit, key);
+					splitTokenQuotaKey(key);
+				}
+			},
+			onChange: () => {
+				const doc = this.settingsSource();
+				this.limits = { ...doc.limits };
+				this.monitored = doc.monitored !== void 0 && doc.monitored.length > 0 ? new Set(doc.monitored) : void 0;
+				if (doc.reset !== void 0 && typeof doc.reset === "object" && doc.reset !== null && typeof doc.reset.offsetHours === "number" && typeof doc.reset.hour === "number" && typeof doc.reset.minute === "number") {
+					const configured = doc.reset;
+					this.reset = {
+						offsetHours: Math.max(-12, Math.min(14, Math.round(configured.offsetHours))),
+						hour: Math.max(0, Math.min(23, Math.round(configured.hour))),
+						minute: Math.max(0, Math.min(59, Math.round(configured.minute)))
+					};
+					this.rollCycleIfNeeded();
+				} else {
+					this.reset = {
+						offsetHours: localOffsetHours(),
+						hour: 0,
+						minute: 0
+					};
+					this.rollCycleIfNeeded();
+				}
+			}
+		});
+		this.tryMountRoute();
+		if (this.disposeRoute === void 0) this.disposeRouteWatcher = ctx.on("internal/service", (name) => {
+			if (name === "webServer") this.tryMountRoute();
+		});
+		ctx.on("session/event", (session, event) => {
+			this.onSessionEvent(session, event);
+		});
+		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. */
+	tryMountRoute() {
+		const server = this.ctx.get("webServer");
+		if (server === void 0 || this.disposeRoute !== void 0) return;
+		this.disposeRoute = server.register({
+			kind: "exact",
+			path: "/token-quota",
+			handler: (_req, res) => {
+				const body = JSON.stringify(this.readSnapshot());
+				res.writeHead(200, {
+					"content-type": "application/json",
+					"cache-control": "no-store"
+				});
+				res.end(body);
+			}
+		});
+		this.disposeRouteLog = server.register({
+			kind: "exact",
+			path: "/token-quota/log",
+			handler: (_req, res) => {
+				const body = JSON.stringify(this.readLog());
+				res.writeHead(200, {
+					"content-type": "application/json",
+					"cache-control": "no-store"
+				});
+				res.end(body);
+			}
+		});
+	}
+	/** Read the full per-cycle usage history (log dialog data). */
+	readLog() {
+		this.rollCycleIfNeeded();
+		const entries = [];
+		for (const [cycle, usageByKey] of Object.entries(this.history)) for (const [key, used] of Object.entries(usageByKey)) {
+			const parts = this.safeSplit(key);
+			if (parts === void 0 || used <= 0) continue;
+			entries.push({
+				day: cycle,
+				key,
+				provider: parts.provider,
+				model: parts.model,
+				used
+			});
+		}
+		for (const [key, used] of Object.entries(this.usage)) {
+			const parts = this.safeSplit(key);
+			if (parts === void 0 || used <= 0) continue;
+			entries.push({
+				day: this.cycle,
+				key,
+				provider: parts.provider,
+				model: parts.model,
+				used
+			});
+		}
+		entries.sort((left, right) => right.day.localeCompare(left.day) || left.key.localeCompare(right.key));
+		return { entries };
+	}
+	/** Read the current snapshot (also used by tests and inspection). */
+	readSnapshot() {
+		this.rollCycleIfNeeded();
+		const keys = /* @__PURE__ */ new Set([...Object.keys(this.usage), ...Object.keys(this.limits)]);
+		const entries = [];
+		for (const key of keys) {
+			const parts = this.safeSplit(key);
+			if (parts === void 0) continue;
+			entries.push({
+				key,
+				provider: parts.provider,
+				model: parts.model,
+				used: this.usage[key] ?? 0,
+				limit: this.limitOf(key)
+			});
+		}
+		entries.sort((left, right) => left.key.localeCompare(right.key));
+		return {
+			day: this.cycle,
+			entries
+		};
+	}
+	/** Today's used tokens for one model key, or `0`. */
+	usedToday(key) {
+		this.rollCycleIfNeeded();
+		return this.usage[key] ?? 0;
+	}
+	/** Whether a model is under active monitoring (undefined = every model). */
+	isMonitored(key) {
+		return this.monitored === void 0 || this.monitored.has(key);
+	}
+	/** Resolve one model's daily cap: positive = capped, `0` = unlimited. */
+	limitOf(key) {
+		const limit = this.limits[key];
+		return typeof limit === "number" && Number.isInteger(limit) && limit > 0 ? limit : 0;
+	}
+	onSessionEvent(session, event) {
+		if (event.type === "request/header") {
+			const { provider, model } = event.data.header.config;
+			this.headerKeys.set(session, tokenQuotaKey(provider, model));
+			return;
+		}
+		if (event.type === "assistant/message" && event.data.usage !== void 0) {
+			const key = this.headerKeys.get(session);
+			if (key === void 0) return;
+			if (!this.isMonitored(key)) return;
+			const tokens = usageTokens(event.data.usage);
+			if (tokens <= 0) return;
+			this.rollCycleIfNeeded();
+			this.usage[key] = (this.usage[key] ?? 0) + tokens;
+			this.scheduleWrite();
+		}
+	}
+	async onRequest(payload, next) {
+		const config = await next();
+		const { provider, model } = config;
+		if (!provider || !model) return config;
+		const key = tokenQuotaKey(provider, model);
+		this.headerKeys.set(payload.agent.session, key);
+		if (!this.isMonitored(key)) return config;
+		const limit = this.limitOf(key);
+		if (limit <= 0) return config;
+		const used = this.usage[key] ?? 0;
+		if (used < limit) return config;
+		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);
+	}
+	/**
+	* Roll over to a new reset cycle, archiving the finished cycle's counters
+	* into the history log, when the cycle key changed.
+	* @returns whether a rollover happened.
+	*/
+	rollCycleIfNeeded() {
+		const now = cycleKey(/* @__PURE__ */ new Date(), this.reset);
+		if (this.cycle === now) return false;
+		if (Object.keys(this.usage).length > 0) this.history[this.cycle] = { ...this.usage };
+		this.cycle = now;
+		this.usage = {};
+		this.scheduleWrite();
+		return true;
+	}
+	scheduleWrite() {
+		if (this.writeTimer !== void 0) return;
+		this.writeTimer = setTimeout(() => {
+			this.writeTimer = void 0;
+			this.flush();
+		}, 500);
+	}
+	flush() {
+		if (this.writeTimer !== void 0) {
+			clearTimeout(this.writeTimer);
+			this.writeTimer = void 0;
+		}
+		try {
+			mkdirSync(dirname(this.storagePath), { recursive: true });
+			writeFileSync(this.storagePath, JSON.stringify({
+				cycle: this.cycle,
+				usage: this.usage,
+				history: this.history
+			}, null, 2));
+		} catch (error) {
+			this.ctx.logger.warn("token-quota: failed to persist counters: %o", error);
+		}
+	}
+	load() {
+		try {
+			const candidate = JSON.parse(readFileSync(this.storagePath, "utf8"));
+			this.cycle = typeof candidate?.cycle === "string" && candidate.cycle.length > 0 ? candidate.cycle : typeof candidate?.day === "string" && candidate.day.length > 0 ? candidate.day : cycleKey(/* @__PURE__ */ new Date(), this.reset);
+			const usage = candidate?.usage;
+			this.usage = typeof usage === "object" && usage !== null && !Array.isArray(usage) ? usage : {};
+			const history = candidate?.history;
+			this.history = typeof history === "object" && history !== null && !Array.isArray(history) ? history : {};
+			this.rollCycleIfNeeded();
+		} catch {}
+	}
+	disposeLocal() {
+		if (this.disposeRouteWatcher !== void 0) this.disposeRouteWatcher();
+		if (this.disposeRoute !== void 0) this.disposeRoute();
+		if (this.disposeRouteLog !== void 0) this.disposeRouteLog();
+		this.flush();
+	}
+	safeSplit(key) {
+		try {
+			return splitTokenQuotaKey(key);
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+export { TokenQuotaService, TokenQuotaService as default };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Runtime guards for the token-quota plugin's public boundary.
+*
+* A separate companion module keeps these reachable from both the Host and
+* Client build faces without dragging the service implementation into a
+* browser bundle.
+*
+* @module @jxgame2020/dsh-token-quota/invariant
+*/
+/** Accept one per-model daily limit: `0` (unlimited) or a positive integer. */
+function assertTokenQuotaLimit(value, key) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new TypeError(`token-quota: limit for "${key}" must be a non-negative integer, received ${String(value)}`);
+}
+/** Resolve a model key of the form `provider/model` into its two parts. */
+function splitTokenQuotaKey(key) {
+	const slash = key.indexOf("/");
+	if (slash <= 0 || slash === key.length - 1) throw new TypeError(`token-quota: invalid model key "${key}" — expected "provider/model"`);
+	return {
+		provider: key.slice(0, slash),
+		model: key.slice(slash + 1)
+	};
+}
+//#endregion
+export { assertTokenQuotaLimit, splitTokenQuotaKey };

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

@@ -0,0 +1,28 @@
+import type { PropsLocale, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SessionId } from '@deepseek-ai/dsh-api-remotes/client';
+import type { TokenQuotaFullAction, TokenQuotaReset } from '@jxgame2020/dsh-token-quota/types';
+import type { createTokenQuotaPanelStore } from './store.ts';
+/** Injected business face: data loading and mutations wired in `apply`. */
+export interface TokenQuotaPanelInjected {
+    /** Refresh the model directory for one session. */
+    load: (sessionId: SessionId) => void;
+    /** Persist one model's daily cap (0 = unlimited) through the settings scope. */
+    setLimit: (key: string, limit: number) => void;
+    /** Switch the current session to one route through the Host RPC. */
+    selectModel: (sessionId: SessionId, provider: string, model: string) => void;
+    /** Persist the monitored-model selection (null = every model). */
+    setMonitored: (monitored: string[] | null) => void;
+    /** Persist the full-quota strategy. */
+    setOnFull: (action: TokenQuotaFullAction) => void;
+    /** Persist the daily reset moment (null = machine-local midnight). */
+    setReset: (reset: TokenQuotaReset | null) => void;
+}
+/** Full component props: runtime + store + locale + injected face. */
+export type TokenQuotaPanelComponentProps = PropsRuntime<'shell.overlay'> & PropsStore<ReturnType<typeof createTokenQuotaPanelStore>> & PropsLocale<'token-quota'> & TokenQuotaPanelInjected;
+/**
+ * Render the floating panel (or its collapsed tab).
+ * @param props - composed slot props.
+ * @returns the panel element tree.
+ */
+export declare function TokenQuotaPanel({ t, load, setLimit, selectModel, setMonitored, setOnFull, setReset, useStore, actions, useSessions, }: TokenQuotaPanelComponentProps): import("react").JSX.Element;
+//# sourceMappingURL=TokenQuotaPanel.d.ts.map

package/lib/types/client/TokenQuotaPanel.js

@@ -0,0 +1,147 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Token-quota floating panel, registered into the frame-wide `shell.overlay`
+ * seat. Renders one row per MONITORED model of the current session's
+ * directory merged with the live quota snapshot: name, a compact `选择` action,
+ * `used / limit`, a progress bar, and an icon-folded limit editor. A settings
+ * dialog (header button) chooses which models are monitored and what to do
+ * when a capped model is full. The panel is pure presentation — every fact
+ * arrives through the props shares and every mutation through the injected
+ * callbacks.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { mergeModelRows } from "./store.js";
+import css from './TokenQuotaPanel.module.css';
+/** Compact a token count for display. */
+function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+function barStateOf(row) {
+    if (row.limit <= 0)
+        return row.used > 0 ? 'warn' : 'idle';
+    if (row.used >= row.limit)
+        return 'over';
+    if (row.used / row.limit >= 0.8)
+        return 'warn';
+    return 'idle';
+}
+/** Full-quota strategy choices, in display order. */
+const FULL_ACTIONS = [
+    { value: 'stop', labelKey: 'fullStop' },
+    { value: 'switchQuota', labelKey: 'fullSwitchQuota' },
+    { value: 'switchAll', labelKey: 'fullSwitchAll' },
+    { value: 'switchPriority', labelKey: 'fullSwitchPriority' },
+];
+/**
+ * Render the floating panel (or its collapsed tab).
+ * @param props - composed slot props.
+ * @returns the panel element tree.
+ */
+export function TokenQuotaPanel({ t, load, setLimit, selectModel, setMonitored, setOnFull, setReset, useStore, actions, useSessions, }) {
+    const [collapsed, setCollapsed] = useState(false);
+    const [drafts, setDrafts] = useState({});
+    const [editingKey, setEditingKey] = useState(null);
+    const sessionId = useSessions(s => s.current);
+    const snapshot = useStore(s => s.snapshot);
+    const groups = useStore(s => s.groups);
+    const current = useStore(s => s.current);
+    const monitored = useStore(s => s.monitored);
+    const onFull = useStore(s => s.onFull);
+    const reset = useStore(s => s.reset);
+    const dialogOpen = useStore(s => s.dialogOpen);
+    const logOpen = useStore(s => s.logOpen);
+    const log = useStore(s => s.log);
+    const fullNotice = useStore(s => s.fullNotice);
+    const loading = useStore(s => s.loading);
+    const error = useStore(s => s.error);
+    // Refresh the advisory model directory whenever the current session changes.
+    useEffect(() => {
+        if (sessionId !== undefined)
+            load(sessionId);
+    }, [sessionId, load]);
+    const rows = useMemo(() => mergeModelRows(groups, snapshot, current), [groups, snapshot, current]);
+    // All directory models, flattened for the monitoring picker.
+    const allModels = useMemo(() => groups.flatMap(group => group.models.map((model) => ({
+        key: `${group.id}/${model.id}`,
+        name: model.name,
+    }))).sort((a, b) => a.key.localeCompare(b.key)), [groups]);
+    const isMonitoredKey = (key) => monitored === null || monitored.includes(key);
+    if (collapsed) {
+        return (_jsx("div", { className: css.tab, role: "button", tabIndex: 0, title: t('title'), onClick: () => { setCollapsed(false); }, children: _jsx("span", { className: css.tabLabel, children: t('expand') }) }));
+    }
+    const openSettings = () => {
+        actions.setDialogOpen(true);
+    };
+    // Fetch the usage log whenever the log dialog opens.
+    useEffect(() => {
+        if (!logOpen)
+            return;
+        let cancelled = false;
+        void fetch('/token-quota/log', { headers: { accept: 'application/json' } }).then((response) => response.json(), () => null).then((data) => {
+            if (!cancelled)
+                actions.setLog(data);
+        });
+        return () => { cancelled = true; };
+    }, [logOpen, actions]);
+    const commitLimit = (row) => {
+        const raw = drafts[row.key]?.trim();
+        setDrafts((prev) => {
+            const { [row.key]: _dropped, ...rest } = prev;
+            return rest;
+        });
+        setEditingKey(null);
+        if (raw === undefined || raw === '')
+            return;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed) || parsed < 0 || !Number.isInteger(parsed))
+            return;
+        setLimit(row.key, parsed);
+    };
+    const visibleRows = rows.filter(row => isMonitoredKey(row.key) || row.current);
+    return (_jsxs("div", { className: css.panel, children: [_jsxs("div", { className: css.header, children: [_jsxs("div", { className: css.headerText, children: [_jsx("div", { className: css.title, children: t('title') }), _jsx("div", { className: css.subtitle, children: t('subtitle') })] }), _jsxs("div", { className: css.headerActions, children: [_jsx("button", { type: "button", className: css.settingsBtn, onClick: () => { actions.setLogOpen(true); }, children: t('logs') }), _jsx("button", { type: "button", className: css.settingsBtn, onClick: openSettings, children: t('settings') }), _jsx("button", { type: "button", className: css.collapse, onClick: () => { setCollapsed(true); }, children: t('collapse') })] })] }), _jsxs("div", { className: css.body, children: [loading && _jsx("div", { className: css.notice, children: t('loading') }), error !== null && _jsx("div", { className: css.noticeError, children: error }), fullNotice !== null && (_jsx("div", { className: css.fullNotice, role: "alert", children: fullNotice })), !loading && error === null && visibleRows.length === 0 && (_jsx("div", { className: css.notice, children: monitored !== null && monitored.length === 0 ? t('noMonitored') : t('waiting') })), visibleRows.map((row) => {
+                        const state = barStateOf(row);
+                        const pct = row.limit > 0 ? Math.min(100, Math.round((row.used / row.limit) * 100)) : 0;
+                        const barClass = state === 'over'
+                            ? css.fillOver
+                            : state === 'warn'
+                                ? css.fillWarn
+                                : css.fillIdle;
+                        const editing = editingKey === row.key;
+                        return (_jsxs("div", { className: css.row, children: [_jsxs("div", { className: css.rowHeader, children: [_jsxs("span", { className: css.rowName, title: row.key, children: [row.name, row.current && _jsx("span", { className: css.currentBadge, children: t('current') }), sessionId !== undefined && !row.current && (_jsx("button", { type: "button", className: css.selectBtn, onClick: () => { selectModel(sessionId, row.provider, row.model); }, children: t('select') }))] }), _jsxs("span", { className: css.rowMeta, children: [row.limit > 0
+                                                    ? `${formatTokens(row.used)} / ${formatTokens(row.limit)}`
+                                                    : `${formatTokens(row.used)} · ${t('unlimited')}`, _jsx("button", { type: "button", className: css.gearBtn, title: t('setLimitHint'), onClick: () => { setEditingKey(editing ? null : row.key); }, children: "\u2699" })] })] }), _jsx("div", { className: css.bar, children: _jsx("div", { className: barClass, style: { width: `${pct}%` } }) }), editing && (_jsxs("div", { className: css.controls, children: [_jsx("input", { className: css.input, type: "number", min: 0, step: 10000, placeholder: t('limitPlaceholder'), value: drafts[row.key] ?? '', onChange: (event) => { setDrafts(prev => ({ ...prev, [row.key]: event.target.value })); }, onKeyDown: (event) => { if (event.key === 'Enter')
+                                                commitLimit(row); } }), _jsx("button", { type: "button", className: css.save, onClick: () => { commitLimit(row); }, children: t('save') })] }))] }, row.key));
+                    })] }), dialogOpen && (_jsx("div", { className: css.dialogBackdrop, onClick: () => { actions.setDialogOpen(false); }, children: _jsxs("div", { className: css.dialog, onClick: (event) => { event.stopPropagation(); }, children: [_jsxs("div", { className: css.dialogHeader, children: [_jsx("div", { className: css.dialogTitle, children: t('settingsTitle') }), _jsx("button", { type: "button", className: css.dialogClose, title: t('close'), onClick: () => { actions.setDialogOpen(false); }, children: "\u00D7" })] }), _jsxs("div", { className: css.dialogSection, children: [_jsx("div", { className: css.dialogLabel, children: t('monitorLabel') }), _jsx("div", { className: css.monitorHint, children: t('monitorHint') }), _jsx("div", { className: css.monitorList, children: allModels.map(model => (_jsxs("label", { className: css.monitorRow, children: [_jsx("input", { type: "checkbox", checked: monitored === null || monitored.includes(model.key), onChange: (event) => {
+                                                    const base = monitored === null ? allModels.map(m => m.key) : monitored;
+                                                    const next = new Set(base);
+                                                    if (event.target.checked)
+                                                        next.add(model.key);
+                                                    else
+                                                        next.delete(model.key);
+                                                    // Auto-save on every change; all selected stores as null.
+                                                    setMonitored(next.size === allModels.length ? null : [...next]);
+                                                } }), _jsx("span", { className: css.monitorName, title: model.key, children: model.name })] }, model.key))) })] }), _jsxs("div", { className: css.dialogSection, children: [_jsx("div", { className: css.dialogLabel, children: t('fullActionLabel') }), FULL_ACTIONS.map(action => (_jsxs("label", { className: css.radioRow, children: [_jsx("input", { type: "radio", name: "token-quota-onfull", checked: onFull === action.value, onChange: () => { setOnFull(action.value); } }), _jsx("span", { children: t(action.labelKey) })] }, action.value)))] }), _jsxs("div", { className: css.dialogSection, children: [_jsx("div", { className: css.dialogLabel, children: t('resetLabel') }), _jsx("div", { className: css.monitorHint, children: t('resetHint') }), _jsxs("div", { className: css.resetRow, children: [_jsx("select", { className: css.resetSelect, value: reset?.offsetHours ?? -new Date().getTimezoneOffset() / 60, onChange: (event) => {
+                                                setReset({
+                                                    offsetHours: Number(event.target.value),
+                                                    hour: reset?.hour ?? 0,
+                                                    minute: reset?.minute ?? 0,
+                                                });
+                                            }, children: Array.from({ length: 27 }, (_, i) => i - 12).map(offset => (_jsxs("option", { value: offset, children: ["UTC", offset >= 0 ? `+${offset}` : offset] }, offset))) }), _jsx("select", { className: css.resetSelect, value: reset?.hour ?? 0, onChange: (event) => {
+                                                setReset({
+                                                    offsetHours: reset?.offsetHours ?? -new Date().getTimezoneOffset() / 60,
+                                                    hour: Number(event.target.value),
+                                                    minute: reset?.minute ?? 0,
+                                                });
+                                            }, children: Array.from({ length: 24 }, (_, i) => i).map(hour => (_jsxs("option", { value: hour, children: [String(hour).padStart(2, '0'), " \u65F6"] }, hour))) }), _jsx("select", { className: css.resetSelect, value: reset?.minute ?? 0, onChange: (event) => {
+                                                setReset({
+                                                    offsetHours: reset?.offsetHours ?? -new Date().getTimezoneOffset() / 60,
+                                                    hour: reset?.hour ?? 0,
+                                                    minute: Number(event.target.value),
+                                                });
+                                            }, children: Array.from({ length: 12 }, (_, i) => i * 5).map(minute => (_jsxs("option", { value: minute, children: [String(minute).padStart(2, '0'), " \u5206"] }, minute))) })] })] })] }) })), logOpen && (_jsx("div", { className: css.dialogBackdrop, onClick: () => { actions.setLogOpen(false); }, children: _jsxs("div", { className: css.dialog, onClick: (event) => { event.stopPropagation(); }, children: [_jsxs("div", { className: css.dialogHeader, children: [_jsx("div", { className: css.dialogTitle, children: t('logsTitle') }), _jsx("button", { type: "button", className: css.dialogClose, title: t('close'), onClick: () => { actions.setLogOpen(false); }, children: "\u00D7" })] }), log !== null && log.entries.length === 0 && (_jsx("div", { className: css.notice, children: t('logEmpty') })), _jsxs("table", { className: css.logTable, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: t('logDay') }), _jsx("th", { children: t('logModel') }), _jsx("th", { className: css.logUsedCol, children: t('logUsed') })] }) }), _jsx("tbody", { children: log?.entries.map(entry => (_jsxs("tr", { children: [_jsx("td", { className: css.logDayCol, children: entry.day }), _jsx("td", { className: css.logModelCol, title: entry.key, children: entry.key }), _jsx("td", { className: css.logUsedCol, children: formatTokens(entry.used) })] }, `${entry.day}/${entry.key}`))) })] })] }) }))] }));
+}
+//# sourceMappingURL=TokenQuotaPanel.js.map

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

@@ -0,0 +1,36 @@
+/**
+ * Token-quota browser half: a floating panel over the frame-wide
+ * `shell.overlay` seat. It renders one row per MONITORED model (directory
+ * merged with the polled quota snapshot), edits per-model daily caps through
+ * the settings scope, and switches the current session's model through the
+ * Host RPC — so when one model is full the user flips to another in place.
+ *
+ * Data flows by pull: the panel polls the plugin's own HTTP snapshot route
+ * (`GET /token-quota`) on a short interval and syncs monitoring/strategy
+ * preferences from the `token-quota` settings namespace. When the current
+ * model is a monitored, capped model at its daily cap, the configured
+ * full-quota strategy runs: `stop` shows a notice, the other three
+ * auto-switch to a suitable model.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { type TokenQuotaKey } from './locales.ts';
+export type { TokenQuotaPanelInjected } from './TokenQuotaPanel.tsx';
+export type { ModelQuotaRow, TokenQuotaPanelState } from './store.ts';
+export { mergeModelRows } from './store.ts';
+export type { TokenQuotaKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The token-quota floating panel's copy. */
+        'token-quota': TokenQuotaKey;
+    }
+}
+/** Required services: slot registry, connection RPC, locale, settings scope. */
+export declare const inject: string[];
+/**
+ * Client plugin body: poll the Host snapshot route, run the full-quota
+ * strategy, wire the injected face (directory load, limit write, model
+ * switch, preferences), and register the floating panel into `shell.overlay`.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map