alita-sdk 0.3.435__py3-none-any.whl → 0.3.437__py3-none-any.whl

alita_sdk/runtime/toolkits/mcp.py

@@ -5,6 +5,7 @@ Following MCP specification: https://modelcontextprotocol.io/specification/2025-
 """
 
 import logging
+import re
 import requests
 from typing import List, Optional, Any, Dict, Literal, ClassVar
 
@@ -12,6 +13,7 @@ from langchain_core.tools import BaseToolkit, BaseTool
 from pydantic import BaseModel, ConfigDict, Field
 
 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
@@ -20,6 +22,119 @@ logger = logging.getLogger(__name__)
 
 name = "mcp"
 
+def safe_int(value, default):
+    """Convert value to int, handling string inputs."""
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        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):
     """
@@ -277,6 +392,7 @@ class McpToolkit(BaseToolkit):
                 server_tool = cls._create_tool_from_dict(
                     tool_dict=tool_metadata,
                     toolkit_name=toolkit_name,
+                    connection_config=connection_config,
                     timeout=timeout,
                     client=client
                 )
@@ -480,6 +596,7 @@ class McpToolkit(BaseToolkit):
         cls,
         tool_dict: Dict[str, Any],
         toolkit_name: str,
+        connection_config: McpConnectionConfig,
         timeout: int,
         client
     ) -> Optional[BaseTool]:
@@ -491,23 +608,34 @@ class McpToolkit(BaseToolkit):
             # 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")}'
