OpenAI and Gemini works

app.py

@@ -24,7 +24,7 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
         yield "Error: OpenAI API key not provided."
         return
 
-    # Build message history
+    # Build message history with user and assistant roles
     messages = []
     for msg in history:
         messages.append({"role": "user", "content": msg["user"]})
@@ -38,7 +38,7 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
     }
 
     payload = {
-        "model": "gpt-4o-mini",
+        "model": "gpt-3.5-turbo",
         "messages": messages,
         "stream": True
     }
@@ -47,11 +47,13 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
         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:
-                        # Parse the streaming chunk (JSON lines)
-                        lines = chunk.splitlines()
-                        for line in lines:
+                        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]":
@@ -59,7 +61,7 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                                 if not data.strip():
                                     continue
                                 try:
-                                    json_data = json.loads(data)  # Safely parse JSON
+                                    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:
@@ -72,7 +74,6 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                                     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')}"
@@ -86,7 +87,7 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> str:
         logger.error("Anthropic API key not provided")
         return "Error: Anthropic API key not provided."
 
-    # Build message history
+    # Build message history with user and assistant roles
     messages = []
     for msg in history:
         messages.append({"role": "user", "content": msg["user"]})
@@ -114,7 +115,6 @@ async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> str:
         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}"
@@ -128,7 +128,7 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
         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
+    # 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"
@@ -152,7 +152,6 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
         
         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}"
@@ -160,58 +159,46 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
         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
-    
-    logger.info(f"Processing query with provider: {provider}")
-    if provider == "openai":
+async def query_model(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]]], None]:
+    logger.info(f"Processing query with providers: {providers}")
+    responses = []  # To collect responses from each provider
+    streaming_response = ""
+
+    # Handle OpenAI (streaming)
+    if "OpenAI" in providers:
         async for chunk in ask_openai(query, history):
-            response += chunk
-            yield chunk, history  # Yield partial response for streaming
-    elif provider == "anthropic":
+            streaming_response += chunk
+            # Yield streaming updates for OpenAI
+            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"]})
+            chatbot_messages.append({"role": "user", "content": query})
+            chatbot_messages.append({"role": "assistant", "content": streaming_response})
+            yield "", chatbot_messages, history  # Yield partial updates
+        if streaming_response.strip():
+            responses.append(f"[OpenAI]: {streaming_response}")
+
+    # Handle Anthropic (non-streaming)
+    if "Anthropic" in providers:
         response = await ask_anthropic(query, history)
-        yield response, history
-    elif provider == "gemini":
+        if response.strip():
+            responses.append(f"[Anthropic]: {response}")
+
+    # Handle Gemini (non-streaming)
+    if "Gemini" in providers:
         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}]
+        if response.strip():
+            responses.append(f"[Gemini]: {response}")
+
+    # Combine responses
+    combined_response = "\n\n".join(responses) if responses else "No valid responses received."
+    # Update history with the combined response
+    updated_history = history + [{"user": query, "bot": combined_response}]
     logger.info(f"Updated history: {updated_history}")
-    yield response, 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]:
-    if not query.strip():
-        yield "", [{"role": "assistant", "content": "Please enter a query."}], history
-        return
-    
-    response = ""
-    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
+    # Yield final response
     chatbot_messages = []
     for msg in updated_history:
         chatbot_messages.append({"role": "user", "content": msg["user"]})
@@ -219,6 +206,22 @@ async def submit_query(query: str, provider: str, history: List[Dict[str, str]])
             chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
     yield "", chatbot_messages, updated_history
 
+async def submit_query(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]]], None]:
+    if not query.strip():
+        chatbot_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        yield "", chatbot_messages, history
+        return
+    
+    if not providers:
+        chatbot_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        yield "", chatbot_messages, history
+        return
+
+    async for response_chunk, chatbot_messages, updated_history in query_model(query, providers, history):
+        yield "", chatbot_messages, updated_history  # Keep query textbox unchanged during streaming
+    # Final yield to clear the query textbox
+    yield "", chatbot_messages, updated_history
+
 # Gradio interface
 def clear_history():
     return [], []
@@ -226,9 +229,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 providers and start typing!")
     
-    provider = gr.Dropdown(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Provider", value="OpenAI")
+    providers = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Providers", value=["OpenAI"])
     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?")
@@ -237,7 +240,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
     submit_button.click(
         fn=submit_query,
-        inputs=[query, provider, history_state],
+        inputs=[query, providers, history_state],
         outputs=[query, chatbot, history_state]
     )
     clear_button.click(