@asm-agent/coding-agent 0.9.2 → 0.9.4

package/dist/bundle/{chunk-ZFAQZSZL.js → chunk-GUPU2EEK.js}

@@ -329,7 +329,7 @@ import {
   waitForPromptAdmission,
   watchWithErrorHandler,
   wrapTextWithAnsi
-} from "./chunk-LRHUL5TM.js";
+} from "./chunk-NESKY6T7.js";
 import {
   array,
   boolean,
@@ -354,7 +354,7 @@ import {
 import {
   findEnvKeys,
   getEnvApiKey
-} from "./chunk-6GUVYK6P.js";
+} from "./chunk-EBIKTZ7C.js";
 import {
   getLogger,
   setLogSink,
@@ -7828,6 +7828,373 @@ var anthropicOAuthProvider = {
   }
 };
 
+// ../ai/src/utils/oauth/gemini.ts
+var nodeApis2 = null;
+var nodeApisPromise2 = null;
+var DEFAULT_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+var AUTHORIZE_URL2 = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var CALLBACK_HOST2 = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
+var CALLBACK_PORT2 = Number(process.env.GEMINI_OAUTH_CALLBACK_PORT || process.env.GOOGLE_OAUTH_CALLBACK_PORT || 53694);
+var CALLBACK_PATH2 = "/oauth2callback";
+var REDIRECT_URI2 = `http://localhost:${CALLBACK_PORT2}${CALLBACK_PATH2}`;
+var SCOPES2 = [
+  "https://www.googleapis.com/auth/generative-language",
+  "https://www.googleapis.com/auth/cloud-platform",
+  "openid",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+].join(" ");
+function getClientId() {
+  return process.env.GEMINI_OAUTH_CLIENT_ID || process.env.GOOGLE_OAUTH_CLIENT_ID || DEFAULT_CLIENT_ID;
+}
+function getClientSecret() {
+  return process.env.GEMINI_OAUTH_CLIENT_SECRET || process.env.GOOGLE_OAUTH_CLIENT_SECRET || void 0;
+}
+async function getNodeApis2() {
+  if (nodeApis2) return nodeApis2;
+  if (!nodeApisPromise2) {
+    if (typeof process === "undefined" || !process.versions?.node && !process.versions?.bun) {
+      throw new Error("Gemini OAuth is only available in Node.js environments");
+    }
+    nodeApisPromise2 = import("node:http").then((httpModule) => ({
+      createServer: httpModule.createServer
+    }));
+  }
+  nodeApis2 = await nodeApisPromise2;
+  return nodeApis2;
+}
+function parseAuthorizationInput2(input) {
+  const value = input.trim();
+  if (!value) return {};
+  if (value.startsWith("AIza") || value.startsWith("ya29.") && !value.includes("=") && !value.includes("&")) {
+    return { apiKey: value };
+  }
+  try {
+    const url2 = new URL(value);
+    return {
+      code: url2.searchParams.get("code") ?? void 0,
+      state: url2.searchParams.get("state") ?? void 0
+    };
+  } catch {
+  }
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code, state };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? void 0,
+      state: params.get("state") ?? void 0
+    };
+  }
+  return { code: value };
+}
+function formatErrorDetails2(error) {
+  if (error instanceof Error) {
+    const details = [`${error.name}: ${error.message}`];
+    const errorWithCode = error;
+    if (errorWithCode.code) details.push(`code=${errorWithCode.code}`);
+    if (typeof errorWithCode.errno !== "undefined") details.push(`errno=${String(errorWithCode.errno)}`);
+    if (typeof error.cause !== "undefined") {
+      details.push(`cause=${formatErrorDetails2(error.cause)}`);
+    }
+    if (error.stack) {
+      details.push(`stack=${error.stack}`);
+    }
+    return details.join("; ");
+  }
+  return String(error);
+}
+async function startCallbackServer2(expectedState) {
+  const { createServer: createServer3 } = await getNodeApis2();
+  return new Promise((resolve21, reject) => {
+    let settleWait;
+    const waitForCodePromise = new Promise((resolveWait) => {
+      let settled = false;
+      settleWait = (value) => {
+        if (settled) return;
+        settled = true;
+        resolveWait(value);
+      };
+    });
+    const server = createServer3((req, res) => {
+      try {
+        const url2 = new URL(req.url || "", "http://localhost");
+        if (url2.pathname !== CALLBACK_PATH2 && url2.pathname !== "/callback") {
+          res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Callback route not found."));
+          return;
+        }
+        const code = url2.searchParams.get("code");
+        const state = url2.searchParams.get("state");
+        const error = url2.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Google Gemini authentication did not complete.", `Error: ${error}`));
+          return;
+        }
+        if (!code || !state) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Missing code or state parameter."));
+          return;
+        }
+        if (state !== expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("State mismatch."));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(oauthSuccessHtml("Google Gemini authentication completed. You can close this window."));
+        settleWait?.({ code, state });
+      } catch {
+        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Internal error");
+      }
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+    server.listen(CALLBACK_PORT2, CALLBACK_HOST2, () => {
+      resolve21({
+        server,
+        redirectUri: REDIRECT_URI2,
+        cancelWait: () => {
+          settleWait?.(null);
+        },
+        waitForCode: () => waitForCodePromise
+      });
+    });
+  });
+}
+async function postForm(url2, params) {
+  const body = new URLSearchParams(params);
+  const response = await fetch(url2, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: body.toString(),
+    signal: AbortSignal.timeout(3e4)
+  });
+  const responseBody = await response.text();
+  if (!response.ok) {
+    throw new Error(`HTTP request failed. status=${response.status}; url=${url2}; body=${responseBody}`);
+  }
+  return responseBody;
+}
+async function exchangeAuthorizationCode2(code, verifier, redirectUri) {
+  const clientId = getClientId();
+  const clientSecret = getClientSecret();
+  const payload = {
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  };
+  if (clientSecret) {
+    payload.client_secret = clientSecret;
+  }
+  let responseBody;
+  try {
+    responseBody = await postForm(TOKEN_URL2, payload);
+  } catch (error) {
+    throw new Error(
+      `Token exchange request failed. url=${TOKEN_URL2}; redirect_uri=${redirectUri}; details=${formatErrorDetails2(error)}`
+    );
+  }
+  let tokenData;
+  try {
+    tokenData = JSON.parse(responseBody);
+  } catch (error) {
+    throw new Error(
+      `Token exchange returned invalid JSON. url=${TOKEN_URL2}; body=${responseBody}; details=${formatErrorDetails2(error)}`
+    );
+  }
+  return {
+    access: tokenData.access_token,
+    refresh: tokenData.refresh_token || "",
+    expires: Date.now() + (tokenData.expires_in ?? 3600) * 1e3 - 5 * 60 * 1e3
+  };
+}
+async function loginGemini(options) {
+  const { verifier, challenge } = await generatePKCE();
+  const server = await startCallbackServer2(verifier);
+  let code;
+  let state;
+  let manualApiKey;
+  let redirectUriForExchange = REDIRECT_URI2;
+  try {
+    const clientId = getClientId();
+    const authParams = new URLSearchParams({
+      client_id: clientId,
+      response_type: "code",
+      redirect_uri: REDIRECT_URI2,
+      scope: SCOPES2,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      state: verifier,
+      access_type: "offline",
+      prompt: "consent"
+    });
+    options.onAuth({
+      url: `${AUTHORIZE_URL2}?${authParams.toString()}`,
+      instructions: "Complete login in your browser. If the browser is on another machine, paste the final redirect URL or an API key here."
+    });
+    if (options.onManualCodeInput) {
+      let manualInput;
+      let manualError;
+      const manualPromise = options.onManualCodeInput().then((input) => {
+        manualInput = input;
+        server.cancelWait();
+      }).catch((err) => {
+        manualError = err instanceof Error ? err : new Error(String(err));
+        server.cancelWait();
+      });
+      const result = await server.waitForCode();
+      if (manualError) {
+        throw manualError;
+      }
+      if (result?.code) {
+        code = result.code;
+        state = result.state;
+        redirectUriForExchange = REDIRECT_URI2;
+      } else if (manualInput) {
+        const parsed = parseAuthorizationInput2(manualInput);
+        if (parsed.apiKey) {
+          manualApiKey = parsed.apiKey;
+        } else {
+          if (parsed.state && parsed.state !== verifier) {
+            throw new Error("OAuth state mismatch");
+          }
+          code = parsed.code;
+          state = parsed.state ?? verifier;
+        }
+      }
+      if (!code && !manualApiKey) {
+        await manualPromise;
+        if (manualError) {
+          throw manualError;
+        }
+        if (manualInput) {
+          const parsed = parseAuthorizationInput2(manualInput);
+          if (parsed.apiKey) {
+            manualApiKey = parsed.apiKey;
+          } else {
+            if (parsed.state && parsed.state !== verifier) {
+              throw new Error("OAuth state mismatch");
+            }
+            code = parsed.code;
+            state = parsed.state ?? verifier;
+          }
+        }
+      }
+    } else {
+      const result = await server.waitForCode();
+      if (result?.code) {
+        code = result.code;
+        state = result.state;
+        redirectUriForExchange = REDIRECT_URI2;
+      }
+    }
+    if (!code && !manualApiKey) {
+      const input = await options.onPrompt({
+        message: "Paste the authorization code, redirect URL, or Gemini API key:",
+        placeholder: REDIRECT_URI2
+      });
+      const parsed = parseAuthorizationInput2(input);
+      if (parsed.apiKey) {
+        manualApiKey = parsed.apiKey;
+      } else {
+        if (parsed.state && parsed.state !== verifier) {
+          throw new Error("OAuth state mismatch");
+        }
+        code = parsed.code;
+        state = parsed.state ?? verifier;
+      }
+    }
+    if (manualApiKey) {
+      return {
+        access: manualApiKey,
+        refresh: "",
+        expires: Date.now() + 365 * 24 * 60 * 60 * 1e3
+      };
+    }
+    if (!code) {
+      throw new Error("Missing authorization code");
+    }
+    if (!state) {
+      throw new Error("Missing OAuth state");
+    }
+    options.onProgress?.("Exchanging authorization code for tokens...");
+    return exchangeAuthorizationCode2(code, verifier, redirectUriForExchange);
+  } finally {
+    server.server.close();
+  }
+}
+async function refreshGeminiToken(refreshToken) {
+  if (!refreshToken) {
+    throw new Error("No refresh token available for Google Gemini");
+  }
+  const clientId = getClientId();
+  const clientSecret = getClientSecret();
+  const payload = {
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: refreshToken
+  };
+  if (clientSecret) {
+    payload.client_secret = clientSecret;
+  }
+  let responseBody;
+  try {
+    responseBody = await postForm(TOKEN_URL2, payload);
+  } catch (error) {
+    throw new Error(
+      `Google Gemini token refresh request failed. url=${TOKEN_URL2}; details=${formatErrorDetails2(error)}`
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(responseBody);
+  } catch (error) {
+    throw new Error(
+      `Google Gemini token refresh returned invalid JSON. url=${TOKEN_URL2}; body=${responseBody}; details=${formatErrorDetails2(error)}`
+    );
+  }
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: Date.now() + (data.expires_in ?? 3600) * 1e3 - 5 * 60 * 1e3
+  };
+}
+var geminiOAuthProvider = {
+  id: "google",
+  name: "Google Gemini",
+  usesCallbackServer: true,
+  async login(callbacks) {
+    return loginGemini({
+      onAuth: callbacks.onAuth,
+      onPrompt: callbacks.onPrompt,
+      onProgress: callbacks.onProgress,
+      onManualCodeInput: callbacks.onManualCodeInput
+    });
+  },
+  async refreshToken(credentials) {
+    if (!credentials.refresh) {
+      return credentials;
+    }
+    return refreshGeminiToken(credentials.refresh);
+  },
+  getApiKey(credentials) {
+    return credentials.access;
+  }
+};
+var googleOAuthProvider = geminiOAuthProvider;
+
 // ../ai/src/utils/oauth/github-copilot.ts
 var decode2 = (s) => atob(s);
 var CLIENT_ID2 = decode2("SXYxLmI1MDdhMDhjODdlY2ZlOTg=");
