Update app.py

app.py

@@ -1,6 +1,6 @@
-# app.py - MateAI v18.3.1: Conciencia Aumentada (Hotfix de Compatibilidad)
+# app.py - MateAI v18.4: Conciencia Aumentada (Corrección de Lógica e Inteligencia)
 # Arquitectura por un asistente de IA para un futuro colaborativo.
-# Cambio: Se reemplaza gr.Box por gr.Group para compatibilidad con versiones antiguas de Gradio.
+# Cambios: Se añade inteligencia conversacional real, manejo de frustración y feedback inmediato.
 
 import gradio as gr
 import random
@@ -11,62 +11,36 @@ import os
 import asyncio
 import logging
 from typing import Dict, Any, List, Optional, Tuple
+import re
 
-# --- LIBRERÍAS DE IA Y NLP ---
-# Usaremos pysentimiento para un análisis de sentimiento robusto en español.
 from pysentimiento import create_analyzer
-
-# --- INTEGRACIÓN CON FIREBASE ---
-# Firebase se usará como nuestro "núcleo de memoria" persistente.
 import firebase_admin
 from firebase_admin import credentials, firestore
 
 # ==============================================================================
 # MÓDULO 1: CONFIGURACIÓN Y CONSTANTES DEL SISTEMA
 # ==============================================================================
-# Define el comportamiento global, los límites y las constantes de la aplicación.
-# Es la "constitución" de MateAI.
-# ==============================================================================
-
 class Config:
-    """Clase de configuración central para todos los parámetros de MateAI."""
-    APP_NAME = "MateAI v18.3: Conciencia Aumentada"
-    APP_VERSION = "18.3.1-hotfix"
-    
-    # --- Configuración de Base de Datos ---
-    FIREBASE_COLLECTION_USERS = "users_v18" # Nueva colección para la arquitectura avanzada.
-    
-    # --- Parámetros del Motor de Personalidad (Basado en el Modelo OCEAN) ---
+    APP_NAME = "MateAI v18.4: Conciencia Aumentada"
+    APP_VERSION = "18.4.0"
+    FIREBASE_COLLECTION_USERS = "users_v18"
     DEFAULT_PSYCH_PROFILE = {
-        "openness": 0.0,          # Apertura a nuevas experiencias
-        "conscientiousness": 0.0, # Organización y responsabilidad
-        "extraversion": 0.0,      # Sociabilidad y energía
-        "agreeableness": 0.0,     # Amabilidad y cooperación
-        "neuroticism": 0.0,       # Estabilidad emocional (inversa)
+        "openness": 0.0, "conscientiousness": 0.0, "extraversion": 0.0,
+        "agreeableness": 0.0, "neuroticism": 0.0
     }
-    
-    # --- Parámetros del Motor de Gamificación ---
-    POINTS_PER_INSIGHT = 10       # Puntos por una reflexión profunda.
-    POINTS_PER_GOAL_COMPLETED = 25# Puntos por completar una meta a largo plazo.
-    POINTS_PER_FEEDBACK = 5       # Puntos por dar feedback a MateAI.
-    
-    # --- Parámetros del Motor de Interacción ---
-    PROACTIVE_CHECKIN_HOURS = 6   # Horas antes de que MateAI considere un "check-in".
-    MAX_MEMORY_STREAM_ITEMS = 200 # Límite de recuerdos para no sobrecargar el perfil.
-    SENTIMENT_THRESHOLD_NEGATIVE = -0.3 # Umbral para detectar sentimiento negativo.
-    SENTIMENT_THRESHOLD_POSITIVE = 0.3 # Umbral para detectar sentimiento positivo.
+    POINTS_PER_INSIGHT = 10
+    PROACTIVE_CHECKIN_HOURS = 6
+    MAX_MEMORY_STREAM_ITEMS = 200
+    SENTIMENT_THRESHOLD_NEGATIVE = -0.3
+    # Palabras clave para detectar frustración o insultos
+    FRUSTRATION_KEYWORDS = ['tonto', 'inútil', 'bruto', 'estúpido', 'mierda', 'carajo', 'dale boludo']
+    META_QUESTION_KEYWORDS = ['para qué', 'de qué te sirve', 'por qué preguntas', 'cuál es el punto']
 
 # ==============================================================================
 # MÓDULO 2: INICIALIZACIÓN DE SERVICIOS EXTERNOS
 # ==============================================================================
