Update chat endpoints

routes/voice_chat_routes.py

@@ -1,15 +1,17 @@
-from fastapi import APIRouter, UploadFile, File, HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi import APIRouter, UploadFile, File, HTTPException, Query
+from fastapi.responses import FileResponse, StreamingResponse
 from pydantic import BaseModel
 from typing import Optional
 import tempfile
 import os
 from pathlib import Path
+import uuid
 import io
 
 from services.stt_service import speech_to_text
 from services.tts_service import text_to_speech
-from services.chat_service import generate_chat_response  # Votre service de chatbot existant
+# Assurez-vous que ce service existe et fonctionne correctement
+from services.chat_service import generate_chat_response
 
 router = APIRouter(prefix="/voice-chat", tags=["Voice Chat"])
 
@@ -22,10 +24,13 @@ class VoiceChatResponse(BaseModel):
     audio_url: Optional[str] = None
     conversation_id: str
 
+# Stockage temporaire pour l'audio généré
+audio_cache = {}
+
 @router.post("/voice", response_model=VoiceChatResponse)
 async def voice_chat_endpoint(
     file: UploadFile = File(...),
-    conversation_id: Optional[str] = None
+    conversation_id: Optional[str] = Query(None)
 ):
     """
     Point d'entrée unique pour le chat vocal:
@@ -34,61 +39,88 @@ async def voice_chat_endpoint(
     3. TTS: Réponse → Audio
     """
     # 1. Vérifier le fichier audio
-    if not file.content_type.startswith('audio/'):
-        raise HTTPException(400, "Le fichier doit être un fichier audio")
+    if not file.content_type or not file.content_type.startswith('audio/'):
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Le fichier doit être un fichier audio. Type reçu: {file.content_type}"
+        )
     
-    # Créer un ID de conversation si non fourni
+    # 2. Créer un ID de conversation si non fourni
     if not conversation_id:
-        import uuid
         conversation_id = str(uuid.uuid4())
     
-    # 2. Sauvegarder temporairement l'audio
+    # 3. Sauvegarder temporairement l'audio
     with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
         temp_path = temp_file.name
         content = await file.read()
+        
+        # Vérifier que le fichier n'est pas vide
+        if len(content) == 0:
+            os.unlink(temp_path)
+            raise HTTPException(status_code=400, detail="Le fichier audio est vide")
+        
         temp_file.write(content)
     
     try:
-        # 3. STT: Audio → Texte
+        # 4. STT: Audio → Texte
         user_text = speech_to_text(temp_path)
         
         if not user_text or user_text.strip() == "":
-            raise HTTPException(400, "Aucune parole détectée dans l'audio")
+            raise HTTPException(
+                status_code=400, 
+                detail="Aucune parole détectée dans l'audio. Essayez de parler plus clairement."
+            )
         
-        # 4. Générer la réponse du chatbot (utilise votre logique existante)
+        # 5. Générer la réponse du chatbot
+        # Assurez-vous que generate_chat_response fonctionne correctement
         chatbot_response = generate_chat_response(
             user_input=user_text,
             conversation_id=conversation_id
         )
         
-        # 5. TTS: Réponse texte → Audio
+        # 6. TTS: Réponse texte → Audio
         audio_path = text_to_speech(
             text=chatbot_response,
-            voice="Aaliyah-PlayAI",  # ou une voix configurable
+            voice="Aaliyah-PlayAI",
             fmt="wav"
         )
         
-        # 6. Lire le fichier audio
+        # 7. Lire le fichier audio
         with open(audio_path, "rb") as audio_file:
             audio_data = audio_file.read()
         
+        # Stocker l'audio dans le cache
+        audio_cache[conversation_id] = audio_data
+        
         # Nettoyer les fichiers temporaires
         os.unlink(temp_path)
         if Path(audio_path).exists():
             os.unlink(audio_path)
         
-        # 7. Retourner réponse
+        # 8. Retourner réponse avec URL pour récupérer l'audio
         return VoiceChatResponse(
             text_response=chatbot_response,
-            audio_url=f"/voice-chat/audio/{conversation_id}",  # ou stream direct
+            audio_url=f"/voice-chat/audio/{conversation_id}",
             conversation_id=conversation_id
         )
         
+    except HTTPException:
+        # Relancer les HTTPException
+        raise
     except Exception as e:
         # Nettoyer en cas d'erreur
         if os.path.exists(temp_path):
             os.unlink(temp_path)
-        raise HTTPException(500, f"Erreur lors du traitement vocal: {str(e)}")
+        
+        # Log l'erreur complète pour le débogage
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Erreur dans voice_chat_endpoint: {error_details}")
+        
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du traitement vocal: {str(e)}"
+        )
 
 @router.post("/text", response_model=VoiceChatResponse)
 async def text_chat_endpoint(request: TextChatRequest):
