@google/gemini-cli 0.53.0-preview.0 → 0.53.1

package/bundle/{chunk-5RDOS7UZ.js → chunk-2NH5AG3B.js}

@@ -253529,6 +253529,13 @@ var REFERENCE_CONTENT_END = "--- End of content ---";
 var DEFAULT_MAX_LINES_TEXT_FILE = 2e3;
 var MAX_LINE_LENGTH_TEXT_FILE = 2e3;
 var MAX_FILE_SIZE_MB = 20;
+var EMPTY_RESPONSE_COMPRESS_SUGGESTION = "The model returned an empty text response. If your context window is near capacity, try using /compress.";
+var THINKING_ONLY_COMPRESS_SUGGESTION = "The model returned reasoning thoughts but no final response text. If your context window is near capacity, try using /compress.";
+var MAX_TOKENS_EXCEEDED_SUGGESTION = "Model response was truncated because it exceeded the token limit. Try using /compress to free up context space.";
+var SAFETY_BLOCKED_MESSAGE = "The model response was blocked due to safety settings.";
+var RECITATION_BLOCKED_MESSAGE = "The model response was blocked due to recitation/copyright filters.";
+var OTHER_BLOCKED_MESSAGE = "The model response was blocked due to other policy settings.";
+var TRUE_EMPTY_RESPONSE_MESSAGE = "The model returned an empty response with no text or thoughts. This may be a transient API issue; please try again.";
 
 // packages/core/dist/src/utils/fileUtils.js
 var requireModule = createModuleRequire(import.meta.url);