-# Conexión a la base de datos y carga de modelos de IA.
-# Este bloque se ejecuta una sola vez al iniciar la aplicación.
-# ==============================================================================
-
-# --- Configuración de Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Inicialización del Analizador de Sentimiento ---
 sentiment_analyzer = None
 try:
     sentiment_analyzer = create_analyzer(task="sentiment", lang="es")
@@ -74,7 +48,6 @@ try:
 except Exception as e:
     logging.error(f"No se pudo cargar el analizador de sentimiento: {e}")
 
-# --- Inicialización de Firebase Admin SDK ---
 db = None
 try:
     if not firebase_admin._apps:
@@ -82,13 +55,13 @@ try:
         if firebase_credentials_json:
             cred_dict = json.loads(firebase_credentials_json)
             if 'project_id' not in cred_dict:
-                cred_dict['project_id'] = 'mateai-815ca' # Reemplazar con tu project_id real si es diferente
+                cred_dict['project_id'] = 'mateai-815ca'
             cred = credentials.Certificate(cred_dict)
             firebase_admin.initialize_app(cred)
             db = firestore.client()
-            logging.info("Firebase Admin SDK inicializado correctamente. Conexión a Firestore establecida.")
+            logging.info("Firebase Admin SDK inicializado correctamente.")
         else:
-            logging.warning("SECRET 'GOOGLE_APPLICATION_CREDENTIALS_JSON' no configurado. La persistencia de datos NO funcionará.")
+            logging.warning("SECRET 'GOOGLE_APPLICATION_CREDENTIALS_JSON' no configurado.")
     else:
         db = firestore.client()
         logging.info("Firebase Admin SDK ya estaba inicializado.")
@@ -99,180 +72,142 @@ except Exception as e:
 # MÓDULO 3: MODELOS DE DATOS Y CLASES CENTRALES
 # ==============================================================================
 class User:
-    """Representa el estado completo de un usuario, incluyendo su personalidad y memoria."""
     def __init__(self, user_id: str, name: str, **kwargs: Any):
         self.user_id: str = user_id
         self.name: str = name
         self.created_at: datetime = kwargs.get('created_at', datetime.now())
         self.last_login: datetime = kwargs.get('last_login', datetime.now())
+        self.login_count: int = kwargs.get('login_count', 0) # NUEVO: Contador de inicios de sesión
         self.psych_profile: Dict[str, float] = kwargs.get('psych_profile', Config.DEFAULT_PSYCH_PROFILE.copy())
         self.memory_stream: List[Dict[str, Any]] = kwargs.get('memory_stream', [])
         self.short_term_context: Dict[str, Any] = {}
-        self.goals: List[Dict[str, Any]] = kwargs.get('goals', [])
         self.connection_points: int = kwargs.get('connection_points', 0)
-        self.achievements: List[str] = kwargs.get('achievements', [])
-        self.last_proactive_checkin: Optional[datetime] = kwargs.get('last_proactive_checkin')
 
     def to_dict(self) -> Dict[str, Any]:
-        """Serializa el objeto User a un diccionario para guardarlo en Firestore."""
         return {
             "user_id": self.user_id, "name": self.name, "created_at": self.created_at.isoformat(),
-            "last_login": self.last_login.isoformat(), "psych_profile": self.psych_profile,
-            "memory_stream": self.memory_stream, "goals": self.goals,
-            "connection_points": self.connection_points, "achievements": self.achievements,
-            "last_proactive_checkin": self.last_proactive_checkin.isoformat() if self.last_proactive_checkin else None
+            "last_login": self.last_login.isoformat(), "login_count": self.login_count,
+            "psych_profile": self.psych_profile, "memory_stream": self.memory_stream,
+            "connection_points": self.connection_points,
         }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> 'User':
-        """Crea una instancia de User a partir de un diccionario de Firestore."""
         data['created_at'] = datetime.fromisoformat(data.get('created_at', datetime.now().isoformat()))
         data['last_login'] = datetime.fromisoformat(data.get('last_login', datetime.now().isoformat()))
-        last_checkin_str = data.get('last_proactive_checkin')
-        data['last_proactive_checkin'] = datetime.fromisoformat(last_checkin_str) if last_checkin_str else None
         profile = Config.DEFAULT_PSYCH_PROFILE.copy()
         profile.update(data.get('psych_profile', {}))
         data['psych_profile'] = profile
         return cls(**data)
