alita-sdk 0.3.430__py3-none-any.whl → 0.3.432__py3-none-any.whl

alita_sdk/runtime/toolkits/mcp.py

@@ -28,7 +28,7 @@ class McpToolkit(BaseToolkit):
     """
 
     tools: List[BaseTool] = []
-    server_name: Optional[str] = None
+    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
@@ -63,15 +63,6 @@ class McpToolkit(BaseToolkit):
 
         return create_model(
             'mcp',
-            server_name=(
-                str,
-                Field(
-                    description="MCP server name/identifier",
-                    json_schema_extra={
-                        'tooltip': 'Unique identifier for this MCP server'
-                    }
-                )
-            ),
             url=(
                 str,
                 Field(
@@ -160,7 +151,6 @@ class McpToolkit(BaseToolkit):
     @classmethod
     def get_toolkit(
         cls,
-        server_name: str,
         url: str,
         headers: Optional[Dict[str, str]] = None,
         timeout: int = 60,
@@ -169,7 +159,7 @@ class McpToolkit(BaseToolkit):
         selected_tools: List[str] = None,
         enable_caching: bool = True,
         cache_ttl: int = 300,
-        toolkit_name: Optional[str] = None,
+        toolkit_name: str = None,
         client = None,
         **kwargs
     ) -> 'McpToolkit':
@@ -183,7 +173,6 @@ class McpToolkit(BaseToolkit):
         4. Return all tools via get_tools() method
 
         Args:
-            server_name: MCP server name/identifier
             url: MCP server HTTP URL
             headers: HTTP headers for authentication
             timeout: Request timeout in seconds
@@ -192,7 +181,7 @@ class McpToolkit(BaseToolkit):
             selected_tools: List of specific tools to enable (empty = all tools)
             enable_caching: Whether to enable caching
             cache_ttl: Cache TTL in seconds
-            toolkit_name: Optional name prefix for tools
+            toolkit_name: Toolkit name/identifier and prefix for tools
             client: Alita client for MCP communication
             **kwargs: Additional configuration options
 
@@ -201,8 +190,11 @@ class McpToolkit(BaseToolkit):
         """
         if selected_tools is None:
             selected_tools = []
+        
+        if not toolkit_name:
+            raise ValueError("toolkit_name is required")
 
-        logger.info(f"Creating MCP toolkit for server: {server_name}")
+        logger.info(f"Creating MCP toolkit: {toolkit_name}")
 
         # Parse headers if they're provided as a JSON string
         parsed_headers = headers
@@ -232,15 +224,14 @@ class McpToolkit(BaseToolkit):
             raise ValueError(f"Invalid MCP connection configuration: {e}")
 
         # Create toolkit instance
-        toolkit = cls(server_name=server_name)
+        toolkit = cls(toolkit_name=toolkit_name)
 
         # Generate tools from the MCP server
         toolkit.tools = cls._create_tools_from_server(
-            server_name=server_name,
+            toolkit_name=toolkit_name,
             connection_config=connection_config,
             timeout=timeout,
             selected_tools=selected_tools,
-            toolkit_name=toolkit_name,
             client=client,
             discovery_mode=discovery_mode
         )
@@ -250,11 +241,10 @@ class McpToolkit(BaseToolkit):
     @classmethod
     def _create_tools_from_server(
         cls,
-        server_name: str,
+        toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int,
         selected_tools: List[str],
-        toolkit_name: Optional[str],
         client,
         discovery_mode: str = "dynamic"
     ) -> List[BaseTool]:
@@ -265,11 +255,11 @@ class McpToolkit(BaseToolkit):
 
         # First, try direct HTTP discovery since we have valid connection config
         try:
-            logger.info(f"Discovering tools from MCP server '{server_name}' at {connection_config.url}")
+            logger.info(f"Discovering tools from MCP toolkit '{toolkit_name}' at {connection_config.url}")
 
             # Use synchronous HTTP discovery for toolkit initialization
             tool_metadata_list = cls._discover_tools_sync(
-                server_name=server_name,
+                toolkit_name=toolkit_name,
                 connection_config=connection_config,
                 timeout=timeout
             )
