Multimodel chat with user login and historical dropdown

api.py

@@ -67,35 +67,75 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGener
         yield "Error: Anthropic API key not provided."
         return
 
-    messages = []
+    # --- Start: Message Cleaning for Anthropic ---
+    # Anthropic requires messages to alternate roles, starting with 'user'.
+    # Clean the history to ensure this format.
+    cleaned_messages = []
+    last_role = None
+
     for msg in history:
-        if msg.get("role") == "user":
-            messages.append({"role": "user", "content": msg["content"]})
-        elif msg.get("role") == "assistant":
-            messages.append({"role": "assistant", "content": msg["content"]})
-    messages.append({"role": "user", "content": query})
+        role = msg.get("role")
+        content = msg.get("content")
+
+        if not role or not content:
+            continue # Skip invalid messages
+
+        # If the last message was the same role, skip this one or combine (combining is more complex)
+        if role == last_role:
+             logger.warning(f"Skipping consecutive message with role: {role}")
+             continue
+
+        # If the first message is 'assistant', skip it
+        if not cleaned_messages and role == "assistant":
+            logger.warning("Skipping initial assistant message in history for Anthropic.")
+            continue
+
+        cleaned_messages.append({"role": role, "content": content})
+        last_role = role
+
+    # Ensure the last message in history is 'assistant' before adding the new user query
+    # If the history ends with 'user', we might have an issue or the model didn't respond last turn.
+    # For simplicity, we'll just append the new user query. The API will validate the full list.
+    # A more robust approach might require padding with an empty assistant message if history ends with user.
+    # However, the core.py logic should ensure history alternates correctly.
+    # The main cleaning needed is handling initial assistant messages and consecutive roles.
+
+    # Append the current user query
+    cleaned_messages.append({"role": "user", "content": query})
+
+    # Final check: Ensure the list starts with 'user' and alternates.
+    # If after cleaning and adding the new query, the list is empty or starts with 'assistant', something is wrong.
+    if not cleaned_messages or cleaned_messages[0].get("role") != "user":
+         logger.error("Anthropic message cleaning resulted in invalid format.")
+         yield "Error: Internal message formatting issue for Anthropic."
+         return
+
+    # --- End: Message Cleaning ---
+
 
     headers = {
         "x-api-key": anthropic_api_key,
-        "anthropic-version": "2023-06-01",
+        "anthropic-version": "2023-06-01", # Use a valid API version
         "Content-Type": "application/json"
     }
 
     payload = {
-        "model": "claude-3-5-sonnet-20241022",
-        "max_tokens": 1024,
-        "messages": messages,
+        "model": "claude-3-5-sonnet-20241022", # Ensure you are using a valid model name
+        "max_tokens": 4096, # Increased max_tokens for potentially longer responses
+        "messages": cleaned_messages, # Use the cleaned messages
         "stream": True
     }
 
     try:
         async with httpx.AsyncClient() as client:
             async with client.stream("POST", "https://api.anthropic.com/v1/messages", headers=headers, json=payload) as response:
-                response.raise_for_status()
+                response.raise_for_status() # Raise HTTPError for bad responses (like 400)
                 buffer = ""
                 async for chunk in response.aiter_text():
                     if chunk:
                         buffer += chunk
+                        # Anthropic streaming sends JSON objects separated by newlines
+                        # Sometimes multiple objects are in one chunk
                         while "\n" in buffer:
                             line, buffer = buffer.split("\n", 1)
                             if line.startswith("data: "):
@@ -106,11 +146,19 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGener
                                     continue
                                 try:
                                     json_data = json.loads(data)
+                                    # Check the type of event
                                     if json_data.get("type") == "content_block_delta" and "delta" in json_data:
                                         yield json_data["delta"].get("text", "")
