change from dropdown to checkbox

app.py

@@ -17,207 +17,53 @@ 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
-    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-4o-mini",
-        "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()
-                async for chunk in response.aiter_text():
-                    if chunk:
-                        # Parse the streaming chunk (JSON lines)
-                        lines = chunk.splitlines()
-                        for line in lines:
-                            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)  # Safely parse JSON
-                                    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:
-        # Read the response body for streaming responses
-        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]]) -> str:
-    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
-    if not anthropic_api_key:
-        logger.error("Anthropic API key not provided")
-        return "Error: Anthropic API key not provided."
-
-    # Build message history
-    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
-    }
-
-    try:
-        async with httpx.AsyncClient() as client:
-            logger.info(f"Sending Anthropic request: {payload}")
-            response = await client.post("https://api.anthropic.com/v1/messages", headers=headers, json=payload)
-        
-        response.raise_for_status()
-        logger.info(f"Anthropic response: {response.json()}")
-        return response.json()['content'][0]['text']
-
-    except httpx.HTTPStatusError as e:
-        logger.error(f"Anthropic HTTP Status Error: {e.response.status_code}, {e.response.text}")
-        return f"Error: Anthropic HTTP Status Error: {e.response.status_code}, {e.response.text}"
-    except Exception as e:
-        logger.error(f"Anthropic Error: {str(e)}")
-        return f"Error: Anthropic Error: {str(e)}"
+# Asking functions remain the same ...
 
-async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        logger.error("Gemini API key not provided")
-        return "Error: Gemini API key not provided."
-
-    # Gemini doesn't natively support chat history in the same way, so we concatenate history as text
-    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() as client:
-            response = await client.post(
-                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={gemini_api_key}",
-                headers=headers,
-                json=payload
-            )
-        
-        response.raise_for_status()
-        return response.json()['candidates'][0]['content']['parts'][0]['text']
-
-    except httpx.HTTPStatusError as e:
-        logger.error(f"Gemini HTTP Status Error: {e.response.status_code}, {e.response.text}")
-        return f"Error: Gemini HTTP Status Error: {e.response.status_code}, {e.response.text}"
-    except Exception as e:
-        logger.error(f"Gemini Error: {str(e)}")
-        return f"Error: Gemini Error: {str(e)}"
-
-async def query_model(query: str, provider: str, history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]]], None]:
-    provider = provider.lower()
-    response = ""  # Initialize response to avoid UnboundLocalError
+async def query_model(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[List[Tuple[str, str]], None]:
+    responses = []
     
-    logger.info(f"Processing query with provider: {provider}")
-    if provider == "openai":
-        async for chunk in ask_openai(query, history):
-            response += chunk
-            yield chunk, history  # Yield partial response for streaming
-    elif provider == "anthropic":
-        response = await ask_anthropic(query, history)
-        yield response, history
-    elif provider == "gemini":
-        response = await ask_gemini(query, history)
-        yield response, history
-    else:
-        response = f"Error: Unknown provider: {provider}"
-        logger.error(response)
-        yield response, history
-
-    # Update history with the new query and response
-    updated_history = history + [{"user": query, "bot": response}]
+    for provider in providers:
+        provider = provider.lower()
+        response = ""
+        logger.info(f"Processing query with provider: {provider}")
+        if provider == "openai":
+            async for chunk in ask_openai(query, history):
+                response += chunk
+                yield [(provider, response)], history
+        elif provider == "anthropic":
+            response = await ask_anthropic(query, history)
+            responses.append((provider, response))
+        elif provider == "gemini":
+            response = await ask_gemini(query, history)
+            responses.append((provider, response))
+        else:
+            response = f"Error: Unknown provider: {provider}"
+            logger.error(response)
+            responses.append((provider, response))
+
+    # Update history with the new query and responses
+    updated_history = history + [{"user": query, "bot": " | ".join(resp[1] for resp in responses)}]
     logger.info(f"Updated history: {updated_history}")
-    yield response, updated_history  # Final yield with updated history
+    yield responses, updated_history  # Final yield with updated history
 
-async def submit_query(query: str, provider: str, history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]]], None]:
+async def submit_query(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[List[str], None]:
     if not query.strip():
-        yield "", [{"role": "assistant", "content": "Please enter a query."}], history
+        yield ["Please enter a query."], history
         return
     
-    response = ""
+    responses = []
     chatbot_messages = []
     for msg in history:
         chatbot_messages.append({"role": "user", "content": msg["user"]})
         if msg["bot"]:
             chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
-    async for response_chunk, updated_history in query_model(query, provider, history):
-        response += response_chunk
-        # Update chatbot messages for streaming
-        chatbot_messages = []
-        for msg in updated_history:
-            chatbot_messages.append({"role": "user", "content": msg["user"]})
-            if msg["bot"]:
-                chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
-        if response and provider == "openai":
-            # For streaming, show partial response
-            if chatbot_messages and chatbot_messages[-1]["role"] == "user":
-                chatbot_messages.append({"role": "assistant", "content": response})
-            else:
-                chatbot_messages[-1] = {"role": "assistant", "content": response}
-        yield "", chatbot_messages, updated_history  # Yield to chatbot, not query
-    # Final yield with complete response
-    chatbot_messages = []
-    for msg in updated_history:
-        chatbot_messages.append({"role": "user", "content": msg["user"]})
-        if msg["bot"]:
-            chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
-    yield "", chatbot_messages, updated_history
+    
+    async for response_group, updated_history in query_model(query, providers, history):
+        for provider, response in response_group:
+            responses.append(f"{provider.capitalize()}: {response}")
+            chatbot_messages.append({"role": "assistant", "content": f"{provider.capitalize()}: {response}"})
+
+    yield responses, chatbot_messages, updated_history
 
 # Gradio interface
 def clear_history():
@@ -226,9 +72,9 @@ def clear_history():
 # Define Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Multi-Model Chat")
-    gr.Markdown("Chat with OpenAI, Anthropic, or Gemini. Select a provider and start typing!")
+    gr.Markdown("Chat with OpenAI, Anthropic, or Gemini. Select one or multiple providers and start typing!")
     
-    provider = gr.Dropdown(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Provider", value="OpenAI")
+    provider = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Provider")
     history_state = gr.State(value=[])
     chatbot = gr.Chatbot(label="Conversation", type="messages")
     query = gr.Textbox(label="Enter your query", placeholder="e.g., What is the capital of the United States?")
@@ -238,7 +84,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     submit_button.click(
         fn=submit_query,
         inputs=[query, provider, history_state],
-        outputs=[query, chatbot, history_state]
+        outputs=[chatbot, history_state]
     )
     clear_button.click(
         fn=clear_history,