All working modular

api.py

@@ -0,0 +1,229 @@
+import os
+import httpx
+import json
+import traceback
+from typing import AsyncGenerator, List, Dict
+from config import logger
+
+async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        logger.error("OpenAI API key not provided")
+        yield "Error: OpenAI API key not provided."
+        return
+
+    # Build message history with user and assistant roles
+    messages = []
+    for msg in history:
+        messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            messages.append({"role": "assistant", "content": msg["bot"]})
+    messages.append({"role": "user", "content": query})
+
+    headers = {
+        "Authorization": f"Bearer {openai_api_key}",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": "gpt-3.5-turbo",
+        "messages": messages,
+        "stream": True
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            async with client.stream("POST", "https://api.openai.com/v1/chat/completions", headers=headers, json=payload) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        while "\n" in buffer:
+                            line, buffer = buffer.split("\n", 1)
+                            if line.startswith("data: "):
+                                data = line[6:]
+                                if data == "[DONE]":
+                                    break
+                                if not data.strip():
+                                    continue
+                                try:
+                                    json_data = json.loads(data)
+                                    if "choices" in json_data and json_data["choices"]:
+                                        delta = json_data["choices"][0].get("delta", {})
+                                        if "content" in delta and delta["content"] is not None:
+                                            logger.info(f"OpenAI yielding chunk: {delta['content']}")
+                                            yield delta["content"]
+                                except json.JSONDecodeError as e:
+                                    logger.error(f"Error parsing OpenAI stream chunk: {str(e)} - Data: {data}")
+                                    yield f"Error parsing stream: {str(e)}"
+                                except Exception as e:
+                                    logger.error(f"Unexpected error in OpenAI stream: {str(e)} - Data: {data}")
+                                    yield f"Error in stream: {str(e)}"
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"OpenAI HTTP Status Error: {e.response.status_code}, {response_text}")
+        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"OpenAI Error: {str(e)}")
+        yield f"Error: OpenAI Error: {str(e)}"
+
+async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not anthropic_api_key:
+        logger.error("Anthropic API key not provided")
+        yield "Error: Anthropic API key not provided."
+        return
+
+    messages = []
+    for msg in history:
+        messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            messages.append({"role": "assistant", "content": msg["bot"]})
+    messages.append({"role": "user", "content": query})
+
+    headers = {
+        "x-api-key": anthropic_api_key,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": "claude-3-5-sonnet-20241022",
+        "max_tokens": 1024,
+        "messages": messages,
+        "stream": True
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            logger.info(f"Sending Anthropic streaming request: {payload}")
+            async with client.stream("POST", "https://api.anthropic.com/v1/messages", headers=headers, json=payload) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        while "\n" in buffer:
+                            line, buffer = buffer.split("\n", 1)
+                            if line.startswith("data: "):
+                                data = line[6:]
+                                if data.strip() == "[DONE]":
+                                    break
+                                if not data.strip():
+                                    continue
+                                try:
+                                    json_data = json.loads(data)
+                                    if json_data.get("type") == "content_block_delta" and "delta" in json_data and "text" in json_data["delta"]:
+                                        logger.info(f"Anthropic yielding chunk: {json_data['delta']['text']}")
+                                        yield json_data["delta"]["text"]
+                                    elif json_data.get("type") == "message_start" or json_data.get("type") == "message_delta":
+                                        continue
+                                except json.JSONDecodeError as e:
+                                    logger.error(f"Error parsing Anthropic stream chunk: {str(e)} - Data: {data}")
+                                    yield f"Error parsing stream: {str(e)}"
+                                except Exception as e:
+                                    logger.error(f"Unexpected error in Anthropic stream: {str(e)} - Data: {data}")
+                                    yield f"Error in stream: {str(e)}"
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
+        yield f"Error: Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"Anthropic Error: {str(e)}\nStack trace: {traceback.format_exc()}")
+        yield f"Error: Anthropic Error: {str(e)}"
+
+async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key:
+        logger.error("Gemini API key not provided")
+        yield "Error: Gemini API key not provided."
+        return
+
+    history_text = ""
+    for msg in history:
+        history_text += f"User: {msg['user']}\nAssistant: {msg['bot']}\n" if msg['bot'] else f"User: {msg['user']}\n"
+    full_query = history_text + f"User: {query}\n"
+
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "contents": [{"parts": [{"text": full_query}]}]
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            logger.info(f"Sending Gemini streaming request: {payload}")
+            async with client.stream(
+                "POST",
+                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?key={gemini_api_key}",
+                headers=headers,
+                json=payload
+            ) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        logger.info(f"Gemini stream chunk: {chunk}")
+                        while buffer.strip():
+                            try:
+                                json_data = json.loads(buffer)
+                                logger.info(f"Parsed Gemini JSON: {json_data}")
+                                buffer = ""
+                                objects = json_data if isinstance(json_data, list) else [json_data]
+                                for obj in objects:
+                                    if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
+                                        content = obj["candidates"][0].get("content", {})
+                                        if "parts" in content and content["parts"]:
+                                            text = content["parts"][0].get("text", "")
+                                            if text:
+                                                logger.info(f"Gemini yielding chunk: {text}")
+                                                yield text
+                                break
+                            except json.JSONDecodeError:
+                                brace_count = 0
+                                split_index = -1
+                                for i, char in enumerate(buffer):
+                                    if char == '{':
+                                        brace_count += 1
+                                    elif char == '}':
+                                        brace_count -= 1
+                                        if brace_count == 0:
+                                            split_index = i + 1
+                                if split_index > 0:
+                                    try:
+                                        json_str = buffer[:split_index]
+                                        json_data = json.loads(json_str)
+                                        logger.info(f"Parsed Gemini JSON: {json_data}")
+                                        buffer = buffer[split_index:].lstrip(',')
+                                        objects = json_data if isinstance(json_data, list) else [json_data]
+                                        for obj in objects:
+                                            if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
+                                                content = obj["candidates"][0].get("content", {})
+                                                if "parts" in content and content["parts"]:
+                                                    text = content["parts"][0].get("text", "")
+                                                    if text:
+                                                        logger.info(f"Gemini yielding chunk: {text}")
+                                                        yield text
+                                        continue
+                                    except json.JSONDecodeError:
+                                        pass
+                                break
+                            except Exception as e:
+                                logger.error(f"Unexpected error in Gemini stream: {str(e)} - Buffer: {buffer}")
+                                yield f"Error in stream: {str(e)}"
+                                buffer = ""
+                                break
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
+        yield f"Error: Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"Gemini Error: {str(e)}\nStack trace: {traceback.format_exc()}")
+        yield f"Error: Gemini Error: {str(e)}"

app.py

@@ -1,364 +1,25 @@
-import os
-import logging
-import httpx
-import json
-from dotenv import load_dotenv
 import gradio as gr
-from typing import AsyncGenerator, List, Dict, Tuple
-import traceback
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Load environment variables
-load_dotenv()
-logger.info("Environment variables loaded from .env file")
-logger.info(f"OPENAI_API_KEY present: {'OPENAI_API_KEY' in os.environ}")
-logger.info(f"ANTHROPIC_API_KEY present: {'ANTHROPIC_API_KEY' in os.environ}")
-logger.info(f"GEMINI_API_KEY present: {'GEMINI_API_KEY' in os.environ}")
-
-async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
-    openai_api_key = os.getenv("OPENAI_API_KEY")
-    if not openai_api_key:
-        logger.error("OpenAI API key not provided")
-        yield "Error: OpenAI API key not provided."
-        return
-
-    # Build message history with user and assistant roles
-    messages = []
-    for msg in history:
-        messages.append({"role": "user", "content": msg["user"]})
-        if msg["bot"]:
-            messages.append({"role": "assistant", "content": msg["bot"]})
-    messages.append({"role": "user", "content": query})
-
-    headers = {
-        "Authorization": f"Bearer {openai_api_key}",
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "model": "gpt-3.5-turbo",
-        "messages": messages,
-        "stream": True
-    }
-
-    try:
-        async with httpx.AsyncClient() as client:
-            async with client.stream("POST", "https://api.openai.com/v1/chat/completions", headers=headers, json=payload) as response:
-                response.raise_for_status()
-                buffer = ""
-                async for chunk in response.aiter_text():
-                    if chunk:
-                        buffer += chunk
-                        # Process complete JSON lines
-                        while "\n" in buffer:
-                            line, buffer = buffer.split("\n", 1)
-                            if line.startswith("data: "):
-                                data = line[6:]  # Remove "data: " prefix
-                                if data == "[DONE]":
-                                    break
-                                if not data.strip():
-                                    continue
-                                try:
-                                    json_data = json.loads(data)
-                                    if "choices" in json_data and json_data["choices"]:
-                                        delta = json_data["choices"][0].get("delta", {})
-                                        if "content" in delta and delta["content"] is not None:
-                                            yield delta["content"]
-                                except json.JSONDecodeError as e:
-                                    logger.error(f"Error parsing OpenAI stream chunk: {str(e)} - Data: {data}")
-                                    yield f"Error parsing stream: {str(e)}"
-                                except Exception as e:
-                                    logger.error(f"Unexpected error in OpenAI stream: {str(e)} - Data: {data}")
-                                    yield f"Error in stream: {str(e)}"
-
-    except httpx.HTTPStatusError as e:
-        response_text = await e.response.aread()
-        logger.error(f"OpenAI HTTP Status Error: {e.response.status_code}, {response_text}")
-        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
-    except Exception as e:
-        logger.error(f"OpenAI Error: {str(e)}")
-        yield f"Error: OpenAI Error: {str(e)}"
-
-async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
-    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
-    if not anthropic_api_key:
-        logger.error("Anthropic API key not provided")
-        yield "Error: Anthropic API key not provided."
-        return
-
-    # Build message history with user and assistant roles
-    messages = []
-    for msg in history:
-        messages.append({"role": "user", "content": msg["user"]})
-        if msg["bot"]:
-            messages.append({"role": "assistant", "content": msg["bot"]})
-    messages.append({"role": "user", "content": query})
-
-    headers = {
-        "x-api-key": anthropic_api_key,
-        "anthropic-version": "2023-06-01",
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "model": "claude-3-5-sonnet-20241022",
-        "max_tokens": 1024,
-        "messages": messages,
-        "stream": True
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            logger.info(f"Sending Anthropic streaming request: {payload}")
-            async with client.stream("POST", "https://api.anthropic.com/v1/messages", headers=headers, json=payload) as response:
-                response.raise_for_status()
-                buffer = ""
-                async for chunk in response.aiter_text():
-                    if chunk:
-                        buffer += chunk
-                        # Process complete JSON lines
-                        while "\n" in buffer:
-                            line, buffer = buffer.split("\n", 1)
-                            if line.startswith("data: "):
-                                data = line[6:]  # Remove "data: " prefix
-                                if data.strip() == "[DONE]":
-                                    break
-                                if not data.strip():
-                                    continue
-                                try:
-                                    json_data = json.loads(data)
-                                    if json_data.get("type") == "content_block_delta" and "delta" in json_data and "text" in json_data["delta"]:
-                                        yield json_data["delta"]["text"]
-                                    elif json_data.get("type") == "message_start" or json_data.get("type") == "message_delta":
-                                        continue  # Skip metadata events
-                                except json.JSONDecodeError as e:
-                                    logger.error(f"Error parsing Anthropic stream chunk: {str(e)} - Data: {data}")
-                                    yield f"Error parsing stream: {str(e)}"
-                                except Exception as e:
-                                    logger.error(f"Unexpected error in Anthropic stream: {str(e)} - Data: {data}")
-                                    yield f"Error in stream: {str(e)}"
-
-    except httpx.HTTPStatusError as e:
-        response_text = await e.response.aread()
-        logger.error(f"Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
-        yield f"Error: Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
-    except Exception as e:
-        logger.error(f"Anthropic Error: {str(e)}\nStack trace: {traceback.format_exc()}")
-        yield f"Error: Anthropic Error: {str(e)}"
-
-async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logger.error("Gemini API key not provided")
-        yield "Error: Gemini API key not provided."
-        return
-
-    # Concatenate history as text for Gemini
-    history_text = ""
-    for msg in history:
-        history_text += f"User: {msg['user']}\nAssistant: {msg['bot']}\n" if msg["bot"] else f"User: {msg['user']}\n"
-    full_query = history_text + f"User: {query}\n"
-
-    headers = {
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "contents": [{"parts": [{"text": full_query}]}]
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            logger.info(f"Sending Gemini streaming request: {payload}")
-            async with client.stream(
-                "POST",
-                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?key={gemini_api_key}",
-                headers=headers,
-                json=payload
-            ) as response:
-                response.raise_for_status()
-                buffer = ""
-                async for chunk in response.aiter_text():
-                    if chunk:
-                        buffer += chunk
-                        logger.info(f"Gemini stream chunk: {chunk}")
-                        # Try to parse buffer as multiple JSON objects
-                        while buffer.strip():
-                            try:
-                                # Attempt to parse the buffer as JSON
-                                json_data = json.loads(buffer)
-                                logger.info(f"Parsed Gemini JSON: {json_data}")
-                                buffer = ""  # Reset buffer after successful parse
-                                # Handle both single object and list of objects
-                                objects = json_data if isinstance(json_data, list) else [json_data]
-                                for obj in objects:
-                                    if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
-                                        content = obj["candidates"][0].get("content", {})
-                                        if "parts" in content and content["parts"]:
-                                            text = content["parts"][0].get("text", "")
-                                            if text:
-                                                yield text
-                                break  # Exit loop after successful parse
-                            except json.JSONDecodeError as e:
-                                # Check if buffer might contain a partial object followed by a comma
-                                comma_index = buffer.rfind(",")
-                                if comma_index != -1:
-                                    # Try parsing up to the last comma
-                                    try:
-                                        json_data = json.loads(buffer[:comma_index])
-                                        logger.info(f"Parsed Gemini JSON (before comma): {json_data}")
-                                        buffer = buffer[comma_index + 1:].strip()
-                                        objects = json_data if isinstance(json_data, list) else [json_data]
-                                        for obj in objects:
-                                            if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
-                                                content = obj["candidates"][0].get("content", {})
-                                                if "parts" in content and content["parts"]:
-                                                    text = content["parts"][0].get("text", "")
-                                                    if text:
-                                                        yield text
-                                        continue  # Continue processing remaining buffer
-                                    except json.JSONDecodeError:
-                                        pass  # Continue accumulating buffer
-                                # If parsing fails, accumulate more data
-                                break
-                            except Exception as e:
-                                logger.error(f"Unexpected error in Gemini stream: {str(e)} - Data: {buffer}")
-                                yield f"Error in stream: {str(e)}"
-                                buffer = ""
-                                break
-
-    except httpx.HTTPStatusError as e:
-        response_text = await e.response.aread()
-        logger.error(f"Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
-        yield f"Error: Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
-    except Exception as e:
-        logger.error(f"Gemini Error: {str(e)}\nStack trace: {traceback.format_exc()}")
-        yield f"Error: Gemini Error: {str(e)}"
-
-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]]], None]:
-    logger.info(f"Processing query with providers: {providers}")
-    openai_response = ""
-    anthropic_response = ""
-    gemini_response = ""
-    
-    # Initialize chatbot messages for each provider
-    openai_messages = []
-    anthropic_messages = []
-    gemini_messages = []
-    
-    # Populate history for each chatbot
-    for msg in history:
-        openai_messages.append({"role": "user", "content": msg["user"]})
-        anthropic_messages.append({"role": "user", "content": msg["user"]})
-        gemini_messages.append({"role": "user", "content": msg["user"]})
-        if msg["bot"]:
-            # Parse the combined response to extract provider-specific responses
-            lines = msg["bot"].split("\n\n")
-            for line in lines:
-                if line.startswith("[OpenAI]:"):
-                    openai_messages.append({"role": "assistant", "content": line[len("[OpenAI]:"):].strip()})
-                elif line.startswith("[Anthropic]:"):
-                    anthropic_messages.append({"role": "assistant", "content": line[len("[Anthropic]:"):].strip()})
-                elif line.startswith("[Gemini]:"):
-                    gemini_messages.append({"role": "assistant", "content": line[len("[Gemini]:"):].strip()})
-
-    # Append the current query to all chatbots
-    if "OpenAI" in providers:
-        openai_messages.append({"role": "user", "content": query})
-        openai_messages.append({"role": "assistant", "content": ""})
-    if "Anthropic" in providers:
-        anthropic_messages.append({"role": "user", "content": query})
-        anthropic_messages.append({"role": "assistant", "content": ""})
-    if "Gemini" in providers:
-        gemini_messages.append({"role": "user", "content": query})
-        gemini_messages.append({"role": "assistant", "content": ""})
-
-    # Handle OpenAI (streaming)
-    if "OpenAI" in providers:
-        async for chunk in ask_openai(query, history):
-            openai_response += chunk
-            # Update OpenAI chatbot with streaming response
-            openai_messages[-1] = {"role": "assistant", "content": openai_response}
-            yield "", openai_messages, anthropic_messages, gemini_messages
-
-    # Handle Anthropic (streaming)
-    if "Anthropic" in providers:
-        async for chunk in ask_anthropic(query, history):
-            anthropic_response += chunk
-            # Update Anthropic chatbot with streaming response
-            anthropic_messages[-1] = {"role": "assistant", "content": anthropic_response}
-            yield "", openai_messages, anthropic_messages, gemini_messages
-
-    # Handle Gemini (streaming)
-    if "Gemini" in providers:
-        async for chunk in ask_gemini(query, history):
-            gemini_response += chunk
-            # Update Gemini chatbot with streaming response
-            gemini_messages[-1] = {"role": "assistant", "content": gemini_response}
-            yield "", openai_messages, anthropic_messages, gemini_messages
-
-    # Combine responses for history
-    responses = []
-    if openai_response.strip() and not openai_response.startswith("Error:"):
-        responses.append(f"[OpenAI]: {openai_response}")
-    if anthropic_response.strip() and not anthropic_response.startswith("Error:"):
-        responses.append(f"[Anthropic]: {anthropic_response}")
-    if gemini_response.strip() and not gemini_response.startswith("Error:"):
-        responses.append(f"[Gemini]: {gemini_response}")
-    
-    combined_response = "\n\n".join(responses) if responses else "No valid responses received."
-    updated_history = history + [{"user": query, "bot": combined_response}]
-    logger.info(f"Updated history: {updated_history}")
-
-    # Yield final response
-    yield "", openai_messages, anthropic_messages, gemini_messages
-
-async def submit_query(query: str, providers: List[str]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]]], None]:
-    if not query.strip():
-        openai_messages = [{"role": "assistant", "content": "Please enter a query."}]
-        anthropic_messages = [{"role": "assistant", "content": "Please enter a query."}]
-        gemini_messages = [{"role": "assistant", "content": "Please enter a query."}]
-        yield "", openai_messages, anthropic_messages, gemini_messages
-        return
-    
-    if not providers:
-        openai_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
-        anthropic_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
-        gemini_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
-        yield "", openai_messages, anthropic_messages, gemini_messages
-        return
-
-    # Initialize history
-    history = []
-    
-    async for response_chunk, openai_messages, anthropic_messages, gemini_messages in query_model(query, providers, history):
-        yield "", openai_messages, anthropic_messages, gemini_messages
-    # Final yield to clear the query textbox
-    yield "", openai_messages, anthropic_messages, gemini_messages
-
-# Gradio interface
-def clear_history():
-    return [], [], []
+from core import submit_query, clear_history
 
 # Define Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), css=".full-height { height: 100%; display: flex; align-items: stretch; min-height: 40px; } .full-height button { height: 100%; padding: 8px 16px; } .providers-row { height: 100%; display: flex; align-items: stretch; min-height: 40px; } .providers-row .checkbox-group { height: 100%; display: flex; flex-direction: row; align-items: center; gap: 10px; }") as demo:
     gr.Markdown("# Multi-Model Chat")
     gr.Markdown("Chat with OpenAI, Anthropic, or Gemini. Select providers and compare responses side by side!")
     
-    providers = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Providers", value=["OpenAI"])
-    query = gr.Textbox(label="Enter your query", placeholder="e.g., What is the capital of the United States?")
+    with gr.Row(elem_classes="providers-row"):
+        providers = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Providers", value=["OpenAI"], elem_classes="checkbox-group")
+    
+    with gr.Row(elem_classes="full-height"):
+        query = gr.Textbox(label="Enter your query", placeholder="e.g., What is the capital of the United States?", scale=4)
+        submit_button = gr.Button("Submit", scale=1)
+    
+    with gr.Row():
+        clear_button = gr.Button("Clear History")
     
     with gr.Row():
         openai_chatbot = gr.Chatbot(label="OpenAI", type="messages", scale=1)
         anthropic_chatbot = gr.Chatbot(label="Anthropic", type="messages", scale=1)
         gemini_chatbot = gr.Chatbot(label="Gemini", type="messages", scale=1)
-    
-    with gr.Row():
-        submit_button = gr.Button("Submit")
-        clear_button = gr.Button("Clear History")
 
     submit_button.click(
         fn=submit_query,

config.py

@@ -0,0 +1,14 @@
+import os
+import logging
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+logger.info("Environment variables loaded from .env file")
+logger.info(f"OPENAI_API_KEY present: {'OPENAI_API_KEY' in os.environ}")
+logger.info(f"ANTHROPIC_API_KEY present: {'ANTHROPIC_API_KEY' in os.environ}")
+logger.info(f"GEMINI_API_KEY present: {'GEMINI_API_KEY' in os.environ}")

core.py

@@ -0,0 +1,147 @@
+import asyncio
+from typing import AsyncGenerator, List, Dict, Tuple
+from config import logger
+from api import ask_openai, ask_anthropic, ask_gemini
+
+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]]], None]:
+    logger.info(f"Processing query with providers: {providers}")
+    openai_response = ""
+    anthropic_response = ""
+    gemini_response = ""
+    
+    openai_messages = []
+    anthropic_messages = []
+    gemini_messages = []
+    
+    for msg in history:
+        openai_messages.append({"role": "user", "content": msg["user"]})
+        anthropic_messages.append({"role": "user", "content": msg["user"]})
+        gemini_messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            lines = msg["bot"].split("\n\n")
+            for line in lines:
+                if line.startswith("[OpenAI]:"):
+                    openai_messages.append({"role": "assistant", "content": line[len("[OpenAI]:"):].strip()})
+                elif line.startswith("[Anthropic]:"):
+                    anthropic_messages.append({"role": "assistant", "content": line[len("[Anthropic]:"):].strip()})
+                elif line.startswith("[Gemini]:"):
+                    gemini_messages.append({"role": "assistant", "content": line[len("[Gemini]:"):].strip()})
+
+    if "OpenAI" in providers:
+        openai_messages.append({"role": "user", "content": query})
+        openai_messages.append({"role": "assistant", "content": ""})
+    if "Anthropic" in providers:
+        anthropic_messages.append({"role": "user", "content": query})
+        anthropic_messages.append({"role": "assistant", "content": ""})
+    if "Gemini" in providers:
+        gemini_messages.append({"role": "user", "content": query})
+        gemini_messages.append({"role": "assistant", "content": ""})
+
+    tasks = []
+    if "OpenAI" in providers:
+        tasks.append(("OpenAI", ask_openai(query, history), openai_response, openai_messages))
+    if "Anthropic" in providers:
+        tasks.append(("Anthropic", ask_anthropic(query, history), anthropic_response, anthropic_messages))
+    if "Gemini" in providers:
+        tasks.append(("Gemini", ask_gemini(query, history), gemini_response, gemini_messages))
+
+    async def collect_chunks(provider: str, generator: AsyncGenerator, response: str, messages: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, str, List[Dict[str, str]]], None]:
+        async for chunk in generator:
+            response += chunk
+            messages[-1] = {"role": "assistant", "content": response}
+            yield provider, response, messages
+
+    generator_states = [(provider, collect_chunks(provider, gen, resp, msgs), None) for provider, gen, resp, msgs in tasks]
+    active_generators = generator_states[:]
+
+    while active_generators:
+        tasks_to_wait = []
+        new_generator_states = []
+        
+        for provider, gen, active_task in active_generators:
+            if active_task is None or active_task.done():
+                try:
+                    task = asyncio.create_task(gen.__anext__())
+                    new_generator_states.append((provider, gen, task))
+                    tasks_to_wait.append(task)
+                    logger.debug(f"Created task for {provider}")
+                except StopAsyncIteration:
+                    logger.info(f"Generator for {provider} completed")
+                    continue
+            else:
+                new_generator_states.append((provider, gen, active_task))
+                tasks_to_wait.append(active_task)
+        
+        if not tasks_to_wait:
+            break
+
+        done, _ = await asyncio.wait(tasks_to_wait, return_when=asyncio.FIRST_COMPLETED)
+        
+        for provider, gen, task in new_generator_states:
+            if task in done:
+                try:
+                    provider, response, messages = task.result()
+                    if provider == "OpenAI":
+                        openai_response = response
+                        openai_messages = messages
+                    elif provider == "Anthropic":
+                        anthropic_response = response
+                        anthropic_messages = messages
+                    elif provider == "Gemini":
+                        gemini_response = response
+                        gemini_messages = messages
+                    logger.info(f"Yielding update for {provider}: {response[:50]}...")
+                    yield "", openai_messages, anthropic_messages, gemini_messages
+                    new_generator_states[new_generator_states.index((provider, gen, task))] = (provider, gen, None)
+                except StopAsyncIteration:
+                    logger.info(f"Generator for {provider} completed")
+                    new_generator_states.remove((provider, gen, task))
+            else:
+                if (provider, gen, task) not in new_generator_states:
+                    new_generator_states.append((provider, gen, task))
+
+        active_generators = new_generator_states
+
+    responses = []
+    if openai_response.strip() and not openai_response.startswith("Error:"):
+        responses.append(f"[OpenAI]: {openai_response}")
+    if anthropic_response.strip() and not anthropic_response.startswith("Error:"):
+        responses.append(f"[Anthropic]: {anthropic_response}")
+    if gemini_response.strip() and not gemini_response.startswith("Error:"):
+        responses.append(f"[Gemini]: {gemini_response}")
+    
+    combined_response = "\n\n".join(responses) if responses else "No valid responses received."
+    updated_history = history + [{"user": query, "bot": combined_response}]
+    logger.info(f"Updated history: {updated_history}")
+
+    yield "", openai_messages, anthropic_messages, gemini_messages
+
+async def submit_query(query: str, providers: List[str]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]]], None]:
+    if not query.strip():
+        openai_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        anthropic_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        gemini_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        logger.info("Yielding empty query response")
+        yield "", openai_messages, anthropic_messages, gemini_messages
+        return
+    
+    if not providers:
+        openai_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        anthropic_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        gemini_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        logger.info("Yielding no providers response")
+        yield "", openai_messages, anthropic_messages, gemini_messages
+        return
+
+    history = []
+    
+    async for response_chunk, openai_messages, anthropic_messages, gemini_messages in query_model(query, providers, history):
+        logger.info(f"Submitting update to UI: OpenAI: {openai_messages[-1]['content'][:50] if openai_messages else ''}, "
+                    f"Anthropic: {anthropic_messages[-1]['content'][:50] if anthropic_messages else ''}, "
+                    f"Gemini: {gemini_messages[-1]['content'][:50] if gemini_messages else ''}")
+        yield "", openai_messages, anthropic_messages, gemini_messages
+    logger.info("Final UI update")
+    yield "", openai_messages, anthropic_messages, gemini_messages
+
+def clear_history():
+    return [], [], []