Update app.py

app.py

@@ -1,30 +1,29 @@
-# app.py
+#!/usr/bin/env python3
 """
-AURA Chat — Gradio Space
-Single-file Gradio app that:
-- Accepts newline-separated prompts (data queries) from the user.
-- On "Analyze" scrapes those queries, sends the aggregated text to a locked LLM,
-  and returns a polished analysis with a ranked list of best stocks and an
-  "Investment Duration" (when to enter / when to exit) for each stock.
-- Seeds a chat component with the generated analysis; user can then chat about it.
-Notes:
-- Model, max tokens, and delay between scrapes are fixed and cannot be changed via UI.
-- Set OPENAI_API_KEY in environment (Space Secrets).
+AURA Chat — Gradio Space (single-file)
+- Fixed model, tokens, and scrape delay (not editable in UI).
+- User supplies data prompts (one per line) and presses Analyze.
+- App scrapes via SCRAPER_API_URL, runs LLM analysis, returns a polished "Top picks" analysis
+  with Investment Duration (When to Invest / When to Sell) for each stock.
+- The analysis seeds a chat conversation; the user can then ask follow-ups referencing the analysis.
+- Robust lifecycle: creates/ closes OpenAI client per-call and tries to avoid asyncio fd shutdown warnings.
 """
 
 import os
-import time
 import sys
+import time
 import asyncio
 import requests
 import atexit
 import traceback
+import gc
+import socket
 from datetime import datetime
 from typing import List
 
 import gradio as gr
 
-# Defensive: ensure a fresh event loop early to avoid fd race on shutdown.
+# Defensive: make a fresh event loop early to avoid fd race during interpreter shutdown
 if sys.platform != "win32":
     try:
         loop = asyncio.new_event_loop()
@@ -33,23 +32,27 @@ if sys.platform != "win32":
         traceback.print_exc()
 
 # -----------------------
-# Configuration (fixed)
+# Fixed configuration (locked)
 # -----------------------
 SCRAPER_API_URL = os.getenv("SCRAPER_API_URL", "https://deep-scraper-96.created.app/api/deep-scrape")
 SCRAPER_HEADERS = {"User-Agent": "Mozilla/5.0", "Content-Type": "application/json"}
 
-# FIXED model & tokens (cannot be changed from UI)
-LLM_MODEL = os.getenv("LLM_MODEL", "openai/gpt-oss-20b:free")  # locked model id
-MAX_TOKENS = int(os.getenv("LLM_MAX_TOKENS", "3000"))         # locked max tokens
-SCRAPE_DELAY = float(os.getenv("SCRAPE_DELAY", "1.0"))        # locked delay between scrapes (seconds)
+# Locked model & tokens & delay (not editable from UI)
+LLM_MODEL = os.getenv("LLM_MODEL", "openai/gpt-oss-20b:free")
+MAX_TOKENS = int(os.getenv("LLM_MAX_TOKENS", "3000"))
+SCRAPE_DELAY = float(os.getenv("SCRAPE_DELAY", "1.0"))
 
-# OpenAI key is read from env (set in HF Space Secrets). We create the client lazily per-call.
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://openrouter.ai/api/v1")
 
-# If OPENAI_API_KEY is missing, UI will show a clear error on Analyze click.
+# Attempt to import OpenAI client class (SDK must be installed)
+try:
+    from openai import OpenAI
+except Exception:
+    OpenAI = None
+
 # -----------------------
-# Prompt engineering (fixed) — instruct the model to produce consistent output.
+# System prompt (locked)
 # -----------------------
 PROMPT_TEMPLATE = f"""
 You are AURA, a concise, professional hedge-fund research assistant.
@@ -57,24 +60,20 @@ You are AURA, a concise, professional hedge-fund research assistant.
 Task:
 - Given scraped data below, produce a clear, readable analysis that:
   1) Lists the top 5 stock picks (or fewer if not enough data).
-  2) For each stock provide: Ticker / Company name, short rationale (2-3 bullets),
-     and an explicit **Investment Duration** entry: a one-line "When to Invest" and
-     a one-line "When to Sell" instruction (these two lines are mandatory for each stock).
-  3) Keep each stock entry short and scannable. Use a bullet list or numbered list.
-  4) At the top, provide a 2-3 sentence summary conclusion (market context + highest conviction pick).
-  5) Output in plain text, clean formatting, easy for humans to read. No JSON.
-  6) After the list, include a concise "Assumptions & Risks" section (2-3 bullet points).
-
-Important: Be decisive. If data is insufficient, state that clearly and provide the best-available picks with lower confidence.
-Max tokens for the LLM response: {MAX_TOKENS}
+  2) For each stock provide: Ticker / Company name, 2 short rationale bullets,
+     and an explicit **Investment Duration** entry: one-line "When to Invest" and one-line "When to Sell".
+  3) Provide a 2–3 sentence summary conclusion at the top.
+  4) After the list, include a concise "Assumptions & Risks" section (2–3 bullets).
+  5) Use clean, scannable formatting (numbered list, bold headers). No JSON. Human-readable.
+
 Model: {LLM_MODEL}
+Max tokens: {MAX_TOKENS}
 """
 
 # -----------------------