+                                    # Handle other event types if necessary (e.g., message_start, message_delta, message_stop)
+                                except json.JSONDecodeError:
+                                     # If it's not a complete JSON line, keep buffering
+                                     buffer = line + "\n" + buffer # Put the line back in buffer
                                 except Exception as e:
                                     logger.error(f"Anthropic parse error: {e}")
-                                    yield f"[Anthropic Error]: {e}"
+                                    yield f"[Anthropic Parse Error]: {e}"
+    except httpx.HTTPStatusError as e:
+        logger.error(f"Anthropic API HTTP error: {e.response.status_code} - {e.response.text}")
+        yield f"[Anthropic API Error {e.response.status_code}]: {e.response.text}"
     except Exception as e:
         logger.error(f"Anthropic API error: {e}")
         yield f"[Anthropic Error]: {e}"

app.py

@@ -3,6 +3,7 @@ import sqlite3
 import os
 import asyncio
 from core import submit_query
+from config import logger
 
 DB_PATH = "chat_history.db"
 
@@ -15,14 +16,23 @@ def init_db():
             password TEXT NOT NULL
         )
     """)
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            session_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
     c.execute("""
         CREATE TABLE IF NOT EXISTS history (
+            session_id INTEGER,
             username TEXT,
             providers TEXT,
             message TEXT,
             openai_response TEXT,
             anthropic_response TEXT,
-            gemini_response TEXT
+            gemini_response TEXT,
+            FOREIGN KEY(session_id) REFERENCES sessions(session_id)
         )
     """)
     conn.commit()
@@ -48,121 +58,266 @@ def login_user(username, password):
     conn.close()
     return result is not None
 
-def get_chat_history(username):
+def create_new_session(username):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("INSERT INTO sessions (username) VALUES (?)", (username,))
+    session_id = c.lastrowid
+    conn.commit()
+    conn.close()
+    return session_id
+
+def list_sessions(username):
     conn = sqlite3.connect(DB_PATH)
     c = conn.cursor()
-    c.execute("SELECT message, openai_response, anthropic_response, gemini_response FROM history WHERE username=?", (username,))
+    c.execute("SELECT session_id, created_at FROM sessions WHERE username=? ORDER BY created_at DESC", (username,))
+    sessions = c.fetchall()
+    conn.close()
+    return sessions
+
+def get_chat_history(session_id):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT message, openai_response, anthropic_response, gemini_response FROM history WHERE session_id=? ORDER BY rowid", (session_id,))
     rows = c.fetchall()
     conn.close()
-    history = []
+
+    openai_history = []
+    anthropic_history = []
+    gemini_history = []
+
     for m, o, a, g in rows:
-        history.append({"role": "user", "content": m})
-        responses = []
-        if o: responses.append(f"OpenAI: {o}")
-        if a: responses.append(f"Anthropic: {a}")
-        if g: responses.append(f"Gemini: {g}")
-        if responses:
-            history.append({"role": "assistant", "content": "\n".join(responses)})
-    return history
-
-def save_chat_history(username, providers, message, openai_resp, anthropic_resp, gemini_resp):
+        user_msg_dict = {"role": "user", "content": m}
+        openai_history.append(user_msg_dict)
+        anthropic_history.append(user_msg_dict)
+        gemini_history.append(user_msg_dict)
+        if o:
+            openai_history.append({"role": "assistant", "content": o})
+        if a:
+            anthropic_history.append({"role": "assistant", "content": a})
+        if g:
+            gemini_history.append({"role": "assistant", "content": g})
+
+    return openai_history, anthropic_history, gemini_history
+
+def save_chat_history(session_id, username, providers, message, openai_resp, anthropic_resp, gemini_resp):
     conn = sqlite3.connect(DB_PATH)
     c = conn.cursor()
     c.execute(
-        "INSERT INTO history (username, providers, message, openai_response, anthropic_response, gemini_response) VALUES (?, ?, ?, ?, ?, ?)",
-        (username, ",".join(providers), message, openai_resp, anthropic_resp, gemini_resp)
+        "INSERT INTO history (session_id, username, providers, message, openai_response, anthropic_response, gemini_response) VALUES (?, ?, ?, ?, ?, ?, ?)",
+        (session_id, username, ",".join(providers), message, openai_resp, anthropic_resp, gemini_resp)
     )
     conn.commit()
     conn.close()
 
-async def chatbot_fn(message, history, username, providers):
-    if not username:
-        return "", history or []
+async def chatbot_fn(message, openai_history, anthropic_history, gemini_history, username, providers, session_id):
+    if not username or not session_id:
+        return "", openai_history or [], anthropic_history or [], gemini_history or [], openai_history or [], anthropic_history or [], gemini_history or []
     if not providers:
-        return "", (history or []) + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": "Please select at least one provider."}
-        ]
+        user_msg_dict = {"role": "user", "content": message}
+        no_provider_msg = {"role": "assistant", "content": "Please select at least one provider."}
+        openai_history = (openai_history or []) + [user_msg_dict, no_provider_msg]
+        anthropic_history = (anthropic_history or []) + [user_msg_dict, no_provider_msg]
+        gemini_history = (gemini_history or []) + [user_msg_dict, no_provider_msg]
+        return "", openai_history, anthropic_history, gemini_history, openai_history, anthropic_history, gemini_history
 
+    context_history = openai_history
     final_result = None
-    async for _, openai_msgs, anthropic_msgs, gemini_msgs, updated_history in submit_query(message, providers, history, username):
-        final_result = (openai_msgs, anthropic_msgs, gemini_msgs, updated_history)
+    error_message = ""
+    async for err, openai_msgs, anthropic_msgs, gemini_msgs, updated_context_history in submit_query(
+        message, providers, context_history, username
+    ):
+        final_result = (openai_msgs, anthropic_msgs, gemini_msgs, updated_context_history)
+        error_message = err
 
     if not final_result:
-        return "", (history or []) + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": "Error: No response received."}
-        ]
+        logger.error("submit_query returned no result")
+        return f"Error: submit_query failed.", openai_history, anthropic_history, gemini_history, openai_history, anthropic_history, gemini_history
 
-    openai_resp, anthropic_resp, gemini_resp, updated_history = final_result
+    new_openai_history, new_anthropic_history, new_gemini_history, _ = final_result
 
-    def get_last_response(msgs):
-        if isinstance(msgs, list) and msgs:
-            for m in reversed(msgs):
+    def get_last_response_text_from_history(history_list):
+        if isinstance(history_list, list) and history_list:
+            for m in reversed(history_list):
                 if isinstance(m, dict) and m.get("role") == "assistant" and m.get("content"):
                     return m.get("content", "")
         return ""
 
-    openai_text = get_last_response(openai_resp)
-    anthropic_text = get_last_response(anthropic_resp)
-    gemini_text = get_last_response(gemini_resp)
-    save_chat_history(username, providers, message, openai_text, anthropic_text, gemini_text)
+    openai_text_to_save = get_last_response_text_from_history(new_openai_history)
+    anthropic_text_to_save = get_last_response_text_from_history(new_anthropic_history)
+    gemini_text_to_save = get_last_response_text_from_history(new_gemini_history)
 
-    responses = []
-    if openai_text: responses.append(f"OpenAI: {openai_text}")
-    if anthropic_text: responses.append(f"Anthropic: {anthropic_text}")
-    if gemini_text: responses.append(f"Gemini: {gemini_text}")
+    save_chat_history(session_id, username, providers, message, openai_text_to_save, anthropic_text_to_save, gemini_text_to_save)
 
-    history = history or []
-    history.append({"role": "user", "content": message})
-    if responses:
-        history.append({"role": "assistant", "content": "\n".join(responses)})
-    return "", history
+    return error_message, new_openai_history, new_anthropic_history, new_gemini_history, new_openai_history, new_anthropic_history, new_gemini_history
 
-def load_history(username):
-    if not username:
-        return "", []
-    return "", get_chat_history(username)
+def session_label(session):
+    sid, created = session
+    return f"{sid} ({created})"
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Multi-Model Chat with Login")
-    with gr.Tabs():
-        with gr.Tab("Login / Register"):
-            username = gr.Textbox(label="Username")
-            password = gr.Textbox(label="Password", type="password")
-            login_btn = gr.Button("Login")
-            register_btn = gr.Button("Register")
-            login_status = gr.Markdown("")
-
-        with gr.Tab("Chat"):
-            providers = gr.CheckboxGroup(
-                choices=["OpenAI", "Anthropic", "Gemini"],
-                label="Select Providers",
-                value=["OpenAI"]
-            )
-            chatbox = gr.Chatbot(type="messages")
-            msg = gr.Textbox(label="Message")
-            send_btn = gr.Button("Send")
-            clear_btn = gr.Button("Clear History")
-            hidden_username = gr.State("")
+    gr.Markdown("# Multi-Model Chat")
+
+    # Login/Register group
+    login_group = gr.Group(visible=True)
+    with login_group:
+        username = gr.Textbox(label="Username")
+        password = gr.Textbox(label="Password", type="password")
+        login_btn = gr.Button("Login")
+        register_btn = gr.Button("Register")
+        login_status = gr.Markdown("")
+
+    # Chat group (hidden by default)
+    chat_group = gr.Group(visible=False)
+    with chat_group:
+        with gr.Row():
+            session_selector = gr.Dropdown(choices=[], label="Select Chat Session", interactive=True)
+            new_chat_btn = gr.Button("New Chat")
+            user_display = gr.Markdown("", elem_id="user_display")
+            logout_btn = gr.Button("Logout")
+        providers = gr.CheckboxGroup(
+            choices=["OpenAI", "Anthropic", "Gemini"],
+            label="Select Providers",
+            value=["OpenAI"]
+        )
+        with gr.Row():
+            openai_chat = gr.Chatbot(label="OpenAI", type="messages", height=400)
+            anthropic_chat = gr.Chatbot(label="Anthropic", type="messages", height=400)
+            gemini_chat = gr.Chatbot(label="Gemini", type="messages", height=400)
+        msg = gr.Textbox(label="Message")
+        send_btn = gr.Button("Send")
+        clear_btn = gr.Button("Clear History")
+        hidden_username = gr.State("")
+        openai_history_state = gr.State([])
+        anthropic_history_state = gr.State([])
+        gemini_history_state = gr.State([])
+        session_id_state = gr.State("")
 
+    # --- Function Definitions ---
     def do_login(u, p):
         if login_user(u, p):
-            return f"Welcome, {u}!", gr.update(visible=True), u
+            session_id = create_new_session(u)
+            sessions = list_sessions(u)
+            session_choices = [session_label(s) for s in sessions]
+            session_value = session_label(sessions[0]) if sessions else ""
+            return (
+                f"Welcome, {u}!",
+                gr.update(visible=False),  # Hide login group
+                gr.update(visible=True),   # Show chat group
+                [], [], [],  # Empty chats for new session
+                [], [], [],
+                u,
+                f"Logged in as: **{u}**",
+                session_id,
+                gr.update(choices=session_choices, value=session_value)
+            )
         else:
-            return "Login failed.", gr.update(visible=False), ""
+            return "Login failed.", gr.update(), gr.update(), [], [], [], [], [], [], "", "", gr.update(choices=[], value="")
 
     def do_register(u, p):
         if register_user(u, p):
-            return "Registration successful! Please login.", gr.update(visible=False), ""
+            return "Registration successful! Please login.", gr.update(), gr.update(), [], [], [], [], [], [], "", "", gr.update(choices=[], value="")
         else:
-            return "Username already exists.", gr.update(visible=False), ""
+            return "Username already exists.", gr.update(), gr.update(), [], [], [], [], [], [], "", "", gr.update(choices=[], value="")
+
+    def do_logout():
+        return (
+            "",  # login_status
+            gr.update(visible=True),   # Show login group
+            gr.update(visible=False),  # Hide chat group
+            [], [], [], [], [], [], "", "", gr.update(choices=[], value="")
+        )
+
+    def do_new_chat(username):
+        if not username:
+            return "", [], [], [], gr.update(choices=[], value="")
+        session_id = create_new_session(username)
+        sessions = list_sessions(username)
+        session_choices = [session_label(s) for s in sessions]
+        session_value = session_label(sessions[0]) if sessions else ""
+        return session_id, [], [], [], gr.update(choices=session_choices, value=session_value)
+
+    def do_select_session(session_label_str, username):
+        if not session_label_str or not username:
+            return [], [], [], [], [], [], ""
+        session_id = int(session_label_str.split(" ")[0])
+        openai_hist, anthropic_hist, gemini_hist = get_chat_history(session_id)
+        return (
+            openai_hist, anthropic_hist, gemini_hist,  # update chat displays
+            openai_hist, anthropic_hist, gemini_hist,  # update state variables
+            session_id                                 # update session_id_state
+        )
+
+    # --- Gradio Wiring ---
+    login_btn.click(
+        do_login,
+        [username, password],
+        [
+            login_status, login_group, chat_group,
+            openai_chat, anthropic_chat, gemini_chat,
+            openai_history_state, anthropic_history_state, gemini_history_state,
+            hidden_username,
+            user_display,
+            session_id_state,
+            session_selector  # Only one output for dropdown!
+        ]
+    )
+
+    register_btn.click(
+        do_register,
+        [username, password],
+        [
+            login_status, login_group, chat_group,
+            openai_chat, anthropic_chat, gemini_chat,
+            openai_history_state, anthropic_history_state, gemini_history_state,
+            hidden_username,
+            user_display,
+            session_id_state,
+            session_selector
+        ]
+    )
 
-    login_btn.click(do_login, [username, password], [login_status, chatbox, hidden_username])
-    register_btn.click(do_register, [username, password], [login_status, chatbox, hidden_username])
-    send_btn.click(chatbot_fn, [msg, chatbox, hidden_username, providers], [msg, chatbox])
-    clear_btn.click(lambda u: ("", []), [hidden_username], [msg, chatbox])
-    login_btn.click(load_history, [username], [msg, chatbox])
+    send_btn.click(
+        chatbot_fn,
+        [msg, openai_history_state, anthropic_history_state, gemini_history_state, hidden_username, providers, session_id_state],
+        [msg, openai_chat, anthropic_chat, gemini_chat, openai_history_state, anthropic_history_state, gemini_history_state]
+    )
+
+    clear_btn.click(
+        lambda: ("", [], [], [], [], [], []),
+        [],
+        [msg, openai_chat, anthropic_chat, gemini_chat, openai_history_state, anthropic_history_state, gemini_history_state]
+    )
+
+    logout_btn.click(
+        do_logout,
+        [],
+        [
+            login_status, login_group, chat_group,
+            openai_chat, anthropic_chat, gemini_chat,
+            openai_history_state, anthropic_history_state, gemini_history_state,
+            hidden_username,
+            user_display,
+            session_id_state,
+            session_selector
+        ]
+    )
+
+    new_chat_btn.click(
+        do_new_chat,
+        [hidden_username],
+        [session_id_state, openai_chat, anthropic_chat, gemini_chat, session_selector]
+    )
+
+    session_selector.change(
+        do_select_session,
+        [session_selector, hidden_username],
+        [
+            openai_chat, anthropic_chat, gemini_chat,           # chat displays
+            openai_history_state, anthropic_history_state, gemini_history_state,  # state variables
+            session_id_state                                    # session id state
+        ]
+    )
 
 if __name__ == "__main__":
     init_db()

core.py

@@ -1,13 +1,18 @@
 import asyncio
 from typing import AsyncGenerator, List, Dict, Tuple
-from config import logger
-from api import ask_openai, ask_anthropic, ask_gemini
-from database import Database
+from config import logger # Make sure config.py exists with a logger
+from api import ask_openai, ask_anthropic, ask_gemini # Make sure api.py exists with these functions
+from database import Database # Make sure database.py exists with a Database class
 import json
 
+# Assuming database.py has a Database class with connect, add_user, get_user,
+# get_conversations, add_conversation, clear_conversation methods.
+# If not, you'll need to implement these or adjust.
 db = Database()
 db.connect()
 
+# These functions might be redundant if login/register is handled fully in app.py
+# but keeping them here based on previous code structure.
 def register(username, password, message=None):
     if db.add_user(username, password):
         return "Registration successful"
@@ -17,8 +22,11 @@ def register(username, password, message=None):
 def login(username, password, message=None):
     user_id = db.get_user(username, password)
     if user_id:
+        # Note: This loads a single conversation string, not separate histories.
+        # If you need separate histories loaded here, database schema needs adjustment.
+        # For now, app.py's get_chat_history handles loading separate histories from the DB.
         conversation = db.get_conversations(user_id)
-        history = json.loads(conversation) if conversation else []
+        history = json.loads(conversation) if conversation else [] # Assuming conversation is JSON string of history
         return "Login successful", user_id, history
     else:
         return "Invalid credentials", None, []
@@ -26,45 +34,107 @@ def login(username, password, message=None):
 def logout():
     return "Logout successful"
 
+# This clear_history might be redundant if app.py handles clearing via Gradio states
 def clear_history(user_id):
     db.clear_conversation(user_id)
-    return [], [], [], []
+    return [], [], [], [] # Assuming this returns empty histories for 3 models + context
+
 
 async def submit_query(query, providers, history, user_id):
-    async for _, openai_msgs, anthropic_msgs, gemini_msgs, updated_history in query_model(query, providers, history):
-        db.add_conversation(user_id, json.dumps(updated_history))
-        yield "", openai_msgs, anthropic_msgs, gemini_msgs, updated_history
+    # submit_query calls query_model and saves the history
+    # query_model will return the updated histories for each model
+    # The yielded values are: error_msg, openai_msgs, anthropic_msgs, gemini_msgs, updated_context_history
+    async for error_msg, openai_msgs, anthropic_msgs, gemini_msgs, updated_context_history in query_model(query, providers, history):
+        # Save the *combined* history for the user (using one of the updated histories, e.g., openai_msgs)
+        # Note: Saving separate histories per user per model might be better for full history recall per model
+        # but sticking to the current DB schema which seems to save combined responses per turn.
+        # Let's save the history from one model (e.g., OpenAI) as the main conversation history.
+        # A better approach for saving separate histories would require changing the DB schema.
+        # For now, let's save the OpenAI history as the main user conversation history.
+        # db.add_conversation(user_id, json.dumps(openai_msgs)) # This seems to save the *full* history list
+        # The save_chat_history in app.py saves individual responses per turn.
+        # Let's rely on app.py's save_chat_history for saving to the DB.
+        # This submit_query function should focus on getting responses and yielding updated histories.
+
+        # Yield the results from query_model
+        yield error_msg, openai_msgs, anthropic_msgs, gemini_msgs, updated_context_history
+
 
 async def query_model(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]]], None]:
-    try:
-        openai_msgs = history.copy()
-        anthropic_msgs = history.copy()
-        gemini_msgs = history.copy()
-
-        openai_response = ""
-        if "OpenAI" in providers:
-            async for chunk in ask_openai(query, history):
+    # history input is the context history (e.g., openai_history from app.py)
+    # We need to create the *new* history lists for this turn based on the input history
+
+    # Start with the context history for each model's potential history
+    openai_msgs = history.copy()
+    anthropic_msgs = history.copy()
+    gemini_msgs = history.copy()
+
+    user_msg_dict = {"role": "user", "content": query} # User message for this turn
+
+    # Append user message to the history copies *before* calling models
+    # This ensures the history passed to ask_* includes the current user message
+    # and the history returned includes the user message.
+    openai_msgs.append(user_msg_dict)
+    anthropic_msgs.append(user_msg_dict)
+    gemini_msgs.append(user_msg_dict)
+
+    error_msg = ""
+
+    # --- OpenAI ---
+    openai_response = ""
+    if "OpenAI" in providers:
+        try:
+            # Pass the history *including* the current user message to the model API
+            async for chunk in ask_openai(query, openai_msgs): # Pass openai_msgs as history
                 openai_response += chunk
             if openai_response:
+                # Append assistant response to the OpenAI history copy
                 openai_msgs.append({"role": "assistant", "content": openai_response.strip()})
+            # If no response (e.g., API error), openai_msgs remains with just the user message
+        except Exception as e:
+            logger.error(f"Error calling OpenAI: {e}")
+            error_msg += f"OpenAI Error: {e}\n"
+            # Optionally append an error message to the history
+            openai_msgs.append({"role": "assistant", "content": f"Error: {e}"})
+
 
-        anthropic_response = ""
-        if "Anthropic" in providers:
-            async for chunk in ask_anthropic(query, history):
+    # --- Anthropic ---
+    anthropic_response = ""
+    if "Anthropic" in providers:
+        try:
+            # Pass the history *including* the current user message to the model API
+            async for chunk in ask_anthropic(query, anthropic_msgs): # Pass anthropic_msgs as history
                 anthropic_response += chunk
             if anthropic_response:
+                # Append assistant response to the Anthropic history copy
                 anthropic_msgs.append({"role": "assistant", "content": anthropic_response.strip()})
+            # If no response, anthropic_msgs remains with just the user message
+        except Exception as e:
+            logger.error(f"Error calling Anthropic: {e}")
+            error_msg += f"Anthropic Error: {e}\n"
+            # Optionally append an error message to the history
+            anthropic_msgs.append({"role": "assistant", "content": f"Error: {e}"})
 
-        gemini_response = ""
-        if "Gemini" in providers:
-            async for chunk in ask_gemini(query, history):
+
+    # --- Gemini ---
+    gemini_response = ""
+    if "Gemini" in providers: # Add Gemini check
+        try:
+             # Pass the history *including* the current user message to the model API
+            async for chunk in ask_gemini(query, gemini_msgs): # Pass gemini_msgs as history
                 gemini_response += chunk
             if gemini_response:
+                # Append assistant response to the Gemini history copy
                 gemini_msgs.append({"role": "assistant", "content": gemini_response.strip()})
+            # If no response, gemini_msgs remains with just the user message
+        except Exception as e:
+            logger.error(f"Error calling Gemini: {e}")
+            error_msg += f"Gemini Error: {e}\n"
+            # Optionally append an error message to the history
+            gemini_msgs.append({"role": "assistant", "content": f"Error: {e}"})
+
 
-        updated_history = history.copy()
-        updated_history.append({"role": "user", "content": query})
-        yield "", openai_msgs, anthropic_msgs, gemini_msgs, updated_history
-    except Exception as e:
-        logger.error(f"Error in query_model: {e}")
-        yield f"Error: An unexpected error occurred. {e}", [], [], [], history
+    # Yield the updated histories for each model.
+    # The first element is for error messages.
+    # The last element is the updated context history (using openai_msgs as the main one).
+    yield error_msg.strip(), openai_msgs, anthropic_msgs, gemini_msgs, openai_msgs # Yield the updated lists