opencode-antigravity-auth 1.3.1-beta.2 → 1.3.1

package/dist/src/plugin.js

@@ -1,5 +1,4 @@
 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";
@@ -21,7 +20,6 @@ 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;
@@ -285,7 +283,7 @@ async function persistAccountPool(results, replaceAll = false) {
         },
     });
 }
-function retryAfterMsFromResponse(response, defaultRetryMs = 60_000) {
+function retryAfterMsFromResponse(response) {
     const retryAfterMsHeader = response.headers.get("retry-after-ms");
     if (retryAfterMsHeader) {
         const parsed = Number.parseInt(retryAfterMsHeader, 10);
@@ -300,54 +298,20 @@ function retryAfterMsFromResponse(response, defaultRetryMs = 60_000) {
             return parsed * 1000;
         }
     }
-    return defaultRetryMs;
+    return 60_000;
 }
-/**
- * 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) {
-    // 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;
-        }
+    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;
     }
-    return matchFound ? totalMs : null;
 }
 function extractRateLimitBodyInfo(body) {
     if (!body || typeof body !== "object") {
@@ -471,10 +435,9 @@ 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, maxBackoffMs = 60_000) {
+function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs) {
     const now = Date.now();
     const stateKey = `${accountIndex}:${quotaKey}`;
     const previous = rateLimitStateByAccountQuota.get(stateKey);
@@ -482,7 +445,7 @@ function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs, maxBack
     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), maxBackoffMs);
+        const backoffDelay = Math.min(baseDelay * Math.pow(2, previous.consecutive429 - 1), 60_000);
         return {
             attempt: previous.consecutive429,
             delayMs: Math.max(baseDelay, backoffDelay),
@@ -499,7 +462,7 @@ function getRateLimitBackoff(accountIndex, quotaKey, serverRetryAfterMs, maxBack
         quotaKey
     });
     const baseDelay = serverRetryAfterMs ?? 1000;
-    const backoffDelay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxBackoffMs);
+    const backoffDelay = Math.min(baseDelay * Math.pow(2, attempt - 1), 60_000);
     return { attempt, delayMs: Math.max(baseDelay, backoffDelay), isDuplicate: false };
 }
 /**
@@ -577,8 +540,6 @@ 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
@@ -655,55 +616,11 @@ 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)) {
@@ -787,13 +704,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 throw abortSignal.reason instanceof Error ? abortSignal.reason : new Error("Aborted");
                             }
                         };
-                        // Use while(true) loop to handle rate limits with backoff
-                        // This ensures we wait and retry when all accounts are rate-limited
-                        const quietMode = config.quiet_mode;
-                        // Helper to show toast without blocking on abort (respects quiet_mode)
+                        // Helper to show toast without blocking on abort
                         const showToast = async (message, variant) => {
-                            if (quietMode)
-                                return;
                             if (abortSignal?.aborted)
                                 return;
                             try {
@@ -805,6 +717,9 @@ 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;
@@ -820,10 +735,8 @@ 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, headerStyle, explicitQuota) || 60_000;
+                                const waitMs = accountManager.getMinWaitTimeForFamily(family, model) || 60_000;
                                 const waitSecValue = Math.max(1, Math.ceil(waitMs / 1000));
                                 pushDebug(`all-rate-limited family=${family} accounts=${accountCount} waitMs=${waitMs}`);
                                 if (isDebugEnabled()) {
@@ -860,8 +773,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     rateLimitState: account.rateLimitResetTimes,
                                 });
                             }
-                            // Show toast when switching to a different account (debounced, quiet_mode handled by showToast)
-                            if (accountCount > 1 && accountManager.shouldShowAccountToast(account.index)) {
+                            // Show toast when switching to a different account (debounced, respects quiet mode)
+                            if (!quietMode && 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);
@@ -1015,9 +928,6 @@ 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)
@@ -1026,7 +936,9 @@ 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";
-                                        await showToast(`${quotaName} quota exhausted, using ${altQuotaName} quota`, "warning");
+                                        if (!quietMode) {
+                                            await showToast(`${quotaName} quota exhausted, using ${altQuotaName} quota`, "warning");
+                                        }
                                         headerStyle = alternateStyle;
                                         pushDebug(`quota fallback: ${headerStyle}`);
                                     }
@@ -1043,20 +955,15 @@ 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,
-                                            fingerprint: account.fingerprint,
+                                            googleSearch: config.web_search ? {
+                                                mode: config.web_search.default_mode,
+                                                threshold: config.web_search.grounding_threshold
+                                            } : undefined,
                                         });
                                         const originalUrl = toUrlString(input);
                                         const resolvedUrl = toUrlString(prepared.request);
@@ -1079,58 +986,22 @@ 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 (or Service Overloaded) with improved logic
-                                        if (response.status === 429 || response.status === 503 || response.status === 529) {
+                                        // Handle 429 rate limit with improved logic
+                                        if (response.status === 429) {
                                             // Refund token on rate limit
                                             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 headerRetryMs = retryAfterMsFromResponse(response);
                                             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}, trying next endpoint...`);
-                                                    // Do not decrement i, loop will advance to next endpoint
-                                                    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);
-                                            // Calculate potential backoffs
+                                            const rateLimitReason = parseRateLimitReason(bodyInfo.reason, bodyInfo.message);
                                             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}`);
@@ -1144,37 +1015,36 @@ 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}`;
-                                            // Progressive retry for standard 429s: 1st 429 → 1s then switch (if enabled) or retry same
-                                            if (attempt === 1 && rateLimitReason !== "QUOTA_EXHAUSTED") {
+                                            if (attempt === 1) {
                                                 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, config.failure_ttl_seconds * 1000);
+                                                    accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs);
                                                     shouldSwitchAccount = true;
                                                     break;
                                                 }
-                                                // Same endpoint retry for first RPM hit
-                                                i -= 1;
                                                 continue;
                                             }
-                                            accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs, config.failure_ttl_seconds * 1000);
+                                            accountManager.markRateLimitedWithReason(account, family, headerStyle, model, rateLimitReason, serverRetryMs);
                                             accountManager.requestSaveToDisk();
                                             // For Gemini, try prioritized Antigravity across ALL accounts first
                                             if (family === "gemini") {
@@ -1277,7 +1147,6 @@ 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}`,
@@ -1289,7 +1158,9 @@ 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")) {
-                                                    await showToast("Context too long - use /compact to reduce size", "warning");
+                                                    if (!quietMode) {
+                                                        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);
                                                 }
@@ -1326,7 +1197,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) {
+                                        if (contextError && !quietMode) {
                                             if (contextError === "prompt_too_long") {
                                                 await showToast("Context too long - use /compact to reduce size, or trim your request", "warning");
                                             }
@@ -1418,82 +1289,18 @@ 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 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) {
+                                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");
                                 }
-                                else if (!startFresh) {
+                                else {
                                     console.log("\nAdding to existing accounts.\n");
                                 }
                             }
@@ -1587,6 +1394,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     break;
                                 }
                                 accounts.push(result);
+                                // Show toast for successful account authentication
                                 try {
                                     await client.tui.showToast({
                                         body: {
@@ -1596,40 +1404,15 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     });
                                 }
                                 catch {
+                                    // TUI may not be available in CLI mode
                                 }
                                 try {
-                                    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);
-                                    }
+                                    // Use startFresh only on first account, subsequent accounts always append
+                                    const isFirstAccount = accounts.length === 1;
+                                    await persistAccountPool([result], isFirstAccount && startFresh);
                                 }
                                 catch {
-                                }
-                                if (refreshAccountIndex !== undefined) {
-                                    break;
+                                    // ignore
                                 }
                                 if (accounts.length >= MAX_OAUTH_ACCOUNTS) {
                                     break;
@@ -1659,6 +1442,7 @@ 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();
@@ -1667,13 +1451,11 @@ 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: successMessage,
+                                instructions: `Multi-account setup complete (${actualAccountCount} account(s)).`,
                                 method: "auto",
                                 callback: async () => primary,
                             };