@google/gemini-cli-a2a-server 0.16.0-preview.4 → 0.16.0

package/dist/a2a-server.mjs

@@ -295944,8 +295944,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "47642b2e3";
-var CLI_VERSION = "0.16.0-preview.4";
+var GIT_COMMIT_INFO = "56f9e597c";
+var CLI_VERSION = "0.16.0";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -295957,12 +295957,16 @@ var IDE_DEFINITIONS = {
   firebasestudio: { name: "firebasestudio", displayName: "Firebase Studio" },
   trae: { name: "trae", displayName: "Trae" },
   vscode: { name: "vscode", displayName: "VS Code" },
-  vscodefork: { name: "vscodefork", displayName: "IDE" }
+  vscodefork: { name: "vscodefork", displayName: "IDE" },
+  antigravity: { name: "antigravity", displayName: "Antigravity" }
 };
 function isCloudShell() {
   return !!(process.env["EDITOR_IN_CLOUD_SHELL"] || process.env["CLOUD_SHELL"]);
 }
 function detectIdeFromEnv() {
+  if (process.env["ANTIGRAVITY_CLI_ALIAS"]) {
+    return IDE_DEFINITIONS.antigravity;
+  }
   if (process.env["__COG_BASHRC_SOURCED"]) {
     return IDE_DEFINITIONS.devin;
   }
@@ -298790,7 +298794,7 @@ async function createContentGenerator(config2, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version3 = "0.16.0-preview.4";
+    const version3 = "0.16.0";
     const userAgent = `GeminiCLI/${version3} (${process.platform}; ${process.arch})`;
     const baseHeaders = {
       "User-Agent": userAgent
@@ -328902,9 +328906,10 @@ var IdeClient = class _IdeClient {
   removeTrustChangeListener(listener) {
     this.trustChangeListeners.delete(listener);
   }
-  async connect() {
+  async connect(options2 = {}) {
+    const logError2 = options2.logToConsole ?? true;
     if (!this.currentIde) {
-      this.setState(IDEConnectionStatus.Disconnected, `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: VS Code or VS Code forks`, false);
+      this.setState(IDEConnectionStatus.Disconnected, `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: Antigravity, VS Code, or VS Code forks.`, false);
       return;
     }
     this.setState(IDEConnectionStatus.Connecting);
@@ -328915,7 +328920,7 @@ var IdeClient = class _IdeClient {
     const workspacePath = this.connectionConfig?.workspacePath ?? process.env["GEMINI_CLI_IDE_WORKSPACE_PATH"];
     const { isValid: isValid2, error } = _IdeClient.validateWorkspacePath(workspacePath, process.cwd());
     if (!isValid2) {
-      this.setState(IDEConnectionStatus.Disconnected, error, true);
+      this.setState(IDEConnectionStatus.Disconnected, error, logError2);
       return;
     }
     if (this.connectionConfig) {
@@ -328946,7 +328951,7 @@ var IdeClient = class _IdeClient {
         return;
       }
     }
-    this.setState(IDEConnectionStatus.Disconnected, `Failed to connect to IDE companion extension in ${this.currentIde.displayName}. Please ensure the extension is running. To install the extension, run /ide install.`, true);
+    this.setState(IDEConnectionStatus.Disconnected, `Failed to connect to IDE companion extension in ${this.currentIde.displayName}. Please ensure the extension is running. To install the extension, run /ide install.`, logError2);
   }
   /**
    * Opens a diff view in the IDE, allowing the user to review and accept or
@@ -329817,7 +329822,8 @@ function isValidEditorType(editor) {
     "vim",
     "neovim",
     "zed",
-    "emacs"
+    "emacs",
+    "antigravity"
   ].includes(editor);
 }
 function commandExists(cmd) {
@@ -329836,7 +329842,8 @@ var editorCommands = {
   vim: { win32: ["vim"], default: ["vim"] },
   neovim: { win32: ["nvim"], default: ["nvim"] },
   zed: { win32: ["zed"], default: ["zed", "zeditor"] },
-  emacs: { win32: ["emacs.exe"], default: ["emacs"] }
+  emacs: { win32: ["emacs.exe"], default: ["emacs"] },
+  antigravity: { win32: ["agy.cmd"], default: ["agy"] }
 };
 function getDiffCommand(oldPath, newPath, editor) {
   if (!isValidEditorType(editor)) {
@@ -329851,6 +329858,7 @@ function getDiffCommand(oldPath, newPath, editor) {
     case "windsurf":
     case "cursor":
     case "zed":
+    case "antigravity":
       return { command, args: ["--wait", "--diff", oldPath, newPath] };
     case "vim":
     case "neovim":
@@ -330246,13 +330254,39 @@ function fromApiError(errorObj) {
   return outerError;
 }
 
+// packages/core/dist/src/utils/httpErrors.js
+function getErrorStatus(error) {
+  if (typeof error === "object" && error !== null) {
+    if ("status" in error && typeof error.status === "number") {
+      return error.status;
+    }
+    if ("response" in error && typeof error.response === "object" && error.response !== null) {
+      const response = error.response;
+      if ("status" in response && typeof response.status === "number") {
+        return response.status;
+      }
+    }
+  }
+  return void 0;
+}
+var ModelNotFoundError = class extends Error {
+  code;
+  constructor(message, code2) {
+    super(message);
+    this.name = "ModelNotFoundError";
+    this.code = code2 ? code2 : 404;
+  }
+};
+
 // packages/core/dist/src/utils/googleQuotaErrors.js
 var TerminalQuotaError = class extends Error {
   cause;
-  constructor(message, cause) {
+  retryDelayMs;
+  constructor(message, cause, retryDelayMs) {
     super(message);
     this.cause = cause;
     this.name = "TerminalQuotaError";
+    this.retryDelayMs = retryDelayMs ? retryDelayMs * 1e3 : void 0;
   }
 };
 var RetryableQuotaError = class extends Error {
@@ -330278,6 +330312,11 @@ function parseDurationInSeconds(duration) {
 }
 function classifyGoogleError(error) {
   const googleApiError = parseGoogleApiError(error);
+  const status = googleApiError?.code ?? getErrorStatus(error);
+  if (status === 404) {
+    const message = googleApiError?.message || (error instanceof Error ? error.message : "Model not found");
+    return new ModelNotFoundError(message, status);
+  }
   if (!googleApiError || googleApiError.code !== 429) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     const match2 = errorMessage.match(/Please retry in ([0-9.]+(?:ms|s))/);
@@ -330304,6 +330343,13 @@ function classifyGoogleError(error) {
       }
     }
   }
+  let delaySeconds;
+  if (retryInfo?.retryDelay) {
+    const parsedDelay = parseDurationInSeconds(retryInfo.retryDelay);
+    if (parsedDelay) {
+      delaySeconds = parsedDelay;
+    }
+  }
   if (errorInfo) {
     if (errorInfo.domain) {
       const validDomains = [
@@ -330313,17 +330359,10 @@ function classifyGoogleError(error) {
       ];
       if (validDomains.includes(errorInfo.domain)) {
         if (errorInfo.reason === "RATE_LIMIT_EXCEEDED") {
-          let delaySeconds = 10;
-          if (retryInfo?.retryDelay) {
-            const parsedDelay = parseDurationInSeconds(retryInfo.retryDelay);
-            if (parsedDelay) {
-              delaySeconds = parsedDelay;
-            }
-          }
-          return new RetryableQuotaError(`${googleApiError.message}`, googleApiError, delaySeconds);
+          return new RetryableQuotaError(`${googleApiError.message}`, googleApiError, delaySeconds ?? 10);
         }
         if (errorInfo.reason === "QUOTA_EXHAUSTED") {
-          return new TerminalQuotaError(`${googleApiError.message}`, googleApiError);
+          return new TerminalQuotaError(`${googleApiError.message}`, googleApiError, delaySeconds);
         }
       }
     }
@@ -330333,11 +330372,10 @@ function classifyGoogleError(error) {
     }
   }
   if (retryInfo?.retryDelay) {
-    const delaySeconds = parseDurationInSeconds(retryInfo.retryDelay);
     if (delaySeconds) {
       if (delaySeconds > 120) {
         return new TerminalQuotaError(`${googleApiError.message}
-Suggested retry after ${retryInfo.retryDelay}.`, googleApiError);
+Suggested retry after ${retryInfo.retryDelay}.`, googleApiError, delaySeconds);
       }
       return new RetryableQuotaError(`${googleApiError.message}
 Suggested retry after ${retryInfo.retryDelay}.`, googleApiError, delaySeconds);
@@ -330447,7 +330485,8 @@ async function retryWithBackoff(fn, options2) {
         throw error;
       }
       const classifiedError = classifyGoogleError(error);
-      if (classifiedError instanceof TerminalQuotaError) {
+      const errorCode = getErrorStatus(error);
+      if (classifiedError instanceof TerminalQuotaError || classifiedError instanceof ModelNotFoundError) {
         if (onPersistent429 && authType === AuthType2.LOGIN_WITH_GOOGLE) {
           try {
             const fallbackModel = await onPersistent429(authType, classifiedError);
@@ -330462,7 +330501,8 @@ async function retryWithBackoff(fn, options2) {
         }
         throw classifiedError;
       }
-      if (classifiedError instanceof RetryableQuotaError) {
+      const is500 = errorCode !== void 0 && errorCode >= 500 && errorCode < 600;
+      if (classifiedError instanceof RetryableQuotaError || is500) {
         if (attempt >= maxAttempts) {
           if (onPersistent429 && authType === AuthType2.LOGIN_WITH_GOOGLE) {
             try {
@@ -330476,11 +330516,21 @@ async function retryWithBackoff(fn, options2) {
               console.warn("Model fallback failed:", fallbackError);
             }
           }
-          throw classifiedError;
+          throw classifiedError instanceof RetryableQuotaError ? classifiedError : error;
+        }
+        if (classifiedError instanceof RetryableQuotaError) {
+          console.warn(`Attempt ${attempt} failed: ${classifiedError.message}. Retrying after ${classifiedError.retryDelayMs}ms...`);
+          await delay2(classifiedError.retryDelayMs, signal);
+          continue;
+        } else {
+          const errorStatus2 = getErrorStatus(error);
+          logRetryAttempt(attempt, error, errorStatus2);
+          const jitter2 = currentDelay * 0.3 * (Math.random() * 2 - 1);
+          const delayWithJitter2 = Math.max(0, currentDelay + jitter2);
+          await delay2(delayWithJitter2, signal);
+          currentDelay = Math.min(maxDelayMs, currentDelay * 2);
+          continue;
         }
-        console.warn(`Attempt ${attempt} failed: ${classifiedError.message}. Retrying after ${classifiedError.retryDelayMs}ms...`);
-        await delay2(classifiedError.retryDelayMs, signal);
-        continue;
       }
       if (attempt >= maxAttempts || !shouldRetryOnError(error, retryFetchErrors)) {
         throw error;
@@ -330495,20 +330545,6 @@ async function retryWithBackoff(fn, options2) {
   }
   throw new Error("Retry attempts exhausted");
 }
-function getErrorStatus(error) {
-  if (typeof error === "object" && error !== null) {
-    if ("status" in error && typeof error.status === "number") {
-      return error.status;
-    }
-    if ("response" in error && typeof error.response === "object" && error.response !== null) {
-      const response = error.response;
-      if ("status" in response && typeof response.status === "number") {
-        return response.status;
-      }
-    }
-  }
-  return void 0;
-}
 function logRetryAttempt(attempt, error, errorStatus) {
   let message = `Attempt ${attempt} failed. Retrying with backoff...`;
   if (errorStatus) {
@@ -343174,20 +343210,46 @@ My setup is complete. I will provide my first command in the next turn.
 }
 
 // packages/core/dist/src/config/models.js
+var PREVIEW_GEMINI_MODEL = "gemini-3-pro-preview";
 var DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
 var DEFAULT_GEMINI_FLASH_MODEL = "gemini-2.5-flash";
+var DEFAULT_GEMINI_FLASH_LITE_MODEL = "gemini-2.5-flash-lite";
 var DEFAULT_GEMINI_MODEL_AUTO = "auto";
+var GEMINI_MODEL_ALIAS_PRO = "pro";
+var GEMINI_MODEL_ALIAS_FLASH = "flash";
+var GEMINI_MODEL_ALIAS_FLASH_LITE = "flash-lite";
 var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
 var DEFAULT_THINKING_MODE = 8192;
-function getEffectiveModel(isInFallbackMode, requestedModel) {
+function resolveModel(requestedModel, previewFeaturesEnabled) {
+  switch (requestedModel) {
+    case DEFAULT_GEMINI_MODEL_AUTO:
+    case GEMINI_MODEL_ALIAS_PRO: {
+      return previewFeaturesEnabled ? PREVIEW_GEMINI_MODEL : DEFAULT_GEMINI_MODEL;
+    }
+    case GEMINI_MODEL_ALIAS_FLASH: {
+      return DEFAULT_GEMINI_FLASH_MODEL;
+    }
+    case GEMINI_MODEL_ALIAS_FLASH_LITE: {
+      return DEFAULT_GEMINI_FLASH_LITE_MODEL;
+    }
+    default: {
+      return requestedModel;
+    }
+  }
+}
+function getEffectiveModel(isInFallbackMode, requestedModel, previewFeaturesEnabled) {
+  const resolvedModel = resolveModel(requestedModel, previewFeaturesEnabled);
   if (!isInFallbackMode) {
-    return requestedModel;
+    return resolvedModel;
   }
-  if (requestedModel.includes("lite")) {
-    return requestedModel;
+  if (resolvedModel.includes("lite")) {
+    return resolvedModel;
   }
   return DEFAULT_GEMINI_FLASH_MODEL;
 }
+function isGemini2Model(model) {
+  return /^gemini-2(\.|$)/.test(model);
+}
 
 // packages/core/dist/src/utils/generateContentResponseUtilities.js
 function getResponseTextFromParts(parts2) {
@@ -344237,25 +344299,131 @@ var ChatRecordingService = class {
 
 // packages/core/dist/src/fallback/handler.js
 init_events();
+
+// packages/core/dist/src/utils/secure-browser-launcher.js
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify12 } from "node:util";
+import { platform as platform9 } from "node:os";
+import { URL as URL7 } from "node:url";
+var execFileAsync5 = promisify12(execFile6);
+function validateUrl(url4) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL7(url4);
+  } catch (_error) {
+    throw new Error(`Invalid URL: ${url4}`);
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    throw new Error(`Unsafe protocol: ${parsedUrl.protocol}. Only HTTP and HTTPS are allowed.`);
+  }
+  if (/[\r\n\x00-\x1f]/.test(url4)) {
+    throw new Error("URL contains invalid characters");
+  }
+}
+async function openBrowserSecurely(url4) {
+  validateUrl(url4);
+  const platformName = platform9();
+  let command;
+  let args2;
+  switch (platformName) {
+    case "darwin":
+      command = "open";
+      args2 = [url4];
+      break;
+    case "win32":
+      command = "powershell.exe";
+      args2 = [
+        "-NoProfile",
+        "-NonInteractive",
+        "-WindowStyle",
+        "Hidden",
+        "-Command",
+        `Start-Process '${url4.replace(/'/g, "''")}'`
+      ];
+      break;
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+      command = "xdg-open";
+      args2 = [url4];
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platformName}`);
+  }
+  const options2 = {
+    // Don't inherit parent's environment to avoid potential issues
+    env: {
+      ...process.env,
+      // Ensure we're not in a shell that might interpret special characters
+      SHELL: void 0
+    },
+    // Detach the browser process so it doesn't block
+    detached: true,
+    stdio: "ignore"
+  };
+  try {
+    await execFileAsync5(command, args2, options2);
+  } catch (error) {
+    if ((platformName === "linux" || platformName === "freebsd" || platformName === "openbsd") && command === "xdg-open") {
+      const fallbackCommands = [
+        "gnome-open",
+        "kde-open",
+        "firefox",
+        "chromium",
+        "google-chrome"
+      ];
+      for (const fallbackCommand of fallbackCommands) {
+        try {
+          await execFileAsync5(fallbackCommand, [url4], options2);
+          return;
+        } catch {
+          continue;
+        }
+      }
+    }
+    throw new Error(`Failed to open browser: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// packages/core/dist/src/fallback/handler.js
+var UPGRADE_URL_PAGE = "https://goo.gle/set-up-gemini-code-assist";
 async function handleFallback(config2, failedModel, authType, error) {
   if (authType !== AuthType2.LOGIN_WITH_GOOGLE)
     return null;
-  const fallbackModel = DEFAULT_GEMINI_FLASH_MODEL;
+  if (error instanceof ModelNotFoundError && failedModel !== PREVIEW_GEMINI_MODEL) {
+    return null;
+  }
+  if (failedModel === PREVIEW_GEMINI_MODEL) {
+    config2.setPreviewModelBypassMode(true);
+    if (config2.isPreviewModelFallbackMode()) {
+      return true;
+    }
+  }
+  const fallbackModel = failedModel === PREVIEW_GEMINI_MODEL ? DEFAULT_GEMINI_MODEL : DEFAULT_GEMINI_FLASH_MODEL;
   const fallbackModelHandler = config2.fallbackModelHandler;
   if (typeof fallbackModelHandler !== "function")
     return null;
   try {
     const intent = await fallbackModelHandler(failedModel, fallbackModel, error);
     switch (intent) {
-      case "retry":
-        activateFallbackMode(config2, authType);
+      case "retry_always":
+        if (failedModel === PREVIEW_GEMINI_MODEL) {
+          activatePreviewModelFallbackMode(config2);
+        } else {
+          activateFallbackMode(config2, authType);
+        }
         return true;
       // Signal retryWithBackoff to continue.
+      case "retry_once":
+        return true;
       case "stop":
         activateFallbackMode(config2, authType);
         return false;
       case "retry_later":
         return false;
+      case "upgrade":
+        await handleUpgrade();
+        return false;
       default:
         throw new Error(`Unexpected fallback intent received from fallbackModelHandler: "${intent}"`);
     }
@@ -344264,6 +344432,13 @@ async function handleFallback(config2, failedModel, authType, error) {
     return null;
   }
 }
+async function handleUpgrade() {
+  try {
+    await openBrowserSecurely(UPGRADE_URL_PAGE);
+  } catch (error) {
+    debugLogger.warn("Failed to open browser automatically:", getErrorMessage(error));
+  }
+}
 function activateFallbackMode(config2, authType) {
   if (!config2.isInFallbackMode()) {
     config2.setFallbackMode(true);
@@ -344273,6 +344448,11 @@ function activateFallbackMode(config2, authType) {
     }
   }
 }
+function activatePreviewModelFallbackMode(config2) {
+  if (!config2.isPreviewModelFallbackMode()) {
+    config2.setPreviewModelFallbackMode(true);
+  }
+}
 
 // packages/core/dist/src/core/geminiRequest.js
 function partListUnionToString(value) {
@@ -344290,6 +344470,7 @@ var INVALID_CONTENT_RETRY_OPTIONS = {
   // 1 initial call + 1 retry
   initialDelayMs: 500
 };
+var SYNTHETIC_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
 function isValidResponse2(response) {
   if (response.candidates === void 0 || response.candidates.length === 0) {
     return false;
@@ -344407,6 +344588,7 @@ var GeminiChat = class {
    */
   async sendMessageStream(model, params, prompt_id) {
     await this.sendPromise;
+    this.config.setPreviewModelBypassMode(false);
     let streamDoneResolver;
     const streamDonePromise = new Promise((resolve14) => {
       streamDoneResolver = resolve14;
@@ -344428,7 +344610,11 @@ var GeminiChat = class {
     return async function* () {
       try {
         let lastError = new Error("Request failed after all retries.");
-        for (let attempt = 0; attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
+        let maxAttempts = INVALID_CONTENT_RETRY_OPTIONS.maxAttempts;
+        if (self2.config.isPreviewModelFallbackMode() && model === PREVIEW_GEMINI_MODEL) {
+          maxAttempts = 1;
+        }
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
           try {
             if (attempt > 0) {
               yield { type: StreamEventType.RETRY };
@@ -344449,8 +344635,8 @@ var GeminiChat = class {
           } catch (error) {
             lastError = error;
             const isContentError = error instanceof InvalidStreamError;
-            if (isContentError) {
-              if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
+            if (isContentError && isGemini2Model(model)) {
+              if (attempt < maxAttempts - 1) {
                 logContentRetry(self2.config, new ContentRetryEvent(attempt, error.type, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs, model));
                 await new Promise((res) => setTimeout(res, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs * (attempt + 1)));
                 continue;
@@ -344460,10 +344646,14 @@ var GeminiChat = class {
           }
         }
         if (lastError) {
-          if (lastError instanceof InvalidStreamError) {
-            logContentRetryFailure(self2.config, new ContentRetryFailureEvent(INVALID_CONTENT_RETRY_OPTIONS.maxAttempts, lastError.type, model));
+          if (lastError instanceof InvalidStreamError && isGemini2Model(model)) {
+            logContentRetryFailure(self2.config, new ContentRetryFailureEvent(maxAttempts, lastError.type, model));
           }
           throw lastError;
+        } else {
+          if (model === PREVIEW_GEMINI_MODEL && !self2.config.isPreviewModelBypassMode()) {
+            self2.config.setPreviewModelFallbackMode(false);
+          }
         }
       } finally {
         streamDoneResolver();
@@ -344471,23 +344661,27 @@ var GeminiChat = class {
     }();
   }
   async makeApiCallAndProcessStream(model, requestContents, params, prompt_id) {
+    let effectiveModel = model;
+    const contentsForPreviewModel = this.ensureActiveLoopHasThoughtSignatures(requestContents);
     const apiCall = () => {
-      const modelToUse = getEffectiveModel(this.config.isInFallbackMode(), model);
-      if (this.config.getQuotaErrorOccurred() && modelToUse === DEFAULT_GEMINI_FLASH_MODEL) {
-        throw new Error("Please submit a new query to continue with the Flash model.");
+      let modelToUse = getEffectiveModel(this.config.isInFallbackMode(), model, this.config.getPreviewFeatures());
+      if (this.config.isPreviewModelBypassMode() && modelToUse === PREVIEW_GEMINI_MODEL) {
+        modelToUse = DEFAULT_GEMINI_MODEL;
       }
+      effectiveModel = modelToUse;
       return this.config.getContentGenerator().generateContentStream({
         model: modelToUse,
-        contents: requestContents,
+        contents: modelToUse === PREVIEW_GEMINI_MODEL ? contentsForPreviewModel : requestContents,
         config: { ...this.generationConfig, ...params.config }
       }, prompt_id);
     };
-    const onPersistent429Callback = async (authType, error) => await handleFallback(this.config, model, authType, error);
+    const onPersistent429Callback = async (authType, error) => await handleFallback(this.config, effectiveModel, authType, error);
     const streamResponse = await retryWithBackoff(apiCall, {
       onPersistent429: onPersistent429Callback,
       authType: this.config.getContentGeneratorConfig()?.authType,
       retryFetchErrors: this.config.getRetryFetchErrors(),
-      signal: params.config?.abortSignal
+      signal: params.config?.abortSignal,
+      maxAttempts: this.config.isPreviewModelFallbackMode() && model === PREVIEW_GEMINI_MODEL ? 1 : void 0
     });
     return this.processStreamResponse(model, streamResponse);
   }
@@ -344549,6 +344743,46 @@ var GeminiChat = class {
       return newContent;
     });
   }
+  // To ensure our requests validate, the first function call in every model
+  // turn within the active loop must have a `thoughtSignature` property.
+  // If we do not do this, we will get back 400 errors from the API.
+  ensureActiveLoopHasThoughtSignatures(requestContents) {
+    let activeLoopStartIndex = -1;
+    for (let i3 = requestContents.length - 1; i3 >= 0; i3--) {
+      const content = requestContents[i3];
+      if (content.role === "user" && content.parts?.some((part) => part.text)) {
+        activeLoopStartIndex = i3;
+        break;
+      }
+    }
+    if (activeLoopStartIndex === -1) {
+      return requestContents;
+    }
+    const newContents = requestContents.slice();
+    for (let i3 = activeLoopStartIndex; i3 < newContents.length; i3++) {
+      const content = newContents[i3];
+      if (content.role === "model" && content.parts) {
+        const newParts = content.parts.slice();
+        for (let j = 0; j < newParts.length; j++) {
+          const part = newParts[j];
+          if (part.functionCall) {
+            if (!part.thoughtSignature) {
+              newParts[j] = {
+                ...part,
+                thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE
+              };
+              newContents[i3] = {
+                ...content,
+                parts: newParts
+              };
+            }
+            break;
+          }
+        }
+      }
+    }
+    return newContents;
+  }
   setTools(tools) {
     this.generationConfig.tools = tools;
   }
@@ -346037,7 +346271,7 @@ var ChatCompressionService = class {
 
 // packages/core/dist/src/core/client.js
 function isThinkingSupported(model) {
-  return model.startsWith("gemini-2.5") || model === DEFAULT_GEMINI_MODEL_AUTO;
+  return model.startsWith("gemini-2.5") || model.startsWith("gemini-3") || model === DEFAULT_GEMINI_MODEL_AUTO;
 }
 var MAX_TURNS = 100;
 var GeminiClient = class {
@@ -346292,8 +346526,7 @@ var GeminiClient = class {
       return this.currentSequenceModel;
     }
     const configModel = this.config.getModel();
-    const model = configModel === DEFAULT_GEMINI_MODEL_AUTO ? DEFAULT_GEMINI_MODEL : configModel;
-    return getEffectiveModel(this.config.isInFallbackMode(), model);
+    return getEffectiveModel(this.config.isInFallbackMode(), configModel, this.config.getPreviewFeatures());
   }
   async *sendMessageStream(request3, signal, prompt_id, turns = MAX_TURNS, isInvalidStreamRetry = false) {
     if (this.lastPromptId !== prompt_id) {
@@ -351482,7 +351715,7 @@ var ClassifierResponseSchema = external_exports.object({
 });
 var ClassifierStrategy = class {
   name = "classifier";
-  async route(context2, _config, baseLlmClient) {
+  async route(context2, config2, baseLlmClient) {
     const startTime = Date.now();
     try {
       let promptId = promptIdContext.getStore();
@@ -351506,7 +351739,7 @@ var ClassifierStrategy = class {
       const latencyMs = Date.now() - startTime;
       if (routerResponse.model_choice === FLASH_MODEL) {
         return {
-          model: DEFAULT_GEMINI_FLASH_MODEL,
+          model: resolveModel(GEMINI_MODEL_ALIAS_FLASH, config2.getPreviewFeatures()),
           metadata: {
             source: "Classifier",
             latencyMs,
@@ -351515,7 +351748,7 @@ var ClassifierStrategy = class {
         };
       } else {
         return {
-          model: DEFAULT_GEMINI_MODEL,
+          model: resolveModel(GEMINI_MODEL_ALIAS_PRO, config2.getPreviewFeatures()),
           metadata: {
             source: "Classifier",
             reasoning,
@@ -351592,7 +351825,7 @@ var FallbackStrategy = class {
     if (!isInFallbackMode) {
       return null;
     }
-    const effectiveModel = getEffectiveModel(isInFallbackMode, config2.getModel());
+    const effectiveModel = getEffectiveModel(isInFallbackMode, config2.getModel(), config2.getPreviewFeatures());
     return {
       model: effectiveModel,
       metadata: {
@@ -351612,7 +351845,7 @@ var OverrideStrategy = class {
     if (overrideModel === DEFAULT_GEMINI_MODEL_AUTO)
       return null;
     return {
-      model: overrideModel,
+      model: resolveModel(overrideModel, config2.getPreviewFeatures()),
       metadata: {
         source: this.name,
         latencyMs: 0,
@@ -351649,6 +351882,11 @@ var ModelRouterService = class {
     let decision;
     try {
       decision = await this.strategy.route(context2, this.config, this.config.getBaseLlmClient());
+      if (decision.model === DEFAULT_GEMINI_MODEL && this.config.getPreviewFeatures() && decision.metadata.source !== "override") {
+        decision.model = PREVIEW_GEMINI_MODEL;
+        decision.metadata.source += " (Preview Model)";
+        decision.metadata.reasoning += " (Upgraded to Preview Model)";
+      }
       const event = new ModelRoutingEvent(
         decision.model,
         decision.metadata.source,
@@ -354864,7 +355102,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.16.0-preview.4",
+      ideVersion: "0.16.0",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -354901,7 +355139,10 @@ function parseExperiments(response) {
 // packages/core/dist/src/code_assist/experiments/flagNames.js
 var ExperimentFlags = {
   CONTEXT_COMPRESSION_THRESHOLD: 45740197,
-  USER_CACHING: 45740198
+  USER_CACHING: 45740198,
+  BANNER_TEXT_NO_CAPACITY_ISSUES: 45740199,
+  BANNER_TEXT_CAPACITY_ISSUES: 45740200,
+  ENABLE_PREVIEW: 45740196
 };
 
 // packages/core/dist/src/utils/memoryDiscovery.js
@@ -358615,91 +358856,6 @@ import * as http5 from "node:http";
 import * as crypto21 from "node:crypto";
 import { URL as URL8 } from "node:url";
 
-// packages/core/dist/src/utils/secure-browser-launcher.js
-import { execFile as execFile6 } from "node:child_process";
-import { promisify as promisify12 } from "node:util";
-import { platform as platform9 } from "node:os";
-import { URL as URL7 } from "node:url";
-var execFileAsync5 = promisify12(execFile6);
-function validateUrl(url4) {
-  let parsedUrl;
-  try {
-    parsedUrl = new URL7(url4);
-  } catch (_error) {
-    throw new Error(`Invalid URL: ${url4}`);
-  }
-  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-    throw new Error(`Unsafe protocol: ${parsedUrl.protocol}. Only HTTP and HTTPS are allowed.`);
-  }
-  if (/[\r\n\x00-\x1f]/.test(url4)) {
-    throw new Error("URL contains invalid characters");
-  }
-}
-async function openBrowserSecurely(url4) {
-  validateUrl(url4);
-  const platformName = platform9();
-  let command;
-  let args2;
-  switch (platformName) {
-    case "darwin":
-      command = "open";
-      args2 = [url4];
-      break;
-    case "win32":
-      command = "powershell.exe";
-      args2 = [
-        "-NoProfile",
-        "-NonInteractive",
-        "-WindowStyle",
-        "Hidden",
-        "-Command",
-        `Start-Process '${url4.replace(/'/g, "''")}'`
-      ];
-      break;
-    case "linux":
-    case "freebsd":
-    case "openbsd":
-      command = "xdg-open";
-      args2 = [url4];
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${platformName}`);
-  }
-  const options2 = {
-    // Don't inherit parent's environment to avoid potential issues
-    env: {
-      ...process.env,
-      // Ensure we're not in a shell that might interpret special characters
-      SHELL: void 0
-    },
-    // Detach the browser process so it doesn't block
-    detached: true,
-    stdio: "ignore"
-  };
-  try {
-    await execFileAsync5(command, args2, options2);
-  } catch (error) {
-    if ((platformName === "linux" || platformName === "freebsd" || platformName === "openbsd") && command === "xdg-open") {
-      const fallbackCommands = [
-        "gnome-open",
-        "kde-open",
-        "firefox",
-        "chromium",
-        "google-chrome"
-      ];
-      for (const fallbackCommand of fallbackCommands) {
-        try {
-          await execFileAsync5(fallbackCommand, [url4], options2);
-          return;
-        } catch {
-          continue;
-        }
-      }
-    }
-    throw new Error(`Failed to open browser: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-
 // packages/core/dist/src/mcp/oauth-token-storage.js
 init_events();
 import { promises as fs54 } from "node:fs";
@@ -360341,6 +360497,7 @@ var Config = class {
   cwd;
   bugCommand;
   model;
+  previewFeatures;
   noBrowser;
   folderTrust;
   ideMode;
@@ -360396,6 +360553,8 @@ var Config = class {
   hooks;
   experiments;
   experimentsPromise;
+  previewModelFallbackMode = false;
+  previewModelBypassMode = false;
   constructor(params) {
     this.sessionId = params.sessionId;
     this.embeddingModel = params.embeddingModel ?? DEFAULT_GEMINI_EMBEDDING_MODEL;
@@ -360442,6 +360601,7 @@ var Config = class {
     this.fileDiscoveryService = params.fileDiscoveryService ?? null;
     this.bugCommand = params.bugCommand;
     this.model = params.model;
+    this.previewFeatures = params.previewFeatures ?? void 0;
     this.maxSessionTurns = params.maxSessionTurns ?? -1;
     this.experimentalZedIntegration = params.experimentalZedIntegration ?? false;
     this.listSessions = params.listSessions ?? false;
@@ -360566,17 +360726,24 @@ var Config = class {
         this.model = DEFAULT_GEMINI_MODEL;
       }
     }
-    if (this.contentGeneratorConfig?.authType === AuthType2.USE_GEMINI && authMethod === AuthType2.LOGIN_WITH_GOOGLE) {
+    if (this.contentGeneratorConfig?.authType === AuthType2.USE_GEMINI && authMethod !== AuthType2.USE_GEMINI) {
       this.geminiClient.stripThoughtsFromHistory();
     }
     const newContentGeneratorConfig = await createContentGeneratorConfig(this, authMethod);
     this.contentGenerator = await createContentGenerator(newContentGeneratorConfig, this, this.getSessionId());
     this.contentGeneratorConfig = newContentGeneratorConfig;
     this.baseLlmClient = new BaseLlmClient(this.contentGenerator, this);
+    const previewFeatures = this.getPreviewFeatures();
     const codeAssistServer = getCodeAssistServer(this);
     if (codeAssistServer) {
       this.experimentsPromise = getExperiments(codeAssistServer).then((experiments) => {
         this.setExperiments(experiments);
+        if (previewFeatures === void 0) {
+          const remotePreviewFeatures = experiments.flags[ExperimentFlags.ENABLE_PREVIEW]?.boolValue;
+          if (remotePreviewFeatures === true) {
+            this.setPreviewFeatures(remotePreviewFeatures);
+          }
+        }
       }).catch((e2) => {
         debugLogger.error("Failed to fetch experiments", e2);
       });
@@ -360639,6 +360806,21 @@ var Config = class {
   setFallbackModelHandler(handler) {
     this.fallbackModelHandler = handler;
   }
+  getFallbackModelHandler() {
+    return this.fallbackModelHandler;
+  }
+  isPreviewModelFallbackMode() {
+    return this.previewModelFallbackMode;
+  }
+  setPreviewModelFallbackMode(active) {
+    this.previewModelFallbackMode = active;
+  }
+  isPreviewModelBypassMode() {
+    return this.previewModelBypassMode;
+  }
+  setPreviewModelBypassMode(active) {
+    this.previewModelBypassMode = active;
+  }
   getMaxSessionTurns() {
     return this.maxSessionTurns;
   }
@@ -360683,6 +360865,12 @@ var Config = class {
   getQuestion() {
     return this.question;
   }
+  getPreviewFeatures() {
+    return this.previewFeatures;
+  }
+  setPreviewFeatures(previewFeatures) {
+    this.previewFeatures = previewFeatures;
+  }
   getCoreTools() {
     return this.coreTools;
   }
@@ -360934,6 +361122,14 @@ var Config = class {
     await this.ensureExperimentsLoaded();
     return this.experiments?.flags[ExperimentFlags.USER_CACHING]?.boolValue;
   }
+  async getBannerTextNoCapacityIssues() {
+    await this.ensureExperimentsLoaded();
+    return this.experiments?.flags[ExperimentFlags.BANNER_TEXT_NO_CAPACITY_ISSUES]?.stringValue ?? "";
+  }
+  async getBannerTextCapacityIssues() {
+    await this.ensureExperimentsLoaded();
+    return this.experiments?.flags[ExperimentFlags.BANNER_TEXT_CAPACITY_ISSUES]?.stringValue ?? "";
+  }
   async ensureExperimentsLoaded() {
     if (!this.experimentsPromise) {
       return;