Add response models for new MCP tools: DetectStance, MatchKeypoint, TranscribeAudio, GenerateSpeech, and GenerateArgument

models/__init__.py

@@ -30,6 +30,11 @@ from .mcp_models import (
     ToolListResponse,
     ResourceInfo,
     ResourceListResponse,
+    DetectStanceResponse,
+    MatchKeypointResponse,
+    TranscribeAudioResponse,
+    GenerateSpeechResponse,
+    GenerateArgumentResponse,
 )
 
 __all__ = [
@@ -53,4 +58,9 @@ __all__ = [
     "ToolListResponse",
     "ResourceInfo",
     "ResourceListResponse",
+    "DetectStanceResponse",
+    "MatchKeypointResponse",
+    "TranscribeAudioResponse",
+    "GenerateSpeechResponse",
+    "GenerateArgumentResponse",
 ]

models/mcp_models.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, ConfigDict
 from typing import Any, Dict, List, Optional
 
 class ToolCallRequest(BaseModel):
@@ -13,6 +13,82 @@ class ToolCallResponse(BaseModel):
     error: Optional[str] = None
     tool_name: str
 
+# Response models for individual MCP tools
+class DetectStanceResponse(BaseModel):
+    """Response model for stance detection"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "predicted_stance": "PRO",
+                "confidence": 0.9598,
+                "probability_con": 0.0402,
+                "probability_pro": 0.9598
+            }
+        }
+    )
+    
+    predicted_stance: str = Field(..., description="PRO or CON")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    probability_con: float = Field(..., ge=0.0, le=1.0)
+    probability_pro: float = Field(..., ge=0.0, le=1.0)
+
+class MatchKeypointResponse(BaseModel):
+    """Response model for keypoint matching"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "prediction": 1,
+                "label": "apparie",
+                "confidence": 0.8157,
+                "probabilities": {
+                    "non_apparie": 0.1843,
+                    "apparie": 0.8157
+                }
+            }
+        }
+    )
+    
+    prediction: int = Field(..., description="1 = apparie, 0 = non_apparie")
+    label: str = Field(..., description="apparie or non_apparie")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    probabilities: Dict[str, float] = Field(..., description="Dictionary of class probabilities")
+
+class TranscribeAudioResponse(BaseModel):
+    """Response model for audio transcription"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "text": "Hello, this is the transcribed text from the audio file."
+            }
+        }
+    )
+    
+    text: str = Field(..., description="Transcribed text from audio")
+
+class GenerateSpeechResponse(BaseModel):
+    """Response model for speech generation"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "audio_path": "temp_audio/tts_e9b78164.wav"
+            }
+        }
+    )
+    
+    audio_path: str = Field(..., description="Path to generated audio file")
+
+class GenerateArgumentResponse(BaseModel):
+    """Response model for argument generation"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "argument": "Climate change is a pressing issue that requires immediate action..."
+            }
+        }
+    )
+    
+    argument: str = Field(..., description="Generated debate argument")
+
 class ResourceInfo(BaseModel):
     """Information about an MCP resource"""
     uri: str

routes/mcp_routes.py

@@ -7,7 +7,17 @@ import logging
 import json
 
 from services.mcp_service import mcp_server
-from models.mcp_models import ToolListResponse, ToolInfo, ToolCallRequest, ToolCallResponse
+from models.mcp_models import (
+    ToolListResponse, 
+    ToolInfo, 
+    ToolCallRequest, 
+    ToolCallResponse,
+    DetectStanceResponse,
+    MatchKeypointResponse,
+    TranscribeAudioResponse,
+    GenerateSpeechResponse,
+    GenerateArgumentResponse
+)
 
 router = APIRouter(prefix="/api/v1/mcp", tags=["MCP"])
 logger = logging.getLogger(__name__)
@@ -234,8 +244,8 @@ async def call_mcp_tool(request: ToolCallRequest):
 
 # ===== Routes individuelles pour chaque outil (pour Swagger) =====
 
-@router.post("/tools/detect-stance", summary="Détecter la stance d'un argument")
-async def mcp_detect_stance(request: DetectStanceRequest) -> Dict[str, Any]:
+@router.post("/tools/detect-stance", response_model=DetectStanceResponse, summary="Détecter la stance d'un argument")
+async def mcp_detect_stance(request: DetectStanceRequest):
     """Détecte si un argument est PRO ou CON pour un topic donné"""
     try:
         # Appeler directement via call_tool (async)
@@ -243,95 +253,144 @@ async def mcp_detect_stance(request: DetectStanceRequest) -> Dict[str, Any]:
             "topic": request.topic,
             "argument": request.argument
         })
-        # Gérer différents types de retours MCP
+        
+        # Extraire les données du résultat MCP
+        parsed_result = None
         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)
+                        parsed_result = json.loads(content_block.text)
                     except json.JSONDecodeError:
-                        return {"text": content_block.text}
-            return result
+                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_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') and result[0].text:
                 try:
-                    return json.loads(result[0].text)
+                    parsed_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
-                    return {"text": result[0].text}
-            return {"result": result[0] if result else {}}
-        return {"result": result}
+                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+        else:
+            parsed_result = result
+        
+        if not parsed_result:
+            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        
+        # Construire la réponse structurée
+        response = DetectStanceResponse(
+            predicted_stance=parsed_result["predicted_stance"],
+            confidence=parsed_result["confidence"],
+            probability_con=parsed_result["probability_con"],
+            probability_pro=parsed_result["probability_pro"]
+        )
+        
+        logger.info(f"Stance prediction: {response.predicted_stance} (conf={response.confidence:.4f})")
+        return response
+        
+    except HTTPException:
+        raise
     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}")
 
-@router.post("/tools/match-keypoint", summary="Matcher un argument avec un keypoint")
-async def mcp_match_keypoint(request: MatchKeypointRequest) -> Dict[str, Any]:
+@router.post("/tools/match-keypoint", response_model=MatchKeypointResponse, summary="Matcher un argument avec un keypoint")
+async def mcp_match_keypoint(request: MatchKeypointRequest):
     """Détermine si un argument correspond à un keypoint"""
     try:
         result = await mcp_server.call_tool("match_keypoint_argument", {
             "argument": request.argument,
             "key_point": request.key_point
         })
-        # Gérer différents types de retours MCP
+        
+        # Extraire les données du résultat MCP
+        parsed_result = None
         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)
+                        parsed_result = json.loads(content_block.text)
                     except json.JSONDecodeError:
-                        return {"text": content_block.text}
-            return result
+                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_result = result
         elif isinstance(result, (list, tuple)) and len(result) > 0:
             if hasattr(result[0], 'text') and result[0].text:
                 try:
-                    return json.loads(result[0].text)
+                    parsed_result = json.loads(result[0].text)
                 except json.JSONDecodeError:
-                    return {"text": result[0].text}
-            return {"result": result[0] if result else {}}
-        return {"result": result}
+                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+        else:
+            parsed_result = result
+        
+        if not parsed_result:
+            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        
+        # Construire la réponse structurée
+        response = MatchKeypointResponse(
+            prediction=parsed_result["prediction"],
+            label=parsed_result["label"],
+            confidence=parsed_result["confidence"],
+            probabilities=parsed_result["probabilities"]
+        )
+        
+        logger.info(f"Keypoint matching: {response.label} (conf={response.confidence:.4f})")
+        return response
+        
+    except HTTPException:
+        raise
     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", summary="Transcrire un audio en texte")
-async def mcp_transcribe_audio(request: TranscribeAudioRequest) -> Dict[str, str]:
+@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"""
     try:
         result = await mcp_server.call_tool("transcribe_audio", {
             "audio_path": request.audio_path
         })
