alita-sdk 0.3.462__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/runtime/toolkits/mcp.py

@@ -6,19 +6,17 @@ Following MCP specification: https://modelcontextprotocol.io/specification/2025-
 
 import logging
 import re
-import requests
 import asyncio
 from typing import List, Optional, Any, Dict, Literal, ClassVar, Union
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 from ..tools.mcp_server_tool import McpServerTool
 from ..tools.mcp_remote_tool import McpRemoteTool
 from ..tools.mcp_inspect_tool import McpInspectTool
-from ...tools.utils import TOOLKIT_SPLITTER, clean_string
 from ..models.mcp_models import McpConnectionConfig
-from ..utils.mcp_sse_client import McpSseClient
+from ..utils.mcp_client import McpClient
 from ..utils.mcp_oauth import (
     McpAuthorizationRequired,
     canonical_resource,
@@ -41,110 +39,6 @@ def safe_int(value, default):
         logger.warning(f"Invalid integer value '{value}', using default {default}")
         return default
 
-def optimize_tool_name(prefix: str, tool_name: str, max_total_length: int = 64) -> str:
-    """
-    Optimize tool name to fit within max_total_length while preserving meaning.
-    
-    Args:
-        prefix: The toolkit prefix (already cleaned)
-        tool_name: The original tool name
-        max_total_length: Maximum total length for the full tool name (default: 64)
-    
-    Returns:
-        Optimized full tool name in format: prefix___tool_name
-    """
-    splitter = TOOLKIT_SPLITTER
-    splitter_len = len(splitter)
-    prefix_len = len(prefix)
-    
-    # Calculate available space for tool name
-    available_space = max_total_length - prefix_len - splitter_len
-    
-    if available_space <= 0:
-        logger.error(f"Prefix '{prefix}' is too long ({prefix_len} chars), cannot create valid tool name")
-        # Fallback: truncate prefix itself
-        prefix = prefix[:max_total_length - splitter_len - 10]  # Leave 10 chars for tool name
-        available_space = max_total_length - len(prefix) - splitter_len
-    
-    # If tool name fits, use it as-is
-    if len(tool_name) <= available_space:
-        return f'{prefix}{splitter}{tool_name}'
-    
-    # Tool name is too long, need to optimize
-    logger.debug(f"Tool name '{tool_name}' is too long ({len(tool_name)} chars), optimizing to fit {available_space} chars")
-    
-    # Split tool name into parts (handle camelCase, snake_case, and mixed)
-    # First, split by underscores and hyphens
-    parts = re.split(r'[_-]', tool_name)
-    
-    # Further split camelCase within each part
-    all_parts = []
-    for part in parts:
-        # Insert underscore before uppercase letters (camelCase to snake_case)
-        snake_case_part = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', part)
-        all_parts.extend(snake_case_part.split('_'))
-    
-    # Filter out empty parts
-    all_parts = [p for p in all_parts if p]
-    
-    # Remove redundant prefix words (case-insensitive comparison)
-    # Only remove if prefix is meaningful (>= 3 chars) to avoid over-filtering
-    prefix_lower = prefix.lower()
-    filtered_parts = []
-    for part in all_parts:
-        part_lower = part.lower()
-        # Skip if this part contains the prefix or the prefix contains this part
-        # But only if both are meaningful (>= 3 chars)
-        should_remove = False
-        if len(prefix_lower) >= 3 and len(part_lower) >= 3:
-            if part_lower in prefix_lower or prefix_lower in part_lower:
-                should_remove = True
-                logger.debug(f"Removing redundant part '{part}' (matches prefix '{prefix}')")
-        
-        if not should_remove:
-            filtered_parts.append(part)
-    
-    # If we removed all parts, keep the original parts
-    if not filtered_parts:
-        filtered_parts = all_parts
-    
-    # Reconstruct tool name with filtered parts
-    optimized_name = '_'.join(filtered_parts)
-    
-    # If still too long, truncate intelligently
-    if len(optimized_name) > available_space:
-        # Strategy: Keep beginning and end, as they often contain the most important info
-        # For example: "projectalita_github_io_list_branches" -> "projectalita_list_branches"
-        
-        # Try removing middle parts first
-        if len(filtered_parts) > 2:
-            # Keep first and last parts, remove middle
-            kept_parts = [filtered_parts[0], filtered_parts[-1]]
-            optimized_name = '_'.join(kept_parts)
-            
-            # If still too long, add parts from the end until we run out of space
-            if len(optimized_name) <= available_space and len(filtered_parts) > 2:
-                for i in range(len(filtered_parts) - 2, 0, -1):
-                    candidate = '_'.join([filtered_parts[0]] + filtered_parts[i:])
-                    if len(candidate) <= available_space:
-                        optimized_name = candidate
-                        break
-        
-        # If still too long, just truncate
-        if len(optimized_name) > available_space:
-            # Try to truncate at word boundary
-            truncated = optimized_name[:available_space]
-            last_underscore = truncated.rfind('_')
-            if last_underscore > available_space * 0.7:  # Keep if we're not losing too much
-                optimized_name = truncated[:last_underscore]
-            else:
-                optimized_name = truncated
-    
-    full_name = f'{prefix}{splitter}{optimized_name}'
-    logger.info(f"Optimized tool name: '{tool_name}' ({len(tool_name)} chars) -> '{optimized_name}' ({len(optimized_name)} chars), full: '{full_name}' ({len(full_name)} chars)")
-    
-    return full_name
-
 class McpToolkit(BaseToolkit):
     """
     MCP Toolkit for connecting to a single remote MCP server and exposing its tools.
@@ -154,9 +48,6 @@ class McpToolkit(BaseToolkit):
     tools: List[BaseTool] = []
     toolkit_name: Optional[str] = None
 
-    # Class variable (not Pydantic field) for tool name length limit
-    toolkit_max_length: ClassVar[int] = 0  # No limit for MCP tool names
-
     def __getstate__(self):
         """Custom serialization for pickle compatibility."""
         state = self.__dict__.copy()
@@ -208,28 +99,32 @@ class McpToolkit(BaseToolkit):
                     }
                 )
             ),
-            timeout=(
-                Union[int, str], # TODO: remove one I will figure out why UI sends str
+            client_id=(
+                Optional[str],
                 Field(
-                    default=300,
-                    description="Request timeout in seconds (1-3600)"
+                    default=None,
+                    description="OAuth Client ID (if applicable)"
                 )
             ),
-            discovery_mode=(
-                Literal['static', 'dynamic', 'hybrid'],
+            client_secret=(
+                Optional[SecretStr],
                 Field(
-                    default="dynamic",
-                    description="Discovery mode",
-                    json_schema_extra={
-                        'tooltip': 'static: use registry, dynamic: live discovery, hybrid: try dynamic first'
-                    }
+                    default=None,
+                    description="OAuth Client Secret (if applicable)"
                 )
             ),
-            discovery_interval=(
-                Union[int, str],
+            scopes=(
+                Optional[List[str]],
+                Field(
+                    default=None,
+                    description="OAuth Scopes (if applicable)"
+                )
+            ),
+            timeout=(
+                Union[int, str], # TODO: remove one I will figure out why UI sends str
                 Field(
                     default=300,
-                    description="Discovery interval in seconds (60-3600, for periodic discovery)"
+                    description="Request timeout in seconds (1-3600)"
                 )
             ),
             selected_tools=(
@@ -259,7 +154,7 @@ class McpToolkit(BaseToolkit):
             __config__=ConfigDict(
                 json_schema_extra={
                     'metadata': {
-                        "label": "Remove MCP",
+                        "label": "Remote MCP",
                         "icon_url": None,
                         "categories": ["other"],
                         "extra_categories": ["remote tools", "sse", "http"],
@@ -275,8 +170,6 @@ class McpToolkit(BaseToolkit):
         url: str,
         headers: Optional[Dict[str, str]] = None,
         timeout: int = 60,
-        discovery_mode: str = "hybrid",
-        discovery_interval: int = 300,
         selected_tools: List[str] = None,
         enable_caching: bool = True,
         cache_ttl: int = 300,
@@ -297,8 +190,6 @@ class McpToolkit(BaseToolkit):
             url: MCP server HTTP URL
             headers: HTTP headers for authentication
             timeout: Request timeout in seconds
-            discovery_mode: Discovery mode ('static', 'dynamic', 'hybrid')
-            discovery_interval: Discovery interval in seconds (for periodic discovery)
             selected_tools: List of specific tools to enable (empty = all tools)
             enable_caching: Whether to enable caching
             cache_ttl: Cache TTL in seconds
@@ -317,7 +208,6 @@ class McpToolkit(BaseToolkit):
 
         # Convert numeric parameters that may come as strings from UI
         timeout = safe_int(timeout, 60)
-        discovery_interval = safe_int(discovery_interval, 300)
         cache_ttl = safe_int(cache_ttl, 300)
 
         logger.info(f"Creating MCP toolkit: {toolkit_name}")
@@ -363,8 +253,7 @@ class McpToolkit(BaseToolkit):
             connection_config=connection_config,
             timeout=timeout,
             selected_tools=selected_tools,
-            client=client,
-            discovery_mode=discovery_mode
+            client=client
         )
 
         return toolkit
@@ -376,8 +265,7 @@ class McpToolkit(BaseToolkit):
         connection_config: McpConnectionConfig,
         timeout: int,
         selected_tools: List[str],
-        client,
-        discovery_mode: str = "dynamic"
+        client
     ) -> List[BaseTool]:
         """
         Create tools from a single MCP server. Always performs live discovery when connection config is provided.
@@ -423,19 +311,23 @@ class McpToolkit(BaseToolkit):
 
             logger.info(f"Successfully created {len(tools)} MCP tools from toolkit '{toolkit_name}' via direct discovery")
 
+        except McpAuthorizationRequired:
+            # Authorization is required; surface upstream so the caller can prompt the user
+            logger.info(f"MCP toolkit '{toolkit_name}' requires OAuth authorization")
+            raise
         except Exception as e:
             logger.error(f"Direct discovery failed for MCP toolkit '{toolkit_name}': {e}", exc_info=True)
             logger.error(f"Discovery error details - URL: {connection_config.url}, Timeout: {timeout}s")
-
-            # Fallback to static mode if available and not already static
-            if isinstance(e, McpAuthorizationRequired):
-                # Authorization is required; surface upstream so the caller can prompt the user
+            
+            # For new MCP toolkits (no client), don't silently return empty - surface the error
+            # This helps users understand why tool discovery failed
+            if not client:
+                logger.warning(f"No fallback available for toolkit '{toolkit_name}' - re-raising discovery error")
                 raise
-            if client and discovery_mode != "static":
-                logger.info(f"Falling back to static discovery for toolkit '{toolkit_name}'")
-                tools = cls._create_tools_static(toolkit_name, selected_tools, timeout, client)
-            else:
-                logger.warning(f"No fallback available for toolkit '{toolkit_name}' - returning empty tools list")
+            
+            # Only fall back to static discovery for existing toolkits with a client
+            logger.info(f"Falling back to static discovery for toolkit '{toolkit_name}'")
+            tools = cls._create_tools_static(toolkit_name, selected_tools, timeout, client)
 
         # Don't add inspection tool to agent - it's only for internal use by toolkit
         # inspection_tool = cls._create_inspection_tool(
@@ -459,28 +351,34 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Discover tools and prompts from MCP server using SSE client.
-        Returns list of tool/prompt dictionaries with name, description, and inputSchema.
-        Prompts are converted to tools that can be invoked.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id) - session_id may be server-provided
         """
-        session_id = connection_config.session_id
+        initial_session_id = connection_config.session_id
         
-        if not session_id:
-            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - server may require it")
-            logger.warning(f"[MCP Session] Frontend should generate a UUID and include it with mcp_tokens")
+        if not initial_session_id:
+            logger.warning(f"[MCP Session] No session_id provided for '{toolkit_name}' - will generate one")
         
         # Run async discovery in sync context
         try:
-            all_tools = asyncio.run(
+            all_tools, server_session_id = asyncio.run(
                 cls._discover_tools_async(
                     toolkit_name=toolkit_name,
                     connection_config=connection_config,
                     timeout=timeout
                 )
             )
-            return all_tools, session_id
+            # Return tools and the session_id (server-provided or generated)
+            logger.info(f"[MCP Session] Final session_id for '{toolkit_name}': {server_session_id}")
+            return all_tools, server_session_id
+        except McpAuthorizationRequired:
+            # Re-raise auth required exceptions directly
+            logger.info(f"[MCP SSE] Authorization required for '{toolkit_name}'")
+            raise
         except Exception as e:
             logger.error(f"[MCP SSE] Discovery failed for '{toolkit_name}': {e}")
             raise
@@ -491,9 +389,12 @@ class McpToolkit(BaseToolkit):
         toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
-    ) -> List[Dict[str, Any]]:
+    ) -> tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Async implementation of tool discovery using SSE client.
+        
+        Returns:
+            Tuple of (tool_list, server_session_id)
         """
         all_tools = []
         session_id = connection_config.session_id
