tool_exposure.py 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149
  1. """
  2. Exposition des outils au protocole MCP.
  3. Génère la liste des outils disponibles au format MCP et les mappe aux handlers.
  4. """
  5. import logging
  6. from typing import Dict, Any, List, Callable
  7. import asyncio
  8. from mcp_server.tools.tool_class import Tool
  9. from mcp_server.tools.resource.create_resource import create_resource_tool
  10. from mcp_server.tools.resource.get_resource import get_resource_tool
  11. from mcp_server.tools.resource.update_resource import update_resource_tool
  12. from mcp_server.mcp.request_validator import RequestValidator
  13. from mcp_server.mcp.response_formatter import ResponseFormatter
  14. from mcp_server.core.errors import InvalidToolCallError
  15. logger = logging.getLogger(__name__)
  16. class ToolExposure:
  17. """Gestionnaire d'exposition des outils MCP."""
  18. def __init__(self):
  19. """Initialiser l'exposition des outils."""
  20. self.tools = {
  21. "create_resource": create_resource_tool,
  22. "get_resource": get_resource_tool,
  23. "update_resource": update_resource_tool,
  24. }
  25. self.tools_schema = self._generate_tools_schema()
  26. def _generate_tools_schema(self) -> List[Dict[str, Any]]:
  27. """
  28. Générer le schéma JSON des outils pour le protocole MCP.
  29. Returns:
  30. Liste des outils au format MCP
  31. """
  32. tools_schema = []
  33. for tool_name, tool in self.tools.items():
  34. # Convertir les paramètres du format Tool au format MCP
  35. parameters_schema = {}
  36. for param_name, param in tool.parameters.items():
  37. parameters_schema[param_name] = {
  38. "type": param.type,
  39. "description": param.description,
  40. "required": param.required,
  41. }
  42. if param.default is not None:
  43. parameters_schema[param_name]["default"] = param.default
  44. tool_schema = {
  45. "name": tool.name,
  46. "description": tool.description,
  47. "parameters": parameters_schema,
  48. "remarks": tool.remarks,
  49. }
  50. tools_schema.append(tool_schema)
  51. logger.info(f"Exposed {len(tools_schema)} tools to MCP")
  52. return tools_schema
  53. def get_tools_schema(self) -> List[Dict[str, Any]]:
  54. """
  55. Obtenir le schéma de tous les outils.
  56. Returns:
  57. Liste des outils
  58. """
  59. return self.tools_schema
  60. def get_tools_dict(self) -> Dict[str, Dict[str, Any]]:
  61. """
  62. Obtenir un dictionnaire des outils pour validation.
  63. Returns:
  64. Dict {tool_name: {parameters: {...}}}
  65. """
  66. tools_dict = {}
  67. for schema in self.tools_schema:
  68. tools_dict[schema["name"]] = {
  69. "parameters": schema["parameters"]
  70. }
  71. return tools_dict
  72. async def call_tool(self, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
  73. """
  74. Appeler un outil avec ses paramètres.
  75. Args:
  76. tool_name: Nom de l'outil
  77. parameters: Paramètres de l'appel
  78. Returns:
  79. Réponse de l'outil
  80. Raises:
  81. InvalidToolCallError: Si l'appel d'outil est invalide
  82. """
  83. # Valider l'appel d'outil
  84. is_valid, error_msg = RequestValidator.validate_tool_call(
  85. {"tool": tool_name, "parameters": parameters},
  86. self.get_tools_dict()
  87. )
  88. if not is_valid:
  89. logger.error(f"Invalid tool call: {error_msg}")
  90. raise InvalidToolCallError(error_msg)
  91. # Obtenir l'outil
  92. if tool_name not in self.tools:
  93. raise InvalidToolCallError(f"Unknown tool: {tool_name}")
  94. tool = self.tools[tool_name]
  95. # Appeler le handler
  96. try:
  97. logger.info(f"Calling tool: {tool_name} with parameters: {parameters}")
  98. response = await tool.handler(**parameters)
  99. # Formater la réponse
  100. formatted_response = ResponseFormatter.format_tool_response(response)
  101. logger.debug(f"Tool response: {formatted_response}")
  102. return formatted_response
  103. except Exception as e:
  104. logger.error(f"Error calling tool {tool_name}: {str(e)}")
  105. return ResponseFormatter.format_error_response(
  106. 500,
  107. f"Error executing tool: {str(e)}"
  108. )
  109. # Instance globale du gestionnaire d'exposition
  110. _tool_exposure: ToolExposure = None
  111. def get_tool_exposure() -> ToolExposure:
  112. """
  113. Obtenir l'instance globale du gestionnaire d'exposition.
  114. Returns:
  115. Instance de ToolExposure
  116. """
  117. global _tool_exposure
  118. if _tool_exposure is None:
  119. _tool_exposure = ToolExposure()
  120. return _tool_exposure