-# Helper: scraping
+# Scraping helpers
 # -----------------------
 def deep_scrape(query: str, retries: int = 3, timeout: int = 40) -> str:
-    """Post a query to SCRAPER_API_URL and return a readable aggregation (or an error string)."""
     payload = {"query": query}
     last_err = None
     for attempt in range(1, retries + 1):
@@ -82,14 +81,12 @@ def deep_scrape(query: str, retries: int = 3, timeout: int = 40) -> str:
             resp = requests.post(SCRAPER_API_URL, headers=SCRAPER_HEADERS, json=payload, timeout=timeout)
             resp.raise_for_status()
             data = resp.json()
-            # Format into readable text
             if isinstance(data, dict):
-                parts = []
+                pieces = []
                 for k, v in data.items():
-                    parts.append(f"{k.upper()}:\n{v}\n")
-                return "\n".join(parts)
-            else:
-                return str(data)
+                    pieces.append(f"{k.upper()}:\n{v}\n")
+                return "\n".join(pieces)
+            return str(data)
         except Exception as e:
             last_err = e
             if attempt < retries:
@@ -99,7 +96,6 @@ def deep_scrape(query: str, retries: int = 3, timeout: int = 40) -> str:
     return f"ERROR: {last_err}"
 
 def multi_scrape(queries: List[str], delay: float = SCRAPE_DELAY) -> str:
-    """Scrape multiple queries and join results into one large string."""
     aggregated = []
     for q in queries:
         q = q.strip()
@@ -112,21 +108,13 @@ def multi_scrape(queries: List[str], delay: float = SCRAPE_DELAY) -> str:
     return "\n".join(aggregated)
 
 # -----------------------
-# LLM interaction (safe: create+close per call)
+# LLM call (safe create/close per-call)
 # -----------------------
-# Using the 'openai' SDK style that provides OpenAI class available in some providers.
-# If your environment uses a different SDK, adjust accordingly.
-try:
-    from openai import OpenAI  # keep import local; if package missing, we'll error nicely at runtime
-except Exception:
-    OpenAI = None
-
 def run_llm_system_and_user(system_prompt: str, user_text: str, model: str = LLM_MODEL, max_tokens: int = MAX_TOKENS) -> str:
-    """Create the OpenAI client lazily, call the chat completions endpoint, then close."""
     if OpenAI is None:
-        return "ERROR: `openai` package not installed or available. See requirements."
+        return "ERROR: `openai` package not installed (see requirements)."
     if not OPENAI_API_KEY:
-        return "ERROR: OPENAI_API_KEY not set in environment. Please add it to Space Secrets."
+        return "ERROR: OPENAI_API_KEY not set in environment."
 
     client = None
     try:
@@ -139,7 +127,7 @@ def run_llm_system_and_user(system_prompt: str, user_text: str, model: str = LLM
             ],
             max_tokens=max_tokens,
         )
-        # Extract content robustly
+        # Guarded extraction
         if hasattr(completion, "choices") and len(completion.choices) > 0:
             try:
                 return completion.choices[0].message.content
