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

package/dist/a2a-server.mjs

@@ -220929,8 +220929,8 @@ var GIT_COMMIT_INFO, CLI_VERSION;
 var init_git_commit = __esm({
   "packages/core/dist/src/generated/git-commit.js"() {
     "use strict";
-    GIT_COMMIT_INFO = "9681621c6";
-    CLI_VERSION = "0.53.0-preview.0";
+    GIT_COMMIT_INFO = "983af5d58";
+    CLI_VERSION = "0.53.1";
   }
 });
 
@@ -291854,6 +291854,15 @@ var init_agentChatHistory = __esm({
       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;
       }
@@ -292663,7 +292672,8 @@ var init_uiTelemetry = __esm({
       api: {
         totalRequests: 0,
         totalErrors: 0,
-        totalLatencyMs: 0
+        totalLatencyMs: 0,
+        errorsByType: {}
       },
       tokens: {
         input: 0,
@@ -292718,6 +292728,19 @@ var init_uiTelemetry = __esm({
           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;
       }
@@ -292839,6 +292862,11 @@ var init_uiTelemetry = __esm({
         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();
@@ -336548,7 +336576,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.53.0-preview.0";
+    return "0.53.1";
   })();
   return versionPromise;
 }
@@ -365638,10 +365666,10 @@ var init_agent_loop_context = __esm({
 
 // 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);
 }
 var init_messageInspectors = __esm({
   "packages/core/dist/src/utils/messageInspectors.js"() {
@@ -366258,15 +366286,18 @@ var init_geminiChat = __esm({
        */
       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((resolve23) => {
           streamDoneResolver = resolve23;
         });
         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;
@@ -366345,13 +366376,14 @@ var init_geminiChat = __esm({
         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;
@@ -366360,6 +366392,9 @@ var init_geminiChat = __esm({
                 }
                 return;
               } catch (error2) {
+                if (error2 instanceof InvalidStreamError) {
+                  lastStreamError = error2;
+                }
                 if (error2 instanceof AgentExecutionStoppedError) {
                   yield {
                     type: StreamEventType.AGENT_EXECUTION_STOPPED,
@@ -366385,7 +366420,7 @@ var init_geminiChat = __esm({
                 }
                 const isRetryable = isRetryableError(error2, this.context.config.getRetryFetchErrors());
                 const isContentError = error2 instanceof InvalidStreamError;
-                const isRetryableContentError = isContentError && error2.type !== "NO_RESPONSE_TEXT";
+                const isRetryableContentError = isContentError;
                 const errorType = isContentError ? error2.type : getRetryErrorType(error2);
                 if (isRetryableContentError || isRetryable && !signal.aborted) {
                   const maxMidStreamAttempts = MID_STREAM_RETRY_OPTIONS.maxAttempts;
@@ -366414,6 +366449,13 @@ var init_geminiChat = __esm({
                 throw error2;
               }
             }
+          } catch (error2) {
+            if (!isOriginalFunctionResponse) {
+              this.agentHistory.rollback(historyLengthBefore);
+              this.chatRecordingService.updateMessagesFromHistory(this.agentHistory.get());
+              this.lastPromptTokenCount = baselinePromptTokenCount;
+            }
+            throw error2;
           } finally {
             streamDoneResolver();
           }
@@ -366472,6 +366514,22 @@ var init_geminiChat = __esm({
             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) {
@@ -366714,6 +366772,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();
@@ -366759,7 +366819,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;
@@ -366781,10 +366844,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) {
@@ -366840,17 +366900,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");
@@ -366862,9 +366919,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 }
@@ -366902,11 +366993,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) {
@@ -366914,11 +367005,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;
       }
     };
   }
@@ -367171,7 +367263,13 @@ ${[...this.pendingCitations].sort().join("\n")}`
             return;
           }
           if (e3 instanceof InvalidStreamError) {
-            yield { type: GeminiEventType.InvalidStream };
+            yield {
+              type: GeminiEventType.InvalidStream,
+              value: {
+                type: e3.type,
+                message: e3.message
+              }
+            };
             return;
           }
           const error2 = toFriendlyError(e3);
@@ -367521,6 +367619,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)}
@@ -386080,6 +386188,7 @@ var init_scheduler = __esm({
         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");
@@ -386194,6 +386303,12 @@ var init_scheduler = __esm({
        */
       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;
         }