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

alita_sdk/runtime/toolkits/mcp.py

@@ -13,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
@@ -391,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
                 )
@@ -594,6 +596,7 @@ class McpToolkit(BaseToolkit):
         cls,
         tool_dict: Dict[str, Any],
         toolkit_name: str,
+        connection_config: McpConnectionConfig,
         timeout: int,
         client
     ) -> Optional[BaseTool]:
@@ -612,17 +615,27 @@ class McpToolkit(BaseToolkit):
             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}")
@@ -714,9 +727,15 @@ class McpToolkit(BaseToolkit):
             # 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,
@@ -745,9 +764,15 @@ class McpToolkit(BaseToolkit):
             # 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", {})
                 ),

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.436.dist-info → alita_sdk-0.3.437.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.436
+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.436.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=6MRNk8FCFSyPFJJhC-Sr5MRdxnEjW8xhO8c8rtePxOs,36176
+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.436.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.436.dist-info/METADATA,sha256=2cPfEOfx6pSH8_ITPeRoYsrJ7kNp0X5Z0h7F0UXhUE0,19071
-alita_sdk-0.3.436.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.436.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.436.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,,