@@ -286,8 +276,7 @@ class McpToolkit(BaseToolkit):
             for tool_metadata in tool_metadata_list:
                 server_tool = cls._create_tool_from_dict(
                     tool_dict=tool_metadata,
-                    server_name=server_name,
-                    toolkit_name=toolkit_name or server_name,
+                    toolkit_name=toolkit_name,
                     timeout=timeout,
                     client=client
                 )
@@ -295,34 +284,33 @@ class McpToolkit(BaseToolkit):
                 if server_tool:
                     tools.append(server_tool)
 
-            logger.info(f"Successfully created {len(tools)} MCP tools from server '{server_name}' via direct discovery")
+            logger.info(f"Successfully created {len(tools)} MCP tools from toolkit '{toolkit_name}' via direct discovery")
 
         except Exception as e:
-            logger.error(f"Direct discovery failed for MCP server '{server_name}': {e}")
+            logger.error(f"Direct discovery failed for MCP toolkit '{toolkit_name}': {e}")
 
             # Fallback to static mode if available and not already static
             if client and discovery_mode != "static":
-                logger.info(f"Falling back to static discovery for server '{server_name}'")
-                tools = cls._create_tools_static(server_name, selected_tools, toolkit_name, timeout, client)
+                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 server '{server_name}' - returning empty tools list")
+                logger.warning(f"No fallback available for toolkit '{toolkit_name}' - returning empty tools list")
 
         # Always add the inspection tool (not subject to selected_tools filtering)
         inspection_tool = cls._create_inspection_tool(
-            server_name=server_name,
-            connection_config=connection_config,
-            toolkit_name=toolkit_name or server_name
+            toolkit_name=toolkit_name,
+            connection_config=connection_config
         )
         if inspection_tool:
             tools.append(inspection_tool)
-            logger.info(f"Added MCP inspection tool for server '{server_name}'")
+            logger.info(f"Added MCP inspection tool for toolkit '{toolkit_name}'")
 
         return tools
 
     @classmethod
     def _discover_tools_sync(
         cls,
-        server_name: str,
+        toolkit_name: str,
         connection_config: McpConnectionConfig,
         timeout: int
     ) -> List[Dict[str, Any]]:
@@ -340,7 +328,10 @@ class McpToolkit(BaseToolkit):
             "params": {}
         }
 
-        headers = {"Content-Type": "application/json"}
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream"
+        }
         if connection_config.headers:
             headers.update(connection_config.headers)
 
@@ -355,26 +346,33 @@ class McpToolkit(BaseToolkit):
             if response.status_code != 200:
                 raise Exception(f"HTTP {response.status_code}: {response.text}")
 
-            data = response.json()
+            # Check if response is actually JSON
+            content_type = response.headers.get('Content-Type', '')
+            if 'application/json' not in content_type:
+                raise Exception(f"Expected JSON response but got Content-Type: {content_type}. Response: {response.text[:200]}")
+
+            try:
+                data = response.json()
+            except ValueError as json_err:
+                raise Exception(f"Invalid JSON response: {json_err}. Response text: {response.text[:200]}")
 
             if "error" in data:
                 raise Exception(f"MCP Error: {data['error']}")
 
             # Parse MCP response and extract tools
             tools_data = data.get("result", {}).get("tools", [])
-            logger.info(f"Discovered {len(tools_data)} tools from MCP server '{server_name}'")
+            logger.info(f"Discovered {len(tools_data)} tools from MCP toolkit '{toolkit_name}'")
 
             return tools_data
 
         except Exception as e:
-            logger.error(f"Failed to discover tools from MCP server '{server_name}': {e}")
+            logger.error(f"Failed to discover tools from MCP toolkit '{toolkit_name}': {e}")
             raise
 
     @classmethod
     def _create_tool_from_dict(
         cls,
         tool_dict: Dict[str, Any],
-        server_name: str,
         toolkit_name: str,
         timeout: int,
         client
@@ -384,31 +382,30 @@ class McpToolkit(BaseToolkit):
             # 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 server_name instead of toolkit_name)
-            clean_prefix = clean_string(server_name, max_length_value)
+            # Clean toolkit name for prefixing
+            clean_prefix = clean_string(toolkit_name, max_length_value)
 
             full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}{tool_dict.get("name", "unknown")}'
 
             return McpServerTool(
                 name=full_tool_name,
-                description=f"MCP tool '{tool_dict.get('name')}' from server '{server_name}': {tool_dict.get('description', '')}",
+                description=f"MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {tool_dict.get('description', '')}",
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     tool_dict.get("inputSchema", {})
                 ),
                 client=client,
-                server=server_name,
+                server=toolkit_name,
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from server '{server_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
     def _create_tools_static(
         cls,
-        server_name: str,
+        toolkit_name: str,
         selected_tools: List[str],
-        toolkit_name: Optional[str],
         timeout: int,
         client
     ) -> List[BaseTool]:
@@ -421,10 +418,10 @@ class McpToolkit(BaseToolkit):
 
         try:
             all_toolkits = client.get_mcp_toolkits()
-            server_toolkit = next((tk for tk in all_toolkits if tk.get('name') == server_name), None)
+            server_toolkit = next((tk for tk in all_toolkits if tk.get('name') == toolkit_name), None)
 
             if not server_toolkit:
-                logger.warning(f"MCP server '{server_name}' not found in available toolkits")
+                logger.warning(f"MCP toolkit '{toolkit_name}' not found in available toolkits")
                 return tools
 
             # Extract tools from the toolkit
@@ -440,8 +437,7 @@ class McpToolkit(BaseToolkit):
 
                 # Create the tool
                 server_tool = cls._create_single_tool(
-                    server_name=server_name,
-                    toolkit_name=toolkit_name or server_name,
+                    toolkit_name=toolkit_name,
                     available_tool=available_tool,
                     timeout=timeout,
                     client=client
@@ -450,7 +446,7 @@ class McpToolkit(BaseToolkit):
                 if server_tool:
                     tools.append(server_tool)
 
-            logger.info(f"Successfully created {len(tools)} MCP tools from server '{server_name}' using static mode")
+            logger.info(f"Successfully created {len(tools)} MCP tools from toolkit '{toolkit_name}' using static mode")
 
         except Exception as e:
             logger.error(f"Error in static tool creation: {e}")
@@ -461,15 +457,15 @@ 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(server_name, 50)}{TOOLKIT_SPLITTER}mcp_inspect",
-                server_name=server_name,
+                name=f"{clean_string(toolkit_name, 50)}{TOOLKIT_SPLITTER}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 server '{server_name}'"
+                description=f"Inspect available tools, prompts, and resources from MCP toolkit '{toolkit_name}'"
             )
             tools.append(inspection_tool)
-            logger.info(f"Added MCP inspection tool for server '{server_name}' (static mode)")
+            logger.info(f"Added MCP inspection tool for toolkit '{toolkit_name}' (static mode)")
         except Exception as e:
-            logger.warning(f"Failed to create inspection tool for {server_name}: {e}")
+            logger.warning(f"Failed to create inspection tool for {toolkit_name}: {e}")
 
         return tools
 
@@ -505,7 +501,6 @@ class McpToolkit(BaseToolkit):
     @classmethod
     def _create_single_tool(
         cls,
-        server_name: str,
         toolkit_name: str,
         available_tool: Dict[str, Any],
         timeout: int,
@@ -516,51 +511,50 @@ class McpToolkit(BaseToolkit):
             # 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 server_name instead of toolkit_name)
-            clean_prefix = clean_string(server_name, max_length_value)
+            # Clean toolkit name for prefixing
+            clean_prefix = clean_string(toolkit_name, max_length_value)
 
             full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}{available_tool["name"]}'
 
             return McpServerTool(
                 name=full_tool_name,
-                description=f"MCP tool '{available_tool['name']}' from server '{server_name}': {available_tool.get('description', '')}",
+                description=f"MCP tool '{available_tool['name']}' from toolkit '{toolkit_name}': {available_tool.get('description', '')}",
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     available_tool.get("inputSchema", {})
                 ),
                 client=client,