@@ -96,50 +128,112 @@ async def text_chat_endpoint(request: TextChatRequest):
     Alternative: Chat texte avec réponse audio
     Pour les utilisateurs qui préfèrent taper mais écouter la réponse
     """
-    # Créer un ID de conversation si non fourni
-    if not request.conversation_id:
-        import uuid
-        conversation_id = str(uuid.uuid4())
-    else:
-        conversation_id = request.conversation_id
-    
     try:
-        # 1. Générer la réponse du chatbot
+        # 1. Créer un ID de conversation si non fourni
+        if not request.conversation_id:
+            conversation_id = str(uuid.uuid4())
+        else:
+            conversation_id = request.conversation_id
+        
+        # 2. Vérifier que le texte n'est pas vide
+        if not request.text or request.text.strip() == "":
+            raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide")
+        
+        # 3. Générer la réponse du chatbot
         chatbot_response = generate_chat_response(
             user_input=request.text,
             conversation_id=conversation_id
         )
         
-        # 2. TTS: Réponse texte → Audio
+        # 4. TTS: Réponse texte → Audio
         audio_path = text_to_speech(
             text=chatbot_response,
             voice="Aaliyah-PlayAI",
             fmt="wav"
         )
         
+        # 5. Lire et stocker l'audio
+        with open(audio_path, "rb") as audio_file:
+            audio_data = audio_file.read()
+        
+        audio_cache[conversation_id] = audio_data
+        
+        # 6. Nettoyer le fichier temporaire
+        if Path(audio_path).exists():
+            os.unlink(audio_path)
+        
+        # 7. Retourner réponse
         return VoiceChatResponse(
             text_response=chatbot_response,
             audio_url=f"/voice-chat/audio/{conversation_id}",
             conversation_id=conversation_id
         )
         
+    except HTTPException:
+        raise
     except Exception as e:
-        raise HTTPException(500, f"Erreur lors du chat: {str(e)}")
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Erreur dans text_chat_endpoint: {error_details}")
+        
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du chat: {str(e)}"
+        )
 
 @router.get("/audio/{conversation_id}")
 async def get_audio_stream(conversation_id: str):
     """
     Stream l'audio de la dernière réponse
