alita-sdk 0.3.436__tar.gz → 0.3.438__tar.gz

{alita_sdk-0.3.436 → alita_sdk-0.3.438}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.436
+Version: 0.3.438
 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 → alita_sdk-0.3.438}/alita_sdk/runtime/toolkits/mcp.py

@@ -7,12 +7,13 @@ Following MCP specification: https://modelcontextprotocol.io/specification/2025-
 import logging
 import re
 import requests
-from typing import List, Optional, Any, Dict, Literal, ClassVar
+from typing import List, Optional, Any, Dict, Literal, ClassVar, Union
 
 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
@@ -199,11 +200,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             timeout=(
-                int,
+                Union[int, str], # TODO: remove one I will figure out why UI sends str
                 Field(
-                    default=60,
-                    ge=1, le=300,
-                    description="Request timeout in seconds"
+                    default=300,
+                    description="Request timeout in seconds (1-3600)"
                 )
             ),
             discovery_mode=(
@@ -217,11 +217,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             discovery_interval=(
-                int,
+                Union[int, str],
                 Field(
                     default=300,
-                    ge=60, le=3600,
-                    description="Discovery interval in seconds (for periodic discovery)"
+                    description="Discovery interval in seconds (60-3600, for periodic discovery)"
                 )
             ),
             selected_tools=(
@@ -242,11 +241,10 @@ class McpToolkit(BaseToolkit):
                 )
             ),
             cache_ttl=(
-                int,
+                Union[int, str],
                 Field(
                     default=300,
-                    ge=60, le=3600,
-                    description="Cache TTL in seconds"
+                    description="Cache TTL in seconds (60-3600)"
                 )
             ),
             __config__=ConfigDict(
@@ -308,6 +306,11 @@ class McpToolkit(BaseToolkit):
         if not toolkit_name:
             raise ValueError("toolkit_name is required")
 
+        # 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}")
 
         # Parse headers if they're provided as a JSON string
@@ -391,6 +394,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 +598,7 @@ class McpToolkit(BaseToolkit):
         cls,
         tool_dict: Dict[str, Any],
         toolkit_name: str,
+        connection_config: McpConnectionConfig,
         timeout: int,
         client
     ) -> Optional[BaseTool]:
@@ -612,17 +617,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 +729,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 +766,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-0.3.438/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-0.3.436 → alita_sdk-0.3.438}/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 → alita_sdk-0.3.438}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.436
+Version: 0.3.438
 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 → alita_sdk-0.3.438}/alita_sdk.egg-info/SOURCES.txt

@@ -130,6 +130,7 @@ alita_sdk/runtime/tools/llm.py
 alita_sdk/runtime/tools/loop.py
 alita_sdk/runtime/tools/loop_output.py
 alita_sdk/runtime/tools/mcp_inspect_tool.py
+alita_sdk/runtime/tools/mcp_remote_tool.py
 alita_sdk/runtime/tools/mcp_server_tool.py
 alita_sdk/runtime/tools/pgvector_search.py
 alita_sdk/runtime/tools/prompt.py

{alita_sdk-0.3.436 → alita_sdk-0.3.438}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.436"
+version = "0.3.438"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"