Mejoras profesionales: logging, prompt optimizado, temperature 0.0, mejor limpieza de respuestas

agents.py

@@ -1,330 +1,280 @@
 """
-Agent class para resolver tareas GAIA usando Gemini.
+Agent class para resolver tareas GAIA.
+
+Basado en tu versión original (inspirado en chiarapaglioni/GAIA-agents),
+con mejoras para compatibilidad con la evaluación GAIA (exact match),
+robustez en descarga/procesado de archivos y limpieza de respuesta.
 """
 
 import re
 from typing import Optional, List, Any
-from model import GeminiModel
+from io import BytesIO
+import requests
+import logging
+
+# Ajusta el nivel de logging si quieres más/menos detalle
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# Asumimos que `model.py` expone get_model() y una clase modelo con método generate_simple(prompt, **kwargs)
+# e.g., model = get_model("gemini/...")
+from model import GeminiModel  # type: ignore
 
 
 class Agent:
     """
-    Agente para resolver tareas del benchmark GAIA usando Google Gemini.
+    Agente para resolver tareas del benchmark GAIA.
     """
-    
+
     def __init__(
         self,
         model: GeminiModel,
         tools: Optional[List[Any]] = None,
-        verbose: bool = False
+        verbose: bool = False,
+        normalize_to_lowercase: bool = False
     ):
         """
         Inicializa el agente.
-        
         Args:
-            model: Modelo Gemini a usar
-            tools: Lista de herramientas disponibles (opcional)
-            verbose: Si True, imprime información de debug
+            model: Modelo (adaptador) que implemente generate_simple(prompt, **kwargs)
+            tools: Lista de herramientas (opcional)
+            verbose: Si True, imprime info de debug
+            normalize_to_lowercase: Si True, normaliza la salida a minúsculas (cuidado: puede romper nombres)
         """
         self.model = model
         self.tools = tools or []
         self.verbose = verbose
-        
-        # Prompt optimizado para GAIA benchmark
-        self.system_prompt = """You are an expert AI assistant specialized in solving GAIA benchmark tasks with precision.
-
-CRITICAL FORMATTING RULES (EXACT MATCHING REQUIRED):
-
-1. NUMBERS:
-   - Write as plain digits: 42 (not 42.0 or 42,000)
-   - NO commas in numbers: 1000000 (not 1,000,000)
-   - NO units unless explicitly requested: 42 (not $42 or 42%)
-   - Use Arabic numerals: 9 (not nine)
-
-2. STRINGS:
-   - Lowercase preferred: paris (not Paris)
-   - NO articles: paris (not "the paris" or "a paris")
-   - NO abbreviations: san francisco (not SF or S.F.)
-   - Write digits in plain text unless specified
-
-3. LISTS:
-   - Comma-separated: apple,orange,banana
-   - NO brackets: apple,orange (not [apple,orange])
-   - NO quotes: apple,orange (not "apple","orange")
-
-4. CURRENCY (only if explicitly requested):
-   - Use symbol: $40.00
-   - Follow requested format exactly
-
-5. DATES:
-   - Follow exact format requested in question
-
-YOUR RESPONSE STRUCTURE:
-1. Think step by step (max 5 sentences)
-2. If files are provided, USE THE CONTENT
-3. End with: FINAL ANSWER: [exact answer ON SAME LINE]
-
-🚨 CRITICAL FINAL ANSWER RULES 🚨:
-- "FINAL ANSWER:" MUST be the LAST line of your response
-- Put ONLY the answer on the SAME LINE after "FINAL ANSWER:"
-- NEVER write ANYTHING after the answer (no periods, explanations, nothing!)
-- The answer must be on ONE line only
-
-✅ CORRECT Examples:
-FINAL ANSWER: 42
-FINAL ANSWER: paris
-FINAL ANSWER: apple,banana,orange
-
-❌ WRONG Examples (DO NOT DO THIS):
-FINAL ANSWER: The answer is 42.
-FINAL ANSWER: 42
-This is because...
-FINAL ANSWER: I need to listen to...
-
-IMPORTANT: GAIA uses exact string matching. Be precise!"""
-    
+        self.normalize_to_lowercase = normalize_to_lowercase
+
+        # Prompt mejorado: pedir SOLO la respuesta final sin prefijos ni explicaciones.
+        # NO exigir "FINAL ANSWER:" para evitar que el sistema agregue un prefijo que rompa exact-match.
+        self.system_prompt = (
+            "You are an expert AI assistant specialized in solving GAIA benchmark tasks with precision.\n\n"
+            "IMPORTANT - OUTPUT RULES (GAIA EXACT MATCH):\n"
+            " - Return ONLY the final answer, nothing else. No explanations, no commentary, no prefixes.\n"
+            " - The answer must be on a single line (no line breaks) and must match the expected format exactly.\n"
+            " - Do NOT add 'Final answer', 'Answer:', or any label.\n"
+            " - If the question expects a list, return comma-separated values with no brackets or quotes (apple,orange).\n"
+            " - If the question expects a number, return digits only (e.g. 42).\n"
+            " - If the question expects a string, return it exactly (case-sensitive unless you configured normalization).\n\n"
+            "Follow any file content provided and use it as context. Think briefly if needed, but output only the final line."
+        )
+
     def __call__(self, question: str, files: Optional[List[str]] = None) -> str:
