@cortexkit/opencode-antigravity-auth 3.0.5 → 3.0.6

package/dist/src/plugin/shared/request-services.js

@@ -1,6 +1,6 @@
 /**
  * Shared Antigravity request engine: account selection, retries, endpoint
- * and quota fallback, warmups and response handling for one plugin location.
+ * fallback, warmups and response handling for one plugin location.
  *
  * OpenCode 1's `createFetchInterceptor` and the GA location services both
  * call `createRequestExecutor`, so there is exactly one retry loop. Every
@@ -16,12 +16,12 @@
  * `RequestWire`, which `createRequestWire` binds to one location's signature
  * cache, debug log and logger; the raw sender is called unchanged.
  */
-import { accessTokenExpired, calculateBackoffMs, computeSoftQuotaCacheTtlMs, getPublicModelDefinitions, getResolverAliasMap, isClaudeThinkingModel, isImageGenerationModel, isRetiredAgyModel, parseRateLimitReason, preserveResponseMetadata, RETIRED_AGY_MODEL_MESSAGE, redactCredentialError, redactCredentialResponse, redactCredentialText, resolveQuotaGroup, VAULT_ACCOUNT_REMEDY, } from '@cortexkit/antigravity-auth-core';
-import { ANTIGRAVITY_ENDPOINT_FALLBACKS, } from '../../constants';
+import { accessTokenExpired, calculateBackoffMs, computeSoftQuotaCacheTtlMs, getPublicModelDefinitions, getQuotaKey, getResolverAliasMap, isClaudeThinkingModel, isImageGenerationModel, isRetiredAgyModel, parseRateLimitReason, preserveResponseMetadata, RETIRED_AGY_MODEL_MESSAGE, redactCredentialError, redactCredentialResponse, redactCredentialText, resolveQuotaGroup, VAULT_ACCOUNT_REMEDY, } from '@cortexkit/antigravity-auth-core';
+import { ANTIGRAVITY_ENDPOINT_FALLBACKS } from '../../constants';
 import { AntigravityKillswitchError } from '../errors';
 import { createRetryState, } from '../fetch/retry-state';
 import { createWarmupState } from '../fetch/warmup';
-import { extractModelFromUrl, getModelFamilyFromUrl, isCapacityRetryBudgetExhausted, MAX_TOTAL_CAPACITY_RETRIES, resolveHeaderRoutingDecision, resolveQuotaFallbackHeaderStyle, toUrlString, toWarmupStreamUrl, } from '../fetch-routing';
+import { extractModelFromUrl, getModelFamilyFromUrl, isCapacityRetryBudgetExhausted, MAX_TOTAL_CAPACITY_RETRIES, toUrlString, toWarmupStreamUrl, } from '../fetch-routing';
 import { noteGeminiDumpResponse } from '../gemini-dump';
 import { evaluateKillswitchForAccount, throwIfAllKilled } from '../killswitch';
 import { createNativeGoogleErrorResponse, createSyntheticTextResponse, isEmptyResponseBody, } from '../request-helpers';
