updated the chatbot history

app.py

@@ -288,19 +288,44 @@ def generate_plot(data, x_col, y_col, title, x_label, y_label):
 
 def convert_to_messages_format(chat_history):
     """Convert chat history to the format expected by Gradio 5.x"""
+    if not chat_history:
+        return []
+        
     messages = []
-    for msg in chat_history:
-        if isinstance(msg, (list, tuple)) and len(msg) == 2:
-            if msg[0]:  # User message
-                messages.append({"role": "user", "content": msg[0]})
-            if msg[1]:  # Assistant message
-                messages.append({"role": "assistant", "content": msg[1]})
+    
+    # If the first element is a list, assume it's in the old format
+    if isinstance(chat_history[0], list):
+        for msg in chat_history:
+            if isinstance(msg, list) and len(msg) == 2:
+                # Format: [user_msg, bot_msg]
+                user_msg, bot_msg = msg
+                if user_msg:
+                    messages.append({"role": "user", "content": user_msg})
+                if bot_msg:
+                    messages.append({"role": "assistant", "content": bot_msg})
+    else:
+        # Assume it's already in the correct format or can be used as is
+        for msg in chat_history:
+            if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                messages.append(msg)
+            elif isinstance(msg, str):
+                # If it's a string, assume it's a user message
+                messages.append({"role": "user", "content": msg})
+    
     return messages
 
-async def stream_agent_response(question: str, chat_history: List) -> Tuple[List, Dict]:
+async def stream_agent_response(question: str, chat_history: List) -> tuple:
     """Procesa la pregunta del usuario y devuelve la respuesta del agente."""
