@google/gemini-cli-a2a-server 0.18.0-nightly.20251120.2231497b1 → 0.18.0-preview.0

package/dist/a2a-server.mjs

@@ -84519,28 +84519,48 @@ var init_events = __esm({
       CoreEvent2["UserFeedback"] = "user-feedback";
       CoreEvent2["FallbackModeChanged"] = "fallback-mode-changed";
       CoreEvent2["ModelChanged"] = "model-changed";
+      CoreEvent2["ConsoleLog"] = "console-log";
+      CoreEvent2["Output"] = "output";
       CoreEvent2["MemoryChanged"] = "memory-changed";
+      CoreEvent2["ExternalEditorClosed"] = "external-editor-closed";
     })(CoreEvent || (CoreEvent = {}));
     CoreEventEmitter = class _CoreEventEmitter extends EventEmitter4 {
-      _feedbackBacklog = [];
+      _eventBacklog = [];
       static MAX_BACKLOG_SIZE = 1e4;
       constructor() {
         super();
       }
+      _emitOrQueue(event, ...args2) {
+        if (this.listenerCount(event) === 0) {
+          if (this._eventBacklog.length >= _CoreEventEmitter.MAX_BACKLOG_SIZE) {
+            this._eventBacklog.shift();
+          }
+          this._eventBacklog.push({ event, args: args2 });
+        } else {
+          this.emit(event, ...args2);
+        }
+      }
       /**
        * Sends actionable feedback to the user.
        * Buffers automatically if the UI hasn't subscribed yet.
        */
       emitFeedback(severity, message, error) {
         const payload = { severity, message, error };
-        if (this.listenerCount(CoreEvent.UserFeedback) === 0) {
-          if (this._feedbackBacklog.length >= _CoreEventEmitter.MAX_BACKLOG_SIZE) {
-            this._feedbackBacklog.shift();
-          }
-          this._feedbackBacklog.push(payload);
-        } else {
-          this.emit(CoreEvent.UserFeedback, payload);
-        }
+        this._emitOrQueue(CoreEvent.UserFeedback, payload);
+      }
+      /**
+       * Broadcasts a console log message.
+       */
+      emitConsoleLog(type, content) {
+        const payload = { type, content };
+        this._emitOrQueue(CoreEvent.ConsoleLog, payload);
+      }
+      /**
+       * Broadcasts stdout/stderr output.
+       */
+      emitOutput(isStderr, chunk2, encoding) {
+        const payload = { isStderr, chunk: chunk2, encoding };
+        this._emitOrQueue(CoreEvent.Output, payload);
       }
       /**
        * Notifies subscribers that fallback mode has changed.
@@ -84561,11 +84581,11 @@ var init_events = __esm({
        * Flushes buffered messages. Call this immediately after primary UI listener
        * subscribes.
        */
-      drainFeedbackBacklog() {
-        const backlog = [...this._feedbackBacklog];
-        this._feedbackBacklog.length = 0;
-        for (const payload of backlog) {
-          this.emit(CoreEvent.UserFeedback, payload);
+      drainBacklogs() {
+        const backlog = [...this._eventBacklog];
+        this._eventBacklog.length = 0;
+        for (const item of backlog) {
+          this.emit(item.event, ...item.args);
         }
       }
     };
@@ -307570,8 +307590,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 = "2231497b1";
-var CLI_VERSION = "0.18.0-nightly.20251120.2231497b1";
+var GIT_COMMIT_INFO = "8e531dc02";
+var CLI_VERSION = "0.18.0-preview.0";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -310430,7 +310450,7 @@ async function createContentGenerator(config2, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version3 = "0.18.0-nightly.20251120.2231497b1";
+    const version3 = "0.18.0-preview.0";
     const userAgent = `GeminiCLI/${version3} (${process.platform}; ${process.arch})`;
     const baseHeaders = {
       "User-Agent": userAgent
@@ -342218,6 +342238,7 @@ import * as crypto19 from "node:crypto";
 
 // packages/core/dist/src/utils/editor.js
 import { execSync, spawn as spawn6, spawnSync as spawnSync2 } from "node:child_process";
+init_events();
 function isValidEditorType(editor) {
   return [
     "vscode",
@@ -342303,7 +342324,7 @@ function getDiffCommand(oldPath, newPath, editor) {
       return null;
   }
 }
-async function openDiff(oldPath, newPath, editor, onEditorClose) {
+async function openDiff(oldPath, newPath, editor) {
   const diffCommand = getDiffCommand(oldPath, newPath, editor);
   if (!diffCommand) {
     debugLogger.error("No diff tool available. Install a supported editor.");
@@ -342322,7 +342343,7 @@ async function openDiff(oldPath, newPath, editor, onEditorClose) {
         throw new Error(`${editor} exited with code ${result.status}`);
       }
     } finally {
-      onEditorClose();
+      coreEvents.emit(CoreEvent.ExternalEditorClosed);
     }
     return;
   }
@@ -342412,14 +342433,14 @@ function deleteTempFiles(oldPath, newPath, dirPath) {
     debugLogger.error(`Error deleting temp diff directory: ${dirPath}`);
   }
 }
-async function modifyWithEditor(originalParams, modifyContext, editorType, _abortSignal, onEditorClose, overrides) {
+async function modifyWithEditor(originalParams, modifyContext, editorType, _abortSignal, overrides) {
   const hasCurrentOverride = overrides !== void 0 && "currentContent" in overrides;
   const hasProposedOverride = overrides !== void 0 && "proposedContent" in overrides;
   const currentContent = hasCurrentOverride ? overrides.currentContent ?? "" : await modifyContext.getCurrentContent(originalParams);
   const proposedContent = hasProposedOverride ? overrides.proposedContent ?? "" : await modifyContext.getProposedContent(originalParams);
   const { oldPath, newPath, dirPath } = createTempFilesForModify(currentContent ?? "", proposedContent ?? "", modifyContext.getFilePath(originalParams));
   try {
-    await openDiff(oldPath, newPath, editorType, onEditorClose);
+    await openDiff(oldPath, newPath, editorType);
     const result = getUpdatedParams(oldPath, newPath, originalParams, modifyContext);
     return result;
   } finally {
@@ -355800,7 +355821,6 @@ var CoreToolScheduler = class _CoreToolScheduler {
   onToolCallsUpdate;
   getPreferredEditor;
   config;
-  onEditorClose;
   isFinalizingToolCalls = false;
   isScheduling = false;
   isCancelling = false;
@@ -355813,7 +355833,6 @@ var CoreToolScheduler = class _CoreToolScheduler {
     this.onAllToolCallsComplete = options2.onAllToolCallsComplete;
     this.onToolCallsUpdate = options2.onToolCallsUpdate;
     this.getPreferredEditor = options2.getPreferredEditor;
-    this.onEditorClose = options2.onEditorClose;
     if (this.config.getEnableMessageBusIntegration()) {
       const messageBus = this.config.getMessageBus();
       if (!_CoreToolScheduler.subscribedMessageBuses.has(messageBus)) {
@@ -356186,7 +356205,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
           currentContent: waitingToolCall.confirmationDetails.originalContent,
           proposedContent: waitingToolCall.confirmationDetails.newContent
         } : void 0;
-        const { updatedParams, updatedDiff } = await modifyWithEditor(waitingToolCall.request.args, modifyContext, editorType, signal, this.onEditorClose, contentOverrides);
+        const { updatedParams, updatedDiff } = await modifyWithEditor(waitingToolCall.request.args, modifyContext, editorType, signal, contentOverrides);
         this.setArgsInternal(callId, updatedParams);
         this.setStatusInternal(callId, "awaiting_approval", signal, {
           ...waitingToolCall.confirmationDetails,
@@ -356953,16 +356972,18 @@ var InvalidStreamError = class extends Error {
 };
 var GeminiChat = class {
   config;
-  generationConfig;
+  systemInstruction;
+  tools;
   history;
   // A promise to represent the current state of the message being sent to the
   // model.
   sendPromise = Promise.resolve();
   chatRecordingService;
   lastPromptTokenCount;
-  constructor(config2, generationConfig = {}, history = [], resumedSessionData) {
+  constructor(config2, systemInstruction = "", tools = [], history = [], resumedSessionData) {
     this.config = config2;
-    this.generationConfig = generationConfig;
+    this.systemInstruction = systemInstruction;
+    this.tools = tools;
     this.history = history;
     validateHistory2(history);
     this.chatRecordingService = new ChatRecordingService(config2);
@@ -356970,7 +356991,7 @@ var GeminiChat = class {
     this.lastPromptTokenCount = Math.ceil(JSON.stringify(this.history).length / 4);
   }
   setSystemInstruction(sysInstr) {
-    this.generationConfig.systemInstruction = sysInstr;
+    this.systemInstruction = sysInstr;
   }
   /**
    * Sends a message to the model and returns the response in chunks.
@@ -356980,7 +357001,10 @@ var GeminiChat = class {
    * sending the next message.
    *
    * @see {@link Chat#sendMessage} for non-streaming method.
-   * @param params - parameters for sending the message.
+   * @param modelConfigKey - The key for the model config.
+   * @param message - The list of messages to send.
+   * @param prompt_id - The ID of the prompt.
+   * @param signal - An abort signal for this message.
    * @return The model's response.
    *
    * @example
@@ -356994,7 +357018,7 @@ var GeminiChat = class {
    * }
    * ```
    */
-  async sendMessageStream(model, params, prompt_id) {
+  async sendMessageStream(modelConfigKey, message, prompt_id, signal) {
     await this.sendPromise;
     this.config.setPreviewModelBypassMode(false);
     let streamDoneResolver;
@@ -357002,9 +357026,11 @@ var GeminiChat = class {
       streamDoneResolver = resolve14;
     });
     this.sendPromise = streamDonePromise;
-    const userContent = createUserContent(params.message);
+    const userContent = createUserContent(message);
+    const { model, generateContentConfig } = this.config.modelConfigService.getResolvedConfig(modelConfigKey);
+    generateContentConfig.abortSignal = signal;
     if (!isFunctionResponse(userContent)) {
-      const userMessage = Array.isArray(params.message) ? params.message : [params.message];
+      const userMessage = Array.isArray(message) ? message : [message];
       const userMessageContent = partListUnionToString(toParts(userMessage));
       this.chatRecordingService.recordMessage({
         model,
@@ -357027,14 +357053,10 @@ var GeminiChat = class {
             if (attempt > 0) {
               yield { type: StreamEventType.RETRY };
             }
-            const currentParams = { ...params };
             if (attempt > 0) {
-              currentParams.config = {
-                ...currentParams.config,
-                temperature: 1
-              };
+              generateContentConfig.temperature = 1;
             }
-            const stream3 = await self2.makeApiCallAndProcessStream(model, requestContents, currentParams, prompt_id);
+            const stream3 = await self2.makeApiCallAndProcessStream(model, generateContentConfig, requestContents, prompt_id);
             for await (const chunk2 of stream3) {
               yield { type: StreamEventType.CHUNK, value: chunk2 };
             }
@@ -357068,7 +357090,7 @@ var GeminiChat = class {
       }
     }();
   }
-  async makeApiCallAndProcessStream(model, requestContents, params, prompt_id) {
+  async makeApiCallAndProcessStream(model, generateContentConfig, requestContents, prompt_id) {
     let effectiveModel = model;
     const contentsForPreviewModel = this.ensureActiveLoopHasThoughtSignatures(requestContents);
     const apiCall = () => {
@@ -357077,10 +357099,24 @@ var GeminiChat = class {
         modelToUse = DEFAULT_GEMINI_MODEL;
       }
       effectiveModel = modelToUse;
+      const config2 = {
+        ...generateContentConfig,
+        // TODO(12622): Ensure we don't overrwrite these when they are
+        // passed via config.
+        systemInstruction: this.systemInstruction,
+        tools: this.tools
+      };
+      if (modelToUse.startsWith("gemini-3")) {
+        config2.thinkingConfig = {
+          ...config2.thinkingConfig,
+          thinkingLevel: ThinkingLevel.HIGH
+        };
+        delete config2.thinkingConfig?.thinkingBudget;
+      }
       return this.config.getContentGenerator().generateContentStream({
         model: modelToUse,
         contents: modelToUse === PREVIEW_GEMINI_MODEL ? contentsForPreviewModel : requestContents,
-        config: { ...this.generationConfig, ...params.config }
+        config: config2
       }, prompt_id);
     };
     const onPersistent429Callback = async (authType, error) => await handleFallback(this.config, effectiveModel, authType, error);
@@ -357088,7 +357124,7 @@ var GeminiChat = class {
       onPersistent429: onPersistent429Callback,
       authType: this.config.getContentGeneratorConfig()?.authType,
       retryFetchErrors: this.config.getRetryFetchErrors(),
-      signal: params.config?.abortSignal,
+      signal: generateContentConfig.abortSignal,
       maxAttempts: this.config.isPreviewModelFallbackMode() && model === PREVIEW_GEMINI_MODEL ? 1 : void 0
     });
     return this.processStreamResponse(model, streamResponse);
@@ -357192,7 +357228,7 @@ var GeminiChat = class {
     return newContents;
   }
   setTools(tools) {
-    this.generationConfig.tools = tools;
+    this.tools = tools;
   }
   async maybeIncludeSchemaDepthContext(error) {
     if (isSchemaDepthError(error.message) || isInvalidArgumentError(error.message)) {
@@ -357369,14 +357405,9 @@ var Turn = class {
     this.prompt_id = prompt_id;
   }
   // The run method yields simpler events suitable for server logic
-  async *run(model, req, signal) {
+  async *run(modelConfigKey, req, signal) {
     try {
-      const responseStream = await this.chat.sendMessageStream(model, {
-        message: req,
-        config: {
-          abortSignal: signal
-        }
-      }, this.prompt_id);
+      const responseStream = await this.chat.sendMessageStream(modelConfigKey, req, this.prompt_id, signal);
       for await (const streamEvent of responseStream) {
         if (signal?.aborted) {
           yield { type: GeminiEventType.UserCancelled };
@@ -358554,7 +358585,7 @@ var LoopDetectionService = class {
 };
 
 // packages/core/dist/src/services/chatCompressionService.js
-var DEFAULT_COMPRESSION_TOKEN_THRESHOLD = 0.7;
+var DEFAULT_COMPRESSION_TOKEN_THRESHOLD = 0.5;
 var COMPRESSION_PRESERVE_THRESHOLD = 0.3;
 function findCompressSplitPoint(contents, fraction) {
   if (fraction <= 0 || fraction >= 1) {
@@ -358679,18 +358710,10 @@ var ChatCompressionService = class {
 };
 
 // packages/core/dist/src/core/client.js
-function isThinkingSupported(model) {
-  return !model.startsWith("gemini-2.0");
-}
 var MAX_TURNS = 100;
 var GeminiClient = class {
   config;
   chat;
-  generateContentConfig = {
-    temperature: 1,
-    topP: 0.95,
-    topK: 64
-  };
   sessionTurnCount = 0;
   loopDetector;
   compressionService;
@@ -358777,6 +358800,14 @@ var GeminiClient = class {
       parts: [{ text: await getDirectoryContextString(this.config) }]
     });
   }
+  async updateSystemInstruction() {
+    if (!this.isInitialized()) {
+      return;
+    }
+    const userMemory = this.config.getUserMemory();
+    const systemInstruction = getCoreSystemPrompt(this.config, userMemory);
+    this.getChat().setSystemInstruction(systemInstruction);
+  }
   async startChat(extraHistory, resumedSessionData) {
     this.forceFullIdeContext = true;
     this.hasFailedCompressionAttempt = false;
@@ -358787,19 +358818,7 @@ var GeminiClient = class {
     try {
       const userMemory = this.config.getUserMemory();
       const systemInstruction = getCoreSystemPrompt(this.config, userMemory);
-      const model = this.config.getModel();
-      const config2 = { ...this.generateContentConfig };
-      if (isThinkingSupported(model)) {
-        config2.thinkingConfig = {
-          includeThoughts: true,
-          thinkingBudget: DEFAULT_THINKING_MODE
-        };
-      }
-      return new GeminiChat(this.config, {
-        systemInstruction,
-        ...config2,
-        tools
-      }, history, resumedSessionData);
+      return new GeminiChat(this.config, systemInstruction, tools, history, resumedSessionData);
     } catch (error) {
       await reportError(error, "Error initializing Gemini chat session.", history, "startChat");
       throw new Error(`Failed to initialize chat: ${getErrorMessage(error)}`);
@@ -359006,7 +359025,7 @@ var GeminiClient = class {
       this.currentSequenceModel = modelToUse;
       yield { type: GeminiEventType.ModelInfo, value: modelToUse };
     }
-    const resultStream = turn.run(modelToUse, request3, linkedSignal);
+    const resultStream = turn.run({ model: modelToUse }, request3, linkedSignal);
     for await (const event of resultStream) {
       if (this.loopDetector.addAndCheck(event)) {
         yield { type: GeminiEventType.LoopDetected };
@@ -364292,7 +364311,7 @@ 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") {
+      if (decision.model === DEFAULT_GEMINI_MODEL && this.config.getPreviewFeatures() && !decision.metadata.source.includes("override")) {
         decision.model = PREVIEW_GEMINI_MODEL;
         decision.metadata.source += " (Preview Model)";
         decision.metadata.reasoning += " (Upgraded to Preview Model)";
@@ -364347,10 +364366,14 @@ var JsonStreamEventType;
 // packages/core/dist/src/services/modelConfigService.js
 var ModelConfigService = class {
   config;
+  runtimeAliases = {};
   // TODO(12597): Process config to build a typed alias hierarchy.
   constructor(config2) {
     this.config = config2;
   }
+  registerRuntimeModelConfig(aliasName, alias) {
+    this.runtimeAliases[aliasName] = alias;
+  }
   resolveAlias(aliasName, aliases2, visited = /* @__PURE__ */ new Set()) {
     if (visited.has(aliasName)) {
       throw new Error(`Circular alias dependency: ${[...visited, aliasName].join(" -> ")}`);
@@ -364374,10 +364397,11 @@ var ModelConfigService = class {
   internalGetResolvedConfig(context2) {
     const config2 = this.config || {};
     const { aliases: aliases2 = {}, overrides = [] } = config2;
+    const allAliases = { ...aliases2, ...this.runtimeAliases };
     let baseModel = context2.model;
     let resolvedConfig = {};
-    if (aliases2[context2.model]) {
-      const resolvedAlias = this.resolveAlias(context2.model, aliases2);
+    if (allAliases[context2.model]) {
+      const resolvedAlias = this.resolveAlias(context2.model, allAliases);
       baseModel = resolvedAlias.modelConfig.model;
       resolvedConfig = this.deepMerge(resolvedConfig, resolvedAlias.modelConfig.generateContentConfig);
     }
@@ -364479,8 +364503,7 @@ var DEFAULT_MODEL_CONFIGS = {
       modelConfig: {
         generateContentConfig: {
           thinkingConfig: {
-            includeThoughts: true,
-            thinkingBudget: -1
+            includeThoughts: true
           },
           temperature: 1,
           topP: 0.95,
@@ -364488,25 +364511,51 @@ var DEFAULT_MODEL_CONFIGS = {
         }
       }
     },
+    "chat-base-2.5": {
+      extends: "chat-base",
+      modelConfig: {
+        generateContentConfig: {
+          thinkingConfig: {
+            thinkingBudget: DEFAULT_THINKING_MODE
+          }
+        }
+      }
+    },
+    "chat-base-3": {
+      extends: "chat-base",
+      modelConfig: {
+        generateContentConfig: {
+          thinkingConfig: {
+            thinkingLevel: ThinkingLevel.HIGH
+          }
+        }
+      }
+    },
     // Because `gemini-2.5-pro` and related model configs are "user-facing"
     // today, i.e. they could be passed via `--model`, we have to be careful to
     // ensure these model configs can be used interactively.
     // TODO(joshualitt): Introduce internal base configs for the various models,
     // note: we will have to think carefully about names.
+    "gemini-3-pro-preview": {
+      extends: "chat-base-3",
+      modelConfig: {
+        model: "gemini-3-pro-preview"
+      }
+    },
     "gemini-2.5-pro": {
-      extends: "chat-base",
+      extends: "chat-base-2.5",
       modelConfig: {
         model: "gemini-2.5-pro"
       }
     },
     "gemini-2.5-flash": {
-      extends: "chat-base",
+      extends: "chat-base-2.5",
       modelConfig: {
         model: "gemini-2.5-flash"
       }
     },
     "gemini-2.5-flash-lite": {
-      extends: "chat-base",
+      extends: "chat-base-2.5",
       modelConfig: {
         model: "gemini-2.5-flash-lite"
       }
@@ -365027,6 +365076,9 @@ var PolicyEngine = class {
 };
 
 // packages/core/dist/src/agents/registry.js
+function getModelConfigAlias(definition) {
+  return `${definition.name}-config`;
+}
 var AgentRegistry = class {
   config;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -365076,6 +365128,21 @@ var AgentRegistry = class {
       debugLogger.log(`[AgentRegistry] Overriding agent '${definition.name}'`);
     }
     this.agents.set(definition.name, definition);
+    const modelConfig = definition.modelConfig;
+    const runtimeAlias = {
+      modelConfig: {
+        model: modelConfig.model,
+        generateContentConfig: {
+          temperature: modelConfig.temp,
+          topP: modelConfig.top_p,
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingBudget: modelConfig.thinkingBudget ?? -1
+          }
+        }
+      }
+    };
+    this.config.modelConfigService.registerRuntimeModelConfig(getModelConfigAlias(definition), runtimeAlias);
   }
   /**
    * Retrieves an agent definition by name.
@@ -365137,10 +365204,12 @@ async function executeToolCall(config2, toolCallRequest, abortSignal) {
     const scheduler3 = new CoreToolScheduler({
       config: config2,
       getPreferredEditor: () => void 0,
-      onEditorClose: () => {
-      },
       onAllToolCallsComplete: async (completedToolCalls) => {
-        resolve14(completedToolCalls[0]);
+        if (completedToolCalls.length > 0) {
+          resolve14(completedToolCalls[0]);
+        } else {
+          reject(new Error("No completed tool calls returned."));
+        }
       }
     });
     scheduler3.schedule(toolCallRequest, abortSignal).catch((error) => {
@@ -366779,14 +366848,13 @@ var AgentExecutor = class _AgentExecutor {
    * @returns The model's response, including any tool calls or text.
    */
   async callModel(chat, message, tools, signal, promptId) {
-    const messageParams = {
-      message: message.parts || [],
-      config: {
-        abortSignal: signal,
-        tools: tools.length > 0 ? [{ functionDeclarations: tools }] : void 0
-      }
-    };
-    const responseStream = await chat.sendMessageStream(this.definition.modelConfig.model, messageParams, promptId);
+    if (tools.length > 0) {
+      chat.setTools([{ functionDeclarations: tools }]);
+    }
+    const responseStream = await chat.sendMessageStream({
+      model: getModelConfigAlias(this.definition),
+      overrideScope: this.definition.name
+    }, message.parts || [], promptId, signal);
     const functionCalls = [];
     let textResponse = "";
     for await (const resp of responseStream) {
@@ -366812,25 +366880,20 @@ var AgentExecutor = class _AgentExecutor {
   }
   /** Initializes a `GeminiChat` instance for the agent run. */
   async createChatObject(inputs) {
-    const { promptConfig, modelConfig } = this.definition;
+    const { promptConfig } = this.definition;
     if (!promptConfig.systemPrompt && !promptConfig.initialMessages) {
       throw new Error("PromptConfig must define either `systemPrompt` or `initialMessages`.");
     }
     const startHistory = this.applyTemplateToInitialMessages(promptConfig.initialMessages ?? [], inputs);
     const systemInstruction = promptConfig.systemPrompt ? await this.buildSystemPrompt(inputs) : void 0;
     try {
-      const generationConfig = {
-        temperature: modelConfig.temp,
-        topP: modelConfig.top_p,
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingBudget: modelConfig.thinkingBudget ?? -1
-        }
-      };
-      if (systemInstruction) {
-        generationConfig.systemInstruction = systemInstruction;
-      }
-      return new GeminiChat(this.runtimeContext, generationConfig, startHistory);
+      return new GeminiChat(
+        this.runtimeContext,
+        systemInstruction,
+        [],
+        // set in `callModel`,
+        startHistory
+      );
     } catch (error) {
       await reportError(error, `Error initializing Gemini chat for agent ${this.definition.name}.`, startHistory, "startChat");
       throw new Error(`Failed to create chat object: ${error}`);
@@ -367512,7 +367575,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.18.0-nightly.20251120.2231497b1",
+      ideVersion: "0.18.0-preview.0",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -369783,7 +369846,7 @@ var logger4 = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   warn: (...args2) => debugLogger.warn("[WARN] [ImportProcessor]", ...args2),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  error: (...args2) => console.error("[ERROR] [ImportProcessor]", ...args2)
+  error: (...args2) => debugLogger.error("[ERROR] [ImportProcessor]", ...args2)
 };
 async function findProjectRoot(startDir) {
   let currentDir = path60.resolve(startDir);
@@ -373452,6 +373515,16 @@ var Config = class {
   getGeminiClient() {
     return this.geminiClient;
   }
+  /**
+   * Updates the system instruction with the latest user memory.
+   * Whenever the user memory (GEMINI.md files) is updated.
+   */
+  async updateSystemInstructionIfInitialized() {
+    const geminiClient = this.getGeminiClient();
+    if (geminiClient?.isInitialized()) {
+      await geminiClient.updateSystemInstruction();
+    }
+  }
   getModelRouterService() {
     return this.modelRouterService;
   }
@@ -375055,9 +375128,7 @@ var Task = class _Task {
       onAllToolCallsComplete: this._schedulerAllToolCallsComplete.bind(this),
       onToolCallsUpdate: this._schedulerToolCallsUpdate.bind(this),
       getPreferredEditor: () => "vscode",
-      config: this.config,
-      onEditorClose: () => {
-      }
+      config: this.config
     });
     return scheduler3;
   }

package/dist/src/agent/task.js

@@ -273,7 +273,6 @@ export class Task {
             onToolCallsUpdate: this._schedulerToolCallsUpdate.bind(this),
             getPreferredEditor: () => 'vscode',
             config: this.config,
-            onEditorClose: () => { },
         });
         return scheduler;
     }