alita-sdk 0.3.423__py3-none-any.whl → 0.3.449__py3-none-any.whl

alita_sdk/runtime/toolkits/tools.py

@@ -12,12 +12,14 @@ from .datasource import DatasourcesToolkit
 from .prompt import PromptToolkit
 from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
+from .mcp import McpToolkit
 from ..tools.mcp_server_tool import McpServerTool
 from ..tools.sandbox import SandboxToolkit
 from ..tools.image_generation import ImageGenerationToolkit
 # Import community tools
 from ...community import get_toolkits as community_toolkits, get_tools as community_tools
 from ...tools.memory import MemoryToolkit
+from ..utils.mcp_oauth import canonical_resource, McpAuthorizationRequired
 from ...tools.utils import TOOLKIT_SPLITTER
 
 logger = logging.getLogger(__name__)
@@ -29,13 +31,14 @@ def get_toolkits():
         MemoryToolkit.toolkit_config_schema(),
         VectorStoreToolkit.toolkit_config_schema(),
         SandboxToolkit.toolkit_config_schema(),
-        ImageGenerationToolkit.toolkit_config_schema()
+        ImageGenerationToolkit.toolkit_config_schema(),
+        McpToolkit.toolkit_config_schema()
     ]
 
     return core_toolkits + community_toolkits() + alita_toolkits()
 
 
-def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = None, debug_mode: Optional[bool] = False) -> list:
+def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = None, debug_mode: Optional[bool] = False, mcp_tokens: Optional[dict] = None) -> list:
     prompts = []
     tools = []
 
@@ -106,7 +109,52 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                     llm=llm,
                     toolkit_name=tool.get('toolkit_name', ''),
                     **tool['settings']).get_tools())
+            elif tool['type'] == 'mcp':
+                settings = dict(tool['settings'])
+                url = settings.get('url')
+                headers = settings.get('headers')
+                token_data = None
+                session_id = None
+                if mcp_tokens and url:
+                    canonical_url = canonical_resource(url)
+                    logger.info(f"[MCP Auth] Looking for token for URL: {url}")
+                    logger.info(f"[MCP Auth] Canonical URL: {canonical_url}")
+                    logger.info(f"[MCP Auth] Available tokens: {list(mcp_tokens.keys())}")
+                    token_data = mcp_tokens.get(canonical_url)
+                    if token_data:
+                        logger.info(f"[MCP Auth] Found token data for {canonical_url}")
+                        # Handle both old format (string) and new format (dict with access_token and session_id)
+                        if isinstance(token_data, dict):
+                            access_token = token_data.get('access_token')
+                            session_id = token_data.get('session_id')
+                            logger.info(f"[MCP Auth] Token data: access_token={'present' if access_token else 'missing'}, session_id={session_id or 'none'}")
+                        else:
+                            # Backward compatibility: treat as plain token string
+                            access_token = token_data
+                            logger.info(f"[MCP Auth] Using legacy token format (string)")
+                    else:
+                        access_token = None
+                        logger.warning(f"[MCP Auth] No token found for {canonical_url}")
+                else:
+                    access_token = None
+                    
+                if access_token:
+                    merged_headers = dict(headers) if headers else {}
+                    merged_headers.setdefault('Authorization', f'Bearer {access_token}')
+                    settings['headers'] = merged_headers
+                    logger.info(f"[MCP Auth] Added Authorization header for {url}")
+                    
+                # Pass session_id to MCP toolkit if available
+                if session_id:
+                    settings['session_id'] = session_id
+                    logger.info(f"[MCP Auth] Passing session_id to toolkit: {session_id}")
+                tools.extend(McpToolkit.get_toolkit(
+                    toolkit_name=tool.get('toolkit_name', ''),
+                    client=alita_client,
+                    **settings).get_tools())
         except Exception as e:
+            if isinstance(e, McpAuthorizationRequired):
+                raise
             logger.error(f"Error initializing toolkit for tool '{tool.get('name', 'unknown')}': {e}", exc_info=True)
             if debug_mode:
                 logger.info("Skipping tool initialization error due to debug mode.")
@@ -121,7 +169,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
@@ -176,6 +225,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}
@@ -183,6 +236,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