-        
-    def add_memory(self, content: str, memory_type: str, sentiment: Dict[str, float], tags: List[str] = []):
-        """Añade un nuevo recuerdo al flujo de memoria del usuario."""
-        if len(self.memory_stream) >= Config.MAX_MEMORY_STREAM_ITEMS:
-            self.memory_stream.pop(0)
-        memory = {"timestamp": datetime.now().isoformat(), "content": content, "type": memory_type, "sentiment": sentiment, "tags": tags}
-        self.memory_stream.append(memory)
-        logging.info(f"Nuevo recuerdo añadido para {self.name}: {content[:50]}...")
 
 # ==============================================================================
-# MÓDULO 4: GESTOR DE DATOS DE USUARIO (CAPA DE PERSISTENCIA)
+# MÓDULO 4: GESTOR DE DATOS DE USUARIO
 # ==============================================================================
 class UserManager:
-    """Maneja la carga, creación y actualización de perfiles de usuario en Firestore."""
     @staticmethod
     async def get_user(user_id: str) -> Optional[User]:
         if not db or not user_id: return None
         try:
-            user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
-            doc = await asyncio.to_thread(user_doc_ref.get)
+            doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
+            doc = await asyncio.to_thread(doc_ref.get)
             if doc.exists:
                 user_data = doc.to_dict()
                 user_data['user_id'] = doc.id
                 user_obj = User.from_dict(user_data)
                 user_obj.last_login = datetime.now()
+                user_obj.login_count += 1 # Aumentamos el contador en cada carga
                 await UserManager.save_user(user_obj)
-                logging.info(f"Usuario '{user_obj.name}' ({user_id}) cargado y actualizado.")
+                logging.info(f"Usuario '{user_obj.name}' cargado. Login #{user_obj.login_count}.")
                 return user_obj
-            else:
-                logging.warning(f"Intento de carga de usuario inexistente: {user_id}")
-                return None
+            return None
         except Exception as e:
-            logging.error(f"Error al cargar usuario {user_id} desde Firestore: {e}")
+            logging.error(f"Error al cargar usuario {user_id}: {e}")
             return None
 
     @staticmethod
     async def create_user(name: str) -> Tuple[Optional[User], str]:
-        if not db: return None, "Error: La base de datos no está disponible."
-        if not name.strip(): return None, "El nombre no puede estar vacío."
+        if not db: return None, "Error de base de datos."
         try:
             user_id = f"{name.lower().replace(' ', '_')}_{int(time.time())}"
-            new_user = User(user_id=user_id, name=name)
+            new_user = User(user_id=user_id, name=name, login_count=1) # El primer login es la creación
             await UserManager.save_user(new_user)
-            msg = f"¡Bienvenido, {name}! Tu perfil ha sido creado. Guarda bien tu ID de Usuario: **{user_id}**"
+            msg = f"¡Bienvenido, {name}! Tu perfil ha sido creado. Guarda este ID: **{user_id}**"
             logging.info(f"Nuevo usuario creado: {name} ({user_id})")
             return new_user, msg
         except Exception as e:
-            logging.error(f"Error al crear usuario en Firestore: {e}")
-            return None, f"Error inesperado al crear el perfil: {e}"
+            logging.error(f"Error al crear usuario: {e}")
+            return None, "Error inesperado al crear perfil."
 
     @staticmethod
     async def save_user(user: User) -> bool:
         if not db: return False
         try:
-            user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user.user_id)
-            await asyncio.to_thread(user_doc_ref.set, user.to_dict())
+            doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user.user_id)
+            await asyncio.to_thread(doc_ref.set, user.to_dict())
             return True
         except Exception as e:
-            logging.error(f"Error al guardar usuario {user.user_id} en Firestore: {e}")
+            logging.error(f"Error al guardar usuario {user.user_id}: {e}")
             return False
 
 # ==============================================================================
-# MÓDULO 5: MOTOR DE PERSONA Y LÓGICA DE IA
+# MÓDULO 5: MOTOR DE PERSONA Y LÓGICA DE IA (REFACTORIZADO)
 # ==============================================================================
 class PersonaEngine:
-    """Orquesta la lógica de IA para generar respuestas y gestionar la interacción."""
     def __init__(self, user: User):
         self.user = user
 
-    async def analyze_sentiment(self, text: str) -> Dict[str, float]:
-        if not sentiment_analyzer: return {"label": "NEU", "score": 1.0}
-        try:
-            analysis = await asyncio.to_thread(sentiment_analyzer.predict, text)
-            return {"label": analysis.output, "score": analysis.probas[analysis.output]}
-        except Exception as e:
-            logging.error(f"Error en análisis de sentimiento: {e}")
-            return {"label": "NEU", "score": 1.0}
-
     def _get_greeting(self) -> str:
