Refactor MCP tool handling to use hardcoded tool definitions and improve return value handling in health check and tool calls

routes/mcp_routes.py

@@ -86,8 +86,15 @@ class GenerateArgumentRequest(BaseModel):
 async def mcp_health():
     """Health check pour le serveur MCP"""
     try:
-        tools = mcp_server.list_tools()
-        tool_names = [tool.name for tool in tools] if tools else []
+        # Liste hardcodée des outils disponibles (plus fiable)
+        tool_names = [
+            "detect_stance",
+            "match_keypoint_argument",
+            "transcribe_audio",
+            "generate_speech",
+            "generate_argument",
+            "health_check"
+        ]
         return {
             "status": "healthy",
             "tools": tool_names,
@@ -101,15 +108,78 @@ async def mcp_health():
 async def list_mcp_tools():
     """Liste tous les outils MCP disponibles"""
     try:
-        tools = mcp_server.list_tools()
-        tool_list = []
-        for tool in tools:
-            tool_info = ToolInfo(
-                name=tool.name,
-                description=tool.description or "",
-                input_schema=tool.inputSchema if hasattr(tool, 'inputSchema') else {}
+        # Définir manuellement les outils avec leurs schémas
+        tool_list = [
+            ToolInfo(
+                name="detect_stance",
+                description="Détecte si un argument est PRO ou CON pour un topic donné",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "topic": {"type": "string", "description": "Le sujet du débat"},
+                        "argument": {"type": "string", "description": "L'argument à analyser"}
+                    },
+                    "required": ["topic", "argument"]
+                }
+            ),
+            ToolInfo(
+                name="match_keypoint_argument",
+                description="Détermine si un argument correspond à un keypoint",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "argument": {"type": "string", "description": "L'argument à évaluer"},
+                        "key_point": {"type": "string", "description": "Le keypoint de référence"}
+                    },
+                    "required": ["argument", "key_point"]
+                }
+            ),
+            ToolInfo(
+                name="transcribe_audio",
+                description="Convertit un fichier audio en texte",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "audio_path": {"type": "string", "description": "Chemin vers le fichier audio"}
+                    },
+                    "required": ["audio_path"]
+                }
+            ),
+            ToolInfo(
+                name="generate_speech",
+                description="Convertit du texte en fichier audio",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "text": {"type": "string", "description": "Texte à convertir en parole"},
+                        "voice": {"type": "string", "description": "Voix à utiliser", "default": "Aaliyah-PlayAI"},
+                        "format": {"type": "string", "description": "Format audio", "default": "wav"}
+                    },
+                    "required": ["text"]
+                }
+            ),
+            ToolInfo(
+                name="generate_argument",
+                description="Génère un argument de débat à partir d'un input utilisateur",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "user_input": {"type": "string", "description": "Input utilisateur pour générer l'argument"},
+                        "conversation_id": {"type": "string", "description": "ID de conversation (optionnel)"}
+                    },
+                    "required": ["user_input"]
+                }
+            ),
+            ToolInfo(
+                name="health_check",
+                description="Health check pour le serveur MCP",
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
             )
-            tool_list.append(tool_info)
+        ]
         
         return ToolListResponse(tools=tool_list, count=len(tool_list))
     except Exception as e:
@@ -121,12 +191,25 @@ async def call_mcp_tool(request: ToolCallRequest):
     """Appelle un outil MCP par son nom avec des arguments"""
     try:
         result = mcp_server.call_tool(request.tool_name, request.arguments)
-        # Convertir en dict si nécessaire
-        if not isinstance(result, dict):
-            result = {"result": result}
+        # Gérer différents types de retours
+        if isinstance(result, dict):
+            final_result = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            # Si c'est une liste de ContentBlock, extraire le contenu
+            if hasattr(result[0], 'text'):
+                import json
+                try:
+                    final_result = json.loads(result[0].text) if result[0].text else {}
+                except json.JSONDecodeError:
+                    final_result = {"text": result[0].text} if result[0].text else {}
+            else:
+                final_result = {"result": result[0] if result else {}}
+        else:
+            final_result = {"result": result}
+        
         return ToolCallResponse(
             success=True,
-            result=result,
+            result=final_result,
             tool_name=request.tool_name
         )
     except Exception as e:
@@ -144,13 +227,20 @@ async def call_mcp_tool(request: ToolCallRequest):
 async def mcp_detect_stance(request: DetectStanceRequest) -> Dict[str, Any]:
     """Détecte si un argument est PRO ou CON pour un topic donné"""
     try:
+        # Appeler directement via call_tool
         result = mcp_server.call_tool("detect_stance", {
             "topic": request.topic,
             "argument": request.argument
         })
-        # S'assurer que le résultat est un dict
+        # Gérer différents types de retours
         if isinstance(result, dict):
             return result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            # Si c'est une liste de ContentBlock, extraire le contenu
+            if hasattr(result[0], 'text'):
+                import json
+                return json.loads(result[0].text) if result[0].text else {}
+            return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in detect_stance: {e}")
@@ -164,8 +254,14 @@ async def mcp_match_keypoint(request: MatchKeypointRequest) -> Dict[str, Any]:
             "argument": request.argument,
             "key_point": request.key_point
         })
+        # Gérer différents types de retours
         if isinstance(result, dict):
             return result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                import json
+                return json.loads(result[0].text) if result[0].text else {}
+            return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in match_keypoint_argument: {e}")
@@ -178,9 +274,13 @@ async def mcp_transcribe_audio(request: TranscribeAudioRequest) -> Dict[str, str
         result = mcp_server.call_tool("transcribe_audio", {
             "audio_path": request.audio_path
         })
-        # Le résultat est déjà une string
+        # Gérer différents types de retours
         if isinstance(result, str):
             return {"text": result}
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                return {"text": result[0].text}
+            return {"text": str(result[0])}
         return {"text": str(result)}
     except Exception as e:
         logger.error(f"Error in transcribe_audio: {e}")
@@ -195,9 +295,13 @@ async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
             "voice": request.voice,
             "format": request.format
         })
-        # Le résultat est déjà une string (chemin du fichier)
+        # Gérer différents types de retours
         if isinstance(result, str):
             return {"audio_path": result}
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                return {"audio_path": result[0].text}
+            return {"audio_path": str(result[0])}
         return {"audio_path": str(result)}
     except Exception as e:
         logger.error(f"Error in generate_speech: {e}")
@@ -211,9 +315,13 @@ async def mcp_generate_argument(request: GenerateArgumentRequest) -> Dict[str, s
             "user_input": request.user_input,
             "conversation_id": request.conversation_id
         })
-        # Le résultat est déjà une string
+        # Gérer différents types de retours
         if isinstance(result, str):
             return {"argument": result}
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                return {"argument": result[0].text}
+            return {"argument": str(result[0])}
         return {"argument": str(result)}
     except Exception as e:
         logger.error(f"Error in generate_argument: {e}")
@@ -224,8 +332,17 @@ async def mcp_tool_health_check() -> Dict[str, Any]:
     """Health check via l'outil MCP"""
     try:
         result = mcp_server.call_tool("health_check", {})
+        # Gérer différents types de retours
         if isinstance(result, dict):
             return result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                import json
+                try:
+                    return json.loads(result[0].text) if result[0].text else {}
+                except json.JSONDecodeError:
+                    return {"text": result[0].text} if result[0].text else {}
+            return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in health_check tool: {e}")

services/mcp_service.py

@@ -63,8 +63,15 @@ def get_debate_prompt() -> str:
 def health_check() -> Dict[str, Any]:
     """Health check pour le serveur MCP"""
     try:
-        tools = mcp_server.list_tools()
-        tool_names = [tool.name for tool in tools] if tools else []
+        # Liste hardcodée pour éviter les problèmes avec list_tools()
+        tool_names = [
+            "detect_stance",
+            "match_keypoint_argument",
+            "transcribe_audio",
+            "generate_speech",
+            "generate_argument",
+            "health_check"
+        ]
     except Exception:
         tool_names = []
     return {"status": "healthy", "tools": tool_names}