File size: 10,170 Bytes
22087d0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 | import json
import asyncio
from typing import Dict, Any, List
from mcp import ClientSession, StdioServerParameters
from mcp.client.sse import sse_client
from mcp.client.stdio import stdio_client
from mcp.client.streamable_http import streamablehttp_client
from core.utils.logger import logger
from .mcp_connection_manager import MCPConnectionManager
class CustomMCPHandler:
def __init__(self, connection_manager: MCPConnectionManager, account_id: str = None):
self.connection_manager = connection_manager
self.account_id = account_id
self.custom_tools = {}
async def initialize_custom_mcps(self, custom_configs: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
initialization_tasks = []
for config in custom_configs:
task = self._initialize_single_custom_mcp_safe(config)
initialization_tasks.append(task)
if initialization_tasks:
logger.debug(f"Initializing {len(initialization_tasks)} custom MCPs in parallel...")
results = await asyncio.gather(*initialization_tasks, return_exceptions=True)
for i, result in enumerate(results):
if isinstance(result, Exception):
config_name = custom_configs[i].get('name', 'Unknown')
logger.error(f"Failed to initialize custom MCP {config_name}: {result}")
return self.custom_tools
async def _initialize_single_custom_mcp_safe(self, config: Dict[str, Any]):
try:
await self._initialize_single_custom_mcp(config)
except Exception as e:
logger.error(f"Failed to initialize custom MCP {config.get('name', 'Unknown')}: {e}")
return e
async def _initialize_single_custom_mcp(self, config: Dict[str, Any]):
custom_type = config.get('customType', 'sse')
server_config = config.get('config', {})
enabled_tools = config.get('enabledTools', config.get('enabled_tools', []))
server_name = config.get('name', 'Unknown')
# logger.debug(f"Initializing custom MCP: {server_name} (type: {custom_type})")
if custom_type == 'composio':
await self._initialize_composio_mcp(server_name, server_config, enabled_tools)
elif custom_type == 'sse':
await self._initialize_sse_mcp(server_name, server_config, enabled_tools)
elif custom_type == 'http':
await self._initialize_http_mcp(server_name, server_config, enabled_tools)
elif custom_type == 'json':
await self._initialize_json_mcp(server_name, server_config, enabled_tools)
else:
logger.error(f"Custom MCP {server_name}: Unsupported type '{custom_type}'")
async def _initialize_composio_mcp(self, server_name: str, server_config: Dict[str, Any], enabled_tools: List[str]):
profile_id = server_config.get('profile_id')
if not profile_id:
logger.error(f"Composio MCP {server_name}: Missing profile_id in config")
return
try:
from core.composio_integration.composio_profile_service import ComposioProfileService
from core.services.supabase import DBConnection
db = DBConnection()
profile_service = ComposioProfileService(db)
mcp_url = await profile_service.get_mcp_url_for_runtime(profile_id, account_id=self.account_id)
logger.debug(f"Resolved Composio profile {profile_id} to MCP URL")
async with streamablehttp_client(mcp_url) as (read_stream, write_stream, _):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tools_result = await session.list_tools()
tools = tools_result.tools if hasattr(tools_result, 'tools') else tools_result
self._register_custom_tools(tools, server_name, enabled_tools, 'composio', server_config)
except Exception as e:
logger.error(f"Failed to initialize Composio MCP {server_name}: {str(e)}")
async def _initialize_sse_mcp(self, server_name: str, server_config: Dict[str, Any], enabled_tools: List[str]):
if 'url' not in server_config:
logger.error(f"Custom MCP {server_name}: Missing 'url' in config")
return
server_info = await self.connection_manager.connect_sse_server(server_name, server_config)
if server_info.get('status') == 'connected':
tools_info = server_info.get('tools', [])
self._register_custom_tools_from_info(tools_info, server_name, enabled_tools, 'sse', server_config)
else:
logger.error(f"Failed to connect to custom MCP {server_name}")
async def _initialize_http_mcp(self, server_name: str, server_config: Dict[str, Any], enabled_tools: List[str]):
if 'url' not in server_config:
logger.error(f"Custom MCP {server_name}: Missing 'url' in config")
return
server_info = await self.connection_manager.connect_http_server(server_name, server_config)
if server_info.get('status') == 'connected':
tools_info = server_info.get('tools', [])
self._register_custom_tools_from_info(tools_info, server_name, enabled_tools, 'http', server_config)
else:
logger.error(f"Failed to connect to custom MCP {server_name}")
async def _initialize_json_mcp(self, server_name: str, server_config: Dict[str, Any], enabled_tools: List[str]):
if 'command' not in server_config:
logger.error(f"Custom MCP {server_name}: Missing 'command' in config")
return
server_info = await self.connection_manager.connect_stdio_server(server_name, server_config)
if server_info.get('status') == 'connected':
tools_info = server_info.get('tools', [])
self._register_custom_tools_from_info(tools_info, server_name, enabled_tools, 'json', server_config)
else:
logger.error(f"Failed to connect to custom MCP {server_name}")
async def _resolve_external_user_id(self, server_config: Dict[str, Any]) -> str:
profile_id = server_config.get('profile_id')
external_user_id = server_config.get('external_user_id')
if not profile_id:
return external_user_id
try:
from core.services.supabase import DBConnection
from core.utils.encryption import decrypt_data
db = DBConnection()
supabase = await db.client
result = await supabase.table('user_mcp_credential_profiles').select(
'encrypted_config'
).eq('profile_id', profile_id).eq('account_id', self.account_id).single().execute()
if result.data:
decrypted_config = decrypt_data(result.data['encrypted_config'])
config_data = json.loads(decrypted_config)
profile_external_user_id = config_data.get('external_user_id')
if external_user_id and external_user_id != profile_external_user_id:
logger.warning(f"Overriding external_user_id {external_user_id} with profile's external_user_id {profile_external_user_id}")
if 'oauth_app_id' in config_data:
server_config['oauth_app_id'] = config_data['oauth_app_id']
return profile_external_user_id
else:
logger.error(f"Profile {profile_id} not found")
return None
except Exception as e:
logger.error(f"Failed to resolve profile {profile_id}: {str(e)}")
return None
def _register_custom_tools(self, tools, server_name: str, enabled_tools: List[str], custom_type: str, server_config: Dict[str, Any]):
tools_registered = 0
for tool in tools:
tool_name_from_server = tool.name
if not enabled_tools or tool_name_from_server in enabled_tools:
tool_name = f"custom_{server_name.replace(' ', '_').lower()}_{tool_name_from_server}"
self.custom_tools[tool_name] = {
'name': tool_name,
'description': tool.description,
'parameters': tool.inputSchema,
'server': server_name,
'original_name': tool_name_from_server,
'is_custom': True,
'custom_type': custom_type,
'custom_config': server_config
}
tools_registered += 1
# logger.debug(f"Registered custom tool: {tool_name}")
# logger.debug(f"Successfully initialized custom MCP {server_name} with {tools_registered} tools")
def _register_custom_tools_from_info(self, tools_info: List[Dict[str, Any]], server_name: str, enabled_tools: List[str], custom_type: str, server_config: Dict[str, Any]):
tools_registered = 0
for tool_info in tools_info:
tool_name_from_server = tool_info['name']
if not enabled_tools or tool_name_from_server in enabled_tools:
tool_name = f"custom_{server_name.replace(' ', '_').lower()}_{tool_name_from_server}"
self.custom_tools[tool_name] = {
'name': tool_name,
'description': tool_info['description'],
'parameters': tool_info['input_schema'],
'server': server_name,
'original_name': tool_name_from_server,
'is_custom': True,
'custom_type': custom_type,
'custom_config': server_config
}
tools_registered += 1
def get_custom_tools(self) -> Dict[str, Dict[str, Any]]:
return self.custom_tools.copy() |