@cortexkit/opencode-antigravity-auth 1.0.1 → 1.1.0

package/dist/src/plugin.js

@@ -9,9 +9,9 @@ import { fetchWithAgyCliTransport } from "./plugin/agy-transport";
 import { buildFingerprintHeaders, getSessionFingerprint } from "./plugin/fingerprint";
 import { clearProvisionFailedKeys, ensureProjectContext } from "./plugin/project";
 import { startAntigravityDebugRequest, logAntigravityDebugResponse, logAccountContext, logRateLimitEvent, logRateLimitSnapshot, logResponseBody, logModelFamily, isDebugEnabled, getLogFilePath, initializeDebug, } from "./plugin/debug";
-import { buildThinkingWarmupBody, getLastCacheStats, isGenerativeLanguageRequest, prepareAntigravityRequest, transformAntigravityResponse, } from "./plugin/request";
+import { buildThinkingWarmupBody, getLastCacheStats, isGenerativeLanguageRequest, getImageModelLocalTitle, prepareAntigravityRequest, transformAntigravityResponse, } from "./plugin/request";
 import { resolveModelWithTier } from "./plugin/transform/model-resolver";
-import { isEmptyResponseBody, createSyntheticErrorResponse, } from "./plugin/request-helpers";
+import { isEmptyResponseBody, createSyntheticErrorResponse, createSyntheticTextResponse, } from "./plugin/request-helpers";
 import { AntigravityTokenRefreshError, refreshAccessToken } from "./plugin/token";
 import { startOAuthListener } from "./plugin/server";
 import { clearAccounts, loadAccounts, saveAccounts, saveAccountsReplace } from "./plugin/storage";
@@ -30,6 +30,8 @@ import { initHealthTracker, getHealthTracker, initTokenTracker, getTokenTracker
 import { getAntigravityVersionResolution, initAntigravityVersion } from "./plugin/version";
 import { executeSearch } from "./plugin/search";
 import { resolvePromptContext } from "./plugin/prompt-context";
+import { AgySessionRegistry, extractOpenCodeSessionIdentity } from "./plugin/session-context";
+import { buildAgyAgentRequestMetadata, createAgyRequestSessionContext, orderAgyRequestPayloadInPlace, } from "./plugin/agy-request-metadata";
 import { dumpGeminiRequest, executeGeminiDumpCommand, GEMINI_DUMP_COMMAND_NAME, noteGeminiDumpResponse, parseGeminiDumpCommandAction, setGeminiDumpEnabled, } from "./plugin/gemini-dump";
 import { getAntigravityOpencodeModelIds, OPENCODE_MODEL_DEFINITIONS } from "./plugin/model-registry";
 const MAX_OAUTH_ACCOUNTS = 10;
@@ -46,10 +48,6 @@ function getCapacityBackoffDelay(consecutiveFailures) {
 }
 const warmupAttemptedSessionIds = new Set();
 const warmupSucceededSessionIds = new Set();
-// Track if this plugin instance is running in a child session (subagent, background task)
-// Used to filter toasts based on toast_scope config
-let isChildSession = false;
-let childSessionParentID = undefined;
 const log = createLogger("plugin");
 // Module-level toast debounce to persist across requests (fixes toast spam)
 const rateLimitToastCooldowns = new Map();
@@ -264,10 +262,12 @@ function selectBestVerificationUrl(urls) {
     });
     return unique[0];
 }
