Merge pull request #1271 from BudEcosystem/fix/tool_name_prefix

Fix/tool name prefix

Author: vsraccubits

services/budapp/budapp/prompt_ops/schemas.py

@@ -652,6 +652,9 @@ class MCPToolConfig(BaseModel):
     gateway_config: Dict[str, str] = Field(
         default_factory=dict, description="Gateway configuration with connector_id as key and gateway_id as value"
     )
+    gateway_slugs: Dict[str, str] = Field(
+        default_factory=dict, description="Gateway slugs with connector_id as key and gateway_slug as value"
+    )
     server_config: Dict[str, List[str]] = Field(
         default_factory=dict, description="Server configuration with connector_id as key and list of tool IDs as value"
     )

services/budapp/budapp/prompt_ops/services.py

@@ -1406,22 +1406,28 @@ async def register_connector_for_prompt(
                 name=gateway_name, url=connector.url, transport=transport, visibility="public", auth_config=auth_config
             )
 
+            gateway_id = gateway_response.get("id", gateway_response.get("gateway_id"))
+            gateway_slug = gateway_response.get("slug")
+
             logger.debug(
                 f"Successfully created gateway for connector {connector_id} and prompt {budprompt_id}",
-                gateway_id=gateway_response.get("id", gateway_response.get("gateway_id")),
+                gateway_id=gateway_id,
+                gateway_slug=gateway_slug,
             )
 
             # Create GatewayResponse object
             gateway = GatewayResponse(
-                gateway_id=gateway_response.get("id", gateway_response.get("gateway_id")),
+                gateway_id=gateway_id,
                 name=gateway_name,
                 url=connector.url,
                 transport="SSE",
                 visibility="public",
             )
 
             # Store MCP tool configuration in Redis via budprompt service
-            await self._store_mcp_tool_config(budprompt_id, connector_id, gateway.gateway_id, version, permanent)
+            await self._store_mcp_tool_config(
+                budprompt_id, connector_id, gateway.gateway_id, gateway_slug, version, permanent
+            )
 
             # Update PromptVersion metadata with gateway_id (if prompt and version exist in DB)
             try:
@@ -1760,6 +1766,10 @@ async def disconnect_connector_from_prompt(
         # Step 5: Update gateway_config - remove connector
         del gateway_config[connector_id]
 
+        # Step 5b: Update gateway_slugs - remove connector's slug
+        gateway_slugs = mcp_tool.get("gateway_slugs", {})
+        gateway_slugs.pop(connector_id, None)
+
         # Step 6: Update server_config - remove connector's tools
         server_config.pop(connector_id, None)
 
@@ -1794,6 +1804,7 @@ async def disconnect_connector_from_prompt(
         else:
             # Update MCP tool config (connectors still remain)
             mcp_tool["gateway_config"] = gateway_config
+            mcp_tool["gateway_slugs"] = gateway_slugs
             mcp_tool["server_config"] = server_config
             mcp_tool["allowed_tools"] = updated_allowed_tools
             mcp_tool["allowed_tool_names"] = updated_allowed_tool_names
@@ -1930,6 +1941,7 @@ async def _store_mcp_tool_config(
         budprompt_id: str,
         connector_id: str,
         gateway_id: str,
+        gateway_slug: Optional[str] = None,
         version: Optional[int] = None,
         permanent: bool = False,
     ) -> None:
@@ -1939,13 +1951,15 @@ async def _store_mcp_tool_config(
             budprompt_id: The bud prompt ID (can be UUID or draft prompt ID)
             connector_id: The connector ID
             gateway_id: The gateway ID from MCP Foundry
+            gateway_slug: The gateway slug from MCP Foundry (used for tool name shortening)
             version: Optional version to update. If None, updates default version
             permanent: Store configuration permanently without expiration
 
         Raises:
             ClientException: If storing configuration fails
         """
         # 1. Create MCPToolConfig using Pydantic schema
+        gateway_slugs = {connector_id: gateway_slug} if gateway_slug else {}
         mcp_tool = MCPToolConfig(
             type="mcp",
             server_label=None,
@@ -1955,6 +1969,7 @@ async def _store_mcp_tool_config(
             allowed_tools=[],
             connector_id=None,  # Set to None as requested
             gateway_config={connector_id: gateway_id},
+            gateway_slugs=gateway_slugs,
         )
         mcp_tool_dict = mcp_tool.model_dump(exclude_none=True)
 
@@ -2011,6 +2026,12 @@ async def _store_mcp_tool_config(
             gateway_config[connector_id] = gateway_id
             existing_mcp_tool["gateway_config"] = gateway_config
 
+            # Also merge gateway_slugs for tool name shortening
+            gateway_slugs_dict = existing_mcp_tool.get("gateway_slugs", {})
+            if gateway_slug:
+                gateway_slugs_dict[connector_id] = gateway_slug
+            existing_mcp_tool["gateway_slugs"] = gateway_slugs_dict
+
             # Also update server_config to maintain consistency
             server_config = existing_mcp_tool.get("server_config", {})
             # Note: server_config is updated separately when tools are added

services/budprompt/budprompt/executors/v4/tool_loaders.py

@@ -54,14 +54,19 @@ def __init__(self):
         self.base_url = app_settings.mcp_foundry_base_url
         self.api_key = app_settings.mcp_foundry_api_key
 
-    async def load_tools(self, tool_config: MCPToolConfig) -> Optional[MCPServerStreamableHTTP]:
-        """Load MCP tools from configuration.
+    async def load_tools(self, tool_config: MCPToolConfig) -> Optional[Any]:
+        """Load MCP tools from configuration with optional name shortening.
+
+        When gateway_slugs are provided, tool names are shortened by stripping
+        the gateway prefix. This helps with:
+        1. OpenAI's 64-character limit on function/tool names
+        2. Improved accuracy in smaller LLMs with cleaner tool names
 
         Args:
             tool_config: MCP tool configuration
 
         Returns:
-            MCPServerStreamableHTTP instance or None if server_url is missing
+            MCPServerStreamableHTTP instance (possibly renamed) or None if server_url is missing
         """
         # Only create toolset if server_url is present
         if not tool_config.server_url:
@@ -80,6 +85,37 @@ async def load_tools(self, tool_config: MCPToolConfig) -> Optional[MCPServerStre
             # Create MCPServerStreamableHTTP instance
             mcp_server = MCPServerStreamableHTTP(url=mcp_url, headers=headers if headers else None)
 
+            # Get all gateway slugs (multiple connectors = multiple slugs)
+            gateway_slugs = self._get_gateway_slugs(tool_config)
+
+            if gateway_slugs:
+                # Fetch tool list to get original names
+                tool_list = await self.get_tool_list(mcp_server, tool_config.server_label or "unknown")
+                if tool_list and tool_list.get("tools"):
+                    original_names = [tool.name for tool in tool_list["tools"]]
+
+                    # Generate mapping: short_name -> original_name
+                    # Try each slug to find matching prefix
+                    name_map = {}
+                    for original in original_names:
+                        short = original  # Default: keep original if no prefix matches
+                        for slug in gateway_slugs:
+                            prefix = f"{slug}-"
+                            if original.startswith(prefix):
+                                short = original[len(prefix) :]
+                                break  # Found matching prefix, stop searching
+                        name_map[short] = original
+
+                    # Update allowed_tool_names with SHORT names
+                    tool_config.allowed_tool_names = list(name_map.keys())
+
+                    logger.info(
+                        f"Stripped gateway prefixes from {len(name_map)} tools "
+                        f"for server '{tool_config.server_label}' using {len(gateway_slugs)} slug(s)"
+                    )
+
+                    return mcp_server.renamed(name_map)
+
             logger.debug(
                 f"Loaded MCP tool '{tool_config.server_label}' from {mcp_url} "
                 f"with {len(tool_config.allowed_tools)} allowed tools"
@@ -91,6 +127,24 @@ async def load_tools(self, tool_config: MCPToolConfig) -> Optional[MCPServerStre
             logger.error(f"Failed to load MCP tool '{tool_config.server_label}': {str(e)}")
             return None
 
+    def _get_gateway_slugs(self, tool_config: MCPToolConfig) -> List[str]:
+        """Extract all gateway slugs from tool config.
+
+        When multiple connectors are registered, gateway_slugs contains:
+        {connector1: slug1, connector2: slug2, ...}
+
+        Returns all slugs so we can strip any matching prefix.
+
+        Args:
+            tool_config: MCP tool configuration
+
+        Returns:
+            List of gateway slugs
+        """
+        if tool_config.gateway_slugs:
+            return list(tool_config.gateway_slugs.values())
+        return []
+
     async def get_tool_list(self, mcp_server: MCPServerStreamableHTTP, server_label: str) -> Optional[Dict]:
         """Fetch the list of available tools from an MCP server.
 

services/budprompt/budprompt/prompt/schemas.py

@@ -129,6 +129,9 @@ class MCPToolConfig(BaseModel):
     gateway_config: Dict[str, str] = Field(
         default_factory=dict, description="Gateway configuration with connector_id as key and gateway_id as value"
     )
+    gateway_slugs: Dict[str, str] = Field(
+        default_factory=dict, description="Gateway slugs with connector_id as key and gateway_slug as value"
+    )
     server_config: Dict[str, List[str]] = Field(
         default_factory=dict, description="Server configuration with connector_id as key and list of tool IDs as value"
     )