gpt-4o-mini streaming

app.py

@@ -24,7 +24,6 @@ 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"]})
@@ -49,7 +48,6 @@ 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: "):
@@ -59,23 +57,19 @@ 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:
                                             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:
-        logger.error(f"OpenAI HTTP Status Error: {e.response.status_code}, {e.response.text}")
-        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}, {e.response.text}"
+        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}"
     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:
@@ -84,7 +78,6 @@ 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"]})
@@ -126,7 +119,6 @@ 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"
@@ -160,11 +152,9 @@ 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 = ""
     
     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)
@@ -187,25 +177,22 @@ async def submit_query(query: str, provider: str, history: List[Dict[str, str]])
         return
     
     response = ""
+    
     async for response_chunk, updated_history in query_model(query, provider, history):
         response += response_chunk
+        
         # Convert history to chatbot messages format
         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
-            chatbot_messages[-1] = {"role": "assistant", "content": response}
-        yield "", chatbot_messages, updated_history  # Yield intermediate updates
-    # 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
+        
+        # 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
 
 # Gradio interface
 def clear_history():