-    (Cache ou base de données dans une version réelle)
     """
-    # Dans une vraie implémentation, vous stockeriez l'audio
-    # temporairement ou en cache
-    return {"message": "Endpoint pour récupérer l'audio"}
+    if conversation_id not in audio_cache:
+        raise HTTPException(
+            status_code=404, 
+            detail=f"Aucun audio trouvé pour la conversation {conversation_id}"
+        )
+    
+    audio_data = audio_cache[conversation_id]
+    
+    # Retourner l'audio en streaming
+    return StreamingResponse(
+        io.BytesIO(audio_data),
+        media_type="audio/wav",
+        headers={
+            "Content-Disposition": f"attachment; filename=response_{conversation_id}.wav"
+        }
+    )
 
 @router.get("/conversation/{conversation_id}")
 async def get_conversation_history(conversation_id: str):
     """
     Récupérer l'historique d'une conversation
     """
-    # Implémentez selon votre système de stockage
-    return {"conversation_id": conversation_id, "history": []}
+    try:
+        from services.chat_service import get_conversation_history
+        history = get_conversation_history(conversation_id)
+        
+        return {
+            "conversation_id": conversation_id,
+            "history": history,
+            "message_count": len(history)
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Erreur lors de la récupération de l'historique: {str(e)}"
+        )
+
+# Endpoint pour nettoyer le cache audio (optionnel)
+@router.delete("/audio/{conversation_id}")
+async def clear_audio_cache(conversation_id: str):
+    """
+    Supprimer l'audio d'une conversation du cache
+    """
+    if conversation_id in audio_cache:
+        del audio_cache[conversation_id]
+        return {"message": f"Audio de la conversation {conversation_id} supprimé"}
+    else:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Aucun audio trouvé pour la conversation {conversation_id}"
+        )

services/chat_service.py

@@ -1,13 +1,12 @@
 import uuid
 from typing import Dict, List, Optional
 from datetime import datetime
+import requests
 import json
 
-# Pour Groq Chat API (si vous utilisez Groq)
-import requests
 from config import GROQ_API_KEY, GROQ_CHAT_MODEL
 
-# Stockage en mémoire (remplacez par une base de données en production)
+# Stockage en mémoire des conversations
 conversation_store: Dict[str, List[Dict]] = {}
 
 def generate_chat_response(
@@ -18,47 +17,73 @@ def generate_chat_response(
     """
     Génère une réponse de chatbot pour une entrée utilisateur
     """
-    # 1. Gérer la conversation
-    if not conversation_id:
-        conversation_id = str(uuid.uuid4())
-        conversation_store[conversation_id] = []
-    
-    # 2. Ajouter le message utilisateur à l'historique
-    conversation_store[conversation_id].append({
-        "role": "user",
-        "content": user_input,
-        "timestamp": datetime.now().isoformat()
-    })
-    
-    # 3. Préparer le prompt système
-    if not system_prompt:
-        system_prompt = """Tu es un assistant vocal amical et utile. 
-        Tes réponses doivent être naturelles à l'oral, concises 
-        (max 2-3 phrases) et adaptées à une synthèse vocale."""
-    
-    # 4. Préparer les messages pour l'API Groq
-    messages = [{"role": "system", "content": system_prompt}]
-    
-    # Ajouter l'historique (limité aux derniers messages pour le contexte)
-    history = conversation_store[conversation_id][-5:]  # Derniers 5 échanges
-    for msg in history:
-        messages.append({"role": msg["role"], "content": msg["content"]})
-    
-    # 5. Appeler l'API Groq Chat
     try:
-        response_text = call_groq_chat_api(messages)
+        # 1. Vérifier que l'input n'est pas vide
+        if not user_input or not isinstance(user_input, str):
+            raise ValueError("L'entrée utilisateur doit être une chaîne de caractères non vide")
+        
+        user_input = user_input.strip()
+        if len(user_input) == 0:
+            return "Je n'ai pas entendu ce que vous avez dit. Pouvez-vous répéter ?"
+        
+        # 2. Gérer la conversation
+        if not conversation_id:
+            conversation_id = str(uuid.uuid4())
+        
+        # Initialiser la conversation si elle n'existe pas
+        if conversation_id not in conversation_store:
+            conversation_store[conversation_id] = []
+        
+        # 3. Ajouter le message utilisateur à l'historique
+        conversation_store[conversation_id].append({
+            "role": "user",
+            "content": user_input,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # 4. Préparer le prompt système
+        if not system_prompt:
+            system_prompt = """Tu es un assistant vocal amical et utile. 
+            Tes réponses doivent être naturelles à l'oral, concises 
+            (max 2-3 phrases) et adaptées à une synthèse vocale.
+            Sois courtois et serviable."""
+        
+        # 5. Préparer les messages pour l'API Groq
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Ajouter l'historique (limité aux derniers messages)
+        history = conversation_store[conversation_id][-6:]  # Derniers 6 messages
+        for msg in history:
+            messages.append({"role": msg["role"], "content": msg["content"]})
+        
+        # 6. Appeler l'API Groq Chat
+        if not GROQ_API_KEY:
+            # Fallback si pas de clé API
+            response_text = f"Bonjour ! Vous avez dit : '{user_input}'. Je suis configuré pour répondre, mais l'API Groq n'est pas configurée."
+        else:
+            try:
+                response_text = call_groq_chat_api(messages)
+            except Exception as api_error:
+                # Fallback en cas d'erreur API
+                print(f"Erreur API Groq: {api_error}")
+                response_text = f"D'accord, j'ai compris : {user_input}. Je suis un chatbot et je vous réponds."
+        
+        # 7. Ajouter la réponse à l'historique
+        conversation_store[conversation_id].append({
+            "role": "assistant",
+            "content": response_text,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Limiter la taille de l'historique
+        if len(conversation_store[conversation_id]) > 20:
+            conversation_store[conversation_id] = conversation_store[conversation_id][-10:]
+        
+        return response_text
+        
     except Exception as e:
-        # Fallback simple
-        response_text = f"Désolé, je ne peux pas répondre pour le moment. Erreur: {str(e)}"
-    
-    # 6. Ajouter la réponse à l'historique
-    conversation_store[conversation_id].append({
-        "role": "assistant",
-        "content": response_text,
-        "timestamp": datetime.now().isoformat()
-    })
-    
-    return response_text
+        print(f"Erreur dans generate_chat_response: {e}")
+        return f"Désolé, une erreur est survenue : {str(e)}"
 
 def call_groq_chat_api(messages: List[Dict]) -> str:
     """
@@ -78,15 +103,26 @@ def call_groq_chat_api(messages: List[Dict]) -> str:
         "model": GROQ_CHAT_MODEL,
         "messages": messages,
         "temperature": 0.7,
-        "max_tokens": 150,  # Limité pour les réponses vocales
+        "max_tokens": 300,  # Augmenté pour des réponses plus complètes
         "top_p": 0.9,
+        "stream": False
     }
     
-    response = requests.post(url, headers=headers, json=payload, timeout=30)
-    response.raise_for_status()
-    
-    result = response.json()
-    return result["choices"][0]["message"]["content"]
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        if "choices" not in result or len(result["choices"]) == 0:
+            raise ValueError("Réponse invalide de l'API Groq")
+        
+        return result["choices"][0]["message"]["content"]
+        
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Erreur de connexion à l'API Groq: {str(e)}")
+    except KeyError as e:
+        raise Exception(f"Format de réponse invalide: {str(e)}")
 
 def get_conversation_history(conversation_id: str) -> List[Dict]:
     """
@@ -99,4 +135,6 @@ def clear_conversation(conversation_id: str):
     Efface une conversation
     """
     if conversation_id in conversation_store:
-        del conversation_store[conversation_id]
+        del conversation_store[conversation_id]
+        return True
+    return False