@slkiser/opencode-quota 3.8.8 → 3.10.0

package/dist/lib/quota-dialog-commands.js

@@ -0,0 +1,677 @@
+import { formatQuotaCommand } from "./quota-command-format.js";
+import { aggregateUsage, resolveSessionTree, SessionNotFoundError, } from "./quota-stats.js";
+import { formatQuotaStatsReport } from "./quota-stats-format.js";
+import { buildQuotaStatusReport } from "./quota-status.js";
+import { inspectTuiConfig } from "./tui-config-diagnostics.js";
+import { getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./modelsdev-pricing.js";
+import { refreshGoogleTokensForAllAccounts } from "./google.js";
+import { isCursorProviderId } from "./cursor-pricing.js";
+import { parseOptionalJsonArgs, parseQuotaBetweenArgs, startOfLocalDayMs, startOfNextLocalDayMs, formatYmd, } from "./command-parsing.js";
+import { renderCommandHeading } from "./format-utils.js";
+import { ALL_WINDOWS_FORMAT_STYLE, SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE, } from "./quota-format-style.js";
+import { collectConcreteEnabledProviderIds, collectQuotaRenderData, collectQuotaStatusLiveProbes, matchesQuotaProviderCurrentSelection, resolveQuotaRenderSelection, } from "./quota-render-data.js";
+import { createQuotaProviderRuntimeContext, createQuotaRuntimeRequestContext, resolveQuotaRuntimeContext, } from "./quota-runtime-context.js";
+import { BUNDLED_MAINTAINER_ANNOUNCEMENTS, getMaintainerAnnouncementsSummary, } from "./maintainer-announcements.js";
+const TOKEN_REPORT_COMMANDS = [
+    {
+        id: "tokens_today",
+        template: "/tokens_today",
+        description: "Token + deterministic cost summary for today (calendar day, local timezone).",
+        title: "Tokens used (Today) (/tokens_today)",
+        metadataTitle: "Tokens used (Today)",
+        kind: "today",
+    },
+    {
+        id: "tokens_daily",
+        template: "/tokens_daily",
+        description: "Token + deterministic cost summary for the last 24 hours (rolling).",
+        title: "Tokens used (Last 24 Hours) (/tokens_daily)",
+        metadataTitle: "Tokens used (Last 24 Hours)",
+        kind: "rolling",
+        windowMs: 24 * 60 * 60 * 1000,
+    },
+    {
+        id: "tokens_weekly",
+        template: "/tokens_weekly",
+        description: "Token + deterministic cost summary for the last 7 days (rolling).",
+        title: "Tokens used (Last 7 Days) (/tokens_weekly)",
+        metadataTitle: "Tokens used (Last 7 Days)",
+        kind: "rolling",
+        windowMs: 7 * 24 * 60 * 60 * 1000,
+    },
+    {
+        id: "tokens_monthly",
+        template: "/tokens_monthly",
+        description: "Token + deterministic cost summary for the last 30 days (rolling).",
+        title: "Tokens used (Last 30 Days) (/tokens_monthly)",
+        metadataTitle: "Tokens used (Last 30 Days)",
+        kind: "rolling",
+        windowMs: 30 * 24 * 60 * 60 * 1000,
+    },
+    {
+        id: "tokens_all",
+        template: "/tokens_all",
+        description: "Token + deterministic cost summary for all locally saved OpenCode history.",
+        title: "Tokens used (All Time) (/tokens_all)",
+        metadataTitle: "Tokens used (All Time)",
+        kind: "all",
+        topModels: 12,
+        topSessions: 12,
+    },
+    {
+        id: "tokens_session",
+        template: "/tokens_session",
+        description: "Token + deterministic cost summary for current session only.",
+        title: "Tokens used (Current Session) (/tokens_session)",
+        metadataTitle: "Tokens used (Current Session)",
+        kind: "session",
+    },
+    {
+        id: "tokens_session_all",
+        template: "/tokens_session_all",
+        description: "Token + deterministic cost summary for current session and all descendant child/subagent sessions.",
+        title: "Tokens used (Current Session Tree) (/tokens_session_all)",
+        metadataTitle: "Tokens used (Current Session Tree)",
+        kind: "session_tree",
+    },
+    {
+        id: "tokens_between",
+        template: "/tokens_between",
+        description: "Token + deterministic cost report between two YYYY-MM-DD dates (local timezone, inclusive).",
+        titleForRange: (startYmd, endYmd) => {
+            return `Tokens used (${formatYmd(startYmd)} .. ${formatYmd(endYmd)}) (/tokens_between)`;
+        },
+        metadataTitle: "Tokens used (Date Range)",
+        kind: "between",
+    },
+];
+// OpenCode's xlarge TUI dialog is 116 columns, but the plugin API exposes
+// only the size label, not the live measured width. With command-output padding
+// of 2 columns on each side, 34 keeps token model tables comfortably within the
+// xlarge content budget even when the Reasoning column is present.
+const TUI_TOKEN_REPORT_MODEL_MAX_WIDTH = 34;
+const TOKEN_REPORT_COMMANDS_BY_ID = (() => {
+    const map = new Map();
+    for (const spec of TOKEN_REPORT_COMMANDS) {
+        map.set(spec.id, spec);
+    }
+    return map;
+})();
+export const QUOTA_DIALOG_COMMANDS = [
+    {
+        id: "quota",
+        slashName: "quota",
+        title: "OpenCode Quota",
+        description: "Show deterministic quota output in a local TUI dialog.",
+        dialogSize: "xlarge",
+        requiresSession: true,
+    },
+    {
+        id: "quota_status",
+        slashName: "quota_status",
+        title: "OpenCode Quota Status",
+        description: "Diagnostics for quota, TUI, pricing, and local storage.",
+        dialogSize: "xlarge",
+        requiresSession: true,
+        acceptsArguments: true,
+    },
+    {
+        id: "quota_announcements",
+        slashName: "quota_announcements",
+        title: "OpenCode Quota Announcements",
+        description: "List active bundled maintainer announcements.",
+        dialogSize: "xlarge",
+        acceptsArguments: true,
+    },
+    {
+        id: "pricing_refresh",
+        slashName: "pricing_refresh",
+        title: "OpenCode Quota Pricing Refresh",
+        description: "Refresh the local runtime pricing snapshot from models.dev.",
+        dialogSize: "xlarge",
+        acceptsArguments: true,
+    },
+    ...TOKEN_REPORT_COMMANDS.map((spec) => ({
+        id: spec.id,
+        slashName: spec.id,
+        title: spec.kind === "between" ? "OpenCode Quota Token Report" : spec.metadataTitle,
+        description: spec.description,
+        dialogSize: "xlarge",
+        requiresSession: spec.kind === "session" || spec.kind === "session_tree",
+        acceptsArguments: spec.kind === "between",
+    })),
+];
+const QUOTA_DIALOG_COMMANDS_BY_ID = (() => {
+    const map = new Map();
+    for (const spec of QUOTA_DIALOG_COMMANDS) {
+        map.set(spec.id, spec);
+    }
+    return map;
+})();
+export function isQuotaDialogCommand(command) {
+    return QUOTA_DIALOG_COMMANDS_BY_ID.has(command);
+}
+function isTokenReportCommand(cmd) {
+    return TOKEN_REPORT_COMMANDS_BY_ID.has(cmd);
+}
+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(runtime) {
+    const selection = await resolveQuotaRenderSelection({
+        client: runtime.client,
+        config: runtime.config,
+        request: createQuotaRuntimeRequestContext(runtime),
+        providers: runtime.providers,
+    });
+    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 fetchQuotaCommandData(params) {
+    const { runtime } = params;
+    const request = createQuotaRuntimeRequestContext(runtime);
+    const quotaResult = await collectQuotaRenderData({
+        client: runtime.client,
+        config: runtime.config,
+        configMeta: runtime.configMeta,
+        request,
+        surfaceExplicitProviderIssues: false,
+        formatStyle: ALL_WINDOWS_FORMAT_STYLE,
+        providers: runtime.providers,
+    });
+    if (runtime.config.showSessionTokens && request.sessionID) {
+        params.setLastSessionTokenError?.(quotaResult.sessionTokenError);
+    }
+    if (quotaResult.selection?.filteringByCurrentSelection &&
+        quotaResult.selection.filtered.length === 0) {
+        return null;
+    }
+    return quotaResult.data;
+}
+async function kickPricingRefresh(params) {
+    try {
+        const refreshPromise = maybeRefreshPricingSnapshot({
+            reason: params.reason,
+            snapshotSelection: params.snapshotSelection,
+        });
+        const guardedRefreshPromise = refreshPromise.catch(() => undefined);
+        if (!params.maxWaitMs || params.maxWaitMs <= 0) {
+            void guardedRefreshPromise;
+            return;
+        }
+        await Promise.race([
+            guardedRefreshPromise,
+            new Promise((resolve) => {
+                setTimeout(resolve, params.maxWaitMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        await params.log?.("Pricing refresh failed", {
+            reason: params.reason,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function buildQuotaReport(params) {
+    const result = await aggregateUsage({
+        sinceMs: params.sinceMs,
+        untilMs: params.untilMs,
+        sessionID: params.filterSessionID,
+        sessionIDs: params.filterSessionIDs,
+    });
+    return formatQuotaStatsReport({
+        title: params.title,
+        result,
+        topModels: params.topModels,
+        topSessions: params.topSessions,
+        focusSessionID: params.sessionID,
+        sessionOnly: params.sessionOnly,
+        reportKind: params.reportKind,
+        sessionTree: params.sessionTree,
+        generatedAtMs: params.generatedAtMs,
+        tableOptions: {
+            compactHeaders: true,
+            modelNameMaxWidth: TUI_TOKEN_REPORT_MODEL_MAX_WIDTH,
+        },
+    });
+}
+async function buildStatusReport(params) {
+    const runtimeConfig = params.runtime.config;
+    if (!runtimeConfig.enabled)
+        return null;
+    await kickPricingRefresh({
+        reason: "status",
+        maxWaitMs: 750,
+        snapshotSelection: runtimeConfig.pricingSnapshot.source,
+        log: params.log,
+    });
+    const currentSession = params.runtime.session.sessionMeta ?? {};
+    const currentModel = currentSession.modelID;
+    const currentProviderID = currentSession.providerID;
+    const sessionModelLookup = !params.sessionID
+        ? "no_session"
+        : currentModel
+            ? "ok"
+            : "not_found";
+    const isAutoMode = runtimeConfig.enabledProviders === "auto";
+    const providers = params.runtime.providers;
+    const providerContext = createQuotaProviderRuntimeContext(params.runtime);
+    const availability = await Promise.all(providers.map(async (p) => {
+        let ok = false;
+        try {
+            ok = await p.isAvailable(providerContext);
+        }
+        catch {
+            ok = false;
+        }
+        return {
+            id: p.id,
+            enabled: isAutoMode ? ok : runtimeConfig.enabledProviders.includes(p.id),
+            available: ok,
+            matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
+                ? matchesQuotaProviderCurrentSelection({
+                    provider: p,
+                    currentModel,
+                    currentProviderID,
+                })
+                : undefined,
+        };
+    }));
+    const providersById = new Map(providers.map((provider) => [provider.id, provider]));
+    const liveProbeProviders = availability.flatMap((item) => {
+        if (!item.enabled || !item.available) {
+            return [];
+        }
+        const provider = providersById.get(item.id);
+        return provider ? [provider] : [];
+    });
+    let providerLiveProbes = [];
+    if (liveProbeProviders.length > 0) {
+        try {
+            providerLiveProbes = await collectQuotaStatusLiveProbes({
+                client: params.runtime.client,
+                config: runtimeConfig,
+                configMeta: params.runtime.configMeta,
+                request: createQuotaRuntimeRequestContext(params.runtime),
+                formatStyle: SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE,
+                providers: liveProbeProviders,
+            });
+        }
+        catch (error) {
+            await params.log?.("Failed to collect /quota_status live probes", {
+                providers: liveProbeProviders.map((provider) => provider.id),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const refresh = params.refreshGoogleTokens
+        ? await refreshGoogleTokensForAllAccounts({ skewMs: params.skewMs, force: params.force })
+        : null;
+    const tuiDiagnostics = await inspectTuiConfig({ roots: params.runtime.roots });
+    const announcementProviderIds = availability
+        .filter((item) => item.enabled && item.available)
+        .map((item) => item.id);
+    const maintainerAnnouncementsSummary = getMaintainerAnnouncementsSummary({
+        enabledProviders: announcementProviderIds,
+    });
+    return await buildQuotaStatusReport({
+        tuiDiagnostics,
+        configSource: params.runtime.configMeta.source,
+        configPaths: params.runtime.configMeta.paths,
+        globalConfigPaths: params.runtime.configMeta.globalConfigPaths,
+        workspaceConfigPaths: params.runtime.configMeta.workspaceConfigPaths,
+        settingSources: params.runtime.configMeta.settingSources,
+        configIssues: params.runtime.configMeta.configIssues,
+        enabledProviders: runtimeConfig.enabledProviders,
+        anthropicBinaryPath: runtimeConfig.anthropicBinaryPath,
+        alibabaCodingPlanTier: runtimeConfig.alibabaCodingPlanTier,
+        cursorPlan: runtimeConfig.cursorPlan,
+        cursorIncludedApiUsd: runtimeConfig.cursorIncludedApiUsd,
+        cursorBillingCycleStartDay: runtimeConfig.cursorBillingCycleStartDay,
+        opencodeGoWindows: runtimeConfig.opencodeGoWindows,
+        pricingSnapshotSource: runtimeConfig.pricingSnapshot.source,
+        onlyCurrentModel: runtimeConfig.onlyCurrentModel,
+        currentModel,
+        sessionModelLookup,
+        providerAvailability: availability,
+        providerLiveProbes,
+        googleRefresh: refresh
+            ? {
+                attempted: true,
+                total: refresh.total,
+                successCount: refresh.successCount,
+                failures: refresh.failures,
+            }
+            : { attempted: false },
+        sessionTokenError: params.lastSessionTokenError,
+        maintainerAnnouncements: {
+            config: runtimeConfig.maintainerAnnouncements,
+            summary: maintainerAnnouncementsSummary,
+        },
+        geminiCliClient: params.runtime.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 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=${params.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 (params.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");
+}
+function buildTokenReportUnavailableOutput(params) {
+    const lines = [
+        renderCommandHeading({
+            title: `Token report unavailable (${params.command})`,
+            generatedAtMs: params.generatedAtMs,
+        }),
+        "",
+        "session_lookup_error:",
+        `- session_id: ${params.error.sessionID}`,
+        `- error: ${params.error.message}`,
+        `- checked_path: ${params.error.checkedPath}`,
+    ];
+    return lines.join("\n");
+}
+async function buildQuotaAnnouncementsCommandOutput(runtime) {
+    let activeAnnouncements = [];
+    if (runtime.config.enabled && runtime.config.maintainerAnnouncements.enabled) {
+        const providerIds = await collectConcreteEnabledProviderIds({
+            providers: runtime.providers,
+            ctx: createQuotaProviderRuntimeContext(runtime),
+            enabledProviders: runtime.config.enabledProviders,
+        });
+        const summary = getMaintainerAnnouncementsSummary({
+            announcements: BUNDLED_MAINTAINER_ANNOUNCEMENTS,
+            enabledProviders: providerIds,
+        });
+        activeAnnouncements = summary.activeAnnouncements;
+    }
+    const lines = ["Maintainer announcements", ""];
+    if (activeAnnouncements.length === 0) {
+        lines.push("No current announcements.");
+        return lines.join("\n");
+    }
+    for (const evaluation of activeAnnouncements) {
+        lines.push(`- ${evaluation.announcement.message}`);
+        if (evaluation.announcement.url) {
+            lines.push(`  ${evaluation.announcement.url}`);
+        }
+    }
+    return lines.join("\n");
+}
+function outputResult(params) {
+    const spec = QUOTA_DIALOG_COMMANDS_BY_ID.get(params.command);
+    return {
+        state: "output",
+        command: params.command,
+        title: spec.title,
+        output: params.output,
+        dialogSize: spec.dialogSize,
+    };
+}
+async function buildTokenReportCommandOutput(params) {
+    const spec = TOKEN_REPORT_COMMANDS_BY_ID.get(params.command);
+    const sessionID = params.sessionID;
+    const untilMs = params.generatedAtMs;
+    await kickPricingRefresh({
+        reason: "tokens",
+        maxWaitMs: 750,
+        snapshotSelection: params.runtime.config.pricingSnapshot.source,
+        log: params.log,
+    });
+    if (!sessionID && (spec.kind === "session" || spec.kind === "session_tree")) {
+        return buildTokenReportUnavailableOutput({
+            command: spec.template,
+            generatedAtMs: params.generatedAtMs,
+            error: new SessionNotFoundError("(none)", "(none)"),
+        });
+    }
+    try {
+        if (spec.kind === "between") {
+            const parsed = parseQuotaBetweenArgs(params.arguments);
+            if (!parsed.ok) {
+                return `Invalid arguments for /${spec.id}\n\n${parsed.error}\n\nExpected: /${spec.id} YYYY-MM-DD YYYY-MM-DD\nExample: /${spec.id} 2026-01-01 2026-01-15`;
+            }
+            const sinceMs = startOfLocalDayMs(parsed.startYmd);
+            const rangeUntilMs = startOfNextLocalDayMs(parsed.endYmd);
+            return await buildQuotaReport({
+                title: spec.titleForRange(parsed.startYmd, parsed.endYmd),
+                sinceMs,
+                untilMs: rangeUntilMs,
+                sessionID: sessionID ?? "",
+                generatedAtMs: params.generatedAtMs,
+            });
+        }
+        let sinceMs;
+        let filterSessionID;
+        let filterSessionIDs;
+        let sessionOnly;
+        let topModels;
+        let topSessions;
+        let reportKind;
+        let sessionTree;
+        switch (spec.kind) {
+            case "rolling":
+                sinceMs = untilMs - spec.windowMs;
+                break;
+            case "today": {
+                const now = new Date(untilMs);
+                const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                sinceMs = startOfDay.getTime();
+                break;
+            }
+            case "session":
+                filterSessionID = sessionID;
+                sessionOnly = true;
+                reportKind = "session";
+                break;
+            case "session_tree": {
+                const nodes = await resolveSessionTree(sessionID);
+                filterSessionIDs = nodes.map((node) => node.sessionID);
+                reportKind = "session_tree";
+                sessionTree = { rootSessionID: sessionID, nodes };
+                break;
+            }
+            case "all":
+                topModels = spec.topModels;
+                topSessions = spec.topSessions;
+                break;
+        }
+        return await buildQuotaReport({
+            title: spec.title,
+            sinceMs,
+            untilMs: spec.kind === "rolling" || spec.kind === "today" ? untilMs : undefined,
+            sessionID: sessionID ?? "",
+            filterSessionID,
+            filterSessionIDs,
+            sessionOnly,
+            reportKind,
+            sessionTree,
+            topModels,
+            topSessions,
+            generatedAtMs: params.generatedAtMs,
+        });
+    }
+    catch (err) {
+        if (err instanceof SessionNotFoundError) {
+            return buildTokenReportUnavailableOutput({
+                command: spec.template,
+                generatedAtMs: params.generatedAtMs,
+                error: err,
+            });
+        }
+        throw err;
+    }
+}
+export async function buildQuotaDialogCommandOutput(params) {
+    const generatedAtMs = params.generatedAtMs ?? Date.now();
+    const runtime = await resolveQuotaRuntimeContext({
+        client: params.client,
+        roots: params.roots,
+        sessionID: params.sessionID,
+        sessionMeta: params.sessionMeta,
+        resolveSessionMeta: params.resolveSessionMeta,
+        includeSessionMeta: (config) => config.onlyCurrentModel || params.command === "quota_status",
+    });
+    setPricingSnapshotAutoRefresh(runtime.config.pricingSnapshot.autoRefresh);
+    setPricingSnapshotSelection(runtime.config.pricingSnapshot.source);
+    if (!runtime.config.enabled && params.command !== "quota_announcements") {
+        return { state: "noop", command: params.command, reason: "disabled" };
+    }
+    if (params.command === "quota") {
+        const reportData = await fetchQuotaCommandData({
+            runtime,
+            setLastSessionTokenError: params.setLastSessionTokenError,
+        });
+        if (!reportData) {
+            return outputResult({
+                command: params.command,
+                output: await buildQuotaCommandUnavailableMessage(runtime),
+            });
+        }
+        return outputResult({
+            command: params.command,
+            output: formatQuotaCommand({
+                ...reportData,
+                generatedAtMs,
+                percentDisplayMode: runtime.config.percentDisplayMode,
+            }),
+        });
+    }
+    if (params.command === "quota_status") {
+        const parsed = parseOptionalJsonArgs(params.arguments);
+        if (!parsed.ok) {
+            return outputResult({
+                command: params.command,
+                output: `Invalid arguments for /quota_status\n\n${parsed.error}\n\nExample:\n/quota_status {"refreshGoogleTokens": true}`,
+            });
+        }
+        const output = await buildStatusReport({
+            runtime,
+            refreshGoogleTokens: parsed.value["refreshGoogleTokens"] === true,
+            skewMs: typeof parsed.value["skewMs"] === "number" ? parsed.value["skewMs"] : undefined,
+            force: parsed.value["force"] === true,
+            sessionID: params.sessionID,
+            generatedAtMs,
+            lastSessionTokenError: params.lastSessionTokenError,
+            log: params.log,
+        });
+        return output ? outputResult({ command: params.command, output }) : { state: "noop", command: params.command, reason: "disabled" };
+    }
+    if (params.command === "quota_announcements") {
+        if ((params.arguments ?? "").trim()) {
+            return outputResult({
+                command: params.command,
+                output: "Invalid arguments for /quota_announcements\n\nThis command does not accept arguments.\n\nUsage: /quota_announcements",
+            });
+        }
+        return outputResult({
+            command: params.command,
+            output: await buildQuotaAnnouncementsCommandOutput(runtime),
+        });
+    }
+    if (params.command === "pricing_refresh") {
+        if ((params.arguments ?? "").trim()) {
+            return outputResult({
+                command: params.command,
+                output: "Invalid arguments for /pricing_refresh\n\nThis command does not accept arguments.\n\nUsage:\n/pricing_refresh",
+            });
+        }
+        const result = await maybeRefreshPricingSnapshot({
+            reason: "manual",
+            force: true,
+            snapshotSelection: runtime.config.pricingSnapshot.source,
+            allowRefreshWhenSelectionBundled: true,
+        });
+        return outputResult({
+            command: params.command,
+            output: buildPricingRefreshCommandOutput({
+                result,
+                configuredSelection: runtime.config.pricingSnapshot.source,
+                generatedAtMs,
+            }),
+        });
+    }
+    if (isTokenReportCommand(params.command)) {
+        return outputResult({
+            command: params.command,
+            output: await buildTokenReportCommandOutput({
+                command: params.command,
+                arguments: params.arguments,
+                sessionID: params.sessionID,
+                generatedAtMs,
+                runtime,
+                log: params.log,
+            }),
+        });
+    }
+    return { state: "noop", command: params.command, reason: "disabled" };
+}
+//# sourceMappingURL=quota-dialog-commands.js.map