@@ -505,65 +406,74 @@ class McpToolkit(BaseToolkit):
             session_id = str(uuid.uuid4())
             logger.info(f"[MCP SSE] Generated temporary session_id for OAuth: {session_id}")
         
-        logger.info(f"[MCP SSE] Discovering from {connection_config.url} with session {session_id}")
+        logger.info(f"[MCP] Discovering from {connection_config.url} with session {session_id}")
         
         # Prepare headers
         headers = {}
         if connection_config.headers:
             headers.update(connection_config.headers)
         
-        # Create SSE client
-        client = McpSseClient(
+        # Create unified MCP client (auto-detects SSE vs Streamable HTTP)
+        client = McpClient(
             url=connection_config.url,
             session_id=session_id,
             headers=headers,
             timeout=timeout
         )
         
-        # Initialize MCP session
-        await client.initialize()
-        logger.info(f"[MCP SSE] Session initialized for '{toolkit_name}'")
-        
-        # Discover tools
-        tools = await client.list_tools()
-        all_tools.extend(tools)
-        logger.info(f"[MCP SSE] Discovered {len(tools)} tools from '{toolkit_name}'")
-        
-        # Discover prompts
-        try:
-            prompts = await client.list_prompts()
-            # Convert prompts to tool format
-            for prompt in prompts:
-                prompt_tool = {
-                    "name": f"prompt_{prompt.get('name', 'unnamed')}",
-                    "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "arguments": {
-                                "type": "object",
-                                "description": "Arguments for the prompt template",
-                                "properties": {
-                                    arg.get("name"): {
-                                        "type": "string",
-                                        "description": arg.get("description", ""),
-                                        "required": arg.get("required", False)
+        server_session_id = None
+        async with client:
+            # Initialize MCP session
+            await client.initialize()
+            logger.info(f"[MCP] Session initialized for '{toolkit_name}' (transport={client.detected_transport})")
+            
+            # Capture server-provided session_id (from mcp-session-id header)
+            server_session_id = client.server_session_id
+            if server_session_id:
+                logger.info(f"[MCP] Server provided session_id: {server_session_id}")
+            
+            # Discover tools
+            tools = await client.list_tools()
+            all_tools.extend(tools)
+            logger.info(f"[MCP] Discovered {len(tools)} tools from '{toolkit_name}'")
+            
+            # Discover prompts
+            try:
+                prompts = await client.list_prompts()
+                # Convert prompts to tool format
+                for prompt in prompts:
+                    prompt_tool = {
+                        "name": f"prompt_{prompt.get('name', 'unnamed')}",
+                        "description": prompt.get('description', f"Execute prompt: {prompt.get('name')}"),
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "arguments": {
+                                    "type": "object",
+                                    "description": "Arguments for the prompt template",
+                                    "properties": {
+                                        arg.get("name"): {
+                                            "type": "string",
+                                            "description": arg.get("description", ""),
+                                            "required": arg.get("required", False)
+                                        }
+                                        for arg in prompt.get("arguments", [])
                                     }
-                                    for arg in prompt.get("arguments", [])
                                 }
                             }
-                        }
-                    },
-                    "_mcp_type": "prompt",
-                    "_mcp_prompt_name": prompt.get('name')
-                }
-                all_tools.append(prompt_tool)
-            logger.info(f"[MCP SSE] Discovered {len(prompts)} prompts from '{toolkit_name}'")
-        except Exception as e:
-            logger.warning(f"[MCP SSE] Failed to discover prompts: {e}")
+                        },
+                        "_mcp_type": "prompt",
+                        "_mcp_prompt_name": prompt.get('name')
+                    }
+                    all_tools.append(prompt_tool)
+                logger.info(f"[MCP] Discovered {len(prompts)} prompts from '{toolkit_name}'")
+            except Exception as e:
+                logger.warning(f"[MCP] Failed to discover prompts: {e}")
         