@@ -282493,8 +282500,8 @@ function isValidToolName(name3, options = {}) {
 }
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "9681621c6";
-var CLI_VERSION = "0.53.0-preview.0";
+var GIT_COMMIT_INFO = "983af5d58";
+var CLI_VERSION = "0.53.1";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -284971,6 +284978,15 @@ var AgentChatHistory = class {
   clear() {
     this.history = [];
   }
+  /**
+   * Rolls back the history to a specified length.
+   * Useful when a stream fails and we need to remove the un-responded turn(s).
+   */
+  rollback(length) {
+    if (length >= 0 && length <= this.history.length) {
+      this.history = this.history.slice(0, length);
+    }
+  }
   get() {
     return this.history;
   }
@@ -285839,7 +285855,8 @@ var createInitialModelMetrics = () => ({
   api: {
     totalRequests: 0,
     totalErrors: 0,
-    totalLatencyMs: 0
+    totalLatencyMs: 0,
+    errorsByType: {}
   },
   tokens: {
     input: 0,
@@ -285894,6 +285911,19 @@ var UiTelemetryService = class extends EventEmitter3 {
       lastPromptTokenCount: this.#lastPromptTokenCount
     });
   }
+  recordSemanticValidationError(model, errorType) {
+    const modelMetrics = this.getOrCreateModelMetrics(model);
+    modelMetrics.api.totalErrors++;
+    if (!modelMetrics.api.errorsByType) {
+      modelMetrics.api.errorsByType = {};
+    }
+    const type2 = errorType || "INVALID_STREAM";
+    modelMetrics.api.errorsByType[type2] = (modelMetrics.api.errorsByType[type2] || 0) + 1;
+    this.emit("update", {
+      metrics: this.#metrics,
+      lastPromptTokenCount: this.#lastPromptTokenCount
+    });
+  }
   getMetrics() {
     return this.#metrics;
   }
@@ -286015,6 +286045,11 @@ var UiTelemetryService = class extends EventEmitter3 {
     modelMetrics.api.totalRequests++;
     modelMetrics.api.totalErrors++;
     modelMetrics.api.totalLatencyMs += event.duration_ms;
+    if (!modelMetrics.api.errorsByType) {
+      modelMetrics.api.errorsByType = {};
+    }
+    const errorType = event.error_type || "UNKNOWN";
+    modelMetrics.api.errorsByType[errorType] = (modelMetrics.api.errorsByType[errorType] || 0) + 1;
     if (event.role) {
       if (!modelMetrics.roles[event.role]) {
         modelMetrics.roles[event.role] = createInitialRoleMetrics();
@@ -305675,7 +305710,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.53.0-preview.0";
+    return "0.53.1";
   })();
   return versionPromise;
 }
@@ -329864,10 +329899,10 @@ import { randomUUID as randomUUID5 } from "node:crypto";
 
 // packages/core/dist/src/utils/messageInspectors.js
 function isFunctionResponse(content) {
-  return content.role === "user" && !!content.parts && content.parts.every((part) => !!part.functionResponse);
+  return content.role === "user" && !!content.parts && content.parts.some((part) => !!part.functionResponse);
 }
 function isFunctionCall(content) {
-  return content.role === "model" && !!content.parts && content.parts.every((part) => !!part.functionCall);
+  return content.role === "model" && !!content.parts && content.parts.length > 0 && content.parts.every((part) => !!part.functionCall);
 }
 
 // packages/core/dist/src/utils/historyHardening.js
@@ -330387,15 +330422,18 @@ var GeminiChat = class {
    */
   async sendMessageStream(modelConfigKey, message, prompt_id, signal, role, displayContent, apiHistoryOverride) {
     await this.sendPromise;
+    const historyLengthBefore = this.agentHistory.length;
+    const baselinePromptTokenCount = this.lastPromptTokenCount;
     let streamDoneResolver;
     const streamDonePromise = new Promise((resolve29) => {
       streamDoneResolver = resolve29;
     });
     this.sendPromise = streamDonePromise;
     let userContent = createUserContent(message);
+    const isOriginalFunctionResponse = isFunctionResponse(userContent);
     const { model } = this.context.config.modelConfigService.getResolvedConfig(modelConfigKey);
     const isContextManagementEnabled = this.context.config.isContextManagementEnabled();
-    if (!isFunctionResponse(userContent)) {
+    if (!isOriginalFunctionResponse) {
       const userMessageParts = userContent.parts || [];
       const userMessageContent = partListUnionToString(userMessageParts);
       let finalDisplayContent = void 0;
@@ -330474,13 +330512,14 @@ var GeminiChat = class {
     const streamWithRetries = async function* () {
       try {
         const maxAttempts = this.context.config.getMaxAttempts();
+        let lastStreamError = void 0;
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
           let isConnectionPhase = true;
           try {
             if (attempt > 0) {
               yield { type: StreamEventType.RETRY };
             }
-            const currentConfigKey = attempt > 0 ? { ...modelConfigKey, isRetry: true } : modelConfigKey;
+            const currentConfigKey = attempt > 0 ? { ...modelConfigKey, isRetry: true, lastStreamError } : modelConfigKey;
             isConnectionPhase = true;
             const stream2 = await this.makeApiCallAndProcessStream(currentConfigKey, requestHistory, prompt_id, signal, role, apiHistoryOverride);
             isConnectionPhase = false;
@@ -330489,6 +330528,9 @@ var GeminiChat = class {
             }
             return;
           } catch (error40) {
+            if (error40 instanceof InvalidStreamError) {
+              lastStreamError = error40;
+            }
             if (error40 instanceof AgentExecutionStoppedError) {
               yield {
                 type: StreamEventType.AGENT_EXECUTION_STOPPED,
@@ -330514,7 +330556,7 @@ var GeminiChat = class {
             }
             const isRetryable = isRetryableError(error40, this.context.config.getRetryFetchErrors());
             const isContentError = error40 instanceof InvalidStreamError;
-            const isRetryableContentError = isContentError && error40.type !== "NO_RESPONSE_TEXT";
+            const isRetryableContentError = isContentError;
             const errorType = isContentError ? error40.type : getRetryErrorType(error40);
             if (isRetryableContentError || isRetryable && !signal.aborted) {
               const maxMidStreamAttempts = MID_STREAM_RETRY_OPTIONS.maxAttempts;
@@ -330543,6 +330585,13 @@ var GeminiChat = class {
             throw error40;
           }
         }
+      } catch (error40) {
+        if (!isOriginalFunctionResponse) {
+          this.agentHistory.rollback(historyLengthBefore);
+          this.chatRecordingService.updateMessagesFromHistory(this.agentHistory.get());
+          this.lastPromptTokenCount = baselinePromptTokenCount;
+        }
+        throw error40;
       } finally {
         streamDoneResolver();
       }
@@ -330601,6 +330650,22 @@ var GeminiChat = class {
         tools: this.tools,
         abortSignal
       };
+      if (modelConfigKey.isRetry && modelConfigKey.lastStreamError instanceof InvalidStreamError) {
+        const lastError = modelConfigKey.lastStreamError;
+        let nudgeMessage = "";
+        if (lastError.type === "THINKING_ONLY_RESPONSE") {
+          nudgeMessage = "\n[System: You previously generated thoughts but failed to provide a final user-facing response. Please ensure you provide your final answer or call a tool now.]";
+        } else if (lastError.type === "NO_RESPONSE_TEXT") {
+          nudgeMessage = "\n[System: You previously returned an empty response with no text or thoughts. Please ensure you provide your final answer or call a tool now.]";
+        }
+        if (nudgeMessage) {
+          if (typeof config2.systemInstruction === "string") {
+            config2.systemInstruction += nudgeMessage;
+          } else if (config2.systemInstruction === void 0) {
+            config2.systemInstruction = nudgeMessage;
+          }
+        }
+      }
       let contentsToUse = supportsModernFeatures(modelToUse) ? [...contentsForPreviewModel] : [...requestContents];
       const hookSystem = this.context.config.getHookSystem();
       if (hookSystem) {
@@ -330843,6 +330908,8 @@ This error was probably caused by cyclic schema references in one of the followi
     let hasToolCall = false;
     let hasThoughts = false;
     let finishReason;
+    const bufferedThoughts = [];
+    let bufferedUsageMetadata = void 0;
     const finalFunctionCallsMap = /* @__PURE__ */ new Map();
     const legacyFunctionCalls = [];
     const callIndexToId = /* @__PURE__ */ new Map();
@@ -330888,7 +330955,10 @@ This error was probably caused by cyclic schema references in one of the followi
         if (content?.parts) {
           if (content.parts.some((part) => part.thought)) {
             hasThoughts = true;
-            this.recordThoughtFromContent(content);
+            const thought = this.extractThoughtFromContent(content);
+            if (thought) {
+              bufferedThoughts.push(thought);
+            }
           }
           if (content.parts.some((part) => part.functionCall)) {
             hasToolCall = true;
@@ -330910,10 +330980,7 @@ This error was probably caused by cyclic schema references in one of the followi
         }
       }
       if (chunk.usageMetadata) {
-        this.chatRecordingService.recordMessageTokens(chunk.usageMetadata);
-        if (chunk.usageMetadata.promptTokenCount !== void 0) {
-          this.lastPromptTokenCount = chunk.usageMetadata.promptTokenCount;
-        }
+        bufferedUsageMetadata = chunk.usageMetadata;
       }
       const hookSystem = this.context.config.getHookSystem();
       if (originalRequest && chunk && hookSystem) {
@@ -330969,17 +331036,14 @@ This error was probably caused by cyclic schema references in one of the followi
         }
       }
     }
-    const responseText = consolidatedParts.filter((part) => part.text).map((part) => part.text).join("").trim();
-    let id;
-    if (responseText || hasThoughts || hasToolCall) {
-      id = this.chatRecordingService.recordMessage({
-        model,
-        type: "gemini",
-        content: responseText
-      });
-    } else {
-      id = this.chatRecordingService.recordSyntheticMessage("gemini", consolidatedParts);
-    }
+    const rawResponseText = consolidatedParts.filter((part) => part.text).map((part) => part.text).join("");
+    let responseText = rawResponseText.replace(/[\u200B-\u200D\uFEFF\u200E\u200F]/g, "");
+    let previous;
+    do {
+      previous = responseText;
+      responseText = responseText.replace(/<!--[\s\S]*?-->/g, "");
+    } while (responseText !== previous);
+    responseText = responseText.trim();
     if (!hasToolCall) {
       if (!finishReason) {
         throw new InvalidStreamError("Model stream ended without a finish reason.", "NO_FINISH_REASON");
@@ -330991,9 +331055,43 @@ This error was probably caused by cyclic schema references in one of the followi
         throw new InvalidStreamError("Model stream ended with unexpected tool call.", "UNEXPECTED_TOOL_CALL");
       }
       if (!responseText) {
+        if (finishReason === FinishReason.MAX_TOKENS) {
+          throw new InvalidStreamError("Model stream ended due to token limit exhaustion (MAX_TOKENS) with empty response text.", "MAX_TOKENS_EXCEEDED");
+        }
+        if (finishReason === FinishReason.SAFETY) {
+          throw new InvalidStreamError("Model stream ended due to safety settings (SAFETY) with empty response text.", "SAFETY_BLOCKED");
+        }
+        if (finishReason === FinishReason.RECITATION) {
+          throw new InvalidStreamError("Model stream ended due to recitation settings (RECITATION) with empty response text.", "RECITATION_BLOCKED");
+        }
+        if (finishReason === FinishReason.OTHER) {
+          throw new InvalidStreamError("Model stream ended due to other settings (OTHER) with empty response text.", "OTHER_BLOCKED");
+        }
+        if (hasThoughts) {
+          throw new InvalidStreamError("Model stream ended with empty response text but contained reasoning thoughts.", "THINKING_ONLY_RESPONSE");
+        }
         throw new InvalidStreamError("Model stream ended with empty response text.", "NO_RESPONSE_TEXT");
       }
     }
+    for (const thought of bufferedThoughts) {
+      this.chatRecordingService.recordThought(thought);
+    }
+    if (bufferedUsageMetadata) {
+      this.chatRecordingService.recordMessageTokens(bufferedUsageMetadata);
+      if (bufferedUsageMetadata.promptTokenCount !== void 0) {
+        this.lastPromptTokenCount = bufferedUsageMetadata.promptTokenCount;
+      }
+    }
+    let id;
+    if (responseText || hasThoughts || hasToolCall) {
+      id = this.chatRecordingService.recordMessage({
+        model,
+        type: "gemini",
+        content: responseText
+      });
+    } else {
+      id = this.chatRecordingService.recordSyntheticMessage("gemini", consolidatedParts);
+    }
     this.agentHistory.push({
       id,
       content: { role: "model", parts: consolidatedParts }
@@ -331031,11 +331129,11 @@ This error was probably caused by cyclic schema references in one of the followi
     this.chatRecordingService.recordToolCalls(model, toolCallRecords);
   }
   /**
-   * Extracts and records thought from thought content.
+   * Extracts thought from thought content.
    */
-  recordThoughtFromContent(content) {
+  extractThoughtFromContent(content) {
     if (!content.parts || content.parts.length === 0) {
-      return;
+      return void 0;
     }
     const thoughtPart = content.parts[0];
     if (thoughtPart.text) {
@@ -331043,11 +331141,12 @@ This error was probably caused by cyclic schema references in one of the followi
       const subjectStringMatches = rawText.match(/\*\*(.*?)\*\*/s);
       const subject = subjectStringMatches ? subjectStringMatches[1].trim() : "";
       const description = rawText.replace(/\*\*(.*?)\*\*/s, "").trim();
-      this.chatRecordingService.recordThought({
+      return {
         subject,
         description
-      });
+      };
     }
+    return void 0;
   }
 };
 function isSchemaDepthError(errorMessage) {
@@ -331348,7 +331447,13 @@ ${[...this.pendingCitations].sort().join("\n")}`
         return;
       }
       if (e2 instanceof InvalidStreamError) {
-        yield { type: GeminiEventType.InvalidStream };
+        yield {
+          type: GeminiEventType.InvalidStream,
+          value: {
+            type: e2.type,
+            message: e2.message
+          }
+        };
         return;
       }
       const error40 = toFriendlyError(e2);
@@ -331694,6 +331799,16 @@ function renderOperationalGuidelines(options) {
 - **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
 
 ## Tool Usage
+- **Tool Execution Response Rules:**
+  1. After receiving a \`functionResponse\`, you MUST ALWAYS execute one of the following two actions:
+     a) Call another tool to proceed with the task.
+     b) Provide a user-facing text response explaining the tool output, your analysis, and next steps.
+  2. You MUST NEVER return an empty response with no text and no tool calls.
+- **Post-Edit Response Rules:**
+  1. After an edit tool execution (e.g. ${formatToolName(EDIT_TOOL_NAME)}, ${formatToolName(WRITE_FILE_TOOL_NAME)}), you MUST ALWAYS generate a user-facing text response summarizing:
+     - What changes were made to the file.
+     - Your verification plan or next steps (e.g. running tests).
+  2. You MUST NEVER return an empty response with 0 text tokens after completing an edit.
 - **Parallelism & Sequencing:** Tools execute in parallel by default. Execute multiple independent tool calls in parallel when feasible (e.g., searching, reading files, independent shell commands, or editing *different* files). If a tool depends on the output or side-effects of a previous tool in the same turn (e.g., running a shell command that depends on the success of a previous command), you MUST set the \`wait_for_previous\` parameter to \`true\` on the dependent tool to ensure sequential execution.
 - **File Editing Collisions:** Do NOT make multiple calls to the ${formatToolName(EDIT_TOOL_NAME)} tool for the SAME file in a single turn. To make multiple edits to the same file, you MUST perform them sequentially across multiple conversational turns to prevent race conditions and ensure the file state is accurate before each edit.
 - **Command Execution:** Use the ${formatToolName(SHELL_TOOL_NAME)} tool for running shell commands, remembering the safety rule to explain modifying commands first.${toolUsageInteractive(options.interactive, options.interactiveShellEnabled)}${toolUsageRememberingFacts(options)}
@@ -338237,7 +338352,7 @@ var A2AAuthProviderFactory = class _A2AAuthProviderFactory {
         return provider;
       }
       case "oauth2": {
-        const { OAuth2AuthProvider } = await import("./oauth2-provider-E3S5DGLL.js");
+        const { OAuth2AuthProvider } = await import("./oauth2-provider-MZRAKSIZ.js");
         const provider = new OAuth2AuthProvider(authConfig, options.agentName ?? "unknown", agentCard, options.agentCardUrl);
         await provider.initialize();
         return provider;
@@ -345647,6 +345762,7 @@ var Scheduler = class {
     for (const activeCall of activeCalls) {
       if (!this.isTerminal(activeCall.status)) {
         this.state.updateStatus(activeCall.request.callId, CoreToolCallStatus.Cancelled, "Operation cancelled by user");
+        this.state.finalizeCall(activeCall.request.callId);
       }
     }
     this.state.cancelAllQueued("Operation cancelled by user");
@@ -345761,6 +345877,12 @@ var Scheduler = class {
    */
   async _processNextItem(signal) {
     if (signal.aborted || this.isCancelling) {
+      const activeCalls2 = this.state.allActiveCalls;
+      for (const call of activeCalls2) {
+        if (this.isTerminal(call.status)) {
+          this.state.finalizeCall(call.request.callId);
+        }
+      }
       this.state.cancelAllQueued("Operation cancelled");
       return false;
     }
@@ -386467,8 +386589,13 @@ function translateEvent(event, state) {
       ensureStreamStart(state, out2);
       out2.push(makeEvent("error", state, {
         status: "INTERNAL",
-        message: "Invalid stream received from model",
-        fatal: true
+        message: event.value?.message?.trim() || "Invalid stream received from model",
+        fatal: true,
+        _meta: {
+          code: "INVALID_STREAM",
+          errorType: event.value?.type,
+          rawMessage: event.value?.message
+        }
       }));
       break;
     case GeminiEventType.ToolCallRequest:
@@ -386727,6 +386854,7 @@ var LegacyAgentProtocol = class {
         return;
       }
       const toolCallRequests = [];
+      let finishedReason = void 0;
       const responseStream = this._client.sendMessageStream(currentParts, this._abortController.signal, this._promptId, void 0, currentDisplayContent);
       currentDisplayContent = void 0;
       for await (const event of responseStream) {
@@ -386745,10 +386873,7 @@ var LegacyAgentProtocol = class {
             this._finishStream("failed");
             return;
           case GeminiEventType.Finished:
-            if (toolCallRequests.length === 0) {
-              this._finishStream(mapFinishReason(event.value.reason));
-              return;
-            }
+            finishedReason = event.value.reason;
             break;
           case GeminiEventType.AgentExecutionStopped:
           case GeminiEventType.UserCancelled:
@@ -386764,7 +386889,11 @@ var LegacyAgentProtocol = class {
         return;
       }
       if (toolCallRequests.length === 0) {
-        this._finishStream("completed");
+        if (finishedReason !== void 0) {
+          this._finishStream(mapFinishReason(finishedReason));
+        } else {
+          this._finishStream("completed");
+        }
         return;
       }
       const completedToolCalls = await this._scheduler.schedule(toolCallRequests, this._abortController.signal);
@@ -395229,6 +395358,13 @@ export {
   DEFAULT_MAX_LINES_TEXT_FILE,
   MAX_LINE_LENGTH_TEXT_FILE,
   MAX_FILE_SIZE_MB,
+  EMPTY_RESPONSE_COMPRESS_SUGGESTION,
+  THINKING_ONLY_COMPRESS_SUGGESTION,
+  MAX_TOKENS_EXCEEDED_SUGGESTION,
+  SAFETY_BLOCKED_MESSAGE,
+  RECITATION_BLOCKED_MESSAGE,
+  OTHER_BLOCKED_MESSAGE,
+  TRUE_EMPTY_RESPONSE_MESSAGE,
   readWasmBinaryFromDisk,
   loadWasmBinary,
   DEFAULT_ENCODING,

package/bundle/{chunk-PVCJCQWY.js → chunk-2W4AGAXV.js}

@@ -5,7 +5,7 @@ import {
   isTelemetrySdkInitialized,
   resetBrowserSession,
   shutdownTelemetry
-} from "./chunk-HF533LET.js";
+} from "./chunk-3A32ZSG7.js";
 
 // packages/cli/src/utils/cleanup.ts
 import { promises as fs } from "node:fs";