Enhance MCP tool performance by implementing asynchronous handling in tool calls

routes/mcp_routes.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter, HTTPException
 from typing import Dict, Any, Optional
 from pydantic import BaseModel, Field
 import logging
+import json
 
 from services.mcp_service import mcp_server
 from models.mcp_models import ToolListResponse, ToolInfo, ToolCallRequest, ToolCallResponse
@@ -191,17 +192,27 @@ async def call_mcp_tool(request: ToolCallRequest):
     """Appelle un outil MCP par son nom avec des arguments"""
     try:
         result = await mcp_server.call_tool(request.tool_name, request.arguments)
-        # Gérer différents types de retours
+        # Gérer différents types de retours MCP
         if isinstance(result, dict):
-            final_result = result
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        final_result = json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        final_result = {"text": content_block.text}
+                else:
+                    final_result = result
+            else:
+                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
+            if hasattr(result[0], 'text') and result[0].text:
                 try:
-                    final_result = json.loads(result[0].text) if result[0].text else {}
+                    final_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
-                    final_result = {"text": result[0].text} if result[0].text else {}
+                    final_result = {"text": result[0].text}
             else:
                 final_result = {"result": result[0] if result else {}}
         else:
@@ -232,19 +243,29 @@ async def mcp_detect_stance(request: DetectStanceRequest) -> Dict[str, Any]:
             "topic": request.topic,
             "argument": request.argument
         })
-        # Gérer différents types de retours
+        # Gérer différents types de retours MCP
         if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        return json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        return {"text": content_block.text}
             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 {}
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    return json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    return {"text": result[0].text}
             return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in detect_stance: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool detect_stance: {e}")
 
 @router.post("/tools/match-keypoint", summary="Matcher un argument avec un keypoint")
 async def mcp_match_keypoint(request: MatchKeypointRequest) -> Dict[str, Any]:
@@ -254,18 +275,28 @@ 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
+        # Gérer différents types de retours MCP
         if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        return json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        return {"text": content_block.text}
             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 {}
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    return json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    return {"text": result[0].text}
             return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in match_keypoint_argument: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool match_keypoint_argument: {e}")
 
 @router.post("/tools/transcribe-audio", summary="Transcrire un audio en texte")
 async def mcp_transcribe_audio(request: TranscribeAudioRequest) -> Dict[str, str]:
@@ -274,17 +305,30 @@ async def mcp_transcribe_audio(request: TranscribeAudioRequest) -> Dict[str, str
         result = await mcp_server.call_tool("transcribe_audio", {
             "audio_path": request.audio_path
         })
-        # Gérer différents types de retours
-        if isinstance(result, str):
+        # Gérer différents types de retours MCP
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    return {"text": content_block.text}
+            # Si c'est un dict simple, essayer d'extraire le texte
+            if "text" in result:
+                return {"text": result["text"]}
+            return {"text": str(result)}
+        elif 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 FileNotFoundError as e:
+        logger.error(f"File not found in transcribe_audio: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool transcribe_audio: {e}")
     except Exception as e:
         logger.error(f"Error in transcribe_audio: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool transcribe_audio: {e}")
 
 @router.post("/tools/generate-speech", summary="Générer de la parole à partir de texte")
 async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
@@ -295,8 +339,18 @@ async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
             "voice": request.voice,
             "format": request.format
         })
-        # Gérer différents types de retours
-        if isinstance(result, str):
+        # Gérer différents types de retours MCP
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    return {"audio_path": content_block.text}
+            # Si c'est un dict simple, essayer d'extraire le chemin
+            if "audio_path" in result:
+                return {"audio_path": result["audio_path"]}
+            return {"audio_path": str(result)}
+        elif isinstance(result, str):
             return {"audio_path": result}
         elif isinstance(result, (list, tuple)) and len(result) > 0:
             if hasattr(result[0], 'text'):
@@ -305,7 +359,7 @@ async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
         return {"audio_path": str(result)}
     except Exception as e:
         logger.error(f"Error in generate_speech: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool generate_speech: {e}")
 
 @router.post("/tools/generate-argument", summary="Générer un argument de débat")
 async def mcp_generate_argument(request: GenerateArgumentRequest) -> Dict[str, str]:
@@ -315,8 +369,18 @@ async def mcp_generate_argument(request: GenerateArgumentRequest) -> Dict[str, s
             "user_input": request.user_input,
             "conversation_id": request.conversation_id
         })
-        # Gérer différents types de retours
-        if isinstance(result, str):
+        # Gérer différents types de retours MCP
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    return {"argument": content_block.text}
+            # Si c'est un dict simple, essayer d'extraire l'argument
+            if "argument" in result:
+                return {"argument": result["argument"]}
+            return {"argument": str(result)}
+        elif isinstance(result, str):
             return {"argument": result}
         elif isinstance(result, (list, tuple)) and len(result) > 0:
             if hasattr(result[0], 'text'):
@@ -325,25 +389,33 @@ async def mcp_generate_argument(request: GenerateArgumentRequest) -> Dict[str, s
         return {"argument": str(result)}
     except Exception as e:
         logger.error(f"Error in generate_argument: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool generate_argument: {e}")
 
 @router.get("/tools/health-check", summary="Health check MCP (outil)")
 async def mcp_tool_health_check() -> Dict[str, Any]:
     """Health check via l'outil MCP"""
     try:
         result = await mcp_server.call_tool("health_check", {})
-        # Gérer différents types de retours
+        # Gérer différents types de retours MCP
+        import json
         if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        return json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        return {"text": content_block.text}
             return result
         elif isinstance(result, (list, tuple)) and len(result) > 0:
-            if hasattr(result[0], 'text'):
-                import json
+            if hasattr(result[0], 'text') and result[0].text:
                 try:
-                    return json.loads(result[0].text) if result[0].text else {}
+                    return json.loads(result[0].text)
                 except json.JSONDecodeError:
-                    return {"text": result[0].text} if result[0].text else {}
+                    return {"text": result[0].text}
             return {"result": result[0] if result else {}}
         return {"result": result}
     except Exception as e:
         logger.error(f"Error in health_check tool: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error executing tool health_check: {e}")