-        """
-        Interfaz principal para resolver una pregunta.
-        
-        Args:
-            question: La pregunta a responder
-            files: Lista opcional de rutas de archivos asociados
-            
-        Returns:
-            str: La respuesta limpia y formateada
-        """
         if self.verbose:
-            print(f"\n{'='*60}")
-            print(f"📋 Pregunta: {question[:100]}...")
+            logger.info("\n" + "=" * 60)
+            logger.info(f"📋 Pregunta: {question[:200]}")
             if files:
-                print(f"📎 Archivos: {files}")
-        
+                logger.info(f"📎 Archivos: {files}")
+
         answer = self.answer_question(question, files)
-        
+
         if self.verbose:
-            print(f"✅ Respuesta: {answer}")
-            print(f"{'='*60}\n")
-        
+            logger.info(f"✅ Respuesta final: {answer}")
+            logger.info("=" * 60 + "\n")
+
         return answer
-    
+
     def answer_question(self, question: str, files: Optional[List[str]] = None) -> str:
-        """
-        Procesa la pregunta y genera una respuesta.
-        
-        Args:
-            question: La pregunta a responder
-            files: Lista opcional de archivos
-            
-        Returns:
-            str: Respuesta limpia
-        """
         try:
-            # Construir contexto
             context = self._build_context(question, files)
-            
-            # Construir prompt completo
-            full_prompt = f"{self.system_prompt}\n\n{context}"
-            
+
+            full_prompt = f"{self.system_prompt}\n\nTASK: {question}\n\nCONTEXT:\n{context}\n\nAnswer now:"
             if self.verbose:
-                print(f"🤖 Llamando a Gemini...")
-            
-            # Llamar al modelo con configuración optimizada
+                logger.info("🤖 Llamando al modelo con prompt optimizado...")
+
             response = self.model.generate_simple(
-                full_prompt, 
-                temperature=0.1,  # Balance: determinismo pero no robotico
-                max_tokens=500  # Limitado para forzar concisión
+                full_prompt,
+                temperature=0.0,  # determinismo preferible para exact-match
+                max_tokens=256
             )
-            
-            # Limpiar y formatear respuesta
+
+            if self.verbose:
+                logger.info(f"🔍 Respuesta bruta del modelo (truncada 1000 chars): {response[:1000]!r}")
+
             clean = self._clean_answer(response)
-            
+
+            # Normalización opcional (configurable)
+            if self.normalize_to_lowercase and isinstance(clean, str):
+                clean = clean.lower()
+
             return clean
-            
+
         except Exception as e:
-            error_msg = f"ERROR: {str(e)}"
-            print(f"❌ {error_msg}")
-            return error_msg
-    
+            logger.exception("Error al resolver la pregunta:")
+            return f"ERROR: {str(e)}"
+
     def _build_context(self, question: str, files: Optional[List[str]] = None) -> str:
         """
         Construye el contexto para el prompt, procesando archivos si existen.
-        
-        Args:
-            question: La pregunta
-            files: Lista opcional de archivos/URLs
-            
-        Returns:
-            str: Contexto formateado con contenido de archivos
         """
-        context_parts = [f"TASK: {question}"]
-        
-        # Procesar archivos si existen
-        if files and len(files) > 0:
-            context_parts.append("\n📁 FILES PROVIDED:")
-            
-            from tools import read_image_text, read_excel_file, read_audio_file
-            import requests
-            
+        context_parts = []
+        # Incluir (breve) instrucción/metadata
+        context_parts.append(f"QUESTION_RAW: {question}")
+
+        if files:
+            context_parts.append("FILES_CONTENT_START")
+            # import tools aquí (asumimos que existen funciones en tools.py)
+            from tools import read_image_text, read_excel_file, read_audio_file  # type: ignore
+
             for file_url in files:
                 try:
                     file_lower = file_url.lower()
-                    
-                    # Procesar imágenes con OCR
                     if any(ext in file_lower for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']):
                         if self.verbose:
-                            print(f"  📷 Procesando imagen: {file_url}")
-                        text = read_image_text(file_url)
+                            logger.info(f"  📷 Procesando imagen: {file_url}")
+                        try:
+                            text = read_image_text(file_url)
+                        except Exception as e:
+                            logger.warning(f"    OCR error: {e}")
+                            text = ""
                         if text and text.strip():
-                            context_parts.append(f"\n🖼️ IMAGE CONTENT from {file_url}:")
-                            context_parts.append(f"{text.strip()}")
+                            context_parts.append(f"IMAGE_TEXT_FROM {file_url}:\n{text.strip()}")
                         else:
-                            context_parts.append(f"\n⚠️  Could not extract text from image: {file_url}")
-                    
-                    # Procesar archivos Excel
+                            context_parts.append(f"IMAGE_NO_TEXT_EXTRACTED_FROM {file_url}")
+
                     elif any(ext in file_lower for ext in ['.xlsx', '.xls']):
                         if self.verbose:
-                            print(f"  📊 Procesando Excel: {file_url}")
-                        content = read_excel_file(file_url)
-                        context_parts.append(f"\n📊 EXCEL DATA from {file_url}:")
-                        context_parts.append(content)
-                    
-                    # Procesar archivos de audio (limitado)
+                            logger.info(f"  📊 Procesando Excel: {file_url}")
+                        try:
+                            content = read_excel_file(file_url)
+                            context_parts.append(f"EXCEL_FROM {file_url}:\n{content}")
+                        except Exception as e:
+                            logger.warning(f"    Excel read error: {e}")
+                            context_parts.append(f"EXCEL_READ_ERROR {file_url}")
+
                     elif any(ext in file_lower for ext in ['.mp3', '.wav', '.ogg', '.m4a']):
                         if self.verbose:
-                            print(f"  🎵 Detectado audio: {file_url}")
-                        info = read_audio_file(file_url)
-                        context_parts.append(f"\n🎵 AUDIO FILE:")
-                        context_parts.append(info)
-                    
-                    # Procesar archivos de texto
+                            logger.info(f"  🎵 Procesando audio: {file_url}")
+                        try:
+                            info = read_audio_file(file_url)
+                            context_parts.append(f"AUDIO_TRANSCRIPT_FROM {file_url}:\n{info}")
+                        except Exception as e:
+                            logger.warning(f"    Audio read error: {e}")
+                            context_parts.append(f"AUDIO_READ_ERROR {file_url}")
+
                     elif any(ext in file_lower for ext in ['.txt', '.csv', '.json', '.py', '.md']):
                         if self.verbose:
-                            print(f"  📄 Procesando archivo texto: {file_url}")
-                        response = requests.get(file_url, timeout=30)
-                        response.raise_for_status()
-                        content = response.text[:5000]  # Primeros 5000 caracteres
-                        context_parts.append(f"\n📄 FILE CONTENT from {file_url}:")
-                        context_parts.append(f"{content}")
-                    
+                            logger.info(f"  📄 Procesando texto: {file_url}")
+                        try:
+                            r = requests.get(file_url, timeout=15)
+                            r.raise_for_status()
+                            content = r.text[:5000]  # limitar
+                            context_parts.append(f"TEXT_FILE_FROM {file_url}:\n{content}")
+                        except Exception as e:
+                            logger.warning(f"    Text download error: {e}")
+                            context_parts.append(f"TEXT_READ_ERROR {file_url}")
+
                     else:
-                        # Archivo de tipo desconocido
-                        context_parts.append(f"\n📎 File available: {file_url}")
-                        
+                        # Unknown type -> only include url
+                        context_parts.append(f"FILE_AVAILABLE: {file_url}")
+
                 except Exception as e:
-                    if self.verbose:
-                        print(f"  ❌ Error procesando {file_url}: {str(e)}")
-                    context_parts.append(f"\n⚠️  Could not process file: {file_url}")
-        
-        # Detectar texto invertido (reversed text) - común en GAIA
+                    logger.warning(f"  ❌ Error procesando {file_url}: {e}")
+                    context_parts.append(f"FILE_PROCESS_ERROR {file_url}")
+
+            context_parts.append("FILES_CONTENT_END")
+
+        # Detectar texto invertido (heurística básica)
         if self._is_reversed_text(question):
             reversed_q = question[::-1]
-            context_parts.append(f"\n⚠️  REVERSED TEXT DETECTED!")
-            context_parts.append(f"Original text: {question}")
-            context_parts.append(f"Actual question: {reversed_q}")
-            context_parts.append("Answer the reversed version in NORMAL text.")
-        
+            context_parts.append("NOTE: detected reversed text in the question.")
+            context_parts.append(f"REVERSED_ORIGINAL: {question}")
+            context_parts.append(f"REVERSED_INTERPRETATION: {reversed_q}")
+
         return "\n".join(context_parts)
-    
+
     def _is_reversed_text(self, text: str) -> bool:
         """
-        Detecta si el texto está invertido.
-        
-        Args:
-            text: Texto a analizar
-            
-        Returns:
-            bool: True si parece estar invertido
+        Detecta si el texto está invertido. Heurística simple.
         """
-        # Heurística: texto invertido suele empezar con "." o contener patrones invertidos
+        if not text:
+            return False
+        s = text.strip()
         indicators = [
-            text.strip().startswith("."),
-            "?rewsna" in text.lower(),
-            "?noitseuq" in text.lower(),
-            ".rewsna eht sa" in text.lower()
+            s.startswith("."),
+            "?rewsna" in s.lower(),
+            "?noitseuq" in s.lower(),
+            ".rewsna eht sa" in s.lower(),
+            # si tiene muchas letras no alfabeticas al inicio
+            (len(s) > 3 and not s[0].isalnum())
         ]
         return any(indicators)
-    
+
     def _clean_answer(self, response: str) -> str:
         """
-        Limpia y formatea la respuesta según reglas GAIA.
-        
-        Args:
-            response: Respuesta cruda del modelo
-            
-        Returns:
-            str: Respuesta limpia
+        Limpia la respuesta del modelo y extrae lo que consideramos la respuesta final.
+        Reglas:
+         - Si el modelo incluyó "FINAL ANSWER:" (case-insensitive), respetar lo que sigue.
+         - Si no, tomar la última línea no vacía o la línea más corta <= 200 chars, con heurística.
+         - Quitar comillas y espacios en los extremos.
         """
-        # Extraer respuesta final si hay marcador "FINAL ANSWER:"
-        if "FINAL ANSWER:" in response.upper():
-            # Buscar case-insensitive
+        if not response:
+            return ""
+
+        # Normalize line endings and split
+        lines = [ln.strip() for ln in response.replace("\r", "").split("\n")]
+
+        # Buscar marcador FINAL ANSWER: (case-insensitive)
+        joined_upper = response.upper()
+        if "FINAL ANSWER:" in joined_upper:
             parts = re.split(r'FINAL ANSWER:\s*', response, flags=re.IGNORECASE)
-            if len(parts) > 1:
-                # Tomar solo lo que viene después de FINAL ANSWER:
-                after_marker = parts[-1].strip()
-                
-                # Tomar solo la MISMA LÍNEA (cortar en el primer salto de línea)
-                # Esto evita que el modelo escriba explicaciones largas después
-                first_line = after_marker.split('\n')[0].strip()
-                
-                # Si la primera línea es sospechosamente larga (>200 chars), 
-                # probablemente el modelo no siguió instrucciones - cortar agresivamente
-                if len(first_line) > 200:
-                    # Buscar patrones comunes de fin de respuesta
-                    for delimiter in ['. ', '? ', '! ', ', because', ', which', ', and', ', so']:
-                        if delimiter in first_line[:200]:
-                            first_line = first_line.split(delimiter)[0].strip()
-                            break
-                    else:
-                        # Si no hay delimitadores, tomar primeros 150 caracteres
-                        first_line = first_line[:150].strip()
-                
-                response = first_line if first_line else after_marker
-        
-        # Remover prefijos comunes
-        prefixes = [
-            "The answer is:", "Answer:", "Final Answer:", 
-            "The final answer is:", "=>", "Result:",
-            "Output:", "Solution:", "I need to"
-        ]
-        for prefix in prefixes:
-            if response.lower().startswith(prefix.lower()):
-                response = response[len(prefix):].strip()
-        
-        # Limpiar comillas y espacios
-        response = response.strip(" '\"")
-        
-        # Remover punto final si no es parte de la respuesta
-        # (solo si la respuesta es larga o contiene espacios)
-        if response.endswith("."):
-            # No remover si parece un decimal o número con punto
-            if not response.replace(".", "").replace(",", "").replace(" ", "").isdigit():
-                # Solo remover si hay espacios o es muy larga
-                if " " in response or len(response) > 20:
-                    response = response.rstrip(".")
-        
-        # Manejar respuestas invertidas - invertir de vuelta
-        if self._is_reversed_text(response):
-            response = response[::-1]
-        
-        # Remover corchetes de listas si existen
-        response = response.strip("[]")
-        
-        return response.strip()
+            after = parts[-1].strip()
+            # tomar solo la primera línea después del marcador
+            candidate = after.splitlines()[0].strip()
+            candidate = self._postprocess_candidate(candidate)
+            return candidate
+
+        # Si no hay marcador, filtrar líneas no vacías
+        nonempty = [ln for ln in lines if ln]
+        if not nonempty:
+            return ""
+
+        # Heurística:
+        # 1) Si alguna línea es corta y no contiene ':' (probable respuesta), usar la línea m��s corta <=200
+        short_lines = [ln for ln in nonempty if len(ln) <= 200 and ':' not in ln]
+        if short_lines:
+            # preferir la última línea corta (suele ser la respuesta)
+            candidate = short_lines[-1].strip()
+            return self._postprocess_candidate(candidate)
+
+        # 2) Si todo lo anterior falla, usar la última línea no vacía
+        candidate = nonempty[-1]
+        return self._postprocess_candidate(candidate)
+
+    def _postprocess_candidate(self, candidate: str) -> str:
+        """
+        Limpieza final: quitar comillas, corchetes, puntos finales innecesarios.
+        """
+        if not candidate:
+            return ""
+
+        # Remove enclosing quotes/brackets
+        candidate = candidate.strip()
+        candidate = candidate.strip('\'"')
+        candidate = candidate.strip("[](){}")
+
+        # Remove trailing period if it's not numeric decimal
+        if candidate.endswith("."):
+            candidate_core = candidate[:-1]
+            # no quitar si parece decimal (e.g., "3.14")
+            if not re.match(r'^\d+(\.\d+)?$', candidate_core):
+                candidate = candidate_core
+
+        # Trim spaces
+        candidate = candidate.strip()
+
+        # If normalize_to_lowercase flag is set, lower-case here (this can be optional)
+        if self.normalize_to_lowercase:
+            candidate = candidate.lower()
+
+        return candidate
 
 
 def create_agent(model_id: str = "gemini/gemini-2.0-flash-exp", verbose: bool = False, **kwargs) -> Agent:
     """
-    Factory function para crear un agente con Gemini.
-    
-    Args:
-        model_id: ID del modelo Gemini a usar
-        verbose: Si True, imprime información de debug
-        **kwargs: Argumentos adicionales para el modelo
-        
-    Returns:
-        Agent: Instancia del agente configurado
+    Factory para crear un agente.
     """
     from model import get_model
     model = get_model(model_id, **kwargs)
-    return Agent(model=model, verbose=verbose)
+    return Agent(model=model, verbose=verbose, normalize_to_lowercase=kwargs.get("normalize_to_lowercase", False))

app.py

@@ -88,8 +88,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         
         print(f"✅ Recibidas {len(questions_data)} preguntas")
         
-        # Para testing, descomentar para limitar a 5 preguntas:
-        # questions_data = questions_data[:5]
+        # TESTING: Limitar a solo 3 preguntas para evitar rate limits
+        questions_data = questions_data[:3]
+        print(f"⚠️  [TESTING MODE] Limitado a {len(questions_data)} preguntas")
         
     except Exception as e:
         error_msg = f"❌ Error al obtener preguntas: {str(e)}"
@@ -114,10 +115,10 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         submissions.append(result["submission"])
         logs.append(result["log"])
         
-        # Delay entre preguntas para evitar rate limits (Gemini free tier: ~1 req/seg)
+        # Delay entre preguntas para evitar rate limits (Gemini free tier: muy limitado)
         if i < len(questions_data):  # No esperar después de la última
-            print(f"⏳ Esperando 2 segundos antes de la siguiente pregunta...")
-            time.sleep(2)
+            print(f"⏳ Esperando 5 segundos antes de la siguiente pregunta...")
+            time.sleep(5)  # Aumentado de 2 a 5 segundos
     
     if not submissions:
         return "⚠️ No se generaron respuestas.", pd.DataFrame(logs)

model.py

@@ -1,54 +1,51 @@
 """
-Model wrapper para usar Google Gemini via LiteLLM.
-Similar a chiarapaglioni/GAIA-agents pero simplificado.
+Model wrapper para usar Google Gemini u otros modelos vía LiteLLM.
+Optimizado para ejecución en Hugging Face Spaces (sin bloqueos prolongados).
 """
 
 import os
 import time
 import re
-from typing import Any, Optional
+import logging
 from functools import lru_cache
+from typing import Optional
 
 try:
     from litellm import completion, RateLimitError
     LITELLM_AVAILABLE = True
 except ImportError:
     LITELLM_AVAILABLE = False
-    print("⚠️  LiteLLM no instalado. Instala con: pip install litellm")
+    print("⚠️ LiteLLM no instalado. Instala con: pip install litellm")
+
+# Configurar logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 
 
 class GeminiModel:
-    """Wrapper para Gemini usando LiteLLM con manejo de rate limits."""
-    
-    def __init__(self, model_id: str = "gemini/gemini-2.0-flash-exp", api_key: Optional[str] = None, max_retries: int = 3):
-        """
-        Inicializa el modelo Gemini.
-        
-        Args:
-            model_id: ID del modelo Gemini (con prefijo gemini/)
-            api_key: API key de Google (GEMINI_API_KEY del env si no se proporciona)
-            max_retries: Número máximo de reintentos en caso de rate limit (default: 3)
-        """
+    """Wrapper universal para modelos soportados por LiteLLM (por defecto Gemini)."""
+
+    def __init__(
+        self,
+        model_id: str = "gemini/gemini-2.0-flash-exp",
+        api_key: Optional[str] = None,
+        max_retries: int = 3,
+        retry_base_delay: int = 10,
+    ):
         if not LITELLM_AVAILABLE:
             raise ImportError("LiteLLM es requerido. Instala con: pip install litellm")
-        
+
         self.model_id = model_id
         self.api_key = api_key or os.getenv("GEMINI_API_KEY")
         self.max_retries = max_retries
-        
+        self.retry_base_delay = retry_base_delay
+
         if not self.api_key:
-            raise ValueError("GEMINI_API_KEY no encontrada en variables de entorno")
-    
+            raise ValueError("⚠️ GEMINI_API_KEY no encontrada en variables de entorno")
+
     def __call__(self, messages, **kwargs):
         """
         Llama al modelo con manejo de rate limits.
-        
-        Args:
-            messages: Lista de mensajes en formato OpenAI/LiteLLM
-            **kwargs: Argumentos adicionales (temperature, max_tokens, etc.)
-            
-        Returns:
-            str: Respuesta del modelo
         """
         for attempt in range(self.max_retries):
             try:
@@ -56,79 +53,64 @@ class GeminiModel:
                     model=self.model_id,
                     messages=messages,
                     api_key=self.api_key,
-                    **kwargs
+                    **kwargs,
                 )