+        # CORREGIDO: Saludo diferenciado para la primera vez.
+        if self.user.login_count <= 1:
+            return f"¡Hola, {self.user.name}! Soy MateAI, tu compañero para la introspección. Es un gusto conocerte. Para empezar a entendernos, a veces te haré algunas preguntas. ¿Listo para empezar?"
+        
         hour = datetime.now().hour
         if 5 <= hour < 12: time_greeting = "Buen día"
         elif 12 <= hour < 19: time_greeting = "Buenas tardes"
         else: time_greeting = "Buenas noches"
-        if self.user.psych_profile['extraversion'] > 0.5:
-            return f"¡{time_greeting}, {self.user.name}! ¡Qué bueno verte! ¿En qué andamos hoy?"
-        elif self.user.psych_profile['neuroticism'] > 0.4:
-            return f"{time_greeting}, {self.user.name}. Espero que estés teniendo un día tranquilo. ¿Cómo te sentís?"
-        else:
-            return f"{time_greeting}, {self.user.name}. Un gusto conectar de nuevo."
-
-    async def generate_proactive_checkin(self) -> Optional[str]:
-        now = datetime.now()
-        if self.user.last_proactive_checkin and (now - self.user.last_proactive_checkin < timedelta(hours=Config.PROACTIVE_CHECKIN_HOURS)):
-            return None
-        self.user.last_proactive_checkin = now
-        await UserManager.save_user(self.user)
-        if self.user.psych_profile['conscientiousness'] > 0.5 and self.user.goals:
-            pending_goals = [g['name'] for g in self.user.goals if not g.get('completed')]
-            if pending_goals:
-                return f"¡Hola {self.user.name}! Solo pasaba a saludar y recordarte que tenés metas increíbles como '{pending_goals[0]}' en marcha. ¡Cualquier pasito cuenta!"
-        return self._get_greeting() + " Solo pasaba a ver cómo estabas."
         
+        return f"{time_greeting}, {self.user.name}. Qué bueno conectar de nuevo."
+
     async def generate_response(self, message: str) -> str:
-        sentiment = await self.analyze_sentiment(message)
-        self.user.add_memory(content=message, memory_type="chat", sentiment=sentiment)
-        if sentiment['label'] == 'NEG' and sentiment['score'] > 0.7:
-             return f"Noto que lo que decís tiene una carga fuerte, {self.user.name}. Si querés hablar de ello, acá estoy para escucharte sin juzgar."
-        if abs(sum(self.user.psych_profile.values())) < 0.1:
-            return await self._ask_profiling_question()
-        response = self._craft_default_response(sentiment)
-        await UserManager.save_user(self.user)
-        return response
+        message_lower = message.lower()
+        sentiment = await asyncio.to_thread(sentiment_analyzer.predict, message)
+        
+        # LÓGICA 1: Manejar frustración del usuario. Tiene máxima prioridad.
+        if any(keyword in message_lower for keyword in Config.FRUSTRATION_KEYWORDS) or \
+           (sentiment.output == 'NEG' and sentiment.probas[sentiment.output] > 0.8):
+            return f"Entiendo tu frustración. Claramente mi respuesta anterior no fue buena y pido disculpas. Soy un sistema en desarrollo y tu feedback honesto me ayuda a mejorar. Por favor, decime qué te molestó o cómo puedo ayudarte mejor."
+
+        # LÓGICA 2: Manejar meta-preguntas sobre el propósito.
+        if any(keyword in message_lower for keyword in Config.META_QUESTION_KEYWORDS):
+            return f"Buena pregunta. Te hago estas preguntas para ir construyendo un mapa de tu personalidad, sin que tengas que llenar un formulario. Saber si preferís la improvisación o la planificación, por ejemplo, me ayuda a entender qué tipo de consejos o reflexiones te pueden servir más. No es para juzgar, sino para personalizar nuestra conversación. Por cierto, gracias por preguntar, demuestra curiosidad."
+
+        # LÓGICA 3: Procesar respuesta a una pregunta de perfilado.
+        if self.user.short_term_context.get('last_question'):
+            response, points_awarded = self.process_profiling_answer(message)
+            await UserManager.save_user(self.user)
+            return f"{response} (Por tu reflexión, sumaste **{points_awarded} Puntos de Conexión** 💠)."
 
