opencode-antigravity-auth 1.3.1 → 1.3.2-beta.0

package/dist/src/plugin.js

@@ -1,4 +1,5 @@
 import { exec } from "node:child_process";
+import { tool } from "@opencode-ai/plugin";
 import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_PROVIDER_ID } from "./constants";
 import { authorizeAntigravity, exchangeAntigravity } from "./antigravity/oauth";
 import { accessTokenExpired, isOAuthAuth, parseRefreshParts } from "./plugin/auth";
@@ -20,6 +21,7 @@ import { initDiskSignatureCache } from "./plugin/cache";
 import { createProactiveRefreshQueue } from "./plugin/refresh-queue";
 import { initLogger, createLogger } from "./plugin/logger";
 import { initHealthTracker, getHealthTracker, initTokenTracker, getTokenTracker } from "./plugin/rotation";
+import { executeSearch } from "./plugin/search";
 const MAX_OAUTH_ACCOUNTS = 10;
 const MAX_WARMUP_SESSIONS = 1000;
 const MAX_WARMUP_RETRIES = 2;
@@ -283,7 +285,7 @@ async function persistAccountPool(results, replaceAll = false) {
         },
     });
 }
-function retryAfterMsFromResponse(response) {
+function retryAfterMsFromResponse(response, defaultRetryMs = 60_000) {
     const retryAfterMsHeader = response.headers.get("retry-after-ms");
     if (retryAfterMsHeader) {
         const parsed = Number.parseInt(retryAfterMsHeader, 10);
@@ -298,20 +300,54 @@ function retryAfterMsFromResponse(response) {
             return parsed * 1000;
         }
     }
-    return 60_000;
+    return defaultRetryMs;
 }
+/**
+ * Parse Go-style duration strings to milliseconds.
+ * Supports compound durations: "1h16m0.667s", "1.5s", "200ms", "5m30s"
+ *
+ * @param duration - Duration string in Go format
+ * @returns Duration in milliseconds, or null if parsing fails
+ */
 function parseDurationToMs(duration) {
-    const match = duration.match(/^(\d+(?:\.\d+)?)(s|m|h)?$/i);
-    if (!match)
-        return null;
-    const value = parseFloat(match[1]);
-    const unit = (match[2] || "s").toLowerCase();
-    switch (unit) {
-        case "h": return value * 3600 * 1000;
-        case "m": return value * 60 * 1000;
-        case "s": return value * 1000;
-        default: return value * 1000;
+    // Handle simple formats first for backwards compatibility
+    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;
+        }
     }
+    // Parse compound Go-style durations: "1h16m0.667s", "5m30s", etc.
+    const compoundRegex = /(\d+(?:\.\d+)?)(h|m(?!s)|s|ms)/gi;
+    let totalMs = 0;
+    let matchFound = false;
+    let match;
+    while ((match = compoundRegex.exec(duration)) !== null) {
+        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;
+        }
+    }
+    return matchFound ? totalMs : null;
 }
 function extractRateLimitBodyInfo(body) {
     if (!body || typeof body !== "object") {
@@ -435,9 +471,10 @@ const emptyResponseAttempts = new Map();
  * @param accountIndex - The account index
  * @param quotaKey - The quota key (e.g., "gemini-cli", "gemini-antigravity", "claude")
  * @param serverRetryAfterMs - Server-provided retry delay (if any)
+ * @param maxBackoffMs - Maximum backoff delay in milliseconds (default 60000)
  * @returns { attempt, delayMs, isDuplicate } - isDuplicate=true if within dedup window
  */
-function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs) {
+function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs, maxBackoffMs = 60_000) {
     const now = Date.now();
     const stateKey = `${accountIndex}:${quotaKey}`;
     const previous = rateLimitStateByAccountQuota.get(stateKey);
@@ -445,7 +482,7 @@ function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs) {
     if (previous && (now - previous.lastAt < RATE_LIMIT_DEDUP_WINDOW_MS)) {
         // Same rate limit event from concurrent request - don't increment
         const baseDelay = serverRetryAfterMs ?? 1000;
-        const backoffDelay = Math.min(baseDelay * Math.pow(2, previous.consecutive429 - 1), 60_000);
+        const backoffDelay = Math.min(baseDelay * Math.pow(2, previous.consecutive429 - 1), maxBackoffMs);
         return {
             attempt: previous.consecutive429,
             delayMs: Math.max(baseDelay, backoffDelay),
@@ -462,7 +499,7 @@ function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs) {
         quotaKey
     });
     const baseDelay = serverRetryAfterMs ?? 1000;
-    const backoffDelay = Math.min(baseDelay * Math.pow(2, attempt - 1), 60_000);
+    const backoffDelay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxBackoffMs);
     return { attempt, delayMs: Math.max(baseDelay, backoffDelay), isDuplicate: false };
 }
 /**
@@ -540,6 +577,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
     // Load configuration from files and environment variables
     const config = loadConfig(directory);
     initRuntimeConfig(config);
+    // Cached getAuth function for tool access
+    let cachedGetAuth = null;
     // Initialize debug with config
     initializeDebug(config);
     // Initialize structured logger for TUI integration
@@ -616,11 +655,55 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
             }
         }
     };
+    // Create google_search tool with access to auth context
+    const googleSearchTool = tool({
+        description: "Search the web using Google Search and analyze URLs. Returns real-time information from the internet with source citations. Use this when you need up-to-date information about current events, recent developments, or any topic that may have changed. You can also provide specific URLs to analyze. IMPORTANT: If the user mentions or provides any URLs in their query, you MUST extract those URLs and pass them in the 'urls' parameter for direct analysis.",
+        args: {
+            query: tool.schema.string().describe("The search query or question to answer using web search"),
+            urls: tool.schema.array(tool.schema.string()).optional().describe("List of specific URLs to fetch and analyze. IMPORTANT: Always extract and include any URLs mentioned by the user in their query here."),
+            thinking: tool.schema.boolean().optional().default(true).describe("Enable deep thinking for more thorough analysis (default: true)"),
+        },
+        async execute(args, ctx) {
+            log.debug("Google Search tool called", { query: args.query, urlCount: args.urls?.length ?? 0 });
+            // Get current auth context
+            const auth = cachedGetAuth ? await cachedGetAuth() : null;
+            if (!auth || !isOAuthAuth(auth)) {
+                return "Error: Not authenticated with Antigravity. Please run `opencode auth login` to authenticate.";
+            }
+            // Get access token and project ID
+            const parts = parseRefreshParts(auth.refresh);
+            const projectId = parts.managedProjectId || parts.projectId || "unknown";
+            // Ensure we have a valid access token
+            let accessToken = auth.access;
+            if (!accessToken || accessTokenExpired(auth)) {
+                try {
+                    const refreshed = await refreshAccessToken(auth, client, providerId);
+                    accessToken = refreshed?.access;
+                }
+                catch (error) {
+                    return `Error: Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+            if (!accessToken) {
+                return "Error: No valid access token available. Please run `opencode auth login` to re-authenticate.";
+            }
+            return executeSearch({
+                query: args.query,
+                urls: args.urls,
+                thinking: args.thinking,
+            }, accessToken, projectId, ctx.abort);
+        },
+    });
     return {
         event: eventHandler,
+        tool: {
+            google_search: googleSearchTool,
+        },
         auth: {
             provider: providerId,
             loader: async (getAuth, provider) => {
+                // Cache getAuth for tool access
+                cachedGetAuth = getAuth;
                 const auth = await getAuth();
                 // If OpenCode has no valid OAuth auth, clear any stale account storage
                 if (!isOAuthAuth(auth)) {
@@ -704,10 +787,28 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 throw abortSignal.reason instanceof Error ? abortSignal.reason : new Error("Aborted");
                             }
                         };
-                        // Helper to show toast without blocking on abort
+                        // Use while(true) loop to handle rate limits with backoff
+                        // This ensures we wait and retry when all accounts are rate-limited
+                        const quietMode = config.quiet_mode;
+                        // Debounce rate limit toasts to avoid spam (5s cooldown per message type)
+                        const rateLimitToastCooldowns = new Map();
+                        const RATE_LIMIT_TOAST_COOLDOWN_MS = 5000;
+                        // Helper to show toast without blocking on abort (respects quiet_mode)
                         const showToast = async (message, variant) => {
+                            if (quietMode)
+                                return;
                             if (abortSignal?.aborted)
                                 return;
+                            // Debounce rate limit warnings to prevent toast spam
+                            if (variant === "warning" && message.toLowerCase().includes("rate")) {
+                                const toastKey = message.replace(/\d+/g, "X"); // Normalize numbers for grouping
+                                const lastShown = rateLimitToastCooldowns.get(toastKey) ?? 0;
+                                const now = Date.now();
+                                if (now - lastShown < RATE_LIMIT_TOAST_COOLDOWN_MS) {
+                                    return; // Skip - shown recently
+                                }
+                                rateLimitToastCooldowns.set(toastKey, now);
+                            }
                             try {
                                 await client.tui.showToast({
                                     body: { message, variant },
@@ -717,9 +818,6 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 // TUI may not be available
                             }
                         };
-                        // Use while(true) loop to handle rate limits with backoff
-                        // This ensures we wait and retry when all accounts are rate-limited
-                        const quietMode = config.quiet_mode;
                         const hasOtherAccountWithAntigravity = (currentAccount) => {
                             if (family !== "gemini")
                                 return false;
@@ -735,8 +833,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             }
                             const account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, 'antigravity', config.pid_offset_enabled);
                             if (!account) {
+                                const headerStyle = getHeaderStyleFromUrl(urlString, family);
+                                const explicitQuota = isExplicitQuotaFromUrl(urlString);
                                 // All accounts are rate-limited - wait and retry
-                                const waitMs = accountManager.getMinWaitTimeForFamily(family, model) || 60_000;
+                                const waitMs = accountManager.getMinWaitTimeForFamily(family, model, headerStyle, explicitQuota) || 60_000;
                                 const waitSecValue = Math.max(1, Math.ceil(waitMs / 1000));
                                 pushDebug(`all-rate-limited family=${family} accounts=${accountCount} waitMs=${waitMs}`);
                                 if (isDebugEnabled()) {
@@ -773,8 +873,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     rateLimitState: account.rateLimitResetTimes,
                                 });
                             }
-                            // Show toast when switching to a different account (debounced, respects quiet mode)
-                            if (!quietMode && accountCount > 1 && accountManager.shouldShowAccountToast(account.index)) {
+                            // Show toast when switching to a different account (debounced, quiet_mode handled by showToast)
+                            if (accountCount > 1 && accountManager.shouldShowAccountToast(account.index)) {
                                 const accountLabel = account.email || `Account ${account.index + 1}`;
                                 await showToast(`Using ${accountLabel} (${account.index + 1}/${accountCount})`, "info");
                                 accountManager.markToastShown(account.index);
@@ -928,6 +1028,9 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             let headerStyle = getHeaderStyleFromUrl(urlString, family);
                             const explicitQuota = isExplicitQuotaFromUrl(urlString);
                             pushDebug(`headerStyle=${headerStyle} explicit=${explicitQuota}`);
+                            if (account.fingerprint) {
+                                pushDebug(`fingerprint: quotaUser=${account.fingerprint.quotaUser} deviceId=${account.fingerprint.deviceId.slice(0, 8)}...`);
+                            }
                             // Check if this header style is rate-limited for this account
                             if (accountManager.isRateLimitedForHeaderStyle(account, family, headerStyle, model)) {
                                 // Quota fallback: try alternate quota on same account (if enabled and not explicit)
@@ -936,9 +1039,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     if (alternateStyle && alternateStyle !== headerStyle) {
                                         const quotaName = headerStyle === "gemini-cli" ? "Gemini CLI" : "Antigravity";
                                         const altQuotaName = alternateStyle === "gemini-cli" ? "Gemini CLI" : "Antigravity";
-                                        if (!quietMode) {
-                                            await showToast(`${quotaName} quota exhausted, using ${altQuotaName} quota`, "warning");
-                                        }
+                                        await showToast(`${quotaName} quota exhausted, using ${altQuotaName} quota`, "warning");
                                         headerStyle = alternateStyle;
                                         pushDebug(`quota fallback: ${headerStyle}`);
                                     }
@@ -955,15 +1056,20 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 let forceThinkingRecovery = false;
                                 // Track if token was consumed (for hybrid strategy refund on error)
                                 let tokenConsumed = false;
+                                // Track capacity retries per endpoint to prevent infinite loops
+                                let capacityRetryCount = 0;
+                                let lastEndpointIndex = -1;
                                 for (let i = 0; i < ANTIGRAVITY_ENDPOINT_FALLBACKS.length; i++) {
+                                    // Reset capacity retry counter when switching to a new endpoint
+                                    if (i !== lastEndpointIndex) {
+                                        capacityRetryCount = 0;
+                                        lastEndpointIndex = i;
+                                    }
                                     const currentEndpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i];
                                     try {
                                         const prepared = prepareAntigravityRequest(input, init, accessToken, projectContext.effectiveProjectId, currentEndpoint, headerStyle, forceThinkingRecovery, {
                                             claudeToolHardening: config.claude_tool_hardening,
-                                            googleSearch: config.web_search ? {
-                                                mode: config.web_search.default_mode,
-                                                threshold: config.web_search.grounding_threshold
-                                            } : undefined,
+                                            fingerprint: account.fingerprint,
                                         });
                                         const originalUrl = toUrlString(input);
                                         const resolvedUrl = toUrlString(prepared.request);
@@ -979,6 +1085,12 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             projectId: projectContext.effectiveProjectId,
                                         });
                                         await runThinkingWarmup(prepared, projectContext.effectiveProjectId);
+                                        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);
+                                            }
+                                        }
                                         // Consume token for hybrid strategy
                                         // Refunded later if request fails (429 or network error)
                                         if (config.account_selection_strategy === 'hybrid') {
@@ -986,22 +1098,62 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         }
                                         const response = await fetch(prepared.request, prepared.init);
                                         pushDebug(`status=${response.status} ${response.statusText}`);
-                                        // Handle 429 rate limit with improved logic
-                                        if (response.status === 429) {
+                                        // Handle 429 rate limit (or Service Overloaded) with improved logic
+                                        if (response.status === 429 || response.status === 503 || response.status === 529) {
                                             // Refund token on rate limit
                                             if (tokenConsumed) {
                                                 getTokenTracker().refund(account.index);
                                                 tokenConsumed = false;
                                             }
-                                            const headerRetryMs = retryAfterMsFromResponse(response);
+                                            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 extractRetryInfoFromBody(response);
                                             const serverRetryMs = bodyInfo.retryDelayMs ?? headerRetryMs;
+                                            // [Enhanced Parsing] Pass status to handling logic
+                                            const rateLimitReason = parseRateLimitReason(bodyInfo.reason, bodyInfo.message, response.status);
+                                            // STRATEGY 1: CAPACITY / SERVER ERROR (Transient)
+                                            // Goal: Wait and Retry SAME Account. DO NOT LOCK.
+                                            // We handle this FIRST to avoid calling getRateLimitBackoff() and polluting the global rate limit state for transient errors.
+                                            if (rateLimitReason === "MODEL_CAPACITY_EXHAUSTED" || rateLimitReason === "SERVER_ERROR") {
+                                                // Exponential backoff with jitter for capacity errors: 1s → 2s → 4s → 8s (max)
+                                                // Matches Antigravity-Manager's ExponentialBackoff(1s, 8s)
+                                                const baseDelayMs = 1000;
+                                                const maxDelayMs = 8000;
+                                                const exponentialDelay = Math.min(baseDelayMs * Math.pow(2, capacityRetryCount), maxDelayMs);
+                                                // Add ±10% jitter to prevent thundering herd
+                                                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})`);
+                                                await showToast(`⏳ Server busy (${response.status}). Retrying in ${waitSec}s...`, "warning");
+                                                await sleep(waitMs, abortSignal);
+                                                // CRITICAL FIX: Decrement i so that the loop 'continue' retries the SAME endpoint index
+                                                // (i++ in the loop will bring it back to the current index)
+                                                // But limit retries to prevent infinite loops (Greptile feedback)
+                                                if (capacityRetryCount < 3) {
+                                                    capacityRetryCount++;
+                                                    i -= 1;
+                                                    continue;
+                                                }
+                                                else {
+                                                    pushDebug(`Max capacity retries (3) exhausted for endpoint ${currentEndpoint}, regenerating fingerprint...`);
+                                                    // Regenerate fingerprint to get fresh device identity before trying next endpoint
+                                                    const newFingerprint = accountManager.regenerateAccountFingerprint(account.index);
+                                                    if (newFingerprint) {
+                                                        pushDebug(`Fingerprint regenerated for account ${account.index}`);
+                                                    }
+                                                    continue;
+                                                }
+                                            }
+                                            // STRATEGY 2: RATE LIMIT EXCEEDED (RPM) / QUOTA EXHAUSTED / UNKNOWN
+                                            // Goal: Lock and Rotate (Standard Logic)
+                                            // Only now do we call getRateLimitBackoff, which increments the global failure tracker
                                             const quotaKey = headerStyleToQuotaKey(headerStyle, family);
                                             const { attempt, delayMs, isDuplicate } = getRateLimitBackoff(account.index, quotaKey, serverRetryMs);
-                                            const rateLimitReason = parseRateLimitReason(bodyInfo.reason, bodyInfo.message);
+                                            // Calculate potential backoffs
                                             const smartBackoffMs = calculateBackoffMs(rateLimitReason, account.consecutiveFailures ?? 0, serverRetryMs);
                                             const effectiveDelayMs = Math.max(delayMs, smartBackoffMs);
-                                            const isCapacityExhausted = rateLimitReason === "MODEL_CAPACITY_EXHAUSTED";
                                             pushDebug(`429 idx=${account.index} email=${account.email ?? ""} family=${family} delayMs=${effectiveDelayMs} attempt=${attempt} reason=${rateLimitReason}`);
                                             if (bodyInfo.message) {
                                                 pushDebug(`429 message=${bodyInfo.message}`);
@@ -1015,36 +1167,37 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             logRateLimitEvent(account.index, account.email, family, response.status, effectiveDelayMs, bodyInfo);
                                             await logResponseBody(debugContext, response, 429);
                                             getHealthTracker().recordRateLimit(account.index);
-                                            if (isCapacityExhausted) {
-                                                const capacityBackoffMs = calculateBackoffMs(rateLimitReason, account.consecutiveFailures ?? 0, serverRetryMs);
-                                                accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs);
-                                                const backoffFormatted = formatWaitTime(capacityBackoffMs);
-                                                const failures = account.consecutiveFailures ?? 0;
-                                                pushDebug(`capacity exhausted on account ${account.index}, backoff=${capacityBackoffMs}ms (failure #${failures})`);
-                                                // Check if we can switch to another account (respects switch_on_first_rate_limit config)
-                                                if (config.switch_on_first_rate_limit && accountCount > 1) {
-                                                    await showToast(`Server at capacity. Switching account in 1s...`, "warning");
-                                                    await sleep(FIRST_RETRY_DELAY_MS, abortSignal);
-                                                    shouldSwitchAccount = true;
-                                                    break;
-                                                }
-                                                // No other accounts available or config disabled - wait the backoff
-                                                await showToast(`Server at capacity. Waiting ${backoffFormatted}... (attempt ${failures})`, "warning");
-                                                await sleep(capacityBackoffMs, abortSignal);
-                                                continue;
-                                            }
                                             const accountLabel = account.email || `Account ${account.index + 1}`;
-                                            if (attempt === 1) {
+                                            // Progressive retry for standard 429s: 1st 429 → 1s then switch (if enabled) or retry same
+                                            if (attempt === 1 && rateLimitReason !== "QUOTA_EXHAUSTED") {
                                                 await showToast(`Rate limited. Quick retry in 1s...`, "warning");
                                                 await sleep(FIRST_RETRY_DELAY_MS, abortSignal);
+                                                // CacheFirst mode: wait for same account if within threshold (preserves prompt cache)
+                                                if (config.scheduling_mode === 'cache_first') {
+                                                    const maxCacheFirstWaitMs = config.max_cache_first_wait_seconds * 1000;
+                                                    // effectiveDelayMs is the backoff calculated for this account
+                                                    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);
+                                                        // Retry same endpoint after wait
+                                                        i -= 1;
+                                                        continue;
+                                                    }
+                                                    // Wait time exceeds threshold, fall through to switch
+                                                    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);
+                                                    accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
                                                     shouldSwitchAccount = true;
                                                     break;
                                                 }
+                                                // Same endpoint retry for first RPM hit
+                                                i -= 1;
                                                 continue;
                                             }
-                                            accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs);
+                                            accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
                                             accountManager.requestSaveToDisk();
                                             // For Gemini, try prioritized Antigravity across ALL accounts first
                                             if (family === "gemini") {
@@ -1147,6 +1300,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         if (response.ok) {
                                             account.consecutiveFailures = 0;
                                             getHealthTracker().recordSuccess(account.index);
+                                            accountManager.markAccountUsed(account.index);
                                         }
                                         logAntigravityDebugResponse(debugContext, response, {
                                             note: response.ok ? "Success" : `Error ${response.status}`,
@@ -1158,9 +1312,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 const cloned = response.clone();
                                                 const bodyText = await cloned.text();
                                                 if (bodyText.includes("Prompt is too long") || bodyText.includes("prompt_too_long")) {
-                                                    if (!quietMode) {
-                                                        await showToast("Context too long - use /compact to reduce size", "warning");
-                                                    }
+                                                    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);
                                                 }
@@ -1197,7 +1349,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         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);
                                         // Check for context errors and show appropriate toast
                                         const contextError = transformedResponse.headers.get("x-antigravity-context-error");
-                                        if (contextError && !quietMode) {
+                                        if (contextError) {
                                             if (contextError === "prompt_too_long") {
                                                 await showToast("Context too long - use /compact to reduce size, or trim your request", "warning");
                                             }
@@ -1289,18 +1441,82 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             const useManualMode = noBrowser || shouldSkipLocalServer();
                             // Check for existing accounts and prompt user for login mode
                             let startFresh = true;
+                            let refreshAccountIndex;
                             const existingStorage = await loadAccounts();
                             if (existingStorage && existingStorage.accounts.length > 0) {
-                                const existingAccounts = existingStorage.accounts.map((acc, idx) => ({
-                                    email: acc.email,
-                                    index: idx,
-                                }));
-                                const loginMode = await promptLoginMode(existingAccounts);
-                                startFresh = loginMode === "fresh";
-                                if (startFresh) {
-                                    console.log("\nStarting fresh - existing accounts will be replaced.\n");
+                                const now = Date.now();
+                                const existingAccounts = existingStorage.accounts.map((acc, idx) => {
+                                    let status = 'unknown';
+                                    const rateLimits = acc.rateLimitResetTimes;
+                                    if (rateLimits) {
+                                        const isRateLimited = Object.values(rateLimits).some((resetTime) => typeof resetTime === 'number' && resetTime > now);
+                                        if (isRateLimited) {
+                                            status = 'rate-limited';
+                                        }
+                                        else {
+                                            status = 'active';
+                                        }
+                                    }
+                                    else {
+                                        status = 'active';
+                                    }
+                                    if (acc.coolingDownUntil && acc.coolingDownUntil > now) {
+                                        status = 'rate-limited';
+                                    }
+                                    return {
+                                        email: acc.email,
+                                        index: idx,
+                                        addedAt: acc.addedAt,
+                                        lastUsed: acc.lastUsed,
+                                        status,
+                                        isCurrentAccount: idx === (existingStorage.activeIndex ?? 0),
+                                    };
+                                });
+                                const menuResult = await promptLoginMode(existingAccounts);
+                                if (menuResult.mode === "cancel") {
+                                    return {
+                                        url: "",
+                                        instructions: "Authentication cancelled",
+                                        method: "auto",
+                                        callback: async () => ({ type: "failed", error: "Authentication cancelled" }),
+                                    };
+                                }
+                                if (menuResult.deleteAccountIndex !== undefined) {
+                                    const updatedAccounts = existingStorage.accounts.filter((_, idx) => idx !== menuResult.deleteAccountIndex);
+                                    await saveAccounts({
+                                        version: 3,
+                                        accounts: updatedAccounts,
+                                        activeIndex: 0,
+                                        activeIndexByFamily: { claude: 0, gemini: 0 },
+                                    });
+                                    console.log("\nAccount deleted.\n");
+                                    if (updatedAccounts.length > 0) {
+                                        return {
+                                            url: "",
+                                            instructions: "Account deleted. Please run `opencode auth login` again to continue.",
+                                            method: "auto",
+                                            callback: async () => ({ type: "failed", error: "Account deleted - please re-run auth" }),
+                                        };
+                                    }
+                                }
+                                if (menuResult.refreshAccountIndex !== undefined) {
+                                    refreshAccountIndex = menuResult.refreshAccountIndex;
+                                    const refreshEmail = existingStorage.accounts[refreshAccountIndex]?.email;
+                                    console.log(`\nRe-authenticating ${refreshEmail || 'account'}...\n`);
+                                    startFresh = false;
+                                }
+                                if (menuResult.deleteAll) {
+                                    await clearAccounts();
+                                    console.log("\nAll accounts deleted.\n");
+                                    startFresh = true;
                                 }
                                 else {
+                                    startFresh = menuResult.mode === "fresh";
+                                }
+                                if (startFresh && !menuResult.deleteAll) {
+                                    console.log("\nStarting fresh - existing accounts will be replaced.\n");
+                                }
+                                else if (!startFresh) {
                                     console.log("\nAdding to existing accounts.\n");
                                 }
                             }
@@ -1394,7 +1610,6 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     break;
                                 }
                                 accounts.push(result);
-                                // Show toast for successful account authentication
                                 try {
                                     await client.tui.showToast({
                                         body: {
@@ -1404,15 +1619,40 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     });
                                 }
                                 catch {
-                                    // TUI may not be available in CLI mode
                                 }
                                 try {
-                                    // Use startFresh only on first account, subsequent accounts always append
-                                    const isFirstAccount = accounts.length === 1;
-                                    await persistAccountPool([result], isFirstAccount && startFresh);
+                                    if (refreshAccountIndex !== undefined) {
+                                        const currentStorage = await loadAccounts();
+                                        if (currentStorage) {
+                                            const updatedAccounts = [...currentStorage.accounts];
+                                            const parts = parseRefreshParts(result.refresh);
+                                            if (parts.refreshToken) {
+                                                updatedAccounts[refreshAccountIndex] = {
+                                                    email: result.email ?? updatedAccounts[refreshAccountIndex]?.email,
+                                                    refreshToken: parts.refreshToken,
+                                                    projectId: parts.projectId ?? updatedAccounts[refreshAccountIndex]?.projectId,
+                                                    managedProjectId: parts.managedProjectId ?? updatedAccounts[refreshAccountIndex]?.managedProjectId,
+                                                    addedAt: updatedAccounts[refreshAccountIndex]?.addedAt ?? Date.now(),
+                                                    lastUsed: Date.now(),
+                                                };
+                                                await saveAccounts({
+                                                    version: 3,
+                                                    accounts: updatedAccounts,
+                                                    activeIndex: currentStorage.activeIndex,
+                                                    activeIndexByFamily: currentStorage.activeIndexByFamily,
+                                                });
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        const isFirstAccount = accounts.length === 1;
+                                        await persistAccountPool([result], isFirstAccount && startFresh);
+                                    }
                                 }
                                 catch {
-                                    // ignore
+                                }
+                                if (refreshAccountIndex !== undefined) {
+                                    break;
                                 }
                                 if (accounts.length >= MAX_OAUTH_ACCOUNTS) {
                                     break;
@@ -1442,7 +1682,6 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     callback: async () => ({ type: "failed", error: "Authentication cancelled" }),
                                 };
                             }
-                            // Get the actual deduplicated account count from storage
                             let actualAccountCount = accounts.length;
                             try {
                                 const finalStorage = await loadAccounts();
@@ -1451,11 +1690,13 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 }
                             }
                             catch {
-                                // Fall back to accounts.length if we can't read storage
                             }
+                            const successMessage = refreshAccountIndex !== undefined
+                                ? `Token refreshed successfully.`
+                                : `Multi-account setup complete (${actualAccountCount} account(s)).`;
                             return {
                                 url: "",
-                                instructions: `Multi-account setup complete (${actualAccountCount} account(s)).`,
+                                instructions: successMessage,
                                 method: "auto",
                                 callback: async () => primary,
                             };