-        # Gérer différents types de retours MCP
+        
+        # Extraire le texte du résultat MCP
+        transcribed_text = None
         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)}
+                    transcribed_text = content_block.text
+            elif "text" in result:
+                transcribed_text = result["text"]
         elif isinstance(result, str):
-            return {"text": result}
+            transcribed_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)}
+                transcribed_text = result[0].text
+            else:
+                transcribed_text = str(result[0])
+        else:
+            transcribed_text = str(result)
+        
+        if not transcribed_text:
+            raise HTTPException(status_code=500, detail="Empty transcription result from MCP tool")
+        
+        response = TranscribeAudioResponse(text=transcribed_text)
+        logger.info(f"Audio transcribed: {len(transcribed_text)} characters")
+        return response
+        
     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 HTTPException:
+        raise
     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}")
 
-@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]:
+@router.post("/tools/generate-speech", response_model=GenerateSpeechResponse, summary="Générer de la parole à partir de texte")
+async def mcp_generate_speech(request: GenerateSpeechRequest):
     """Convertit du texte en fichier audio"""
     try:
         result = await mcp_server.call_tool("generate_speech", {
@@ -339,54 +398,76 @@ async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
             "voice": request.voice,
             "format": request.format
         })
-        # Gérer différents types de retours MCP
+        
+        # Extraire le chemin audio du résultat MCP
+        audio_path = None
         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)}
+                    audio_path = content_block.text
+            elif "audio_path" in result:
+                audio_path = result["audio_path"]
         elif isinstance(result, str):
-            return {"audio_path": result}
+            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)}
+                audio_path = result[0].text
+            else:
+                audio_path = str(result[0])
+        else:
+            audio_path = str(result)
+        
+        if not audio_path:
+            raise HTTPException(status_code=500, detail="Empty audio path from MCP tool")
+        
+        response = GenerateSpeechResponse(audio_path=audio_path)
+        logger.info(f"Speech generated: {audio_path}")
+        return response
+        
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error in generate_speech: {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]:
+@router.post("/tools/generate-argument", response_model=GenerateArgumentResponse, summary="Générer un argument de débat")
+async def mcp_generate_argument(request: GenerateArgumentRequest):
     """Génère un argument de débat à partir d'un input utilisateur"""
     try:
         result = await mcp_server.call_tool("generate_argument", {
             "user_input": request.user_input,
             "conversation_id": request.conversation_id
         })
-        # Gérer différents types de retours MCP
+        
+        # Extraire l'argument du résultat MCP
+        generated_argument = None
         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)}
+                    generated_argument = content_block.text
+            elif "argument" in result:
+                generated_argument = result["argument"]
         elif isinstance(result, str):
-            return {"argument": result}
+            generated_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)}
+                generated_argument = result[0].text
+            else:
+                generated_argument = str(result[0])
+        else:
+            generated_argument = str(result)
+        
+        if not generated_argument:
+            raise HTTPException(status_code=500, detail="Empty argument from MCP tool")
+        
+        response = GenerateArgumentResponse(argument=generated_argument)
+        logger.info(f"Argument generated: {len(generated_argument)} characters")
+        return response
+        
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error in generate_argument: {e}")
         raise HTTPException(status_code=500, detail=f"Error executing tool generate_argument: {e}")