@google/gemini-cli 0.41.0-preview.1 → 0.42.0-nightly.20260501.gcaa046641

package/bundle/{gemini-FTUVOUHP.js → gemini-TZ26TZKD.js}

@@ -9,7 +9,6 @@ import {
   INSTALL_WARNING_MESSAGE,
   McpPromptLoader,
   McpServerEnablementManager,
-  RELAUNCH_EXIT_CODE,
   canLoadServer,
   checkForAllExtensionUpdates,
   checkForExtensionUpdate,
@@ -42,18 +41,18 @@ import {
   updateAllUpdatableExtensions,
   updateExtension,
   validateAuthMethod
-} from "./chunk-DOHALVIP.js";
+} from "./chunk-3Y7ZPPS2.js";
 import {
   appEvents
 } from "./chunk-5PS3AYFU.js";
 import {
   startCommand,
   startServer
-} from "./chunk-TBBDQEFQ.js";
+} from "./chunk-WTLXL6OZ.js";
 import {
   exitCli,
   require_source
-} from "./chunk-VLSVN2FJ.js";
+} from "./chunk-GXIITUGM.js";
 import {
   DEFAULT_PORT,
   GEMMA_MODEL_NAME,
@@ -87,7 +86,11 @@ import {
   readServerProcessInfo,
   resolveGemmaConfig,
   saveModelChange
-} from "./chunk-5Z2T77EB.js";
+} from "./chunk-NNAHWZGK.js";
+import {
+  RELAUNCH_EXIT_CODE
+} from "./chunk-FNLKMX3W.js";
+import "./chunk-IDYSRNE5.js";
 import {
   cleanupCheckpoints,
   registerCleanup,
@@ -96,7 +99,7 @@ import {
   runExitCleanup,
   runSyncCleanup,
   setupSignalHandlers
-} from "./chunk-DCHOW6BK.js";
+} from "./chunk-SFDJ7FIE.js";
 import {
   AuthType,
   ChatRecordingService,
@@ -116,6 +119,7 @@ import {
   ReadManyFilesTool,
   Scheduler,
   ShellExecutionService,
+  SimpleExtensionLoader,
   StreamJsonFormatter,
   ToolCallEvent,
   UserAccountManager,
@@ -155,6 +159,7 @@ import {
   getVersion,
   isGeminiWorktree,
   isHeadlessMode,
+  isTextPart,
   isWithinRoot,
   listExtensions,
   listInboxPatches,
@@ -183,7 +188,7 @@ import {
   updatePolicy,
   writeToStderr,
   writeToStdout
-} from "./chunk-EQSLZT5Z.js";
+} from "./chunk-VUMF52YD.js";
 import {
   ASK_USER_TOOL_NAME,
   DEFAULT_FILE_FILTERING_OPTIONS,
@@ -227,7 +232,7 @@ import {
   loadServerHierarchicalMemory,
   resolveToRealPath,
   setGeminiMdFilename
-} from "./chunk-XRLFHCHC.js";
+} from "./chunk-533APETE.js";
 import "./chunk-664ZODQF.js";
 import "./chunk-RJTRUG2J.js";
 import "./chunk-IUUIT4SU.js";
@@ -7806,7 +7811,7 @@ async function loadSandboxConfig(settings, argv) {
   }
   const command2 = getSandboxCommand(sandboxValue);
   const packageJson = await getPackageJson(__dirname3);
-  const image = process.env["GEMINI_SANDBOX_IMAGE"] ?? "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.41.0-preview.0" ?? customImage ?? packageJson?.config?.sandboxImageUri;
+  const image = process.env["GEMINI_SANDBOX_IMAGE"] ?? "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.42.0-nightly.20260428.g59b2dea0e" ?? customImage ?? packageJson?.config?.sandboxImageUri;
   const isNative = command2 === "windows-native" || command2 === "sandbox-exec" || command2 === "lxc";
   return command2 && (image || isNative) ? { enabled: true, allowedPaths, networkAccess, command: command2, image } : void 0;
 }
@@ -8208,7 +8213,7 @@ function isDebugMode(argv) {
   );
 }
 async function loadCliConfig(settings, sessionId, argv, options = {}) {
-  const { cwd = process3.cwd(), projectHooks } = options;
+  const { cwd = process3.cwd(), projectHooks, skipExtensions = false } = options;
   const debugMode = isDebugMode(argv);
   const worktreeSettings = options.worktreeSettings ?? await resolveWorktreeSettings(cwd);
   if (argv.sandbox) {
@@ -8254,18 +8259,21 @@ async function loadCliConfig(settings, sessionId, argv, options = {}) {
     });
     includeDirectories.push(...ideFolders);
   }
-  const extensionManager = new ExtensionManager({
-    settings,
-    requestConsent: requestConsentNonInteractive,
-    requestSetting: promptForSetting,
-    workspaceDir: cwd,
-    enabledExtensionOverrides: argv.extensions,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    eventEmitter: coreEvents,
-    clientVersion: await getVersion()
-  });
-  await extensionManager.loadExtensions();
-  const extensionPlanSettings = extensionManager.getExtensions().find((ext) => ext.isActive && ext.plan?.directory)?.plan;
+  let extensionManager;
+  if (!skipExtensions) {
+    extensionManager = new ExtensionManager({
+      settings,
+      requestConsent: requestConsentNonInteractive,
+      requestSetting: promptForSetting,
+      workspaceDir: cwd,
+      enabledExtensionOverrides: argv.extensions,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      eventEmitter: coreEvents,
+      clientVersion: await getVersion()
+    });
+    await extensionManager.loadExtensions();
+  }
+  const extensionPlanSettings = extensionManager?.getExtensions()?.find((ext) => ext.isActive && ext.plan?.directory)?.plan;
   const experimentalJitContext = settings.experimental.jitContext ?? true;
   let extensionRegistryURI = process3.env["GEMINI_CLI_EXTENSION_REGISTRY_URI"] ?? (trustedFolder ? settings.experimental?.extensionRegistryURI : void 0);
   if (extensionRegistryURI && !extensionRegistryURI.startsWith("http")) {
@@ -8276,12 +8284,13 @@ async function loadCliConfig(settings, sessionId, argv, options = {}) {
   let memoryContent = "";
   let fileCount = 0;
   let filePaths = [];
+  const finalExtensionLoader = extensionManager ?? new SimpleExtensionLoader([]);
   if (!experimentalJitContext) {
     const result = await loadServerHierarchicalMemory(
       cwd,
       settings.context?.loadMemoryFromIncludeDirectories || false ? includeDirectories : [],
       fileService,
-      extensionManager,
+      finalExtensionLoader,
       trustedFolder,
       memoryImportFormat,
       memoryFileFiltering,
@@ -8465,7 +8474,13 @@ async function loadCliConfig(settings, sessionId, argv, options = {}) {
     const ide = detectIdeFromEnv();
     if (ide && (ide.name !== "vscode" || process3.env["TERM_PROGRAM"] === "vscode")) {
       clientName = `acp-${ide.name}`;
+    } else {
+      clientName = "acp";
     }
+  } else if (argv.isCommand) {
+    clientName = "cli-command";
+  } else {
+    clientName = "tui";
   }
   let profileSelector = void 0;
   if (settings.experimental?.stressTestProfile) {
@@ -8539,7 +8554,7 @@ async function loadCliConfig(settings, sessionId, argv, options = {}) {
     listSessions: argv.listSessions || false,
     deleteSession: argv.deleteSession,
     enabledExtensions: argv.extensions,
-    extensionLoader: extensionManager,
+    extensionLoader: finalExtensionLoader,
     extensionRegistryURI,
     enableExtensionReloading: settings.experimental?.extensionReloading,
     enableAgents: settings.experimental?.enableAgents,
@@ -8660,6 +8675,15 @@ async function resolveWorktreeSettings(cwd) {
 }
 
 // packages/cli/src/utils/readStdin.ts
+function truncateUtf8Bytes(str, maxBytes) {
+  const buf = Buffer.from(str, "utf8");
+  if (buf.length <= maxBytes) return str;
+  let end = maxBytes;
+  while (end > 0 && (buf[end] & 192) === 128) {
+    end--;
+  }
+  return buf.subarray(0, end).toString("utf8");
+}
 async function readStdin() {
   const MAX_STDIN_SIZE = 8 * 1024 * 1024;
   return new Promise((resolve9, reject) => {
@@ -8677,9 +8701,10 @@ async function readStdin() {
           clearTimeout(pipedInputTimerId);
           pipedInputTimerId = null;
         }
-        if (totalSize + chunk.length > MAX_STDIN_SIZE) {
-          const remainingSize = MAX_STDIN_SIZE - totalSize;
-          data += chunk.slice(0, remainingSize);
+        const chunkByteLength = Buffer.byteLength(chunk, "utf8");
+        if (totalSize + chunkByteLength > MAX_STDIN_SIZE) {
+          const remainingBytes = MAX_STDIN_SIZE - totalSize;
+          data += truncateUtf8Bytes(chunk, remainingBytes);
           debugLogger.warn(
             `Warning: stdin input truncated to ${MAX_STDIN_SIZE} bytes.`
           );
@@ -8688,7 +8713,7 @@ async function readStdin() {
           break;
         }
         data += chunk;
-        totalSize += chunk.length;
+        totalSize += chunkByteLength;
       }
     };
     const onEnd = () => {
@@ -10183,7 +10208,7 @@ async function runNonInteractive({
       }
     });
     if (process.env["GEMINI_CLI_ACTIVITY_LOG_TARGET"]) {
-      const { setupInitialActivityLogger } = await import("./devtoolsService-QXOHXSMJ.js");
+      const { setupInitialActivityLogger } = await import("./devtoolsService-DFWZ34A5.js");
       setupInitialActivityLogger(config);
     }
     const { stdout: workingStdout } = createWorkingStdio();
@@ -10370,7 +10395,13 @@ async function runNonInteractive({
           const formatter = new JsonFormatter();
           const stats = uiTelemetryService.getMetrics();
           textOutput.write(
-            formatter.format(config.getSessionId(), responseText, stats)
+            formatter.format(
+              config.getSessionId(),
+              responseText,
+              stats,
+              void 0,
+              warnings
+            )
           );
         } else {
           textOutput.ensureTrailingNewline();
@@ -10441,6 +10472,7 @@ async function runNonInteractive({
       let responseText = "";
       let preToolResponseText;
       let streamEnded = false;
+      const warnings = [];
       for await (const event of session.stream({ streamId })) {
         if (streamEnded) break;
         switch (event.type) {
@@ -10539,10 +10571,19 @@ async function runNonInteractive({
             }
             const errorCode = event._meta?.["code"];
             if (errorCode === "AGENT_EXECUTION_BLOCKED") {
+              const blockMessage = `Agent execution blocked: ${event.message.trim()}`;
               if (config.getOutputFormat() === "text" /* TEXT */) {
-                process.stderr.write(`[WARNING] ${event.message}
+                process.stderr.write(`[WARNING] ${blockMessage}
 `);
+              } else if (streamFormatter) {
+                streamFormatter.emitEvent({
+                  type: "error" /* ERROR */,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  severity: "warning",
+                  message: stripAnsi(blockMessage)
+                });
               }
+              warnings.push(blockMessage);
               break;
             }
             const severity = event.status === "RESOURCE_EXHAUSTED" ? "error" : "warning";
@@ -10555,9 +10596,10 @@ async function runNonInteractive({
                 type: "error" /* ERROR */,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                 severity,
-                message: event.message
+                message: stripAnsi(event.message)
               });
             }
+            warnings.push(event.message);
             break;
           }
           case "agent_end": {
@@ -10634,7 +10676,7 @@ async function runNonInteractive2(params) {
       }
     });
     if (process.env["GEMINI_CLI_ACTIVITY_LOG_TARGET"]) {
-      const { setupInitialActivityLogger } = await import("./devtoolsService-QXOHXSMJ.js");
+      const { setupInitialActivityLogger } = await import("./devtoolsService-DFWZ34A5.js");
       setupInitialActivityLogger(config);
     }
     const { stdout: workingStdout } = createWorkingStdio();
@@ -10777,6 +10819,8 @@ async function runNonInteractive2(params) {
       }
       let currentMessages = [{ role: "user", parts: query }];
       let turnCount = 0;
+      let invalidStreamError;
+      const warnings = [];
       while (true) {
         turnCount++;
         if (config.getMaxSessionTurns() >= 0 && turnCount > config.getMaxSessionTurns()) {
@@ -10826,23 +10870,27 @@ async function runNonInteractive2(params) {
             }
             toolCallRequests.push(event.value);
           } else if (event.type === "loop_detected" /* LoopDetected */) {
+            const message = "Loop detected, stopping execution";
             if (streamFormatter) {
               streamFormatter.emitEvent({
                 type: "error" /* ERROR */,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                 severity: "warning",
-                message: "Loop detected, stopping execution"
+                message
               });
             }
+            warnings.push(message);
           } else if (event.type === "max_session_turns" /* MaxSessionTurns */) {
+            const message = "Maximum session turns exceeded";
             if (streamFormatter) {
               streamFormatter.emitEvent({
                 type: "error" /* ERROR */,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                 severity: "error",
-                message: "Maximum session turns exceeded"
+                message
               });
             }
+            warnings.push(message);
           } else if (event.type === "error" /* Error */) {
             throw event.value.error;
           } else if (event.type === "agent_execution_stopped" /* AgentExecutionStopped */) {
@@ -10869,8 +10917,31 @@ async function runNonInteractive2(params) {
             const blockMessage = `Agent execution blocked: ${event.value.systemMessage?.trim() || event.value.reason}`;
             if (config.getOutputFormat() === "text" /* TEXT */) {
               process.stderr.write(`[WARNING] ${blockMessage}
+`);
+            } else if (streamFormatter) {
+              streamFormatter.emitEvent({
+                type: "error" /* ERROR */,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                severity: "warning",
+                message: stripAnsi(blockMessage)
+              });
+            }
+            warnings.push(blockMessage);
+          } else if (event.type === "invalid_stream" /* InvalidStream */) {
+            invalidStreamError = "Invalid stream: The model returned an empty response or malformed tool call.";
+            if (streamFormatter) {
+              streamFormatter.emitEvent({
+                type: "error" /* ERROR */,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                severity: "error",
+                message: invalidStreamError
+              });
+            } else if (config.getOutputFormat() === "text" /* TEXT */) {
+              process.stderr.write(`[ERROR] ${invalidStreamError}
 `);
             }
+            toolCallRequests.length = 0;
+            break;
           }
         }
         if (toolCallRequests.length > 0) {
@@ -10943,7 +11014,13 @@ async function runNonInteractive2(params) {
               const formatter = new JsonFormatter();
               const stats = uiTelemetryService.getMetrics();
               textOutput.write(
-                formatter.format(config.getSessionId(), responseText, stats)
+                formatter.format(
+                  config.getSessionId(),
+                  responseText,
+                  stats,
+                  void 0,
+                  warnings
+                )
               );
             } else {
               textOutput.ensureTrailingNewline();
@@ -10958,14 +11035,20 @@ async function runNonInteractive2(params) {
             streamFormatter.emitEvent({
               type: "result" /* RESULT */,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              status: "success",
+              status: invalidStreamError ? "error" : "success",
               stats: streamFormatter.convertToStreamStats(metrics, durationMs)
             });
           } else if (config.getOutputFormat() === "json" /* JSON */) {
             const formatter = new JsonFormatter();
             const stats = uiTelemetryService.getMetrics();
             textOutput.write(
-              formatter.format(config.getSessionId(), responseText, stats)
+              formatter.format(
+                config.getSessionId(),
+                responseText,
+                stats,
+                invalidStreamError ? { type: "INVALID_STREAM", message: invalidStreamError } : void 0,
+                warnings
+              )
             );
           } else {
             textOutput.ensureTrailingNewline();
@@ -12524,59 +12607,8 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// packages/cli/src/acp/fileSystemService.ts
-import os5 from "node:os";
-import path10 from "node:path";
-var AcpFileSystemService = class {
-  constructor(connection, sessionId, capabilities, fallback, root) {
-    this.connection = connection;
-    this.sessionId = sessionId;
-    this.capabilities = capabilities;
-    this.fallback = fallback;
-    this.root = root;
-  }
-  geminiDir = path10.join(os5.homedir(), ".gemini");
-  shouldUseFallback(filePath) {
-    return !isWithinRoot(filePath, this.root) || isWithinRoot(filePath, this.geminiDir);
-  }
-  normalizeFileSystemError(err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (errorMessage.includes("Resource not found") || errorMessage.includes("ENOENT") || errorMessage.includes("does not exist") || errorMessage.includes("No such file")) {
-      const newErr = new Error(errorMessage);
-      newErr.code = "ENOENT";
-      throw newErr;
-    }
-    throw err;
-  }
-  async readTextFile(filePath) {
-    if (!this.capabilities.readTextFile || this.shouldUseFallback(filePath)) {
-      return this.fallback.readTextFile(filePath);
-    }
-    try {
-      const response = await this.connection.readTextFile({
-        path: filePath,
-        sessionId: this.sessionId
-      });
-      return response.content;
-    } catch (err) {
-      this.normalizeFileSystemError(err);
-    }
-  }
-  async writeTextFile(filePath, content) {
-    if (!this.capabilities.writeTextFile || this.shouldUseFallback(filePath)) {
-      return this.fallback.writeTextFile(filePath, content);
-    }
-    try {
-      await this.connection.writeTextFile({
-        path: filePath,
-        content,
-        sessionId: this.sessionId
-      });
-    } catch (err) {
-      this.normalizeFileSystemError(err);
-    }
-  }
-};
+// packages/cli/src/acp/acpStdioTransport.ts
+import { Readable, Writable } from "node:stream";
 
 // packages/cli/src/acp/acpErrors.ts
 function getAcpErrorMessage(error) {
@@ -12598,10 +12630,12 @@ function extractRecursiveMessage(input) {
   return input;
 }
 
-// packages/cli/src/acp/acpClient.ts
-import { Readable, Writable } from "node:stream";
+// packages/cli/src/acp/acpSessionManager.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/cli/src/acp/acpSession.ts
 import * as fs12 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path12 from "node:path";
 import { randomUUID } from "node:crypto";
 
 // packages/cli/src/acp/commands/commandRegistry.ts
@@ -13073,7 +13107,7 @@ var UpdateExtensionCommand = class {
 
 // packages/cli/src/acp/commands/init.ts
 import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as path10 from "node:path";
 var InitCommand = class {
   name = "init";
   description = "Analyzes the project and creates a tailored GEMINI.md file";
@@ -13083,7 +13117,7 @@ var InitCommand = class {
     if (!targetDir) {
       throw new Error("Command requires a workspace.");
     }
-    const geminiMdPath = path11.join(targetDir, "GEMINI.md");
+    const geminiMdPath = path10.join(targetDir, "GEMINI.md");
     const result = performInit(fs10.existsSync(geminiMdPath));
     switch (result.type) {
       case "message":
@@ -13116,7 +13150,7 @@ ${result.content}`
 
 // packages/cli/src/acp/commands/restore.ts
 import * as fs11 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as path11 from "node:path";
 var RestoreCommand = class {
   name = "restore";
   description = "Restore to a previous checkpoint, or list available checkpoints to restore. This will reset the conversation and file history to the state it was in when the checkpoint was created";
@@ -13138,7 +13172,7 @@ var RestoreCommand = class {
       }
       const selectedFile = argsStr.endsWith(".json") ? argsStr : `${argsStr}.json`;
       const checkpointDir = config.storage.getProjectTempCheckpointsDir();
-      const filePath = path12.join(checkpointDir, selectedFile);
+      const filePath = path11.join(checkpointDir, selectedFile);
       let data;
       try {
         data = await fs11.readFile(filePath, "utf-8");
@@ -13212,7 +13246,7 @@ var ListCheckpointsCommand = class {
       }
       const checkpointFiles = /* @__PURE__ */ new Map();
       for (const file of jsonFiles) {
-        const filePath = path12.join(checkpointDir, file);
+        const filePath = path11.join(checkpointDir, file);
         const data = await fs11.readFile(filePath, "utf-8");
         checkpointFiles.set(file, data);
       }
@@ -13319,7 +13353,7 @@ var HelpCommand = class {
   }
 };
 
-// packages/cli/src/acp/commandHandler.ts
+// packages/cli/src/acp/acpCommandHandler.ts
 var CommandHandler = class _CommandHandler {
   registry;
   constructor() {
@@ -13406,7 +13440,7 @@ var CommandHandler = class _CommandHandler {
   }
 };
 
-// packages/cli/src/acp/acpClient.ts
+// packages/cli/src/acp/acpUtils.ts
 function hasMeta(obj) {
   return typeof obj === "object" && obj !== null && "_meta" in obj;
 }
@@ -13419,380 +13453,273 @@ var RequestPermissionResponseSchema = external_exports.object({
     })
   ])
 });
-async function runAcpClient(config, settings, argv) {
-  const { stdout: workingStdout } = createWorkingStdio();
-  const stdout = Writable.toWeb(workingStdout);
-  const stdin = Readable.toWeb(process.stdin);
-  const stream = ndJsonStream(stdout, stdin);
-  const connection = new AgentSideConnection(
-    (connection2) => new GeminiAgent(config, settings, argv, connection2),
-    stream
-  );
-  await connection.closed.finally(runExitCleanup);
-}
-var GeminiAgent = class _GeminiAgent {
-  constructor(context, settings, argv, connection) {
-    this.context = context;
-    this.settings = settings;
-    this.argv = argv;
-    this.connection = connection;
-  }
-  static callIdCounter = 0;
-  static generateCallId(name) {
-    return `${name}-${Date.now()}-${++_GeminiAgent.callIdCounter}`;
+function toToolCallContent(toolResult) {
+  if (toolResult.error?.message) {
+    throw new Error(toolResult.error.message);
   }
-  sessions = /* @__PURE__ */ new Map();
-  clientCapabilities;
-  apiKey;
-  baseUrl;
-  customHeaders;
-  async initialize(args) {
-    this.clientCapabilities = args.clientCapabilities;
-    const authMethods = [
-      {
-        id: "oauth-personal" /* LOGIN_WITH_GOOGLE */,
-        name: "Log in with Google",
-        description: "Log in with your Google account"
-      },
-      {
-        id: "gemini-api-key" /* USE_GEMINI */,
-        name: "Gemini API key",
-        description: "Use an API key with Gemini Developer API",
-        _meta: {
-          "api-key": {
-            provider: "google"
-          }
-        }
-      },
-      {
-        id: "vertex-ai" /* USE_VERTEX_AI */,
-        name: "Vertex AI",
-        description: "Use an API key with Vertex AI GenAI API"
-      },
-      {
-        id: "gateway" /* GATEWAY */,
-        name: "AI API Gateway",
-        description: "Use a custom AI API Gateway",
-        _meta: {
-          gateway: {
-            protocol: "google",
-            restartRequired: "false"
+  if (toolResult.returnDisplay) {
+    if (typeof toolResult.returnDisplay === "string") {
+      return {
+        type: "content",
+        content: { type: "text", text: toolResult.returnDisplay }
+      };
+    } else {
+      if ("fileName" in toolResult.returnDisplay) {
+        return {
+          type: "diff",
+          path: toolResult.returnDisplay.filePath ?? toolResult.returnDisplay.fileName,
+          oldText: toolResult.returnDisplay.originalContent,
+          newText: toolResult.returnDisplay.newContent,
+          _meta: {
+            kind: !toolResult.returnDisplay.originalContent ? "add" : toolResult.returnDisplay.newContent === "" ? "delete" : "modify"
           }
-        }
-      }
-    ];
-    await this.context.config.initialize();
-    const version = await getVersion();
-    return {
-      protocolVersion: PROTOCOL_VERSION,
-      authMethods,
-      agentInfo: {
-        name: "gemini-cli",
-        title: "Gemini CLI",
-        version
-      },
-      agentCapabilities: {
-        loadSession: true,
-        promptCapabilities: {
-          image: true,
-          audio: true,
-          embeddedContext: true
-        },
-        mcpCapabilities: {
-          http: true,
-          sse: true
-        }
-      }
-    };
-  }
-  async authenticate(req) {
-    const { methodId } = req;
-    const method = external_exports.nativeEnum(AuthType).parse(methodId);
-    const selectedAuthType = this.settings.merged.security.auth.selectedType;
-    if (selectedAuthType && selectedAuthType !== method) {
-      await clearCachedCredentialFile();
-    }
-    const meta = hasMeta(req) ? req._meta : void 0;
-    const apiKey = typeof meta?.["api-key"] === "string" ? meta["api-key"] : void 0;
-    try {
-      if (apiKey) {
-        this.apiKey = apiKey;
-      }
-      const gatewaySchema = external_exports.object({
-        baseUrl: external_exports.string().optional(),
-        headers: external_exports.record(external_exports.string()).optional()
-      });
-      let baseUrl;
-      let headers;
-      if (meta?.["gateway"]) {
-        const result = gatewaySchema.safeParse(meta["gateway"]);
-        if (result.success) {
-          baseUrl = result.data.baseUrl;
-          headers = result.data.headers;
-        } else {
-          throw new RequestError(
-            -32602,
-            `Malformed gateway payload: ${result.error.message}`
-          );
-        }
+        };
       }
-      this.baseUrl = baseUrl;
-      this.customHeaders = headers;
-      await this.context.config.refreshAuth(
-        method,
-        apiKey ?? this.apiKey,
-        baseUrl,
-        headers
-      );
-    } catch (e) {
-      throw new RequestError(-32e3, getAcpErrorMessage(e));
+      return null;
     }
-    this.settings.setValue(
-      "User" /* User */,
-      "security.auth.selectedType",
-      method
-    );
+  } else {
+    return null;
   }
-  async newSession({
-    cwd,
-    mcpServers
-  }) {
-    const sessionId = randomUUID();
-    const loadedSettings = loadSettings(cwd);
-    const config = await this.newSessionConfig(
-      sessionId,
-      cwd,
-      mcpServers,
-      loadedSettings
-    );
-    const authType = loadedSettings.merged.security.auth.selectedType || "gemini-api-key" /* USE_GEMINI */;
-    let isAuthenticated = false;
-    let authErrorMessage = "";
-    try {
-      await config.refreshAuth(
-        authType,
-        this.apiKey,
-        this.baseUrl,
-        this.customHeaders
-      );
-      isAuthenticated = true;
-      const contentGeneratorConfig = config.getContentGeneratorConfig();
-      if (authType === "gemini-api-key" /* USE_GEMINI */ && (!contentGeneratorConfig || !contentGeneratorConfig.apiKey)) {
-        isAuthenticated = false;
-        authErrorMessage = "Gemini API key is missing or not configured.";
-      }
-    } catch (e) {
-      isAuthenticated = false;
-      authErrorMessage = getAcpErrorMessage(e);
-      debugLogger.error(
-        `Authentication failed: ${e instanceof Error ? e.stack : e}`
-      );
-    }
-    if (!isAuthenticated) {
-      throw new RequestError(
-        -32e3,
-        authErrorMessage || "Authentication required."
-      );
-    }
-    if (this.clientCapabilities?.fs) {
-      const acpFileSystemService = new AcpFileSystemService(
-        this.connection,
-        sessionId,
-        this.clientCapabilities.fs,
-        config.getFileSystemService(),
-        cwd
-      );
-      config.setFileSystemService(acpFileSystemService);
-    }
-    await config.initialize();
-    startupProfiler.flush(config);
-    startAutoMemoryIfEnabled(config);
-    const geminiClient = config.getGeminiClient();
-    const chat = await geminiClient.startChat();
-    const session = new Session(
-      sessionId,
-      chat,
-      config,
-      this.connection,
-      this.settings
-    );
-    this.sessions.set(sessionId, session);
-    setTimeout(() => {
-      session.sendAvailableCommands();
-    }, 0);
-    const { availableModels, currentModelId } = buildAvailableModels(
-      config,
-      loadedSettings
-    );
-    const response = {
-      sessionId,
-      modes: {
-        availableModes: buildAvailableModes(config.isPlanEnabled()),
-        currentModeId: config.getApprovalMode()
-      },
-      models: {
-        availableModels,
-        currentModelId
-      }
-    };
-    return response;
-  }
-  async loadSession({
-    sessionId,
-    cwd,
-    mcpServers
-  }) {
-    const config = await this.initializeSessionConfig(
-      sessionId,
-      cwd,
-      mcpServers
-    );
-    const sessionSelector = new SessionSelector(config.storage);
-    const { sessionData, sessionPath } = await sessionSelector.resolveSession(sessionId);
-    const clientHistory = convertSessionToClientHistory(sessionData.messages);
-    const geminiClient = config.getGeminiClient();
-    await geminiClient.initialize();
-    await geminiClient.resumeChat(clientHistory, {
-      conversation: sessionData,
-      filePath: sessionPath
-    });
-    const session = new Session(
-      sessionId,
-      geminiClient.getChat(),
-      config,
-      this.connection,
-      this.settings
-    );
-    this.sessions.set(sessionId, session);
-    session.streamHistory(sessionData.messages);
-    setTimeout(() => {
-      session.sendAvailableCommands();
-    }, 0);
-    const { availableModels, currentModelId } = buildAvailableModels(
-      config,
-      this.settings
-    );
-    const response = {
-      modes: {
-        availableModes: buildAvailableModes(config.isPlanEnabled()),
-        currentModeId: config.getApprovalMode()
-      },
-      models: {
-        availableModels,
-        currentModelId
-      }
-    };
-    return response;
-  }
-  async initializeSessionConfig(sessionId, cwd, mcpServers) {
-    const selectedAuthType = this.settings.merged.security.auth.selectedType;
-    if (!selectedAuthType) {
-      throw RequestError.authRequired();
-    }
-    const config = await this.newSessionConfig(sessionId, cwd, mcpServers);
-    try {
-      await config.refreshAuth(
-        selectedAuthType,
-        this.apiKey,
-        this.baseUrl,
-        this.customHeaders
-      );
-    } catch (e) {
-      debugLogger.error(`Authentication failed: ${e}`);
-      throw RequestError.authRequired();
-    }
-    if (this.clientCapabilities?.fs) {
-      const acpFileSystemService = new AcpFileSystemService(
-        this.connection,
-        sessionId,
-        this.clientCapabilities.fs,
-        config.getFileSystemService(),
-        cwd
-      );
-      config.setFileSystemService(acpFileSystemService);
-    }
-    await config.initialize();
-    startupProfiler.flush(config);
-    startAutoMemoryIfEnabled(config);
-    return config;
+}
+var basicPermissionOptions = [
+  {
+    optionId: "proceed_once" /* ProceedOnce */,
+    name: "Allow",
+    kind: "allow_once"
+  },
+  {
+    optionId: "cancel" /* Cancel */,
+    name: "Reject",
+    kind: "reject_once"
   }
-  async newSessionConfig(sessionId, cwd, mcpServers, loadedSettings) {
-    const currentSettings = loadedSettings || this.settings;
-    const mergedMcpServers = { ...currentSettings.merged.mcpServers };
-    for (const server of mcpServers) {
-      if ("type" in server && (server.type === "sse" || server.type === "http")) {
-        const headers = Object.fromEntries(
-          server.headers.map(({ name, value }) => [name, value])
-        );
-        mergedMcpServers[server.name] = new MCPServerConfig(
-          void 0,
-          // command
-          void 0,
-          // args
-          void 0,
-          // env
-          void 0,
-          // cwd
-          server.type === "sse" ? server.url : void 0,
-          // url (sse)
-          server.type === "http" ? server.url : void 0,
-          // httpUrl
-          headers
-        );
-      } else if ("command" in server) {
-        const env2 = {};
-        for (const { name: envName, value } of server.env) {
-          env2[envName] = value;
+];
+function toPermissionOptions(confirmation, config, enablePermanentToolApproval = false) {
+  const disableAlwaysAllow = config.getDisableAlwaysAllow();
+  const options = [];
+  if (!disableAlwaysAllow) {
+    switch (confirmation.type) {
+      case "edit":
+        options.push({
+          optionId: "proceed_always" /* ProceedAlways */,
+          name: "Allow for this session",
+          kind: "allow_always"
+        });
+        if (enablePermanentToolApproval) {
+          options.push({
+            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
+            name: "Allow for this file in all future sessions",
+            kind: "allow_always"
+          });
         }
-        mergedMcpServers[server.name] = new MCPServerConfig(
-          server.command,
-          server.args,
-          env2,
-          cwd
+        break;
+      case "exec":
+        options.push({
+          optionId: "proceed_always" /* ProceedAlways */,
+          name: "Allow for this session",
+          kind: "allow_always"
+        });
+        if (enablePermanentToolApproval) {
+          options.push({
+            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
+            name: "Allow this command for all future sessions",
+            kind: "allow_always"
+          });
+        }
+        break;
+      case "mcp":
+        options.push(
+          {
+            optionId: "proceed_always_server" /* ProceedAlwaysServer */,
+            name: "Allow all server tools for this session",
+            kind: "allow_always"
+          },
+          {
+            optionId: "proceed_always_tool" /* ProceedAlwaysTool */,
+            name: "Allow tool for this session",
+            kind: "allow_always"
+          }
         );
-      }
+        if (enablePermanentToolApproval) {
+          options.push({
+            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
+            name: "Allow tool for all future sessions",
+            kind: "allow_always"
+          });
+        }
+        break;
+      case "info":
+        options.push({
+          optionId: "proceed_always" /* ProceedAlways */,
+          name: "Allow for this session",
+          kind: "allow_always"
+        });
+        if (enablePermanentToolApproval) {
+          options.push({
+            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
+            name: "Allow for all future sessions",
+            kind: "allow_always"
+          });
+        }
+        break;
+      case "ask_user":
+      case "exit_plan_mode":
+        break;
+      default:
+        break;
     }
-    const settings = {
-      ...currentSettings.merged,
-      mcpServers: mergedMcpServers
-    };
-    const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });
-    createPolicyUpdater2(
-      config.getPolicyEngine(),
-      config.messageBus,
-      config.storage
-    );
-    return config;
   }
-  async cancel(params) {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
+  options.push(...basicPermissionOptions);
+  switch (confirmation.type) {
+    case "edit":
+    case "exec":
+    case "mcp":
+    case "info":
+    case "ask_user":
+    case "exit_plan_mode":
+    case "sandbox_expansion":
+      break;
+    default: {
+      const unreachable = confirmation;
+      throw new Error(`Unexpected: ${unreachable}`);
     }
-    await session.cancelPendingPrompt();
   }
-  async prompt(params) {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
+  return options;
+}
+function toAcpToolKind(kind) {
+  switch (kind) {
+    case "read" /* Read */:
+    case "edit" /* Edit */:
+    case "execute" /* Execute */:
+    case "search" /* Search */:
+    case "delete" /* Delete */:
+    case "move" /* Move */:
+    case "think" /* Think */:
+    case "fetch" /* Fetch */:
+    case "switch_mode" /* SwitchMode */:
+    case "other" /* Other */:
+      return kind;
+    case "agent" /* Agent */:
+      return "think";
+    case "plan" /* Plan */:
+    case "communicate" /* Communicate */:
+    default:
+      return "other";
+  }
+}
+function buildAvailableModes(isPlanEnabled) {
+  const modes = [
+    {
+      id: "default" /* DEFAULT */,
+      name: "Default",
+      description: "Prompts for approval"
+    },
+    {
+      id: "autoEdit" /* AUTO_EDIT */,
+      name: "Auto Edit",
+      description: "Auto-approves edit tools"
+    },
+    {
+      id: "yolo" /* YOLO */,
+      name: "YOLO",
+      description: "Auto-approves all tools"
     }
-    return session.prompt(params);
+  ];
+  if (isPlanEnabled) {
+    modes.push({
+      id: "plan" /* PLAN */,
+      name: "Plan",
+      description: "Read-only mode"
+    });
   }
-  async setSessionMode(params) {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
+  return modes;
+}
+function buildAvailableModels(config, settings) {
+  const preferredModel = config.getModel() || DEFAULT_GEMINI_MODEL_AUTO;
+  const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
+  const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
+  const useGemini31FlashLite = config.getGemini31FlashLiteLaunchedSync?.() ?? false;
+  const selectedAuthType = settings.merged.security.auth.selectedType;
+  const useCustomToolModel = useGemini31 && selectedAuthType === "gemini-api-key" /* USE_GEMINI */;
+  if (config.getExperimentalDynamicModelConfiguration?.() === true && config.getModelConfigService) {
+    const options = config.getModelConfigService().getAvailableModelOptions({
+      useGemini3_1: useGemini31,
+      useGemini3_1FlashLite: useGemini31FlashLite,
+      useCustomTools: useCustomToolModel,
+      hasAccessToPreview: shouldShowPreviewModels
+    });
+    return {
+      availableModels: options,
+      currentModelId: preferredModel
+    };
+  }
+  const mainOptions = [
+    {
+      value: DEFAULT_GEMINI_MODEL_AUTO,
+      title: getDisplayString(DEFAULT_GEMINI_MODEL_AUTO),
+      description: "Let Gemini CLI decide the best model for the task: gemini-2.5-pro, gemini-2.5-flash"
     }
-    return session.setMode(params.modeId);
+  ];
+  if (shouldShowPreviewModels) {
+    mainOptions.unshift({
+      value: PREVIEW_GEMINI_MODEL_AUTO,
+      title: getDisplayString(PREVIEW_GEMINI_MODEL_AUTO),
+      description: useGemini31 ? "Let Gemini CLI decide the best model for the task: gemini-3.1-pro, gemini-3-flash" : "Let Gemini CLI decide the best model for the task: gemini-3-pro, gemini-3-flash"
+    });
   }
-  async unstable_setSessionModel(params) {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
+  const manualOptions = [
+    {
+      value: DEFAULT_GEMINI_MODEL,
+      title: getDisplayString(DEFAULT_GEMINI_MODEL)
+    },
+    {
+      value: DEFAULT_GEMINI_FLASH_MODEL,
+      title: getDisplayString(DEFAULT_GEMINI_FLASH_MODEL)
+    },
+    {
+      value: DEFAULT_GEMINI_FLASH_LITE_MODEL,
+      title: getDisplayString(DEFAULT_GEMINI_FLASH_LITE_MODEL)
     }
-    return session.setModel(params.modelId);
+  ];
+  if (shouldShowPreviewModels) {
+    const previewProModel = useGemini31 ? PREVIEW_GEMINI_3_1_MODEL : PREVIEW_GEMINI_MODEL;
+    const previewProValue = useCustomToolModel ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL : previewProModel;
+    const previewOptions = [
+      {
+        value: previewProValue,
+        title: getDisplayString(previewProModel)
+      },
+      {
+        value: PREVIEW_GEMINI_FLASH_MODEL,
+        title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL)
+      }
+    ];
+    if (useGemini31FlashLite) {
+      previewOptions.push({
+        value: PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
+        title: getDisplayString(PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL)
+      });
+    }
+    manualOptions.unshift(...previewOptions);
   }
-};
+  const scaleOptions = (options) => options.map((o) => ({
+    modelId: o.value,
+    name: o.title,
+    description: o.description
+  }));
+  return {
+    availableModels: [
+      ...scaleOptions(mainOptions),
+      ...scaleOptions(manualOptions)
+    ],
+    currentModelId: preferredModel
+  };
+}
+
+// packages/cli/src/acp/acpSession.ts
+var StructuredErrorSchema = external_exports.object({
+  status: external_exports.number().optional(),
+  message: external_exports.string().optional()
+});
 var Session = class {
   constructor(id, chat, context, connection, settings) {
     this.id = id;
@@ -13803,6 +13730,10 @@ var Session = class {
   }
   pendingPrompt = null;
   commandHandler = new CommandHandler();
+  callIdCounter = 0;
+  generateCallId(name) {
+    return `${name}-${Date.now()}-${++this.callIdCounter}`;
+  }
   async cancelPendingPrompt() {
     if (!this.pendingPrompt) {
       throw new Error("Not currently generating");
@@ -13903,16 +13834,13 @@ ${thought.description}`;
     this.pendingPrompt = pendingSend;
     await this.context.config.waitForMcpInit();
     const promptId = Math.random().toString(16).slice(2);
-    const chat = this.chat;
     const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
     let commandText = "";
     for (const part of parts) {
       if (typeof part === "object" && part !== null) {
-        if ("text" in part) {
+        if (isTextPart(part)) {
           const text = part.text;
-          if (typeof text === "string") {
-            commandText += text;
-          }
+          commandText += text;
         } else {
           break;
         }
@@ -13936,80 +13864,108 @@ ${thought.description}`;
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     const modelUsageMap = /* @__PURE__ */ new Map();
-    let nextMessage = { role: "user", parts };
-    while (nextMessage !== null) {
+    let currentParts = parts;
+    let turnCount = 0;
+    const maxTurns = this.context.config.getMaxSessionTurns();
+    while (true) {
+      turnCount++;
+      if (maxTurns >= 0 && turnCount > maxTurns) {
+        return {
+          stopReason: "max_turn_requests",
+          _meta: {
+            quota: {
+              token_count: {
+                input_tokens: totalInputTokens,
+                output_tokens: totalOutputTokens
+              },
+              model_usage: Array.from(modelUsageMap.entries()).map(
+                ([modelName, counts]) => ({
+                  model: modelName,
+                  token_count: {
+                    input_tokens: counts.input,
+                    output_tokens: counts.output
+                  }
+                })
+              )
+            }
+          }
+        };
+      }
       if (pendingSend.signal.aborted) {
-        chat.addHistory(nextMessage);
-        return { stopReason: "cancelled" /* Cancelled */ };
+        return { stopReason: "cancelled" };
       }
-      const functionCalls = [];
+      const toolCallRequests = [];
+      let stopReason = "end_turn";
+      let turnModelId = this.context.config.getModel();
+      let turnInputTokens = 0;
+      let turnOutputTokens = 0;
       try {
-        const routingContext = {
-          history: chat.getHistory(
-            /*curated=*/
-            true
-          ),
-          request: nextMessage?.parts ?? [],
-          signal: pendingSend.signal,
-          requestedModel: this.context.config.getModel()
-        };
-        const router = this.context.config.getModelRouterService();
-        const { model } = await router.route(routingContext);
-        const responseStream = await chat.sendMessageStream(
-          { model },
-          nextMessage?.parts ?? [],
-          promptId,
+        const responseStream = this.context.geminiClient.sendMessageStream(
+          currentParts,
           pendingSend.signal,
-          "main" /* MAIN */
+          promptId
         );
-        nextMessage = null;
-        let turnInputTokens = 0;
-        let turnOutputTokens = 0;
-        let turnModelId = model;
-        for await (const resp of responseStream) {
+        for await (const event of responseStream) {
           if (pendingSend.signal.aborted) {
-            return { stopReason: "cancelled" /* Cancelled */ };
-          }
-          if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-            turnInputTokens = resp.value.usageMetadata.promptTokenCount ?? turnInputTokens;
-            turnOutputTokens = resp.value.usageMetadata.candidatesTokenCount ?? turnOutputTokens;
-            if (resp.value.modelVersion) {
-              turnModelId = resp.value.modelVersion;
-            }
+            return { stopReason: "cancelled" };
           }
-          if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
-            const candidate = resp.value.candidates[0];
-            for (const part of candidate.content?.parts ?? []) {
-              if (!part.text) {
-                continue;
-              }
+          switch (event.type) {
+            case "content" /* Content */: {
               const content = {
                 type: "text",
-                text: part.text
+                text: event.value
               };
-              this.sendUpdate({
-                sessionUpdate: part.thought ? "agent_thought_chunk" : "agent_message_chunk",
+              await this.sendUpdate({
+                sessionUpdate: "agent_message_chunk",
                 content
               });
+              break;
+            }
+            case "thought" /* Thought */: {
+              const thoughtText = `**${event.value.subject}**
+${event.value.description}`;
+              await this.sendUpdate({
+                sessionUpdate: "agent_thought_chunk",
+                content: { type: "text", text: thoughtText }
+              });
+              break;
             }
+            case "tool_call_request" /* ToolCallRequest */:
+              toolCallRequests.push(event.value);
+              break;
+            case "finished" /* Finished */: {
+              const usage2 = event.value.usageMetadata;
+              if (usage2) {
+                turnInputTokens = usage2.promptTokenCount ?? turnInputTokens;
+                turnOutputTokens = usage2.candidatesTokenCount ?? turnOutputTokens;
+              }
+              break;
+            }
+            case "model_info" /* ModelInfo */:
+              turnModelId = event.value;
+              break;
+            case "max_session_turns" /* MaxSessionTurns */:
+              stopReason = "max_turn_requests";
+              break;
+            case "loop_detected" /* LoopDetected */:
+              stopReason = "max_turn_requests";
+              break;
+            case "context_window_will_overflow" /* ContextWindowWillOverflow */:
+              stopReason = "max_tokens";
+              break;
+            case "error" /* Error */: {
+              const parseResult = StructuredErrorSchema.safeParse(
+                event.value.error
+              );
+              const errData = parseResult.success ? parseResult.data : {};
+              throw new RequestError(
+                errData.status ?? 500,
+                errData.message ?? "Unknown stream execution error."
+              );
+            }
+            default:
+              break;
           }
-          if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-            functionCalls.push(...resp.value.functionCalls);
-          }
-        }
-        totalInputTokens += turnInputTokens;
-        totalOutputTokens += turnOutputTokens;
-        if (turnInputTokens > 0 || turnOutputTokens > 0) {
-          const existing = modelUsageMap.get(turnModelId) ?? {
-            input: 0,
-            output: 0
-          };
-          existing.input += turnInputTokens;
-          existing.output += turnOutputTokens;
-          modelUsageMap.set(turnModelId, existing);
-        }
-        if (pendingSend.signal.aborted) {
-          return { stopReason: "cancelled" /* Cancelled */ };
         }
       } catch (error) {
         if (getErrorStatus(error) === 429) {
@@ -14019,7 +13975,10 @@ ${thought.description}`;
           );
         }
         if (pendingSend.signal.aborted || error instanceof Error && error.name === "AbortError") {
-          return { stopReason: "cancelled" /* Cancelled */ };
+          return { stopReason: "cancelled" };
+        }
+        if (error instanceof RequestError) {
+          throw error;
         }
         if (error instanceof InvalidStreamError || error && typeof error === "object" && "type" in error && (error.type === "NO_RESPONSE_TEXT" || error.type === "NO_FINISH_REASON" || error.type === "MALFORMED_FUNCTION_CALL" || error.type === "UNEXPECTED_TOOL_CALL")) {
           return {
@@ -14048,14 +14007,53 @@ ${thought.description}`;
           getAcpErrorMessage(error)
         );
       }
-      if (functionCalls.length > 0) {
-        const toolResponseParts = [];
-        for (const fc of functionCalls) {
-          const response = await this.runTool(pendingSend.signal, promptId, fc);
-          toolResponseParts.push(...response);
-        }
-        nextMessage = { role: "user", parts: toolResponseParts };
+      totalInputTokens += turnInputTokens;
+      totalOutputTokens += turnOutputTokens;
+      if (turnInputTokens > 0 || turnOutputTokens > 0) {
+        const existing = modelUsageMap.get(turnModelId) ?? {
+          input: 0,
+          output: 0
+        };
+        existing.input += turnInputTokens;
+        existing.output += turnOutputTokens;
+        modelUsageMap.set(turnModelId, existing);
+      }
+      if (stopReason !== "end_turn") {
+        return {
+          stopReason,
+          _meta: {
+            quota: {
+              token_count: {
+                input_tokens: totalInputTokens,
+                output_tokens: totalOutputTokens
+              },
+              model_usage: Array.from(modelUsageMap.entries()).map(
+                ([modelName, counts]) => ({
+                  model: modelName,
+                  token_count: {
+                    input_tokens: counts.input,
+                    output_tokens: counts.output
+                  }
+                })
+              )
+            }
+          }
+        };
+      }
+      if (toolCallRequests.length === 0) {
+        break;
+      }
+      const toolResponseParts = [];
+      for (const tReq of toolCallRequests) {
+        const fc = {
+          id: tReq.callId,
+          name: tReq.name,
+          args: tReq.args
+        };
+        const response = await this.runTool(pendingSend.signal, promptId, fc);
+        toolResponseParts.push(...response);
       }
+      currentParts = toolResponseParts;
     }
     const modelUsageArray = Array.from(modelUsageMap.entries()).map(
       ([modelName, counts]) => ({
@@ -14102,7 +14100,7 @@ ${thought.description}`;
     await this.connection.sessionUpdate(params);
   }
   async runTool(abortSignal, promptId, fc) {
-    const callId = fc.id ?? GeminiAgent.generateCallId(fc.name || "unknown");
+    const callId = fc.id ?? this.generateCallId(fc.name || "unknown");
     const args = fc.args ?? {};
     const startTime = Date.now();
     const errorResponse = (error) => {
@@ -14394,7 +14392,7 @@ ${thought.description}`;
       let resolvedSuccessfully = false;
       let readDirectly = false;
       try {
-        const absolutePath = path13.resolve(
+        const absolutePath = path12.resolve(
           this.context.config.getTargetDir(),
           pathName
         );
@@ -14470,7 +14468,7 @@ ${thought.description}`;
           }
         }
         if (!validationError) {
-          if ((path13.isAbsolute(pathName) || !isWithinRoot(
+          if ((path12.isAbsolute(pathName) || !isWithinRoot(
             absolutePath,
             this.context.config.getTargetDir()
           )) && !readDirectly) {
@@ -14574,7 +14572,7 @@ ${contentToPush}`;
                 const lines = globResult.llmContent.split("\n");
                 if (lines.length > 1 && lines[1]) {
                   const firstMatchAbsolute = lines[1].trim();
-                  currentPathSpec = path13.relative(
+                  currentPathSpec = path12.relative(
                     this.context.config.getTargetDir(),
                     firstMatchAbsolute
                   );
@@ -14656,7 +14654,7 @@ ${contentToPush}`;
       const toolArgs = {
         include: pathSpecsToRead
       };
-      const callId = GeminiAgent.generateCallId(readManyFilesTool.name);
+      const callId = this.generateCallId(readManyFilesTool.name);
       try {
         const invocation = readManyFilesTool.build(toolArgs);
         await this.sendUpdate({
@@ -14734,321 +14732,524 @@ Content from @${filePathSpecInContent}:
         throw error;
       }
     }
-    if (directContents.length > 0) {
-      const hasReferenceStart = processedQueryParts.some(
-        (p) => "text" in p && typeof p.text === "string" && p.text.includes(REFERENCE_CONTENT_START)
+    if (directContents.length > 0) {
+      const hasReferenceStart = processedQueryParts.some(
+        (p) => "text" in p && typeof p.text === "string" && p.text.includes(REFERENCE_CONTENT_START)
+      );
+      if (!hasReferenceStart) {
+        processedQueryParts.push({
+          text: `
+${REFERENCE_CONTENT_START}`
+        });
+      }
+      for (const item of directContents) {
+        processedQueryParts.push({
+          text: `
+Content from @${item.spec}:
+`
+        });
+        if (item.content) {
+          processedQueryParts.push({ text: item.content });
+        } else if (item.part) {
+          processedQueryParts.push(item.part);
+        }
+      }
+    }
+    if (embeddedContext.length > 0) {
+      processedQueryParts.push({
+        text: "\n--- Content from referenced context ---"
+      });
+      for (const contextPart of embeddedContext) {
+        processedQueryParts.push({
+          text: `
+Content from @${contextPart.uri}:
+`
+        });
+        if ("text" in contextPart) {
+          processedQueryParts.push({
+            text: contextPart.text
+          });
+        } else {
+          processedQueryParts.push({
+            inlineData: {
+              mimeType: contextPart.mimeType ?? "application/octet-stream",
+              data: contextPart.blob
+            }
+          });
+        }
+      }
+    }
+    return processedQueryParts;
+  }
+  debug(msg) {
+    if (this.context.config.getDebugMode()) {
+      debugLogger.warn(msg);
+    }
+  }
+};
+
+// packages/cli/src/acp/acpFileSystemService.ts
+import os5 from "node:os";
+import path13 from "node:path";
+var AcpFileSystemService = class {
+  constructor(connection, sessionId, capabilities, fallback, root) {
+    this.connection = connection;
+    this.sessionId = sessionId;
+    this.capabilities = capabilities;
+    this.fallback = fallback;
+    this.root = root;
+  }
+  geminiDir = path13.join(os5.homedir(), ".gemini");
+  shouldUseFallback(filePath) {
+    return !isWithinRoot(filePath, this.root) || isWithinRoot(filePath, this.geminiDir);
+  }
+  normalizeFileSystemError(err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    if (errorMessage.includes("Resource not found") || errorMessage.includes("ENOENT") || errorMessage.includes("does not exist") || errorMessage.includes("No such file")) {
+      const newErr = new Error(errorMessage);
+      newErr.code = "ENOENT";
+      throw newErr;
+    }
+    throw err;
+  }
+  async readTextFile(filePath) {
+    if (!this.capabilities.readTextFile || this.shouldUseFallback(filePath)) {
+      return this.fallback.readTextFile(filePath);
+    }
+    try {
+      const response = await this.connection.readTextFile({
+        path: filePath,
+        sessionId: this.sessionId
+      });
+      return response.content;
+    } catch (err) {
+      this.normalizeFileSystemError(err);
+    }
+  }
+  async writeTextFile(filePath, content) {
+    if (!this.capabilities.writeTextFile || this.shouldUseFallback(filePath)) {
+      return this.fallback.writeTextFile(filePath, content);
+    }
+    try {
+      await this.connection.writeTextFile({
+        path: filePath,
+        content,
+        sessionId: this.sessionId
+      });
+    } catch (err) {
+      this.normalizeFileSystemError(err);
+    }
+  }
+};
+
+// packages/cli/src/acp/acpSessionManager.ts
+var AcpSessionManager = class {
+  constructor(settings, argv, connection) {
+    this.settings = settings;
+    this.argv = argv;
+    this.connection = connection;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  clientCapabilities;
+  setClientCapabilities(capabilities) {
+    this.clientCapabilities = capabilities;
+  }
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  async newSession({ cwd, mcpServers }, authDetails) {
+    const sessionId = randomUUID2();
+    const loadedSettings = loadSettings(cwd);
+    const config = await this.newSessionConfig(
+      sessionId,
+      cwd,
+      mcpServers,
+      loadedSettings
+    );
+    const authType = loadedSettings.merged.security.auth.selectedType || "gemini-api-key" /* USE_GEMINI */;
+    let isAuthenticated = false;
+    let authErrorMessage = "";
+    try {
+      await config.refreshAuth(
+        authType,
+        authDetails.apiKey,
+        authDetails.baseUrl,
+        authDetails.customHeaders
+      );
+      isAuthenticated = true;
+      const contentGeneratorConfig = config.getContentGeneratorConfig();
+      if (authType === "gemini-api-key" /* USE_GEMINI */ && (!contentGeneratorConfig || !contentGeneratorConfig.apiKey)) {
+        isAuthenticated = false;
+        authErrorMessage = "Gemini API key is missing or not configured.";
+      }
+    } catch (e) {
+      isAuthenticated = false;
+      authErrorMessage = getAcpErrorMessage(e);
+      debugLogger.error(
+        `Authentication failed: ${e instanceof Error ? e.stack : e}`
+      );
+    }
+    if (!isAuthenticated) {
+      throw new RequestError(
+        -32e3,
+        authErrorMessage || "Authentication required."
+      );
+    }
+    if (this.clientCapabilities?.fs) {
+      const acpFileSystemService = new AcpFileSystemService(
+        this.connection,
+        sessionId,
+        this.clientCapabilities.fs,
+        config.getFileSystemService(),
+        cwd
+      );
+      config.setFileSystemService(acpFileSystemService);
+    }
+    await config.initialize();
+    startupProfiler.flush(config);
+    startAutoMemoryIfEnabled(config);
+    const geminiClient = config.getGeminiClient();
+    const chat = await geminiClient.startChat();
+    const session = new Session(
+      sessionId,
+      chat,
+      config,
+      this.connection,
+      this.settings
+    );
+    this.sessions.set(sessionId, session);
+    setTimeout(() => {
+      session.sendAvailableCommands();
+    }, 0);
+    const { availableModels, currentModelId } = buildAvailableModels(
+      config,
+      loadedSettings
+    );
+    const response = {
+      sessionId,
+      modes: {
+        availableModes: buildAvailableModes(config.isPlanEnabled()),
+        currentModeId: config.getApprovalMode()
+      },
+      models: {
+        availableModels,
+        currentModelId
+      }
+    };
+    return response;
+  }
+  async loadSession({ sessionId, cwd, mcpServers }, authDetails) {
+    const config = await this.initializeSessionConfig(
+      sessionId,
+      cwd,
+      mcpServers,
+      authDetails
+    );
+    const sessionSelector = new SessionSelector(config.storage);
+    const { sessionData, sessionPath } = await sessionSelector.resolveSession(sessionId);
+    const clientHistory = convertSessionToClientHistory(sessionData.messages);
+    const geminiClient = config.getGeminiClient();
+    await geminiClient.initialize();
+    await geminiClient.resumeChat(clientHistory, {
+      conversation: sessionData,
+      filePath: sessionPath
+    });
+    const session = new Session(
+      sessionId,
+      geminiClient.getChat(),
+      config,
+      this.connection,
+      this.settings
+    );
+    this.sessions.set(sessionId, session);
+    session.streamHistory(sessionData.messages);
+    setTimeout(() => {
+      session.sendAvailableCommands();
+    }, 0);
+    const { availableModels, currentModelId } = buildAvailableModels(
+      config,
+      this.settings
+    );
+    const response = {
+      modes: {
+        availableModes: buildAvailableModes(config.isPlanEnabled()),
+        currentModeId: config.getApprovalMode()
+      },
+      models: {
+        availableModels,
+        currentModelId
+      }
+    };
+    return response;
+  }
+  async initializeSessionConfig(sessionId, cwd, mcpServers, authDetails) {
+    const selectedAuthType = this.settings.merged.security.auth.selectedType;
+    if (!selectedAuthType) {
+      throw RequestError.authRequired();
+    }
+    const config = await this.newSessionConfig(sessionId, cwd, mcpServers);
+    try {
+      await config.refreshAuth(
+        selectedAuthType,
+        authDetails.apiKey,
+        authDetails.baseUrl,
+        authDetails.customHeaders
+      );
+    } catch (e) {
+      debugLogger.error(`Authentication failed: ${e}`);
+      throw RequestError.authRequired();
+    }
+    if (this.clientCapabilities?.fs) {
+      const acpFileSystemService = new AcpFileSystemService(
+        this.connection,
+        sessionId,
+        this.clientCapabilities.fs,
+        config.getFileSystemService(),
+        cwd
       );
-      if (!hasReferenceStart) {
-        processedQueryParts.push({
-          text: `
-${REFERENCE_CONTENT_START}`
-        });
-      }
-      for (const item of directContents) {
-        processedQueryParts.push({
-          text: `
-Content from @${item.spec}:
-`
-        });
-        if (item.content) {
-          processedQueryParts.push({ text: item.content });
-        } else if (item.part) {
-          processedQueryParts.push(item.part);
-        }
-      }
+      config.setFileSystemService(acpFileSystemService);
     }
-    if (embeddedContext.length > 0) {
-      processedQueryParts.push({
-        text: "\n--- Content from referenced context ---"
-      });
-      for (const contextPart of embeddedContext) {
-        processedQueryParts.push({
-          text: `
-Content from @${contextPart.uri}:
-`
-        });
-        if ("text" in contextPart) {
-          processedQueryParts.push({
-            text: contextPart.text
-          });
-        } else {
-          processedQueryParts.push({
-            inlineData: {
-              mimeType: contextPart.mimeType ?? "application/octet-stream",
-              data: contextPart.blob
-            }
-          });
+    await config.initialize();
+    startupProfiler.flush(config);
+    startAutoMemoryIfEnabled(config);
+    return config;
+  }
+  async newSessionConfig(sessionId, cwd, mcpServers, loadedSettings) {
+    const currentSettings = loadedSettings || this.settings;
+    const mergedMcpServers = { ...currentSettings.merged.mcpServers };
+    for (const server of mcpServers) {
+      if ("type" in server && (server.type === "sse" || server.type === "http")) {
+        const headers = Object.fromEntries(
+          server.headers.map(({ name, value }) => [name, value])
+        );
+        mergedMcpServers[server.name] = new MCPServerConfig(
+          void 0,
+          // command
+          void 0,
+          // args
+          void 0,
+          // env
+          void 0,
+          // cwd
+          server.type === "sse" ? server.url : void 0,
+          // url (sse)
+          server.type === "http" ? server.url : void 0,
+          // httpUrl
+          headers
+        );
+      } else if ("command" in server) {
+        const env2 = {};
+        for (const { name: envName, value } of server.env) {
+          env2[envName] = value;
         }
+        mergedMcpServers[server.name] = new MCPServerConfig(
+          server.command,
+          server.args,
+          env2,
+          cwd
+        );
       }
     }
-    return processedQueryParts;
-  }
-  debug(msg) {
-    if (this.context.config.getDebugMode()) {
-      debugLogger.warn(msg);
-    }
+    const settings = {
+      ...currentSettings.merged,
+      mcpServers: mergedMcpServers
+    };
+    const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });
+    createPolicyUpdater(
+      config.getPolicyEngine(),
+      config.messageBus,
+      config.storage
+    );
+    return config;
   }
 };
-function toToolCallContent(toolResult) {
-  if (toolResult.error?.message) {
-    throw new Error(toolResult.error.message);
+
+// packages/cli/src/acp/acpRpcDispatcher.ts
+var GeminiAgent = class {
+  constructor(context, settings, argv, connection) {
+    this.context = context;
+    this.settings = settings;
+    this.sessionManager = new AcpSessionManager(settings, argv, connection);
   }
-  if (toolResult.returnDisplay) {
-    if (typeof toolResult.returnDisplay === "string") {
-      return {
-        type: "content",
-        content: { type: "text", text: toolResult.returnDisplay }
-      };
-    } else {
-      if ("fileName" in toolResult.returnDisplay) {
-        return {
-          type: "diff",
-          path: toolResult.returnDisplay.filePath ?? toolResult.returnDisplay.fileName,
-          oldText: toolResult.returnDisplay.originalContent,
-          newText: toolResult.returnDisplay.newContent,
-          _meta: {
-            kind: !toolResult.returnDisplay.originalContent ? "add" : toolResult.returnDisplay.newContent === "" ? "delete" : "modify"
-          }
-        };
-      }
-      return null;
+  apiKey;
+  baseUrl;
+  customHeaders;
+  sessionManager;
+  async initialize(args) {
+    if (args.clientCapabilities) {
+      this.sessionManager.setClientCapabilities(args.clientCapabilities);
     }
-  } else {
-    return null;
-  }
-}
-var basicPermissionOptions = [
-  {
-    optionId: "proceed_once" /* ProceedOnce */,
-    name: "Allow",
-    kind: "allow_once"
-  },
-  {
-    optionId: "cancel" /* Cancel */,
-    name: "Reject",
-    kind: "reject_once"
-  }
-];
-function toPermissionOptions(confirmation, config, enablePermanentToolApproval = false) {
-  const disableAlwaysAllow = config.getDisableAlwaysAllow();
-  const options = [];
-  if (!disableAlwaysAllow) {
-    switch (confirmation.type) {
-      case "edit":
-        options.push({
-          optionId: "proceed_always" /* ProceedAlways */,
-          name: "Allow for this session",
-          kind: "allow_always"
-        });
-        if (enablePermanentToolApproval) {
-          options.push({
-            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
-            name: "Allow for this file in all future sessions",
-            kind: "allow_always"
-          });
-        }
-        break;
-      case "exec":
-        options.push({
-          optionId: "proceed_always" /* ProceedAlways */,
-          name: "Allow for this session",
-          kind: "allow_always"
-        });
-        if (enablePermanentToolApproval) {
-          options.push({
-            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
-            name: "Allow this command for all future sessions",
-            kind: "allow_always"
-          });
+    const authMethods = [
+      {
+        id: "oauth-personal" /* LOGIN_WITH_GOOGLE */,
+        name: "Log in with Google",
+        description: "Log in with your Google account"
+      },
+      {
+        id: "gemini-api-key" /* USE_GEMINI */,
+        name: "Gemini API key",
+        description: "Use an API key with Gemini Developer API",
+        _meta: {
+          "api-key": {
+            provider: "google"
+          }
         }
-        break;
-      case "mcp":
-        options.push(
-          {
-            optionId: "proceed_always_server" /* ProceedAlwaysServer */,
-            name: "Allow all server tools for this session",
-            kind: "allow_always"
-          },
-          {
-            optionId: "proceed_always_tool" /* ProceedAlwaysTool */,
-            name: "Allow tool for this session",
-            kind: "allow_always"
+      },
+      {
+        id: "vertex-ai" /* USE_VERTEX_AI */,
+        name: "Vertex AI",
+        description: "Use an API key with Vertex AI GenAI API"
+      },
+      {
+        id: "gateway" /* GATEWAY */,
+        name: "AI API Gateway",
+        description: "Use a custom AI API Gateway",
+        _meta: {
+          gateway: {
+            protocol: "google",
+            restartRequired: "false"
           }
-        );
-        if (enablePermanentToolApproval) {
-          options.push({
-            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
-            name: "Allow tool for all future sessions",
-            kind: "allow_always"
-          });
         }
-        break;
-      case "info":
-        options.push({
-          optionId: "proceed_always" /* ProceedAlways */,
-          name: "Allow for this session",
-          kind: "allow_always"
-        });
-        if (enablePermanentToolApproval) {
-          options.push({
-            optionId: "proceed_always_and_save" /* ProceedAlwaysAndSave */,
-            name: "Allow for all future sessions",
-            kind: "allow_always"
-          });
+      }
+    ];
+    await this.context.config.initialize();
+    const version = await getVersion();
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      authMethods,
+      agentInfo: {
+        name: "gemini-cli",
+        title: "Gemini CLI",
+        version
+      },
+      agentCapabilities: {
+        loadSession: true,
+        promptCapabilities: {
+          image: true,
+          audio: true,
+          embeddedContext: true
+        },
+        mcpCapabilities: {
+          http: true,
+          sse: true
         }
-        break;
-      case "ask_user":
-      case "exit_plan_mode":
-        break;
-      default:
-        break;
-    }
+      }
+    };
   }
-  options.push(...basicPermissionOptions);
-  switch (confirmation.type) {
-    case "edit":
-    case "exec":
-    case "mcp":
-    case "info":
-    case "ask_user":
-    case "exit_plan_mode":
-    case "sandbox_expansion":
-      break;
-    default: {
-      const unreachable = confirmation;
-      throw new Error(`Unexpected: ${unreachable}`);
+  async authenticate(req) {
+    const { methodId } = req;
+    const method = external_exports.nativeEnum(AuthType).parse(methodId);
+    const selectedAuthType = this.settings.merged.security.auth.selectedType;
+    if (selectedAuthType && selectedAuthType !== method) {
+      await clearCachedCredentialFile();
     }
-  }
-  return options;
-}
-function toAcpToolKind(kind) {
-  switch (kind) {
-    case "read" /* Read */:
-    case "edit" /* Edit */:
-    case "execute" /* Execute */:
-    case "search" /* Search */:
-    case "delete" /* Delete */:
-    case "move" /* Move */:
-    case "think" /* Think */:
-    case "fetch" /* Fetch */:
-    case "switch_mode" /* SwitchMode */:
-    case "other" /* Other */:
-      return kind;
-    case "agent" /* Agent */:
-      return "think";
-    case "plan" /* Plan */:
-    case "communicate" /* Communicate */:
-    default:
-      return "other";
-  }
-}
-function buildAvailableModes(isPlanEnabled) {
-  const modes = [
-    {
-      id: "default" /* DEFAULT */,
-      name: "Default",
-      description: "Prompts for approval"
-    },
-    {
-      id: "autoEdit" /* AUTO_EDIT */,
-      name: "Auto Edit",
-      description: "Auto-approves edit tools"
-    },
-    {
-      id: "yolo" /* YOLO */,
-      name: "YOLO",
-      description: "Auto-approves all tools"
+    const meta = hasMeta(req) ? req._meta : void 0;
+    const apiKey = typeof meta?.["api-key"] === "string" ? meta["api-key"] : void 0;
+    try {
+      if (apiKey) {
+        this.apiKey = apiKey;
+      }
+      const gatewaySchema = external_exports.object({
+        baseUrl: external_exports.string().optional(),
+        headers: external_exports.record(external_exports.string()).optional()
+      });
+      let baseUrl;
+      let headers;
+      if (meta?.["gateway"]) {
+        const result = gatewaySchema.safeParse(meta["gateway"]);
+        if (result.success) {
+          baseUrl = result.data.baseUrl;
+          headers = result.data.headers;
+        } else {
+          throw new RequestError(
+            -32602,
+            `Malformed gateway payload: ${result.error.message}`
+          );
+        }
+      }
+      this.baseUrl = baseUrl;
+      this.customHeaders = headers;
+      await this.context.config.refreshAuth(
+        method,
+        apiKey ?? this.apiKey,
+        baseUrl,
+        headers
+      );
+    } catch (e) {
+      throw new RequestError(-32e3, getAcpErrorMessage(e));
     }
-  ];
-  if (isPlanEnabled) {
-    modes.push({
-      id: "plan" /* PLAN */,
-      name: "Plan",
-      description: "Read-only mode"
-    });
+    this.settings.setValue(
+      "User" /* User */,
+      "security.auth.selectedType",
+      method
+    );
   }
-  return modes;
-}
-function buildAvailableModels(config, settings) {
-  const preferredModel = config.getModel() || DEFAULT_GEMINI_MODEL_AUTO;
-  const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
-  const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
-  const useGemini31FlashLite = config.getGemini31FlashLiteLaunchedSync?.() ?? false;
-  const selectedAuthType = settings.merged.security.auth.selectedType;
-  const useCustomToolModel = useGemini31 && selectedAuthType === "gemini-api-key" /* USE_GEMINI */;
-  if (config.getExperimentalDynamicModelConfiguration?.() === true && config.getModelConfigService) {
-    const options = config.getModelConfigService().getAvailableModelOptions({
-      useGemini3_1: useGemini31,
-      useGemini3_1FlashLite: useGemini31FlashLite,
-      useCustomTools: useCustomToolModel,
-      hasAccessToPreview: shouldShowPreviewModels
-    });
+  getAuthDetails() {
     return {
-      availableModels: options,
-      currentModelId: preferredModel
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      customHeaders: this.customHeaders
     };
   }
-  const mainOptions = [
-    {
-      value: DEFAULT_GEMINI_MODEL_AUTO,
-      title: getDisplayString(DEFAULT_GEMINI_MODEL_AUTO),
-      description: "Let Gemini CLI decide the best model for the task: gemini-2.5-pro, gemini-2.5-flash"
+  async newSession(params) {
+    return this.sessionManager.newSession(params, this.getAuthDetails());
+  }
+  async loadSession(params) {
+    return this.sessionManager.loadSession(params, this.getAuthDetails());
+  }
+  async cancel(params) {
+    const session = this.sessionManager.getSession(params.sessionId);
+    if (!session) {
+      throw new RequestError(
+        -32602,
+        `Session not found: ${params.sessionId}`
+      );
     }
-  ];
-  if (shouldShowPreviewModels) {
-    mainOptions.unshift({
-      value: PREVIEW_GEMINI_MODEL_AUTO,
-      title: getDisplayString(PREVIEW_GEMINI_MODEL_AUTO),
-      description: useGemini31 ? "Let Gemini CLI decide the best model for the task: gemini-3.1-pro, gemini-3-flash" : "Let Gemini CLI decide the best model for the task: gemini-3-pro, gemini-3-flash"
-    });
+    await session.cancelPendingPrompt();
   }
-  const manualOptions = [
-    {
-      value: DEFAULT_GEMINI_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_MODEL)
-    },
-    {
-      value: DEFAULT_GEMINI_FLASH_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_FLASH_MODEL)
-    },
-    {
-      value: DEFAULT_GEMINI_FLASH_LITE_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_FLASH_LITE_MODEL)
+  async prompt(params) {
+    const session = this.sessionManager.getSession(params.sessionId);
+    if (!session) {
+      throw new RequestError(
+        -32602,
+        `Session not found: ${params.sessionId}`
+      );
     }
-  ];
-  if (shouldShowPreviewModels) {
-    const previewProModel = useGemini31 ? PREVIEW_GEMINI_3_1_MODEL : PREVIEW_GEMINI_MODEL;
-    const previewProValue = useCustomToolModel ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL : previewProModel;
-    const previewOptions = [
-      {
-        value: previewProValue,
-        title: getDisplayString(previewProModel)
-      },
-      {
-        value: PREVIEW_GEMINI_FLASH_MODEL,
-        title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL)
-      }
-    ];
-    if (useGemini31FlashLite) {
-      previewOptions.push({
-        value: PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
-        title: getDisplayString(PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL)
-      });
+    return session.prompt(params);
+  }
+  async setSessionMode(params) {
+    const session = this.sessionManager.getSession(params.sessionId);
+    if (!session) {
+      throw new RequestError(
+        -32602,
+        `Session not found: ${params.sessionId}`
+      );
     }
-    manualOptions.unshift(...previewOptions);
+    return session.setMode(params.modeId);
   }
-  const scaleOptions = (options) => options.map((o) => ({
-    modelId: o.value,
-    name: o.title,
-    description: o.description
-  }));
-  return {
-    availableModels: [
-      ...scaleOptions(mainOptions),
-      ...scaleOptions(manualOptions)
-    ],
-    currentModelId: preferredModel
-  };
+  async unstable_setSessionModel(params) {
+    const session = this.sessionManager.getSession(params.sessionId);
+    if (!session) {
+      throw new RequestError(
+        -32602,
+        `Session not found: ${params.sessionId}`
+      );
+    }
+    return session.setModel(params.modelId);
+  }
+};
+
+// packages/cli/src/acp/acpStdioTransport.ts
+async function runAcpClient(config, settings, argv) {
+  const { stdout: workingStdout } = createWorkingStdio();
+  const stdout = Writable.toWeb(workingStdout);
+  const stdin = Readable.toWeb(process.stdin);
+  const stream = ndJsonStream(stdout, stdin);
+  const connection = new AgentSideConnection(
+    (connection2) => new GeminiAgent(config, settings, argv, connection2),
+    stream
+  );
+  await connection.closed.finally(runExitCleanup);
 }
 
 // packages/cli/src/validateNonInterActiveAuth.ts
@@ -15410,7 +15611,7 @@ function getNodeMemoryArgs(isDebugMode2) {
       `Current heap size ${currentMaxOldSpaceSizeMb.toFixed(2)} MB`
     );
   }
-  if (process.env["GEMINI_CLI_NO_RELAUNCH"]) {
+  if (process.env["IS_BINARY"] === "true" || process.env["GEMINI_CLI_NO_RELAUNCH"] || process.env["SANDBOX"]) {
     return [];
   }
   const args = [];
@@ -15495,7 +15696,7 @@ async function resolveSessionId(resumeArg, sessionIdArg) {
   }
 }
 async function startInteractiveUI(config, settings, startupWarnings, workspaceRoot = process.cwd(), resumedSessionData, initializationResult) {
-  const { startInteractiveUI: doStartUI } = await import("./interactiveCli-JOX7MFFH.js");
+  const { startInteractiveUI: doStartUI } = await import("./interactiveCli-ZS4ZQWNV.js");
   await doStartUI(
     config,
     settings,
@@ -15506,12 +15707,13 @@ async function startInteractiveUI(config, settings, startupWarnings, workspaceRo
   );
 }
 async function main() {
+  let config;
   const cliStartupHandle = startupProfiler.start("cli_startup");
   const adminControlsListner = setupAdminControlsListener();
   registerCleanup(adminControlsListner.cleanup);
   const cleanupStdio = patchStdio();
   registerSyncCleanup(() => {
-    initializeOutputListenersAndFlush();
+    initializeOutputListenersAndFlush(config);
     cleanupStdio();
   });
   setupUnhandledRejectionHandler();
@@ -15606,7 +15808,8 @@ async function main() {
     }
   }
   const partialConfig = await loadCliConfig(settings.merged, sessionId, argv, {
-    projectHooks: settings.workspace.settings.hooks
+    projectHooks: settings.workspace.settings.hooks,
+    skipExtensions: true
   });
   adminControlsListner.setConfig(partialConfig);
   let initialAuthFailed = false;
@@ -15691,7 +15894,7 @@ ${finalArgs[promptIndex + 1]}`;
   }
   {
     const loadConfigHandle = startupProfiler.start("load_cli_config");
-    const config = await loadCliConfig(settings.merged, sessionId, argv, {
+    config = await loadCliConfig(settings.merged, sessionId, argv, {
       projectHooks: settings.workspace.settings.hooks,
       worktreeSettings: worktreeInfo
     });
@@ -15699,7 +15902,7 @@ ${finalArgs[promptIndex + 1]}`;
     await config.storage.initialize();
     adminControlsListner.setConfig(config);
     if (config.isInteractive() && settings.merged.general.devtools) {
-      const { setupInitialActivityLogger } = await import("./devtoolsService-QXOHXSMJ.js");
+      const { setupInitialActivityLogger } = await import("./devtoolsService-DFWZ34A5.js");
       setupInitialActivityLogger(config);
     }
     registerTelemetryConfig(config);
@@ -15758,7 +15961,7 @@ ${finalArgs[promptIndex + 1]}`;
     const initAppHandle = startupProfiler.start("initialize_app");
     const initializationResult = await initializeApp(config, settings);
     initAppHandle?.end();
-    import("./liteRtServerManager-VGYEHFUE.js").then(({ LiteRtServerManager }) => {
+    import("./liteRtServerManager-IDNLXYHP.js").then(({ LiteRtServerManager }) => {
       const mergedGemma = settings.merged.experimental?.gemmaModelRouter;
       if (!mergedGemma) return;
       const userGemma = settings.forScope("User" /* User */).settings.experimental?.gemmaModelRouter;
@@ -15865,7 +16068,7 @@ ${input}` : wrappedContext;
     if (config.getDebugMode()) {
       debugLogger.log("Session ID: %s", sessionId);
     }
-    initializeOutputListenersAndFlush();
+    initializeOutputListenersAndFlush(config);
     await runNonInteractive2({
       config,
       settings,
@@ -15877,7 +16080,7 @@ ${input}` : wrappedContext;
     process.exit(ExitCodes.SUCCESS);
   }
 }
-function initializeOutputListenersAndFlush() {
+function initializeOutputListenersAndFlush(config) {
   if (coreEvents.listenerCount("output" /* Output */) === 0) {
     coreEvents.on("output" /* Output */, (payload) => {
       if (payload.isStderr) {
@@ -15886,22 +16089,38 @@ function initializeOutputListenersAndFlush() {
         writeToStdout(payload.chunk, payload.encoding);
       }
     });
-    if (coreEvents.listenerCount("console-log" /* ConsoleLog */) === 0) {
-      coreEvents.on("console-log" /* ConsoleLog */, (payload) => {
-        if (payload.type === "error" || payload.type === "warn") {
-          writeToStderr(payload.content + "\n");
-        } else {
-          writeToStderr(payload.content + "\n");
+  }
+  if (coreEvents.listenerCount("console-log" /* ConsoleLog */) === 0) {
+    coreEvents.on("console-log" /* ConsoleLog */, (payload) => {
+      if (payload.type === "error" || payload.type === "warn") {
+        writeToStderr(payload.content + "\n");
+      } else {
+        writeToStderr(payload.content + "\n");
+      }
+    });
+  }
+  if (coreEvents.listenerCount("user-feedback" /* UserFeedback */) === 0) {
+    coreEvents.on("user-feedback" /* UserFeedback */, (payload) => {
+      writeToStderr(payload.message + "\n");
+    });
+  }
+  const outputFormat = config?.getOutputFormat();
+  const forceToStderr = outputFormat === "json" || config === void 0;
+  coreEvents.drainBacklogs(
+    (event, args) => {
+      if (forceToStderr && event === "output" /* Output */) {
+        const payload = args[0];
+        if (!payload.isStderr) {
+          return {
+            event,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            args: [{ ...payload, isStderr: true }]
+          };
         }
-      });
-    }
-    if (coreEvents.listenerCount("user-feedback" /* UserFeedback */) === 0) {
-      coreEvents.on("user-feedback" /* UserFeedback */, (payload) => {
-        writeToStderr(payload.message + "\n");
-      });
+      }
+      return { event, args };
     }
-  }
-  coreEvents.drainBacklogs();
+  );
 }
 function setupAdminControlsListener() {
   let pendingSettings;