""" Exposition des outils au protocole MCP. Génère la liste des outils disponibles au format MCP et les mappe aux handlers. """ import logging from typing import Dict, Any, List, Callable import asyncio from mcp_server.tools.tool_class import Tool from mcp_server.tools.resource.create_resource import create_resource_tool from mcp_server.tools.resource.get_resource import get_resource_tool from mcp_server.tools.resource.update_resource import update_resource_tool from mcp_server.mcp.request_validator import RequestValidator from mcp_server.mcp.response_formatter import ResponseFormatter from mcp_server.core.errors import InvalidToolCallError logger = logging.getLogger(__name__) class ToolExposure: """Gestionnaire d'exposition des outils MCP.""" def __init__(self): """Initialiser l'exposition des outils.""" self.tools = { "create_resource": create_resource_tool, "get_resource": get_resource_tool, "update_resource": update_resource_tool, } self.tools_schema = self._generate_tools_schema() def _generate_tools_schema(self) -> List[Dict[str, Any]]: """ Générer le schéma JSON des outils pour le protocole MCP. Returns: Liste des outils au format MCP """ tools_schema = [] for tool_name, tool in self.tools.items(): # Convertir les paramètres du format Tool au format MCP parameters_schema = {} for param_name, param in tool.parameters.items(): parameters_schema[param_name] = { "type": param.type, "description": param.description, "required": param.required, } if param.default is not None: parameters_schema[param_name]["default"] = param.default tool_schema = { "name": tool.name, "description": tool.description, "parameters": parameters_schema, "remarks": tool.remarks, } tools_schema.append(tool_schema) logger.info(f"Exposed {len(tools_schema)} tools to MCP") return tools_schema def get_tools_schema(self) -> List[Dict[str, Any]]: """ Obtenir le schéma de tous les outils. Returns: Liste des outils """ return self.tools_schema def get_tools_dict(self) -> Dict[str, Dict[str, Any]]: """ Obtenir un dictionnaire des outils pour validation. Returns: Dict {tool_name: {parameters: {...}}} """ tools_dict = {} for schema in self.tools_schema: tools_dict[schema["name"]] = { "parameters": schema["parameters"] } return tools_dict async def call_tool(self, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]: """ Appeler un outil avec ses paramètres. Args: tool_name: Nom de l'outil parameters: Paramètres de l'appel Returns: Réponse de l'outil Raises: InvalidToolCallError: Si l'appel d'outil est invalide """ # Valider l'appel d'outil is_valid, error_msg = RequestValidator.validate_tool_call( {"tool": tool_name, "parameters": parameters}, self.get_tools_dict() ) if not is_valid: logger.error(f"Invalid tool call: {error_msg}") raise InvalidToolCallError(error_msg) # Obtenir l'outil if tool_name not in self.tools: raise InvalidToolCallError(f"Unknown tool: {tool_name}") tool = self.tools[tool_name] # Appeler le handler try: logger.info(f"Calling tool: {tool_name} with parameters: {parameters}") response = await tool.handler(**parameters) # Formater la réponse formatted_response = ResponseFormatter.format_tool_response(response) logger.debug(f"Tool response: {formatted_response}") return formatted_response except Exception as e: logger.error(f"Error calling tool {tool_name}: {str(e)}") return ResponseFormatter.format_error_response( 500, f"Error executing tool: {str(e)}" ) # Instance globale du gestionnaire d'exposition _tool_exposure: ToolExposure = None def get_tool_exposure() -> ToolExposure: """ Obtenir l'instance globale du gestionnaire d'exposition. Returns: Instance de ToolExposure """ global _tool_exposure if _tool_exposure is None: _tool_exposure = ToolExposure() return _tool_exposure