@google/gemini-cli-a2a-server 0.54.0-preview.1 → 0.54.4

package/dist/a2a-server.mjs

@@ -54912,7 +54912,7 @@ var require_jsonfile = __commonJS({
       await universalify.fromCallback(fs88.writeFile)(file, str2, options);
     }
     var writeFile9 = universalify.fromPromise(_writeFile);
-    function writeFileSync7(file, obj, options = {}) {
+    function writeFileSync8(file, obj, options = {}) {
       const fs88 = options.fs || _fs;
       const str2 = stringify5(obj, options);
       return fs88.writeFileSync(file, str2, options);
@@ -54921,7 +54921,7 @@ var require_jsonfile = __commonJS({
       readFile: readFile12,
       readFileSync: readFileSync10,
       writeFile: writeFile9,
-      writeFileSync: writeFileSync7
+      writeFileSync: writeFileSync8
     };
   }
 });
@@ -220939,8 +220939,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 = "d3c51f158";
-    CLI_VERSION = "0.54.0-preview.1";
+    GIT_COMMIT_INFO = "10944dcc4";
+    CLI_VERSION = "0.54.4";
   }
 });
 
@@ -292296,7 +292296,10 @@ var init_chatRecordingService = __esm({
               }
               this.updateMetadata({ sessionId: this.sessionId });
             } else {
-              throw new Error("Failed to load resumed session data from file");
+              debugLogger.warn("Failed to reload resumed session data from file; falling back to the in-memory conversation.");
+              this.cachedConversation = resumedSessionData.conversation;
+              this.projectHash = this.cachedConversation.projectHash;
+              this.rewriteConversationFile(this.cachedConversation);
             }
           } else {
             this.sessionId = this.context.promptId;
@@ -292366,6 +292369,57 @@ var init_chatRecordingService = __esm({
           }
         }
       }
+      /**
+       * Rewrites the session file from an in-memory record. Any existing
+       * (unreadable) file is preserved alongside rather than destroyed, and the
+       * new file is written atomically (temp file + rename).
+       */
+      rewriteConversationFile(conversation) {
+        if (!this.conversationFile)
+          return;
+        if (this.conversationFile.endsWith(".json")) {
+          this.conversationFile = this.conversationFile + "l";
+        }
+        const { messages, memoryScratchpad, ...metadata2 } = conversation;
+        const lines = [JSON.stringify(metadata2)];
+        for (const msg of messages) {
+          lines.push(JSON.stringify(msg));
+        }
+        if (memoryScratchpad) {
+          lines.push(JSON.stringify({ $set: { memoryScratchpad } }));
+        }
+        const content = lines.join("\n") + "\n";
+        try {
+          fs34.mkdirSync(path28.dirname(this.conversationFile), { recursive: true });
+          if (fs34.existsSync(this.conversationFile)) {
+            const backup = `${this.conversationFile}.unreadable-${Date.now()}`;
+            try {
+              fs34.renameSync(this.conversationFile, backup);
+              debugLogger.warn(`Preserved the unreadable session file at ${backup}.`);
+            } catch (backupError) {
+              debugLogger.error("Failed to preserve the unreadable session file.", backupError);
+            }
+          }
+          const tempFile = `${this.conversationFile}.tmp-${process.pid}`;
+          try {
+            fs34.writeFileSync(tempFile, content);
+            fs34.renameSync(tempFile, this.conversationFile);
+          } catch (error2) {
+            try {
+              fs34.unlinkSync(tempFile);
+            } catch {
+            }
+            throw error2;
+          }
+        } catch (error2) {
+          if (isNodeError(error2) && error2.code === "ENOSPC") {
+            this.conversationFile = null;
+            debugLogger.warn(ENOSPC_WARNING_MESSAGE);
+          } else {
+            throw error2;
+          }
+        }
+      }
       updateMetadata(updates) {
         if (!this.cachedConversation)
           return;
@@ -336586,7 +336640,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.54.0-preview.1";
+    return "0.54.4";
   })();
   return versionPromise;
 }
@@ -366183,16 +366237,29 @@ function stripThoughts2(history) {
     if (!hasThought)
       return turn;
     const nonThoughtParts = turn.content.parts.filter((p2) => p2 && !p2.thought);
+    let patchedFirstCall = false;
+    const finalParts = turn.content.role === "model" ? nonThoughtParts.map((p2) => {
+      if (!patchedFirstCall && p2.functionCall) {
+        patchedFirstCall = true;
+        if (!p2.thoughtSignature) {
+          return {
+            ...p2,
+            thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE2
+          };
+        }
+      }
+      return p2;
+    }) : nonThoughtParts;
     return {
       ...turn,
       content: {
         ...turn.content,
-        parts: nonThoughtParts
+        parts: finalParts
       }
     };
   }).filter((turn) => !turn.content.parts || turn.content.parts.length > 0);
 }
-var StreamEventType, MID_STREAM_RETRY_OPTIONS, SYNTHETIC_THOUGHT_SIGNATURE2, InvalidStreamError, AgentExecutionStoppedError, AgentExecutionBlockedError, GeminiChat;
+var StreamEventType, MID_STREAM_RETRY_OPTIONS, SYNTHETIC_THOUGHT_SIGNATURE2, INTERRUPTED_RESPONSE_PLACEHOLDER, InvalidStreamError, AgentExecutionStoppedError, AgentExecutionBlockedError, GeminiChat;
 var init_geminiChat = __esm({
   "packages/core/dist/src/core/geminiChat.js"() {
     "use strict";
@@ -366227,6 +366294,7 @@ var init_geminiChat = __esm({
       useExponentialBackoff: true
     };
     SYNTHETIC_THOUGHT_SIGNATURE2 = "skip_thought_signature_validator";
+    INTERRUPTED_RESPONSE_PLACEHOLDER = "[The previous response was interrupted before it completed.]";
     InvalidStreamError = class extends Error {
       type;
       constructor(message, type2) {
@@ -366343,6 +366411,9 @@ var init_geminiChat = __esm({
         this.sendPromise = streamDonePromise;
         let userContent = createUserContent(message);
         const isOriginalFunctionResponse = isFunctionResponse(userContent);
+        if (!isOriginalFunctionResponse) {
+          this.closeUnansweredToolResponseTurn();
+        }
         const { model } = this.context.config.modelConfigService.getResolvedConfig(modelConfigKey);
         const isContextManagementEnabled = this.context.config.isContextManagementEnabled();
         if (!isOriginalFunctionResponse) {
@@ -366510,6 +366581,24 @@ var init_geminiChat = __esm({
         };
         return streamWithRetries.call(this);
       }
+      /**
+       * Appends a closing model turn when history ends with an unanswered tool
+       * response, so the next user message stays a turn of its own.
+       */
+      closeUnansweredToolResponseTurn() {
+        const turns = this.agentHistory.get();
+        const last2 = turns[turns.length - 1];
+        if (last2?.content.role !== "user" || !last2.content.parts?.some((part) => !!part.functionResponse)) {
+          return;
+        }
+        this.agentHistory.push({
+          id: randomUUID8(),
+          content: {
+            role: "model",
+            parts: [{ text: INTERRUPTED_RESPONSE_PLACEHOLDER }]
+          }
+        });
+      }
       extractBinaryInjections(parts2) {
         const binaryParts = [];
         if (parts2) {