@google/gemini-cli-a2a-server 0.33.0-preview.4 → 0.33.0-preview.5

package/dist/a2a-server.mjs

@@ -122500,10 +122500,36 @@ var init_tools = __esm({
 
 // packages/core/dist/src/tools/mcp-tool.js
 function isMcpToolName(name4) {
-  if (!name4.includes(MCP_QUALIFIED_NAME_SEPARATOR))
-    return false;
-  const parts2 = name4.split(MCP_QUALIFIED_NAME_SEPARATOR);
-  return parts2.length === 2 && parts2[0].length > 0 && parts2[1].length > 0;
+  return name4.startsWith(MCP_TOOL_PREFIX);
+}
+function parseMcpToolName(name4) {
+  if (!isMcpToolName(name4)) {
+    return {};
+  }
+  const withoutPrefix = name4.slice(MCP_TOOL_PREFIX.length);
+  const match2 = withoutPrefix.match(/^([^_]+)_(.+)$/);
+  if (match2) {
+    return {
+      serverName: match2[1],
+      toolName: match2[2]
+    };
+  }
+  return {};
+}
+function formatMcpToolName(serverName, toolName) {
+  if (serverName === "*" && !toolName) {
+    return `${MCP_TOOL_PREFIX}*`;
+  } else if (serverName === "*") {
+    return `${MCP_TOOL_PREFIX}*_${toolName}`;
+  } else if (!toolName) {
+    return `${MCP_TOOL_PREFIX}${serverName}_*`;
+  } else {
+    return `${MCP_TOOL_PREFIX}${serverName}_${toolName}`;
+  }
+}
+function isMcpToolAnnotation(annotation) {
+  return typeof annotation === "object" && annotation !== null && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  typeof annotation["_serverName"] === "string";
 }
 function transformTextBlock(block) {
   return { text: block.text };
@@ -122598,24 +122624,28 @@ function getStringifiedResultForDisplay(rawResponse) {
   return displayParts.join("\n");
 }
 function generateValidName(name4) {
-  let validToolname = name4.replace(/[^a-zA-Z0-9_.:-]/g, "_");
+  let validToolname = name4.startsWith("mcp_") ? name4 : `mcp_${name4}`;
+  validToolname = validToolname.replace(/[^a-zA-Z0-9_\-.:]/g, "_");
   if (/^[^a-zA-Z_]/.test(validToolname)) {
     validToolname = `_${validToolname}`;
   }
   const safeLimit = MAX_FUNCTION_NAME_LENGTH - 1;
   if (validToolname.length > safeLimit) {
+    debugLogger.warn(`Truncating MCP tool name "${validToolname}" to fit within the 64 character limit. This tool may require user approval.`);
     validToolname = validToolname.slice(0, 30) + "..." + validToolname.slice(-30);
   }
   return validToolname;
 }
-var MCP_QUALIFIED_NAME_SEPARATOR, DiscoveredMCPToolInvocation, DiscoveredMCPTool, MAX_FUNCTION_NAME_LENGTH;
+var MCP_QUALIFIED_NAME_SEPARATOR, MCP_TOOL_PREFIX, DiscoveredMCPToolInvocation, DiscoveredMCPTool, MAX_FUNCTION_NAME_LENGTH;
 var init_mcp_tool = __esm({
   "packages/core/dist/src/tools/mcp-tool.js"() {
     "use strict";
     init_safeJsonStringify();
+    init_debugLogger();
     init_tools();
     init_tool_error();
-    MCP_QUALIFIED_NAME_SEPARATOR = "__";
+    MCP_QUALIFIED_NAME_SEPARATOR = "_";
+    MCP_TOOL_PREFIX = "mcp_";
     DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends BaseToolInvocation {
       mcpTool;
       serverName;
@@ -122757,7 +122787,7 @@ var init_mcp_tool = __esm({
       _toolAnnotations;
       constructor(mcpTool, serverName, serverToolName, description, parameterSchema, messageBus, trust, isReadOnly, nameOverride, cliConfig, extensionName, extensionId, _toolAnnotations) {
         super(
-          generateValidName(nameOverride ?? serverToolName),
+          nameOverride ?? generateValidName(`${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`),
           `${serverToolName} (${serverName} MCP Server)`,
           description,
           Kind.Other,
@@ -122792,7 +122822,7 @@ var init_mcp_tool = __esm({
         return this._toolAnnotations;
       }
       getFullyQualifiedPrefix() {
-        return `${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}`;
+        return generateValidName(`${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}`);
       }
       getFullyQualifiedName() {
         return generateValidName(`${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${this.serverToolName}`);
@@ -214180,8 +214210,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 = "7e6e40c81";
-    CLI_VERSION = "0.33.0-preview.4";
+    GIT_COMMIT_INFO = "a6256cdab";
+    CLI_VERSION = "0.33.0-preview.5";
   }
 });
 
@@ -291439,7 +291469,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname3);
-    return "0.33.0-preview.4";
+    return "0.33.0-preview.5";
   })();
   return versionPromise;
 }
@@ -293618,11 +293648,11 @@ Signal: Signal number or \`(none)\` if no signal was received.
       buildToolMetadata() {
         const toolMetadata = /* @__PURE__ */ new Map();
         for (const [name4, tool] of this.allKnownTools) {
-          if (tool.toolAnnotations) {
-            const metadata2 = { ...tool.toolAnnotations };
-            if (tool instanceof DiscoveredMCPTool) {
-              metadata2["_serverName"] = tool.serverName;
-            }
+          const metadata2 = tool.toolAnnotations ? { ...tool.toolAnnotations } : {};
+          if (tool instanceof DiscoveredMCPTool) {
+            metadata2["_serverName"] = tool.serverName;
+          }
+          if (Object.keys(metadata2).length > 0) {
             toolMetadata.set(name4, metadata2);
           }
         }
@@ -400313,34 +400343,17 @@ function matchesWildcard(pattern, toolName, serverName) {
   if (pattern === "*") {
     return true;
   }
-  if (pattern.includes("__")) {
-    return matchesCompositePattern(pattern, toolName, serverName);
-  }
-  return toolName === pattern;
-}
-function matchesCompositePattern(pattern, toolName, serverName) {
-  const parts2 = pattern.split("__");
-  if (parts2.length !== 2)
-    return false;
-  const [patternServer, patternTool] = parts2;
-  const { actualServer, actualTool } = getToolMetadata(toolName, serverName);
-  if (actualServer === void 0) {
-    return false;
+  if (pattern === `${MCP_TOOL_PREFIX}*`) {
+    return serverName !== void 0;
   }
-  if (serverName !== void 0 && !toolName.startsWith(serverName + "__")) {
-    return false;
+  if (pattern.startsWith(MCP_TOOL_PREFIX) && pattern.endsWith("_*")) {
+    const expectedServerName = pattern.slice(MCP_TOOL_PREFIX.length, -2);
+    if (serverName === void 0 || serverName !== expectedServerName) {
+      return false;
+    }
+    return toolName.startsWith(`${MCP_TOOL_PREFIX}${expectedServerName}_`);
   }
-  const serverMatch = patternServer === "*" || patternServer === actualServer;
-  const toolMatch = patternTool === "*" || patternTool === actualTool;
-  return serverMatch && toolMatch;
-}
-function getToolMetadata(toolName, serverName) {
-  const sepIndex = toolName.indexOf("__");
-  const isQualified = sepIndex !== -1;
-  return {
-    actualServer: serverName ?? (isQualified ? toolName.substring(0, sepIndex) : void 0),
-    actualTool: isQualified ? toolName.substring(sepIndex + 2) : toolName
-  };
+  return toolName === pattern;
 }
 function ruleMatches(rule, toolCall, stringifiedArgs, serverName, currentApprovalMode, toolAnnotations) {
   if (rule.modes && rule.modes.length > 0) {
@@ -400348,6 +400361,15 @@ function ruleMatches(rule, toolCall, stringifiedArgs, serverName, currentApprova
       return false;
     }
   }
+  if (rule.mcpName) {
+    if (rule.mcpName === "*") {
+      if (serverName === void 0)
+        return false;
+    } else {
+      if (serverName !== rule.mcpName)
+        return false;
+    }
+  }
   if (rule.toolName) {
     if (rule.toolName === "*") {
     } else if (isWildcardPattern(rule.toolName)) {
@@ -400389,6 +400411,7 @@ var init_policy_engine = __esm({
     init_protocol2();
     init_shell_utils();
     init_tool_names();
+    init_mcp_tool();
     PolicyEngine = class {
       rules;
       checkers;
@@ -400517,6 +400540,15 @@ var init_policy_engine = __esm({
        * Returns the decision and the matching rule (if any).
        */
       async check(toolCall, serverName, toolAnnotations) {
+        if (!serverName && isMcpToolAnnotation(toolAnnotations)) {
+          serverName = toolAnnotations._serverName;
+        }
+        if (!serverName && toolCall.name) {
+          const parsed = parseMcpToolName(toolCall.name);
+          if (parsed.serverName) {
+            serverName = parsed.serverName;
+          }
+        }
         let stringifiedArgs;
         if (toolCall.args && (this.rules.some((rule) => rule.argsPattern) || this.checkers.some((checker) => checker.argsPattern))) {
           stringifiedArgs = stableStringify(toolCall.args);
@@ -400538,12 +400570,6 @@ var init_policy_engine = __esm({
         const toolCallsToTry = [];
         for (const name4 of toolNamesToTry) {
           toolCallsToTry.push({ ...toolCall, name: name4 });
-          if (serverName && !name4.includes("__")) {
-            toolCallsToTry.push({
-              ...toolCall,
-              name: `${serverName}__${name4}`
-            });
-          }
         }
         for (const rule of this.rules) {
           const match2 = toolCallsToTry.some((tc) => ruleMatches(rule, tc, stringifiedArgs, serverName, this.approvalMode, toolAnnotations));
@@ -400689,107 +400715,52 @@ var init_policy_engine = __esm({
        */
       getExcludedTools(toolMetadata, allToolNames) {
         const excludedTools = /* @__PURE__ */ new Set();
-        const processedTools = /* @__PURE__ */ new Set();
-        let globalVerdict;
-        for (const rule of this.rules) {
-          if (rule.argsPattern) {
-            if (rule.toolName && rule.decision !== PolicyDecision.DENY) {
-              processedTools.add(rule.toolName);
-            }
-            continue;
-          }
-          if (rule.modes && rule.modes.length > 0) {
-            if (!rule.modes.includes(this.approvalMode)) {
-              continue;
-            }
-          }
-          if (rule.toolAnnotations) {
-            if (!toolMetadata) {
-              continue;
-            }
-            for (const [toolName2, annotations] of toolMetadata) {
-              if (processedTools.has(toolName2)) {
-                continue;
-              }
-              let annotationsMatch = true;
-              for (const [key, value] of Object.entries(rule.toolAnnotations)) {
-                if (annotations[key] !== value) {
-                  annotationsMatch = false;
+        if (!allToolNames) {
+          return excludedTools;
+        }
+        for (const toolName of allToolNames) {
+          const annotations = toolMetadata?.get(toolName);
+          const serverName = isMcpToolAnnotation(annotations) ? annotations._serverName : void 0;
+          let staticallyExcluded = false;
+          let matchFound = false;
+          for (const rule of this.rules) {
+            const ruleWithoutArgs = { ...rule, argsPattern: void 0 };
+            const toolCall = { name: toolName, args: {} };
+            const appliesToTool = ruleMatches(
+              ruleWithoutArgs,
+              toolCall,
+              void 0,
+              // stringifiedArgs
+              serverName,
+              this.approvalMode,
+              annotations
+            );
+            if (appliesToTool) {
+              if (rule.argsPattern) {
+                if (rule.decision !== PolicyDecision.DENY) {
+                  staticallyExcluded = false;
+                  matchFound = true;
                   break;
                 }
-              }
-              if (!annotationsMatch) {
                 continue;
-              }
-              if (rule.toolName) {
-                if (isWildcardPattern(rule.toolName)) {
-                  const rawServerName = annotations["_serverName"];
-                  const serverName = typeof rawServerName === "string" ? rawServerName : void 0;
-                  const qualifiedName = serverName && !toolName2.includes("__") ? `${serverName}__${toolName2}` : toolName2;
-                  if (!matchesWildcard(rule.toolName, qualifiedName, void 0)) {
-                    continue;
-                  }
-                } else if (toolName2 !== rule.toolName) {
-                  continue;
-                }
-              }
-              let decision2;
-              if (globalVerdict !== void 0) {
-                decision2 = globalVerdict;
               } else {
-                decision2 = rule.decision;
-              }
-              if (decision2 === PolicyDecision.DENY) {
-                excludedTools.add(toolName2);
-              }
-              processedTools.add(toolName2);
-            }
-            continue;
-          }
-          if (!rule.toolName) {
-            if (globalVerdict === void 0) {
-              globalVerdict = rule.decision;
-              if (globalVerdict !== PolicyDecision.DENY) {
+                const decision = this.applyNonInteractiveMode(rule.decision);
+                staticallyExcluded = decision === PolicyDecision.DENY;
+                matchFound = true;
                 break;
               }
             }
-            continue;
-          }
-          const toolName = rule.toolName;
-          if (processedTools.has(toolName)) {
-            continue;
           }
-          let coveredByWildcard = false;
-          for (const processed of processedTools) {
-            if (isWildcardPattern(processed) && matchesWildcard(processed, toolName, void 0)) {
-              if (excludedTools.has(processed)) {
-                excludedTools.add(toolName);
-              }
-              coveredByWildcard = true;
-              break;
+          if (!matchFound) {
+            const defaultDec = this.applyNonInteractiveMode(this.defaultDecision);
+            if (defaultDec === PolicyDecision.DENY) {
+              staticallyExcluded = true;
             }
           }
-          if (coveredByWildcard) {
-            continue;
-          }
-          processedTools.add(toolName);
-          let decision;
-          if (globalVerdict !== void 0) {
-            decision = globalVerdict;
-          } else {
-            decision = rule.decision;
-          }
-          if (decision === PolicyDecision.DENY) {
+          if (staticallyExcluded) {
             excludedTools.add(toolName);
           }
         }
-        if (globalVerdict === PolicyDecision.DENY && allToolNames) {
-          for (const name4 of allToolNames) {
-            if (!processedTools.has(name4)) {
-              excludedTools.add(name4);
-            }
-          }
-        }
         return excludedTools;
       }
       applyNonInteractiveMode(decision) {
@@ -414054,7 +414025,10 @@ function validateShellCommandSyntax(rule, ruleIndex) {
   return null;
 }
 function validateToolName(name4, ruleIndex) {
-  if (isValidToolName(name4, { allowWildcards: true }) && !name4.includes("__")) {
+  if (name4.includes("__")) {
+    return `Rule #${ruleIndex + 1}: The "__" syntax for MCP tools is strictly deprecated. Please use the 'mcpName = "..."' property or the 'mcp_server_tool' format instead.`;
+  }
+  if (isValidToolName(name4, { allowWildcards: true })) {
     return null;
   }
   const allNames = [...ALL_BUILTIN_TOOL_NAMES];
@@ -414139,8 +414113,6 @@ async function loadPoliciesFromToml(policyPaths, getPolicyTier) {
         }
         for (let i4 = 0; i4 < tomlRules.length; i4++) {
           const rule = tomlRules[i4];
-          if (rule.mcpName)
-            continue;
           const toolNames = rule.toolName ? Array.isArray(rule.toolName) ? rule.toolName : [rule.toolName] : [];
           for (const name4 of toolNames) {
             const warning = validateToolName(name4, i4);
@@ -414163,16 +414135,14 @@ async function loadPoliciesFromToml(policyPaths, getPolicyTier) {
           return argsPatterns.flatMap((argsPattern) => {
             const toolNames = rule.toolName ? Array.isArray(rule.toolName) ? rule.toolName : [rule.toolName] : [void 0];
             return toolNames.map((toolName) => {
-              let effectiveToolName;
-              if (rule.mcpName && toolName) {
-                effectiveToolName = `${rule.mcpName}__${toolName}`;
-              } else if (rule.mcpName) {
-                effectiveToolName = `${rule.mcpName}__*`;
-              } else {
-                effectiveToolName = toolName;
+              let effectiveToolName = toolName;
+              const mcpName = rule.mcpName;
+              if (mcpName) {
+                effectiveToolName = formatMcpToolName(mcpName, effectiveToolName);
               }
               const policyRule = {
                 toolName: effectiveToolName,
+                mcpName: rule.mcpName,
                 decision: rule.decision,
                 priority: transformPriority(rule.priority, tier),
                 modes: rule.modes,
@@ -414246,14 +414216,15 @@ Error: ${error2.message}`,
             return toolNames.map((toolName) => {
               let effectiveToolName;
               if (checker.mcpName && toolName) {
-                effectiveToolName = `${checker.mcpName}__${toolName}`;
+                effectiveToolName = `${MCP_TOOL_PREFIX}${checker.mcpName}_${toolName}`;
               } else if (checker.mcpName) {
-                effectiveToolName = `${checker.mcpName}__*`;
+                effectiveToolName = `${MCP_TOOL_PREFIX}${checker.mcpName}_*`;
               } else {
                 effectiveToolName = toolName;
               }
               const safetyCheckerRule = {
                 toolName: effectiveToolName,
+                mcpName: checker.mcpName,
                 priority: transformPriority(checker.priority, tier),
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 checker: checker.checker,
@@ -414312,14 +414283,19 @@ Error: ${error2.message}`
   return { rules, checkers, errors };
 }
 function validateMcpPolicyToolNames(serverName, discoveredToolNames, policyRules) {
-  const prefix = `${serverName}__`;
+  const prefix = `${MCP_TOOL_PREFIX}${serverName}_`;
   const warnings = [];
   for (const rule of policyRules) {
     if (!rule.toolName)
       continue;
-    if (!rule.toolName.startsWith(prefix))
+    let toolPart;
+    if (rule.mcpName === serverName && rule.toolName.startsWith(prefix)) {
+      toolPart = rule.toolName.slice(prefix.length);
+    } else if (rule.toolName.startsWith(prefix)) {
+      toolPart = rule.toolName.slice(prefix.length);
+    } else {
       continue;
-    const toolPart = rule.toolName.slice(prefix.length);
+    }
     if (toolPart === "*")
       continue;
     if (discoveredToolNames.includes(toolPart))
@@ -414347,6 +414323,7 @@ var init_toml_loader = __esm({
     import_toml = __toESM(require_toml(), 1);
     init_zod();
     init_errors();
+    init_mcp_tool();
     MAX_TYPO_DISTANCE = 3;
     PolicyRuleSchema = external_exports.object({
       toolName: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
@@ -414429,6 +414406,7 @@ var init_config3 = __esm({
     init_shell_utils();
     init_tool_names();
     init_errors();
+    init_mcp_tool();
     init_security();
     __filename3 = fileURLToPath15(import.meta.url);
     __dirname7 = path77.dirname(__filename3);