-                return response.choices[0].message.content
-            
+                content = response.choices[0].message.content
+                return content.strip()
+
             except RateLimitError as e:
-                error_str = str(e)
-                
-                # Si ya es el último intento, no esperar más
-                if attempt >= self.max_retries - 1:
-                    print(f"❌ Rate limit excedido después de {self.max_retries} intentos")
+                delay = self._parse_retry_delay(str(e))
+                if attempt < self.max_retries - 1:
+                    wait_time = min(delay, self.retry_base_delay * (attempt + 1))
+                    logger.warning(f"⏳ Rate limit ({self.model_id}), reintentando en {wait_time}s...")
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"❌ Rate limit después de {self.max_retries} intentos.")
                     return "ERROR: Rate limit exceeded"
-                
-                print(f"⚠️  RateLimitError (intento {attempt + 1}/{self.max_retries})")
-                
-                # Intentar extraer tiempo de espera del error
-                match = re.search(r'"retryDelay": ?"(\d+)s"', error_str)
-                retry_seconds = int(match.group(1)) if match else 60  # Default 60s
-                
-                print(f"💤 Esperando {retry_seconds} segundos antes de reintentar...")
-                time.sleep(retry_seconds + 2)  # +2 segundos de buffer
-            
+
             except Exception as e:
-                if attempt == self.max_retries - 1:
-                    print(f"❌ Error después de {self.max_retries} intentos: {e}")
-                    raise
-                
-                print(f"⚠️  Error en intento {attempt + 1}/{self.max_retries}: {e}")
-                time.sleep(5)
-        
-        # Si llegamos aquí, se agotaron los reintentos
-        error_msg = f"Rate limit excedido después de {self.max_retries} reintentos."
-        print(f"❌ {error_msg}")
-        raise Exception(error_msg)
-    
-    def generate_simple(self, prompt: str, **kwargs) -> str:
+                if attempt < self.max_retries - 1:
+                    logger.warning(f"⚠️ Error intento {attempt + 1}/{self.max_retries}: {e}")
+                    time.sleep(2 * (attempt + 1))
+                    continue
+                logger.error(f"❌ Error fatal en {self.model_id}: {e}")
+                raise
+
+        return "ERROR: Maximum retries exceeded"
+
+    def _parse_retry_delay(self, error_str: str) -> int:
+        """Extrae tiempo sugerido de espera desde un error RateLimit."""
+        match = re.search(r'"retryDelay": ?"(\d+)s"', error_str)
+        return int(match.group(1)) if match else 10
+
+    def generate_simple(self, prompt: str, system: Optional[str] = None, **kwargs) -> str:
         """
-        Helper para generar respuesta desde un prompt simple.
-        
-        Args:
-            prompt: Texto del prompt
-            **kwargs: Argumentos adicionales
-            
-        Returns:
-            str: Respuesta generada
+        Helper para prompts simples.
+        Permite un 'system prompt' opcional.
         """