@@ -0,0 +1,284 @@
+"""
+MCP Server Inspection Tool.
+Allows inspecting available tools, prompts, and resources on an MCP server.
+"""
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any, Type, Dict, List, Optional
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field, ConfigDict
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+class McpInspectInput(BaseModel):
+    """Input schema for MCP server inspection tool."""
+
+    resource_type: str = Field(
+        default="all",
+        description="What to inspect: 'tools', 'prompts', 'resources', or 'all'"
+    )
+
+
+class McpInspectTool(BaseTool):
+    """Tool for inspecting available tools, prompts, and resources on an MCP server."""
+
+    name: str = "mcp_inspect"
+    description: str = "List available tools, prompts, and resources from the MCP server"
+    args_schema: Type[BaseModel] = McpInspectInput
+    return_type: str = "str"
+
+    # MCP server connection details
+    server_name: str = Field(..., description="Name of the MCP server")
+    server_url: str = Field(..., description="URL of the MCP server")
+    server_headers: Optional[Dict[str, str]] = Field(default=None, description="HTTP headers for authentication")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __getstate__(self):
+        """Custom serialization for pickle compatibility."""
+        state = self.__dict__.copy()
+        # Convert headers dict to regular dict to avoid any reference issues
+        if 'server_headers' in state and state['server_headers'] is not None:
+            state['server_headers'] = dict(state['server_headers'])
+        return state
+
+    def __setstate__(self, state):
+        """Custom deserialization for pickle compatibility."""
+        # Initialize Pydantic internal attributes if needed
+        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
+
+        # Update object state
+        self.__dict__.update(state)
+
+    def _run(self, resource_type: str = "all") -> str:
+        """Inspect the MCP server for available resources."""
+        try:
+            # 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_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))
+
+    async def _inspect_server(self, resource_type: str) -> str:
+        """Perform the actual MCP server inspection."""
+        results = {}
+
+        # Determine what to inspect
+        inspect_tools = resource_type in ["all", "tools"]
+        inspect_prompts = resource_type in ["all", "prompts"]
+        inspect_resources = resource_type in ["all", "resources"]
+
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=self.timeout)) as session:
+
+            # List tools
+            if inspect_tools:
+                try:
+                    tools = await self._list_tools(session)
+                    results["tools"] = tools
+                except Exception as e:
+                    logger.warning(f"Failed to list tools from {self.server_name}: {e}")
+                    results["tools"] = {"error": str(e)}
+
+            # List prompts
+            if inspect_prompts:
+                try:
+                    prompts = await self._list_prompts(session)
+                    results["prompts"] = prompts
+                except Exception as e:
+                    logger.warning(f"Failed to list prompts from {self.server_name}: {e}")
+                    results["prompts"] = {"error": str(e)}
+
+            # List resources
+            if inspect_resources:
+                try:
+                    resources = await self._list_resources(session)
+                    results["resources"] = resources
+                except Exception as e:
+                    logger.warning(f"Failed to list resources from {self.server_name}: {e}")
+                    results["resources"] = {"error": str(e)}
+
+        return self._format_results(results, resource_type)
+
+    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")
+
+    async def _list_tools(self, session: aiohttp.ClientSession) -> Dict[str, Any]:
+        """List available tools from the MCP server."""
+        request = {
+            "jsonrpc": "2.0",
+            "id": f"list_tools_{int(time.time())}",
+            "method": "tools/list",
+            "params": {}
+        }
+
+        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:
+                raise Exception(f"HTTP {response.status}: {await response.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:
+                data = await response.json()
+
+            if "error" in data:
+                raise Exception(f"MCP Error: {data['error']}")
+
+            return data.get("result", {})
+
+    async def _list_prompts(self, session: aiohttp.ClientSession) -> Dict[str, Any]:
+        """List available prompts from the MCP server."""
+        request = {
+            "jsonrpc": "2.0",
+            "id": f"list_prompts_{int(time.time())}",
+            "method": "prompts/list",
+            "params": {}
+        }
+
+        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:
+                raise Exception(f"HTTP {response.status}: {await response.text()}")
+
+            # Handle both JSON and SSE responses
+            content_type = response.headers.get('Content-Type', '')
+            if 'text/event-stream' in content_type:
+                text = await response.text()
+                data = self._parse_sse(text)
+            else:
+                data = await response.json()
+
+            if "error" in data:
+                raise Exception(f"MCP Error: {data['error']}")
+
+            return data.get("result", {})
+
+    async def _list_resources(self, session: aiohttp.ClientSession) -> Dict[str, Any]:
+        """List available resources from the MCP server."""
+        request = {
+            "jsonrpc": "2.0",
+            "id": f"list_resources_{int(time.time())}",
+            "method": "resources/list",
+            "params": {}
+        }
+
+        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:
+                raise Exception(f"HTTP {response.status}: {await response.text()}")
+
+            # Handle both JSON and SSE responses
+            content_type = response.headers.get('Content-Type', '')
+            if 'text/event-stream' in content_type:
+                text = await response.text()
+                data = self._parse_sse(text)
+            else:
+                data = await response.json()
+
+            if "error" in data:
+                raise Exception(f"MCP Error: {data['error']}")
+
+            return data.get("result", {})
+
+    def _format_results(self, results: Dict[str, Any], resource_type: str) -> str:
+        """Format the inspection results for display."""
+        output_lines = [f"=== MCP Server Inspection: {self.server_name} ==="]
+        output_lines.append(f"Server URL: {self.server_url}")
+        output_lines.append("")
+
+        # Format tools
+        if "tools" in results:
+            if "error" in results["tools"]:
+                output_lines.append(f"❌ TOOLS: Error - {results['tools']['error']}")
+            else:
+                tools = results["tools"].get("tools", [])
+                output_lines.append(f"🔧 TOOLS ({len(tools)} available):")
+                if tools:
+                    for tool in tools:
+                        name = tool.get("name", "Unknown")
+                        desc = tool.get("description", "No description")
+                        output_lines.append(f"  • {name}: {desc}")
+                else:
+                    output_lines.append("  (No tools available)")
+                output_lines.append("")
+
+        # Format prompts
+        if "prompts" in results:
+            if "error" in results["prompts"]:
+                output_lines.append(f"❌ PROMPTS: Error - {results['prompts']['error']}")
+            else:
+                prompts = results["prompts"].get("prompts", [])
+                output_lines.append(f"💬 PROMPTS ({len(prompts)} available):")
+                if prompts:
+                    for prompt in prompts:
+                        name = prompt.get("name", "Unknown")
+                        desc = prompt.get("description", "No description")
+                        output_lines.append(f"  • {name}: {desc}")
+                else:
+                    output_lines.append("  (No prompts available)")
+                output_lines.append("")
+
+        # Format resources
+        if "resources" in results:
+            if "error" in results["resources"]:
+                output_lines.append(f"❌ RESOURCES: Error - {results['resources']['error']}")
+            else:
+                resources = results["resources"].get("resources", [])
+                output_lines.append(f"📁 RESOURCES ({len(resources)} available):")
+                if resources:
+                    for resource in resources:
+                        uri = resource.get("uri", "Unknown")
+                        name = resource.get("name", uri)
+                        desc = resource.get("description", "No description")
+                        output_lines.append(f"  • {name}: {desc}")
+                        output_lines.append(f"    URI: {uri}")
+                else:
+                    output_lines.append("  (No resources available)")
+                output_lines.append("")
+
+        return "\n".join(output_lines)

alita_sdk/runtime/tools/mcp_remote_tool.py

@@ -0,0 +1,166 @@
+"""
+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
+from ..utils.mcp_oauth import (
+    McpAuthorizationRequired,
+    canonical_resource,
+    extract_resource_metadata_url,
+    fetch_resource_metadata_async,
+    infer_authorization_servers_from_realm,
+)
+from ..utils.mcp_sse_client import McpSseClient
+
+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
+    session_id: Optional[str] = Field(default=None, description="MCP session ID for stateful SSE servers")
+    
+    def model_post_init(self, __context: Any) -> None:
+        """Update metadata with session info after model initialization."""
+        super().model_post_init(__context)
+        self._update_metadata_with_session()
+    
+    def _update_metadata_with_session(self):
+        """Update the metadata dict with current session information."""
+        if self.session_id:
+            if self.metadata is None:
+                self.metadata = {}
+            self.metadata.update({
+                'mcp_session_id': self.session_id,
+                'mcp_server_url': canonical_resource(self.server_url)
+            })
+    
+    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 McpAuthorizationRequired:
+            # Bubble up so LangChain can surface a tool error with useful metadata
+            raise
+        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 using SSE client."""
+        from ...tools.utils import TOOLKIT_SPLITTER
+        
+        # Check for session_id requirement
+        if not self.session_id:
+            logger.error(f"[MCP Session] Missing session_id for tool '{self.name}'")
+            raise Exception("sessionId required. Frontend must generate UUID and send with mcp_tokens.")
+        
+        # Use the original tool name from discovery for MCP server invocation
+        tool_name_for_server = self.original_tool_name
+        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: {tool_name_for_server}")
+        
+        logger.info(f"[MCP SSE] Executing tool '{tool_name_for_server}' with session {self.session_id}")
+        
+        try:
+            # Prepare headers
+            headers = {}
+            if self.server_headers:
+                headers.update(self.server_headers)
+            
+            # Create SSE client
+            client = McpSseClient(
+                url=self.server_url,
+                session_id=self.session_id,
+                headers=headers,
+                timeout=self.tool_timeout_sec
+            )
+            
+            # Execute tool call via SSE
+            result = await client.call_tool(tool_name_for_server, kwargs)
+            
+            # Format the result
+            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 Exception as e:
+            logger.error(f"[MCP SSE] Tool execution failed: {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")
+    
+    def get_session_metadata(self) -> dict:
+        """Return session metadata to be included in tool responses."""
+        if self.session_id:
+            return {
+                'mcp_session_id': self.session_id,
+                'mcp_server_url': canonical_resource(self.server_url)
+            }
+        return {}

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -3,7 +3,7 @@ from logging import getLogger
 from typing import Any, Type, Literal, Optional, Union, List
 
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field, create_model, EmailStr, constr
+from pydantic import BaseModel, Field, create_model, EmailStr, constr, ConfigDict
 
 from ...tools.utils import TOOLKIT_SPLITTER
 
@@ -19,6 +19,7 @@ class McpServerTool(BaseTool):
     server: str
     tool_timeout_sec: int = 60
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @staticmethod
     def create_pydantic_model_from_schema(schema: dict, model_name: str = "ArgsSchema"):
@@ -90,6 +91,7 @@ class McpServerTool(BaseTool):
         return create_model(model_name, **fields)
 
     def _run(self, *args, **kwargs):
+        # Extract the actual tool/prompt name (remove toolkit prefix)
         call_data = {
             "server": self.server,
             "tool_timeout_sec": self.tool_timeout_sec,