@google/gemini-cli-a2a-server 0.21.0-nightly.20251204.3da4fd5f7 → 0.21.0-nightly.20251205.f4f2bcbd9

package/dist/a2a-server.mjs

@@ -311854,8 +311854,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 = "3da4fd5f7";
-var CLI_VERSION = "0.21.0-nightly.20251204.3da4fd5f7";
+var GIT_COMMIT_INFO = "f4f2bcbd9";
+var CLI_VERSION = "0.21.0-nightly.20251205.f4f2bcbd9";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -315000,7 +315000,7 @@ async function createContentGenerator(config3, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version4 = "0.21.0-nightly.20251204.3da4fd5f7";
+    const version4 = "0.21.0-nightly.20251205.f4f2bcbd9";
     const customHeadersEnv = process.env["GEMINI_CLI_CUSTOM_HEADERS"] || void 0;
     const userAgent = `GeminiCLI/${version4} (${process.platform}; ${process.arch})`;
     const customHeadersMap = parseCustomHeaders(customHeadersEnv);
@@ -352866,7 +352866,6 @@ function delay2(ms, signal) {
 }
 
 // packages/core/dist/src/utils/retry.js
-var FETCH_FAILED_MESSAGE = "exception TypeError: fetch failed sending request";
 var DEFAULT_RETRY_OPTIONS = {
   maxAttempts: 3,
   initialDelayMs: 5e3,
@@ -352874,9 +352873,43 @@ var DEFAULT_RETRY_OPTIONS = {
   // 30 seconds
   shouldRetryOnError: defaultShouldRetry
 };
+var RETRYABLE_NETWORK_CODES = [
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "EPIPE",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ECONNREFUSED"
+];
+function getNetworkErrorCode(error2) {
+  const getCode = (obj) => {
+    if (typeof obj !== "object" || obj === null) {
+      return void 0;
+    }
+    if ("code" in obj && typeof obj.code === "string") {
+      return obj.code;
+    }
+    return void 0;
+  };
+  const directCode = getCode(error2);
+  if (directCode) {
+    return directCode;
+  }
+  if (typeof error2 === "object" && error2 !== null && "cause" in error2) {
+    return getCode(error2.cause);
+  }
+  return void 0;
+}
+var FETCH_FAILED_MESSAGE = "fetch failed";
 function defaultShouldRetry(error2, retryFetchErrors) {
-  if (retryFetchErrors && error2 instanceof Error && error2.message.includes(FETCH_FAILED_MESSAGE)) {
-    return true;
+  if (retryFetchErrors && error2 instanceof Error) {
+    if (error2.message.toLowerCase().includes(FETCH_FAILED_MESSAGE)) {
+      return true;
+    }
+    const errorCode = getNetworkErrorCode(error2);
+    if (errorCode && RETRYABLE_NETWORK_CODES.includes(errorCode)) {
+      return true;
+    }
   }
   if (error2 instanceof ApiError2) {
     if (error2.status === 400)
@@ -359252,24 +359285,11 @@ var ShellExecutionService = class {
           if (shellExecutionConfig.showColor) {
             newOutput = serializeTerminalToObject(headlessTerminal);
           } else {
-            const lines = [];
-            for (let y = 0; y < headlessTerminal.rows; y++) {
-              const line = buffer.getLine(buffer.viewportY + y);
-              const lineContent = line ? line.translateToString(true) : "";
-              lines.push([
-                {
-                  text: lineContent,
-                  bold: false,
-                  italic: false,
-                  underline: false,
-                  dim: false,
-                  inverse: false,
-                  fg: "",
-                  bg: ""
-                }
-              ]);
-            }
-            newOutput = lines;
+            newOutput = (serializeTerminalToObject(headlessTerminal) || []).map((line) => line.map((token2) => {
+              token2.fg = "";
+              token2.bg = "";
+              return token2;
+            }));
           }
           let lastNonEmptyLine = -1;
           for (let i4 = newOutput.length - 1; i4 >= 0; i4--) {
@@ -370232,7 +370252,7 @@ var GeminiClient = class {
     const model = this._getEffectiveModelForCurrentTurn();
     const { newHistory, info: info2 } = await this.compressionService.compress(this.getChat(), prompt_id, force, model, this.config, this.hasFailedCompressionAttempt);
     if (info2.compressionStatus === CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT) {
-      this.hasFailedCompressionAttempt = !force && true;
+      this.hasFailedCompressionAttempt = this.hasFailedCompressionAttempt || !force;
     } else if (info2.compressionStatus === CompressionStatus.COMPRESSED) {
       if (newHistory) {
         this.chat = await this.startChat(newHistory);
@@ -381702,7 +381722,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.21.0-nightly.20251204.3da4fd5f7",
+      ideVersion: "0.21.0-nightly.20251205.f4f2bcbd9",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -383629,17 +383649,23 @@ var McpClient = class {
   toolRegistry;
   promptRegistry;
   workspaceContext;
+  cliConfig;
   debugMode;
+  onToolsUpdated;
   client;
   transport;
   status = MCPServerStatus.DISCONNECTED;
-  constructor(serverName, serverConfig, toolRegistry, promptRegistry, workspaceContext, debugMode) {
+  isRefreshing = false;
+  pendingRefresh = false;
+  constructor(serverName, serverConfig, toolRegistry, promptRegistry, workspaceContext, cliConfig, debugMode, onToolsUpdated) {
     this.serverName = serverName;
     this.serverConfig = serverConfig;
     this.toolRegistry = toolRegistry;
     this.promptRegistry = promptRegistry;
     this.workspaceContext = workspaceContext;
+    this.cliConfig = cliConfig;
     this.debugMode = debugMode;
+    this.onToolsUpdated = onToolsUpdated;
   }
   /**
    * Connects to the MCP server.
@@ -383651,6 +383677,14 @@ var McpClient = class {
     this.updateStatus(MCPServerStatus.CONNECTING);
     try {
       this.client = await connectToMcpServer(this.serverName, this.serverConfig, this.debugMode, this.workspaceContext);
+      const capabilities = this.client.getServerCapabilities();
+      if (capabilities?.tools?.listChanged) {
+        debugLogger.log(`Server '${this.serverName}' supports tool updates. Listening for changes...`);
+        this.client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+          debugLogger.log(`\u{1F514} Received tool update notification from '${this.serverName}'`);
+          await this.refreshTools();
+        });
+      }
       const originalOnError = this.client.onerror;
       this.client.onerror = (error2) => {
         if (this.status !== MCPServerStatus.CONNECTED) {
@@ -383717,9 +383751,11 @@ var McpClient = class {
       throw new Error(`Client is not connected, must connect before interacting with the server. Current state is ${this.status}`);
     }
   }
-  async discoverTools(cliConfig) {
+  async discoverTools(cliConfig, options2) {
     this.assertConnected();
-    return discoverTools(this.serverName, this.serverConfig, this.client, cliConfig, this.toolRegistry.getMessageBus());
+    return discoverTools(this.serverName, this.serverConfig, this.client, cliConfig, this.toolRegistry.getMessageBus(), options2 ?? {
+      timeout: this.serverConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC
+    });
   }
   async discoverPrompts() {
     this.assertConnected();
@@ -383731,6 +383767,56 @@ var McpClient = class {
   getInstructions() {
     return this.client?.getInstructions();
   }
+  /**
+   * Refreshes the tools for this server by re-querying the MCP `tools/list` endpoint.
+   *
+   * This method implements a **Coalescing Pattern** to handle rapid bursts of notifications
+   * (e.g., during server startup or bulk updates) without overwhelming the server or
+   * creating race conditions in the global ToolRegistry.
+   */
+  async refreshTools() {
+    if (this.isRefreshing) {
+      debugLogger.log(`Tool refresh for '${this.serverName}' is already in progress. Pending update.`);
+      this.pendingRefresh = true;
+      return;
+    }
+    this.isRefreshing = true;
+    try {
+      do {
+        this.pendingRefresh = false;
+        if (this.status !== MCPServerStatus.CONNECTED || !this.client)
+          break;
+        const timeoutMs = this.serverConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC;
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+        let newTools;
+        try {
+          newTools = await this.discoverTools(this.cliConfig, {
+            signal: abortController.signal
+          });
+        } catch (err2) {
+          debugLogger.error(`Discovery failed during refresh: ${getErrorMessage(err2)}`);
+          clearTimeout(timeoutId);
+          break;
+        }
+        this.toolRegistry.removeMcpToolsByServer(this.serverName);
+        for (const tool of newTools) {
+          this.toolRegistry.registerTool(tool);
+        }
+        this.toolRegistry.sortTools();
+        if (this.onToolsUpdated) {
+          await this.onToolsUpdated(abortController.signal);
+        }
+        clearTimeout(timeoutId);
+        coreEvents.emitFeedback("info", `Tools updated for server: ${this.serverName}`);
+      } while (this.pendingRefresh);
+    } catch (error2) {
+      debugLogger.error(`Critical error in refresh loop for ${this.serverName}: ${getErrorMessage(error2)}`);
+    } finally {
+      this.isRefreshing = false;
+      this.pendingRefresh = false;
+    }
+  }
 };
 var serverStatuses = /* @__PURE__ */ new Map();
 var mcpDiscoveryState = MCPDiscoveryState.NOT_STARTED;
@@ -383853,11 +383939,11 @@ function populateMcpServerCommand(mcpServers, mcpServerCommand) {
   }
   return mcpServers;
 }
-async function discoverTools(mcpServerName, mcpServerConfig, mcpClient, cliConfig, messageBus) {
+async function discoverTools(mcpServerName, mcpServerConfig, mcpClient, cliConfig, messageBus, options2) {
   try {
     if (mcpClient.getServerCapabilities()?.tools == null)
       return [];
-    const response = await mcpClient.listTools({});
+    const response = await mcpClient.listTools({}, options2);
     const discoveredTools = [];
     for (const toolDef of response.tools) {
       try {
@@ -384410,7 +384496,13 @@ var McpClientManager = class {
           if (existing) {
             await existing.disconnect();
           }
-          const client = existing ?? new McpClient(name4, config3, this.toolRegistry, this.cliConfig.getPromptRegistry(), this.cliConfig.getWorkspaceContext(), this.cliConfig.getDebugMode());
+          const client = existing ?? new McpClient(name4, config3, this.toolRegistry, this.cliConfig.getPromptRegistry(), this.cliConfig.getWorkspaceContext(), this.cliConfig, this.cliConfig.getDebugMode(), async () => {
+            debugLogger.log("Tools changed, updating Gemini context...");
+            const geminiClient = this.cliConfig.getGeminiClient();
+            if (geminiClient.isInitialized()) {
+              await geminiClient.setTools();
+            }
+          });
           if (!existing) {
             this.clients.set(name4, client);
             this.eventEmitter?.emit("mcp-client-update", this.clients);