-                server=server_name,
+                server=toolkit_name,
                 tool_timeout_sec=timeout
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP tool '{available_tool.get('name')}' from server '{server_name}': {e}")
+            logger.error(f"Failed to create MCP tool '{available_tool.get('name')}' from toolkit '{toolkit_name}': {e}")
             return None
 
     @classmethod
     def _create_inspection_tool(
         cls,
-        server_name: str,
-        connection_config: McpConnectionConfig,
-        toolkit_name: str
+        toolkit_name: str,
+        connection_config: McpConnectionConfig
     ) -> Optional[BaseTool]:
-        """Create the inspection tool for the MCP server."""
+        """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 server name for prefixing (use server_name instead of toolkit_name)
-            clean_prefix = clean_string(server_name, max_length_value)
+            # 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,
-                server_name=server_name,
+                server_name=toolkit_name,
                 server_url=connection_config.url,
                 server_headers=connection_config.headers,
-                description=f"Inspect available tools, prompts, and resources from MCP server '{server_name}'"
+                description=f"Inspect available tools, prompts, and resources from MCP toolkit '{toolkit_name}'"
             )
         except Exception as e:
-            logger.error(f"Failed to create MCP inspection tool for server '{server_name}': {e}")
+            logger.error(f"Failed to create MCP inspection tool for toolkit '{toolkit_name}': {e}")
             return None
 
     def get_tools(self) -> List[BaseTool]:
@@ -568,31 +562,31 @@ class McpToolkit(BaseToolkit):
         return self.tools
 
     async def refresh_tools(self):
-        """Manually refresh tools from the MCP server."""
-        if not self.server_name:
-            logger.warning("Cannot refresh tools: server_name not set")
+        """Manually refresh tools from the MCP toolkit."""
+        if not self.toolkit_name:
+            logger.warning("Cannot refresh tools: toolkit_name not set")
             return
 
         try:
             from ..clients.mcp_manager import get_mcp_manager
             manager = get_mcp_manager()
-            await manager.refresh_server(self.server_name)
-            logger.info(f"Successfully refreshed tools for server {self.server_name}")
+            await manager.refresh_server(self.toolkit_name)
+            logger.info(f"Successfully refreshed tools for toolkit {self.toolkit_name}")
         except Exception as e:
-            logger.error(f"Failed to refresh tools for server {self.server_name}: {e}")
+            logger.error(f"Failed to refresh tools for toolkit {self.toolkit_name}: {e}")
 
     async def get_server_health(self) -> Dict[str, Any]:
-        """Get health status of the configured MCP server."""
-        if not self.server_name:
+        """Get health status of the configured MCP toolkit."""
+        if not self.toolkit_name:
             return {"status": "not_configured"}
 
         try:
             from ..clients.mcp_manager import get_mcp_manager
             manager = get_mcp_manager()
-            health_info = await manager.get_server_health(self.server_name)
+            health_info = await manager.get_server_health(self.toolkit_name)
             return health_info
         except Exception as e:
-            logger.error(f"Failed to get server health for {self.server_name}: {e}")
+            logger.error(f"Failed to get server health for {self.toolkit_name}: {e}")
             return {"status": "error", "error": str(e)}
 
 
@@ -611,14 +605,14 @@ def get_tools(tool_config: dict, alita_client, llm=None, memory_store=None) -> L
         List of configured MCP tools
     """
     settings = tool_config.get('settings', {})
+    toolkit_name = tool_config.get('toolkit_name')
 
     # Extract required fields
-    server_name = settings.get('server_name')
     url = settings.get('url')
     headers = settings.get('headers')
 
-    if not server_name:
-        logger.error("MCP toolkit configuration missing required 'server_name'")
+    if not toolkit_name:
+        logger.error("MCP toolkit configuration missing required 'toolkit_name'")
         return []
 
     if not url:
