@slkiser/opencode-quota 2.7.1 → 2.9.1

package/dist/plugin.js

@@ -16,16 +16,17 @@ import { aggregateUsage } from "./lib/quota-stats.js";
 import { fetchSessionTokensForDisplay } from "./lib/session-tokens.js";
 import { formatQuotaStatsReport } from "./lib/quota-stats-format.js";
 import { buildQuotaStatusReport } from "./lib/quota-status.js";
-import { maybeRefreshPricingSnapshot } from "./lib/modelsdev-pricing.js";
+import { getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./lib/modelsdev-pricing.js";
 import { refreshGoogleTokensForAllAccounts } from "./lib/google.js";
 import { getQuotaProviderDisplayLabel } from "./lib/provider-metadata.js";
 import { DEFAULT_ALIBABA_AUTH_CACHE_MAX_AGE_MS, isAlibabaModelId, resolveAlibabaCodingPlanAuthCached, } from "./lib/alibaba-auth.js";
 import { isQwenCodeModelId, resolveQwenLocalPlanCached, } from "./lib/qwen-auth.js";
 import { recordAlibabaCodingPlanCompletion, recordQwenCompletion, } from "./lib/qwen-local-quota.js";
-import { isCursorModelId } from "./lib/cursor-pricing.js";
+import { isCursorModelId, isCursorProviderId } from "./lib/cursor-pricing.js";
 import { parseOptionalJsonArgs, parseQuotaBetweenArgs, startOfLocalDayMs, startOfNextLocalDayMs, formatYmd, } from "./lib/command-parsing.js";
 import { handled } from "./lib/command-handled.js";
 import { renderCommandHeading } from "./lib/format-utils.js";
+import { sanitizeDisplayText } from "./lib/display-sanitize.js";
 /** All token report command specifications */
 const TOKEN_REPORT_COMMANDS = [
     {
@@ -127,7 +128,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                     noReply: true,
                     // ignored=true keeps this out of future model context while still
                     // showing it to the user in the transcript.
-                    parts: [{ type: "text", text: output, ignored: true }],
+                    parts: [{ type: "text", text: sanitizeDisplayText(output), ignored: true }],
                 },
             });
         }
