@expiren/opencode-antigravity-auth 1.6.17 → 1.6.18

package/dist/index.js

@@ -66,6 +66,14 @@ var ANTIGRAVITY_HEADERS = {
   "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
   "Client-Metadata": `{"ideType":"ANTIGRAVITY","platform":"${process.platform === "win32" ? "WINDOWS" : "MACOS"}","pluginType":"GEMINI"}`
 };
+var GEMINI_CLI_VERSION = "1.0.0";
+var GEMINI_CLI_DEFAULT_MODEL = "gemini-2.5-pro";
+function buildGeminiCliUserAgent(model) {
+  const effectiveModel = model || GEMINI_CLI_DEFAULT_MODEL;
+  const platform = process.platform || "darwin";
+  const arch = process.arch || "arm64";
+  return `GeminiCLI/${GEMINI_CLI_VERSION}/${effectiveModel} (${platform}; ${arch})`;
+}
 var GEMINI_CLI_HEADERS = {
   "User-Agent": "google-api-nodejs-client/9.15.1",
   "X-Goog-Api-Client": "gl-node/22.17.0",
@@ -83,7 +91,7 @@ function randomFrom(arr) {
 function getRandomizedHeaders(style, model) {
   if (style === "gemini-cli") {
     return {
-      "User-Agent": GEMINI_CLI_HEADERS["User-Agent"],
+      "User-Agent": buildGeminiCliUserAgent(model),
       "X-Goog-Api-Client": GEMINI_CLI_HEADERS["X-Goog-Api-Client"],
       "Client-Metadata": GEMINI_CLI_HEADERS["Client-Metadata"]
     };
@@ -1574,6 +1582,129 @@ async function confirm(message, defaultYes = false) {
   return result ?? false;
 }
 
+// src/plugin/ui/quota-status.ts
+function formatWaitDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.ceil(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+function classifyGroupStatus(group) {
+  if (!group) {
+    return { label: "READY" };
+  }
+  const remaining = group.remainingFraction;
+  if (typeof remaining !== "number" || !Number.isFinite(remaining)) {
+    return { label: "READY" };
+  }
+  if (remaining <= 0) {
+    const waitMs = parseResetTimeToMs(group.resetTime);
+    if (waitMs !== null && waitMs > 0) {
+      return { label: "EXHAUSTED", waitMs };
+    }
+    return { label: "EXHAUSTED" };
+  }
+  if (remaining < 0.2) {
+    return { label: "LOW" };
+  }
+  return { label: "READY" };
+}
+function parseResetTimeToMs(resetTime) {
+  if (!resetTime) return null;
+  const timestamp = Date.parse(resetTime);
+  if (!Number.isFinite(timestamp)) return null;
+  const ms = timestamp - Date.now();
+  return ms > 0 ? ms : null;
+}
+function buildCooldownStatus(cooldownMs, reason) {
+  return {
+    label: "COOLDOWN",
+    waitMs: cooldownMs > 0 ? cooldownMs : void 0,
+    cooldownReason: reason
+  };
+}
+function formatQuotaStatusBadge(status) {
+  switch (status.label) {
+    case "READY":
+      return `${ANSI.green}[READY]${ANSI.reset}`;
+    case "LOW":
+      return `${ANSI.yellow}[LOW]${ANSI.reset}`;
+    case "WAIT": {
+      const suffix = status.waitMs ? ` ${formatWaitDuration(status.waitMs)}` : "";
+      return `${ANSI.yellow}[WAIT${suffix}]${ANSI.reset}`;
+    }
+    case "EXHAUSTED": {
+      const suffix = status.waitMs ? ` resets in ${formatWaitDuration(status.waitMs)}` : "";
+      return `${ANSI.red}[EXHAUSTED${suffix}]${ANSI.reset}`;
+    }
+    case "COOLDOWN": {
+      const parts = ["COOLDOWN"];
+      if (status.cooldownReason) {
+        parts.push(status.cooldownReason);
+      }
+      if (status.waitMs) {
+        parts.push(formatWaitDuration(status.waitMs));
+      }
+      return `${ANSI.red}[${parts.join(" ")}]${ANSI.reset}`;
+    }
+  }
+}
+function formatQuotaStatusPlain(status) {
+  switch (status.label) {
+    case "READY":
+      return "READY";
+    case "LOW":
+      return "LOW";
+    case "WAIT": {
+      const suffix = status.waitMs ? ` ${formatWaitDuration(status.waitMs)}` : "";
+      return `WAIT${suffix}`;
+    }
+    case "EXHAUSTED": {
+      const suffix = status.waitMs ? ` resets in ${formatWaitDuration(status.waitMs)}` : "";
+      return `EXHAUSTED${suffix}`;
+    }
+    case "COOLDOWN": {
+      const parts = ["COOLDOWN"];
+      if (status.cooldownReason) {
+        parts.push(status.cooldownReason);
+      }
+      if (status.waitMs) {
+        parts.push(formatWaitDuration(status.waitMs));
+      }
+      return parts.join(" ");
+    }
+  }
+}
+function formatCachedQuotaWithStatus(cachedQuota) {
+  if (!cachedQuota) {
+    return void 0;
+  }
+  const entries = [
+    { key: "claude", label: "Claude" },
+    { key: "gemini-pro", label: "Gemini Pro" },
+    { key: "gemini-flash", label: "Gemini Flash" }
+  ].flatMap(({ key, label }) => {
+    const value = cachedQuota[key]?.remainingFraction;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return [];
+    }
+    const pct = Math.round(Math.max(0, Math.min(1, value)) * 100);
+    const status = classifyGroupStatus(cachedQuota[key]);
+    if (status.label === "READY") {
+      return [`${label} ${pct}%`];
+    }
+    return [`${label} ${formatQuotaStatusPlain(status)} ${pct}%`];
+  });
+  return entries.length > 0 ? entries.join(", ") : void 0;
+}
+
 // src/plugin/ui/auth-menu.ts
 function formatRelativeTime(timestamp) {
   if (!timestamp) return "never";
@@ -1588,16 +1719,20 @@ function formatDate(timestamp) {
   if (!timestamp) return "unknown";
   return new Date(timestamp).toLocaleDateString();
 }
-function getStatusBadge(status) {
+function getStatusBadge(status, account) {
+  if (account?.cooldownMs !== void 0 && account.cooldownMs > 0) {
+    const cooldownStatus = buildCooldownStatus(account.cooldownMs, account.cooldownReason);
+    return ` ${formatQuotaStatusBadge(cooldownStatus)}`;
+  }
   switch (status) {
     case "active":
-      return `${ANSI.green}[active]${ANSI.reset}`;
+      return ` ${ANSI.green}[active]${ANSI.reset}`;
     case "rate-limited":
-      return `${ANSI.yellow}[rate-limited]${ANSI.reset}`;
+      return ` ${ANSI.yellow}[rate-limited]${ANSI.reset}`;
     case "expired":
-      return `${ANSI.red}[expired]${ANSI.reset}`;
+      return ` ${ANSI.red}[expired]${ANSI.reset}`;
     case "verification-required":
-      return `${ANSI.red}[needs verification]${ANSI.reset}`;
+      return ` ${ANSI.red}[needs verification]${ANSI.reset}`;
     default:
       return "";
   }
@@ -1606,22 +1741,25 @@ async function showAuthMenu(accounts) {
   const items = [
     { label: "Actions", value: { type: "cancel" }, kind: "heading" },
     { label: "Add account", value: { type: "add" }, color: "cyan" },
+    { label: "Auth current", value: { type: "current" }, color: "cyan" },
     { label: "Check quotas", value: { type: "check" }, color: "cyan" },
+    { label: "Repair auth", value: { type: "repair" }, color: "yellow" },
+    { label: "Auth doctor", value: { type: "doctor" }, color: "cyan" },
     { label: "Verify one account", value: { type: "verify" }, color: "cyan" },
     { label: "Verify all accounts", value: { type: "verify-all" }, color: "cyan" },
     { label: "Configure models in opencode.json", value: { type: "configure-models" }, color: "cyan" },
     { label: "", value: { type: "cancel" }, separator: true },
     { label: "Accounts", value: { type: "cancel" }, kind: "heading" },
     ...accounts.map((account) => {
-      const statusBadge = getStatusBadge(account.status);
+      const statusBadge = getStatusBadge(account.status, account);
       const currentBadge = account.isCurrentAccount ? ` ${ANSI.cyan}[current]${ANSI.reset}` : "";
       const disabledBadge = account.enabled === false ? ` ${ANSI.red}[disabled]${ANSI.reset}` : "";
       const baseLabel = account.email || `Account ${account.index + 1}`;
       const numbered = `${account.index + 1}. ${baseLabel}`;
-      const fullLabel = `${numbered}${currentBadge}${statusBadge ? " " + statusBadge : ""}${disabledBadge}`;
+      const fullLabel = `${numbered}${currentBadge}${statusBadge}${disabledBadge}`;
       return {
         label: fullLabel,
-        hint: account.lastUsed ? `used ${formatRelativeTime(account.lastUsed)}` : "",
+        hint: account.quotaSummary ?? (account.lastUsed ? `used ${formatRelativeTime(account.lastUsed)}` : ""),
         value: { type: "select-account", account }
       };
     }),
@@ -1643,23 +1781,69 @@ async function showAuthMenu(accounts) {
     return result;
   }
 }
+function formatFingerprintReason(reason) {
+  switch (reason) {
+    case "initial":
+      return "initial";
+    case "regenerated":
+      return "regenerated";
+    case "restored":
+      return "restored";
+  }
+}
+async function showFingerprintHistory(history, accountLabel) {
+  const items = [
+    { label: "Back", value: null },
+    { label: "", value: null, separator: true },
+    { label: "Fingerprint history", value: null, kind: "heading" },
+    ...history.map((entry, index) => {
+      const deviceShort = entry.deviceId.slice(0, 8);
+      const reasonBadge = `${ANSI.dim}[${formatFingerprintReason(entry.reason)}]${ANSI.reset}`;
+      const label = `${index + 1}. ${deviceShort}... ${reasonBadge}`;
+      const hint = formatRelativeTime(entry.timestamp);
+      return {
+        label,
+        hint,
+        value: index,
+        color: "cyan"
+      };
+    })
+  ];
+  const result = await select(items, {
+    message: `Restore fingerprint \u2014 ${accountLabel}`,
+    subtitle: "Select a previous fingerprint to restore",
+    clearScreen: true
+  });
+  return result ?? null;
+}
 async function showAccountDetails(account) {
   const label = account.email || `Account ${account.index + 1}`;
-  const badge = getStatusBadge(account.status);
+  const badge = getStatusBadge(account.status, account);
   const disabledBadge = account.enabled === false ? ` ${ANSI.red}[disabled]${ANSI.reset}` : "";
-  const header = `${label}${badge ? " " + badge : ""}${disabledBadge}`;
+  const header = `${label}${badge}${disabledBadge}`;
   const subtitleParts = [
     `Added: ${formatDate(account.addedAt)}`,
     `Last used: ${formatRelativeTime(account.lastUsed)}`
   ];
+  const hasHistory = (account.fingerprintHistory?.length ?? 0) > 0;
   while (true) {
-    const result = await select([
+    const menuItems = [
       { label: "Back", value: "back" },
       { label: "Verify account access", value: "verify", color: "cyan" },
       { label: account.enabled === false ? "Enable account" : "Disable account", value: "toggle", color: account.enabled === false ? "green" : "yellow" },
-      { label: "Refresh token", value: "refresh", color: "cyan" },
+      { label: "Refresh token", value: "refresh", color: "cyan" }
+    ];
+    if (hasHistory) {
+      menuItems.push({
+        label: `Restore fingerprint (${account.fingerprintHistory.length} saved)`,
+        value: "restore-fingerprint",
+        color: "cyan"
+      });
+    }
+    menuItems.push(
       { label: "Delete this account", value: "delete", color: "red" }
-    ], {
+    );
+    const result = await select(menuItems, {
       message: header,
       subtitle: subtitleParts.join(" | "),
       clearScreen: true
@@ -1681,12 +1865,14 @@ import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync
 import { join as join3, dirname as dirname2 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 
-// src/plugin/config/models.ts
+// src/plugin/model-registry.ts
 var DEFAULT_MODALITIES = {
   input: ["text", "image", "pdf"],
   output: ["text"]
 };
 var MODEL_RELEASE_DATE = "";
+var DEFAULT_COST = { input: 0, output: 0 };
+var DEFAULT_OPTIONS = {};
 function defineModel(id, model) {
   return {
     id,
@@ -1694,10 +1880,12 @@ function defineModel(id, model) {
     attachment: model.modalities.input.some((modality) => modality !== "text"),
     temperature: true,
     tool_call: true,
+    cost: { ...DEFAULT_COST },
+    options: { ...DEFAULT_OPTIONS },
     ...model
   };
 }
-var OPENCODE_MODEL_DEFINITIONS = {
+var PUBLIC_MODEL_DEFINITIONS = {
   "antigravity-gemini-3.1-pro": defineModel("antigravity-gemini-3.1-pro", {
     name: "Gemini 3.1 Pro (Antigravity)",
     reasoning: true,
@@ -1796,6 +1984,63 @@ var OPENCODE_MODEL_DEFINITIONS = {
     modalities: DEFAULT_MODALITIES
   })
 };
+var RESOLVER_ALIASES = {
+  "gemini-3.1-pro-low": "gemini-3.1-pro",
+  "gemini-3.1-pro-high": "gemini-3.1-pro",
+  "gemini-3-flash-low": "gemini-3-flash",
+  "gemini-3-flash-medium": "gemini-3-flash",
+  "gemini-3-flash-high": "gemini-3-flash",
+  "gemini-3.5-flash-low": "gemini-3.5-flash",
+  "gemini-3.5-flash-medium": "gemini-3.5-flash",
+  "gemini-3.5-flash-high": "gemini-3.5-flash",
+  "gemini-claude-opus-4-6-thinking-low": "claude-opus-4-6-thinking",
+  "gemini-claude-opus-4-6-thinking-medium": "claude-opus-4-6-thinking",
+  "gemini-claude-opus-4-6-thinking-high": "claude-opus-4-6-thinking",
+  "gemini-claude-sonnet-4-6-thinking-low": "claude-sonnet-4-6-thinking",
+  "gemini-claude-sonnet-4-6-thinking-medium": "claude-sonnet-4-6-thinking",
+  "gemini-claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6-thinking",
+  "gemini-claude-sonnet-4-6": "claude-sonnet-4-6-thinking"
+};
+var GEMINI_35_FLASH_ROUTES = {
+  antigravity: {
+    defaultModel: "gemini-3-flash-agent",
+    byTier: {
+      low: "gemini-3.5-flash-low",
+      medium: "gemini-3.5-flash-low",
+      high: "gemini-3-flash-agent"
+    }
+  },
+  geminiCliFallbackModel: "gemini-3-flash-preview"
+};
+var QUOTA_GROUP_BY_MODEL_ID = {
+  "claude-opus-4-6-thinking": "claude",
+  "claude-opus-4-6": "claude",
+  "claude-sonnet-4-6-thinking": "claude",
+  "claude-sonnet-4-6": "claude",
+  "gemini-pro-agent": "gemini-pro",
+  "gemini-3.1-pro": "gemini-pro",
+  "gemini-3.1-pro-low": "gemini-pro",
+  "gemini-3.1-pro-high": "gemini-pro",
+  "gemini-3-flash": "gemini-flash",
+  "gemini-3-flash-agent": "gemini-flash",
+  "gemini-3.5-flash-low": "gemini-flash"
+};
+var OPENCODE_MODEL_DEFINITIONS = PUBLIC_MODEL_DEFINITIONS;
+function getResolverAliasMap() {
+  return RESOLVER_ALIASES;
+}
+function getGemini35FlashAntigravityModel(tier) {
+  if (!tier) {
+    return GEMINI_35_FLASH_ROUTES.antigravity.defaultModel;
+  }
+  return GEMINI_35_FLASH_ROUTES.antigravity.byTier[tier] ?? GEMINI_35_FLASH_ROUTES.antigravity.defaultModel;
+}
+function getGemini35FlashGeminiCliFallbackModel() {
+  return GEMINI_35_FLASH_ROUTES.geminiCliFallbackModel;
+}
+function getQuotaGroupForModel(modelId) {
+  return QUOTA_GROUP_BY_MODEL_ID[modelId.toLowerCase()];
+}
 
 // src/plugin/config/updater.ts
 var PLUGIN_NAME = "@expiren/opencode-antigravity-auth@latest";
@@ -1906,7 +2151,7 @@ ${existingAccounts.length} account(s) saved:`);
     }
     console.log("");
     while (true) {
-      const answer = await rl.question("(a)dd new, (f)resh start, (c)heck quotas, (v)erify account, (va) verify all? [a/f/c/v/va]: ");
+      const answer = await rl.question("(a)dd new, (f)resh start, (c)heck quotas, auth (d)octor, (v)erify account, (va) verify all? [a/f/c/d/v/va]: ");
       const normalized = answer.trim().toLowerCase();
       if (normalized === "a" || normalized === "add") {
         return { mode: "add" };
@@ -1917,13 +2162,16 @@ ${existingAccounts.length} account(s) saved:`);
       if (normalized === "c" || normalized === "check") {
         return { mode: "check" };
       }
+      if (normalized === "d" || normalized === "doctor" || normalized === "auth-doctor") {
+        return { mode: "doctor" };
+      }
       if (normalized === "v" || normalized === "verify") {
         return { mode: "verify" };
       }
       if (normalized === "va" || normalized === "verify-all" || normalized === "all") {
         return { mode: "verify-all", verifyAll: true };
       }
-      console.log("Please enter 'a', 'f', 'c', 'v', or 'va'.");
+      console.log("Please enter 'a', 'f', 'c', 'd', 'v', or 'va'.");
     }
   } finally {
     rl.close();
@@ -1940,7 +2188,12 @@ async function promptLoginMode(existingAccounts) {
     lastUsed: acc.lastUsed,
     status: acc.status,
     isCurrentAccount: acc.isCurrentAccount,
-    enabled: acc.enabled
+    enabled: acc.enabled,
+    quotaSummary: acc.quotaSummary,
+    cooldownMs: acc.cooldownMs,
+    cooldownReason: acc.cooldownReason,
+    cachedQuota: acc.cachedQuota,
+    fingerprintHistory: acc.fingerprintHistory
   }));
   console.log("");
   while (true) {
@@ -1950,6 +2203,12 @@ async function promptLoginMode(existingAccounts) {
         return { mode: "add" };
       case "check":
         return { mode: "check" };
+      case "doctor":
+        return { mode: "doctor" };
+      case "repair":
+        return { mode: "repair" };
+      case "current":
+        return { mode: "current" };
       case "verify":
         return { mode: "verify" };
       case "verify-all":
@@ -1968,6 +2227,18 @@ async function promptLoginMode(existingAccounts) {
         if (accountAction === "verify") {
           return { mode: "verify", verifyAccountIndex: action.account.index };
         }
+        if (accountAction === "restore-fingerprint") {
+          const history = action.account.fingerprintHistory;
+          if (!history || history.length === 0) continue;
+          const accountLabel = action.account.email || `Account ${action.account.index + 1}`;
+          const historyIndex = await showFingerprintHistory(history, accountLabel);
+          if (historyIndex === null) continue;
+          return {
+            mode: "restore-fingerprint",
+            restoreFingerprintAccountIndex: action.account.index,
+            restoreFingerprintHistoryIndex: historyIndex
+          };
+        }
         continue;
       }
       case "delete-all":
@@ -2750,9 +3021,9 @@ var AntigravityConfigSchema = z2.object({
    * When false: Only shows toast notification, user must manually continue.
    * When true: Automatically sends "continue" to resume the session.
    * 
-   * @default false
+   * @default true
    */
-  auto_resume: z2.boolean().default(false),
+  auto_resume: z2.boolean().default(true),
   /**
    * Custom text to send when auto-resuming after recovery.
    * Only used when auto_resume is enabled.
@@ -5762,31 +6033,7 @@ var THINKING_TIER_BUDGETS = {
   "gemini-2.5-flash": { low: 6144, medium: 12288, high: 24576 },
   default: { low: 4096, medium: 8192, high: 16384 }
 };
-var MODEL_ALIASES = {
-  // Gemini 3.x variants - for Gemini CLI only (tier stripped, thinkingLevel used)
-  // For Antigravity, these are bypassed and full model name is kept
-  "gemini-3.1-pro-low": "gemini-3.1-pro",
-  "gemini-3.1-pro-high": "gemini-3.1-pro",
-  "gemini-3-flash-low": "gemini-3-flash",
-  "gemini-3-flash-medium": "gemini-3-flash",
-  "gemini-3-flash-high": "gemini-3-flash",
-  // Gemini 3.5 Flash variants
-  "gemini-3.5-flash-low": "gemini-3.5-flash",
-  "gemini-3.5-flash-medium": "gemini-3.5-flash",
-  "gemini-3.5-flash-high": "gemini-3.5-flash",
-  // Claude proxy names (gemini- prefix for compatibility)
-  "gemini-claude-opus-4-6-thinking-low": "claude-opus-4-6-thinking",
-  "gemini-claude-opus-4-6-thinking-medium": "claude-opus-4-6-thinking",
-  "gemini-claude-opus-4-6-thinking-high": "claude-opus-4-6-thinking",
-  "gemini-claude-sonnet-4-6-thinking-low": "claude-sonnet-4-6-thinking",
-  "gemini-claude-sonnet-4-6-thinking-medium": "claude-sonnet-4-6-thinking",
-  "gemini-claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6-thinking",
-  "gemini-claude-sonnet-4-6": "claude-sonnet-4-6-thinking"
-  // Image generation models
-  // gemini-3.1-flash-image (Nano Banana 2) - available via Antigravity API and Gemini CLI
-  // gemini-2.5-flash-image (Nano Banana) - NOT supported by Antigravity, only Google AI API
-  // Reference: Antigravity-Manager/src-tauri/src/proxy/common/model_mapping.rs
-};
+var MODEL_ALIASES = getResolverAliasMap();
 var TIER_REGEX = /-(minimal|low|medium|high)$/;
 var QUOTA_PREFIX_REGEX = /^antigravity-/i;
 var GEMINI_3_PRO_REGEX = /^gemini-3(?:\.\d+)?-pro/i;
@@ -5829,7 +6076,7 @@ function isGemini35FlashModel(model) {
   return /^gemini-3\.5-flash/i.test(model);
 }
 function resolveGemini35FlashAntigravityModel(tier) {
-  return tier === "low" || tier === "medium" ? "gemini-3.5-flash-low" : "gemini-3-flash-agent";
+  return getGemini35FlashAntigravityModel(tier);
 }
 function resolveModelWithTier(requestedModel, options = {}) {
   const isAntigravity = QUOTA_PREFIX_REGEX.test(requestedModel);
@@ -5956,7 +6203,7 @@ function resolveModelForHeaderStyle(requestedModel, headerStyle) {
     const hasPreviewSuffix = /-preview($|-)/i.test(transformedModel);
     const isGemini35Flash = isGemini35FlashModel(transformedModel);
     if (isGemini35Flash) {
-      transformedModel = "gemini-3-flash-preview";
+      transformedModel = getGemini35FlashGeminiCliFallbackModel();
     } else if (!hasPreviewSuffix) {
       transformedModel = `${transformedModel}-preview`;
     }
@@ -7539,9 +7786,10 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
     const fingerprintHeaders = buildFingerprintHeaders(fingerprint);
     headers.set("User-Agent", fingerprintHeaders["User-Agent"] || selectedHeaders["User-Agent"]);
   } else {
-    headers.set("User-Agent", GEMINI_CLI_HEADERS["User-Agent"]);
-    headers.set("X-Goog-Api-Client", GEMINI_CLI_HEADERS["X-Goog-Api-Client"]);
-    headers.set("Client-Metadata", GEMINI_CLI_HEADERS["Client-Metadata"]);
+    const geminiCliHeaders = getRandomizedHeaders("gemini-cli", requestedModel);
+    headers.set("User-Agent", geminiCliHeaders["User-Agent"]);
+    if (geminiCliHeaders["X-Goog-Api-Client"]) headers.set("X-Goog-Api-Client", geminiCliHeaders["X-Goog-Api-Client"]);
+    if (geminiCliHeaders["Client-Metadata"]) headers.set("Client-Metadata", geminiCliHeaders["Client-Metadata"]);
   }
   return {
     request: transformedUrl,
@@ -9681,6 +9929,219 @@ async function showLocalDevToast(client, version) {
   logAutoUpdate(`Local dev toast shown: v${version}`);
 }
 
+// src/plugin/auth-drift.ts
+function isAccountEnabled(account) {
+  return account.enabled !== false;
+}
+function selectRestorableAccount(storage) {
+  if (!storage || storage.accounts.length === 0) {
+    return void 0;
+  }
+  const activeAccount = storage.accounts[storage.activeIndex];
+  if (activeAccount && isAccountEnabled(activeAccount)) {
+    return activeAccount;
+  }
+  return storage.accounts.find(isAccountEnabled);
+}
+function buildAuthFromStoredAccount(account) {
+  return {
+    type: "oauth",
+    refresh: formatRefreshParts({
+      refreshToken: account.refreshToken,
+      projectId: account.projectId,
+      managedProjectId: account.managedProjectId
+    }),
+    access: "",
+    expires: 0
+  };
+}
+function detectAuthStorageDrift(auth, storage) {
+  if (!storage || storage.accounts.length === 0) {
+    return {
+      status: "unavailable",
+      reason: "no-account-storage"
+    };
+  }
+  const restorableAccount = selectRestorableAccount(storage);
+  if (!restorableAccount) {
+    return {
+      status: "unavailable",
+      reason: "no-enabled-accounts"
+    };
+  }
+  if (!auth) {
+    return {
+      status: "restorable",
+      reason: "missing-opencode-auth",
+      account: restorableAccount
+    };
+  }
+  if (!isOAuthAuth(auth)) {
+    return {
+      status: "restorable",
+      reason: "non-oauth-opencode-auth",
+      account: restorableAccount
+    };
+  }
+  const authRefreshToken = parseRefreshParts(auth.refresh).refreshToken;
+  const matchedAccount = storage.accounts.find((account) => account.refreshToken === authRefreshToken);
+  if (matchedAccount) {
+    return {
+      status: "healthy",
+      reason: "auth-matches-storage",
+      account: matchedAccount
+    };
+  }
+  return {
+    status: "drifted",
+    reason: "refresh-token-not-in-storage",
+    account: restorableAccount
+  };
+}
+
+// src/plugin/auth-doctor.ts
+function isEnabled(account) {
+  return account.enabled !== false;
+}
+function statusFromFindings(findings) {
+  if (findings.some((finding) => finding.repair && finding.severity === "error")) {
+    return "repairable";
+  }
+  if (findings.some((finding) => finding.severity === "error")) {
+    return "error";
+  }
+  if (findings.some((finding) => finding.severity === "warning")) {
+    return "warning";
+  }
+  return "ok";
+}
+function summaryFromStatus(status) {
+  switch (status) {
+    case "ok":
+      return "OpenCode auth and Antigravity account storage are in sync.";
+    case "repairable":
+      return "Auth drift detected. One or more safe repairs are available.";
+    case "warning":
+      return "Auth is usable, but one or more accounts need attention.";
+    case "error":
+      return "Auth state is not usable and no safe automatic repair is available.";
+  }
+}
+function createAuthDoctorReport(input2) {
+  const findings = [];
+  const drift = detectAuthStorageDrift(input2.auth, input2.storage);
+  switch (drift.reason) {
+    case "auth-matches-storage":
+      findings.push({
+        code: "auth-matches-storage",
+        severity: "info",
+        message: "OpenCode OAuth refresh token exists in Antigravity account storage.",
+        accountEmail: drift.account?.email
+      });
+      break;
+    case "missing-opencode-auth":
+      findings.push({
+        code: "missing-opencode-auth",
+        severity: "error",
+        message: "OpenCode auth.json has no Google OAuth entry, but Antigravity account storage has a restorable account.",
+        repair: "restore-opencode-auth",
+        accountEmail: drift.account?.email
+      });
+      break;
+    case "non-oauth-opencode-auth":
+      findings.push({
+        code: "non-oauth-opencode-auth",
+        severity: "error",
+        message: "OpenCode Google auth is not OAuth, but Antigravity account storage has a restorable OAuth account.",
+        repair: "restore-opencode-auth",
+        accountEmail: drift.account?.email
+      });
+      break;
+    case "refresh-token-not-in-storage":
+      findings.push({
+        code: "refresh-token-not-in-storage",
+        severity: "error",
+        message: "OpenCode Google OAuth refresh token does not match any stored Antigravity account.",
+        repair: "restore-opencode-auth",
+        accountEmail: drift.account?.email
+      });
+      break;
+    case "no-account-storage":
+      findings.push({
+        code: "no-account-storage",
+        severity: "error",
+        message: "No Antigravity account storage was found."
+      });
+      break;
+    case "no-enabled-accounts":
+      findings.push({
+        code: "no-enabled-accounts",
+        severity: "error",
+        message: "Antigravity account storage exists, but all accounts are disabled."
+      });
+      break;
+  }
+  const storage = input2.storage;
+  if (storage && storage.accounts.length > 0) {
+    if (!Number.isInteger(storage.activeIndex) || storage.activeIndex < 0 || storage.activeIndex >= storage.accounts.length) {
+      findings.push({
+        code: "active-index-out-of-range",
+        severity: "error",
+        message: `Active account index ${storage.activeIndex} is outside the stored account range.`,
+        repair: "clamp-active-index"
+      });
+    } else {
+      const activeAccount = storage.accounts[storage.activeIndex];
+      if (activeAccount && !isEnabled(activeAccount) && storage.accounts.some(isEnabled)) {
+        findings.push({
+          code: "active-account-disabled",
+          severity: "error",
+          message: "The active account is disabled while another enabled account is available.",
+          repair: "select-enabled-account",
+          accountEmail: activeAccount.email
+        });
+      }
+    }
+    for (const account of storage.accounts) {
+      if (account.verificationRequired) {
+        findings.push({
+          code: "verification-required",
+          severity: "warning",
+          message: account.verificationRequiredReason ?? "Account requires Google verification before it can be used.",
+          repair: "verify-account",
+          accountEmail: account.email
+        });
+      }
+    }
+  }
+  const status = statusFromFindings(findings);
+  return {
+    status,
+    summary: summaryFromStatus(status),
+    findings,
+    runtime: input2.runtime
+  };
+}
+function formatAuthDoctorReport(report) {
+  const lines = [
+    "Antigravity auth doctor",
+    `Status: ${report.status}`,
+    report.summary,
+    ""
+  ];
+  if (report.runtime) {
+    lines.push(`Antigravity version: ${report.runtime.antigravityVersion} (${report.runtime.antigravityVersionSource})`);
+    lines.push("");
+  }
+  for (const finding of report.findings) {
+    const repair = finding.repair ? ` | repair: ${finding.repair}` : "";
+    const account = finding.accountEmail ? ` | account: ${finding.accountEmail}` : "";
+    lines.push(`- [${finding.severity}] ${finding.code}${account}${repair}`);
+    lines.push(`  ${finding.message}`);
+  }
+  return lines.join("\n");
+}
+
 // src/plugin/quota.ts
 var FETCH_TIMEOUT_MS2 = 1e4;
 function buildAuthFromAccount(account) {
@@ -9712,6 +10173,10 @@ function parseResetTime(resetTime) {
   return timestamp;
 }
 function classifyQuotaGroup(modelName, displayName) {
+  const registryGroup = getQuotaGroupForModel(modelName);
+  if (registryGroup) {
+    return registryGroup;
+  }
   const combined = `${modelName} ${displayName ?? ""}`.toLowerCase();
   if (combined.includes("claude")) {
     return "claude";
@@ -9796,9 +10261,7 @@ async function fetchAvailableModels(accessToken, projectId) {
 }
 async function fetchGeminiCliQuota(accessToken, projectId) {
   const endpoint = ANTIGRAVITY_ENDPOINT_PROD;
-  const platform = process.platform || "darwin";
-  const arch = process.arch || "arm64";
-  const geminiCliUserAgent = `GeminiCLI/1.0.0/gemini-2.5-pro (${platform}; ${arch})`;
+  const geminiCliUserAgent = buildGeminiCliUserAgent();
   const body = projectId ? { project: projectId } : {};
   try {
     const response = await fetchWithTimeout2(`${endpoint}/v1internal:retrieveUserQuota`, {
@@ -10130,6 +10593,7 @@ var CHANGELOG_URL = "https://antigravity.google/changelog";
 var FETCH_TIMEOUT_MS3 = 5e3;
 var CHANGELOG_SCAN_CHARS = 5e3;
 var VERSION_REGEX = /\d+\.\d+\.\d+/;
+var lastResolution = null;
 function parseVersion(text) {
   const match = text.match(VERSION_REGEX);
   return match ? match[0] : null;
@@ -10149,6 +10613,9 @@ async function tryFetchVersion(url, maxChars) {
     clearTimeout(timeout);
   }
 }
+function getAntigravityVersionResolution() {
+  return lastResolution ?? { version: getAntigravityVersion(), source: "fallback" };
+}
 async function initAntigravityVersion() {
   const log11 = createLogger("version");
   const fallback = getAntigravityVersion();
@@ -10165,7 +10632,8 @@ async function initAntigravityVersion() {
       source = "fallback";
       setAntigravityVersion(fallback);
       log11.info("version-fetch-failed", { fallback });
-      return;
+      lastResolution = { version: fallback, source };
+      return lastResolution;
     }
   }
   if (version !== fallback) {
@@ -10174,6 +10642,8 @@ async function initAntigravityVersion() {
     log11.debug("version-unchanged", { version, source });
   }
   setAntigravityVersion(version);
+  lastResolution = { version, source };
+  return lastResolution;
 }
 
 // src/plugin/search.ts
@@ -10966,6 +11436,13 @@ function buildAuthSuccessFromStoredAccount(account) {
     projectId: account.projectId ?? ""
   };
 }
+function formatCachedQuotaSummary(account) {
+  const quota = account.cachedQuota;
+  if (!quota) {
+    return void 0;
+  }
+  return formatCachedQuotaWithStatus(quota);
+}
 function retryAfterMsFromResponse(response, defaultRetryMs = 6e4) {
   const retryAfterMsHeader = response.headers.get("retry-after-ms");
   if (retryAfterMsHeader) {
@@ -11317,7 +11794,33 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
       provider: providerId,
       loader: async (getAuth, provider) => {
         cachedGetAuth = getAuth;
-        const auth = await getAuth();
+        let auth = await getAuth();
+        if (!isOAuthAuth(auth)) {
+          const storedAccounts2 = await loadAccounts();
+          const drift = detectAuthStorageDrift(auth, storedAccounts2);
+          if (drift.status === "restorable" && drift.account) {
+            auth = buildAuthFromStoredAccount(drift.account);
+            try {
+              await client.auth.set({
+                path: { id: providerId },
+                body: {
+                  type: "oauth",
+                  refresh: auth.refresh,
+                  access: auth.access ?? "",
+                  expires: auth.expires ?? 0
+                }
+              });
+              log10.info("Restored Antigravity OAuth auth from account storage", {
+                reason: drift.reason,
+                email: drift.account.email
+              });
+            } catch (storeError) {
+              log10.warn("Failed to restore Antigravity OAuth auth from account storage", {
+                error: String(storeError)
+              });
+            }
+          }
+        }
         if (!isOAuthAuth(auth)) {
           try {
             await clearAccounts();
@@ -12225,7 +12728,8 @@ Alternatively, you can:
                       lastUsed: acc.lastUsed,
                       status,
                       isCurrentAccount: idx === (existingStorage2.activeIndex ?? 0),
-                      enabled: acc.enabled !== false
+                      enabled: acc.enabled !== false,
+                      quotaSummary: formatCachedQuotaSummary(acc)
                     };
                   });
                   menuResult = await promptLoginMode(existingAccounts);
@@ -12294,8 +12798,10 @@ Alternatively, you can:
                           const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
                           const bar = createProgressBar(model.remainingFraction);
                           const reset = formatReset(model.resetTime);
+                          const status = classifyGroupStatus({ remainingFraction: model.remainingFraction, resetTime: model.resetTime, modelCount: 1 });
+                          const badge = formatQuotaStatusBadge(status);
                           const modelName = model.modelId.padEnd(29);
-                          console.log(`  \u2502  ${connector} ${modelName} ${bar}${reset}`);
+                          console.log(`  \u2502  ${connector} ${modelName} ${bar} ${badge}${reset}`);
                         });
                       }
                       const hasAntigravity = res.quota && Object.keys(res.quota.groups).length > 0;
@@ -12316,8 +12822,10 @@ Alternatively, you can:
                           const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
                           const bar = createProgressBar(g.data.remainingFraction);
                           const reset = formatReset(g.data.resetTime);
+                          const status = classifyGroupStatus(g.data);
+                          const badge = formatQuotaStatusBadge(status);
                           const modelName = g.name.padEnd(29);
-                          console.log(`     ${connector} ${modelName} ${bar}${reset}`);
+                          console.log(`     ${connector} ${modelName} ${bar} ${badge}${reset}`);
                         });
                       }
                       console.log("");
@@ -12344,6 +12852,22 @@ Alternatively, you can:
                     console.log("");
                     continue;
                   }
+                  if (menuResult.mode === "doctor") {
+                    const auth = cachedGetAuth ? await cachedGetAuth().catch(() => void 0) : void 0;
+                    const versionResolution = getAntigravityVersionResolution();
+                    const report = createAuthDoctorReport({
+                      auth,
+                      storage: existingStorage2,
+                      runtime: {
+                        antigravityVersion: versionResolution.version,
+                        antigravityVersionSource: versionResolution.source
+                      }
+                    });
+                    console.log(`
+${formatAuthDoctorReport(report)}
+`);
+                    continue;
+                  }
                   if (menuResult.mode === "manage") {
                     if (menuResult.toggleAccountIndex !== void 0) {
                       const acc = existingStorage2.accounts[menuResult.toggleAccountIndex];