+            # Optimize tool name to fit within 64 character limit
+            full_tool_name = optimize_tool_name(clean_prefix, 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"
 
-            return McpServerTool(
+            # 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', '')}"
+            if len(description) > 1000:
+                description = description[:997] + "..."
+                logger.debug(f"Trimmed description for tool '{tool_dict.get('name')}' from {len(description)} to 1000 chars")
+
+            # Use McpRemoteTool for remote MCP servers (HTTP/SSE)
+            return McpRemoteTool(
                 name=full_tool_name,
-                description=f"MCP {item_type} '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {tool_dict.get('description', '')}",
+                description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     tool_dict.get("inputSchema", {})
                 ),
                 client=client,
                 server=toolkit_name,
+                server_url=connection_config.url,
+                server_headers=connection_config.headers,
                 tool_timeout_sec=timeout,
                 is_prompt=is_prompt,
-                prompt_name=tool_dict.get("_mcp_prompt_name") if is_prompt else None
+                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
             )
         except Exception as e:
             logger.error(f"Failed to create MCP tool '{tool_dict.get('name')}' from toolkit '{toolkit_name}': {e}")
@@ -596,11 +724,18 @@ class McpToolkit(BaseToolkit):
 
             # Clean server name for prefixing (use tool_metadata.server instead of toolkit_name)
             clean_prefix = clean_string(tool_metadata.server, max_length_value)
-            full_tool_name = f'{clean_prefix}{TOOLKIT_SPLITTER}{tool_metadata.name}'
+            # Optimize tool name to fit within 64 character limit
+            full_tool_name = optimize_tool_name(clean_prefix, 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}"
+            if len(description) > 1000:
+                description = description[:997] + "..."
+                logger.debug(f"Trimmed description for tool '{tool_metadata.name}' from {len(description)} to 1000 chars")
 
             return McpServerTool(
                 name=full_tool_name,
-                description=f"MCP tool '{tool_metadata.name}' from server '{tool_metadata.server}': {tool_metadata.description}",
+                description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(tool_metadata.input_schema),
                 client=client,
                 server=tool_metadata.server,
@@ -626,11 +761,18 @@ class McpToolkit(BaseToolkit):
             # 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"]}'
+            # Optimize tool name to fit within 64 character limit
+            full_tool_name = optimize_tool_name(clean_prefix, 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', '')}"
+            if len(description) > 1000:
+                description = description[:997] + "..."
+                logger.debug(f"Trimmed description for tool '{available_tool['name']}' from {len(description)} to 1000 chars")
 
             return McpServerTool(
                 name=full_tool_name,
-                description=f"MCP tool '{available_tool['name']}' from toolkit '{toolkit_name}': {available_tool.get('description', '')}",
+                description=description,
                 args_schema=McpServerTool.create_pydantic_model_from_schema(
                     available_tool.get("inputSchema", {})
                 ),
@@ -736,16 +878,6 @@ def get_tools(tool_config: dict, alita_client, llm=None, memory_store=None) -> L
         return []
 
     # Type conversion for numeric settings that may come as strings from config
-    def safe_int(value, default):
-        """Convert value to int, handling string inputs."""
-        if value is None:
-            return default
-        try:
-            return int(value)
-        except (ValueError, TypeError):
-            logger.warning(f"Invalid integer value '{value}', using default {default}")
-            return default
-
     return McpToolkit.get_toolkit(
         url=url,
         headers=headers,

alita_sdk/runtime/tools/mcp_remote_tool.py

@@ -0,0 +1,177 @@
+"""
+MCP Remote Tool for direct HTTP/SSE invocation.
+This tool is used for remote MCP servers accessed via HTTP/SSE.
+"""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, Optional
+
+from .mcp_server_tool import McpServerTool
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+class McpRemoteTool(McpServerTool):
+    """
+    Tool for invoking remote MCP server tools via HTTP/SSE.
+    Extends McpServerTool and overrides _run to use direct HTTP calls instead of client.mcp_tool_call.
+    """
+    
+    # Remote MCP connection details
+    server_url: str = Field(..., description="URL of the remote MCP server")
+    server_headers: Optional[Dict[str, str]] = Field(default=None, description="HTTP headers for authentication")
+    original_tool_name: Optional[str] = Field(default=None, description="Original tool name from MCP server (before optimization)")
+    is_prompt: bool = False  # Flag to indicate if this is a prompt tool
+    prompt_name: Optional[str] = None  # Original prompt name if this is a prompt
+    
+    def __getstate__(self):
+        """Custom serialization for pickle compatibility."""
+        state = super().__getstate__()
+        # Ensure headers are serializable
+        if 'server_headers' in state and state['server_headers'] is not None:
+            state['server_headers'] = dict(state['server_headers'])
+        return state
+
+    def _run(self, *args, **kwargs):
+        """
+        Execute the MCP tool via direct HTTP/SSE call to the remote server.
+        Overrides the parent method to avoid using client.mcp_tool_call.
+        """
+        try:
+            # Always create a new event loop for sync context
+            with ThreadPoolExecutor() as executor:
+                future = executor.submit(self._run_in_new_loop, kwargs)
+                return future.result(timeout=self.tool_timeout_sec)
+        except Exception as e:
+            logger.error(f"Error executing remote MCP tool '{self.name}': {e}")
+            return f"Error executing tool: {e}"
+
+    def _run_in_new_loop(self, kwargs: Dict[str, Any]) -> str:
+        """Run the async tool invocation in a new event loop."""
+        return asyncio.run(self._execute_remote_tool(kwargs))
+
+    async def _execute_remote_tool(self, kwargs: Dict[str, Any]) -> str:
+        """Execute the actual remote MCP tool call."""
+        import aiohttp
+        from ...tools.utils import TOOLKIT_SPLITTER
+        
+        # Use the original tool name from discovery for MCP server invocation
+        # The MCP server doesn't know about our optimized names
+        tool_name_for_server = self.original_tool_name
+        
+        # Fallback: extract from optimized name if original not stored (backwards compatibility)
+        if not tool_name_for_server:
+            tool_name_for_server = self.name.rsplit(TOOLKIT_SPLITTER, 1)[-1] if TOOLKIT_SPLITTER in self.name else self.name
+            logger.warning(f"original_tool_name not set for '{self.name}', using extracted name: {tool_name_for_server}")
+        
+        # Build the MCP request based on whether this is a prompt or tool
+        if self.is_prompt:
+            # For prompts, use prompts/get endpoint
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "id": f"prompt_get_{int(time.time())}_{uuid.uuid4().hex[:8]}",
+                "method": "prompts/get",
+                "params": {
+                    "name": self.prompt_name or tool_name_for_server.replace("prompt_", ""),
+                    "arguments": kwargs.get("arguments", kwargs)
+                }
+            }
+        else:
+            # For regular tools, use tools/call endpoint
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "id": f"tool_call_{int(time.time())}_{uuid.uuid4().hex[:8]}",
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name_for_server,
+                    "arguments": kwargs
+                }
+            }
+
+        # Set up headers
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream"
+        }
+        if self.server_headers:
+            headers.update(self.server_headers)
+
+        # Execute the HTTP request
+        timeout = aiohttp.ClientTimeout(total=self.tool_timeout_sec)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            try:
+                logger.debug(f"Calling remote MCP tool '{tool_name_for_server}' (optimized name: '{self.name}') at {self.server_url}")
+                logger.debug(f"Request: {json.dumps(mcp_request, indent=2)}")
+                
+                async with session.post(self.server_url, json=mcp_request, headers=headers) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP {response.status}: {error_text}")
+
+                    # Handle both JSON and SSE responses
+                    content_type = response.headers.get('Content-Type', '')
+                    if 'text/event-stream' in content_type:
+                        # Parse SSE format
+                        text = await response.text()
+                        data = self._parse_sse(text)
+                    else:
+                        # Parse regular JSON
+                        data = await response.json()
+
+                    logger.debug(f"Response: {json.dumps(data, indent=2)}")
+
+                    # Check for MCP error
+                    if "error" in data:
+                        error = data["error"]
+                        error_msg = error.get("message", str(error))
+                        raise Exception(f"MCP Error: {error_msg}")
+
+                    # Extract result
+                    result = data.get("result", {})
+                    
+                    # Format the result based on content type
+                    if isinstance(result, dict):
+                        # Check for content array (common in MCP responses)
+                        if "content" in result:
+                            content_items = result["content"]
+                            if isinstance(content_items, list):
+                                # Extract text from content items
+                                text_parts = []
+                                for item in content_items:
+                                    if isinstance(item, dict):
+                                        if item.get("type") == "text" and "text" in item:
+                                            text_parts.append(item["text"])
+                                        elif "text" in item:
+                                            text_parts.append(item["text"])
+                                        else:
+                                            text_parts.append(json.dumps(item))
+                                    else:
+                                        text_parts.append(str(item))
+                                return "\n".join(text_parts)
+                        
+                        # Return formatted JSON if no content field
+                        return json.dumps(result, indent=2)
+                    
+                    # Return as string for other types
+                    return str(result)
+
+            except asyncio.TimeoutError:
+                raise Exception(f"Tool execution timed out after {self.tool_timeout_sec}s")
+            except Exception as e:
+                logger.error(f"Error calling remote MCP tool '{tool_name_for_server}': {e}", exc_info=True)
+                raise
+
+    def _parse_sse(self, text: str) -> Dict[str, Any]:
+        """Parse Server-Sent Events (SSE) format response."""
+        for line in text.split('\n'):
+            line = line.strip()
+            if line.startswith('data:'):
+                json_str = line[5:].strip()
+                return json.loads(json_str)
+        raise ValueError("No data found in SSE response")

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -15,63 +15,12 @@ class McpServerTool(BaseTool):
     description: str
     args_schema: Optional[Type[BaseModel]] = None
     return_type: str = "str"
-    client: Any = Field(default=None, exclude=True)  # Exclude from serialization
+    client: Any
     server: str
     tool_timeout_sec: int = 60
-    is_prompt: bool = False  # Flag to indicate if this is a prompt tool
-    prompt_name: Optional[str] = None  # Original prompt name if this is a prompt
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def __getstate__(self):
-        """Custom serialization to exclude non-serializable objects."""
-        state = self.__dict__.copy()
-        # Remove the client since it contains threading objects that can't be pickled
-        state['client'] = None
-        # Store args_schema as a schema dict instead of the dynamic class
-        if hasattr(self, 'args_schema') and self.args_schema is not None:
-            # Convert the Pydantic model back to schema dict for pickling
-            try:
-                state['_args_schema_dict'] = self.args_schema.model_json_schema()
-                state['args_schema'] = None
-            except Exception as e:
-                logger.warning(f"Failed to serialize args_schema: {e}")
-                # If conversion fails, just remove it
-                state['args_schema'] = None
-                state['_args_schema_dict'] = {}
-        return state
-
-    def __setstate__(self, state):
-        """Custom deserialization to handle missing objects."""
-        # Restore the args_schema from the stored schema dict
-        args_schema_dict = state.pop('_args_schema_dict', {})
-
-        # Initialize required Pydantic internal attributes
-        if '__pydantic_fields_set__' not in state:
-            state['__pydantic_fields_set__'] = set(state.keys())
-        if '__pydantic_extra__' not in state:
-            state['__pydantic_extra__'] = None
-        if '__pydantic_private__' not in state:
-            state['__pydantic_private__'] = None
-
-        # Directly update the object's __dict__ to bypass Pydantic validation
-        self.__dict__.update(state)
-
-        # Recreate the args_schema from the stored dict if available
-        if args_schema_dict:
-            try:
-                recreated_schema = self.create_pydantic_model_from_schema(args_schema_dict)
-                self.__dict__['args_schema'] = recreated_schema
-            except Exception as e:
-                logger.warning(f"Failed to recreate args_schema: {e}")
-                self.__dict__['args_schema'] = None
-        else:
-            self.__dict__['args_schema'] = None
-
-        # Note: client will be None after unpickling
-        # The toolkit should reinitialize the client when needed
-
-
     @staticmethod
     def create_pydantic_model_from_schema(schema: dict, model_name: str = "ArgsSchema"):
         def parse_type(field: dict, name: str = "Field") -> Any:
@@ -143,30 +92,14 @@ class McpServerTool(BaseTool):
 
     def _run(self, *args, **kwargs):
         # Extract the actual tool/prompt name (remove toolkit prefix)
-        actual_name = self.name.rsplit(TOOLKIT_SPLITTER)[1] if TOOLKIT_SPLITTER in self.name else self.name
-        
-        if self.is_prompt:
-            # For prompts, use prompts/get endpoint
-            call_data = {
-                "server": self.server,
-                "tool_timeout_sec": self.tool_timeout_sec,
-                "tool_call_id": str(uuid.uuid4()),
-                "method": "prompts/get",
-                "params": {
-                    "name": self.prompt_name or actual_name.replace("prompt_", ""),
-                    "arguments": kwargs.get("arguments", kwargs)
-                }
-            }
-        else:
-            # For regular tools, use tools/call endpoint
-            call_data = {
-                "server": self.server,
-                "tool_timeout_sec": self.tool_timeout_sec,
-                "tool_call_id": str(uuid.uuid4()),
-                "params": {
-                    "name": actual_name,
-                    "arguments": kwargs
-                }
+        call_data = {
+            "server": self.server,
+            "tool_timeout_sec": self.tool_timeout_sec,
+            "tool_call_id": str(uuid.uuid4()),
+            "params": {
+                "name": self.name.rsplit(TOOLKIT_SPLITTER)[1] if TOOLKIT_SPLITTER in self.name else self.name,
+                "arguments": kwargs
             }
+        }
         
         return self.client.mcp_tool_call(call_data)

{alita_sdk-0.3.435.dist-info → alita_sdk-0.3.437.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.435
+Version: 0.3.437
 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.435.dist-info → alita_sdk-0.3.437.dist-info}/RECORD

@@ -103,7 +103,7 @@ 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=MnsvXHRbEIE_8O_qPtsGaW3ZiwSOeWUGYVCZGbHLH1E,31402
+alita_sdk/runtime/toolkits/mcp.py,sha256=reAzEnhQe_G5-lQa3P-nV4MCn_YAIx8lllCBFL5uxTk,37624
 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=YCTjrTJuwj2V2C8ZQqXhFvUbVr7NQcUHZlCQLLvoeGA,10946
@@ -122,7 +122,8 @@ alita_sdk/runtime/tools/llm.py,sha256=iRG_wU4T01LRsjEMPZe5Uah7LiMqDc-vspwkMuQtlt
 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=38X8euaxDbEGjcfp6ElvExZalpZun6QEr6ZEW4nU5pQ,11496
-alita_sdk/runtime/tools/mcp_server_tool.py,sha256=HPlEppCbNafee41wSxZL1wnVyYCiOwdMD_dy0eE9IUs,7505
+alita_sdk/runtime/tools/mcp_remote_tool.py,sha256=SfqU-GW7C0ujSLyqRMIYf2AzLxMbYIV2brY6q9yYFCY,8071
+alita_sdk/runtime/tools/mcp_server_tool.py,sha256=-xO3H6BM63KaIV1CdcQKPVE0WPigiqOgFZDX7m2_yGs,4419
 alita_sdk/runtime/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8QwB0UwpsWCYruXU,11692
 alita_sdk/runtime/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
 alita_sdk/runtime/tools/router.py,sha256=p7e0tX6YAWw2M2Nq0A_xqw1E2P-Xz1DaJvhUstfoZn4,1584
@@ -358,8 +359,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.435.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.435.dist-info/METADATA,sha256=kuNOhhnRzdqSLgYrM41t-qLOE62bgF6VE-0r9no-3Z0,19071
-alita_sdk-0.3.435.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.435.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.435.dist-info/RECORD,,
+alita_sdk-0.3.437.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.437.dist-info/METADATA,sha256=fCP3C5QT6Qn1COsbs7uehjpBAicDl_G_rsIfCFl3tDE,19071
+alita_sdk-0.3.437.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.437.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.437.dist-info/RECORD,,