Update app.py

app.py

@@ -166,17 +166,18 @@ def run_llm_system_and_user(system_prompt: str, user_text: str, model: str = LLM
 # -----------------------
 # Pipeline: analyze -> produce analysis, seed chat
 # -----------------------
+# -----------------------
+# PIPELINE: analyze -> produce analysis, seed chat (Gradio-friendly messages)
+# -----------------------
 def analyze_and_seed_chat(prompts_text: str):
     """
     Called when user clicks Analyze.
-    - prompts_text: newline-separated queries provided by user.
-    Returns: (analysis_text, initial_chat_history)
-    Where initial_chat_history is a list of tuples for gr.Chatbot: [(user_msg, assistant_msg), ...].
+    Returns: (analysis_text, initial_chat_messages_list)
+    initial_chat_messages_list is a list of dicts: {"role": "user"|"assistant", "content": "..."}
     """
     if not prompts_text.strip():
         return "Please enter at least one prompt (query) describing what data to gather.", []
 
-    # Prepare queries
     queries = [line.strip() for line in prompts_text.splitlines() if line.strip()]
     scraped = multi_scrape(queries, delay=SCRAPE_DELAY)
     if scraped.startswith("ERROR"):
@@ -186,49 +187,54 @@ def analyze_and_seed_chat(prompts_text: str):
     user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease follow the system instructions and output the analysis."
 
     analysis = run_llm_system_and_user(PROMPT_TEMPLATE, user_payload)
-    # short validation
     if analysis.startswith("ERROR"):
         return analysis, []
 
-    # Prepare initial chat history: seed assistant with analysis (the assistant message)
-    # Put the user's original request as the first user message in chat history for context.
-    initial_chat = []
-    initial_chat.append((f"Analyze the data I provided (prompts: {', '.join(queries)})", analysis))
+    # Seed chat with a user message (the user's original analyze request) and assistant reply (the analysis)
+    initial_chat = [
+        {"role": "user", "content": f"Analyze the data I provided (prompts: {', '.join(queries)})"},
+        {"role": "assistant", "content": analysis}
+    ]
     return analysis, initial_chat
 
 # -----------------------
 # Chat interaction after analysis
 # -----------------------
-def continue_chat(chat_history, user_message, analysis_text):
+# -----------------------
+# Chat: handle follow-ups (append messages as dicts)
+# -----------------------
+def continue_chat(chat_messages, user_message, analysis_text):
     """
-    chat_history: list of (user, assistant) tuples (existing)
-    user_message: new user message (string)
-    analysis_text: the original analysis text produced (we keep as long-term context)
-    Returns: updated chat history including the assistant reply.
+    chat_messages: list of message dicts (role/content)
+    user_message: new user message string
+    analysis_text: original analysis string (kept as reference context)
+
+    Returns: updated list of message dicts
     """
-    # Build LLM input: system prompt + context (analysis_text) + prior chat + new query
-    if not analysis_text:
-        return chat_history + [(user_message, "No analysis available. Please click Analyze first.")]
+    if chat_messages is None:
+        chat_messages = []
 
-    # Compose a concise system message instructing the assistant to be consistent with the analysis
+    if not user_message or not user_message.strip():
+        return chat_messages
+
+    # Append user's new message
+    chat_messages.append({"role": "user", "content": user_message})
+
+    # Build LLM input using the analysis_text as reference
     followup_system = (
         "You are AURA, a helpful analyst. The conversation context includes a recently generated analysis "
-        "from scraped data. Use that analysis as ground truth context; answer follow-up questions "
-        "about the analysis, explain rationale, and provide clarifications. Be concise and actionable."
+        "from scraped data. Use that analysis as ground truth context; answer follow-up questions, explain rationale, and provide clarifications. Be concise and actionable."
     )
 
-    # Build the user text: include the analysis as a reference block plus the user's question
     user_payload = f"REFERENCE ANALYSIS:\n\n{analysis_text}\n\nUSER QUESTION: {user_message}\n\nRespond concisely and reference lines from the analysis where appropriate."
 
-    # Call LLM
     assistant_reply = run_llm_system_and_user(followup_system, user_payload)
     if assistant_reply.startswith("ERROR"):
         assistant_reply = assistant_reply
 
-    # Append to local chat history
-    chat_history = list(chat_history)  # ensure mutable copy
-    chat_history.append((user_message, assistant_reply))
-    return chat_history
+    # Append assistant reply
+    chat_messages.append({"role": "assistant", "content": assistant_reply})
+    return chat_messages
 
 # -----------------------
 # Gradio UI
@@ -306,9 +312,13 @@ def build_demo():
             updated_history = continue_chat(chat_state_list or [], user_msg, analysis_text)
             return updated_history, ""  # second value clears the user_input box
 
-        def render_chat(chat_state_list):
-            """Render the chat_state into the Chatbot component."""
-            return chat_state_list or []
+        def render_chat(chat_messages):
+            """
+            gr.Chatbot in this Gradio version accepts a list of message dicts.
+            Return the message list as-is (or return [] if None).
+            """
+            return chat_messages or []
+
 
         # ---- Wire handlers to UI components ----
         analyze_btn.click(