-    def _craft_default_response(self, sentiment: Dict[str, float]) -> str:
-        responses = [
-            f"Interesante lo que mencionás, {self.user.name}. Me hace pensar en...",
-            f"Entiendo tu punto, {self.user.name}. ¿Cómo se conecta eso con tus metas actuales?",
-            "Gracias por compartir eso. Cada charla nos ayuda a entendernos mejor.",
-        ]
-        if self.user.psych_profile['openness'] > 0.5:
-            responses.append("Eso abre una puerta a una idea nueva. ¿Qué pasaría si lo miramos desde otro ángulo?")
-        if sentiment['label'] == 'POS':
-            responses.append(f"¡Me encanta esa energía, {self.user.name}! Es genial verte así.")
-        return random.choice(responses)
+        # LÓGICA 4: Hacer una pregunta de perfilado si el perfil es nuevo.
+        if abs(sum(self.user.psych_profile.values())) < 0.1: # Perfil casi virgen
+            return self._ask_profiling_question()
 
-    async def _ask_profiling_question(self) -> str:
+        # LÓGICA 5: Respuesta por defecto (mejorada).
+        return self._craft_default_response(message)
+
+    def _ask_profiling_question(self) -> str:
         question = (
-            f"Una pregunta curiosa, {self.user.name}: si tuvieras una tarde libre inesperada, "
-            "¿qué te tienta más? \n"
-            "A) Improvisar y ver a dónde te lleva el día, quizás descubrir un café nuevo o un parque. \n"
+            f"Una pregunta curiosa, {self.user.name}: si tuvieras una tarde libre inesperada, ¿qué te tienta más?\n"
+            "A) Improvisar y ver a dónde te lleva el día, quizás descubrir un café nuevo o un parque.\n"
+  
             "B) Aprovechar para organizar esa pila de libros, planificar la semana o adelantar una tarea pendiente."
         )
         self.user.short_term_context['last_question'] = "openness_vs_conscientiousness"
-        await UserManager.save_user(self.user)
         return question
 
-    def process_profiling_answer(self, answer: str):
+    def process_profiling_answer(self, answer: str) -> Tuple[str, int]:
         question_type = self.user.short_term_context.get('last_question')
-        if not question_type: return
+        if not question_type: return "Hmm, no recuerdo haberte preguntado nada. Sigamos.", 0
+
         answer_lower = answer.lower()
         if question_type == "openness_vs_conscientiousness":
             if 'a' in answer_lower or 'improvisar' in answer_lower:
@@ -281,14 +216,25 @@ class PersonaEngine:
             elif 'b' in answer_lower or 'organizar' in answer_lower:
                 self.user.psych_profile['conscientiousness'] += 0.3
                 self.user.psych_profile['openness'] -= 0.1
+        
         del self.user.short_term_context['last_question']
         self.user.connection_points += Config.POINTS_PER_INSIGHT
         logging.info(f"Perfil de {self.user.name} actualizado. Puntos: {self.user.connection_points}")
+        # CORREGIDO: Devolvemos una respuesta y los puntos ganados para feedback inmediato.
+        return "¡Bárbaro! Gracias por compartirlo, lo tengo en cuenta para que nos entendamos mejor.", Config.POINTS_PER_INSIGHT
+
+    def _craft_default_response(self, message: str) -> str:
+        return random.choice([
+            f"Entendido. ¿Hay algo más en lo que estés pensando, {self.user.name}?",
+            "Ok, te sigo. ¿Querés explorar más esa idea?",
+            "Gracias por compartir. Siempre es bueno tener tu perspectiva.",
+        ])
 
 # ==============================================================================
-# MÓDULO 6: LÓGICA Y ESTRUCTURA DE LA INTERFAZ DE USUARIO (GRADIO)
+# MÓDULO 6: LÓGICA Y ESTRUCTURA DE LA INTERFAZ (GRADIO)
 # ==============================================================================
 async def handle_login_or_creation(action: str, name: str, user_id: str) -> tuple:
+    user, msg = None, ""
     if action == "create":
         if not name:
             gr.Warning("Para crear un perfil, necesito que me digas tu nombre.")
@@ -299,10 +245,10 @@ async def handle_login_or_creation(action: str, name: str, user_id: str) -> tupl
             gr.Warning("¡Che, poné tu ID para cargar el perfil!")
             return None, gr.update(), gr.update(visible=True), gr.update(visible=False)
         user = await UserManager.get_user(user_id)