@@ -149,13 +137,11 @@ def run_llm_system_and_user(system_prompt: str, user_text: str, model: str = LLM
     except Exception as e:
         return f"ERROR: LLM call failed: {e}"
     finally:
-        # try to close client transport
         try:
             if client is not None:
                 try:
                     client.close()
                 except Exception:
-                    # try async close if available
                     try:
                         asyncio.get_event_loop().run_until_complete(client.aclose())
                     except Exception:
@@ -164,18 +150,14 @@ def run_llm_system_and_user(system_prompt: str, user_text: str, model: str = LLM
             pass
 
 # -----------------------
-# Pipeline: analyze -> produce analysis, seed chat
-# -----------------------
-# -----------------------
-# PIPELINE: analyze -> produce analysis, seed chat (Gradio-friendly messages)
+# Pipeline functions (Gradio-friendly: use message dicts)
 # -----------------------
 def analyze_and_seed_chat(prompts_text: str):
     """
-    Called when user clicks Analyze.
-    Returns: (analysis_text, initial_chat_messages_list)
-    initial_chat_messages_list is a list of dicts: {"role": "user"|"assistant", "content": "..."}
+    Returns: analysis_text (string), initial_chat (list of message dicts)
+    message dicts: {"role": "user"|"assistant", "content": "..."}
     """
-    if not prompts_text.strip():
+    if not prompts_text or not prompts_text.strip():
         return "Please enter at least one prompt (query) describing what data to gather.", []
 
     queries = [line.strip() for line in prompts_text.splitlines() if line.strip()]
@@ -183,33 +165,20 @@ def analyze_and_seed_chat(prompts_text: str):
     if scraped.startswith("ERROR"):
         return scraped, []
 
-    # Compose user payload for LLM: scraped data + instruction to format picks only
-    user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease follow the system instructions and output the analysis."
-
+    user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease produce the analysis as instructed in the system prompt."
     analysis = run_llm_system_and_user(PROMPT_TEMPLATE, user_payload)
     if analysis.startswith("ERROR"):
         return 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}
+        {"role": "user", "content": f"Analyze the data provided (prompts: {', '.join(queries)})"},
+        {"role": "assistant", "content": analysis},
     ]
     return analysis, initial_chat
 
-# -----------------------
-# Chat interaction after analysis
-# -----------------------
-# -----------------------
-# Chat: handle follow-ups (append messages as dicts)
-# -----------------------
-def continue_chat(chat_messages, user_message, analysis_text):
+def continue_chat(chat_messages: List[dict], user_message: str, analysis_text: str) -> List[dict]:
     """
-    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
+    Appends user message and assistant response, returns updated list of message dicts.
     """
     if chat_messages is None:
         chat_messages = []
@@ -217,163 +186,248 @@ def continue_chat(chat_messages, user_message, analysis_text):
     if not user_message or not user_message.strip():
         return chat_messages
 
-    # Append user's new message
+    # Append user 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, explain rationale, and provide clarifications. Be concise and actionable."
+        "You are AURA, a helpful analyst. Use the provided analysis as the authoritative context. "
+        "Answer follow-up questions about the analysis, explain rationale, and be concise and actionable."
     )
-
-    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."
+    user_payload = f"REFERENCE ANALYSIS:\n\n{analysis_text}\n\nUSER QUESTION: {user_message}\n\nAnswer concisely."
 
     assistant_reply = run_llm_system_and_user(followup_system, user_payload)
-    if assistant_reply.startswith("ERROR"):
-        assistant_reply = assistant_reply
-
-    # Append assistant reply
     chat_messages.append({"role": "assistant", "content": assistant_reply})
     return chat_messages
 
 # -----------------------
-# Gradio UI
+# Aggressive cleanup to reduce 'Invalid file descriptor: -1' noise at shutdown
+# -----------------------
+def _aggressive_cleanup():
+    try:
+        gc.collect()
+    except Exception:
+        pass
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            try:
+                loop.stop()
+            except Exception:
+                pass
+        if not loop.is_closed():
+            try:
+                loop.close()
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    # Close any lingering sockets found via GC (best-effort)
+    try:
+        for obj in gc.get_objects():
+            try:
+                if isinstance(obj, socket.socket):
+                    try:
+                        obj.close()
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+atexit.register(_aggressive_cleanup)
+
+# -----------------------
+# Beautiful responsive UI (single build function)
 # -----------------------
 def build_demo():
     with gr.Blocks(title="AURA Chat — Hedge Fund Picks") as demo:
-
-        # Inject custom CSS safely
+        # Inject responsive CSS & fonts
         gr.HTML("""
+        <link rel="preconnect" href="https://fonts.googleapis.com">
+        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;700;800&display=swap" rel="stylesheet">
         <style>
-            .gradio-container { max-width: 1100px; margin: 18px auto; }
-            .header { text-align: left; margin-bottom: 6px; }
-            .muted { color: #7d8590; font-size: 14px; }
-            .analysis-box {
-                background: #ffffff;
-                border-radius: 8px;
-                padding: 12px;
-                box-shadow: 0 4px 14px rgba(0,0,0,0.06);
+            :root{
+                --bg:#0f1724;
+                --card:#0b1220;
+                --muted:#9aa4b2;
+                --accent:#6ee7b7;
+                --glass: rgba(255,255,255,0.03);
+            }
+            body, .gradio-container { font-family: Inter, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial; background: linear-gradient(180deg,#071028 0%, #071831 100%); color: #e6eef6; }
+            .container { max-width:1200px; margin:18px auto; padding:18px; }
+            .topbar { display:flex; gap:12px; align-items:center; justify-content:space-between; margin-bottom:12px; }
+            .brand { display:flex; gap:12px; align-items:center; }
+            .logo { width:48px; height:48px; border-radius:10px; background:linear-gradient(135deg,#10b981,#06b6d4); display:flex; align-items:center; justify-content:center; font-weight:700; color:#021028; font-size:18px; box-shadow:0 8px 30px rgba(2,16,40,0.6); }
+            .title { font-size:20px; font-weight:700; margin:0; }
+            .subtitle { color:var(--muted); font-size:13px; margin-top:2px; }
+            .panel { background: linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.01)); border-radius:12px; padding:14px; box-shadow: 0 6px 30px rgba(2,6,23,0.7); border:1px solid rgba(255,255,255,0.03); }
+            .left { min-width: 300px; max-width: 520px; }
+            .right { flex:1; }
+            .analysis-card { background: linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.01)); padding:14px; border-radius:10px; min-height:220px; overflow:auto; }
+            .muted { color:var(--muted); font-size:13px; }
+            .small { font-size:12px; color:var(--muted); }
+            .button-row { display:flex; gap:10px; margin-top:10px; }
+            .pill { display:inline-block; background: rgba(255,255,255,0.03); padding:6px 10px; border-radius:999px; color:var(--muted); font-size:13px; }
+            .chat-container { height:420px; overflow:auto; border-radius:10px; padding:8px; background: linear-gradient(180deg, rgba(255,255,255,0.01), rgba(255,255,255,0.005)); border:1px solid rgba(255,255,255,0.03); }
+            /* Responsive */
+            @media (max-width: 880px){
+                .topbar { flex-direction:column; align-items:flex-start; gap:6px; }
+                .layout-row { flex-direction:column; gap:12px; }
             }
         </style>
         """)
 
-        gr.Markdown("# AURA Chat — Hedge Fund Picks")
-        gr.Markdown("**Enter one or more data prompts (one per line)** — e.g. `SEC insider transactions october 2025 company XYZ`.\n\nOnly input prompts; model, tokens and timing are fixed. Press **Analyze** to fetch & generate the picks. After analysis you can chat with the assistant about the results.")
-
-        with gr.Row():
+        # Top bar / header
+        with gr.Row(elem_id="top-row"):
             with gr.Column(scale=1):
