opencode-antigravity-auth 1.4.2 → 1.4.3-beta.0

package/dist/src/plugin.js

@@ -1,6 +1,6 @@
 import { exec } from "node:child_process";
 import { tool } from "@opencode-ai/plugin";
-import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_PROVIDER_ID } from "./constants";
+import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_ENDPOINT_PROD, ANTIGRAVITY_PROVIDER_ID } from "./constants";
 import { authorizeAntigravity, exchangeAntigravity } from "./antigravity/oauth";
 import { accessTokenExpired, isOAuthAuth, parseRefreshParts } from "./plugin/auth";
 import { promptAddAnotherAccount, promptLoginMode, promptProjectId } from "./plugin/cli";
@@ -13,7 +13,7 @@ import { EmptyResponseError } from "./plugin/errors";
 import { AntigravityTokenRefreshError, refreshAccessToken } from "./plugin/token";
 import { startOAuthListener } from "./plugin/server";
 import { clearAccounts, loadAccounts, saveAccounts } from "./plugin/storage";
-import { AccountManager, parseRateLimitReason, calculateBackoffMs } from "./plugin/accounts";
+import { AccountManager, parseRateLimitReason, calculateBackoffMs, computeSoftQuotaCacheTtlMs } from "./plugin/accounts";
 import { createAutoUpdateCheckerHook } from "./hooks/auto-update-checker";
 import { loadConfig, initRuntimeConfig } from "./plugin/config";
 import { createSessionRecoveryHook, getRecoverySuccessToast } from "./plugin/recovery";
@@ -33,13 +33,18 @@ function getCapacityBackoffDelay(consecutiveFailures) {
 }
 const warmupAttemptedSessionIds = new Set();
 const warmupSucceededSessionIds = new Set();
+// Track if this plugin instance is running in a child session (subagent, background task)
+// Used to filter toasts based on toast_scope config
+let isChildSession = false;
+let childSessionParentID = undefined;
 const log = createLogger("plugin");
 // Module-level toast debounce to persist across requests (fixes toast spam)
 const rateLimitToastCooldowns = new Map();
 const RATE_LIMIT_TOAST_COOLDOWN_MS = 5000;
 const MAX_TOAST_COOLDOWN_ENTRIES = 100;
-// Track if "all accounts rate-limited" toast was shown to prevent spam in while loop
-let allAccountsRateLimitedToastShown = false;
+// Track if "all accounts blocked" toasts were shown to prevent spam in while loop
+let softQuotaToastShown = false;
+let rateLimitToastShown = false;
 function cleanupToastCooldowns() {
     if (rateLimitToastCooldowns.size > MAX_TOAST_COOLDOWN_ENTRIES) {
         const now = Date.now();
@@ -61,8 +66,47 @@ function shouldShowRateLimitToast(message) {
     rateLimitToastCooldowns.set(toastKey, now);
     return true;
 }
-function resetAllAccountsRateLimitedToast() {
-    allAccountsRateLimitedToastShown = false;
+function resetAllAccountsBlockedToasts() {
+    softQuotaToastShown = false;
+    rateLimitToastShown = false;
+}
+const quotaRefreshInProgressByEmail = new Set();
+async function triggerAsyncQuotaRefreshForAccount(accountManager, accountIndex, client, providerId, intervalMinutes) {
+    if (intervalMinutes <= 0)
+        return;
+    const accounts = accountManager.getAccounts();
+    const account = accounts[accountIndex];
+    if (!account || account.enabled === false)
+        return;
+    const accountKey = account.email ?? `idx-${accountIndex}`;
+    if (quotaRefreshInProgressByEmail.has(accountKey))
+        return;
+    const intervalMs = intervalMinutes * 60 * 1000;
+    const age = account.cachedQuotaUpdatedAt != null
+        ? Date.now() - account.cachedQuotaUpdatedAt
+        : Infinity;
+    if (age < intervalMs)
+        return;
+    quotaRefreshInProgressByEmail.add(accountKey);
+    try {
+        const accountsForCheck = accountManager.getAccountsForQuotaCheck();
+        const singleAccount = accountsForCheck[accountIndex];
+        if (!singleAccount) {
+            quotaRefreshInProgressByEmail.delete(accountKey);
+            return;
+        }
+        const results = await checkAccountsQuota([singleAccount], client, providerId);
+        if (results[0]?.status === "ok" && results[0]?.quota?.groups) {
+            accountManager.updateQuotaCache(accountIndex, results[0].quota.groups);
+            accountManager.requestSaveToDisk();
+        }
+    }
+    catch (err) {
+        log.debug(`quota-refresh-failed email=${accountKey}`, { error: String(err) });
+    }
+    finally {
+        quotaRefreshInProgressByEmail.delete(accountKey);
+    }
 }
 function trackWarmupAttempt(sessionId) {
     if (warmupSucceededSessionIds.has(sessionId)) {
@@ -650,6 +694,22 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
     const eventHandler = async (input) => {
         // Forward to update checker
         await updateChecker.event(input);
+        // Track if this is a child session (subagent, background task)
+        // This is used to filter toasts based on toast_scope config
+        if (input.event.type === "session.created") {
+            const props = input.event.properties;
+            if (props?.info?.parentID) {
+                isChildSession = true;
+                childSessionParentID = props.info.parentID;
+                log.debug("child-session-detected", { parentID: props.info.parentID });
+            }
+            else {
+                // Reset for root sessions - important when plugin instance is reused
+                isChildSession = false;
+                childSessionParentID = undefined;
+                log.debug("root-session-detected", {});
+            }
+        }
         // Handle session recovery
         if (sessionRecovery && input.event.type === "session.error") {
             const props = input.event.properties;
@@ -674,15 +734,18 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                         body: { parts: [{ type: "text", text: config.resume_text }] },
                         query: { directory },
                     }).catch(() => { });
-                    // Show success toast
+                    // Show success toast (respects toast_scope for child sessions)
                     const successToast = getRecoverySuccessToast();
-                    await client.tui.showToast({
-                        body: {
-                            title: successToast.title,
-                            message: successToast.message,
-                            variant: "success",
-                        },
-                    }).catch(() => { });
+                    log.debug("recovery-toast", { ...successToast, isChildSession, toastScope: config.toast_scope });
+                    if (!(config.toast_scope === "root_only" && isChildSession)) {
+                        await client.tui.showToast({
+                            body: {
+                                title: successToast.title,
+                                message: successToast.message,
+                                variant: "success",
+                            },
+                        }).catch(() => { });
+                    }
                 }
             }
         }
@@ -822,12 +885,20 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                         // Use while(true) loop to handle rate limits with backoff
                         // This ensures we wait and retry when all accounts are rate-limited
                         const quietMode = config.quiet_mode;
-                        // Helper to show toast without blocking on abort (respects quiet_mode)
+                        const toastScope = config.toast_scope;
+                        // Helper to show toast without blocking on abort (respects quiet_mode and toast_scope)
                         const showToast = async (message, variant) => {
+                            // Always log to debug regardless of toast filtering
+                            log.debug("toast", { message, variant, isChildSession, toastScope });
                             if (quietMode)
                                 return;
                             if (abortSignal?.aborted)
                                 return;
+                            // Filter toasts for child sessions when toast_scope is "root_only"
+                            if (toastScope === "root_only" && isChildSession) {
+                                log.debug("toast-suppressed-child-session", { message, variant, parentID: childSessionParentID });
+                                return;
+                            }
                             if (variant === "warning" && message.toLowerCase().includes("rate")) {
                                 if (!shouldShowRateLimitToast(message)) {
                                     return;
@@ -845,8 +916,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                         const hasOtherAccountWithAntigravity = (currentAccount) => {
                             if (family !== "gemini")
                                 return false;
-                            const otherAccounts = accountManager.getAccounts().filter(acc => acc.index !== currentAccount.index);
-                            return otherAccounts.some(acc => !accountManager.isRateLimitedForHeaderStyle(acc, family, "antigravity", model));
+                            // Use AccountManager method which properly checks for disabled/cooling-down accounts
+                            return accountManager.hasOtherAccountWithAntigravityAvailable(currentAccount.index, family, model);
                         };
                         while (true) {
                             // Check for abort at the start of each iteration
@@ -855,8 +926,29 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             if (accountCount === 0) {
                                 throw new Error("No Antigravity accounts available. Run `opencode auth login`.");
                             }
-                            const account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, 'antigravity', config.pid_offset_enabled);
+                            const softQuotaCacheTtlMs = computeSoftQuotaCacheTtlMs(config.soft_quota_cache_ttl_minutes, config.quota_refresh_interval_minutes);
+                            const account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, 'antigravity', config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs);
                             if (!account) {
+                                if (accountManager.areAllAccountsOverSoftQuota(family, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, model)) {
+                                    const threshold = config.soft_quota_threshold_percent;
+                                    const softQuotaWaitMs = accountManager.getMinWaitTimeForSoftQuota(family, threshold, softQuotaCacheTtlMs, model);
+                                    const maxWaitMs = (config.max_rate_limit_wait_seconds ?? 300) * 1000;
+                                    if (softQuotaWaitMs === null || (maxWaitMs > 0 && softQuotaWaitMs > maxWaitMs)) {
+                                        const waitTimeFormatted = softQuotaWaitMs ? formatWaitTime(softQuotaWaitMs) : "unknown";
+                                        await showToast(`All accounts over ${threshold}% quota threshold. Resets in ${waitTimeFormatted}.`, "error");
+                                        throw new Error(`Quota protection: All ${accountCount} account(s) are over ${threshold}% usage for ${family}. ` +
+                                            `Quota resets in ${waitTimeFormatted}. ` +
+                                            `Add more accounts, wait for quota reset, or set soft_quota_threshold_percent: 100 to disable.`);
+                                    }
+                                    const waitSecValue = Math.max(1, Math.ceil(softQuotaWaitMs / 1000));
+                                    pushDebug(`all-over-soft-quota family=${family} accounts=${accountCount} waitMs=${softQuotaWaitMs}`);
+                                    if (!softQuotaToastShown) {
+                                        await showToast(`All ${accountCount} account(s) over ${threshold}% quota. Waiting ${formatWaitTime(softQuotaWaitMs)}...`, "warning");
+                                        softQuotaToastShown = true;
+                                    }
+                                    await sleep(softQuotaWaitMs, abortSignal);
+                                    continue;
+                                }
                                 const headerStyle = getHeaderStyleFromUrl(urlString, family);
                                 const explicitQuota = isExplicitQuotaFromUrl(urlString);
                                 // All accounts are rate-limited - wait and retry
@@ -882,16 +974,16 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         `Quota resets in ${waitTimeFormatted}. ` +
                                         `Add more accounts with \`opencode auth login\` or wait and retry.`);
                                 }
-                                if (!allAccountsRateLimitedToastShown) {
+                                if (!rateLimitToastShown) {
                                     await showToast(`All ${accountCount} account(s) rate-limited for ${family}. Waiting ${waitSecValue}s...`, "warning");
-                                    allAccountsRateLimitedToastShown = true;
+                                    rateLimitToastShown = true;
                                 }
                                 // Wait for the rate-limit cooldown to expire, then retry
                                 await sleep(waitMs, abortSignal);
                                 continue;
                             }
                             // Account is available - reset the toast flag
-                            resetAllAccountsRateLimitedToast();
+                            resetAllAccountsBlockedToasts();
                             pushDebug(`selected idx=${account.index} email=${account.email ?? ""} family=${family} accounts=${accountCount} strategy=${config.account_selection_strategy}`);
                             if (isDebugEnabled()) {
                                 logAccountContext("Selected", {
@@ -1054,9 +1146,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             // Try endpoint fallbacks with single header style based on model suffix
                             let shouldSwitchAccount = false;
                             // Determine header style from model suffix:
-                            // - Models with :antigravity suffix -> use Antigravity quota
-                            // - Models without suffix (default) -> use Gemini CLI quota
-                            // - Claude models -> always use Antigravity
+                            // - Gemini models default to Antigravity
+                            // - Claude models always use Antigravity
                             let headerStyle = getHeaderStyleFromUrl(urlString, family);
                             const explicitQuota = isExplicitQuotaFromUrl(urlString);
                             pushDebug(`headerStyle=${headerStyle} explicit=${explicitQuota}`);
@@ -1065,8 +1156,29 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             }
                             // Check if this header style is rate-limited for this account
                             if (accountManager.isRateLimitedForHeaderStyle(account, family, headerStyle, model)) {
-                                // Quota fallback: try alternate quota on same account (if enabled and not explicit)
-                                if (config.quota_fallback && !explicitQuota && family === "gemini") {
+                                // Antigravity-first fallback: exhaust antigravity across ALL accounts before gemini-cli
+                                if (config.quota_fallback && !explicitQuota && family === "gemini" && headerStyle === "antigravity") {
+                                    // Check if ANY other account has antigravity available
+                                    if (accountManager.hasOtherAccountWithAntigravityAvailable(account.index, family, model)) {
+                                        // Switch to another account with antigravity (preserve antigravity priority)
+                                        pushDebug(`antigravity rate-limited on account ${account.index}, but available on other accounts. Switching.`);
+                                        shouldSwitchAccount = true;
+                                    }
+                                    else {
+                                        // All accounts exhausted antigravity - fall back to gemini-cli on this account
+                                        const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
+                                        if (alternateStyle && alternateStyle !== headerStyle) {
+                                            await showToast(`Antigravity quota exhausted on all accounts. Using Gemini CLI quota.`, "warning");
+                                            headerStyle = alternateStyle;
+                                            pushDebug(`all-accounts antigravity exhausted, quota fallback: ${headerStyle}`);
+                                        }
+                                        else {
+                                            shouldSwitchAccount = true;
+                                        }
+                                    }
+                                }
+                                else if (config.quota_fallback && !explicitQuota && family === "gemini") {
+                                    // gemini-cli rate-limited - try alternate style (antigravity) on same account
                                     const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
                                     if (alternateStyle && alternateStyle !== headerStyle) {
                                         const quotaName = headerStyle === "gemini-cli" ? "Gemini CLI" : "Antigravity";
@@ -1098,6 +1210,12 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         lastEndpointIndex = i;
                                     }
                                     const currentEndpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i];
+                                    // Skip sandbox endpoints for Gemini CLI models - they only work with Antigravity quota
+                                    // Gemini CLI models must use production endpoint (cloudcode-pa.googleapis.com)
+                                    if (headerStyle === "gemini-cli" && currentEndpoint !== ANTIGRAVITY_ENDPOINT_PROD) {
+                                        pushDebug(`Skipping sandbox endpoint ${currentEndpoint} for gemini-cli headerStyle`);
+                                        continue;
+                                    }
                                     try {
                                         const prepared = prepareAntigravityRequest(input, init, accessToken, projectContext.effectiveProjectId, currentEndpoint, headerStyle, forceThinkingRecovery, {
                                             claudeToolHardening: config.claude_tool_hardening,
@@ -1333,6 +1451,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             account.consecutiveFailures = 0;
                                             getHealthTracker().recordSuccess(account.index);
                                             accountManager.markAccountUsed(account.index);
+                                            void triggerAsyncQuotaRefreshForAccount(accountManager, account.index, client, providerId, config.quota_refresh_interval_minutes);
                                         }
                                         logAntigravityDebugResponse(debugContext, response, {
                                             note: response.ok ? "Success" : `Error ${response.status}`,
@@ -1509,39 +1628,129 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     });
                                     menuResult = await promptLoginMode(existingAccounts);
                                     if (menuResult.mode === "check") {
-                                        console.log("\nChecking quotas for all accounts...");
+                                        console.log("\n📊 Checking quotas for all accounts...\n");
                                         const results = await checkAccountsQuota(existingStorage.accounts, client, providerId);
+                                        let storageUpdated = false;
                                         for (const res of results) {
                                             const label = res.email || `Account ${res.index + 1}`;
                                             const disabledStr = res.disabled ? " (disabled)" : "";
-                                            console.log(`\n${res.index + 1}. ${label}${disabledStr}`);
+                                            console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+                                            console.log(`  ${label}${disabledStr}`);
+                                            console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
                                             if (res.status === "error") {
-                                                console.log(`   Error: ${res.error}`);
+                                                console.log(`  ❌ Error: ${res.error}\n`);
                                                 continue;
                                             }
-                                            if (!res.quota || Object.keys(res.quota.groups).length === 0) {
-                                                console.log("   No quota information available.");
-                                                if (res.quota?.error)
-                                                    console.log(`   Error: ${res.quota.error}`);
-                                                continue;
-                                            }
-                                            const printGrp = (name, group) => {
-                                                if (!group)
-                                                    return;
-                                                const remaining = typeof group.remainingFraction === 'number'
-                                                    ? `${Math.round(group.remainingFraction * 100)}%`
-                                                    : 'UNKNOWN';
-                                                const resetStr = group.resetTime ? `, resets in ${formatWaitTime(Date.parse(group.resetTime) - Date.now())}` : '';
-                                                console.log(`   ${name}: ${remaining}${resetStr}`);
+                                            // ANSI color codes
+                                            const colors = {
+                                                red: '\x1b[31m',
+                                                orange: '\x1b[33m', // Yellow/orange
+                                                green: '\x1b[32m',
+                                                reset: '\x1b[0m',
+                                            };
+                                            // Get color based on remaining percentage
+                                            const getColor = (remaining) => {
+                                                if (typeof remaining !== 'number')
+                                                    return colors.reset;
+                                                if (remaining < 0.2)
+                                                    return colors.red;
+                                                if (remaining < 0.6)
+                                                    return colors.orange;
+                                                return colors.green;
                                             };
-                                            printGrp("Claude", res.quota.groups.claude);
-                                            printGrp("Gemini 3 Pro", res.quota.groups["gemini-pro"]);
-                                            printGrp("Gemini 3 Flash", res.quota.groups["gemini-flash"]);
+                                            // Helper to create colored progress bar
+                                            const createProgressBar = (remaining, width = 20) => {
+                                                if (typeof remaining !== 'number')
+                                                    return '░'.repeat(width) + ' ???';
+                                                const filled = Math.round(remaining * width);
+                                                const empty = width - filled;
+                                                const color = getColor(remaining);
+                                                const bar = `${color}${'█'.repeat(filled)}${colors.reset}${'░'.repeat(empty)}`;
+                                                const pct = `${color}${Math.round(remaining * 100)}%${colors.reset}`.padStart(4 + color.length + colors.reset.length);
+                                                return `${bar} ${pct}`;
+                                            };
+                                            // Helper to format reset time with days support
+                                            const formatReset = (resetTime) => {
+                                                if (!resetTime)
+                                                    return '';
+                                                const ms = Date.parse(resetTime) - Date.now();
+                                                if (ms <= 0)
+                                                    return ' (resetting...)';
+                                                const hours = ms / (1000 * 60 * 60);
+                                                if (hours >= 24) {
+                                                    const days = Math.floor(hours / 24);
+                                                    const remainingHours = Math.floor(hours % 24);
+                                                    if (remainingHours > 0) {
+                                                        return ` (resets in ${days}d ${remainingHours}h)`;
+                                                    }
+                                                    return ` (resets in ${days}d)`;
+                                                }
+                                                return ` (resets in ${formatWaitTime(ms)})`;
+                                            };
+                                            // Display Gemini CLI Quota first (as requested - swap order)
+                                            const hasGeminiCli = res.geminiCliQuota && res.geminiCliQuota.models.length > 0;
+                                            console.log(`\n  ┌─ Gemini CLI Quota`);
+                                            if (!hasGeminiCli) {
+                                                const errorMsg = res.geminiCliQuota?.error || "No Gemini CLI quota available";
+                                                console.log(`  │  └─ ${errorMsg}`);
+                                            }
+                                            else {
+                                                const models = res.geminiCliQuota.models;
+                                                models.forEach((model, idx) => {
+                                                    const isLast = idx === models.length - 1;
+                                                    const connector = isLast ? "└─" : "├─";
+                                                    const bar = createProgressBar(model.remainingFraction);
+                                                    const reset = formatReset(model.resetTime);
+                                                    const modelName = model.modelId.padEnd(29);
+                                                    console.log(`  │  ${connector} ${modelName} ${bar}${reset}`);
+                                                });
+                                            }
+                                            // Display Antigravity Quota second
+                                            const hasAntigravity = res.quota && Object.keys(res.quota.groups).length > 0;
+                                            console.log(`  │`);
+                                            console.log(`  └─ Antigravity Quota`);
+                                            if (!hasAntigravity) {
+                                                const errorMsg = res.quota?.error || "No quota information available";
+                                                console.log(`     └─ ${errorMsg}`);
+                                            }
+                                            else {
+                                                const groups = res.quota.groups;
+                                                const groupEntries = [
+                                                    { name: "Claude", data: groups.claude },
+                                                    { name: "Gemini 3 Pro", data: groups["gemini-pro"] },
+                                                    { name: "Gemini 3 Flash", data: groups["gemini-flash"] },
+                                                ].filter(g => g.data);
+                                                groupEntries.forEach((g, idx) => {
+                                                    const isLast = idx === groupEntries.length - 1;
+                                                    const connector = isLast ? "└─" : "├─";
+                                                    const bar = createProgressBar(g.data.remainingFraction);
+                                                    const reset = formatReset(g.data.resetTime);
+                                                    const modelName = g.name.padEnd(29);
+                                                    console.log(`     ${connector} ${modelName} ${bar}${reset}`);
+                                                });
+                                            }
+                                            console.log("");
+                                            // Cache quota data for soft quota protection
+                                            if (res.quota?.groups) {
+                                                const acc = existingStorage.accounts[res.index];
+                                                if (acc) {
+                                                    acc.cachedQuota = res.quota.groups;
+                                                    acc.cachedQuotaUpdatedAt = Date.now();
+                                                    storageUpdated = true;
+                                                }
+                                            }
                                             if (res.updatedAccount) {
-                                                existingStorage.accounts[res.index] = res.updatedAccount;
-                                                await saveAccounts(existingStorage);
+                                                existingStorage.accounts[res.index] = {
+                                                    ...res.updatedAccount,
+                                                    cachedQuota: res.quota?.groups,
+                                                    cachedQuotaUpdatedAt: Date.now(),
+                                                };
+                                                storageUpdated = true;
                                             }
                                         }
+                                        if (storageUpdated) {
+                                            await saveAccounts(existingStorage);
+                                        }
                                         console.log("");
                                         continue;
                                     }
@@ -1978,10 +2187,10 @@ function getHeaderStyleFromUrl(urlString, family) {
     }
     const modelWithSuffix = extractModelFromUrlWithSuffix(urlString);
     if (!modelWithSuffix) {
-        return "gemini-cli";
+        return "antigravity";
     }
     const { quotaPreference } = resolveModelWithTier(modelWithSuffix);
-    return quotaPreference ?? "gemini-cli";
+    return quotaPreference === "gemini-cli" ? "antigravity" : (quotaPreference ?? "antigravity");
 }
 function isExplicitQuotaFromUrl(urlString) {
     const modelWithSuffix = extractModelFromUrlWithSuffix(urlString);
@@ -1991,4 +2200,7 @@ function isExplicitQuotaFromUrl(urlString) {
     const { explicitQuota } = resolveModelWithTier(modelWithSuffix);
     return explicitQuota ?? false;
 }
+export const __testExports = {
+    getHeaderStyleFromUrl,
+};
 //# sourceMappingURL=plugin.js.map