@cortexkit/opencode-antigravity-auth 2.2.1 → 3.0.1

package/dist/src/plugin/fetch-interceptor.js

@@ -1,195 +1,190 @@
-import { fetchWithAgyCliTransport } from '@cortexkit/antigravity-auth-core';
-import { ANTIGRAVITY_ENDPOINT_FALLBACKS } from '../constants';
-import { upsertSidebarActiveRouting, } from '../sidebar-state';
+import { fetchWithAgyCliTransport, } from '@cortexkit/antigravity-auth-core';
+import { upsertSidebarActiveRouting } from '../sidebar-state';
 import { extractAccountAccessErrorDetails } from './account-access';
-import { calculateBackoffMs, computeSoftQuotaCacheTtlMs, parseRateLimitReason, resolveQuotaGroup, } from './accounts';
-import { accessTokenExpired, isOAuthAuth } from './auth';
-import { isDebugEnabled, logAccountContext, logAntigravityDebugResponse, logRateLimitEvent, logRateLimitSnapshot, logResponseBody, startAntigravityDebugRequest, } from './debug';
-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 { dumpGeminiRequest, noteGeminiDumpResponse } from './gemini-dump';
-import { evaluateKillswitchForAccount, throwIfAllKilled } from './killswitch';
+import { createLocalAccountCredentials, StaleAccountGrantError, } from './accounts';
+import { isOAuthAuth } from './auth';
+import * as moduleDebug from './debug';
+import { dumpGeminiRequest } from './gemini-dump';
 import { createLogger } from './logger';
 import { ensureProjectContext } from './project';
 import { buildThinkingWarmupBody, getImageModelLocalTitle, getLastCacheStats, isGenerativeLanguageRequest, prepareAntigravityRequest, transformAntigravityResponse, } from './request';
-import { createSyntheticErrorResponse, createSyntheticTextResponse, isEmptyResponseBody, } from './request-helpers';
-import { getHealthTracker, getTokenTracker } from './rotation';
-import { extractOpenCodeSessionIdentity, } from './session-context';
+import { createLocalQuotaRefresh, createRequestExecutor, } from './shared/request-services';
+import { createVaultAccountPool, } from './shared/vault-request-credentials';
 import { AntigravityTokenRefreshError, refreshAccessToken } from './token';
 const log = createLogger('fetch-interceptor');
-/**
- * Per-call delay applied before the first 429 retry on the same account.
- * Matches the legacy plugin so callers that compare timing logs see parity.
- */
-const FIRST_RETRY_DELAY_MS = 1000;
 /** Production transport — used when the interceptor context omits one. */
 const defaultAgyTransport = (url, init, options) => fetchWithAgyCliTransport(url, init, options);
 /** Default `fetchImpl` used when the interceptor context omits one. */
 const defaultFetchImpl = (input, init) => globalThis.fetch(input, init);
 /**
- * Builds a Google-style 401 envelope describing a missing-account failure.
- *
- * The legacy plugin returned `createSyntheticErrorResponse(...)`, which yields
- * a 200 SSE body pretending to be a Gemini stream. That hid the underlying
- * misconfiguration from any caller that inspected `response.status`. Callers
- * (notably OpenCode's HTTP layer) treat 200 as success and silently swallow
- * the payload, so the user sees nothing. Surfacing a real 401 with the
- * standard Google error envelope makes the failure actionable.
+ * A pool-file account: the selected account's stored OAuth record is
+ * refreshed through the host's OAuth refresh, and a grant is sent only while
+ * that account is still in the pool, enabled and still holds the token.
  */