-        msg = f"¡Hola de nuevo, {user.name}! Perfil cargado." if user else "ID de usuario no encontrado. Verificá que esté bien escrito."
-    else:
-        return None, "Acción desconocida.", gr.update(visible=True), gr.update(visible=False)
+        if not user: msg = "ID de usuario no encontrado. Verificá que esté bien escrito."
+    
     if user:
+        if action == "login": msg = f"Perfil de {user.name} cargado."
         gr.Success(msg)
         initial_greeting = PersonaEngine(user)._get_greeting()
         chat_history = [{"role": "assistant", "content": initial_greeting}]
@@ -315,15 +261,18 @@ async def handle_chat_message(user_state: User, message: str, chat_history: List
     if not user_state:
         gr.Warning("¡Para empezar, creá un perfil o iniciá sesión!")
         return user_state, chat_history, ""
+    
     chat_history.append({"role": "user", "content": message})
+    
     engine = PersonaEngine(user_state)
-    if user_state.short_term_context.get('last_question'):
-        engine.process_profiling_answer(message)
-        response = "¡Bárbaro! Gracias por compartirlo. Lo tengo en cuenta para que nos entendamos mejor."
-    else:
-        response = await engine.generate_response(message)
+    response = await engine.generate_response(message)
+    
+    # Guardamos el estado del usuario DESPUÉS de generar la respuesta.
+    await UserManager.save_user(engine.user)
+    
     chat_history.append({"role": "assistant", "content": response})
-    return user_state, chat_history, ""
+    
+    return engine.user, chat_history, ""
 
 def render_profile_info(user: Optional[User]) -> str:
     if not user: return "Cargá un perfil para ver tu información."
@@ -340,18 +289,15 @@ def render_profile_info(user: Optional[User]) -> str:
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"), css="footer {display: none !important}") as demo:
     current_user = gr.State(None)
     gr.Markdown(f"# 🧉 {Config.APP_NAME}")
-    gr.Markdown(f"*{Config.APP_VERSION}* - Tu compañero de IA para la introspección y el crecimiento.")
+    gr.Markdown(f"*{Config.APP_VERSION}* - Un compañero de IA que aprende con vos.")
 
     with gr.Row():
         with gr.Column(scale=2):
-            # Panel de Chat - Usando gr.Group en lugar de gr.Box para compatibilidad
             with gr.Group(visible=False) as chat_panel:
-                chatbot = gr.Chatbot(label="Conversación con MateAI", height=600, type="messages")
+                chatbot = gr.Chatbot(label="Conversación con MateAI", height=600, type="messages", show_copy_button=True)
                 with gr.Row():
                     chat_input = gr.Textbox(show_label=False, placeholder="Escribí acá con confianza...", scale=4)
                     send_button = gr.Button("Enviar", variant="primary", scale=1)
-
-            # Panel de Login - Usando gr.Group en lugar de gr.Box para compatibilidad
             with gr.Group(visible=True) as login_panel:
                 gr.Markdown("### 🌟 Para empezar...")
                 with gr.Tabs():
@@ -361,20 +307,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"),
                     with gr.TabItem("Cargar Perfil Existente"):
                         userid_input = gr.Textbox(label="Tu ID de Usuario")
                         login_button = gr.Button("Cargar Perfil")
-        
         with gr.Column(scale=1):
-            # Panel de Perfil - Usando gr.Group en lugar de gr.Box para compatibilidad
             with gr.Group():
                 gr.Markdown("### 🧠 Tu Perfil")
                 profile_display = gr.Markdown("Cargá un perfil para ver tu información.")
 
-    # --- Lógica de Eventos de la Interfaz ---
     login_button.click(fn=handle_login_or_creation, inputs=[gr.State("login"), username_input, userid_input], outputs=[current_user, chatbot, login_panel, chat_panel])
     create_button.click(fn=handle_login_or_creation, inputs=[gr.State("create"), username_input, userid_input], outputs=[current_user, chatbot, login_panel, chat_panel])
-    
     chat_input.submit(fn=handle_chat_message, inputs=[current_user, chat_input, chatbot], outputs=[current_user, chatbot, chat_input])
     send_button.click(fn=handle_chat_message, inputs=[current_user, chat_input, chatbot], outputs=[current_user, chatbot, chat_input])
-
     current_user.change(fn=render_profile_info, inputs=[current_user], outputs=[profile_display])
 
 if __name__ == "__main__":