-    # Convert to messages format for Gradio 5.x
-    messages = convert_to_messages_format(chat_history)
+    # Initialize response
+    response_text = ""
+    messages = []
+    
+    # Add previous chat history
+    if chat_history:
+        messages.extend(chat_history)
+    
+    # Add user's question
+    messages.append({"role": "user", "content": question})
     
     if not agent:
         error_msg = (
@@ -311,16 +336,11 @@ async def stream_agent_response(question: str, chat_history: List) -> Tuple[List
             f"3. El modelo de lenguaje esté disponible\n\n"
             f"Error: {agent_error}"
         )
-        messages.append({"role": "user", "content": question})
         messages.append({"role": "assistant", "content": error_msg})
-        yield messages, gr.update(visible=False)
+        yield messages
         return
     
     try:
-        # Add user's question to the chat history
-        messages.append({"role": "user", "content": question})
-        yield messages, gr.update(visible=False)
-        
         # Execute the agent
         response = await agent.ainvoke({"input": question, "chat_history": chat_history})
         
@@ -343,13 +363,14 @@ async def stream_agent_response(question: str, chat_history: List) -> Tuple[List
         
         # Add assistant's response to the chat history
         messages.append({"role": "assistant", "content": response_text})
-        yield messages, gr.update(visible=False)
+        
+        # Yield the updated messages
+        yield messages
         
     except Exception as e:
         error_msg = f"## ❌ Error\n\nOcurrió un error al procesar tu solicitud:\n\n```\n{str(e)}\n```"
         messages.append({"role": "assistant", "content": error_msg})
-        yield messages, gr.update(visible=False)
-        yield chat_history, gr.update(visible=False)
+        yield messages
 
 # Custom CSS for the app
 custom_css = """
@@ -446,7 +467,38 @@ def create_ui():
         # Mensaje de estado
         if not env_ok:
             gr.Warning("⚠️ " + env_message)
-            
+        
+        # Chatbot component
+        chatbot = gr.Chatbot(
+            label="Chat",
+            height=500,
+            show_label=True,
+            container=True,
+            type="messages",
+            elem_id="chatbot"
+        )
+        
+        # Input area
+        with gr.Row():
+            question_input = gr.Textbox(
+                label="",
+                placeholder="Escribe tu pregunta aquí...",
+                container=False,
+                scale=5,
+                min_width=300,
+                max_lines=3,
+                autofocus=True,
+                elem_id="question-input"
+            )
+            submit_button = gr.Button(
+                "Enviar",
+                variant="primary",
+                min_width=100,
+                scale=1,
+                elem_id="send-button"
+            )
+        
+        # System status
         with gr.Accordion("ℹ️ Estado del sistema", open=not env_ok):
             if not DEPENDENCIES_AVAILABLE:
                 gr.Markdown("""
@@ -508,57 +560,6 @@ def create_ui():
                         El asistente está listo para responder tus preguntas sobre la base de datos.
                         """)
         
-        # Interfaz de chat - usando el nuevo formato de mensajes
-        chatbot = gr.Chatbot(
-            label="Chat",
-            height=500,
-            type="messages"  # Usando el nuevo formato de mensajes
-        )
-        
-        # Área de entrada
-        with gr.Row():
-            question_input = gr.Textbox(
-                label="",
-                placeholder="Escribe tu pregunta sobre la base de datos...",
-                elem_id="question-input",
-                container=False,
-                scale=5,
-                min_width=300,
-                max_lines=3,
-                autofocus=True
-            )
-            submit_button = gr.Button(
-                "Enviar",
-                elem_id="send-button",
-                min_width=100,
-                scale=1,
-                variant="primary"
-            )
-        
-        # Información del sistema (solo para depuración)
-        with gr.Accordion("🔍 Información de depuración", open=False):
-            gr.Markdown("""
-            ### Estado del sistema
-            - **Base de datos**: {}
-            - **Modelo**: {}
-            - **Modo**: {}
-            """.format(
-                f"Conectado a {os.getenv('DB_HOST')}/{os.getenv('DB_NAME')}" if db_connected else "No conectado",
-                "gemini-2.0-flash" if agent else "No disponible",
-                "Completo" if agent else "Demo (sin conexión a base de datos)"
-            ))
-            
-            # Mostrar variables de entorno (solo para depuración)
-            if os.getenv("SHOW_ENV_DEBUG", "false").lower() == "true":
-                env_vars = {k: "***" if "PASS" in k or "KEY" in k else v 
-                           for k, v in os.environ.items() 
-                           if k.startswith(('DB_', 'GOOGLE_'))}
-                gr.Code(
-                    json.dumps(env_vars, indent=2, ensure_ascii=False),
-                    language="json",
-                    label="Variables de entorno"
-                )
-        
         # Hidden component for streaming output
         streaming_output_display = gr.Textbox(visible=False)
         
@@ -576,41 +577,53 @@ def create_application():
             
         logger.info(f"User message: {user_input}")
         
-        # Convert to messages format if needed
-        if chat_history and isinstance(chat_history[0], list):
-            chat_history = convert_to_messages_format(chat_history)
-            
-        # Add user message to chat history
-        updated_history = chat_history + [{"role": "user", "content": user_input}]
-        return "", updated_history
+        # Initialize chat history if needed
+        if chat_history is None:
+            chat_history = []
+        
+        # Add user message
+        chat_history.append({"role": "user", "content": user_input})
+        
+        # Add empty assistant response
+        chat_history.append({"role": "assistant", "content": ""})
+        
+        # Clear the input
+        return "", chat_history
     
-    async def bot_response(chat_history: List[Dict]) -> Tuple[List[Dict], Dict]:
+    async def bot_response(chat_history: List[Dict]) -> List[Dict]:
         """Get bot response and update chat history."""
-        if not chat_history or not chat_history[-1].get("role") == "user":
-            return chat_history, gr.update(visible=False)
-        
-        # Get the last user message
-        question = chat_history[-1]["content"]
-        logger.info(f"Processing question: {question}")
+        if not chat_history or chat_history[-1]["role"] != "assistant":
+            return chat_history
         
-        # Convert to old format for backward compatibility with stream_agent_response
-        old_format = []
-        for msg in chat_history:
-            if msg["role"] == "user":
-                old_format.append([msg["content"], None])
-            elif msg["role"] == "assistant" and old_format and len(old_format[-1]) == 2 and old_format[-1][1] is None:
-                old_format[-1][1] = msg["content"]
-        
-        # Call the agent and get the response
-        # We need to consume the async generator and return the last value
-        last_response = None
-        async for response in stream_agent_response(question, old_format[:-1]):
-            last_response = response
-        return last_response
+        try:
+            # Get the user's question (second to last message)
+            if len(chat_history) < 2:
+                return chat_history
+                
+            question = chat_history[-2]["content"]
+            logger.info(f"Processing question: {question}")
+            
+            # Call the agent and stream the response
+            async for response in stream_agent_response(question, chat_history[:-2]):
+                if isinstance(response, tuple) and len(response) > 0 and isinstance(response[0], list):
+                    messages = response[0]
+                    if messages and messages[-1]["role"] == "assistant":
+                        # Update the assistant's response
+                        chat_history[-1] = messages[-1]
+                        yield chat_history
+            
+            logger.info("Response generation complete")
+            
+        except Exception as e:
+            error_msg = f"Error al procesar la solicitud: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            chat_history[-1]["content"] = error_msg
+            yield chat_history
     
     # Event handlers
     with demo:
-        submit_click = submit_button.click(
+        # Handle form submission
+        msg_submit = question_input.submit(
             fn=user_message,
             inputs=[question_input, chatbot],
             outputs=[question_input, chatbot],
@@ -618,11 +631,12 @@ def create_application():
         ).then(
             fn=bot_response,
             inputs=[chatbot],
-            outputs=[chatbot, streaming_output_display],
+            outputs=[chatbot],
             api_name="ask"
         )
         
-        question_input.submit(
+        # Handle button click
+        btn_click = submit_button.click(
             fn=user_message,
             inputs=[question_input, chatbot],
             outputs=[question_input, chatbot],
@@ -630,7 +644,7 @@ def create_application():
         ).then(
             fn=bot_response,
             inputs=[chatbot],
-            outputs=[chatbot, streaming_output_display]
+            outputs=[chatbot]
         )
     
     return demo