@@ -153,20 +154,45 @@ export const QuotaToastPlugin = async ({ client }) => {
     let lastSessionTokenError;
     const providerFetchCache = new Map();
     function getQuotaCommandCache() {
-        let quotaCache = globalThis.__opencodeQuotaCommandCache;
-        if (!quotaCache) {
-            quotaCache = { body: "", timestamp: 0 };
-            globalThis.__opencodeQuotaCommandCache = quotaCache;
+        const existing = globalThis.__opencodeQuotaCommandCache;
+        if (existing instanceof Map) {
+            return existing;
         }
+        const quotaCache = new Map();
+        globalThis.__opencodeQuotaCommandCache = quotaCache;
         return quotaCache;
     }
     function clearQuotaCommandCache() {
-        const quotaCache = globalThis.__opencodeQuotaCommandCache;
-        if (!quotaCache)
-            return;
-        quotaCache.body = "";
-        quotaCache.timestamp = 0;
-        quotaCache.inFlight = undefined;
+        getQuotaCommandCache().clear();
+    }
+    function buildQuotaCommandCacheKey(params) {
+        const enabledProviders = config.enabledProviders === "auto" ? "auto" : config.enabledProviders.join(",");
+        const googleModels = config.googleModels.join(",");
+        const currentModel = config.onlyCurrentModel && params.sessionID ? params.sessionMeta?.modelID ?? "" : "";
+        const currentProviderID = config.onlyCurrentModel && params.sessionID ? params.sessionMeta?.providerID ?? "" : "";
+        return [
+            `sessionID=${params.sessionID ?? ""}`,
+            `showSessionTokens=${config.showSessionTokens ? "yes" : "no"}`,
+            `onlyCurrentModel=${config.onlyCurrentModel ? "yes" : "no"}`,
+            `enabledProviders=${enabledProviders}`,
+            `googleModels=${googleModels}`,
+            `alibabaTier=${config.alibabaCodingPlanTier}`,
+            `cursorPlan=${config.cursorPlan}`,
+            `cursorIncludedApiUsd=${config.cursorIncludedApiUsd ?? ""}`,
+            `cursorBillingCycleStartDay=${config.cursorBillingCycleStartDay ?? ""}`,
+            `currentModel=${currentModel}`,
+            `currentProviderID=${currentProviderID}`,
+        ].join("|");
+    }
+    function pruneQuotaCommandCache(ttlMs, nowMs) {
+        const quotaCache = getQuotaCommandCache();
+        for (const [cacheKey, entry] of quotaCache.entries()) {
+            if (entry.inFlight)
+                continue;
+            if (entry.timestamp <= 0 || ttlMs <= 0 || nowMs - entry.timestamp >= ttlMs) {
+                quotaCache.delete(cacheKey);
+            }
+        }
     }
     function asRecord(value) {
         return value && typeof value === "object" ? value : null;
@@ -216,7 +242,8 @@ export const QuotaToastPlugin = async ({ client }) => {
         const cursorBillingCycleStartDay = ctx.config.cursorBillingCycleStartDay ?? "";
         const onlyCurrentModel = ctx.config.onlyCurrentModel ? "yes" : "no";
         const currentModel = ctx.config.currentModel ?? "";
-        return `${providerId}|style=${style}|googleModels=${googleModels}|alibabaTier=${alibabaCodingPlanTier}|cursorPlan=${cursorPlan}|cursorIncludedApiUsd=${cursorIncludedApiUsd}|cursorBillingCycleStartDay=${cursorBillingCycleStartDay}|onlyCurrentModel=${onlyCurrentModel}|currentModel=${currentModel}`;
+        const currentProviderID = ctx.config.currentProviderID ?? "";
+        return `${providerId}|style=${style}|googleModels=${googleModels}|alibabaTier=${alibabaCodingPlanTier}|cursorPlan=${cursorPlan}|cursorIncludedApiUsd=${cursorIncludedApiUsd}|cursorBillingCycleStartDay=${cursorBillingCycleStartDay}|onlyCurrentModel=${onlyCurrentModel}|currentModel=${currentModel}|currentProviderID=${currentProviderID}`;
     }
     async function fetchProviderWithCache(params) {
         const { provider, ctx, ttlMs } = params;
@@ -290,10 +317,12 @@ export const QuotaToastPlugin = async ({ client }) => {
     function isProviderEnabled(providerId) {
         return config.enabledProviders === "auto" || config.enabledProviders.includes(providerId);
     }
-    async function shouldBypassToastCacheForLiveLocalUsage(trigger, sessionID) {
+    async function shouldBypassToastCacheForLiveLocalUsage(params) {
+        const { trigger, sessionID } = params;
         if (trigger !== "question")
             return false;
-        const currentModel = await getCurrentModel(sessionID);
+        const currentSession = params.sessionMeta ?? (await getSessionModelMeta(sessionID));
+        const currentModel = currentSession.modelID;
         if (isQwenCodeModelId(currentModel)) {
             const plan = await resolveQwenLocalPlanCached();
             return plan.state === "qwen_free" && isProviderEnabled("qwen-code");
@@ -305,15 +334,19 @@ export const QuotaToastPlugin = async ({ client }) => {
             });
             return plan.state === "configured" && isProviderEnabled("alibaba-coding-plan");
         }
-        if (isCursorModelId(currentModel)) {
+        if (isCursorProviderId(currentSession.providerID) || isCursorModelId(currentModel)) {
             return isProviderEnabled("cursor");
         }
         return false;
     }
-    async function shouldBypassQuotaCommandCache(sessionID) {
+    async function shouldBypassQuotaCommandCache(sessionID, sessionMeta) {
         if (config.debug || !sessionID)
             return config.debug;
-        return await shouldBypassToastCacheForLiveLocalUsage("question", sessionID);
+        return await shouldBypassToastCacheForLiveLocalUsage({
+            trigger: "question",
+            sessionID,
+            sessionMeta,
+        });
     }
     async function refreshConfig() {
         if (configInFlight)
@@ -322,11 +355,15 @@ export const QuotaToastPlugin = async ({ client }) => {
             try {
                 configMeta = createLoadConfigMeta();
                 config = await loadConfig(typedClient, configMeta);
+                setPricingSnapshotAutoRefresh(config.pricingSnapshot.autoRefresh);
+                setPricingSnapshotSelection(config.pricingSnapshot.source);
                 configLoaded = true;
             }
             catch {
                 // Leave configLoaded=false so we can retry on next trigger.
                 config = DEFAULT_CONFIG;
+                setPricingSnapshotAutoRefresh(DEFAULT_CONFIG.pricingSnapshot.autoRefresh);
+                setPricingSnapshotSelection(DEFAULT_CONFIG.pricingSnapshot.source);
             }
             finally {
                 configInFlight = null;
@@ -336,7 +373,10 @@ export const QuotaToastPlugin = async ({ client }) => {
     }
     async function kickPricingRefresh(params) {
         try {
-            const refreshPromise = maybeRefreshPricingSnapshot({ reason: params.reason });
+            const refreshPromise = maybeRefreshPricingSnapshot({
+                reason: params.reason,
+                snapshotSelection: config.pricingSnapshot.source,
+            });
             const guardedRefreshPromise = refreshPromise.catch(() => undefined);
             if (!params.maxWaitMs || params.maxWaitMs <= 0) {
                 void guardedRefreshPromise;
@@ -378,6 +418,8 @@ export const QuotaToastPlugin = async ({ client }) => {
                         cursorPlan: config.cursorPlan,
                         cursorIncludedApiUsd: config.cursorIncludedApiUsd,
                         cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+                        pricingSnapshotSource: config.pricingSnapshot.source,
+                        pricingSnapshotAutoRefresh: config.pricingSnapshot.autoRefresh,
                         showOnIdle: config.showOnIdle,
                         showOnQuestion: config.showOnQuestion,
                         showOnCompact: config.showOnCompact,
@@ -425,22 +467,38 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
     }
     /**
-     * Get the current model from the active session.
+     * Get the current model metadata from the active session.
      *
      * Only uses session-scoped model lookup. Does NOT fall back to
      * client.config.get() because that returns the global/default model
      * which can be stale across sessions.
      */
-    async function getCurrentModel(sessionID) {
+    async function getSessionModelMeta(sessionID) {
         if (!sessionID)
-            return undefined;
+            return {};
         try {
             const sessionResp = await typedClient.session.get({ path: { id: sessionID } });
-            return sessionResp.data?.modelID;
+            return {
+                modelID: sessionResp.data?.modelID,
+                providerID: sessionResp.data?.providerID,
+            };
         }
         catch {
+            return {};
+        }
+    }
+    async function getCurrentModel(sessionID) {
+        if (!sessionID)
             return undefined;
+        return (await getSessionModelMeta(sessionID)).modelID;
+    }
+    function matchesProviderCurrentSelection(params) {
+        if (params.provider.id === "cursor" && isCursorProviderId(params.currentProviderID)) {
+            return true;
         }
+        if (!params.currentModel)
+            return false;
+        return params.provider.matchesCurrentModel ? params.provider.matchesCurrentModel(params.currentModel) : true;
     }
     function formatDebugInfo(params) {
         const availability = params.availability
@@ -461,6 +519,99 @@ export const QuotaToastPlugin = async ({ client }) => {
             `available=${availability}`,
         ].join("\n");
     }
+    async function resolveQuotaCommandSelection(params = {}) {
+        if (!configLoaded)
+            await refreshConfig();
+        if (!config.enabled)
+            return null;
+        const allProviders = getProviders();
+        const isAutoMode = config.enabledProviders === "auto";
+        const providers = isAutoMode
+            ? allProviders
+            : allProviders.filter((p) => config.enabledProviders.includes(p.id));
+        if (!isAutoMode && providers.length === 0)
+            return null;
+        let currentModel;
+        let currentProviderID;
+        if (config.onlyCurrentModel && params.sessionID) {
+            const currentSession = params.sessionMeta ?? (await getSessionModelMeta(params.sessionID));
+            currentModel = currentSession.modelID;
+            currentProviderID = currentSession.providerID;
+        }
+        const ctx = {
+            client: typedClient,
+            config: {
+                googleModels: config.googleModels,
+                alibabaCodingPlanTier: config.alibabaCodingPlanTier,
+                cursorPlan: config.cursorPlan,
+                cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+                cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+                // Always format /quota in grouped mode for a more dashboard-like look.
+                toastStyle: "grouped",
+                onlyCurrentModel: config.onlyCurrentModel,
+                currentModel,
+                currentProviderID,
+            },
+        };
+        const filteringByCurrentSelection = config.onlyCurrentModel && Boolean(currentModel || isCursorProviderId(currentProviderID));
+        const filtered = filteringByCurrentSelection
+            ? providers.filter((p) => matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID }))
+            : providers;
+        return {
+            isAutoMode,
+            providers,
+            filtered,
+            ctx,
+            currentModel,
+            currentProviderID,
+            filteringByCurrentSelection,
+        };
+    }
+    function describeQuotaCommandCurrentSelection(params) {
+        if (isCursorProviderId(params.currentProviderID)) {
+            return `current provider: ${params.currentProviderID}`;
+        }
+        if (params.currentModel) {
+            return `current model: ${params.currentModel}`;
+        }
+        return "current session";
+    }
+    async function buildQuotaCommandUnavailableMessage(params = {}) {
+        const selection = await resolveQuotaCommandSelection(params);
+        if (!selection) {
+            return "Quota unavailable\n\nNo enabled quota providers are configured.\n\nRun /quota_status for diagnostics.";
+        }
+        if (selection.filteringByCurrentSelection && selection.filtered.length === 0) {
+            const detail = describeQuotaCommandCurrentSelection({
+                currentModel: selection.currentModel,
+                currentProviderID: selection.currentProviderID,
+            });
+            return `Quota unavailable\n\nNo enabled quota providers matched the ${detail}.\n\nRun /quota_status for diagnostics.`;
+        }
+        const avail = await Promise.all(selection.filtered.map(async (p) => {
+            try {
+                return { id: p.id, ok: await p.isAvailable(selection.ctx) };
+            }
+            catch {
+                return { id: p.id, ok: false };
+            }
+        }));
+        const availableIds = avail.filter((x) => x.ok).map((x) => x.id);
+        if (availableIds.length === 0) {
+            const scopedDetail = selection.filteringByCurrentSelection
+                ? ` for the ${describeQuotaCommandCurrentSelection({
+                    currentModel: selection.currentModel,
+                    currentProviderID: selection.currentProviderID,
+                })}`
+                : "";
+            return (`Quota unavailable\n\nNo quota providers detected${scopedDetail}. ` +
+                "Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\n" +
+                "Run /quota_status for diagnostics.");
+        }
+        return (`Quota unavailable\n\nProviders detected (${availableIds.join(", ")}) but returned no data. ` +
+            "This may be a temporary API error.\n\n" +
+            "Run /quota_status for diagnostics.");
+    }
     async function fetchQuotaMessage(trigger, sessionID) {
         // Ensure we have loaded config at least once. If load fails, we keep trying
         // on subsequent triggers.
@@ -487,8 +638,11 @@ export const QuotaToastPlugin = async ({ client }) => {
                 : null;
         }
         let currentModel;
+        let currentProviderID;
         if (config.onlyCurrentModel) {
-            currentModel = await getCurrentModel(sessionID);
+            const currentSession = await getSessionModelMeta(sessionID);
+            currentModel = currentSession.modelID;
+            currentProviderID = currentSession.providerID;
         }
         const ctx = {
             client: typedClient,
@@ -501,10 +655,11 @@ export const QuotaToastPlugin = async ({ client }) => {
                 toastStyle: config.toastStyle,
                 onlyCurrentModel: config.onlyCurrentModel,
                 currentModel,
+                currentProviderID,
             },
         };
-        const filtered = config.onlyCurrentModel && currentModel
-            ? providers.filter((p) => p.matchesCurrentModel ? p.matchesCurrentModel(currentModel) : true)
+        const filtered = config.onlyCurrentModel && (currentModel || isCursorProviderId(currentProviderID))
+            ? providers.filter((p) => matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID }))
             : providers;
         // availability checks are cheap, do them in parallel
         const avail = await Promise.all(filtered.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
@@ -650,7 +805,7 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         const bypassMessageCache = config.debug
             ? true
-            : await shouldBypassToastCacheForLiveLocalUsage(trigger, sessionID);
+            : await shouldBypassToastCacheForLiveLocalUsage({ trigger, sessionID });
         const message = bypassMessageCache
             ? await fetchQuotaMessage(trigger, sessionID)
             : await getOrFetchWithCacheControl(async () => {
@@ -670,7 +825,7 @@ export const QuotaToastPlugin = async ({ client }) => {
         try {
             await typedClient.tui.showToast({
                 body: {
-                    message,
+                    message: sanitizeDisplayText(message),
                     variant: "info",
                     duration: config.toastDurationMs,
                 },
@@ -683,37 +838,12 @@ export const QuotaToastPlugin = async ({ client }) => {
             });
         }
     }
-    async function fetchQuotaCommandBody(trigger, sessionID) {
-        if (!configLoaded)
-            await refreshConfig();
-        if (!config.enabled)
-            return null;
-        const allProviders = getProviders();
-        const isAutoMode = config.enabledProviders === "auto";
-        const providers = isAutoMode
-            ? allProviders
-            : allProviders.filter((p) => config.enabledProviders.includes(p.id));
-        if (!isAutoMode && providers.length === 0)
+    async function fetchQuotaCommandBody(trigger, params = {}) {
+        const selection = await resolveQuotaCommandSelection(params);
+        if (!selection)
             return null;
-        let currentModel;
-        if (config.onlyCurrentModel && sessionID) {
-            currentModel = await getCurrentModel(sessionID);
-        }
-        const ctx = {
-            client: typedClient,
-            config: {
-                googleModels: config.googleModels,
-                alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-                cursorPlan: config.cursorPlan,
-                cursorIncludedApiUsd: config.cursorIncludedApiUsd,
-                cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
-                // Always format /quota in grouped mode for a more dashboard-like look.
-                toastStyle: "grouped",
-                onlyCurrentModel: config.onlyCurrentModel,
-                currentModel,
-            },
-        };
-        const avail = await Promise.all(providers.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
+        const { isAutoMode, ctx } = selection;
+        const avail = await Promise.all(selection.filtered.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
         const active = avail.filter((x) => x.ok).map((x) => x.p);
         if (active.length === 0)
             return null;
@@ -738,10 +868,10 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         // Fetch session tokens if enabled and sessionID is available
         let sessionTokens;
-        if (config.showSessionTokens && sessionID) {
+        if (config.showSessionTokens && params.sessionID) {
             const stResult = await fetchSessionTokensForDisplay({
                 enabled: config.showSessionTokens,
-                sessionID,
+                sessionID: params.sessionID,
             });
             sessionTokens = stResult.sessionTokens;
             // Update diagnostics state: clear on success (no error returned), set on failure
@@ -775,7 +905,9 @@ export const QuotaToastPlugin = async ({ client }) => {
         if (!config.enabled)
             return null;
         await kickPricingRefresh({ reason: "status", maxWaitMs: 750 });
-        const currentModel = await getCurrentModel(params.sessionID);
+        const currentSession = await getSessionModelMeta(params.sessionID);
+        const currentModel = currentSession.modelID;
+        const currentProviderID = currentSession.providerID;
         const sessionModelLookup = !params.sessionID
             ? "no_session"
             : currentModel
@@ -795,6 +927,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                         cursorIncludedApiUsd: config.cursorIncludedApiUsd,
                         cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
                         currentModel,
+                        currentProviderID,
                     },
                 });
             }
@@ -806,8 +939,8 @@ export const QuotaToastPlugin = async ({ client }) => {
                 // In auto mode, a provider is effectively "enabled" if it's available.
                 enabled: isAutoMode ? ok : config.enabledProviders.includes(p.id),
                 available: ok,
-                matchesCurrentModel: typeof p.matchesCurrentModel === "function" && currentModel
-                    ? p.matchesCurrentModel(currentModel)
+                matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
+                    ? matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID })
                     : undefined,
             };
         }));
@@ -822,6 +955,7 @@ export const QuotaToastPlugin = async ({ client }) => {
             cursorPlan: config.cursorPlan,
             cursorIncludedApiUsd: config.cursorIncludedApiUsd,
             cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+            pricingSnapshotSource: config.pricingSnapshot.source,
             onlyCurrentModel: config.onlyCurrentModel,
             currentModel,
             sessionModelLookup,
@@ -838,6 +972,42 @@ export const QuotaToastPlugin = async ({ client }) => {
             generatedAtMs: params.generatedAtMs,
         });
     }
+    function formatIsoTimestamp(timestampMs) {
+        return typeof timestampMs === "number" && Number.isFinite(timestampMs) && timestampMs > 0
+            ? new Date(timestampMs).toISOString()
+            : "(none)";
+    }
+    function buildPricingRefreshCommandOutput(params) {
+        const meta = getPricingSnapshotMeta();
+        const activeSource = getPricingSnapshotSource();
+        const configuredSelection = config.pricingSnapshot.source;
+        const resultLabel = params.result.reason ??
+            params.result.state.lastResult ??
+            (params.result.updated ? "success" : "unknown");
+        const lines = [
+            renderCommandHeading({
+                title: "Pricing Refresh (/pricing_refresh)",
+                generatedAtMs: params.generatedAtMs,
+            }),
+            "",
+            "refresh:",
+            `- attempted: ${params.result.attempted ? "true" : "false"}`,
+            `- result: ${resultLabel}`,
+            `- runtime_snapshot_persisted: ${params.result.updated ? "true" : "false"}`,
+        ];
+        if (params.result.error) {
+            lines.push(`- error: ${params.result.error}`);
+        }
+        lines.push("");
+        lines.push("pricing_snapshot:");
+        lines.push(`- selection: configured=${configuredSelection} active=${activeSource}`);
+        lines.push(`- active_snapshot: source=${meta.source} generated_at=${formatIsoTimestamp(meta.generatedAt)} units=${meta.units}`);
+        lines.push(`- runtime_paths: snapshot=${getRuntimePricingSnapshotPath()} refresh_state=${getRuntimePricingRefreshStatePath()}`);
+        if (configuredSelection === "bundled" && params.result.updated) {
+            lines.push("- selection_note: runtime snapshot refreshed locally, but active reports remain pinned to bundled pricing");
+        }
+        return lines.join("\n");
+    }
     // Return hook implementations
     return {
         // Register built-in slash commands (in addition to /tool quota_*)
@@ -853,6 +1023,10 @@ export const QuotaToastPlugin = async ({ client }) => {
                 template: "/quota_status",
                 description: "Diagnostics for toast + pricing + local storage (includes unknown pricing report).",
             };
+            cfg.command["pricing_refresh"] = {
+                template: "/pricing_refresh",
+                description: "Refresh the local runtime pricing snapshot from models.dev.",
+            };
             // Register token report commands (/tokens_*)
             for (const spec of TOKEN_REPORT_COMMANDS) {
                 cfg.command[spec.id] = {
@@ -865,7 +1039,10 @@ export const QuotaToastPlugin = async ({ client }) => {
             try {
                 const cmd = input.command;
                 const sessionID = input.sessionID;
-                const isQuotaCommand = cmd === "quota" || cmd === "quota_status" || isTokenReportCommand(cmd);
+                const isQuotaCommand = cmd === "quota" ||
+                    cmd === "quota_status" ||
+                    cmd === "pricing_refresh" ||
+                    isTokenReportCommand(cmd);
                 if (isQuotaCommand && !configLoaded) {
                     await refreshConfig();
                 }
@@ -874,30 +1051,45 @@ export const QuotaToastPlugin = async ({ client }) => {
                 }
                 if (cmd === "quota") {
                     const generatedAtMs = Date.now();
-                    // Separate cache for /quota so it doesn't pollute the toast cache.
-                    const quotaCache = getQuotaCommandCache();
                     const now = generatedAtMs;
-                    const bypassCommandCache = await shouldBypassQuotaCommandCache(sessionID);
-                    const cached = !bypassCommandCache &&
-                        quotaCache.timestamp &&
-                        now - quotaCache.timestamp < config.minIntervalMs
-                        ? quotaCache.body
-                        : null;
-                    const body = cached
-                        ? cached
-                        : await (quotaCache.inFlight ??
-                            (quotaCache.inFlight = (async () => {
-                                try {
-                                    return await fetchQuotaCommandBody("command:/quota", sessionID);
-                                }
-                                finally {
-                                    quotaCache.inFlight = undefined;
-                                }
-                            })()));
-                    if (body) {
-                        quotaCache.body = body;
-                        quotaCache.timestamp = Date.now();
-                    }
+                    const quotaRequestContext = {
+                        sessionID,
+                        sessionMeta: sessionID ? await getSessionModelMeta(sessionID) : undefined,
+                    };
+                    const bypassCommandCache = await shouldBypassQuotaCommandCache(sessionID, quotaRequestContext.sessionMeta);
+                    const body = bypassCommandCache
+                        ? await fetchQuotaCommandBody("command:/quota", quotaRequestContext)
+                        : await (async () => {
+                            const quotaCache = getQuotaCommandCache();
+                            pruneQuotaCommandCache(config.minIntervalMs, now);
+                            const cacheKey = buildQuotaCommandCacheKey(quotaRequestContext);
+                            const cachedEntry = quotaCache.get(cacheKey);
+                            if (cachedEntry?.timestamp &&
+                                now - cachedEntry.timestamp < config.minIntervalMs) {
+                                return cachedEntry.body;
+                            }
+                            const cacheEntry = cachedEntry ?? { body: "", timestamp: 0 };
+                            if (!cachedEntry) {
+                                quotaCache.set(cacheKey, cacheEntry);
+                            }
+                            return await (cacheEntry.inFlight ??
+                                (cacheEntry.inFlight = (async () => {
+                                    try {
+                                        const freshBody = await fetchQuotaCommandBody("command:/quota", quotaRequestContext);
+                                        if (freshBody) {
+                                            cacheEntry.body = freshBody;
+                                            cacheEntry.timestamp = Date.now();
+                                        }
+                                        return freshBody;
+                                    }
+                                    finally {
+                                        cacheEntry.inFlight = undefined;
+                                        if (!cacheEntry.body && cacheEntry.timestamp <= 0) {
+                                            quotaCache.delete(cacheKey);
+                                        }
+                                    }
+                                })()));
+                        })();
                     if (!body) {
                         // Provide an actionable message instead of a generic "unavailable".
                         if (!configLoaded) {
@@ -907,33 +1099,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                             await injectRawOutput(sessionID, "Quota disabled in config (enabled: false)");
                         }
                         else {
-                            // Check what providers are available for a more specific hint.
-                            const allProvs = getProviders();
-                            const ctx = {
-                                client: typedClient,
-                                config: {
-                                    googleModels: config.googleModels,
-                                    alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-                                    cursorPlan: config.cursorPlan,
-                                    cursorIncludedApiUsd: config.cursorIncludedApiUsd,
-                                    cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
-                                },
-                            };
-                            const avail = await Promise.all(allProvs.map(async (p) => {
-                                try {
-                                    return { id: p.id, ok: await p.isAvailable(ctx) };
-                                }
-                                catch {
-                                    return { id: p.id, ok: false };
-                                }
-                            }));
-                            const availableIds = avail.filter((x) => x.ok).map((x) => x.id);
-                            if (availableIds.length === 0) {
-                                await injectRawOutput(sessionID, "Quota unavailable\n\nNo quota providers detected. Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\nRun /quota_status for diagnostics.");
-                            }
-                            else {
-                                await injectRawOutput(sessionID, `Quota unavailable\n\nProviders detected (${availableIds.join(", ")}) but returned no data. This may be a temporary API error.\n\nRun /quota_status for diagnostics.`);
-                            }
+                            await injectRawOutput(sessionID, await buildQuotaCommandUnavailableMessage(quotaRequestContext));
                         }
                         handled();
                     }
@@ -944,6 +1110,24 @@ export const QuotaToastPlugin = async ({ client }) => {
                     await injectRawOutput(sessionID, `${heading}\n\n${body}`);
                     handled();
                 }
+                if (cmd === "pricing_refresh") {
+                    const generatedAtMs = Date.now();
+                    if ((input.arguments ?? "").trim()) {
+                        await injectRawOutput(sessionID, "Invalid arguments for /pricing_refresh\n\nThis command does not accept arguments.\n\nUsage:\n/pricing_refresh");
+                        handled();
+                    }
+                    const result = await maybeRefreshPricingSnapshot({
+                        reason: "manual",
+                        force: true,
+                        snapshotSelection: config.pricingSnapshot.source,
+                        allowRefreshWhenSelectionBundled: true,
+                    });
+                    await injectRawOutput(sessionID, buildPricingRefreshCommandOutput({
+                        result,
+                        generatedAtMs,
+                    }));
+                    handled();
+                }
                 const untilMs = Date.now();
                 // Handle token report commands (/tokens_*)
                 if (isTokenReportCommand(cmd)) {
@@ -1095,7 +1279,8 @@ export const QuotaToastPlugin = async ({ client }) => {
             if (!config.enabled)
                 return;
             if (isSuccessfulQuestionExecution(output)) {
-                const model = await getCurrentModel(input.sessionID);
+                const sessionMeta = await getSessionModelMeta(input.sessionID);
+                const model = sessionMeta.modelID;
                 try {
                     if (isQwenCodeModelId(model)) {
                         const plan = await resolveQwenLocalPlanCached();
@@ -1114,7 +1299,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                             clearQuotaCommandCache();
                         }
                     }
-                    else if (isCursorModelId(model)) {
+                    else if (isCursorProviderId(sessionMeta.providerID) || isCursorModelId(model)) {
                         clearQuotaCommandCache();
                     }
                 }
@@ -1122,6 +1307,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                     await log("Failed to record local request-plan quota completion", {
                         error: err instanceof Error ? err.message : String(err),
                         model,
+                        providerID: sessionMeta.providerID,
                     });
                 }
             }