-        logger.info(f"[MCP SSE] Total discovered {len(all_tools)} items from '{toolkit_name}'")
-        return all_tools
+        logger.info(f"[MCP] Total discovered {len(all_tools)} items from '{toolkit_name}'")
+        # Return tools and server-provided session_id (use server's if available, else the one we sent)
+        final_session_id = server_session_id or session_id
+        return all_tools, final_session_id
 
     @classmethod
     def _create_tool_from_dict(
@@ -577,28 +487,23 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from a tool/prompt dictionary (from direct HTTP discovery)."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_dict.get("name", "unknown"))
+            # Use original tool name directly
+            tool_name = tool_dict.get("name", "unknown")
             
             # Check if this is a prompt (converted to tool)
             is_prompt = tool_dict.get("_mcp_type") == "prompt"
             item_type = "prompt" if is_prompt else "tool"
 
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP {item_type} '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {tool_dict.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = tool_dict.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name} ({connection_config.url})"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_dict.get('name')}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             # Use McpRemoteTool for remote MCP servers (HTTP/SSE)
             return McpRemoteTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     tool_dict.get("inputSchema", {})
@@ -610,11 +515,12 @@ class McpToolkit(BaseToolkit):
                 tool_timeout_sec=timeout,
                 is_prompt=is_prompt,
                 prompt_name=tool_dict.get("_mcp_prompt_name") if is_prompt else None,
-                original_tool_name=tool_dict.get('name'),  # Store original name for MCP server invocation
-                session_id=session_id  # Pass session ID for stateful SSE servers
+                original_tool_name=tool_name,  # Store original name for MCP server invocation
+                session_id=session_id,  # Pass session ID for stateful SSE servers
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": "mcp"}
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -673,7 +579,7 @@ class McpToolkit(BaseToolkit):
             # We don't have full connection config in static mode, so create a basic one
             # The inspection tool will work as long as the server is accessible
             inspection_tool = McpInspectTool(
-                name=f"{clean_string(toolkit_name, 50)}{TOOLKIT_SPLITTER}mcp_inspect",
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url="",  # Will be populated by the client if available
                 description=f"Inspect available tools, prompts, and resources from MCP toolkit '{toolkit_name}'"
@@ -695,30 +601,26 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a BaseTool from discovered metadata."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean server name for prefixing (use tool_metadata.server instead of toolkit_name)
-            clean_prefix = clean_string(tool_metadata.server, max_length_value)
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, tool_metadata.name)
+            # Use original tool name directly
+            tool_name = tool_metadata.name
 
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {tool_metadata.description}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            description = f"{tool_metadata.description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{tool_metadata.name}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(tool_metadata.input_schema),
                 client=client,
                 server=tool_metadata.server,
-                tool_timeout_sec=timeout
+                tool_timeout_sec=timeout,
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name}
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from server '{tool_metadata.server}': {e}")
             return None
 
     @classmethod