-        messages = [{"role": "user", "content": prompt}]
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
         return self(messages, **kwargs)
 
 
-@lru_cache(maxsize=1)
+@lru_cache(maxsize=2)
 def get_gemini_model(model_id: str = "gemini/gemini-2.0-flash-exp", **kwargs) -> GeminiModel:
-    """
-    Factory function con cache para obtener instancia del modelo Gemini.
-    
-    Args:
-        model_id: ID del modelo Gemini
-        **kwargs: Argumentos adicionales
-        
-    Returns:
-        GeminiModel: Instancia del modelo con cache
-    """
+    """Factory con cache para Gemini."""
     return GeminiModel(model_id=model_id, **kwargs)
 
 
 def get_model(model_id: str = "gemini/gemini-2.0-flash-exp", **kwargs) -> GeminiModel:
     """
-    Función principal para obtener modelo.
-    
-    Args:
-        model_id: ID del modelo (por defecto Gemini Flash)
-        **kwargs: Argumentos adicionales
-        
-    Returns:
-        GeminiModel: Instancia del modelo
+    Factory principal. Permite usar distintos modelos:
+    - gemini/gemini-2.0-flash-exp (por defecto)
+    - openai/gpt-4o-mini
+    - anthropic/claude-3-haiku
+    - mistral/mistral-tiny, etc.
     """
-    return get_gemini_model(model_id, **kwargs)
+    if "gemini" in model_id:
+        return get_gemini_model(model_id, **kwargs)
+    else:
+        # Usa API_KEY genérica de LiteLLM (OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.)
+        return GeminiModel(model_id=model_id, api_key=kwargs.get("api_key"))