@@ -39,7 +39,7 @@ const FIRST_RETRY_DELAY_MS = 1000;
  * `RequestWire.prepare`'s.
  */
 export function prepareAgyWireRequest(wire, request) {
-    return wire.prepare(request.input, request.init, request.accessToken, request.projectId, request.endpoint, request.headerStyle, request.forceThinkingRecovery ?? false, request.options);
+    return wire.prepare(request.input, request.init, request.accessToken, request.projectId, request.endpoint, request.forceThinkingRecovery ?? false, request.options);
 }
 /**
  * The model a title request is sent to when the host selected one this
@@ -61,6 +61,22 @@ export function routeTitleModel(url) {
         return url;
     return url.replace(`/models/${model}`, `/models/${TITLE_FALLBACK_MODEL}`);
 }
+/**
+ * Return the retired-model error using only the model registry: callers need
+ * neither an initialized account store nor an available vault to reject it.
+ */
+export function retiredModelResponse(url) {
+    const model = extractModelFromUrl(url);
+    if (!model || !isRetiredAgyModel(model))
+        return undefined;
+    return new Response(JSON.stringify({
+        error: {
+            code: 412,
+            status: 'FAILED_PRECONDITION',
+            message: RETIRED_AGY_MODEL_MESSAGE,
+        },
+    }), { status: 412, headers: { 'Content-Type': 'application/json' } });
+}
 /**
  * The AGY metadata key for a request: the host session for primary (and
  * kind-less) requests, a separate per-kind key for every other kind.
@@ -174,7 +190,7 @@ function sleep(ms, signal) {
  * dropped.
  */
 export function createLocalQuotaRefresh(accountManager, quotaManager, log) {
-    return async function refreshQuotaAfterSuccess(account, intervalMinutes) {
+    return async function refreshQuotaAfterSuccess(account, intervalMinutes, signal) {
         if (intervalMinutes <= 0)
             return;
         const accountIndex = accountManager.getAccounts().indexOf(account);
@@ -197,7 +213,11 @@ export function createLocalQuotaRefresh(accountManager, quotaManager, log) {
             const expectedRefreshToken = singleAccount.refreshToken;
             const result = await quotaManager.refreshAccount(singleAccount, {
                 index: accountIndex,
+                purpose: 'advisory',
+                ...(signal ? { signal } : {}),
             });
+            if (signal?.aborted)
+                return;
             if (result.status === 'ok' && result.quota?.groups) {
                 // Re-resolve the selected row itself. If it was removed meanwhile,
                 // drop the reading rather than writing onto whichever row shifted
@@ -219,11 +239,13 @@ export function createLocalQuotaRefresh(accountManager, quotaManager, log) {
  * warmup bookkeeping, so disposing it releases every counter.
  */
 export function createRequestExecutor(deps) {
-    const { config, accounts: accountManager, credentials, sessions: agySessionRegistry, operatorSettings, transport: defaultTransport, fetchImpl: upstreamFetch, wire, debug, dump, logger: log, trackers, classifyAccessError, notify, onRouting, } = deps;
+    const { config, accounts: accountManager, credentials, sessions: agySessionRegistry, operatorSettings, transport: defaultTransport, wire, debug, dump, logger: log, trackers, classifyAccessError, notify, onRouting, } = deps;
     const retryState = createRetryState();
     const warmupState = createWarmupState();
     const shutdown = new AbortController();
     const inFlight = new Set();
+    const advisoryWork = new Set();
+    let advisoryClosing = false;
     const bufferedOverflow = new WeakMap();
     let retired = false;
     let drainPromise;
@@ -295,18 +317,40 @@ export function createRequestExecutor(deps) {
                 });
             }
         }
+        let selectedVariant = options.variant;
         if (kind === 'title') {
-            input = routeTitleModel(input);
+            const routed = routeTitleModel(input);
+            // A variant belongs to its catalog model, not the replacement title model.
+            if (routed !== input)
+                selectedVariant = undefined;
+            input = routed;
         }
+        const retired = retiredModelResponse(input);
+        if (retired)
+            return retired;
         const selectedModel = extractModelFromUrl(input);
-        if (selectedModel && isRetiredAgyModel(selectedModel)) {
-            return new Response(JSON.stringify({
-                error: {
-                    code: 412,
-                    status: 'FAILED_PRECONDITION',
-                    message: RETIRED_AGY_MODEL_MESSAGE,
-                },
-            }), { status: 412, headers: { 'Content-Type': 'application/json' } });
+        let variant;
+        if (selectedVariant !== undefined) {
+            const definitions = getPublicModelDefinitions();
+            const variants = selectedModel && Object.hasOwn(definitions, selectedModel)
+                ? definitions[selectedModel]?.variants
+                : undefined;
+            const registered = variants && Object.hasOwn(variants, selectedVariant)
+                ? variants[selectedVariant]
+                : undefined;
+            if (!registered || registered.disabled === true) {
+                return new Response(JSON.stringify({
+                    error: {
+                        code: 412,
+                        status: 'FAILED_PRECONDITION',
+                        message: 'This Antigravity thinking level is unavailable. Choose another thinking level.',
+                    },
+                }), { status: 412, headers: { 'Content-Type': 'application/json' } });
+            }
+            variant = {
+                thinkingLevel: registered.thinkingLevel,
+                thinkingBudget: registered.thinkingConfig?.thinkingBudget,
+            };
         }
         // A host that sends each request through its own raw sender (the GA
         // loopback bridge) supplies it per request; every send of this request,
@@ -367,16 +411,6 @@ export function createRequestExecutor(deps) {
         };
         const quietMode = config.quiet_mode;
         const toastScope = config.toast_scope;
-        // Apply operator-controlled routing overrides live. The slash
-        // commands mutate these values through `applyCommand`; reading
-        // them per-request means a runtime flip takes effect on the next
-        // dispatched call without restarting the plugin.
-        const operatorRouting = operatorSettings?.get().routing;
-        const effectiveConfig = {
-            ...config,
-            cli_first: operatorRouting?.cli_first ?? config.cli_first,
-            quota_style_fallback: operatorRouting?.quota_style_fallback ?? config.quota_style_fallback,
-        };
         const showToast = async (message, variant) => {
             log.debug('toast', {
                 message,
@@ -408,11 +442,6 @@ export function createRequestExecutor(deps) {
                 // TUI may not be available
             }
         };
-        const hasOtherAccountWithAntigravity = (currentAccount) => {
-            if (family !== 'gemini')
-                return false;
-            return accountManager.hasOtherAccountWithAntigravityAvailable(currentAccount.index, family, model);
-        };
         let accountSwitchCount = 0;
         const maxAccountSwitches = config.max_account_switches ?? 2;
         let previousAccountIndex = -1;
@@ -422,8 +451,6 @@ export function createRequestExecutor(deps) {
             await assertAdmission();
             checkAborted();
             const accountCount = accountManager.getAccountCount();
-            const routingDecision = resolveHeaderRoutingDecision(urlString, family, effectiveConfig);
-            const { preferredHeaderStyle, explicitQuota, allowQuotaFallback } = routingDecision;
             if (accountCount === 0) {
                 // Mirror the no-account short-circuit inside the retry loop so callers
                 // that race with account removal still get a proper 401 instead of a
@@ -441,12 +468,6 @@ export function createRequestExecutor(deps) {
                     .getAccounts()
                     .filter((entry) => {
                     const decision = evaluateKillswitchForAccount(entry, family, {
-                        routing: effectiveConfig.cli_first !== undefined
-                            ? {
-                                cli_first: effectiveConfig.cli_first,
-                                quota_style_fallback: !!effectiveConfig.quota_style_fallback,
-                            }
-                            : { cli_first: false, quota_style_fallback: false },
                         killswitch: operatorKillswitch,
                         log_level: 'info',
                     }, { now: Date.now(), model });
@@ -463,7 +484,6 @@ export function createRequestExecutor(deps) {
                         model: model ?? 'unknown',
                         accounts: accountManager.getAccounts(),
                         settings: {
-                            routing: { cli_first: false, quota_style_fallback: false },
                             killswitch: operatorKillswitch ?? {
                                 enabled: false,
                                 minimum_remaining_percent: 0,
@@ -490,8 +510,7 @@ export function createRequestExecutor(deps) {
                 }
             }
             // The eligibility mask above is computed once for this selection
-            // pass and applies to both the initial selection and the header-style
-            // fallback below. Selection does not re-evaluate quota, so a killed
+            // pass and applies to the account selection below. Selection does not re-evaluate quota, so a killed
             // current account falls through to the next eligible account.
             const killedIndexes = eligibleIndexes === null
                 ? undefined
@@ -499,7 +518,7 @@ export function createRequestExecutor(deps) {
                     .getAccounts()
                     .map((entry) => entry.index)
                     .filter((index) => !eligibleIndexes.has(index)));
-            let account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, preferredHeaderStyle, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity, killedIndexes);
+            let account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity, killedIndexes);
             // The selected account must be inside the eligibility mask.
             if (account &&
                 eligibleIndexes !== null &&
@@ -507,21 +526,6 @@ export function createRequestExecutor(deps) {
                 pushDebug(`killswitch-excluded idx=${account.index} (precomputed eligible set)`);
                 account = null;
             }
-            if (!account && allowQuotaFallback) {
-                const alternateHeaderStyle = preferredHeaderStyle === 'antigravity' ? 'gemini-cli' : 'antigravity';
-                account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, alternateHeaderStyle, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity, killedIndexes);
-                if (account) {
-                    pushDebug(`selected-by-fallback idx=${account.index} preferred=${preferredHeaderStyle} alternate=${alternateHeaderStyle}`);
-                }
-                // The header-style fallback may not select an account outside the
-                // eligibility mask.
-                if (account &&
-                    eligibleIndexes !== null &&
-                    !eligibleIndexes.has(account.index)) {
-                    pushDebug(`killswitch-excluded idx=${account.index} after fallback (precomputed eligible set)`);
-                    account = null;
-                }
-            }
             if (!account) {
                 if (accountManager.areAllAccountsOverSoftQuota(family, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, model)) {
                     const threshold = config.soft_quota_threshold_percent;
@@ -547,8 +551,7 @@ export function createRequestExecutor(deps) {
                     await sleep(softQuotaWaitMs, abortSignal);
                     continue;
                 }
-                const strictWait = !allowQuotaFallback;
-                const minWaitMs = accountManager.getMinWaitTimeForFamily(family, model, preferredHeaderStyle, strictWait);
+                const minWaitMs = accountManager.getMinWaitTimeForFamily(family, model);
                 const waitMs = minWaitMs || 60_000;
                 pushDebug(`all-rate-limited family=${family} accounts=${accountCount} waitMs=${waitMs}`);
                 if (debug.isDebugEnabled()) {
@@ -683,7 +686,7 @@ export function createRequestExecutor(deps) {
                             }
                             if (shouldCooldown) {
                                 accountManager.markAccountCoolingDown(account, cooldownMs, 'auth-failure');
-                                accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
+                                accountManager.markRateLimited(account, cooldownMs, family, model);
                                 pushDebug(`token-refresh-failed: cooldown ${cooldownMs}ms after ${failures} failures`);
                             }
                             continue;
@@ -736,7 +739,7 @@ export function createRequestExecutor(deps) {
                             error instanceof Error ? error : new Error(String(error));
                         if (shouldCooldown) {
                             accountManager.markAccountCoolingDown(account, cooldownMs, 'auth-failure');
-                            accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
+                            accountManager.markRateLimited(account, cooldownMs, family, model);
                             pushDebug(`token-refresh-error: cooldown ${cooldownMs}ms after ${failures} failures`);
                         }
                         continue;
@@ -765,7 +768,7 @@ export function createRequestExecutor(deps) {
                     lastError = error instanceof Error ? error : new Error(String(error));
                     if (shouldCooldown) {
                         accountManager.markAccountCoolingDown(account, cooldownMs, 'project-error');
-                        accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
+                        accountManager.markRateLimited(account, cooldownMs, family, model);
                         pushDebug(`project-context-error: cooldown ${cooldownMs}ms after ${failures} failures`);
                     }
                     continue;
@@ -833,12 +836,10 @@ export function createRequestExecutor(deps) {
                 try {
                     pushDebug('thinking-warmup: start');
                     const warmupSend = await credentialForAuxiliarySend(warmupInit, projectId);
-                    const warmupResponse = prepared.headerStyle === 'antigravity'
-                        ? await transport(warmupUrl, warmupSend.init, {
-                            signal: abortSignal,
-                            onDebug: pushDebug,
-                        })
-                        : await upstreamFetch(warmupUrl, warmupSend.init);
+                    const warmupResponse = await transport(warmupUrl, warmupSend.init, {
+                        signal: abortSignal,
+                        onDebug: pushDebug,
+                    });
                     reportVault401(warmupSend.admission, warmupResponse.status);
                     const transformed = await wire.transformResponse(warmupResponse, true, warmupDebugContext, prepared.requestedModel, projectId, warmupUrl, prepared.effectiveModel, prepared.sessionId);
                     await transformed.text();
@@ -864,12 +865,10 @@ export function createRequestExecutor(deps) {
                 try {
                     pushDebug('cache-warmup-probe: start');
                     const probeSend = await credentialForAuxiliarySend({ ...prepared.init, method: 'POST', body: bodyStr }, prepared.projectId ?? '');
-                    const probeResponse = prepared.headerStyle === 'antigravity'
-                        ? await transport(toUrlString(prepared.request), probeSend.init, {
-                            signal: abortSignal,
-                            onDebug: pushDebug,
-                        })
-                        : await upstreamFetch(toUrlString(prepared.request), probeSend.init);
+                    const probeResponse = await transport(toUrlString(prepared.request), probeSend.init, {
+                        signal: abortSignal,
+                        onDebug: pushDebug,
+                    });
                     reportVault401(probeSend.admission, probeResponse.status);
                     if (probeResponse.body) {
                         const reader = probeResponse.body.getReader();
@@ -902,57 +901,11 @@ export function createRequestExecutor(deps) {
             };
             let apiRequestCount = 0;
             let shouldSwitchAccount = false;
-            let headerStyle = preferredHeaderStyle;
-            pushDebug(`headerStyle=${headerStyle} explicit=${explicitQuota}`);
             if (account.fingerprint) {
                 pushDebug(`fingerprint: deviceId=${account.fingerprint.deviceId.slice(0, 8)}...`);
             }
-            if (accountManager.isRateLimitedForHeaderStyle(account, family, headerStyle, model)) {
-                if (allowQuotaFallback &&
-                    family === 'gemini' &&
-                    headerStyle === 'antigravity') {
-                    if (accountManager.hasOtherAccountWithAntigravityAvailable(account.index, family, model)) {
-                        pushDebug(`antigravity rate-limited on account ${account.index}, but available on other accounts. Switching.`);
-                        shouldSwitchAccount = true;
-                    }
-                    else {
-                        const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
-                        const fallbackStyle = resolveQuotaFallbackHeaderStyle({
-                            family,
-                            headerStyle,
-                            alternateStyle,
-                        });
-                        if (fallbackStyle) {
-                            await showToast(`Antigravity quota exhausted on all accounts. Using Gemini CLI quota.`, 'warning');
-                            headerStyle = fallbackStyle;
-                            pushDebug(`all-accounts antigravity exhausted, quota fallback: ${headerStyle}`);
-                        }
-                        else {
-                            shouldSwitchAccount = true;
-                        }
-                    }
-                }
-                else if (allowQuotaFallback && family === 'gemini') {
-                    const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
-                    const fallbackStyle = resolveQuotaFallbackHeaderStyle({
-                        family,
-                        headerStyle,
-                        alternateStyle,
-                    });
-                    if (fallbackStyle) {
-                        const quotaName = headerStyle === 'gemini-cli' ? 'Gemini CLI' : 'Antigravity';
-                        const altQuotaName = fallbackStyle === 'gemini-cli' ? 'Gemini CLI' : 'Antigravity';
-                        await showToast(`${quotaName} quota exhausted, using ${altQuotaName} quota`, 'warning');
-                        headerStyle = fallbackStyle;
-                        pushDebug(`quota fallback: ${headerStyle}`);
-                    }
-                    else {
-                        shouldSwitchAccount = true;
-                    }
-                }
-                else {
-                    shouldSwitchAccount = true;
-                }
+            if (accountManager.isRateLimited(account, family, model)) {
+                shouldSwitchAccount = true;
             }
             let totalCapacityRetries = 0;
             while (!shouldSwitchAccount) {
@@ -969,11 +922,6 @@ export function createRequestExecutor(deps) {
                         lastEndpointIndex = i;
                     }
                     const currentEndpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i];
-                    if (headerStyle === 'gemini-cli' &&
-                        currentEndpoint !== 'https://cloudcode-pa.googleapis.com') {
-                        pushDebug(`Skipping sandbox endpoint ${currentEndpoint} for gemini-cli headerStyle`);
-                        continue;
-                    }
                     let tokenConsumed = false;
                     let physicalAttemptStarted = false;
                     try {
@@ -1011,7 +959,6 @@ export function createRequestExecutor(deps) {
                             accessToken: sendAccessToken,
                             projectId: sendProjectId,
                             endpoint: currentEndpoint,
-                            headerStyle,
                             forceThinkingRecovery,
                             options: {
                                 claudeToolHardening: config.claude_tool_hardening,
@@ -1019,6 +966,7 @@ export function createRequestExecutor(deps) {
                                 fingerprint: account.fingerprint,
                                 agySession: agyRequestSession,
                                 agyRequestTimestamp: agyRequestScope.timestamp,
+                                variant,
                             },
                         });
                         const originalUrl = toUrlString(input);
@@ -1081,9 +1029,7 @@ export function createRequestExecutor(deps) {
                         }
                         pushDebug(`dispatching request via ${prepared.headerStyle} transport`);
                         physicalAttemptStarted = true;
-                        const response = prepared.headerStyle === 'antigravity'
-                            ? await transport(toUrlString(prepared.request), prepared.init, { signal: abortSignal, onDebug: pushDebug })
-                            : await upstreamFetch(prepared.request, prepared.init);
+                        const response = await transport(toUrlString(prepared.request), prepared.init, { signal: abortSignal, onDebug: pushDebug });
                         apiRequestCount++;
                         accountManager.recordRequest(account.index, family);
                         const requestCounts = accountManager.getDailyRequestCounts(account.index);
@@ -1199,7 +1145,7 @@ export function createRequestExecutor(deps) {
                                     continue;
                                 }
                             }
-                            const quotaKey = retryState.headerStyleToQuotaKey(headerStyle, family);
+                            const quotaKey = getQuotaKey(family, model);
                             const backoff = retryState.getRateLimitBackoff(account.index, quotaKey, serverRetryMs);
                             const smartBackoffMs = calculateBackoffMs(rateLimitReason, account.consecutiveFailures ?? 0, serverRetryMs);
                             const effectiveDelayMs = Math.max(backoff.delayMs, smartBackoffMs);
@@ -1223,7 +1169,7 @@ export function createRequestExecutor(deps) {
                                     if (effectiveDelayMs <= maxCacheFirstWaitMs) {
                                         pushDebug(`cache_first: waiting ${effectiveDelayMs}ms for same account to recover`);
                                         await showToast(`⏳ Waiting ${Math.ceil(effectiveDelayMs / 1000)}s for same account (prompt cache preserved)...`, 'info');
-                                        accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs);
+                                        accountManager.markRateLimitedWithReason(account, family, model, rateLimitReason, serverRetryMs);
                                         await sleep(effectiveDelayMs, abortSignal);
                                         i -= 1;
                                         continue;
@@ -1231,59 +1177,16 @@ export function createRequestExecutor(deps) {
                                     pushDebug(`cache_first: wait ${effectiveDelayMs}ms exceeds max ${maxCacheFirstWaitMs}ms, switching account`);
                                 }
                                 if (config.switch_on_first_rate_limit && accountCount > 1) {
-                                    accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
+                                    accountManager.markRateLimitedWithReason(account, family, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
                                     shouldSwitchAccount = true;
                                     break;
                                 }
                                 i -= 1;
                                 continue;
                             }
-                            accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
+                            accountManager.markRateLimitedWithReason(account, family, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
                             accountManager.requestSaveToDisk();
                             const switchAccountDelayMs = config.switch_account_delay_ms ?? 500;
-                            if (family === 'gemini') {
-                                if (headerStyle === 'antigravity') {
-                                    if (hasOtherAccountWithAntigravity(account)) {
-                                        pushDebug(`antigravity exhausted on account ${account.index}, but available on others. Switching account.`);
-                                        await showToast(`Rate limited again. Switching account in ${formatWaitTime(switchAccountDelayMs)}...`, 'warning');
-                                        await sleep(switchAccountDelayMs, abortSignal);
-                                        shouldSwitchAccount = true;
-                                        break;
-                                    }
-                                    if (allowQuotaFallback) {
-                                        const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
-                                        const fallbackStyle = resolveQuotaFallbackHeaderStyle({
-                                            family,
-                                            headerStyle,
-                                            alternateStyle,
-                                        });
-                                        if (fallbackStyle) {
-                                            const safeModelName = model || 'this model';
-                                            await showToast(`Antigravity quota exhausted for ${safeModelName}. Switching to Gemini CLI quota...`, 'warning');
-                                            headerStyle = fallbackStyle;
-                                            pushDebug(`quota fallback: ${headerStyle}`);
-                                            continue;
-                                        }
-                                    }
-                                }
-                                else if (headerStyle === 'gemini-cli') {
-                                    if (allowQuotaFallback) {
-                                        const alternateStyle = accountManager.getAvailableHeaderStyle(account, family, model);
-                                        const fallbackStyle = resolveQuotaFallbackHeaderStyle({
-                                            family,
-                                            headerStyle,
-                                            alternateStyle,
-                                        });
-                                        if (fallbackStyle) {
-                                            const safeModelName = model || 'this model';
-                                            await showToast(`Gemini CLI quota exhausted for ${safeModelName}. Switching to Antigravity quota...`, 'warning');
-                                            headerStyle = fallbackStyle;
-                                            pushDebug(`quota fallback: ${headerStyle}`);
-                                            continue;
-                                        }
-                                    }
-                                }
-                            }
                             if (accountCount > 1) {
                                 const quotaMsg = reasonInfo.quotaResetTime
                                     ? ` (quota resets ${reasonInfo.quotaResetTime})`
@@ -1303,7 +1206,7 @@ export function createRequestExecutor(deps) {
                             shouldSwitchAccount = true;
                             break;
                         }
-                        const quotaKey = retryState.headerStyleToQuotaKey(headerStyle, family);
+                        const quotaKey = getQuotaKey(family, model);
                         retryState.resetRateLimitState(account.index, quotaKey);
                         retryState.resetAccountFailureState(account.index);
                         if (response.status === 403) {
@@ -1333,7 +1236,7 @@ export function createRequestExecutor(deps) {
                                 const cooldownMs = 10 * 60 * 1000;
                                 accountManager.markAccountVerificationRequired(account.index, verificationReason, extracted.verifyUrl);
                                 accountManager.markAccountCoolingDown(account, cooldownMs, 'validation-required');
-                                accountManager.markRateLimited(account, cooldownMs, family, headerStyle, model);
+                                accountManager.markRateLimited(account, cooldownMs, family, model);
                                 const label = account.email || `Account ${account.index + 1}`;
                                 if (accountManager.shouldShowAccountToast(account.index, 60000)) {
                                     await showToast(`⚠ ${label} needs verification. Run 'opencode auth login' and use Verify accounts.`, 'warning');
@@ -1358,17 +1261,28 @@ export function createRequestExecutor(deps) {
                         if (response.ok) {
                             account.consecutiveFailures = 0;
                             trackers.health.recordSuccess(account.index);
-                            accountManager.markAccountUsed(account.index);
+                            if (!advisoryClosing)
+                                accountManager.markAccountUsed(account.index);
                             if (credentials.domain === 'local' &&
+                                !advisoryClosing &&
                                 credentials.refreshQuotaAfterSuccess) {
-                                void credentials
-                                    .refreshQuotaAfterSuccess(account, config.quota_refresh_interval_minutes)
-                                    .catch(() => { });
+                                const quotaCancellation = createRequestCancellation(init?.signal
+                                    ? [init.signal, shutdown.signal]
+                                    : [shutdown.signal]);
+                                const work = credentials
+                                    .refreshQuotaAfterSuccess(account, config.quota_refresh_interval_minutes, quotaCancellation.signal)
+                                    .catch(() => {
+                                    log.debug('post-response-advisory-work-failed');
+                                })
+                                    .finally(() => quotaCancellation.release());
+                                advisoryWork.add(work);
+                                void work.then(() => advisoryWork.delete(work), () => advisoryWork.delete(work));
                             }
                             const proactiveThreshold = config.proactive_rotation_threshold_percent ?? 20;
-                            if (proactiveThreshold > 0 &&
+                            if (!advisoryClosing &&
+                                proactiveThreshold > 0 &&
                                 accountManager.shouldProactivelyRotate(family, model, proactiveThreshold, softQuotaCacheTtlMs, accountSessionIdentity)) {
-                                const rotated = accountManager.proactivelyRotateForFamily(family, model, headerStyle, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity);
+                                const rotated = accountManager.proactivelyRotateForFamily(family, model, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity);
                                 if (rotated) {
                                     const remaining = account.cachedQuota?.[resolveQuotaGroup(family, model)]
                                         ?.remainingFraction;
@@ -1537,7 +1451,7 @@ export function createRequestExecutor(deps) {
                             error instanceof Error ? error : new Error(String(error));
                         if (shouldCooldown) {
                             accountManager.markAccountCoolingDown(account, cooldownMs, 'network-error');
-                            accountManager.markRateLimited(account, cooldownMs, family, headerStyle, model);
+                            accountManager.markRateLimited(account, cooldownMs, family, model);
                             pushDebug(`endpoint-error: cooldown ${cooldownMs}ms after ${failures} failures`);
                         }
                         shouldSwitchAccount = true;
@@ -1571,10 +1485,13 @@ export function createRequestExecutor(deps) {
     // Waits for every admitted request and retained body, then releases the
     // bookkeeping they use. Runs once, whether `retire` or `dispose` asks first.
     function drain() {
+        advisoryClosing = true;
         drainPromise ??= (async () => {
             // A refresh that already exchanged tokens must finish its owned store write.
             while (inFlight.size > 0)
                 await Promise.allSettled([...inFlight]);
+            while (advisoryWork.size > 0)
+                await Promise.allSettled([...advisoryWork]);
             retryState.dispose();
             warmupState.dispose();
         })();