-function createNoAccountResponse(message, model) {
-    const body = {
-        error: {
-            code: 401,
-            message,
-            status: 'UNAUTHENTICATED',
-        },
+function poolFileCredentials(accountManager, client, providerId) {
+    return {
+        refresh: (account) => refreshAccessToken(accountManager.toAuthDetails(account), client, providerId),
+        // A pool-file row has no repository identity; its grant is checked
+        // against the pool itself.
+        captureGrant: ({ account, accessToken }) => ({
+            source: 'pool-file',
+            check() {
+                if (!accountManager.getAccounts().includes(account) ||
+                    account.enabled === false ||
+                    accountManager.toAuthDetails(account).access !== accessToken) {
+                    throw new StaleAccountGrantError();
+                }
+            },
+        }),
+        ensureProject: (auth) => ensureProjectContext(auth),
+        isInvalidGrant: (error) => error instanceof AntigravityTokenRefreshError &&
+            error.code === 'invalid_grant',
     };
-    return new Response(JSON.stringify(body), {
-        status: 401,
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Antigravity-Error-Type': 'no_accounts',
-            'X-Antigravity-Requested-Model': model,
-        },
-    });
-}
-function terminalFetchError(lastError, fallbackMessage) {
-    // A synthetic HTTP 200 is parsed as successful assistant text, bypassing the
-    // host's retry and error pipeline. Preserve the original exception rather
-    // than replacing it with a message-only synthetic response.
-    return lastError ?? new Error(fallbackMessage);
-}
-/** Reads `retry-after-ms` / `retry-after` headers, in that order. */
-function retryAfterMsFromResponse(response, defaultRetryMs = 60_000) {
-    const retryAfterMsHeader = response.headers.get('retry-after-ms');
-    if (retryAfterMsHeader) {
-        const parsed = Number.parseInt(retryAfterMsHeader, 10);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            return parsed;
-        }
-    }
-    const retryAfterHeader = response.headers.get('retry-after');
-    if (retryAfterHeader) {
-        const parsed = Number.parseInt(retryAfterHeader, 10);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            return parsed * 1000;
-        }
-    }
-    return defaultRetryMs;
-}
-/** Formats a millisecond duration the way the legacy toast pipeline did. */
-function formatWaitTime(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    const seconds = Math.ceil(ms / 1000);
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    if (minutes < 60) {
-        return remainingSeconds > 0
-            ? `${minutes}m ${remainingSeconds}s`
-            : `${minutes}m`;
-    }
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
 }
 /**
- * Sleep for `ms` milliseconds, rejecting with the abort reason when the
- * supplied signal fires before the timer elapses.
+ * An account-store account: refresh, grant check and invalid-grant
+ * recognition are the store adapter's own (`createLocalAccountCredentials`
+ * over the manager's repository), so a token is refreshed only through the
+ * repository on the selected account's row reference and never through the
+ * host client. The row reference is captured when the grant is resolved;
+ * every send is checked against that exact row, never against whatever the
+ * account object holds later, and a grant without one is never sent.
  */
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(signal.reason instanceof Error ? signal.reason : new Error('Aborted'));
-            return;
-        }
-        const timeout = setTimeout(() => {
-            cleanup();
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            cleanup();
-            reject(signal?.reason instanceof Error ? signal.reason : new Error('Aborted'));
-        };
-        const cleanup = () => {
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', onAbort);
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
+function storeCredentials(accountManager, repository) {
+    const credentials = createLocalAccountCredentials(accountManager, {
+        repository,
     });
+    return {
+        refresh: (account) => credentials.refresh(account),
+        captureGrant: (grant) => credentials.captureGrant(grant),
+        ensureProject: (auth) => credentials.ensureProject(auth),
+        isInvalidGrant: (error) => credentials.isInvalidGrant(error),
+    };
 }
 /**
- * Wraps the upstream fetch with the full account-rotation, rate-limit, and
- * quota-fallback pipeline. Each interceptor owns its retry/warmup bookkeeping
- * so disposing the plugin releases every counter.
+ * The engine collaborators every OpenCode 1 interceptor shares, whatever
+ * holds its accounts: wire functions, the module-level debug, dump and
+ * logger bindings, host toasts and the sidebar routing file.
+ */
+function openCode1EngineCollaborators(common) {
+    const { client } = common;
+    return {
+        config: common.config,
+        sessions: common.agySessionRegistry,
+        operatorSettings: common.operatorSettings,
+        transport: common.transport,
+        fetchImpl: common.fetchImpl,
+        wire: {
+            prepare: prepareAntigravityRequest,
+            transformResponse: transformAntigravityResponse,
+            buildThinkingWarmupBody,
+            getImageModelLocalTitle,
+            getLastCacheStats,
+        },
+        // OpenCode 1's module-level debug namespace provides the debug methods
+        // the engine calls.
+        debug: moduleDebug,
+        dump: { dumpRequest: dumpGeminiRequest },
+        logger: log,
+        classifyAccessError: extractAccountAccessErrorDetails,
+        notify: (message, variant) => client.tui.showToast({ body: { message, variant } }),
+        onRouting: common.onRouting ??
+            ((sessionId, entry) => {
+                void upsertSidebarActiveRouting(sessionId, entry, {
+                    authoritative: true,
+                }).catch((error) => {
+                    log.debug('sidebar-routing-upsert-failed', {
+                        sessionId,
+                        error: String(error),
+                    });
+                });
+            }),
+    };
+}
+/**
+ * OpenCode 1 binding of the shared request engine for accounts this plugin
+ * holds itself (pool file or account store). The retry, rotation and
+ * quota-fallback pipeline lives in `createRequestExecutor`; this wrapper
+ * decides which requests reach it and binds the account manager, its
+ * source's credential operations and OpenCode 1's collaborators.
  */
 export function createFetchInterceptor(context) {
-    const { client, providerId, config, accountManager, quotaManager, getAuth, agySessionRegistry, operatorSettings, agyTransport = defaultAgyTransport, fetchImpl = defaultFetchImpl,
+    const { client, providerId, accountManager, accountSource, quotaManager, getAuth, agyTransport = defaultAgyTransport, fetchImpl = defaultFetchImpl,
     // directory is part of the contract but not consumed by this interceptor;
     // callers use it when constructing sibling services (e.g. project context).
      } = context;
     void context.directory;
-    const retryState = createRetryState();
-    const warmupState = createWarmupState();
-    let disposed = false;
     // Capture the host fetch at factory time so the interceptor never shadows
     // it with its own (recursive) fetch binding. Production wires this up via
     // the OpenCode plugin runtime; tests inject a mock by stubbing globalThis
     // OR — preferred for e2e — pass `fetchImpl` through the context so the
     // stub survives a process-wide fetch replacement.
     const upstreamFetch = fetchImpl;
-    // Cache the bound transport so the three call sites (warmup, probe,
-    // dispatch) reuse the same closure. The binding happens once per
-    // interceptor to mirror the historical `fetchWithAgyCliTransport`
-    // import behavior — call sites used the function reference, not a
-    // re-bind per request.
-    const transport = agyTransport;
-    async function triggerAsyncQuotaRefreshForAccount(accountIndex, intervalMinutes) {
-        if (intervalMinutes <= 0)
-            return;
-        const accounts = accountManager.getAccounts();
-        const account = accounts[accountIndex];
-        if (!account || account.enabled === false)
-            return;
-        const intervalMs = intervalMinutes * 60 * 1000;
-        const age = account.cachedQuotaUpdatedAt != null
-            ? Date.now() - account.cachedQuotaUpdatedAt
-            : Infinity;
-        if (age < intervalMs)
-            return;
-        let singleAccount;
-        try {
-            const accountsForCheck = accountManager.getAccountsForQuotaCheck();
-            singleAccount = accountsForCheck[accountIndex];
-            if (!singleAccount)
-                return;
-            // Capture the refresh token BEFORE the await so a concurrent
-            // add/remove that shifts the index can't attribute this result
-            // to the wrong account when the refresh resolves.
-            const expectedRefreshToken = singleAccount.refreshToken;
-            const result = await quotaManager.refreshAccount(singleAccount, {
-                index: accountIndex,
-            });
-            if (result.status === 'ok' && result.quota?.groups) {
-                // Re-resolve the live index for the captured refresh token. If
-                // the account was removed mid-refresh, drop the result rather
-                // than writing onto whichever account shifted into the slot.
-                const currentIndex = accountManager
-                    .getAccounts()
-                    .findIndex((entry) => entry.parts.refreshToken === expectedRefreshToken);
-                if (currentIndex === -1)
-                    return;
-                accountManager.updateQuotaCache(currentIndex, result.quota.groups, expectedRefreshToken);
-                accountManager.requestSaveToDisk();
-            }
-        }
-        catch (err) {
-            log.debug(`quota-refresh-failed ${singleAccount ? quotaManager.hashedLogLabel('account', singleAccount) : `idx-${accountIndex}`}`, { error: String(err) });
+    const refreshQuotaAfterSuccess = createLocalQuotaRefresh(accountManager, quotaManager, log);
+    const executor = createRequestExecutor({
+        assertAdmission: context.assertAdmission,
+        ...openCode1EngineCollaborators({
+            ...context,
+            transport: agyTransport,
+            fetchImpl: upstreamFetch,
+        }),
+        accounts: accountManager,
+        credentials: {
+            domain: 'local',
+            toAuthDetails: (account) => accountManager.toAuthDetails(account),
+            updateFromAuth: (account, auth) => accountManager.updateFromAuth(account, auth),
+            removeAccount: (account) => accountManager.removeAccount(account),
+            saveToDisk: () => accountManager.saveToDisk(),
+            saveToDiskReplace: () => accountManager.saveToDiskReplace(),
+            ...(accountSource.kind === 'store'
+                ? storeCredentials(accountManager, accountSource.repository)
+                : poolFileCredentials(accountManager, client, providerId)),
+            clearStoredAuth: async () => {
+                await context.assertAdmission?.();
+                await client.auth.set({
+                    path: { id: providerId },
+                    body: { type: 'oauth', refresh: '', access: '', expires: 0 },
+                });
+            },
+            refreshQuotaAfterSuccess: async (account, intervalMinutes) => {
+                await context.assertAdmission?.();
+                await refreshQuotaAfterSuccess(account, intervalMinutes);
+            },
+        },
+        // The trackers the manager selects with: its own for a store-backed
+        // manager, the process-wide ones for the pool-file manager.
+        trackers: {
+            get health() {
+                return accountManager.healthTracker;
+            },
+            get token() {
+                return accountManager.tokenTracker;
+            },
+        },
+    });
+    let disposed = false;
+    let disposePromise;
+    let retired = false;
+    let retirePromise;
+    // Requests that entered `fetch` but have not yet reached the executor
+    // (they wait on admission or the host sign-in). Retirement waits for them
+    // so the executor admits them before it stops admitting; disposal waits
+    // for them so none resumes after it reports done.
+    const entering = new Set();
+    async function intercept(input, init) {
+        await context.assertAdmission?.();
+        // Disposal may have begun during the admission read; nothing more is
+        // read or sent for this request.
+        if (disposed)
+            throw new Error('The local request runtime is disposed');
+        if (accountSource.kind === 'pool-file') {
+            const latestAuth = await getAuth();
+            if (disposed)
+                throw new Error('The local request runtime is disposed');
+            if (!isOAuthAuth(latestAuth))
+                return upstreamFetch(input, init);
         }
+        return executor.execute(input, init);
     }
     async function fetch(input, init) {
         if (disposed) {
@@ -201,1204 +196,85 @@ export function createFetchInterceptor(context) {
         if (!isGenerativeLanguageRequest(input)) {
             return upstreamFetch(input, init);
         }
-        const latestAuth = await getAuth();
-        if (!isOAuthAuth(latestAuth)) {
-            return upstreamFetch(input, init);
-        }
-        // Normalize Request/URL inputs to (urlString, init) so the string-based
-        // transform pipeline sees the real method/headers/body. Without this,
-        // fetch(new Request(...)) would carry its payload on the Request object
-        // where our string path can't read it.
-        if (typeof input !== 'string') {
-            if (input instanceof Request) {
-                const req = input;
-                const headers = new Headers(req.headers);
-                if (init?.headers) {
-                    new Headers(init.headers).forEach((v, k) => {
-                        headers.set(k, v);
-                    });
-                }
-                const bodyBuffer = req.body
-                    ? await req.clone().arrayBuffer()
-                    : undefined;
-                init = {
-                    method: init?.method ?? req.method,
-                    headers,
-                    body: init?.body ?? (bodyBuffer ? Buffer.from(bodyBuffer) : undefined),
-                    signal: init?.signal ?? req.signal,
-                };
-                input = req.url;
-            }
-            else {
-                input = String(input.href ?? input);
-            }
-        }
-        const localImageTitle = getImageModelLocalTitle(input, init);
-        if (localImageTitle !== undefined) {
-            return createSyntheticTextResponse(localImageTitle, {
-                'X-Antigravity-Response-Type': 'local_title',
-            });
-        }
-        const requestSessionIdentity = extractOpenCodeSessionIdentity(init?.headers);
-        const agyRequestScope = agySessionRegistry.beginRequest(requestSessionIdentity);
-        const agyRequestSession = agyRequestScope.session;
-        const accountSessionIdentity = requestSessionIdentity.sessionId
-            ? {
-                id: requestSessionIdentity.sessionId,
-                parentId: requestSessionIdentity.parentSessionId,
-            }
-            : undefined;
-        const isChildRequest = requestSessionIdentity.parentSessionId !== null;
-        if (accountManager.getAccountCount() === 0) {
-            // Surface a real 401 with the Google error envelope instead of a
-            // 200 SSE body — OpenCode's HTTP layer treats 200 as success and
-            // would otherwise swallow the misconfiguration silently.
-            const urlString = typeof input === 'string' ? input : toUrlString(input);
-            const modelFromUrl = extractModelFromUrl(urlString) ?? 'unknown';
-            return createNoAccountResponse('No Antigravity accounts configured. Run `opencode auth login`.', modelFromUrl);
-        }
-        const urlString = toUrlString(input);
-        const family = getModelFamilyFromUrl(urlString);
-        const model = extractModelFromUrl(urlString);
-        const debugLines = [];
-        const pushDebug = (line) => {
-            if (!isDebugEnabled())
-                return;
-            debugLines.push(line);
-        };
-        pushDebug(`request=${urlString}`);
-        if (requestSessionIdentity.sessionId) {
-            pushDebug(`[Session] id=${requestSessionIdentity.sessionId}` +
-                ` parent=${requestSessionIdentity.parentSessionId ?? 'none'}` +
-                ` child=${isChildRequest}`);
-        }
-        const cachedStats = getLastCacheStats();
-        if (cachedStats) {
-            const label = cachedStats.hitRate > 0 ? 'HIT' : 'MISS';
-            pushDebug(`[Cache] ${label} model=${cachedStats.model} read=${cachedStats.read} total=${cachedStats.total} hitRate=${cachedStats.hitRate}%`);
-        }
-        let lastFailure = null;
-        let lastError = null;
-        const abortSignal = init?.signal ?? undefined;
-        const checkAborted = () => {
-            if (abortSignal?.aborted) {
-                throw abortSignal.reason instanceof Error
-                    ? abortSignal.reason
-                    : new Error('Aborted');
-            }
-        };
-        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,
-                variant,
-                isChildSession: isChildRequest,
-                toastScope,
-            });
-            if (quietMode)
-                return;
-            if (abortSignal?.aborted)
-                return;
-            if (toastScope === 'root_only' && isChildRequest) {
-                log.debug('toast-suppressed-child-session', {
-                    message,
-                    variant,
-                    parentID: requestSessionIdentity.parentSessionId,
-                });
-                return;
-            }
-            if (variant === 'warning' && message.toLowerCase().includes('rate')) {
-                if (!retryState.shouldShowRateLimitToast(message)) {
-                    return;
-                }
-            }
-            try {
-                await client.tui.showToast({ body: { message, variant } });
-            }
-            catch {
-                // 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;
-        let needsCacheWarmup = false;
-        while (true) {
-            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
-                // hang or a synthetic 200.
-                return createNoAccountResponse('No Antigravity accounts available. Run `opencode auth login`.', model ?? 'unknown');
-            }
-            const softQuotaCacheTtlMs = computeSoftQuotaCacheTtlMs(config.soft_quota_cache_ttl_minutes, config.quota_refresh_interval_minutes);
-            // Operator killswitch — drop candidates whose freshest cached
-            // quota remaining-percent is below the configured floor. Fail
-            // open on missing/stale quota so a cold start cannot deadlock
-            // the pipeline. The evaluation is model-aware: a `gemini-pro`
-            // request checks ONLY the `gemini-pro` quota group, not the max
-            // of pro+flash.
-            const operatorKillswitch = operatorSettings?.get().killswitch;
-            const eligibleIndexes = operatorKillswitch?.enabled
-                ? new Set(accountManager
-                    .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 });
-                    return decision.allowed;
-                })
-                    .map((entry) => entry.index))
-                : null;
-            if (eligibleIndexes !== null &&
-                eligibleIndexes.size === 0 &&
-                accountCount > 0) {
-                try {
-                    throwIfAllKilled({
-                        family,
-                        model: model ?? 'unknown',
-                        accounts: accountManager.getAccounts(),
-                        settings: {
-                            routing: { cli_first: false, quota_style_fallback: false },
-                            killswitch: operatorKillswitch ?? {
-                                enabled: false,
-                                minimum_remaining_percent: 0,
-                            },
-                            log_level: 'info',
-                        },
-                        quotaModel: model,
-                    });
-                }
-                catch (error) {
-                    if (error instanceof AntigravityKillswitchError) {
-                        log.warn('killswitch-all-excluded', {
-                            family,
-                            model,
-                            threshold: error.thresholdPercent,
-                            summaries: error.summaries,
-                        });
-                        return createSyntheticErrorResponse(error.message, model ?? 'unknown');
-                    }
-                    throw error;
-                }
-            }
-            // Feed the killswitch verdict INTO selection: every index the
-            // precomputed eligible set rules out is excluded at the source,
-            // so a killed current account falls through to the next eligible
-            // account instead of collapsing the request into the rate-limit
-            // wait path below. The precomputed set is the source of truth —
-            // selection never re-evaluates quota, so a long-running request
-            // cannot see a different answer than the pre-filter above.
-            const killedIndexes = eligibleIndexes === null
-                ? undefined
-                : new Set(accountManager
-                    .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);
-            // Belt-and-suspenders re-check on the chosen candidate against
-            // the precomputed eligible set (selection already excluded the
-            // killed indexes; this guards the fallback paths below).
-            if (account &&
-                eligibleIndexes !== null &&
-                !eligibleIndexes.has(account.index)) {
-                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 fallback path also has to clear the killswitch — a
-                // previous pre-filter scoped to the preferred-header accounts
-                // may have allowed an account only on the fallback header.
-                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;
-                    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');
-                        return createSyntheticErrorResponse(`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.`, model ?? 'unknown');
-                    }
-                    pushDebug(`all-over-soft-quota family=${family} accounts=${accountCount} waitMs=${softQuotaWaitMs}`);
-                    if (!retryState.softQuotaToastShown()) {
-                        await showToast(`All ${accountCount} account(s) over ${threshold}% quota. Waiting ${formatWaitTime(softQuotaWaitMs)}...`, 'warning');
-                        retryState.markSoftQuotaToastShown();
-                    }
-                    await sleep(softQuotaWaitMs, abortSignal);
-                    continue;
-                }
-                const strictWait = !allowQuotaFallback;
-                const waitMs = accountManager.getMinWaitTimeForFamily(family, model, preferredHeaderStyle, strictWait) || 60_000;
-                pushDebug(`all-rate-limited family=${family} accounts=${accountCount} waitMs=${waitMs}`);
-                if (isDebugEnabled()) {
-                    logAccountContext('All accounts rate-limited', {
-                        index: -1,
-                        family,
-                        totalAccounts: accountCount,
-                    });
-                    logRateLimitSnapshot(family, accountManager.getAccountsSnapshot());
-                }
-                const maxWaitMs = (config.max_rate_limit_wait_seconds ?? 300) * 1000;
-                if (maxWaitMs > 0 && waitMs > maxWaitMs) {
-                    const waitTimeFormatted = formatWaitTime(waitMs);
-                    await showToast(`Rate limited for ${waitTimeFormatted}. Try again later or add another account.`, 'error');
-                    return createSyntheticErrorResponse(`All ${accountCount} account(s) rate-limited for ${family}. ` +
-                        `Quota resets in ${waitTimeFormatted}. ` +
-                        `Add more accounts with \`opencode auth login\` or wait and retry.`, model ?? 'unknown');
-                }
-                if (!retryState.rateLimitToastShown()) {
-                    const waitSecValue = Math.max(1, Math.ceil(waitMs / 1000));
-                    await showToast(`All ${accountCount} account(s) rate-limited for ${family}. Waiting ${waitSecValue}s...`, 'warning');
-                    retryState.markRateLimitToastShown();
-                }
-                await sleep(waitMs, abortSignal);
-                continue;
-            }
-            // Account is available - reset the toast flag
-            retryState.resetAllAccountsBlockedToasts();
-            pushDebug(`selected idx=${account.index} email=${account.email ?? ''} family=${family} accounts=${accountCount} strategy=${config.account_selection_strategy}`);
-            if (previousAccountIndex >= 0 && previousAccountIndex !== account.index) {
-                needsCacheWarmup = config.cache_warmup_on_switch;
-                pushDebug(`account-switch: ${previousAccountIndex} → ${account.index}, warmup=${needsCacheWarmup}`);
-            }
-            previousAccountIndex = account.index;
-            accountManager.recordSessionUsage(account.index, accountSessionIdentity);
-            if (isDebugEnabled()) {
-                logAccountContext('Selected', {
-                    index: account.index,
-                    email: account.email,
-                    family,
-                    totalAccounts: accountCount,
-                    rateLimitState: account.rateLimitResetTimes,
-                });
-            }
-            if (accountCount > 1 &&
-                accountManager.shouldShowAccountToast(account.index)) {
-                const accountLabel = account.email || `Account ${account.index + 1}`;
-                const enabledAccounts = accountManager.getEnabledAccounts();
-                const enabledPosition = enabledAccounts.findIndex((a) => a.index === account.index) + 1;
-                await showToast(`Using ${accountLabel} (${enabledPosition}/${accountCount})`, 'info');
-                accountManager.markToastShown(account.index);
-            }
-            accountManager.requestSaveToDisk();
-            let authRecord = accountManager.toAuthDetails(account);
-            if (accessTokenExpired(authRecord)) {
-                try {
-                    const refreshed = await refreshAccessToken(authRecord, client, providerId);
-                    if (!refreshed) {
-                        const { failures, shouldCooldown, cooldownMs } = retryState.trackAccountFailure(account.index);
-                        getHealthTracker().recordFailure(account.index);
-                        lastError = new Error('Antigravity token refresh failed');
-                        if (shouldCooldown) {
-                            accountManager.markAccountCoolingDown(account, cooldownMs, 'auth-failure');
-                            accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
-                            pushDebug(`token-refresh-failed: cooldown ${cooldownMs}ms after ${failures} failures`);
-                        }
-                        continue;
-                    }
-                    retryState.resetAccountFailureState(account.index);
-                    accountManager.updateFromAuth(account, refreshed);
-                    authRecord = refreshed;
-                    try {
-                        await accountManager.saveToDisk();
-                    }
-                    catch (error) {
-                        log.error('Failed to persist refreshed auth', {
-                            error: String(error),
-                        });
-                    }
-                }
-                catch (error) {
-                    if (error instanceof AntigravityTokenRefreshError &&
-                        error.code === 'invalid_grant') {
-                        const removed = accountManager.removeAccount(account);
-                        if (removed) {
-                            log.warn('Removed revoked account from pool - reauthenticate via `opencode auth login`');
-                            try {
-                                await accountManager.saveToDiskReplace();
-                            }
-                            catch (persistError) {
-                                log.error('Failed to persist revoked account removal', {
-                                    error: String(persistError),
-                                });
-                            }
-                        }
-                        if (accountManager.getAccountCount() === 0) {
-                            try {
-                                await client.auth.set({
-                                    path: { id: providerId },
-                                    body: { type: 'oauth', refresh: '', access: '', expires: 0 },
-                                });
-                            }
-                            catch (storeError) {
-                                log.error('Failed to clear stored Antigravity OAuth credentials', {
-                                    error: String(storeError),
-                                });
-                            }
-                            return createNoAccountResponse('All Antigravity accounts have invalid refresh tokens. Run `opencode auth login` and reauthenticate.', model ?? 'unknown');
-                        }
-                        lastError = error;
-                        continue;
-                    }
-                    const { failures, shouldCooldown, cooldownMs } = retryState.trackAccountFailure(account.index);
-                    getHealthTracker().recordFailure(account.index);
-                    lastError = error instanceof Error ? error : new Error(String(error));
-                    if (shouldCooldown) {
-                        accountManager.markAccountCoolingDown(account, cooldownMs, 'auth-failure');
-                        accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
-                        pushDebug(`token-refresh-error: cooldown ${cooldownMs}ms after ${failures} failures`);
-                    }
-                    continue;
-                }
-            }
-            const accessToken = authRecord.access;
-            if (!accessToken) {
-                lastError = new Error('Missing access token');
-                if (accountCount <= 1) {
-                    return createSyntheticErrorResponse('Missing access token. Run `opencode auth login` to reauthenticate.', model ?? 'unknown');
-                }
-                continue;
-            }
-            let projectContext;
-            try {
-                projectContext = await ensureProjectContext(authRecord);
-                retryState.resetAccountFailureState(account.index);
-            }
-            catch (error) {
-                const { failures, shouldCooldown, cooldownMs } = retryState.trackAccountFailure(account.index);
-                getHealthTracker().recordFailure(account.index);
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (shouldCooldown) {
-                    accountManager.markAccountCoolingDown(account, cooldownMs, 'project-error');
-                    accountManager.markRateLimited(account, cooldownMs, family, 'antigravity', model);
-                    pushDebug(`project-context-error: cooldown ${cooldownMs}ms after ${failures} failures`);
-                }
-                continue;
-            }
-            if (projectContext.auth.refresh !== authRecord.refresh ||
-                projectContext.auth.access !== authRecord.access) {
-                accountManager.updateFromAuth(account, projectContext.auth);
-                authRecord = projectContext.auth;
-                try {
-                    await accountManager.saveToDisk();
-                }
-                catch (error) {
-                    log.error('Failed to persist project context', {
-                        error: String(error),
-                    });
-                }
-            }
-            const runThinkingWarmup = async (prepared, projectId) => {
-                if (!config.thinking_warmup)
-                    return;
-                if (!prepared.needsSignedThinkingWarmup || !prepared.sessionId)
-                    return;
-                if (!warmupState.trackAttempt(prepared.sessionId))
-                    return;
-                const warmupBody = buildThinkingWarmupBody(typeof prepared.init.body === 'string'
-                    ? prepared.init.body
-                    : undefined, Boolean(prepared.effectiveModel?.toLowerCase().includes('claude') &&
-                    prepared.effectiveModel?.toLowerCase().includes('thinking')));
-                if (!warmupBody)
-                    return;
-                const warmupUrl = toWarmupStreamUrl(prepared.request);
-                const warmupHeaders = new Headers(prepared.init.headers ?? {});
-                warmupHeaders.set('accept', 'text/event-stream');
-                const warmupInit = {
-                    ...prepared.init,
-                    method: prepared.init.method ?? 'POST',
-                    headers: warmupHeaders,
-                    body: warmupBody,
-                };
-                const warmupDebugContext = startAntigravityDebugRequest({
-                    originalUrl: warmupUrl,
-                    resolvedUrl: warmupUrl,
-                    method: warmupInit.method,
-                    headers: warmupHeaders,
-                    body: warmupBody,
-                    streaming: true,
-                    projectId,
-                });
-                try {
-                    pushDebug('thinking-warmup: start');
-                    const warmupResponse = prepared.headerStyle === 'antigravity'
-                        ? await transport(warmupUrl, warmupInit, {
-                            signal: abortSignal,
-                            onDebug: pushDebug,
-                        })
-                        : await upstreamFetch(warmupUrl, warmupInit);
-                    const transformed = await transformAntigravityResponse(warmupResponse, true, warmupDebugContext, prepared.requestedModel, projectId, warmupUrl, prepared.effectiveModel, prepared.sessionId);
-                    await transformed.text();
-                    warmupState.markSuccess(prepared.sessionId);
-                    pushDebug('thinking-warmup: done');
-                }
-                catch (error) {
-                    warmupState.clearWarmupAttempt(prepared.sessionId);
-                    pushDebug(`thinking-warmup: failed ${error instanceof Error ? error.message : String(error)}`);
-                }
-            };
-            const runCacheWarmupProbe = async (prepared) => {
-                if (!needsCacheWarmup)
-                    return;
-                needsCacheWarmup = false;
-                const bodyStr = typeof prepared.init.body === 'string'
-                    ? prepared.init.body
-                    : undefined;
-                if (!bodyStr)
-                    return;
-                try {
-                    pushDebug('cache-warmup-probe: start');
-                    const probeInit = {
-                        ...prepared.init,
-                        method: 'POST',
-                        body: bodyStr,
-                    };
-                    const probeResponse = prepared.headerStyle === 'antigravity'
-                        ? await transport(toUrlString(prepared.request), probeInit, {
-                            signal: abortSignal,
-                            onDebug: pushDebug,
-                        })
-                        : await upstreamFetch(toUrlString(prepared.request), probeInit);
-                    if (probeResponse.body) {
-                        const reader = probeResponse.body.getReader();
-                        await reader.read();
-                        await reader.cancel();
-                    }
-                    const status = probeResponse.status;
-                    if (status >= 400) {
-                        let errorSnippet = '';
-                        try {
-                            const errText = await probeResponse.text().catch(() => '');
-                            errorSnippet = errText.slice(0, 200);
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                        pushDebug(`cache-warmup-probe: done status=${status}${errorSnippet ? ` error=${errorSnippet}` : ''}`);
-                    }
-                    else {
-                        pushDebug(`cache-warmup-probe: done status=${status} (aborted after first chunk)`);
-                    }
-                }
-                catch (error) {
-                    pushDebug(`cache-warmup-probe: failed ${error instanceof Error ? error.message : String(error)}`);
-                }
-            };
-            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;
-                }
-            }
-            let totalCapacityRetries = 0;
-            while (!shouldSwitchAccount) {
-                let forceThinkingRecovery = false;
-                let tokenConsumed = false;
-                let capacityRetryCount = 0;
-                let lastEndpointIndex = -1;
-                for (let i = 0; i < ANTIGRAVITY_ENDPOINT_FALLBACKS.length; i++) {
-                    if (i !== lastEndpointIndex) {
-                        capacityRetryCount = 0;
-                        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;
-                    }
-                    try {
-                        const prepared = prepareAntigravityRequest(input, init, accessToken, projectContext.effectiveProjectId, currentEndpoint, headerStyle, forceThinkingRecovery, {
-                            claudeToolHardening: config.claude_tool_hardening,
-                            claudePromptAutoCaching: config.claude_prompt_auto_caching,
-                            fingerprint: account.fingerprint,
-                            agySession: agyRequestSession,
-                            agyRequestTimestamp: agyRequestScope.timestamp,
-                        });
-                        const originalUrl = toUrlString(input);
-                        const resolvedUrl = toUrlString(prepared.request);
-                        pushDebug(`endpoint=${currentEndpoint}`);
-                        pushDebug(`resolved=${resolvedUrl}`);
-                        const debugContext = startAntigravityDebugRequest({
-                            originalUrl,
-                            resolvedUrl,
-                            method: prepared.init.method,
-                            headers: prepared.init.headers,
-                            body: prepared.init.body,
-                            streaming: prepared.streaming,
-                            projectId: projectContext.effectiveProjectId,
-                        });
-                        const dumpContext = dumpGeminiRequest({
-                            originalUrl,
-                            resolvedUrl,
-                            method: prepared.init.method,
-                            headers: prepared.init.headers,
-                            body: prepared.init.body,
-                            streaming: prepared.streaming,
-                            requestedModel: prepared.requestedModel,
-                            effectiveModel: prepared.effectiveModel,
-                            sessionId: prepared.sessionId,
-                            projectId: projectContext.effectiveProjectId,
-                        });
-                        const createFailureContext = (failureResponse) => ({
-                            response: failureResponse,
-                            streaming: prepared.streaming,
-                            debugContext,
-                            requestedModel: prepared.requestedModel,
-                            projectId: prepared.projectId,
-                            endpoint: prepared.endpoint,
-                            effectiveModel: prepared.effectiveModel,
-                            sessionId: prepared.sessionId,
-                            toolDebugMissing: prepared.toolDebugMissing,
-                            toolDebugSummary: prepared.toolDebugSummary,
-                            toolDebugPayload: prepared.toolDebugPayload,
-                            dumpContext,
-                        });
-                        await runThinkingWarmup(prepared, projectContext.effectiveProjectId);
-                        await runCacheWarmupProbe(prepared);
-                        if (config.request_jitter_max_ms > 0) {
-                            const jitterMs = Math.floor(Math.random() * config.request_jitter_max_ms);
-                            if (jitterMs > 0) {
-                                await sleep(jitterMs, abortSignal);
-                            }
-                        }
-                        if (config.account_selection_strategy === 'hybrid') {
-                            tokenConsumed = getTokenTracker().consume(account.index);
-                        }
-                        pushDebug(`dispatching request via ${prepared.headerStyle} transport`);
-                        const response = prepared.headerStyle === 'antigravity'
-                            ? await transport(toUrlString(prepared.request), prepared.init, { signal: abortSignal, onDebug: pushDebug })
-                            : await upstreamFetch(prepared.request, prepared.init);
-                        apiRequestCount++;
-                        accountManager.recordRequest(account.index, family);
-                        const requestCounts = accountManager.getDailyRequestCounts(account.index);
-                        if (requestCounts) {
-                            pushDebug(`[Quota] account=${account.index} ${family}_today=${requestCounts[family]} total_${family}_today=${accountManager.getTotalDailyRequests(family)}`);
-                        }
-                        pushDebug(`status=${response.status} ${response.statusText} (api_request #${apiRequestCount})`);
-                        noteGeminiDumpResponse(dumpContext, response);
-                        // Record the final route selection so the sidebar renders the
-                        // actual account/header-style used by this request. Fire-and-
-                        // forget — the dispatch path must not wait on a state write.
-                        const sessionKey = requestSessionIdentity.sessionId;
-                        if (sessionKey) {
-                            const routingEntry = {
-                                accountId: `acct-${account.index}`,
-                                modelFamily: family,
-                                headerStyle: prepared.headerStyle,
-                                strategy: config.account_selection_strategy,
-                                updatedAt: Date.now(),
-                            };
-                            void upsertSidebarActiveRouting(sessionKey, routingEntry, {
-                                authoritative: true,
-                            }).catch((error) => {
-                                log.debug('sidebar-routing-upsert-failed', {
-                                    sessionId: sessionKey,
-                                    error: String(error),
-                                });
-                            });
-                        }
-                        if (response.status === 429 ||
-                            response.status === 503 ||
-                            response.status === 529) {
-                            if (tokenConsumed) {
-                                getTokenTracker().refund(account.index);
-                                tokenConsumed = false;
-                            }
-                            const defaultRetryMs = (config.default_retry_after_seconds ?? 60) * 1000;
-                            const _maxBackoffMs = (config.max_backoff_seconds ?? 60) * 1000;
-                            const headerRetryMs = retryAfterMsFromResponse(response, defaultRetryMs);
-                            const bodyInfo = await (async () => {
-                                try {
-                                    const text = await response.clone().text();
-                                    try {
-                                        return JSON.parse(text);
-                                    }
-                                    catch {
-                                        return null;
-                                    }
-                                }
-                                catch {
-                                    return null;
-                                }
-                            })();
-                            const reasonInfo = bodyInfo
-                                ? extractRateLimitBodyInfo(bodyInfo)
-                                : { retryDelayMs: null };
-                            const serverRetryMs = reasonInfo.retryDelayMs ?? headerRetryMs;
-                            const rateLimitReason = parseRateLimitReason(reasonInfo.reason, reasonInfo.message, response.status);
-                            if (rateLimitReason === 'MODEL_CAPACITY_EXHAUSTED' ||
-                                rateLimitReason === 'SERVER_ERROR') {
-                                totalCapacityRetries++;
-                                if (isCapacityRetryBudgetExhausted(totalCapacityRetries)) {
-                                    pushDebug(`Total capacity retries (${MAX_TOTAL_CAPACITY_RETRIES}) exhausted, switching account`);
-                                    lastFailure = createFailureContext(response);
-                                    shouldSwitchAccount = true;
-                                    break;
-                                }
-                                const baseDelayMs = 1000;
-                                const maxDelayMs = 8000;
-                                const exponentialDelay = Math.min(baseDelayMs * 2 ** capacityRetryCount, maxDelayMs);
-                                const jitter = exponentialDelay * (0.9 + Math.random() * 0.2);
-                                const waitMs = Math.round(jitter);
-                                const waitSec = Math.round(waitMs / 1000);
-                                pushDebug(`Server busy (${rateLimitReason}) on account ${account.index}, exponential backoff ${waitMs}ms (attempt ${capacityRetryCount + 1}, total ${totalCapacityRetries}/${MAX_TOTAL_CAPACITY_RETRIES})`);
-                                await showToast(`⏳ Server busy (${response.status}). Retrying in ${waitSec}s...`, 'warning');
-                                await sleep(waitMs, abortSignal);
-                                if (capacityRetryCount < 1) {
-                                    capacityRetryCount++;
-                                    i -= 1;
-                                    continue;
-                                }
-                                else {
-                                    pushDebug(`Max capacity retries (1) exhausted for endpoint ${currentEndpoint}, regenerating fingerprint...`);
-                                    const newFingerprint = accountManager.regenerateAccountFingerprint(account.index);
-                                    if (newFingerprint) {
-                                        pushDebug(`Fingerprint regenerated for account ${account.index}`);
-                                    }
-                                    continue;
-                                }
-                            }
-                            const quotaKey = retryState.headerStyleToQuotaKey(headerStyle, family);
-                            const backoff = retryState.getRateLimitBackoff(account.index, quotaKey, serverRetryMs);
-                            const smartBackoffMs = calculateBackoffMs(rateLimitReason, account.consecutiveFailures ?? 0, serverRetryMs);
-                            const effectiveDelayMs = Math.max(backoff.delayMs, smartBackoffMs);
-                            pushDebug(`429 idx=${account.index} email=${account.email ?? ''} family=${family} delayMs=${effectiveDelayMs} attempt=${backoff.attempt} reason=${rateLimitReason}`);
-                            if (reasonInfo.message)
-                                pushDebug(`429 message=${reasonInfo.message}`);
-                            if (reasonInfo.quotaResetTime)
-                                pushDebug(`429 quotaResetTime=${reasonInfo.quotaResetTime}`);
-                            if (reasonInfo.reason)
-                                pushDebug(`429 reason=${reasonInfo.reason}`);
-                            logRateLimitEvent(account.index, account.email, family, response.status, effectiveDelayMs, reasonInfo);
-                            await logResponseBody(debugContext, response, 429);
-                            getHealthTracker().recordRateLimit(account.index);
-                            const _accountLabel = account.email || `Account ${account.index + 1}`;
-                            if (backoff.attempt === 1 &&
-                                rateLimitReason !== 'QUOTA_EXHAUSTED') {
-                                await showToast(`Rate limited. Quick retry in 1s...`, 'warning');
-                                await sleep(FIRST_RETRY_DELAY_MS, abortSignal);
-                                if (config.scheduling_mode === 'cache_first') {
-                                    const maxCacheFirstWaitMs = config.max_cache_first_wait_seconds * 1000;
-                                    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);
-                                        await sleep(effectiveDelayMs, abortSignal);
-                                        i -= 1;
-                                        continue;
-                                    }
-                                    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);
-                                    shouldSwitchAccount = true;
-                                    break;
-                                }
-                                i -= 1;
-                                continue;
-                            }
-                            accountManager.markRateLimitedWithReason(account, family, headerStyle, 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})`
-                                    : ``;
-                                await showToast(`Rate limited again. Switching account in ${formatWaitTime(switchAccountDelayMs)}...${quotaMsg}`, 'warning');
-                                await sleep(switchAccountDelayMs, abortSignal);
-                            }
-                            else {
-                                const expBackoffMs = Math.min(FIRST_RETRY_DELAY_MS * 2 ** (backoff.attempt - 1), 60000);
-                                const expBackoffFormatted = expBackoffMs >= 1000
-                                    ? `${Math.round(expBackoffMs / 1000)}s`
-                                    : `${expBackoffMs}ms`;
-                                await showToast(`Rate limited. Retrying in ${expBackoffFormatted} (attempt ${backoff.attempt})...`, 'warning');
-                                await sleep(expBackoffMs, abortSignal);
-                            }
-                            lastFailure = createFailureContext(response);
-                            shouldSwitchAccount = true;
-                            break;
-                        }
-                        const quotaKey = retryState.headerStyleToQuotaKey(headerStyle, family);
-                        retryState.resetRateLimitState(account.index, quotaKey);
-                        retryState.resetAccountFailureState(account.index);
-                        if (response.status === 403) {
-                            const errorBodyText = await response
-                                .clone()
-                                .text()
-                                .catch(() => '');
-                            const extracted = extractAccountAccessErrorDetails(errorBodyText);
-                            if (extracted.accountIneligible) {
-                                const ineligibleReason = extracted.message ??
-                                    'Google marked this account as ineligible for Antigravity.';
-                                accountManager.markAccountIneligible(account.index, ineligibleReason);
-                                const label = account.email || `Account ${account.index + 1}`;
-                                if (accountManager.shouldShowAccountToast(account.index, 60000)) {
-                                    await showToast(`${label} is not eligible for Antigravity and has been disabled. ` +
-                                        'Recheck it from opencode auth login > Verify accounts.', 'warning');
-                                    accountManager.markToastShown(account.index);
-                                }
-                                pushDebug(`account-ineligible: disabled account ${account.index}`);
-                                getHealthTracker().recordFailure(account.index);
-                                lastFailure = createFailureContext(response);
-                                shouldSwitchAccount = true;
-                                break;
-                            }
-                            if (extracted.validationRequired) {
-                                const verificationReason = extracted.message ?? 'Google requires account verification.';
-                                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);
-                                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');
-                                    accountManager.markToastShown(account.index);
-                                }
-                                pushDebug(`verification-required: disabled account ${account.index}`);
-                                getHealthTracker().recordFailure(account.index);
-                                lastFailure = createFailureContext(response);
-                                shouldSwitchAccount = true;
-                                break;
-                            }
-                        }
-                        const shouldRetryEndpoint = response.status === 403 ||
-                            response.status === 404 ||
-                            response.status >= 500;
-                        if (shouldRetryEndpoint &&
-                            i < ANTIGRAVITY_ENDPOINT_FALLBACKS.length - 1) {
-                            await logResponseBody(debugContext, response, response.status);
-                            lastFailure = createFailureContext(response);
-                            continue;
-                        }
-                        if (response.ok) {
-                            account.consecutiveFailures = 0;
-                            getHealthTracker().recordSuccess(account.index);
-                            accountManager.markAccountUsed(account.index);
-                            void triggerAsyncQuotaRefreshForAccount(account.index, config.quota_refresh_interval_minutes);
-                            const proactiveThreshold = config.proactive_rotation_threshold_percent ?? 20;
-                            if (proactiveThreshold > 0 &&
-                                accountManager.shouldProactivelyRotate(family, model, proactiveThreshold, softQuotaCacheTtlMs, accountSessionIdentity)) {
-                                const rotated = accountManager.proactivelyRotateForFamily(family, model, headerStyle, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity);
-                                if (rotated) {
-                                    const remaining = account.cachedQuota?.[resolveQuotaGroup(family, model)]
-                                        ?.remainingFraction;
-                                    const remainingPct = remaining != null ? `${(remaining * 100).toFixed(1)}%` : '?';
-                                    pushDebug(`[ProactiveRotation] account ${account.index} quota ${remainingPct} < ${proactiveThreshold}%, pre-switched to account ${rotated.index} for next request`);
-                                    pushDebug(`[ProactiveRotation] ${account.index} → ${rotated.index}` +
-                                        ` (warm=${accountManager.wasUsedInSession(rotated.index, accountSessionIdentity)})`);
-                                }
-                            }
-                        }
-                        logAntigravityDebugResponse(debugContext, response, {
-                            note: response.ok ? 'Success' : `Error ${response.status}`,
-                        });
-                        if (response.ok && !prepared.streaming) {
-                            await logResponseBody(debugContext, response, response.status);
-                        }
-                        if (!response.ok) {
-                            await logResponseBody(debugContext, response, response.status);
-                            if (response.status === 400) {
-                                const cloned = response.clone();
-                                const bodyText = await cloned.text();
-                                if (bodyText.includes('Prompt is too long') ||
-                                    bodyText.includes('prompt_too_long')) {
-                                    await showToast('Context too long - use /compact to reduce size', 'warning');
-                                    const errorMessage = `[Antigravity Error] Context is too long for this model.\n\nPlease use /compact to reduce context size, then retry your request.\n\nAlternatively, you can:\n- Use /clear to start fresh\n- Use /undo to remove recent messages\n- Switch to a model with larger context window`;
-                                    return createSyntheticErrorResponse(errorMessage, prepared.requestedModel);
-                                }
-                            }
-                        }
-                        if (response.ok && !prepared.streaming) {
-                            const maxAttempts = config.empty_response_max_attempts ?? 4;
-                            const retryDelayMs = config.empty_response_retry_delay_ms ?? 2000;
-                            const clonedForCheck = response.clone();
-                            const bodyText = await clonedForCheck.text();
-                            if (isEmptyResponseBody(bodyText)) {
-                                const emptyAttemptKey = `${prepared.sessionId ?? 'none'}:${prepared.effectiveModel ?? 'unknown'}`;
-                                const currentAttempts = retryState.recordEmptyResponseAttempt(emptyAttemptKey);
-                                pushDebug(`empty-response: attempt ${currentAttempts}/${maxAttempts}`);
-                                if (currentAttempts < maxAttempts) {
-                                    await showToast(`Empty response received. Retrying (${currentAttempts}/${maxAttempts})...`, 'warning');
-                                    await sleep(retryDelayMs, abortSignal);
-                                    continue;
-                                }
-                                retryState.clearEmptyResponseAttempts();
-                                return createSyntheticErrorResponse(`Empty response after ${currentAttempts} attempts for model ${prepared.effectiveModel ?? 'unknown'}.`, prepared.effectiveModel ?? 'unknown');
-                            }
-                            const _emptyAttemptKeyClean = `${prepared.sessionId ?? 'none'}:${prepared.effectiveModel ?? 'unknown'}`;
-                            retryState.clearEmptyResponseAttempts();
-                        }
-                        const transformedResponse = await transformAntigravityResponse(response, prepared.streaming, debugContext, prepared.requestedModel, prepared.projectId, prepared.endpoint, prepared.effectiveModel, prepared.sessionId, prepared.toolDebugMissing, prepared.toolDebugSummary, prepared.toolDebugPayload, debugLines, dumpContext);
-                        const contextError = transformedResponse.headers.get('x-antigravity-context-error');
-                        if (contextError) {
-                            if (contextError === 'prompt_too_long') {
-                                await showToast('Context too long - use /compact to reduce size, or trim your request', 'warning');
-                            }
-                            else if (contextError === 'tool_pairing') {
-                                await showToast('Tool call/result mismatch - use /compact to fix, or /undo last message', 'warning');
-                            }
-                        }
-                        if (apiRequestCount > 1) {
-                            pushDebug(`[Quota] Total API requests for this user message: ${apiRequestCount} (${apiRequestCount - 1} retries)`);
-                        }
-                        const dailyCounts = accountManager.getDailyRequestCounts(account.index);
-                        if (dailyCounts) {
-                            pushDebug(`[Quota] Account ${account.index} (${account.email ?? 'unknown'}) today: claude=${dailyCounts.claude} gemini=${dailyCounts.gemini}`);
-                        }
-                        const totalToday = accountManager.getTotalDailyRequests(family);
-                        pushDebug(`[Quota] Total ${family} requests today (all accounts): ${totalToday}`);
-                        const cachedQuota = account.cachedQuota;
-                        if (cachedQuota) {
-                            const quotaFamily = resolveQuotaGroup(family, model);
-                            const groupQuota = cachedQuota[quotaFamily];
-                            if (groupQuota?.remainingFraction != null) {
-                                const pct = Math.round(groupQuota.remainingFraction * 100);
-                                pushDebug(`[Quota] Account ${account.index} cached ${quotaFamily} remaining: ${pct}%${groupQuota.resetTime ? ` (resets ${groupQuota.resetTime})` : ''}`);
-                            }
-                        }
-                        const sessionSummary = accountManager.getSessionSummary();
-                        if (sessionSummary.durationMinutes >= 1) {
-                            const familyTotal = family === 'claude'
-                                ? sessionSummary.totalClaude
-                                : sessionSummary.totalGemini;
-                            if (familyTotal > 0) {
-                                const ratePerHour = sessionSummary.requestsPerHour;
-                                pushDebug(`[Quota] Session: ${sessionSummary.durationMinutes}min, ${familyTotal} ${family} reqs, ~${ratePerHour} reqs/hr, ${sessionSummary.accountsUsed} accounts used`);
-                            }
-                        }
-                        return transformedResponse;
-                    }
-                    catch (error) {
-                        if (tokenConsumed) {
-                            getTokenTracker().refund(account.index);
-                            tokenConsumed = false;
-                        }
-                        if (error instanceof Error &&
-                            error.message === 'THINKING_RECOVERY_NEEDED') {
-                            if (!forceThinkingRecovery) {
-                                pushDebug('thinking-recovery: API error detected, retrying with forced recovery');
-                                forceThinkingRecovery = true;
-                                i = -1;
-                                continue;
-                            }
-                            const recoveryError = error;
-                            const originalError = recoveryError.originalError || {
-                                error: { message: 'Thinking recovery triggered' },
-                            };
-                            const recoveryMessage = `${originalError.error?.message || 'Session recovery failed'}\n\n[RECOVERY] Thinking block corruption could not be resolved. Try starting a new session.`;
-                            return new Response(JSON.stringify({
-                                type: 'error',
-                                error: {
-                                    type: 'unrecoverable_error',
-                                    message: recoveryMessage,
-                                },
-                            }), {
-                                status: 400,
-                                headers: { 'Content-Type': 'application/json' },
-                            });
-                        }
-                        if (i < ANTIGRAVITY_ENDPOINT_FALLBACKS.length - 1) {
-                            lastError =
-                                error instanceof Error ? error : new Error(String(error));
-                            continue;
-                        }
-                        const { failures, shouldCooldown, cooldownMs } = retryState.trackAccountFailure(account.index);
-                        lastError =
-                            error instanceof Error ? error : new Error(String(error));
-                        if (shouldCooldown) {
-                            accountManager.markAccountCoolingDown(account, cooldownMs, 'network-error');
-                            accountManager.markRateLimited(account, cooldownMs, family, headerStyle, model);
-                            pushDebug(`endpoint-error: cooldown ${cooldownMs}ms after ${failures} failures`);
-                        }
-                        shouldSwitchAccount = true;
-                        break;
-                    }
-                }
-            }
-            if (shouldSwitchAccount) {
-                accountSwitchCount++;
-                if (accountSwitchCount > maxAccountSwitches) {
-                    pushDebug(`account-switch-cap: exceeded max_account_switches=${maxAccountSwitches}, giving up`);
-                    if (lastFailure) {
-                        return transformAntigravityResponse(lastFailure.response, lastFailure.streaming, lastFailure.debugContext, lastFailure.requestedModel, lastFailure.projectId, lastFailure.endpoint, lastFailure.effectiveModel, lastFailure.sessionId, lastFailure.toolDebugMissing, lastFailure.toolDebugSummary, lastFailure.toolDebugPayload, debugLines, lastFailure.dumpContext);
-                    }
-                    throw terminalFetchError(lastError, `Exceeded max account switches (${maxAccountSwitches}). All accounts rate-limited.`);
-                }
-                if (accountCount <= 1) {
-                    if (lastFailure) {
-                        return transformAntigravityResponse(lastFailure.response, lastFailure.streaming, lastFailure.debugContext, lastFailure.requestedModel, lastFailure.projectId, lastFailure.endpoint, lastFailure.effectiveModel, lastFailure.sessionId, lastFailure.toolDebugMissing, lastFailure.toolDebugSummary, lastFailure.toolDebugPayload, debugLines, lastFailure.dumpContext);
-                    }
-                    throw terminalFetchError(lastError, 'All Antigravity endpoints failed');
-                }
-                continue;
-            }
-            if (lastFailure) {
-                return transformAntigravityResponse(lastFailure.response, lastFailure.streaming, lastFailure.debugContext, lastFailure.requestedModel, lastFailure.projectId, lastFailure.endpoint, lastFailure.effectiveModel, lastFailure.sessionId, lastFailure.toolDebugMissing, lastFailure.toolDebugSummary, lastFailure.toolDebugPayload, debugLines, lastFailure.dumpContext);
-            }
-            throw terminalFetchError(lastError, 'All Antigravity accounts failed');
-        }
+        // A retired interceptor has been replaced; a request reaching it now is
+        // refused rather than sent without this plugin's credentials.
+        if (retired)
+            throw new Error('The local request runtime is retired');
+        const pending = intercept(input, init);
+        entering.add(pending);
+        void pending.then(() => entering.delete(pending), () => entering.delete(pending));
+        return pending;
+    }
+    function retire() {
+        retired = true;
+        retirePromise ??= (async () => {
+            while (entering.size > 0)
+                await Promise.allSettled([...entering]);
+            await executor.retire();
+        })();
+        return retirePromise;
     }
     function dispose() {
-        if (disposed)
-            return;
         disposed = true;
-        retryState.dispose();
-        warmupState.dispose();
+        disposePromise ??= (async () => {
+            await executor.dispose();
+            // Requests still reading their admission or the host sign-in stop at
+            // their next check; disposal reports done only once they have.
+            while (entering.size > 0)
+                await Promise.allSettled([...entering]);
+            // A retirement still waiting on those requests settles with them.
+            await retirePromise;
+        })();
+        return disposePromise;
     }
-    return { fetch, dispose };
+    return { fetch, retire, dispose };
 }
-function extractRateLimitBodyInfo(body) {
-    if (!body || typeof body !== 'object')
-        return { retryDelayMs: null };
-    const error = body.error;
-    const message = error && typeof error === 'object'
-        ? error.message
-        : undefined;
-    const details = error && typeof error === 'object'
-        ? error.details
-        : undefined;
-    let reason;
-    if (Array.isArray(details)) {
-        for (const detail of details) {
-            if (!detail || typeof detail !== 'object')
-                continue;
-            const type = detail['@type'];
-            if (typeof type === 'string' && type.includes('google.rpc.ErrorInfo')) {
-                const detailReason = detail.reason;
-                if (typeof detailReason === 'string') {
-                    reason = detailReason;
-                    break;
-                }
-            }
-        }
-        for (const detail of details) {
-            if (!detail || typeof detail !== 'object')
-                continue;
-            const type = detail['@type'];
-            if (typeof type === 'string' && type.includes('google.rpc.RetryInfo')) {
-                const retryDelay = detail.retryDelay;
-                if (typeof retryDelay === 'string') {
-                    const retryDelayMs = parseDurationToMs(retryDelay);
-                    if (retryDelayMs !== null) {
-                        return { retryDelayMs, message, reason };
-                    }
-                }
-            }
-        }
-        for (const detail of details) {
-            if (!detail || typeof detail !== 'object')
-                continue;
-            const metadata = detail
-                .metadata;
-            if (metadata && typeof metadata === 'object') {
-                const quotaResetDelay = metadata.quotaResetDelay;
-                const quotaResetTime = metadata.quotaResetTimeStamp;
-                if (typeof quotaResetDelay === 'string') {
-                    const quotaResetDelayMs = parseDurationToMs(quotaResetDelay);
-                    if (quotaResetDelayMs !== null) {
-                        return {
-                            retryDelayMs: quotaResetDelayMs,
-                            message,
-                            quotaResetTime,
-                            reason,
-                        };
-                    }
-                }
-            }
-        }
-    }
-    if (message) {
-        const afterMatch = message.match(/reset after\s+([0-9hms.]+)/i);
-        const rawDuration = afterMatch?.[1];
-        if (rawDuration) {
-            const parsed = parseDurationToMs(rawDuration);
-            if (parsed !== null) {
-                return { retryDelayMs: parsed, message, reason };
-            }
-        }
-    }
-    return { retryDelayMs: null, message, reason };
-}
-function parseDurationToMs(duration) {
-    const simpleMatch = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
-    if (simpleMatch) {
-        const value = parseFloat(simpleMatch[1]);
-        const unit = (simpleMatch[2] || 's').toLowerCase();
-        switch (unit) {
-            case 'h':
-                return value * 3600 * 1000;
-            case 'm':
-                return value * 60 * 1000;
-            case 's':
-                return value * 1000;
-            case 'ms':
-                return value;
-            default:
-                return value * 1000;
-        }
+/**
+ * OpenCode 1 binding of the shared request engine for vault-held accounts.
+ * Selection runs on an `AccountSelector` over the vault's selectable routes
+ * (metadata rows, no credential). Every physical send takes a fresh receipt
+ * for the selected route through `createVaultRequestCredentials`: its token
+ * and project serve that one send, and a 401 is reported against it.
+ * Nothing is refreshed locally, cached or copied from the host's own Google
+ * sign-in, which is why no host auth is read here.
+ */
+export function createVaultFetchInterceptor(context) {
+    const { source, agyTransport = defaultAgyTransport, fetchImpl = defaultFetchImpl, } = context;
+    const upstreamFetch = fetchImpl;
+    const pool = context.pool ?? createVaultAccountPool({ source });
+    const selector = pool.selector;
+    const executor = createRequestExecutor({
+        assertAdmission: context.assertAdmission,
+        ...openCode1EngineCollaborators({
+            ...context,
+            transport: agyTransport,
+            fetchImpl: upstreamFetch,
+        }),
+        accounts: selector,
+        credentials: pool.credentials,
+        trackers: {
+            health: selector.healthTracker,
+            token: selector.tokenTracker,
+        },
+    });
+    let disposed = false;
+    let disposePromise;
+    async function fetch(input, init) {
+        if (!isGenerativeLanguageRequest(input))
+            return upstreamFetch(input, init);
+        if (disposed)
+            throw new Error('The vault request runtime is disposed');
+        await pool.sync();
+        return executor.execute(input, init);
     }
-    const compoundRegex = /(\d+(?:\.\d+)?)(h|m(?!s)|s|ms)/gi;
-    let totalMs = 0;
-    let matchFound = false;
-    let match = null;
-    while (true) {
-        match = compoundRegex.exec(duration);
-        if (match === null)
-            break;
-        matchFound = true;
-        const value = parseFloat(match[1]);
-        const unit = match[2]?.toLowerCase();
-        switch (unit) {
-            case 'h':
-                totalMs += value * 3600 * 1000;
-                break;
-            case 'm':
-                totalMs += value * 60 * 1000;
-                break;
-            case 's':
-                totalMs += value * 1000;
-                break;
-            case 'ms':
-                totalMs += value;
-                break;
-        }
+    function dispose() {
+        disposed = true;
+        disposePromise ??= (async () => {
+            await executor.dispose();
+            await pool.flush();
+        })();
+        return disposePromise;
     }
-    return matchFound ? totalMs : null;
+    return { fetch, dispose };
 }
 //# sourceMappingURL=fetch-interceptor.js.map