-                prompts = gr.Textbox(
-                    lines=6,
-                    label="Data Prompts (one per line)",
-                    placeholder="SEC insider transactions october 2025\n13F filings Q3 2025\ncompany: ACME corp insider buys"
+                gr.HTML(
+                    """
+                    <div class="container">
+                      <div class="topbar">
+                        <div class="brand">
+                          <div class="logo">A</div>
+                          <div>
+                            <div class="title">AURA — Hedge Fund Picks</div>
+                            <div class="subtitle">Scrape • Synthesize • Serve concise investment durations</div>
+                          </div>
+                        </div>
+                        <div class="small">Model locked • Max tokens locked • Delay locked</div>
+                      </div>
+                    </div>
+                    """
                 )
-                analyze_btn = gr.Button("Analyze", variant="primary")
-                error_box = gr.Markdown("", visible=False)
-                gr.Markdown(f"**Fixed settings:** Model = `{LLM_MODEL}`  •  Max tokens = `{MAX_TOKENS}`  •  Scrape delay = `{SCRAPE_DELAY}s`")
-                gr.Markdown("**Important:** Add your `OPENAI_API_KEY` to Space Secrets before running.")
-            with gr.Column(scale=1):
-                analysis_out = gr.Textbox(
-                    label="Generated Analysis (Top picks with Investment Duration)",
-                    lines=18,
-                    interactive=False
-                )
-                gr.Markdown("**Chat with AURA about this analysis**")
-                chatbot = gr.Chatbot(label="AURA Chat", height=420)
-                user_input = gr.Textbox(
-                    placeholder="Ask a follow-up question about the analysis...",
-                    label="Your question"
-                )
-                send_btn = gr.Button("Send")
 
-        # States
-        analysis_state = gr.State("")   # holds the analysis text
-        chat_state = gr.State([])       # holds list of (user, assistant) tuples
+        # Main layout
+        with gr.Row(elem_classes="layout-row", visible=True):
+            # Left column: inputs
+            with gr.Column(scale=1, min_width=320, elem_classes="left"):
+                with gr.Group(elem_classes="panel"):
+                    gr.Markdown("### Data prompts")
+                    prompts = gr.Textbox(lines=6, placeholder="SEC insider transactions october 2025\n13F filings Q3 2025\ncompany: ACME corp insider buys", label=None)
+                    gr.Markdown("**Only provide prompts**. Model, tokens and scrape delay are fixed.")
+                    with gr.Row():
+                        analyze_btn = gr.Button("Analyze", variant="primary")
+                        clear_btn = gr.Button("Clear", variant="secondary")
+                    gr.Markdown("**Status**")
+                    status = gr.Markdown("Idle", elem_id="status-box")
+                    gr.Markdown("**Settings**")
+                    gr.HTML(f"<div class='pill'>Model: {LLM_MODEL}</div> <div class='pill'>Max tokens: {MAX_TOKENS}</div> <div class='pill'>Delay: {SCRAPE_DELAY}s</div>")
+
+            # Right column: analysis + chat
+            with gr.Column(scale=2, min_width=420, elem_classes="right"):
+                with gr.Group(elem_classes="panel"):
+                    gr.Markdown("### Generated Analysis")
+                    analysis_html = gr.HTML("<div class='analysis-card muted'>No analysis yet. Enter prompts and press <strong>Analyze</strong>.</div>")
+                    gr.Markdown("### Chat (ask follow-ups about the analysis)")
+                    chatbot = gr.Chatbot(elem_classes="chat-container", label=None)
+                    with gr.Row():
+                        user_input = gr.Textbox(placeholder="Ask a follow-up question about the analysis...", label=None)
+                        send_btn = gr.Button("Send", variant="primary")
+
+        # Hidden states
+        analysis_state = gr.State("")       # string
+        chat_state = gr.State([])           # list of message dicts
+
+        # ---- Handler functions (defined in scope) ----
+        def set_status(text: str):
+            # small helper to update status markdown box
+            return gr.update(value=f"**{text}**")
+
+        def on_clear():
+            return "", gr.update(value="<div class='analysis-card muted'>No analysis yet. Enter prompts and press <strong>Analyze</strong>.</div>"), [], gr.update(value=[]), set_status("Cleared")
+
+        def on_analyze(prompts_text: str):
+            # Start
+            status_msg = "Scraping..."
+            analysis_preview = "<div class='analysis-card muted'>Working... scraping data and calling model. This may take a few seconds.</div>"
+            # Immediately return a quick UI update while heavy work runs (Gradio will process synchronously).
+            # Now run real pipeline:
+            try:
+                status_msg = "Scraping..."
+                # update status for UI
+                # Collect queries
+                queries = [line.strip() for line in (prompts_text or "").splitlines() if line.strip()]
+                if not queries:
+                    return "", gr.update(value="<div class='analysis-card muted'>Please provide at least one data prompt.</div>"), [], [], set_status("Idle")
 
-        # ---- Handler functions (must be defined before wiring) ----
-        def on_analyze(prompts_text):
-            """
-            Called when user clicks Analyze.
-            Returns: analysis_out (string), error_box (gr.Markdown value), analysis_state (string), chat_state (list)
-            """
-            analysis_text, initial_chat = analyze_and_seed_chat(prompts_text)
-            if analysis_text.startswith("ERROR"):
-                # Show error in the error_box; leave other outputs unchanged
-                return "", f"**Error:** {analysis_text}", "", []
-            # Success: fill analysis_out, hide error box (empty string), set analysis_state and seed chat_state
-            return analysis_text, "", analysis_text, initial_chat
-
-        def on_send(chat_state_list, user_msg, analysis_text):
-            """
-            Called when user sends a chat message.
-            Returns: updated chat_state, cleared user_input
-            """
+                scraped = multi_scrape(queries, delay=SCRAPE_DELAY)
+                if scraped.startswith("ERROR"):
+                    return "", gr.update(value=f"<div class='analysis-card muted'><strong>Error:</strong> {scraped}</div>"), [], [], set_status("Scrape error")
+
+                status_msg = "Generating analysis (LLM)..."
+
+                user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease produce the analysis as instructed in the system prompt."
+                analysis_text = run_llm_system_and_user(PROMPT_TEMPLATE, user_payload)
+
+                if analysis_text.startswith("ERROR"):
+                    return "", gr.update(value=f"<div class='analysis-card muted'><strong>Error:</strong> {analysis_text}</div>"), [], [], set_status("LLM error")
+
+                # Build nicely formatted HTML preview (we display the raw LLM text wrapped in <pre> for readability)
+                safe_html = "<div class='analysis-card'><pre style='white-space:pre-wrap; font-family:Inter, monospace; font-size:14px; color:#dfeefc;'>" + \
+                            gr.escape(analysis_text) + "</pre></div>"
+
+                # Seed chat messages: user + assistant
+                initial_chat = [
+                    {"role": "user", "content": f"Analyze the data provided (prompts: {', '.join(queries)})"},
+                    {"role": "assistant", "content": analysis_text},
+                ]
+
+                return analysis_text, gr.update(value=safe_html), initial_chat, initial_chat, set_status("Done")
+            except Exception as e:
+                tb = traceback.format_exc()
+                return "", gr.update(value=f"<div class='analysis-card muted'><strong>Unexpected error:</strong> {e}</div>"), [], [], set_status("Error")
+
+        def on_send(chat_messages: List[dict], user_msg: str, analysis_text: str):
             if not user_msg or not user_msg.strip():
-                return chat_state_list or [], ""
-            updated_history = continue_chat(chat_state_list or [], user_msg, analysis_text)
-            return updated_history, ""  # second value clears the user_input box
+                return chat_messages or [], ""
+            # Append and get updated messages
+            updated = continue_chat(chat_messages or [], user_msg, analysis_text or "")
+            return updated, ""
 
-        def render_chat(chat_messages):
+        def render_chat(chat_messages: List[dict]):
             """
-            gr.Chatbot in this Gradio version accepts a list of message dicts.
-            Return the message list as-is (or return [] if None).
+            Gradio Chatbot in some versions accepts list of dicts {"role","content"}.
+            We will return list of dicts unchanged where possible. If Gradio fails,
+            it will raise — but previously we fixed to produce dicts.
             """
-            return chat_messages or []
+            if not chat_messages:
+                return []
+            # Return as-is
+            return chat_messages
 
-
-        # ---- Wire handlers to UI components ----
+        # ---- Wire up events ----
         analyze_btn.click(
             fn=on_analyze,
             inputs=[prompts],
-            outputs=[analysis_out, error_box, analysis_state, chat_state]
+            outputs=[analysis_state, analysis_html, chat_state, chatbot, status],
+        )
+
+        clear_btn.click(
+            fn=on_clear,
+            inputs=[],
+            outputs=[prompts, analysis_html, chat_state, chatbot, status],
         )
 
         send_btn.click(
             fn=on_send,
             inputs=[chat_state, user_input, analysis_state],
-            outputs=[chat_state, user_input]
+            outputs=[chat_state, user_input],
         )
-
-        # Allow Enter-key submission from the textbox
         user_input.submit(
             fn=on_send,
             inputs=[chat_state, user_input, analysis_state],
-            outputs=[chat_state, user_input]
+            outputs=[chat_state, user_input],
         )
 
-        # Keep Chatbot display updated whenever chat_state changes
-        chat_state.change(
-            fn=render_chat,
-            inputs=[chat_state],
-            outputs=[chatbot]
-        )
+        # Keep chatbot UI updated
+        chat_state.change(fn=render_chat, inputs=[chat_state], outputs=[chatbot])
 
     return demo
 
-
-
-# -----------------------
-# Clean shutdown helper
-# -----------------------
-def _cleanup_on_exit():
-    try:
-        loop = asyncio.get_event_loop()
-        if loop and not loop.is_closed():
-            try:
-                loop.stop()
-            except Exception:
-                pass
-            try:
-                loop.close()
-            except Exception:
-                pass
-    except Exception:
-        pass
-
-atexit.register(_cleanup_on_exit)
-
 # -----------------------
 # Run
 # -----------------------
 if __name__ == "__main__":
     demo = build_demo()
     demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+