refactor: Remove GenerateArgumentRequest and GenerateArgumentResponse models; update generate_argument endpoint to accept topic and position parameters.

models/__init__.py

@@ -40,7 +40,6 @@ from .mcp_models import (
     MatchKeypointResponse,
     TranscribeAudioResponse,
     GenerateSpeechResponse,
-    GenerateArgumentResponse,
 )
 
 __all__ = [
@@ -71,5 +70,4 @@ __all__ = [
     "MatchKeypointResponse",
     "TranscribeAudioResponse",
     "GenerateSpeechResponse",
-    "GenerateArgumentResponse",
 ]

models/mcp_models.py

@@ -77,18 +77,6 @@ class GenerateSpeechResponse(BaseModel):
     
     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

@@ -15,9 +15,10 @@ from models.mcp_models import (
     DetectStanceResponse,
     MatchKeypointResponse,
     TranscribeAudioResponse,
-    GenerateSpeechResponse,
-    GenerateArgumentResponse
+    GenerateSpeechResponse
 )
+from models.generate import GenerateRequest, GenerateResponse
+from datetime import datetime
 
 router = APIRouter(prefix="/api/v1/mcp", tags=["MCP"])
 logger = logging.getLogger(__name__)
@@ -77,18 +78,6 @@ class GenerateSpeechRequest(BaseModel):
             }
         }
 
-class GenerateArgumentRequest(BaseModel):
-    """Request pour générer un argument"""
-    user_input: str = Field(..., description="Input utilisateur pour générer l'argument")
-    conversation_id: Optional[str] = Field(default=None, description="ID de conversation (optionnel)")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "user_input": "Generate an argument about climate change",
-                "conversation_id": "conv_123"
-            }
-        }
 
 
 # ===== Routes MCP =====
@@ -171,14 +160,14 @@ async def list_mcp_tools():
             ),
             ToolInfo(
                 name="generate_argument",
-                description="Génère un argument de débat à partir d'un input utilisateur",
+                description="Génère un argument de débat pour un topic et une position donnés",
                 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)"}
+                        "topic": {"type": "string", "description": "Le sujet du débat"},
+                        "position": {"type": "string", "description": "La position à prendre (positive ou negative)"}
                     },
-                    "required": ["user_input"]
+                    "required": ["topic", "position"]
                 }
             ),
             ToolInfo(
@@ -431,39 +420,48 @@ async def mcp_generate_speech(request: GenerateSpeechRequest):
         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", 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"""
+@router.post("/tools/generate-argument", response_model=GenerateResponse, summary="Générer un argument de débat")
+async def mcp_generate_argument(request: GenerateRequest):
+    """Génère un argument de débat pour un topic et une position donnés"""
     try:
         result = await mcp_server.call_tool("generate_argument", {
-            "user_input": request.user_input,
-            "conversation_id": request.conversation_id
+            "topic": request.topic,
+            "position": request.position
         })
         
-        # Extraire l'argument du résultat MCP
-        generated_argument = None
+        # Extraire les données du résultat MCP
+        parsed_result = None
         if isinstance(result, dict):
             if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
                 content_block = result["result"][0]
-                if hasattr(content_block, 'text'):
-                    generated_argument = content_block.text
-            elif "argument" in result:
-                generated_argument = result["argument"]
-        elif isinstance(result, str):
-            generated_argument = result
-        elif isinstance(result, (list, tuple)) and len(result) > 0:
-            if hasattr(result[0], 'text'):
-                generated_argument = result[0].text
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        parsed_result = json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
             else:
-                generated_argument = str(result[0])
+                parsed_result = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    parsed_result = json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
         else:
-            generated_argument = str(result)
+            parsed_result = result
+        
+        if not parsed_result:
+            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
         
-        if not generated_argument:
-            raise HTTPException(status_code=500, detail="Empty argument from MCP tool")
+        # 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", ""),
+            timestamp=datetime.now().isoformat()
+        )
         
-        response = GenerateArgumentResponse(argument=generated_argument)
-        logger.info(f"Argument generated: {len(generated_argument)} characters")
+        logger.info(f"Argument generated for topic '{request.topic}' with position '{request.position}': {len(response.argument)} characters")
         return response
         
     except HTTPException:

services/mcp_service.py

@@ -10,7 +10,7 @@ from services.stance_model_manager import stance_model_manager
 from services.label_model_manager import kpa_model_manager  
 from services.stt_service import speech_to_text
 from services.tts_service import text_to_speech
-from services.chat_service import generate_chat_response
+from services.generate_model_manager import generate_model_manager
 
 logger = logging.getLogger(__name__)
 
@@ -51,8 +51,16 @@ def generate_speech(text: str, voice: str = "Aaliyah-PlayAI", format: str = "wav
     return text_to_speech(text, voice, format)
 
 @mcp_server.tool()
-def generate_argument(user_input: str, conversation_id: str = None) -> str:
-    return generate_chat_response(user_input, conversation_id)
+def generate_argument(topic: str, position: str) -> Dict[str, Any]:
+    """Generate an argument for a given topic and position"""
+    if not generate_model_manager.model_loaded:
+        raise ValueError("Modèle de génération non chargé")
+    argument = generate_model_manager.generate(topic=topic, position=position)
+    return {
+        "topic": topic,
+        "position": position,
+        "argument": argument
+    }
 
 @mcp_server.resource("debate://prompt")
 def get_debate_prompt() -> str: