login info

api.py

@@ -1,7 +1,6 @@
 import os
 import httpx
 import json
-import traceback
 from typing import AsyncGenerator, List, Dict
 from config import logger
 
@@ -15,9 +14,10 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
 
     messages = []
     for msg in history:
-        messages.append({"role": "user", "content": msg["user"]})
-        if msg.get("openai"):
-            messages.append({"role": "assistant", "content": msg["openai"]})
+        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})
 
     headers = {
@@ -59,7 +59,6 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
         logger.error(f"OpenAI API error: {e}")
         yield f"[OpenAI Error]: {e}"
 
-
 # ===== Anthropic =====
 async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
     anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
@@ -70,9 +69,10 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGener
 
     messages = []
     for msg in history:
-        messages.append({"role": "user", "content": msg["user"]})
-        if msg.get("anthropic"):
-            messages.append({"role": "assistant", "content": msg["anthropic"]})
+        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})
 
     headers = {
@@ -115,7 +115,6 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGener
         logger.error(f"Anthropic API error: {e}")
         yield f"[Anthropic Error]: {e}"
 
-
 # ===== Gemini =====
 async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
     gemini_api_key = os.getenv("GEMINI_API_KEY")
@@ -126,9 +125,10 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
 
     history_text = ""
     for msg in history:
-        history_text += f"User: {msg['user']}\n"
-        if msg.get("gemini"):
-            history_text += f"Assistant: {msg['gemini']}\n"
+        if msg.get("role") == "user":
+            history_text += f"User: {msg['content']}\n"
+        elif msg.get("role") == "assistant":
+            history_text += f"Assistant: {msg['content']}\n"
     full_prompt = f"{history_text}User: {query}\n"
 
     headers = {"Content-Type": "application/json"}
@@ -153,8 +153,6 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                     try:
                         json_data = json.loads(buffer.strip(", \n"))
                         buffer = ""
-
-                        # handle both list and dict format
                         objects = json_data if isinstance(json_data, list) else [json_data]
                         for obj in objects:
                             candidates = obj.get("candidates", [])
@@ -165,7 +163,7 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                                     if text:
                                         yield text
                     except json.JSONDecodeError:
-                        continue  # wait for more data
+                        continue
     except Exception as e:
         logger.error(f"Gemini API error: {e}")
-        yield f"[Gemini Error]: {e}"
+        yield f"[Gemini Error]: {e}"

app.py

@@ -1,54 +1,169 @@
 import gradio as gr
-from core import submit_query, clear_history, login, register, logout
+import sqlite3
+import os
+import asyncio
+from core import submit_query
+
+DB_PATH = "chat_history.db"
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS users (
+            username TEXT PRIMARY KEY,
+            password TEXT NOT NULL
+        )
+    """)
+    c.execute("""
+        CREATE TABLE IF NOT EXISTS history (
+            username TEXT,
+            providers TEXT,
+            message TEXT,
+            openai_response TEXT,
+            anthropic_response TEXT,
+            gemini_response TEXT
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+def register_user(username, password):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    try:
+        c.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, password))
+        conn.commit()
+        return True
+    except sqlite3.IntegrityError:
+        return False
+    finally:
+        conn.close()
+
+def login_user(username, password):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT * FROM users WHERE username=? AND password=?", (username, password))
+    result = c.fetchone()
+    conn.close()
+    return result is not None
+
+def get_chat_history(username):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT message, openai_response, anthropic_response, gemini_response FROM history WHERE username=?", (username,))
+    rows = c.fetchall()
+    conn.close()
+    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):
+    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)
+    )
+    conn.commit()
+    conn.close()
+
+async def chatbot_fn(message, history, username, providers):
+    if not username:
+        return "", history or []
+    if not providers:
+        return "", (history or []) + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": "Please select at least one provider."}
+        ]
+
+    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)
+
+    if not final_result:
+        return "", (history or []) + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": "Error: No response received."}
+        ]
+
+    openai_resp, anthropic_resp, gemini_resp, updated_history = final_result
+
+    def get_last_response(msgs):
+        if isinstance(msgs, list) and msgs:
+            for m in reversed(msgs):
+                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)
+
+    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}")
+
+    history = history or []
+    history.append({"role": "user", "content": message})
+    if responses:
+        history.append({"role": "assistant", "content": "\n".join(responses)})
+    return "", history
+
+def load_history(username):
+    if not username:
+        return "", []
+    return "", get_chat_history(username)
 
 with gr.Blocks() as demo:
     gr.Markdown("# Multi-Model Chat with Login")
-    user_id = gr.State(None)
-    chat_history = gr.State([])
-
-    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.Textbox(label="Status", interactive=False)
-
-    with gr.Tab("Chat"):
-        providers = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Providers", value=["OpenAI"])
-        query = gr.Textbox(label="Enter your query")
-        submit_button = gr.Button("Submit")
-        clear_button = gr.Button("Clear History")
-        openai_chatbot = gr.Chatbot(label="OpenAI", type="messages")
-        anthropic_chatbot = gr.Chatbot(label="Anthropic", type="messages")
-        gemini_chatbot = gr.Chatbot(label="Gemini", type="messages")
-        logout_btn = gr.Button("Logout")
-        chat_status = gr.Textbox(label="Chat Status", interactive=False)
-
-    def login_fn(username, password):
-        msg, uid, history = login(username, password)
-        if uid is None:
-            uid = ""
-        return msg, uid, history
-
-    def register_fn(username, password):
-        return register(username, password)
-
-    def logout_fn():
-        return logout(), "", []
-
-    login_btn.click(login_fn, [username, password], [login_status, user_id, chat_history])
-    register_btn.click(register_fn, [username, password], login_status)
-    logout_btn.click(logout_fn, [], [chat_status, user_id, chat_history])
-
-    submit_button.click(
-        submit_query,
-        [query, providers, chat_history, user_id],
-        [query, openai_chatbot, anthropic_chatbot, gemini_chatbot, chat_history]
-    )
-    clear_button.click(
-        clear_history,
-        [user_id],
-        [openai_chatbot, anthropic_chatbot, gemini_chatbot, chat_history]
-    )
+    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("")
+
+    def do_login(u, p):
+        if login_user(u, p):
+            return f"Welcome, {u}!", gr.update(visible=True), u
+        else:
+            return "Login failed.", gr.update(visible=False), ""
+
+    def do_register(u, p):
+        if register_user(u, p):
+            return "Registration successful! Please login.", gr.update(visible=False), ""
+        else:
+            return "Username already exists.", gr.update(visible=False), ""
+
+    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])
 
-demo.launch(share=True)
+if __name__ == "__main__":
+    init_db()
+    demo.launch()

core.py

@@ -17,7 +17,6 @@ def register(username, password, message=None):
 def login(username, password, message=None):
     user_id = db.get_user(username, password)
     if user_id:
-        # Load last conversation if exists
         conversation = db.get_conversations(user_id)
         history = json.loads(conversation) if conversation else []
         return "Login successful", user_id, history
@@ -33,7 +32,6 @@ def clear_history(user_id):
 
 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):
-        # Save updated history for the user
         db.add_conversation(user_id, json.dumps(updated_history))
         yield "", openai_msgs, anthropic_msgs, gemini_msgs, updated_history
 
@@ -43,18 +41,30 @@ async def query_model(query: str, providers: List[str], history: List[Dict[str,
         anthropic_msgs = history.copy()
         gemini_msgs = history.copy()
 
+        openai_response = ""
         if "OpenAI" in providers:
-            openai_response = await ask_openai(query, history)
-            openai_msgs.append({"role": "assistant", "content": openai_response})
+            async for chunk in ask_openai(query, history):
+                openai_response += chunk
+            if openai_response:
+                openai_msgs.append({"role": "assistant", "content": openai_response.strip()})
+
+        anthropic_response = ""
         if "Anthropic" in providers:
-            anthropic_response = await ask_anthropic(query, history)
-            anthropic_msgs.append({"role": "assistant", "content": anthropic_response})
+            async for chunk in ask_anthropic(query, history):
+                anthropic_response += chunk
+            if anthropic_response:
+                anthropic_msgs.append({"role": "assistant", "content": anthropic_response.strip()})
+
+        gemini_response = ""
         if "Gemini" in providers:
-            gemini_response = await ask_gemini(query, history)
-            gemini_msgs.append({"role": "assistant", "content": gemini_response})
+            async for chunk in ask_gemini(query, history):
+                gemini_response += chunk
+            if gemini_response:
+                gemini_msgs.append({"role": "assistant", "content": gemini_response.strip()})
 
-        updated_history = history + [{"role": "user", "content": query}]
+        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 f"Error: An unexpected error occurred. {e}", [], [], [], history

database.py

@@ -2,7 +2,7 @@ import sqlite3
 from typing import Optional
 
 class Database:
-    def __init__(self, db_path="chatapp.db"):
+    def __init__(self, db_path="chat_history.db"):
         self.db_path = db_path
         self.conn = None
 
@@ -28,7 +28,7 @@ class Database:
     def add_user(self, username, password):
         c = self.conn.cursor()
         try:
-            c.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, password))
+            c.execute("INSERT INTO users (username, password) VALUES (_, _)", (username, password))
             self.conn.commit()
             return True
         except sqlite3.IntegrityError:
@@ -54,4 +54,4 @@ class Database:
     def clear_conversation(self, user_id):
         c = self.conn.cursor()
         c.execute("DELETE FROM conversations WHERE user_id=?", (user_id,))
-        self.conn.commit()
+        self.conn.commit()