@@ -8100,11 +8467,11 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
     _http = m;
   });
 }
-var CALLBACK_HOST2 = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
+var CALLBACK_HOST3 = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
 var CLIENT_ID3 = "app_EMoamEEZ73f0CkXaXp7hrann";
-var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
-var TOKEN_URL2 = "https://auth.openai.com/oauth/token";
-var REDIRECT_URI2 = "http://localhost:1455/auth/callback";
+var AUTHORIZE_URL3 = "https://auth.openai.com/oauth/authorize";
+var TOKEN_URL3 = "https://auth.openai.com/oauth/token";
+var REDIRECT_URI3 = "http://localhost:1455/auth/callback";
 var SCOPE = "openid profile email offline_access";
 var JWT_CLAIM_PATH = "https://api.openai.com/auth";
 function createState() {
@@ -8113,7 +8480,7 @@ function createState() {
   }
   return _randomBytes(16).toString("hex");
 }
-function parseAuthorizationInput2(input) {
+function parseAuthorizationInput3(input) {
   const value = input.trim();
   if (!value) return {};
   try {
@@ -8148,8 +8515,8 @@ function decodeJwt(token) {
     return null;
   }
 }
-async function exchangeAuthorizationCode2(code, verifier, redirectUri = REDIRECT_URI2) {
-  const response = await fetch(TOKEN_URL2, {
+async function exchangeAuthorizationCode3(code, verifier, redirectUri = REDIRECT_URI3) {
+  const response = await fetch(TOKEN_URL3, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
     body: new URLSearchParams({
@@ -8184,7 +8551,7 @@ async function exchangeAuthorizationCode2(code, verifier, redirectUri = REDIRECT
 }
 async function refreshAccessToken(refreshToken) {
   try {
-    const response = await fetch(TOKEN_URL2, {
+    const response = await fetch(TOKEN_URL3, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({
@@ -8224,10 +8591,10 @@ async function refreshAccessToken(refreshToken) {
 async function createAuthorizationFlow(originator = "pi") {
   const { verifier, challenge } = await generatePKCE();
   const state = createState();
-  const url2 = new URL(AUTHORIZE_URL2);
+  const url2 = new URL(AUTHORIZE_URL3);
   url2.searchParams.set("response_type", "code");
   url2.searchParams.set("client_id", CLIENT_ID3);
-  url2.searchParams.set("redirect_uri", REDIRECT_URI2);
+  url2.searchParams.set("redirect_uri", REDIRECT_URI3);
   url2.searchParams.set("scope", SCOPE);
   url2.searchParams.set("code_challenge", challenge);
   url2.searchParams.set("code_challenge_method", "S256");
@@ -8283,7 +8650,7 @@ function startLocalOAuthServer(state) {
     }
   });
   return new Promise((resolve21) => {
-    server.listen(1455, CALLBACK_HOST2, () => {
+    server.listen(1455, CALLBACK_HOST3, () => {
       resolve21({
         close: () => server.close(),
         cancelWait: () => {
@@ -8336,7 +8703,7 @@ async function loginOpenAICodex(options) {
       if (result?.code) {
         code = result.code;
       } else if (manualCode) {
-        const parsed = parseAuthorizationInput2(manualCode);
+        const parsed = parseAuthorizationInput3(manualCode);
         if (parsed.state && parsed.state !== state) {
           throw new Error("State mismatch");
         }
@@ -8348,7 +8715,7 @@ async function loginOpenAICodex(options) {
           throw manualError;
         }
         if (manualCode) {
-          const parsed = parseAuthorizationInput2(manualCode);
+          const parsed = parseAuthorizationInput3(manualCode);
           if (parsed.state && parsed.state !== state) {
             throw new Error("State mismatch");
           }
@@ -8365,7 +8732,7 @@ async function loginOpenAICodex(options) {
       const input = await options.onPrompt({
         message: "Paste the authorization code (or full redirect URL):"
       });
-      const parsed = parseAuthorizationInput2(input);
+      const parsed = parseAuthorizationInput3(input);
       if (parsed.state && parsed.state !== state) {
         throw new Error("State mismatch");
       }
@@ -8374,7 +8741,7 @@ async function loginOpenAICodex(options) {
     if (!code) {
       throw new Error("Missing authorization code");
     }
-    const tokenResult = await exchangeAuthorizationCode2(code, verifier);
+    const tokenResult = await exchangeAuthorizationCode3(code, verifier);
     if (tokenResult.type !== "success") {
       throw new Error(tokenResult.message);
     }
@@ -8432,13 +8799,14 @@ var openaiCodexOAuthProvider = {
 var BUILT_IN_OAUTH_PROVIDERS = [
   anthropicOAuthProvider,
   githubCopilotOAuthProvider,
+  geminiOAuthProvider,
   openaiCodexOAuthProvider
 ];
 var oauthProviderRegistry = new Map(
   BUILT_IN_OAUTH_PROVIDERS.map((provider) => [provider.id, provider])
 );
 function getOAuthProvider(id) {
-  return oauthProviderRegistry.get(id);
+  return oauthProviderRegistry.get(id) ?? (id === "gemini" ? oauthProviderRegistry.get("google") : void 0);
 }
 function registerOAuthProvider(provider) {
   oauthProviderRegistry.set(provider.id, provider);
@@ -8495,12 +8863,12 @@ async function getOAuthApiKey(providerId, credentials) {
 }
 
 // ../ai/src/mcp/oauth.ts
-var CALLBACK_HOST3 = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
+var CALLBACK_HOST4 = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
 var CALLBACK_PORT_BASE = Number(process.env.PI_MCP_OAUTH_CALLBACK_PORT || 53700);
 var CALLBACK_PORT_COUNT = 10;
-var CALLBACK_PATH2 = "/callback";
+var CALLBACK_PATH3 = "/callback";
 var CALLBACK_PORTS = Array.from({ length: CALLBACK_PORT_COUNT }, (_2, i) => CALLBACK_PORT_BASE + i);
-var redirectUriFor = (port) => `http://localhost:${port}${CALLBACK_PATH2}`;
+var redirectUriFor = (port) => `http://localhost:${port}${CALLBACK_PATH3}`;
 var ALL_REDIRECT_URIS = CALLBACK_PORTS.map(redirectUriFor);
 var TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
 function validatedHttpsUrl(value, name) {
@@ -8659,7 +9027,7 @@ async function registerClient(registrationEndpoint, label) {
   }
   return data.client_id;
 }
-async function startCallbackServer2(label) {
+async function startCallbackServer3(label) {
   const { createServer: createServer3 } = await import("node:http");
   let settle;
   const waitPromise = new Promise((resolve21) => {
@@ -8673,7 +9041,7 @@ async function startCallbackServer2(label) {
   });
   const handler = (req, res) => {
     const url2 = new URL(req.url || "", "http://localhost");
-    if (url2.pathname !== CALLBACK_PATH2) {
+    if (url2.pathname !== CALLBACK_PATH3) {
       res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
       res.end(oauthErrorHtml("Callback route not found."));
       return;
@@ -8703,7 +9071,7 @@ async function startCallbackServer2(label) {
     try {
       const bound = await new Promise((resolve21) => {
         bindErr = () => resolve21(false);
-        server.listen(port, CALLBACK_HOST3, () => {
+        server.listen(port, CALLBACK_HOST4, () => {
           bindErr = void 0;
           resolve21(true);
         });
@@ -8810,7 +9178,7 @@ function createMcpOAuthProvider(config) {
     const { verifier, challenge } = await generatePKCE();
     const state = randomState();
     const scope = config.scopes ?? meta.scopes_supported?.join(" ");
-    const cb = await startCallbackServer2(label);
+    const cb = await startCallbackServer3(label);
     try {
       const authParams = new URLSearchParams({
         client_id: clientId,
@@ -9821,18 +10189,22 @@ import { createHash } from "node:crypto";
 var oauth_exports = {};
 __export(oauth_exports, {
   anthropicOAuthProvider: () => anthropicOAuthProvider,
+  geminiOAuthProvider: () => geminiOAuthProvider,
   getGitHubCopilotBaseUrl: () => getGitHubCopilotBaseUrl,
   getOAuthApiKey: () => getOAuthApiKey,
   getOAuthProvider: () => getOAuthProvider,
   getOAuthProviderInfoList: () => getOAuthProviderInfoList,
   getOAuthProviders: () => getOAuthProviders,
   githubCopilotOAuthProvider: () => githubCopilotOAuthProvider,
+  googleOAuthProvider: () => googleOAuthProvider,
   loginAnthropic: () => loginAnthropic,
+  loginGemini: () => loginGemini,
   loginGitHubCopilot: () => loginGitHubCopilot,
   loginOpenAICodex: () => loginOpenAICodex,
   normalizeDomain: () => normalizeDomain,
   openaiCodexOAuthProvider: () => openaiCodexOAuthProvider,
   refreshAnthropicToken: () => refreshAnthropicToken,
+  refreshGeminiToken: () => refreshGeminiToken,
   refreshGitHubCopilotToken: () => refreshGitHubCopilotToken,
   refreshOAuthToken: () => refreshOAuthToken,
   refreshOpenAICodexToken: () => refreshOpenAICodexToken,
@@ -10523,7 +10895,7 @@ var AuthStorage = class _AuthStorage {
     };
   }
   getStoredAuthCandidate(provider, options) {
-    const credential = this.data[provider];
+    const credential = this.data[provider] ?? (provider === "google" ? this.data.gemini : provider === "gemini" ? this.data.google : void 0);
     if (!credential) {
       return void 0;
     }
@@ -10747,7 +11119,14 @@ var AuthStorage = class _AuthStorage {
    * Get credential for a provider.
    */
   get(provider) {
-    return this.data[provider] ?? void 0;
+    const direct = this.data[provider];
+    if (direct)
+      return direct;
+    if (provider === "google")
+      return this.data.gemini;
+    if (provider === "gemini")
+      return this.data.google;
+    return void 0;
   }
   /**
    * Set credential for a provider.
@@ -10793,7 +11172,7 @@ var AuthStorage = class _AuthStorage {
    * Check if credentials exist for a provider in auth.json.
    */
   has(provider) {
-    return provider in this.data;
+    return provider in this.data || provider === "google" && "gemini" in this.data || provider === "gemini" && "google" in this.data;
   }
   /**
    * Check if any form of auth is configured for a provider.
@@ -10858,7 +11237,8 @@ var AuthStorage = class _AuthStorage {
       const currentData = this.parseStorageData(current);
       this.data = currentData;
       this.loadError = null;
-      const cred = currentData[providerId];
+      const storageKey = currentData[providerId] ? providerId : providerId === "google" && currentData.gemini ? "gemini" : providerId === "gemini" && currentData.google ? "google" : providerId;
+      const cred = currentData[storageKey];
       if (cred?.type !== "oauth") {
         return { result: null };
       }
@@ -10920,7 +11300,7 @@ var AuthStorage = class _AuthStorage {
         };
       }
     }
-    const cred = this.data[providerId];
+    const cred = this.get(providerId);
     if (cred?.type === "api_key") {
       const storedCandidate = this.getStoredAuthCandidate(providerId);
       if (storedCandidate && !this.isAuthSourceStale(providerId, storedCandidate)) {
@@ -25325,6 +25705,7 @@ var BUILT_IN_PROVIDER_DISPLAY_NAMES = {
   deepseek: "DeepSeek",
   fireworks: "Fireworks",
   google: "Google Gemini",
+  gemini: "Google Gemini",
   "google-vertex": "Google Vertex AI",
   groq: "Groq",
   huggingface: "Hugging Face",
@@ -26068,7 +26449,7 @@ File: ${modelsJsonPath}`);
    * Find a model by provider and ID.
    */
   find(provider, modelId) {
-    return this.models.find((m) => m.provider === provider && m.id === modelId);
+    return this.models.find((m) => m.provider === provider && m.id === modelId) ?? (provider === "gemini" ? this.models.find((m) => m.provider === "google" && m.id === modelId) : void 0);
   }
   /**
    * Get API key for a model.
@@ -26346,6 +26727,14 @@ File: ${modelsJsonPath}`);
       this.setLastProviderAuthSourceToken(provider, authStorageAuth.sourceToken);
       return authStorageAuth.apiKey;
     }
+    if (provider === "google" || provider === "gemini") {
+      const altProvider = provider === "google" ? "gemini" : "google";
+      const altAuth = await this.authStorage.getApiKeyWithSourceToken(altProvider, { includeFallback: false });
+      if (altAuth.apiKey !== void 0) {
+        this.setLastProviderAuthSourceToken(provider, altAuth.sourceToken);
+        return altAuth.apiKey;
+      }
+    }
     const providerApiKey = this.providerRequestConfigs.get(provider)?.apiKey;
     if (!providerApiKey) {
       this.setLastProviderAuthSourceToken(provider, void 0);