@@ -626,16 +620,15 @@ def get_tools(tool_config: dict, alita_client, llm=None, memory_store=None) -> L
         return []
 
     return McpToolkit.get_toolkit(
-        server_name=server_name,
         url=url,
         headers=headers,
         timeout=settings.get('timeout', 60),
-        discovery_mode=settings.get('discovery_mode', 'hybrid'),
+        discovery_mode=settings.get('discovery_mode', 'dynamic'),
         discovery_interval=settings.get('discovery_interval', 300),
         selected_tools=settings.get('selected_tools', []),
         enable_caching=settings.get('enable_caching', True),
         cache_ttl=settings.get('cache_ttl', 300),
-        toolkit_name=tool_config.get('toolkit_name'),
+        toolkit_name=toolkit_name,
         client=alita_client
     ).get_tools()
 
@@ -653,11 +646,11 @@ async def stop_global_discovery():
     await shutdown_discovery_service()
 
 
-async def register_mcp_server_for_discovery(server_name: str, connection_config):
+async def register_mcp_server_for_discovery(toolkit_name: str, connection_config):
     """Register an MCP server for global discovery."""
     from ..clients.mcp_discovery import get_discovery_service
     service = get_discovery_service()
-    await service.register_server(server_name, connection_config)
+    await service.register_server(toolkit_name, connection_config)
 
 
 def get_all_discovered_servers():

alita_sdk/runtime/toolkits/tools.py

@@ -128,7 +128,8 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
     tools += community_tools(tools_list, alita_client, llm)
     # Add alita tools
     tools += alita_tools(tools_list, alita_client, llm, memory_store)
-    # Add MCP tools
+    # Add MCP tools registered via alita-mcp CLI (static registry)
+    # Note: Tools with type='mcp' are already handled in main loop above
     tools += _mcp_tools(tools_list, alita_client)
     
     # Sanitize tool names to meet OpenAI's function naming requirements
@@ -183,6 +184,10 @@ def _sanitize_tool_names(tools: list) -> list:
 
 
 def _mcp_tools(tools_list, alita):
+    """
+    Handle MCP tools registered via alita-mcp CLI (static registry).
+    Skips tools with type='mcp' as those are handled by dynamic discovery.
+    """
     try:
         all_available_toolkits = alita.get_mcp_toolkits()
         toolkit_lookup = {tk["name"]: tk for tk in all_available_toolkits}
@@ -190,6 +195,11 @@ def _mcp_tools(tools_list, alita):
         #
         for selected_toolkit in tools_list:
             server_toolkit_name = selected_toolkit['type']
+            
+            # Skip tools with type='mcp' - they're handled by dynamic discovery
+            if server_toolkit_name == 'mcp':
+                continue
+            
             toolkit_conf = toolkit_lookup.get(server_toolkit_name)
             #
             if not toolkit_conf:

alita_sdk/runtime/tools/mcp_inspect_tool.py

@@ -65,21 +65,17 @@ class McpInspectTool(BaseTool):
     def _run(self, resource_type: str = "all") -> str:
         """Inspect the MCP server for available resources."""
         try:
-            # Run the async inspection
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                # If we're in an async context, we need to create a new event loop
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(self._run_async_inspection, resource_type)
-                    return future.result(timeout=self.timeout)
-            else:
-                return loop.run_until_complete(self._run_async_inspection(resource_type))
+            # Always create a new event loop for sync context
+            # This avoids issues with existing event loops in threads
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(self._run_in_new_loop, resource_type)
+                return future.result(timeout=self.timeout)
         except Exception as e:
             logger.error(f"Error inspecting MCP server '{self.server_name}': {e}")
             return f"Error inspecting MCP server: {e}"
 
-    def _run_async_inspection(self, resource_type: str) -> str:
+    def _run_in_new_loop(self, resource_type: str) -> str:
         """Run the async inspection in a new event loop."""
         return asyncio.run(self._inspect_server(resource_type))
 
@@ -132,7 +128,11 @@ class McpInspectTool(BaseTool):
             "params": {}
         }
 
-        headers = {"Content-Type": "application/json", **self.server_headers}
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            **self.server_headers
+        }
 
         async with session.post(self.server_url, json=request, headers=headers) as response:
             if response.status != 200:
@@ -154,7 +154,11 @@ class McpInspectTool(BaseTool):
             "params": {}
         }
 
-        headers = {"Content-Type": "application/json", **self.server_headers}
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            **self.server_headers
+        }
 
         async with session.post(self.server_url, json=request, headers=headers) as response:
             if response.status != 200:
@@ -176,7 +180,11 @@ class McpInspectTool(BaseTool):
             "params": {}
         }
 
-        headers = {"Content-Type": "application/json", **self.server_headers}
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            **self.server_headers
+        }
 
         async with session.post(self.server_url, json=request, headers=headers) as response:
             if response.status != 200:

{alita_sdk-0.3.430.dist-info → alita_sdk-0.3.432.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.430
+Version: 0.3.432
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.430.dist-info → alita_sdk-0.3.432.dist-info}/RECORD

@@ -103,10 +103,10 @@ alita_sdk/runtime/toolkits/application.py,sha256=HHAKgwKOckxc7EQG-AV7rz4POOzQJKF
 alita_sdk/runtime/toolkits/artifact.py,sha256=YChNCX4QhVpaQG7Jk4TS-Wl0Aruc4slQ2K21zh9nNO0,3176
 alita_sdk/runtime/toolkits/configurations.py,sha256=kIDAlnryPQfbZyFxV-9SzN2-Vefzx06TX1BBdIIpN90,141
 alita_sdk/runtime/toolkits/datasource.py,sha256=qk78OdPoReYPCWwahfkKLbKc4pfsu-061oXRryFLP6I,2498
-alita_sdk/runtime/toolkits/mcp.py,sha256=KLiNWiKH95r9OAmfleVFCe8MwYNawF_FANgNz_-Ta5k,25936
+alita_sdk/runtime/toolkits/mcp.py,sha256=lh1REOY680Q3yP4DfmzFLllmJIZy1IM90NZd1CwLrDY,25730
 alita_sdk/runtime/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/runtime/toolkits/subgraph.py,sha256=wwUK8JjPXkGzyVZ3tAukmvST6eGbqx_U11rpnmbrvtg,2105
-alita_sdk/runtime/toolkits/tools.py,sha256=By1G9gPlp-ZgOriWJm3b77A3ukb3Cs-SZ8dpNs0JaZw,10490
+alita_sdk/runtime/toolkits/tools.py,sha256=YCTjrTJuwj2V2C8ZQqXhFvUbVr7NQcUHZlCQLLvoeGA,10946
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlodEDYEzUcBRbAA,2901
 alita_sdk/runtime/tools/__init__.py,sha256=Fx7iHqkzA90-KfjdcUUzMUI_7kDarjuTsSpSzOW2pN0,568
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
@@ -121,7 +121,7 @@ alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1M
 alita_sdk/runtime/tools/llm.py,sha256=iRG_wU4T01LRsjEMPZe5Uah7LiMqDc-vspwkMuQtltk,16136
 alita_sdk/runtime/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/runtime/tools/loop_output.py,sha256=U4hO9PCQgWlXwOq6jdmCGbegtAxGAPXObSxZQ3z38uk,8069
-alita_sdk/runtime/tools/mcp_inspect_tool.py,sha256=EW81_XlXX5C4lxT-gHMehHcZhtbuG-8DQzo0NuDkCA4,10160
+alita_sdk/runtime/tools/mcp_inspect_tool.py,sha256=wgnv0z9MvB-PWriGKHHpY2IMxjBkd7Cbz4kvwGp9aq8,10243
 alita_sdk/runtime/tools/mcp_server_tool.py,sha256=y6y0j3JeUajNatpsLVJfP0JEknhlRcDRJ0PlJ3Ch8fA,6626
 alita_sdk/runtime/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8QwB0UwpsWCYruXU,11692
 alita_sdk/runtime/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
@@ -358,8 +358,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.430.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.430.dist-info/METADATA,sha256=FRH-k7SYr8J7tTXEOK09ofk2t2dWqUMpJgzjHVZjhmo,19071
-alita_sdk-0.3.430.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.430.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.430.dist-info/RECORD,,
+alita_sdk-0.3.432.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.432.dist-info/METADATA,sha256=5ta9EQvl3qdFIGaqQCAQLW9VWo7PYJRHdNmffxCbdK8,19071
+alita_sdk-0.3.432.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.432.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.432.dist-info/RECORD,,