@@ -731,33 +633,29 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create a single MCP tool."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            # Optimize tool name to fit within 64 character limit
-            full_tool_name = optimize_tool_name(clean_prefix, available_tool["name"])
+            # Use original tool name directly
+            tool_name = available_tool["name"]
 
-            # Build description and ensure it doesn't exceed 1000 characters
-            description = f"MCP tool '{available_tool['name']}' from toolkit '{toolkit_name}': {available_tool.get('description', '')}"
+            # Build description with toolkit context and ensure it doesn't exceed 1000 characters
+            base_description = available_tool.get('description', '')
+            description = f"{base_description}\nToolkit: {toolkit_name}"
             if len(description) > 1000:
                 description = description[:997] + "..."
-                logger.debug(f"Trimmed description for tool '{available_tool['name']}' from {len(description)} to 1000 chars")
+                logger.debug(f"Trimmed description for tool '{tool_name}' to 1000 chars")
 
             return McpServerTool(
-                name=full_tool_name,
+                name=tool_name,
                 description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     available_tool.get("inputSchema", {})
                 ),
                 client=client,
                 server=toolkit_name,
-                tool_timeout_sec=timeout
+                tool_timeout_sec=timeout,
+                metadata={"toolkit_name": toolkit_name, "toolkit_type": name}
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{available_tool.get('name')}' from toolkit '{toolkit_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_name}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
@@ -768,16 +666,8 @@ class McpToolkit(BaseToolkit):
     ) -> Optional[BaseTool]:
         """Create the inspection tool for the MCP toolkit."""
         try:
-            # Store toolkit_max_length in local variable to avoid contextual access issues
-            max_length_value = cls.toolkit_max_length
-
-            # Clean toolkit name for prefixing
-            clean_prefix = clean_string(toolkit_name, max_length_value)
-
-            full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}mcp_inspect'
-
             return McpInspectTool(
-                name=full_tool_name,
+                name="mcp_inspect",
                 server_name=toolkit_name,
                 server_url=connection_config.url,
                 server_headers=connection_config.headers,
@@ -858,8 +748,6 @@ def get_tools(tool_config: dict, alita_client, llm=None, memory_store=None) -> L
         url=url,
         headers=headers,
         timeout=safe_int(settings.get('timeout'), 60),
-        discovery_mode=settings.get('discovery_mode', 'dynamic'),
-        discovery_interval=safe_int(settings.get('discovery_interval'), 300),
         selected_tools=settings.get('selected_tools', []),
         enable_caching=settings.get('enable_caching', True),
         cache_ttl=safe_int(settings.get('cache_ttl'), 300),