feat(feedback): integrar Gemini flash-8b con parser robusto y fallback

src/expon/feedback/application/internal/generate_feedback_service.py

@@ -17,22 +17,29 @@ class GenerateFeedbackService:
     def generate_feedback(self, presentation_id: str) -> dict[str, Any]:
         # 1. Buscar presentación
         presentation: PresentationORM = self.presentation_repo.get_by_id(presentation_id)
-
         if presentation is None:
             raise ValueError("Presentación no encontrada")
 
         user_id = presentation.user_id
         emotion = presentation.dominant_emotion
         transcription = presentation.transcript or ""
-        confidence = presentation.confidence or 0.0
-        anxiety = 0.3  # Puedes cambiarlo si luego deseas calcularlo
+        confidence = float(presentation.confidence or 0.0)
+
+        # 2. Calcular ansiedad desde la distribución (0..1)
+        probs: dict[str, float] = (presentation.emotion_probabilities or {})  # 0..1
+        anxiety = float(probs.get("ansiosa", 0.0) + probs.get("nerviosa", 0.0))
+        if anxiety > 1.0:
+            anxiety = 1.0
+        if anxiety < 0.0:
+            anxiety = 0.0
 
-        # 2. Generar contenido dinámico con IA
+        # 3. Generar contenido con IA (usa distribución completa)
         general, language, confidence_fb, anxiety_fb, suggestions = self.text_gen_service.generate_structured_feedback(
             transcription=transcription,
             emotion=emotion,
             confidence=confidence,
-            anxiety=anxiety
+            anxiety=anxiety,
+            emotion_probabilities=probs
         )
 
         feedback = Feedback(
@@ -59,6 +66,8 @@ class GenerateFeedbackService:
             "anxiety_feedback": feedback.anxiety_feedback,
             "suggestions": feedback.suggestions,
             "created_at": feedback.created_at,
+            # extras para el front:
             "dominant_emotion": emotion,
-            "confidence": round(confidence, 2)
+            "confidence": round(confidence, 2),
+            "emotion_probabilities": probs,
         }

src/expon/feedback/infrastructure/persistence/jpa/feedback_repository.py

@@ -1,8 +1,6 @@
 from sqlalchemy.orm import Session
 from src.expon.feedback.infrastructure.persistence.jpa.feedback_orm import FeedbackORM
 from src.expon.feedback.domain.model.feedback import Feedback
-from datetime import datetime
-import uuid
 
 class FeedbackRepository:
     def __init__(self, db: Session):
@@ -10,7 +8,7 @@ class FeedbackRepository:
 
     def save(self, feedback: Feedback):
         orm_obj = FeedbackORM(
-            id=uuid.uuid4(),
+            id=feedback.id,                               # ✅ respeta el id generado en dominio
             user_id=feedback.user_id,
             presentation_id=feedback.presentation_id,
             general_feedback=feedback.general_feedback,
@@ -18,7 +16,7 @@ class FeedbackRepository:
             confidence_feedback=feedback.confidence_feedback,
             anxiety_feedback=feedback.anxiety_feedback,
             suggestions=feedback.suggestions,
-            created_at=datetime.utcnow()
+            created_at=feedback.created_at                # ✅ usa el created_at del dominio
         )
         self.db.add(orm_obj)
         self.db.commit()
@@ -30,7 +28,7 @@ class FeedbackRepository:
         return self.db.query(FeedbackORM).filter_by(user_id=user_id).all()
 
     def get_by_presentation(self, presentation_id):
-        return self.db.query(FeedbackORM).filter_by(presentation_id=presentation_id).all()  # ✅ CORREGIDO (antes era `.first()`)
+        return self.db.query(FeedbackORM).filter_by(presentation_id=presentation_id).all()
 
     def delete(self, feedback: FeedbackORM):
         self.db.delete(feedback)

src/expon/feedback/infrastructure/services/text_generation_service.py

@@ -1,69 +1,239 @@
-import os
+import os, json, re, time
+from typing import Dict, Tuple, Optional, Any
 import google.generativeai as genai
 from dotenv import load_dotenv
 
-# Cargar variables desde .env
 load_dotenv()
 
+def _fmt_dist(dist: Dict[str, float]) -> str:
+    order = ["confiada","entusiasta","motivada","neutra","ansiosa","nerviosa"]
+    parts = [f"{k}:{round(float(dist.get(k,0))*100,1)}%" for k in order]
+    for k,v in dist.items():
+        if k not in order:
+            parts.append(f"{k}:{round(float(v)*100,1)}%")
+    return ", ".join(parts)
+
+def _extract_json_block(text: Any) -> str:
+    """
+    Acepta str | list | dict | cualquier cosa.
+    Si no es str, lo serializa a str antes de procesar.
+    """
+    if text is None:
+        return ""
+    if not isinstance(text, str):
+        try:
+            text = json.dumps(text, ensure_ascii=False)
+        except Exception:
+            text = str(text)
+
+    t = text.strip()
+    # limpia fences ```json ... ```
+    t = re.sub(r"^```(?:json)?\s*|\s*```$", "", t, flags=re.IGNORECASE)
+
+    # Si ya parece JSON directo
+    try:
+        if t.startswith("{"):
+            json.loads(t)
+            return t
+    except Exception:
+        pass
+
+    # Busca bloque { ... } más grande
+    s, e = t.find("{"), t.rfind("}")
+    if s != -1 and e != -1 and e > s:
+        candidate = t[s:e+1]
+        return candidate
+
+    return t  # último recurso
+
+def _resp_to_str(resp: Any) -> str:
+    """
+    Convierte la respuesta de google-generativeai a string de forma robusta.
+    En 0.8.x, resp.text puede ser str | list | dict dependiendo de response_mime_type.
+    """
+    # 1) Si hay .text y es str, úsalo
+    txt = getattr(resp, "text", None)
+    if isinstance(txt, str):
+        return txt.strip()
+
+    # 2) Si .text es list/dict (caso JSON mode), serializa
+    if isinstance(txt, (list, dict)):
+        try:
+            return json.dumps(txt, ensure_ascii=False)
+        except Exception:
+            pass
+
+    # 3) Intenta candidates -> parts
+    try:
+        cands = getattr(resp, "candidates", None) or []
+        if cands:
+            parts = getattr(cands[0], "content", None)
+            parts = getattr(parts, "parts", None) if parts else None
+            if parts:
+                chunks = []
+                for p in parts:
+                    val = getattr(p, "text", None)
+                    if isinstance(val, str):
+                        chunks.append(val)
+                    else:
+                        try:
+                            chunks.append(json.dumps(p, default=str, ensure_ascii=False))
+                        except Exception:
+                            continue
+                if chunks:
+                    return "\n".join(chunks).strip()
+    except Exception:
+        pass
+
+    # 4) Último recurso: serializa todo el objeto
+    try:
+        return json.dumps(resp, default=str, ensure_ascii=False)
+    except Exception:
+        return ""
+
+def _to_text(value: Any) -> str:
+    """
+    Normaliza cualquier valor del JSON a string “seguro” para .strip().
+    - Si es lista de strings, las une con ' · '.
+    - Si es lista/dict, lo serializa a JSON legible.
+    - Si es None, devuelve "".
+    """
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        # Une strings; si hay dicts u otros tipos, serializa cada item
+        parts = []
+        for it in value:
+            if isinstance(it, str):
+                parts.append(it)
+            else:
+                try:
+                    parts.append(json.dumps(it, ensure_ascii=False))
+                except Exception:
+                    parts.append(str(it))
+        return " · ".join(parts)
+    if isinstance(value, dict):
+        try:
+            return json.dumps(value, ensure_ascii=False)
+        except Exception:
+            return str(value)
+    return str(value)
+
 class TextGenerationService:
-    def __init__(self, model="gemini-1.5-flash"):
-        self.model_name = model
+    def __init__(self, model: str = "gemini-1.5-flash-8b"):
+        # ✅ Mantén solo el 8b para evitar aliases que resuelven a -002/-latest
+        self.primary_model = model
+        self.backup_model  = model  # reintento con la misma versión, sin json_mode
+
         api_key = os.getenv("GEMINI_API_KEY")
         if not api_key:
             raise ValueError("GEMINI_API_KEY no encontrada en variables de entorno")
-        
         genai.configure(api_key=api_key)
-        # Usar modelo sin configuración fija para permitir ajustes dinámicos
-        self.model = genai.GenerativeModel(model)
-
-    def generate_structured_feedback(self, transcription: str, emotion: str, confidence: float, anxiety: float) -> tuple[str, str, str, str, str]:
-        # Contexto base con información de la presentación
-        context = (
-            f"ANÁLISIS DE PRESENTACIÓN ACADÉMICA\n"
-            f"====================================\n"
-            f"Transcripción: \"{transcription}\"\n\n"
-            f"Métricas detectadas:\n"
-            f"- Emoción dominante: {emotion}\n"
-            f"- Nivel de confianza: {int(confidence * 100)}%\n"
-            f"- Nivel de ansiedad: {int(anxiety * 100)}%\n"
-        )
 
-        def ask(prompt: str) -> str:
+    def _gen(self, model_name: str, prompt: str, json_mode: bool) -> str:
+        model = genai.GenerativeModel(model_name)
+        gen_cfg = {"temperature": 0.6, "max_output_tokens": 512}
+        if json_mode:
+            # En 0.8.5 resp.text puede venir como list/dict: lo manejamos en _resp_to_str
+            try:
+                gen_cfg["response_mime_type"] = "application/json"
+            except Exception:
+                pass
+
+        resp = model.generate_content(prompt, generation_config=gen_cfg)
+
+        if hasattr(resp, "prompt_feedback") and resp.prompt_feedback:
+            print("[Gemini] prompt_feedback:", resp.prompt_feedback)
+
+        raw = _resp_to_str(resp)   # ⬅️ SIEMPRE usar el conversor robusto
+        print(f"[Gemini] _gen returned type={type(raw).__name__}")
+        return raw
+
+    def generate_structured_feedback(
+        self,
+        transcription: str,
+        emotion: str,
+        confidence: float,
+        anxiety: float,
+        emotion_probabilities: Optional[Dict[str, float]] = None,
+    ) -> Tuple[str, str, str, str, str]:
+
+        dist = emotion_probabilities or {}
+        dist_txt = _fmt_dist(dist)
+        conf_pct = int((confidence or 0.0) * 100)
+        anx_pct  = int((anxiety or 0.0) * 100)
+        transcript = (transcription or "").strip()
+
+        prompt = f"""
+Eres un coach de oratoria académica. Genera feedback breve, accionable y específico
+para un estudiante usando la TRANSCRIPCIÓN y la DISTRIBUCIÓN DE EMOCIONES del modelo.
+
+### Datos del modelo:
+- Emoción dominante: {emotion or "desconocida"}
+- Confianza del modelo: {conf_pct}%
+- Ansiedad estimada (desde probs): {anx_pct}%
+- Distribución de emociones: {dist_txt}
+
+### Transcripción:
+\"\"\"{transcript[:12000]}\"\"\"
+
+### Reglas de salida (JSON estricto):
+Devuelve SOLO un objeto con estas claves:
+{{
+  "general_feedback": "Resumen (3-5 líneas) con 1 fortaleza y 1 foco principal de mejora.",
+  "confidence_feedback": "Consejo corto para reforzar seguridad; si ya es alta, cómo mantenerla.",
+  "anxiety_feedback": "1-2 técnicas concretas si hay ansiedad; si es baja, cómo prevenir.",
+  "language_feedback": "Observaciones sobre claridad y muletillas (máx. 4 ideas).",
+  "suggestions": "3 recomendaciones accionables numeradas (1 línea cada una)."
+}}
+
+- Prioriza acciones (“pausas de 1s”, “ensayo cronometrado 90s”, “sustituir muletillas”).
+- No inventes hechos fuera de la transcripción.
+- No devuelvas texto fuera del JSON.
+""".strip()
+
+        # Retries: mismo modelo (8b), con y sin json_mode
+        attempts = [
+            (self.primary_model, True),
+            (self.backup_model,  False),
+        ]
+
+        last_err = None
+        for i, (model_name, json_mode) in enumerate(attempts, start=1):
             try:
-                # Crear el prompt completo con contexto
-                full_prompt = f"""Eres un experto en análisis de presentaciones académicas.
+                raw = self._gen(model_name, prompt, json_mode=json_mode)
+                if not raw:
+                    raise RuntimeError("Respuesta vacía de Gemini")
 
-{context}
+                cleaned = _extract_json_block(raw)
+                data = json.loads(cleaned)
 
-{prompt}
+                # Si la raíz es lista y el primer elemento es dict, úsalo
+                if isinstance(data, list) and data and isinstance(data[0], dict):
+                    data = data[0]
 
-IMPORTANTE: Responde en máximo 60 palabras, de forma directa y profesional, sin usar comillas dobles."""
+                def take(key: str) -> str:
+                    return _to_text(data.get(key)).strip()[:800]
 
-                # Configuración dinámica como sugiere GPT
-                response = self.model.generate_content(
-                    full_prompt, 
-                    generation_config={
-                        "temperature": 0.7, 
-                        "max_output_tokens": 100
-                    }
+                return (
+                    take("general_feedback"),
+                    take("language_feedback"),
+                    take("confidence_feedback"),
+                    take("anxiety_feedback"),
+                    take("suggestions"),
                 )
-                
-                # Limpiar caracteres de escape y limitaciones
-                clean_text = response.text.strip().replace('\\"', '"').replace('\\n', ' ')
-                # Limitar palabras si es muy largo
-                words = clean_text.split()
-                if len(words) > 60:
-                    clean_text = ' '.join(words[:60]) + "..."
-                return clean_text
             except Exception as e:
-                print(f"Error al generar feedback con Gemini: {e}")
-                return f"Error al generar análisis. Verifique la configuración de la API."
-
-        # Pedir feedback por secciones con prompts más específicos
-        general = ask("Analiza brevemente la presentación general: fortalezas principales y área de mejora más importante.")
-        language = ask("Evalúa el lenguaje: ¿es académico o informal? Menciona 2 mejoras específicas para el vocabulario.")
-        confidence_fb = ask("¿Cómo se percibe la confianza del orador? Analiza el tono y seguridad proyectada.")
-        anxiety_fb = ask("¿Se detecta ansiedad? Proporciona 2 técnicas específicas para reducirla.")
-        suggestions = ask("Lista exactamente 3 mejoras concretas y accionables para futuras presentaciones.")
+                last_err = e
+                print(f"[Gemini] intento {i} falló ({model_name}, json_mode={json_mode}): {e}")
+                time.sleep(0.6 * i)
 
-        return general, language, confidence_fb, anxiety_fb, suggestions
+        print(f"[Gemini] Fallback activado por error: {last_err}")
+        return (
+            "No se pudo generar el resumen en este intento.",
+            "Revisa claridad y evita muletillas frecuentes.",
+            "Ensaya con voz firme y ritmo estable.",
+            "Prueba respiración 4-7-8 y pausas de 1s.",
+            "1) Ensayo cronometrado 2) Grábate y revisa 3) Mejora transiciones.",
+        )