feat: Implement audio transcription and speech generation endpoints with file upload support and improved response handling

routes/mcp_routes.py

@@ -1,10 +1,14 @@
 """Routes pour exposer MCP via FastAPI pour Swagger UI"""
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, UploadFile, File
+from fastapi.responses import FileResponse
 from typing import Dict, Any, Optional
 from pydantic import BaseModel, Field
 import logging
 import json
+import tempfile
+import os
+from pathlib import Path
 
 from services.mcp_service import mcp_server
 from models.mcp_models import (
@@ -52,16 +56,6 @@ class MatchKeypointRequest(BaseModel):
             }
         }
 
-class TranscribeAudioRequest(BaseModel):
-    """Request pour transcrire un audio"""
-    audio_path: str = Field(..., description="Chemin vers le fichier audio")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "audio_path": "/path/to/audio.wav"
-            }
-        }
 
 class GenerateSpeechRequest(BaseModel):
     """Request pour générer de la parole"""
@@ -302,10 +296,10 @@ async def mcp_detect_stance(request: DetectStanceRequest):
             "argument": request.argument
         })
         
-        # Extraire les données du résultat MCP
+        # FastMCP avec json_response=True retourne directement le dict
         parsed_result = None
         if isinstance(result, dict):
-            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            # Vérifier si c'est un dict avec "result" contenant des ContentBlocks
             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:
@@ -313,7 +307,11 @@ async def mcp_detect_stance(request: DetectStanceRequest):
                         parsed_result = json.loads(content_block.text)
                     except json.JSONDecodeError:
                         raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+                else:
+                    # Si pas de text, utiliser le dict directement
+                    parsed_result = result
             else:
+                # Dict direct retourné par le tool
                 parsed_result = result
         elif isinstance(result, (list, tuple)) and len(result) > 0:
             if hasattr(result[0], 'text') and result[0].text:
@@ -321,11 +319,13 @@ async def mcp_detect_stance(request: DetectStanceRequest):
                     parsed_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
                     raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_result = result[0] if isinstance(result[0], dict) else result
         else:
             parsed_result = result
         
-        if not parsed_result:
-            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        if not parsed_result or not isinstance(parsed_result, dict):
+            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
         
         # Construire la réponse structurée
         response = DetectStanceResponse(
@@ -340,6 +340,9 @@ async def mcp_detect_stance(request: DetectStanceRequest):
         
     except HTTPException:
         raise
+    except KeyError as e:
+        logger.error(f"Missing key in detect_stance response: {e}")
+        raise HTTPException(status_code=500, detail=f"Invalid response format: missing {e}")
     except Exception as e:
         logger.error(f"Error in detect_stance: {e}")
         raise HTTPException(status_code=500, detail=f"Error executing tool detect_stance: {e}")
@@ -353,7 +356,7 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
             "key_point": request.key_point
         })
         
-        # Extraire les données du résultat MCP
+        # FastMCP avec json_response=True retourne directement le dict
         parsed_result = None
         if isinstance(result, dict):
             if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
@@ -363,6 +366,8 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
                         parsed_result = json.loads(content_block.text)
                     except json.JSONDecodeError:
                         raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+                else:
+                    parsed_result = result
             else:
                 parsed_result = result
         elif isinstance(result, (list, tuple)) and len(result) > 0:
@@ -371,11 +376,13 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
                     parsed_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
                     raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_result = result[0] if isinstance(result[0], dict) else result
         else:
             parsed_result = result
         
-        if not parsed_result:
-            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        if not parsed_result or not isinstance(parsed_result, dict):
+            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
         
         # Construire la réponse structurée
         response = MatchKeypointResponse(
@@ -390,16 +397,35 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
         
     except HTTPException:
         raise
+    except KeyError as e:
+        logger.error(f"Missing key in match_keypoint response: {e}")
+        raise HTTPException(status_code=500, detail=f"Invalid response format: missing {e}")
     except Exception as e:
         logger.error(f"Error in match_keypoint_argument: {e}")
         raise HTTPException(status_code=500, detail=f"Error executing tool match_keypoint_argument: {e}")
 
 @router.post("/tools/transcribe-audio", response_model=TranscribeAudioResponse, summary="Transcrire un audio en texte")
-async def mcp_transcribe_audio(request: TranscribeAudioRequest):
-    """Convertit un fichier audio en texte"""
+async def mcp_transcribe_audio(file: UploadFile = File(...)):
+    """Convertit un fichier audio en texte (upload de fichier)"""
+    # Vérifier le type de fichier
+    if not file.content_type or not file.content_type.startswith('audio/'):
+        raise HTTPException(status_code=400, detail="File must be an audio file")
+    
+    # Créer un fichier temporaire
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+        temp_path = temp_file.name
+        content = await file.read()
+        
+        if len(content) == 0:
+            os.unlink(temp_path)
+            raise HTTPException(status_code=400, detail="Audio file is empty")
+        
+        temp_file.write(content)
+    
     try:
+        # Appeler le service MCP avec le chemin temporaire
         result = await mcp_server.call_tool("transcribe_audio", {
-            "audio_path": request.audio_path
+            "audio_path": temp_path
         })
         
         # Extraire le texte du résultat MCP
@@ -436,10 +462,14 @@ async def mcp_transcribe_audio(request: TranscribeAudioRequest):
     except Exception as e:
         logger.error(f"Error in transcribe_audio: {e}")
         raise HTTPException(status_code=500, detail=f"Error executing tool transcribe_audio: {e}")
+    finally:
+        # Nettoyer le fichier temporaire
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
 
-@router.post("/tools/generate-speech", response_model=GenerateSpeechResponse, summary="Générer de la parole à partir de texte")
+@router.post("/tools/generate-speech", summary="Générer de la parole à partir de texte")
 async def mcp_generate_speech(request: GenerateSpeechRequest):
-    """Convertit du texte en fichier audio"""
+    """Convertit du texte en fichier audio (téléchargeable)"""
     try:
         result = await mcp_server.call_tool("generate_speech", {
             "text": request.text,
@@ -466,12 +496,35 @@ async def mcp_generate_speech(request: GenerateSpeechRequest):
         else:
             audio_path = str(result)
         
+        # Nettoyer le chemin si c'est une représentation string d'objet
+        if audio_path and isinstance(audio_path, str):
+            # Si c'est une représentation d'objet TextContent, extraire le chemin
+            if "text='" in audio_path and ".wav" in audio_path:
+                import re
+                match = re.search(r"text='([^']+)'", audio_path)
+                if match:
+                    audio_path = match.group(1)
+        
         if not audio_path:
             raise HTTPException(status_code=500, detail="Empty audio path from MCP tool")
         
-        response = GenerateSpeechResponse(audio_path=audio_path)
+        # Vérifier que le fichier existe
+        if not Path(audio_path).exists():
+            raise HTTPException(status_code=500, detail=f"Audio file not found: {audio_path}")
+        
+        # Déterminer le type MIME
+        media_type = "audio/wav" if request.format == "wav" else "audio/mpeg"
+        
+        # Retourner le fichier pour téléchargement
         logger.info(f"Speech generated: {audio_path}")
-        return response
+        return FileResponse(
+            path=audio_path,
+            filename=f"speech.{request.format}",
+            media_type=media_type,
+            headers={
+                "Content-Disposition": f"attachment; filename=speech.{request.format}"
+            }
+        )
         
     except HTTPException:
         raise
@@ -488,7 +541,7 @@ async def mcp_generate_argument(request: GenerateRequest):
             "position": request.position
         })
         
-        # Extraire les données du résultat MCP
+        # FastMCP avec json_response=True retourne directement le dict
         parsed_result = None
         if isinstance(result, dict):
             if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
@@ -497,7 +550,10 @@ async def mcp_generate_argument(request: GenerateRequest):
                     try:
                         parsed_result = json.loads(content_block.text)
                     except json.JSONDecodeError:
-                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+                        # Si ce n'est pas du JSON, c'est peut-être juste le texte
+                        parsed_result = {"argument": content_block.text}
+                else:
+                    parsed_result = result
             else:
                 parsed_result = result
         elif isinstance(result, (list, tuple)) and len(result) > 0:
@@ -505,18 +561,26 @@ async def mcp_generate_argument(request: GenerateRequest):
                 try:
                     parsed_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
-                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+                    parsed_result = {"argument": result[0].text}
+            else:
+                parsed_result = result[0] if isinstance(result[0], dict) else result
         else:
             parsed_result = result
         
-        if not parsed_result:
-            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        if not parsed_result or not isinstance(parsed_result, dict):
+            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
+        
+        # Extraire l'argument (peut être dans "argument" ou directement dans le dict)
+        argument_text = parsed_result.get("argument", "")
+        if not argument_text:
+            # Essayer de trouver le texte ailleurs dans la réponse
+            argument_text = str(parsed_result)
         
         # Construire la réponse structurée
         response = GenerateResponse(
             topic=parsed_result.get("topic", request.topic),
             position=parsed_result.get("position", request.position),
-            argument=parsed_result.get("argument", ""),
+            argument=argument_text,
             timestamp=datetime.now().isoformat()
         )