gpt-4o-mini streaming error fix

app.py

@@ -24,6 +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
     messages = []
     for msg in history:
         messages.append({"role": "user", "content": msg["user"]})
@@ -48,6 +49,7 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                 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: "):
@@ -57,19 +59,25 @@ async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerato
                                 if not data.strip():
                                     continue
                                 try:
-                                    json_data = json.loads(data)
+                                    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:
-        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}"
+        # 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:
@@ -78,6 +86,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
     messages = []
     for msg in history:
         messages.append({"role": "user", "content": msg["user"]})
@@ -119,6 +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
     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,9 +162,12 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
 
 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 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)
@@ -164,6 +177,7 @@ async def query_model(query: str, provider: str, history: List[Dict[str, str]])
         yield response, history
     else:
         response = f"Error: Unknown provider: {provider}"
+        logger.error(response)
         yield response, history
 
     # Update history with the new query and response
@@ -177,22 +191,33 @@ async def submit_query(query: str, provider: str, history: List[Dict[str, str]])
         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
-        
-        # Convert history to chatbot messages format
+        # 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"]})
-        
-        # Yield incremental updates for streaming
-        yield response_chunk, chatbot_messages, updated_history
-    
-    updated_history.append({"user": query, "bot": response})
-    yield response, chatbot_messages, updated_history
+        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
 
 # Gradio interface
 def clear_history():