-function extractVerificationErrorDetails(bodyText) {
+function extractAccountAccessErrorDetails(bodyText) {
     const decodedBody = decodeEscapedText(bodyText);
     const lowerBody = decodedBody.toLowerCase();
     let validationRequired = lowerBody.includes("validation_required");
+    const ineligiblePattern = /(^|[^a-z0-9_])account_ineligible([^a-z0-9_]|$)/i;
+    let accountIneligible = ineligiblePattern.test(decodedBody);
     let message;
     const verificationUrls = new Set();
     const collectUrlsFromText = (text) => {
@@ -312,6 +312,9 @@ function extractVerificationErrorDetails(bodyText) {
             if (lowerValue.includes("validation_required")) {
                 validationRequired = true;
             }
+            if (ineligiblePattern.test(normalizedValue)) {
+                accountIneligible = true;
+            }
             if (!message &&
                 (lowerKey.includes("message") || lowerKey.includes("detail") || lowerKey.includes("description"))) {
                 message = normalizedValue;
@@ -352,17 +355,68 @@ function extractVerificationErrorDetails(bodyText) {
         const fallback = decodedBody
             .split("\n")
             .map((line) => line.trim())
-            .find((line) => line && !line.startsWith("data:") && /(verify|validation|required)/i.test(line));
+            .find((line) => line && !line.startsWith("data:") && /(verify|validation|required|ineligible)/i.test(line));
         if (fallback) {
             message = fallback;
         }
     }
     return {
         validationRequired,
+        accountIneligible,
         message,
         verifyUrl: selectBestVerificationUrl([...verificationUrls]),
     };
 }
+function buildAccountAccessProbeRequest(projectId) {
+    const wireModel = "gemini-3.5-flash-low";
+    const request = {
+        contents: [{ role: "user", parts: [{ text: "ping" }] }],
+        generationConfig: { maxOutputTokens: 1, temperature: 0 },
+    };
+    const requestMetadata = buildAgyAgentRequestMetadata(createAgyRequestSessionContext(""), request, wireModel);
+    request.labels = requestMetadata.labels;
+    request.sessionId = requestMetadata.sessionId;
+    orderAgyRequestPayloadInPlace(request);
+    return {
+        project: projectId,
+        requestId: requestMetadata.requestId,
+        request,
+        model: wireModel,
+        userAgent: "antigravity",
+        requestType: "agent",
+    };
+}
+async function interpretAccountAccessProbeResponse(response) {
+    if (response.ok) {
+        await response.body?.cancel().catch(() => { });
+        return { status: "ok", message: "Account verification check passed." };
+    }
+    let responseBody = "";
+    try {
+        responseBody = await response.text();
+    }
+    catch {
+        responseBody = "";
+    }
+    const extracted = extractAccountAccessErrorDetails(responseBody);
+    if (response.status === 403 && extracted.accountIneligible) {
+        return {
+            status: "ineligible",
+            message: extracted.message ?? "Google marked this account as ineligible for Antigravity.",
+        };
+    }
+    if (response.status === 403 && extracted.validationRequired) {
+        return {
+            status: "verification-required",
+            message: extracted.message ?? "Google requires additional account verification.",
+            verifyUrl: extracted.verifyUrl,
+        };
+    }
+    return {
+        status: "error",
+        message: extracted.message ?? `Request failed (${response.status} ${response.statusText}).`,
+    };
+}
 async function verifyAccountAccess(account, client, providerId) {
     const parsed = parseRefreshParts(account.refreshToken);
     if (!parsed.refreshToken) {
@@ -403,18 +457,7 @@ async function verifyAccountAccess(account, client, providerId) {
         "Content-Type": "application/json",
         "Accept-Encoding": "gzip",
     };
-    const requestBody = {
-        project: projectId,
-        requestId: `agent/${crypto.randomUUID()}/${Date.now()}/${crypto.randomUUID()}/2`,
-        request: {
-            model: "gemini-3-flash",
-            contents: [{ role: "user", parts: [{ text: "ping" }] }],
-            generationConfig: { maxOutputTokens: 1, temperature: 0 },
-        },
-        model: "gemini-3-flash",
-        userAgent: "antigravity",
-        requestType: "agent",
-    };
+    const requestBody = buildAccountAccessProbeRequest(projectId);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 20000);
     let response;
@@ -434,29 +477,7 @@ async function verifyAccountAccess(account, client, providerId) {
     finally {
         clearTimeout(timeoutId);
     }
-    let responseBody = "";
-    try {
-        responseBody = await response.text();
-    }
-    catch {
-        responseBody = "";
-    }
-    if (response.ok) {
-        return { status: "ok", message: "Account verification check passed." };
-    }
-    const extracted = extractVerificationErrorDetails(responseBody);
-    if (response.status === 403 && extracted.validationRequired) {
-        return {
-            status: "blocked",
-            message: extracted.message ?? "Google requires additional account verification.",
-            verifyUrl: extracted.verifyUrl,
-        };
-    }
-    const fallbackMessage = extracted.message ?? `Request failed (${response.status} ${response.statusText}).`;
-    return {
-        status: "error",
-        message: fallbackMessage,
-    };
+    return interpretAccountAccessProbeResponse(response);
 }
 async function promptAccountIndexForVerification(accounts) {
     const { createInterface } = await import("node:readline/promises");
@@ -499,12 +520,22 @@ async function promptOpenVerificationUrl() {
 function markStoredAccountVerificationRequired(account, reason, verifyUrl) {
     let changed = false;
     const wasVerificationRequired = account.verificationRequired === true;
+    const timestamp = Date.now();
     if (!wasVerificationRequired) {
         account.verificationRequired = true;
         changed = true;
     }
     if (!wasVerificationRequired || account.verificationRequiredAt === undefined) {
-        account.verificationRequiredAt = Date.now();
+        account.verificationRequiredAt = timestamp;
+        changed = true;
+    }
+    if (account.accountIneligible === true ||
+        account.accountIneligibleAt !== undefined ||
+        account.accountIneligibleReason !== undefined) {
+        account.accountIneligible = false;
+        account.accountIneligibleAt = undefined;
+        account.accountIneligibleReason = undefined;
+        account.eligibilityStateUpdatedAt = timestamp;
         changed = true;
     }
     const normalizedReason = reason.trim();
@@ -523,8 +554,31 @@ function markStoredAccountVerificationRequired(account, reason, verifyUrl) {
     }
     return changed;
 }
-function clearStoredAccountVerificationRequired(account, enableIfRequired = false) {
+function markStoredAccountIneligible(account, reason) {
+    const timestamp = Date.now();
+    const normalizedReason = reason.trim() || "Google marked this account as ineligible.";
+    const changed = account.accountIneligible !== true ||
+        account.accountIneligibleReason !== normalizedReason ||
+        account.verificationRequired === true ||
+        account.verificationRequiredAt !== undefined ||
+        account.verificationRequiredReason !== undefined ||
+        account.verificationUrl !== undefined ||
+        account.enabled !== false;
+    account.accountIneligible = true;
+    account.accountIneligibleAt = timestamp;
+    account.accountIneligibleReason = normalizedReason;
+    account.eligibilityStateUpdatedAt = timestamp;
+    account.verificationRequired = false;
+    account.verificationRequiredAt = undefined;
+    account.verificationRequiredReason = undefined;
+    account.verificationUrl = undefined;
+    account.enabled = false;
+    return changed;
+}
+function clearStoredAccountAccessBlocks(account, enableIfBlocked = false) {
     const wasVerificationRequired = account.verificationRequired === true;
+    const wasIneligible = account.accountIneligible === true;
+    const wasAccessBlocked = wasVerificationRequired || wasIneligible;
     let changed = false;
     if (account.verificationRequired !== false) {
         account.verificationRequired = false;
@@ -542,11 +596,27 @@ function clearStoredAccountVerificationRequired(account, enableIfRequired = fals
         account.verificationUrl = undefined;
         changed = true;
     }
-    if (enableIfRequired && wasVerificationRequired && account.enabled === false) {
+    if (account.accountIneligible !== false) {
+        account.accountIneligible = false;
+        changed = true;
+    }
+    if (account.accountIneligibleAt !== undefined) {
+        account.accountIneligibleAt = undefined;
+        changed = true;
+    }
+    if (account.accountIneligibleReason !== undefined) {
+        account.accountIneligibleReason = undefined;
+        changed = true;
+    }
+    if (wasIneligible || account.eligibilityStateUpdatedAt !== undefined) {
+        account.eligibilityStateUpdatedAt = Date.now();
+        changed = true;
+    }
+    if (enableIfBlocked && wasAccessBlocked && account.enabled === false) {
         account.enabled = true;
         changed = true;
     }
-    return { changed, wasVerificationRequired };
+    return { changed, wasAccessBlocked };
 }
 async function promptOAuthCallbackValue(message) {
     const { createInterface } = await import("node:readline/promises");
@@ -1044,6 +1114,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
     // Load configuration from files and environment variables
     const config = loadConfig(directory);
     initRuntimeConfig(config);
+    const agySessionRegistry = new AgySessionRegistry(directory);
     // Cached getAuth function for tool access
     let cachedGetAuth = null;
     // Initialize debug with config
@@ -1087,31 +1158,36 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
     const eventHandler = async (input) => {
         // Forward to update checker
         await updateChecker.event(input);
-        // Track if this is a child session (subagent, background task)
-        // This is used to filter toasts based on toast_scope config
         if (input.event.type === "session.created") {
-            // Log previous session's quota summary before resetting for new session
-            const prevSummary = activeAccountManager?.getSessionSummary();
-            if (prevSummary && (prevSummary.totalClaude > 0 || prevSummary.totalGemini > 0)) {
-                log.debug("prev-session-quota-summary", {
-                    durationMinutes: prevSummary.durationMinutes,
-                    totalClaude: prevSummary.totalClaude,
-                    totalGemini: prevSummary.totalGemini,
-                    requestsPerHour: prevSummary.requestsPerHour,
-                    accountsUsed: prevSummary.accountsUsed,
-                });
-            }
             const props = input.event.properties;
-            if (props?.info?.parentID) {
-                isChildSession = true;
-                childSessionParentID = props.info.parentID;
-                log.debug("child-session-detected", { parentID: props.info.parentID });
+            const sessionId = props?.info?.id;
+            const parentSessionId = props?.info?.parentID ?? null;
+            if (sessionId) {
+                agySessionRegistry.register(sessionId, parentSessionId);
+            }
+            if (parentSessionId) {
+                log.debug("child-session-detected", { sessionId, parentID: parentSessionId });
             }
             else {
-                // Reset for root sessions - important when plugin instance is reused
-                isChildSession = false;
-                childSessionParentID = undefined;
-                log.debug("root-session-detected", {});
+                const prevSummary = activeAccountManager?.getSessionSummary();
+                if (prevSummary && (prevSummary.totalClaude > 0 || prevSummary.totalGemini > 0)) {
+                    log.debug("prev-session-quota-summary", {
+                        durationMinutes: prevSummary.durationMinutes,
+                        totalClaude: prevSummary.totalClaude,
+                        totalGemini: prevSummary.totalGemini,
+                        requestsPerHour: prevSummary.requestsPerHour,
+                        accountsUsed: prevSummary.accountsUsed,
+                    });
+                }
+                log.debug("root-session-detected", { sessionId });
+            }
+        }
+        if (input.event.type === "session.deleted") {
+            const props = input.event.properties;
+            const sessionId = props?.sessionID ?? props?.info?.id;
+            if (sessionId) {
+                agySessionRegistry.delete(sessionId);
+                activeAccountManager?.deleteSessionState(sessionId);
             }
         }
         // Handle session recovery
@@ -1140,8 +1216,13 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                     }).catch(() => { });
                     // Show success toast (respects toast_scope for child sessions)
                     const successToast = getRecoverySuccessToast();
-                    log.debug("recovery-toast", { ...successToast, isChildSession, toastScope: config.toast_scope });
-                    if (!(config.toast_scope === "root_only" && isChildSession)) {
+                    const isChildRecovery = agySessionRegistry.getParentSessionId(sessionID) !== null;
+                    log.debug("recovery-toast", {
+                        ...successToast,
+                        isChildSession: isChildRecovery,
+                        toastScope: config.toast_scope,
+                    });
+                    if (!(config.toast_scope === "root_only" && isChildRecovery)) {
                         await client.tui.showToast({
                             body: {
                                 title: successToast.title,
@@ -1341,6 +1422,22 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 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) {
                             return createSyntheticErrorResponse("No Antigravity accounts configured. Run `opencode auth login`.", "unknown");
                         }
@@ -1354,6 +1451,11 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             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";
@@ -1375,14 +1477,18 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                         // Helper to show toast without blocking on abort (respects quiet_mode and toast_scope)
                         const showToast = async (message, variant) => {
                             // Always log to debug regardless of toast filtering
-                            log.debug("toast", { message, variant, isChildSession, toastScope });
+                            log.debug("toast", { message, variant, isChildSession: isChildRequest, toastScope });
                             if (quietMode)
                                 return;
                             if (abortSignal?.aborted)
                                 return;
                             // Filter toasts for child sessions when toast_scope is "root_only"
-                            if (toastScope === "root_only" && isChildSession) {
-                                log.debug("toast-suppressed-child-session", { message, variant, parentID: childSessionParentID });
+                            if (toastScope === "root_only" && isChildRequest) {
+                                log.debug("toast-suppressed-child-session", {
+                                    message,
+                                    variant,
+                                    parentID: requestSessionIdentity.parentSessionId,
+                                });
                                 return;
                             }
                             if (variant === "warning" && message.toLowerCase().includes("rate")) {
@@ -1419,10 +1525,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 return createSyntheticErrorResponse("No Antigravity accounts available. Run `opencode auth login`.", model ?? "unknown");
                             }
                             const softQuotaCacheTtlMs = computeSoftQuotaCacheTtlMs(config.soft_quota_cache_ttl_minutes, config.quota_refresh_interval_minutes);
-                            let account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, preferredHeaderStyle, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs);
+                            let account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, preferredHeaderStyle, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity);
                             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);
+                                account = accountManager.getCurrentOrNextForFamily(family, model, config.account_selection_strategy, alternateHeaderStyle, config.pid_offset_enabled, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, accountSessionIdentity);
                                 if (account) {
                                     pushDebug(`selected-by-fallback idx=${account.index} preferred=${preferredHeaderStyle} alternate=${alternateHeaderStyle}`);
                                 }
@@ -1488,7 +1594,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 pushDebug(`account-switch: ${previousAccountIndex} → ${account.index}, warmup=${needsCacheWarmup}`);
                             }
                             previousAccountIndex = account.index;
-                            accountManager.recordSessionUsage(account.index);
+                            accountManager.recordSessionUsage(account.index, accountSessionIdentity);
                             if (isDebugEnabled()) {
                                 logAccountContext("Selected", {
                                     index: account.index,
@@ -1796,6 +1902,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             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);
@@ -2041,7 +2149,23 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         resetAccountFailureState(account.index);
                                         if (response.status === 403) {
                                             const errorBodyText = await response.clone().text().catch(() => "");
-                                            const extracted = extractVerificationErrorDetails(errorBodyText);
+                                            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;
@@ -2077,13 +2201,14 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             // Proactive rotation: if current account quota is low, pre-switch
                                             // to a warm-cache account so the NEXT request avoids a cold cache miss
                                             const proactiveThreshold = config.proactive_rotation_threshold_percent ?? 20;
-                                            if (proactiveThreshold > 0 && accountManager.shouldProactivelyRotate(family, model, proactiveThreshold, softQuotaCacheTtlMs)) {
-                                                const rotated = accountManager.proactivelyRotateForFamily(family, model, headerStyle, config.soft_quota_threshold_percent, softQuotaCacheTtlMs);
+                                            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)})`);
+                                                    pushDebug(`[ProactiveRotation] ${account.index} → ${rotated.index}` +
+                                                        ` (warm=${accountManager.wasUsedInSession(rotated.index, accountSessionIdentity)})`);
                                                 }
                                             }
                                         }
@@ -2157,7 +2282,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         // Post-request quota state: show cached remaining quota for this account
                                         const cachedQuota = account.cachedQuota;
                                         if (cachedQuota) {
-                                            const quotaFamily = family === "claude" ? "claude" : "gemini-flash";
+                                            const quotaFamily = resolveQuotaGroup(family, model);
                                             const groupQuota = cachedQuota[quotaFamily];
                                             if (groupQuota?.remainingFraction != null) {
                                                 const pct = Math.round(groupQuota.remainingFraction * 100);
@@ -2273,26 +2398,29 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 while (true) {
                                     const now = Date.now();
                                     const existingAccounts = existingStorage.accounts.map((acc, idx) => {
-                                        let status = 'unknown';
-                                        if (acc.verificationRequired) {
-                                            status = 'verification-required';
+                                        let status = "unknown";
+                                        if (acc.accountIneligible) {
+                                            status = "ineligible";
+                                        }
+                                        else if (acc.verificationRequired) {
+                                            status = "verification-required";
                                         }
                                         else {
                                             const rateLimits = acc.rateLimitResetTimes;
                                             if (rateLimits) {
-                                                const isRateLimited = Object.values(rateLimits).some((resetTime) => typeof resetTime === 'number' && resetTime > now);
+                                                const isRateLimited = Object.values(rateLimits).some((resetTime) => typeof resetTime === "number" && resetTime > now);
                                                 if (isRateLimited) {
-                                                    status = 'rate-limited';
+                                                    status = "rate-limited";
                                                 }
                                                 else {
-                                                    status = 'active';
+                                                    status = "active";
                                                 }
                                             }
                                             else {
-                                                status = 'active';
+                                                status = "active";
                                             }
                                             if (acc.coolingDownUntil && acc.coolingDownUntil > now) {
-                                                status = 'rate-limited';
+                                                status = "rate-limited";
                                             }
                                         }
                                         const cooldownMs = (acc.coolingDownUntil && acc.coolingDownUntil > now)
@@ -2306,11 +2434,11 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             || (now - acc.cachedQuotaUpdatedAt) > DISPLAY_QUOTA_MAX_AGE_MS;
                                         const displayQuota = quotaIsStale ? undefined : acc.cachedQuota;
                                         const displayPerModelQuota = quotaIsStale ? undefined : acc.cachedPerModelQuota;
-                                        if (status === 'active' && displayQuota) {
+                                        if (status === "active" && displayQuota) {
                                             const groups = Object.values(displayQuota);
                                             const allExhausted = groups.length > 0 && groups.every((group) => typeof group.remainingFraction === "number" && group.remainingFraction <= 0);
                                             if (allExhausted) {
-                                                status = 'rate-limited';
+                                                status = "rate-limited";
                                             }
                                         }
                                         return {
@@ -2430,6 +2558,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                     { name: "Claude", data: groups.claude },
                                                     { name: "Gemini 3 Pro", data: groups["gemini-pro"] },
                                                     { name: "Gemini 3 Flash", data: groups["gemini-flash"] },
+                                                    { name: "GPT-OSS", data: groups["gpt-oss"] },
                                                 ].filter(g => g.data);
                                                 groupEntries.forEach((g, idx) => {
                                                     const isLast = idx === groupEntries.length - 1;
@@ -2487,10 +2616,16 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         if (menuResult.toggleAccountIndex !== undefined) {
                                             const acc = existingStorage.accounts[menuResult.toggleAccountIndex];
                                             if (acc) {
-                                                acc.enabled = acc.enabled === false;
+                                                const shouldEnable = acc.enabled === false;
+                                                if (shouldEnable && acc.accountIneligible) {
+                                                    console.log(`\n${acc.email || `Account ${menuResult.toggleAccountIndex + 1}`} remains disabled. ` +
+                                                        "Use Verify accounts to recheck eligibility.\n");
+                                                    continue;
+                                                }
+                                                acc.enabled = shouldEnable;
                                                 await saveAccounts(existingStorage);
                                                 activeAccountManager?.setAccountEnabled(menuResult.toggleAccountIndex, acc.enabled);
-                                                console.log(`\nAccount ${acc.email || menuResult.toggleAccountIndex + 1} ${acc.enabled ? 'enabled' : 'disabled'}.\n`);
+                                                console.log(`\nAccount ${acc.email || menuResult.toggleAccountIndex + 1} ${acc.enabled ? "enabled" : "disabled"}.\n`);
                                             }
                                         }
                                         continue;
@@ -2505,6 +2640,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             console.log(`\nChecking verification status for ${existingStorage.accounts.length} account(s)...\n`);
                                             let okCount = 0;
                                             let blockedCount = 0;
+                                            let ineligibleCount = 0;
                                             let errorCount = 0;
                                             let storageUpdated = false;
                                             const blockedResults = [];
@@ -2516,16 +2652,16 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 process.stdout.write(`- [${i + 1}/${existingStorage.accounts.length}] ${label} ... `);
                                                 const verification = await verifyAccountAccess(account, client, providerId);
                                                 if (verification.status === "ok") {
-                                                    const { changed, wasVerificationRequired } = clearStoredAccountVerificationRequired(account, true);
+                                                    const { changed, wasAccessBlocked } = clearStoredAccountAccessBlocks(account, true);
                                                     if (changed) {
                                                         storageUpdated = true;
                                                     }
-                                                    activeAccountManager?.clearAccountVerificationRequired(i, wasVerificationRequired);
+                                                    activeAccountManager?.clearAccountAccessBlocks(i, wasAccessBlocked);
                                                     okCount += 1;
                                                     console.log("ok");
                                                     continue;
                                                 }
-                                                if (verification.status === "blocked") {
+                                                if (verification.status === "verification-required") {
                                                     const changed = markStoredAccountVerificationRequired(account, verification.message, verification.verifyUrl);
                                                     if (changed) {
                                                         storageUpdated = true;
@@ -2541,13 +2677,24 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                     });
                                                     continue;
                                                 }
+                                                if (verification.status === "ineligible") {
+                                                    const changed = markStoredAccountIneligible(account, verification.message);
+                                                    if (changed) {
+                                                        storageUpdated = true;
+                                                    }
+                                                    activeAccountManager?.markAccountIneligible(i, verification.message);
+                                                    ineligibleCount += 1;
+                                                    console.log("ineligible");
+                                                    continue;
+                                                }
                                                 errorCount += 1;
                                                 console.log(`error (${verification.message})`);
                                             }
                                             if (storageUpdated) {
                                                 await saveAccounts(existingStorage);
                                             }
-                                            console.log(`\nVerification summary: ${okCount} ready, ${blockedCount} need verification, ${errorCount} errors.`);
+                                            console.log(`\nVerification summary: ${okCount} ready, ${blockedCount} need verification, ` +
+                                                `${ineligibleCount} ineligible, ${errorCount} errors.`);
                                             if (blockedResults.length > 0) {
                                                 console.log("\nAccounts needing verification:");
                                                 for (const result of blockedResults) {
@@ -2584,12 +2731,12 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         console.log(`\nChecking verification status for ${label}...\n`);
                                         const verification = await verifyAccountAccess(account, client, providerId);
                                         if (verification.status === "ok") {
-                                            const { changed, wasVerificationRequired } = clearStoredAccountVerificationRequired(account, true);
+                                            const { changed, wasAccessBlocked } = clearStoredAccountAccessBlocks(account, true);
                                             if (changed) {
                                                 await saveAccounts(existingStorage);
                                             }
-                                            activeAccountManager?.clearAccountVerificationRequired(verifyAccountIndex, wasVerificationRequired);
-                                            if (wasVerificationRequired) {
+                                            activeAccountManager?.clearAccountAccessBlocks(verifyAccountIndex, wasAccessBlocked);
+                                            if (wasAccessBlocked) {
                                                 console.log(`✓ ${label} is ready for requests and has been re-enabled.\n`);
                                             }
                                             else {
@@ -2597,7 +2744,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             }
                                             continue;
                                         }
-                                        if (verification.status === "blocked") {
+                                        if (verification.status === "verification-required") {
                                             const changed = markStoredAccountVerificationRequired(account, verification.message, verification.verifyUrl);
                                             if (changed) {
                                                 await saveAccounts(existingStorage);
@@ -2626,6 +2773,16 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             }
                                             continue;
                                         }
+                                        if (verification.status === "ineligible") {
+                                            const changed = markStoredAccountIneligible(account, verification.message);
+                                            if (changed) {
+                                                await saveAccounts(existingStorage);
+                                            }
+                                            activeAccountManager?.markAccountIneligible(verifyAccountIndex, verification.message);
+                                            console.log(`⚠ ${label} is not eligible for Antigravity and has been disabled.`);
+                                            console.log(`${verification.message}\n`);
+                                            continue;
+                                        }
                                         console.log(`✗ ${label}: ${verification.message}\n`);
                                         continue;
                                     }
@@ -3143,6 +3300,9 @@ function isExplicitQuotaFromUrl(urlString) {
     return explicitQuota ?? false;
 }
 export const __testExports = {
+    buildAccountAccessProbeRequest,
+    extractAccountAccessErrorDetails,
+    interpretAccountAccessProbeResponse,
     getHeaderStyleFromUrl,
     isCapacityRetryBudgetExhausted,
     resolveHeaderRoutingDecision,