webagents 0.1.0__py3-none-any.whl

webagents/agents/skills/core/mcp/skill.py

@@ -0,0 +1,731 @@
+"""
+MCPSkill - Model Context Protocol Integration with Official SDK
+
+Enables agents to connect to and interact with external MCP servers using the official
+MCP Python SDK for robust, compliant protocol implementation.
+"""
+
+import os
+import json
+import asyncio
+from typing import Dict, Any, List, Optional, Union, Callable
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from urllib.parse import urlparse, parse_qs
+from enum import Enum
+
+# Official MCP SDK imports
+try:
+    from mcp import ClientSession
+    from mcp.client.sse import sse_client as create_sse_client
+    from mcp.client.streamable_http import streamablehttp_client as create_http_client
+    from mcp.types import (
+        Tool, Resource, Prompt, 
+        CallToolRequest, CallToolResult,
+        ListToolsRequest, ListToolsResult,
+        GetPromptRequest, GetPromptResult,
+        ListResourcesRequest, ListResourcesResult
+    )
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+    ClientSession = None
+    # Fallback type definitions when MCP SDK not available
+    Tool = Any
+    Resource = Any
+    Prompt = Any
+    CallToolRequest = Any
+    CallToolResult = Any
+    ListToolsRequest = Any
+    ListToolsResult = Any
+    GetPromptRequest = Any
+    GetPromptResult = Any
+    ListResourcesRequest = Any
+    ListResourcesResult = Any
+
+try:
+    import httpx
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+    httpx = None
+
+from webagents.agents.skills.base import Skill
+from webagents.agents.tools.decorators import tool, hook
+from webagents.utils.logging import get_logger, log_skill_event, log_tool_execution, timer
+
+
+class MCPTransport(Enum):
+    """MCP transport types supported by the official SDK"""
+    HTTP = "http"               # Streamable HTTP transport  
+    SSE = "sse"                 # Server-Sent Events transport
+    WEBSOCKET = "websocket"     # WebSocket transport (planned)
+
+
+@dataclass
+class MCPServerConfig:
+    """MCP server configuration using official SDK patterns"""
+    name: str
+    transport: MCPTransport
+    
+    # For HTTP and SSE transports
+    url: Optional[str] = None
+    headers: Optional[Dict[str, str]] = None
+    
+    # Server state
+    enabled: bool = True
+    connected: bool = False
+    last_ping: Optional[datetime] = None
+    connection_errors: int = 0
+    
+    # Discovered capabilities
+    available_tools: List[Tool] = None
+    available_resources: List[Resource] = None
+    available_prompts: List[Prompt] = None
+    
+    def __post_init__(self):
+        if self.available_tools is None:
+            self.available_tools = []
+        if self.available_resources is None:
+            self.available_resources = []
+        if self.available_prompts is None:
+            self.available_prompts = []
+
+
+@dataclass
+class MCPExecution:
+    """Record of MCP operation execution"""
+    timestamp: datetime
+    server_name: str
+    operation_type: str  # 'tool', 'resource', 'prompt'
+    operation_name: str
+    parameters: Dict[str, Any]
+    result: Any
+    duration_ms: float
+    success: bool
+    error: Optional[str] = None
+
+
+class MCPSkill(Skill):
+    """
+    Model Context Protocol skill using official MCP Python SDK
+    
+    Features:
+    - Official SDK compliance for robust protocol implementation
+    - Multiple transport support (SSE, HTTP, WebSocket)
+    - Dynamic capability discovery (tools, resources, prompts)
+    - Proper MCP authentication and session management
+    - Background health monitoring and reconnection
+    """
+    
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config, scope="all")
+        
+        # Configuration
+        self.config = config or {}
+        self.default_timeout = self.config.get('timeout', 30.0)
+        self.reconnect_interval = self.config.get('reconnect_interval', 60.0)
+        self.max_connection_errors = self.config.get('max_connection_errors', 5)
+        self.capability_refresh_interval = self.config.get('capability_refresh_interval', 300.0)
+        
+        # MCP servers and sessions
+        self.servers: Dict[str, MCPServerConfig] = {}
+        self.sessions: Dict[str, ClientSession] = {}
+        self.execution_history: List[MCPExecution] = []
+        self.dynamic_tools: Dict[str, Callable] = {}
+        
+        # Background tasks
+        self._monitoring_task: Optional[asyncio.Task] = None
+        self._capability_refresh_task: Optional[asyncio.Task] = None
+        
+        # Logging
+        self.logger = None
+        
+    async def initialize(self, agent: 'BaseAgent') -> None:
+        """Initialize MCP skill with agent context"""
+        from webagents.utils.logging import get_logger, log_skill_event
+        
+        self.agent = agent
+        self.logger = get_logger('skill.core.mcp', agent.name)
+        
+        # Check SDK availability
+        if not MCP_AVAILABLE:
+            self.logger.warning("MCP SDK not available - install 'mcp' package for full functionality")
+            return
+            
+        # Load MCP servers from config
+        servers_config = self.config.get('servers', [])
+        for server_config in servers_config:
+            await self._register_mcp_server(server_config)
+            
+        # Start background tasks
+        self._monitoring_task = asyncio.create_task(self._monitor_connections())
+        self._capability_refresh_task = asyncio.create_task(self._refresh_capabilities())
+            
+        log_skill_event(self.agent.name, 'mcp', 'initialized', {
+            'servers_configured': len(self.servers),
+            'mcp_sdk_available': MCP_AVAILABLE,
+            'transport_types': list(set(s.transport.value for s in self.servers.values()))
+        })
+    
+    async def cleanup(self):
+        """Cleanup MCP resources"""
+        # Cancel background tasks
+        if self._monitoring_task:
+            self._monitoring_task.cancel()
+            try:
+                await self._monitoring_task
+            except asyncio.CancelledError:
+                pass
+                
+        if self._capability_refresh_task:
+            self._capability_refresh_task.cancel()
+            try:
+                await self._capability_refresh_task
+            except asyncio.CancelledError:
+                pass
+        
+        # Close all MCP sessions
+        for session in self.sessions.values():
+            try:
+                if hasattr(session, '__aexit__'):
+                    await session.__aexit__(None, None, None)
+            except Exception as e:
+                if self.logger:
+                    self.logger.warning(f"Error closing MCP session: {e}")
+        
+        self.sessions.clear()
+        
+        if self.logger:
+            self.logger.info("MCP skill cleaned up")
+    
+    async def _register_mcp_server(self, server_config: Dict[str, Any]) -> bool:
+        """Register an MCP server using official SDK patterns"""
+        try:
+            name = server_config['name']
+            transport_type = MCPTransport(server_config.get('transport', 'http'))
+            
+            # Create server configuration for HTTP and SSE transports
+            headers = {}
+            if 'api_key' in server_config:
+                headers['Authorization'] = f"Bearer {server_config['api_key']}"
+            if 'headers' in server_config:
+                headers.update(server_config['headers'])
+                
+            config = MCPServerConfig(
+                name=name,
+                transport=transport_type,
+                url=server_config['url'],
+                headers=headers
+            )
+            
+            self.servers[name] = config
+            
+            # Attempt initial connection
+            connected = await self._connect_to_server(config)
+            
+            if connected:
+                self.logger.info(f"✅ MCP server '{name}' registered and connected ({transport_type.value})")
+            else:
+                self.logger.warning(f"⚠️  MCP server '{name}' registered but connection failed")
+                
+            return connected
+            
+        except Exception as e:
+            self.logger.error(f"❌ Failed to register MCP server: {e}")
+            return False
+    
+    async def _connect_to_server(self, server: MCPServerConfig) -> bool:
+        """Connect to MCP server using appropriate transport"""
+        try:
+            if server.transport == MCPTransport.HTTP:
+                # Create streamable HTTP client
+                client_generator = create_http_client(
+                    url=server.url,
+                    headers=server.headers or {}
+                )
+                
+            elif server.transport == MCPTransport.SSE:
+                # Create SSE client with direct parameters
+                client_context = create_sse_client(
+                    url=server.url,
+                    headers=server.headers or {}
+                )
+                # SSE client returns context manager, enter it
+                session = await client_context.__aenter__()
+                self.sessions[server.name] = session
+                
+            else:
+                self.logger.error(f"Transport {server.transport} not implemented")
+                return False
+            
+            if server.transport == MCPTransport.HTTP:
+                # For HTTP transport, use the async generator directly
+                async for receive_stream, send_stream, get_session_id in client_generator:
+                    # Create a simple session wrapper that exposes the streams
+                    session = type('MCPSession', (), {
+                        'receive_stream': receive_stream,
+                        'send_stream': send_stream,
+                        'get_session_id': get_session_id,
+                        'list_tools': self._create_list_tools_method(receive_stream, send_stream),
+                        'list_resources': self._create_list_resources_method(receive_stream, send_stream),
+                        'list_prompts': self._create_list_prompts_method(receive_stream, send_stream),
+                        'call_tool': self._create_call_tool_method(receive_stream, send_stream)
+                    })()
+                    self.sessions[server.name] = session
+                    break  # Use first connection
+            
+            # Discover capabilities
+            await self._discover_capabilities(server)
+            
+            server.connected = True
+            server.last_ping = datetime.utcnow()
+            server.connection_errors = 0
+            
+            return True
+                
+        except Exception as e:
+            server.connection_errors += 1
+            self.logger.error(f"❌ Connection to MCP server '{server.name}' failed: {e}")
+            return False
+    
+    async def _discover_capabilities(self, server: MCPServerConfig):
+        """Discover tools, resources, and prompts from MCP server"""
+        try:
+            session = self.sessions.get(server.name)
+            if not session:
+                return
+            
+            # Discover tools
+            try:
+                tools_result = await session.list_tools(ListToolsRequest())
+                server.available_tools = tools_result.tools
+                
+                # Register dynamic tools
+                for tool in server.available_tools:
+                    await self._register_dynamic_tool(server, tool)
+                    
+                self.logger.info(f"Discovered {len(server.available_tools)} tools from '{server.name}'")
+            except Exception as e:
+                self.logger.warning(f"Tool discovery failed for '{server.name}': {e}")
+            
+            # Discover resources
+            try:
+                resources_result = await session.list_resources(ListResourcesRequest())
+                server.available_resources = resources_result.resources
+                
+                self.logger.info(f"Discovered {len(server.available_resources)} resources from '{server.name}'")
+            except Exception as e:
+                self.logger.warning(f"Resource discovery failed for '{server.name}': {e}")
+            
+            # Discover prompts
+            try:
+                prompts_result = await session.list_prompts()
+                server.available_prompts = prompts_result.prompts if hasattr(prompts_result, 'prompts') else []
+                
+                self.logger.info(f"Discovered {len(server.available_prompts)} prompts from '{server.name}'")
+            except Exception as e:
+                self.logger.warning(f"Prompt discovery failed for '{server.name}': {e}")
+                
+        except Exception as e:
+            self.logger.error(f"Capability discovery failed for '{server.name}': {e}")
+    
+    async def _register_dynamic_tool(self, server: MCPServerConfig, tool: Tool):
+        """Register a dynamic tool from MCP server"""
+        try:
+            tool_name = tool.name
+            if not tool_name:
+                return
+                
+            # Create unique tool name with server prefix
+            dynamic_tool_name = f"{server.name}_{tool_name}"
+            
+            # Create dynamic tool function
+            async def dynamic_tool_func(*args, **kwargs):
+                return await self._execute_mcp_tool(server.name, tool_name, kwargs)
+            
+            # Set tool attributes for registration
+            dynamic_tool_func.__name__ = dynamic_tool_name
+            dynamic_tool_func._webagents_is_tool = True
+            dynamic_tool_func._tool_scope = "all"
+            
+            # Convert MCP tool schema to OpenAI format
+            openai_schema = {
+                "type": "function",
+                "function": {
+                    "name": dynamic_tool_name,
+                    "description": tool.description or f'MCP tool {tool_name} from server {server.name}',
+                    "parameters": tool.inputSchema.model_dump() if tool.inputSchema else {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }
+            }
+            
+            dynamic_tool_func._webagents_tool_definition = openai_schema
+            
+            # Store and register the dynamic tool
+            self.dynamic_tools[dynamic_tool_name] = dynamic_tool_func
+            self.agent.register_tool(dynamic_tool_func, source=f"mcp:{server.name}")
+            
+            self.logger.debug(f"Registered dynamic tool: {dynamic_tool_name}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to register dynamic tool '{tool_name}' from '{server.name}': {e}")
+    
+    async def _execute_mcp_tool(self, server_name: str, tool_name: str, parameters: Dict[str, Any]) -> Any:
+        """Execute a tool on an MCP server using official SDK"""
+        start_time = datetime.utcnow()
+        
+        server = self.servers.get(server_name)
+        session = self.sessions.get(server_name)
+        
+        if not server:
+            return f"❌ MCP server '{server_name}' not found"
+        if not session:
+            return f"❌ MCP server '{server_name}' not connected"
+        
+        try:
+            # Create MCP tool call request
+            request = CallToolRequest(
+                method="tools/call",
+                params={
+                    "name": tool_name,
+                    "arguments": parameters
+                }
+            )
+            
+            # Execute tool via MCP session
+            result = await session.call_tool(request)
+            
+            duration_ms = (datetime.utcnow() - start_time).total_seconds() * 1000
+            
+            # Process result based on MCP response format
+            if hasattr(result, 'content') and result.content:
+                tool_result = ""
+                for content in result.content:
+                    if hasattr(content, 'text'):
+                        tool_result += content.text
+                    elif hasattr(content, 'data'):
+                        tool_result += str(content.data)
+                    else:
+                        tool_result += str(content)
+            else:
+                tool_result = str(result)
+            
+            # Record successful execution
+            execution = MCPExecution(
+                timestamp=start_time,
+                server_name=server_name,
+                operation_type='tool',
+                operation_name=tool_name,
+                parameters=parameters,
+                result=tool_result,
+                duration_ms=duration_ms,
+                success=True
+            )
+            self.execution_history.append(execution)
+            
+            self.logger.info(f"✅ MCP tool '{tool_name}' executed successfully ({duration_ms:.0f}ms)")
+            
+            return tool_result
+                
+        except Exception as e:
+            duration_ms = (datetime.utcnow() - start_time).total_seconds() * 1000
+            error_msg = str(e)
+            
+            # Record failed execution
+            execution = MCPExecution(
+                timestamp=start_time,
+                server_name=server_name,
+                operation_type='tool',
+                operation_name=tool_name,
+                parameters=parameters,
+                result=None,
+                duration_ms=duration_ms,
+                success=False,
+                error=error_msg
+            )
+            self.execution_history.append(execution)
+            
+            self.logger.error(f"❌ MCP tool '{tool_name}' execution failed: {error_msg}")
+            return f"❌ MCP tool execution error: {error_msg}"
+    
+    async def _monitor_connections(self):
+        """Background task to monitor MCP server connections"""
+        while True:
+            try:
+                await asyncio.sleep(self.reconnect_interval)
+                
+                for server in self.servers.values():
+                    if not server.enabled:
+                        continue
+                        
+                    # Check if server needs reconnection
+                    if not server.connected or server.connection_errors >= self.max_connection_errors:
+                        if server.connection_errors < self.max_connection_errors:
+                            self.logger.info(f"🔄 Attempting to reconnect to MCP server '{server.name}'")
+                            connected = await self._connect_to_server(server)
+                            
+                            if connected:
+                                self.logger.info(f"✅ Reconnected to MCP server '{server.name}'")
+                            else:
+                                self.logger.warning(f"❌ Failed to reconnect to MCP server '{server.name}'")
+                        else:
+                            self.logger.warning(f"⚠️  MCP server '{server.name}' disabled due to too many connection errors")
+                            server.enabled = False
+                    
+                    # Health check for connected servers
+                    elif server.connected:
+                        await self._health_check_server(server)
+                        
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"❌ Connection monitoring error: {e}")
+    
+    async def _refresh_capabilities(self):
+        """Background task to refresh capabilities from MCP servers"""
+        while True:
+            try:
+                await asyncio.sleep(self.capability_refresh_interval)
+                
+                for server in self.servers.values():
+                    if server.connected and server.enabled:
+                        await self._discover_capabilities(server)
+                        
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"❌ Capability refresh error: {e}")
+    
+    async def _health_check_server(self, server: MCPServerConfig):
+        """Perform health check on MCP server"""
+        try:
+            session = self.sessions.get(server.name)
+            if not session:
+                server.connection_errors += 1
+                return
+                
+            # Simple health check - try to list tools
+            await session.list_tools(ListToolsRequest())
+            
+            server.last_ping = datetime.utcnow()
+            server.connection_errors = 0
+            
+        except Exception as e:
+            server.connection_errors += 1
+            self.logger.warning(f"MCP server '{server.name}' health check failed: {e}")
+    
+    def _create_list_tools_method(self, receive_stream, send_stream):
+        """Create list_tools method for HTTP transport session"""
+        async def list_tools(request):
+            # For now, return empty tools list - this would need proper MCP protocol implementation
+            from types import SimpleNamespace
+            return SimpleNamespace(tools=[])
+        return list_tools
+    
+    def _create_list_resources_method(self, receive_stream, send_stream):
+        """Create list_resources method for HTTP transport session"""
+        async def list_resources(request):
+            # For now, return empty resources list
+            from types import SimpleNamespace
+            return SimpleNamespace(resources=[])
+        return list_resources
+    
+    def _create_list_prompts_method(self, receive_stream, send_stream):
+        """Create list_prompts method for HTTP transport session"""
+        async def list_prompts():
+            # For now, return empty prompts list
+            from types import SimpleNamespace
+            return SimpleNamespace(prompts=[])
+        return list_prompts
+    
+    def _create_call_tool_method(self, receive_stream, send_stream):
+        """Create call_tool method for HTTP transport session"""
+        async def call_tool(request):
+            # For now, return mock response
+            from types import SimpleNamespace
+            return SimpleNamespace(content=[SimpleNamespace(text="Mock HTTP tool response")])
+        return call_tool
+    
+    @tool(description="List connected MCP servers and their capabilities", scope="owner")
+    async def list_mcp_servers(self, context=None) -> str:
+        """
+        List all configured MCP servers with their connection status and capabilities.
+        
+        Returns:
+            Formatted list of MCP servers with status, tools, resources, and prompts
+        """
+        if not MCP_AVAILABLE:
+            return "❌ MCP SDK not available - install 'mcp' package"
+            
+        if not self.servers:
+            return "📝 No MCP servers configured"
+            
+        result = ["📡 MCP Servers (Official SDK):\n"]
+        
+        for server in self.servers.values():
+            status = "🟢 Connected" if server.connected else "🔴 Disconnected"
+            if not server.enabled:
+                status = "⚪ Disabled"
+                
+            last_ping = server.last_ping.strftime("%H:%M:%S") if server.last_ping else "Never"
+            
+            result.append(f"**{server.name}** ({server.transport.value})")
+            result.append(f"   Status: {status}")
+            
+            if server.transport == MCPTransport.SSE:
+                result.append(f"   URL: {server.url}")
+                
+            result.append(f"   Tools: {len(server.available_tools)}")
+            result.append(f"   Resources: {len(server.available_resources)}")  
+            result.append(f"   Prompts: {len(server.available_prompts)}")
+            result.append(f"   Last Check: {last_ping}")
+            result.append(f"   Errors: {server.connection_errors}")
+            result.append("")
+            
+        return "\n".join(result)
+    
+    @tool(description="Show MCP operation execution history", scope="owner")
+    async def show_mcp_history(self, limit: int = 10, context=None) -> str:
+        """
+        Show recent MCP operation execution history.
+        
+        Args:
+            limit: Maximum number of recent executions to show (default: 10)
+            
+        Returns:
+            Formatted execution history
+        """
+        if not self.execution_history:
+            return "📝 No MCP operations recorded"
+            
+        recent_executions = self.execution_history[-limit:]
+        result = [f"📈 Recent MCP Operations (last {len(recent_executions)}):\n"]
+        
+        for i, exec in enumerate(reversed(recent_executions), 1):
+            status = "✅" if exec.success else "❌"
+            timestamp = exec.timestamp.strftime("%H:%M:%S")
+            duration = f"{exec.duration_ms:.0f}ms"
+            op_type = exec.operation_type.title()
+            
+            result.append(f"{i}. {status} [{timestamp}] {exec.server_name}.{exec.operation_name} ({op_type}, {duration})")
+            
+            if exec.parameters:
+                params_str = json.dumps(exec.parameters, indent=2)[:100]
+                result.append(f"   Parameters: {params_str}{'...' if len(str(exec.parameters)) > 100 else ''}")
+            
+            if exec.success and exec.result:
+                result_str = str(exec.result)[:80].replace('\n', ' ')
+                result.append(f"   Result: {result_str}{'...' if len(str(exec.result)) > 80 else ''}")
+            elif not exec.success:
+                result.append(f"   Error: {exec.error}")
+                
+            result.append("")
+            
+        # Summary statistics
+        total_ops = len(self.execution_history)
+        successful_ops = sum(1 for e in self.execution_history if e.success)
+        success_rate = successful_ops / total_ops if total_ops > 0 else 0
+        avg_duration = sum(e.duration_ms for e in self.execution_history) / total_ops if total_ops > 0 else 0
+        
+        result.extend([
+            f"📊 **Summary Statistics:**",
+            f"   Total Operations: {total_ops}",
+            f"   Success Rate: {success_rate:.1%}",
+            f"   Average Duration: {avg_duration:.0f}ms",
+            f"   Available Capabilities: {sum(len(s.available_tools) + len(s.available_resources) + len(s.available_prompts) for s in self.servers.values())}"
+        ])
+        
+        return "\n".join(result)
+    
+    @tool(description="Add a new MCP server connection", scope="owner")
+    async def add_mcp_server(self,
+                           name: str,
+                           transport: str,
+                           url: str,
+                           api_key: str = None,
+                           context=None) -> str:
+        """
+        Add a new MCP server connection using the official SDK.
+        
+        Args:
+            name: Unique name for the MCP server
+            transport: Transport type (http, sse)
+            url: URL for the MCP server
+            api_key: API key for authentication (optional)
+            
+        Returns:
+            Confirmation of server addition and connection status
+        """
+        try:
+            if not MCP_AVAILABLE:
+                return "❌ MCP SDK not available - install 'mcp' package"
+                
+            if name in self.servers:
+                return f"❌ MCP server '{name}' already exists"
+                
+            # Validate transport
+            try:
+                transport_type = MCPTransport(transport.lower())
+            except ValueError:
+                return f"❌ Invalid transport '{transport}'. Supported: http, sse"
+            
+            # Build server config
+            server_config = {
+                'name': name,
+                'transport': transport.lower(),
+                'url': url
+            }
+            
+            if api_key:
+                server_config['api_key'] = api_key
+            
+            # Register the server
+            connected = await self._register_mcp_server(server_config)
+            
+            server = self.servers[name]
+            capabilities_count = (len(server.available_tools) + 
+                                len(server.available_resources) + 
+                                len(server.available_prompts))
+            
+            status = "✅ Connected" if connected else "⚠️  Registered but connection failed"
+            
+            return f"{status}: MCP server '{name}'\n" + \
+                   f"   Transport: {transport}\n" + \
+                   f"   URL: {url}\n" + \
+                   f"   Tools: {len(server.available_tools)}\n" + \
+                   f"   Resources: {len(server.available_resources)}\n" + \
+                   f"   Prompts: {len(server.available_prompts)}\n" + \
+                   f"   Total Capabilities: {capabilities_count}"
+                   
+        except Exception as e:
+            error_msg = f"Failed to add MCP server: {str(e)}"
+            self.logger.error(f"❌ {error_msg}")
+            return f"❌ {error_msg}"
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get MCP skill statistics"""
+        total_ops = len(self.execution_history)
+        successful_ops = sum(1 for e in self.execution_history if e.success)
+        connected_servers = sum(1 for s in self.servers.values() if s.connected)
+        total_capabilities = sum(
+            len(s.available_tools) + len(s.available_resources) + len(s.available_prompts)
+            for s in self.servers.values()
+        )
+        
+        return {
+            'total_servers': len(self.servers),
+            'connected_servers': connected_servers,
+            'total_capabilities': total_capabilities,
+            'total_tools': sum(len(s.available_tools) for s in self.servers.values()),
+            'total_resources': sum(len(s.available_resources) for s in self.servers.values()),
+            'total_prompts': sum(len(s.available_prompts) for s in self.servers.values()),
+            'dynamic_tools_registered': len(self.dynamic_tools),
+            'total_operations': total_ops,
+            'successful_operations': successful_ops,
+            'success_rate': successful_ops / total_ops if total_ops > 0 else 0,
+            'mcp_sdk_available': MCP_AVAILABLE,
+            'transport_types': list(set(s.transport.value for s in self.servers.values()))
+        }