@expiren/opencode-antigravity-auth 1.6.17 → 1.6.19

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,78 @@ 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([
-      { label: "Back", value: "back" },
+    const menuItems = [
+      { label: "Back", value: "back" }
+    ];
+    if (!account.isCurrentAccount) {
+      menuItems.push({
+        label: "Switch to this account",
+        value: "switch-account",
+        color: "green"
+      });
+    }
+    menuItems.push(
       { 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 +1874,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 +1889,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 +1993,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 +2160,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 +2171,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 +2197,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 +2212,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 +2236,25 @@ async function promptLoginMode(existingAccounts) {
         if (accountAction === "verify") {
           return { mode: "verify", verifyAccountIndex: action.account.index };
         }
+        if (accountAction === "switch-account") {
+          const accountLabel = action.account.email || `Account ${action.account.index + 1}`;
+          console.log(`
+\u2713 Switched to ${accountLabel}. Restart OpenCode for changes to take effect.
+`);
+          return { mode: "switch-account", switchAccountIndex: 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 +3037,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.
@@ -5316,7 +5603,6 @@ function needsThinkingRecovery(state) {
 
 // src/plugin/transform/claude.ts
 var CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64e3;
-var CLAUDE_INTERLEAVED_THINKING_HINT = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
 function isClaudeModel(model) {
   return model.toLowerCase().includes("claude");
 }
@@ -5324,23 +5610,6 @@ function isClaudeThinkingModel(model) {
   const lower = model.toLowerCase();
   return lower.includes("claude") && lower.includes("thinking");
 }
-function appendClaudeThinkingHint(payload, hint = CLAUDE_INTERLEAVED_THINKING_HINT) {
-  const existing = payload.systemInstruction;
-  if (typeof existing === "string") {
-    payload.systemInstruction = existing.trim().length > 0 ? { role: "user", parts: [{ text: existing }, { text: hint }] } : hint;
-  } else if (existing && typeof existing === "object") {
-    const sys = existing;
-    const partsValue = sys.parts;
-    if (Array.isArray(partsValue)) {
-      sys.parts = [...partsValue, { text: hint }];
-    } else {
-      sys.parts = [{ text: hint }];
-    }
-    payload.systemInstruction = sys;
-  } else if (Array.isArray(payload.contents)) {
-    payload.systemInstruction = { parts: [{ text: hint }] };
-  }
-}
 
 // src/plugin/transform/gemini.ts
 var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
@@ -5762,31 +6031,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 +6074,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 +6201,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`;
     }
@@ -7291,9 +7536,6 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           requestPayload.systemInstruction = requestPayload.system_instruction;
           delete requestPayload.system_instruction;
         }
-        if (isClaudeThinking && Array.isArray(requestPayload.tools) && requestPayload.tools.length > 0) {
-          appendClaudeThinkingHint(requestPayload);
-        }
         const cachedContentFromExtra = typeof requestPayload.extra_body === "object" && requestPayload.extra_body ? requestPayload.extra_body.cached_content ?? requestPayload.extra_body.cachedContent : void 0;
         const cachedContent = requestPayload.cached_content ?? requestPayload.cachedContent ?? cachedContentFromExtra;
         if (cachedContent) {
@@ -7539,9 +7781,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 +9924,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 +10168,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 +10256,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 +10588,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 +10608,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 +10627,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 +10637,8 @@ async function initAntigravityVersion() {
     log11.debug("version-unchanged", { version, source });
   }
   setAntigravityVersion(version);
+  lastResolution = { version, source };
+  return lastResolution;
 }
 
 // src/plugin/search.ts
@@ -10966,6 +11431,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 +11789,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 +12723,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 +12793,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 +12817,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 +12847,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];