| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149 |
- """
- 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
|