Convert chat history to the format expected by Gradio 5.x

app.py

@@ -197,9 +197,22 @@ def generate_plot(data, x_col, y_col, title, x_label, y_label):
     
     return plot_path
 
+def convert_to_messages_format(chat_history):
+    """Convert chat history to the format expected by Gradio 5.x"""
+    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]})
+    return messages
+
 async def stream_agent_response(question: str, chat_history: List) -> Tuple[List, Dict]:
     """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)
+    
     if not agent:
         error_msg = (
             "## ⚠️ Error: Agente no inicializado\n\n"
@@ -209,26 +222,26 @@ 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}"
         )
-        chat_history = chat_history + [[question, error_msg]]
-        yield chat_history, gr.update(visible=False)
-        return
+        messages.append({"role": "user", "content": question})
+        messages.append({"role": "assistant", "content": error_msg})
+        return messages, gr.update(visible=False)
     
     try:
-        # Agregar un mensaje de "pensando"
-        chat_history = chat_history + [[question, None]]
-        yield chat_history, gr.update(visible=False)
+        # Add user's question to the chat history
+        messages.append({"role": "user", "content": question})
+        yield messages, gr.update(visible=False)
         
-        # Ejecutar el agente
-        response = await agent.ainvoke({"input": question, "chat_history": chat_history[:-1]})
+        # Execute the agent
+        response = await agent.ainvoke({"input": question, "chat_history": chat_history})
         
-        # Procesar la respuesta
+        # Process the response
         if hasattr(response, 'output'):
             response_text = response.output
             
-            # Verificar si la respuesta contiene una consulta SQL
+            # Check if the response contains an SQL query
             sql_query = extract_sql_query(response_text)
             if sql_query:
-                # Ejecutar la consulta y actualizar la respuesta
+                # Execute the query and update the response
                 db_connection, _ = setup_database_connection()
                 if db_connection:
                     query_result = execute_sql_query(sql_query, db_connection)
@@ -238,14 +251,14 @@ async def stream_agent_response(question: str, chat_history: List) -> Tuple[List
         else:
             response_text = "Error: No se recibió respuesta del agente."
         
-        # Actualizar el historial con la respuesta completa
-        chat_history[-1][1] = response_text
-        yield chat_history, gr.update(visible=False)
+        # Add assistant's response to the chat history
+        messages.append({"role": "assistant", "content": response_text})
+        yield messages, gr.update(visible=False)
         
     except Exception as e:
         error_msg = f"## ❌ Error\n\nOcurrió un error al procesar tu solicitud:\n\n```\n{str(e)}\n```"
-        chat_history[-1][1] = error_msg
-        yield chat_history, gr.update(visible=False)
+        messages.append({"role": "assistant", "content": error_msg})
+        yield messages, gr.update(visible=False)
         yield chat_history, gr.update(visible=False)
 
 # Custom CSS for the app
@@ -466,21 +479,40 @@ def create_application():
     # Create the UI components
     demo, chatbot, question_input, submit_button, streaming_output_display = create_ui()
     
-    def user_message(user_input: str, chat_history: List) -> Tuple[str, List]:
+    def user_message(user_input: str, chat_history: List[Dict]) -> Tuple[str, List[Dict]]:
         """Add user message to chat history and clear input."""
         if not user_input.strip():
             return "", chat_history
+            
         logger.info(f"User message: {user_input}")
-        return "", chat_history + [[user_input, None]]
+        
+        # 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
     
-    def bot_response(chat_history: List) -> Tuple[List, Dict]:
+    def bot_response(chat_history: List[Dict]) -> Tuple[List[Dict], Dict]:
         """Get bot response and update chat history."""
-        if not chat_history or not chat_history[-1][0]:
+        if not chat_history or not chat_history[-1].get("role") == "user":
             return chat_history, gr.update(visible=False)
         
-        question = chat_history[-1][0]
+        # Get the last user message
+        question = chat_history[-1]["content"]
         logger.info(f"Processing question: {question}")
-        return stream_agent_response(question, chat_history[:-1])
+        
+        # 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
+        return stream_agent_response(question, old_format[:-1])
     
     # Event handlers
     with demo: