chore: update OpenAI package version and refactor chat streaming logic for improved error handling and added test endpoints

backend/app/api/v1/endpoints/chat.py

@@ -1,88 +1,94 @@
+import os
 import json
-import logging
-from typing import AsyncGenerator
 
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
-from openai import OpenAI, APIConnectionError
+from openai import OpenAI
+from typing import List
 
+from ....schemas.chat import Message, ChatRequest
 from ....core.config import settings
-from ....schemas.chat import ChatRequest, Message
-
-logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/chat", tags=["chat"])
 
-# Create a singleton OpenAI client instance.
-client = OpenAI(api_key=settings.OPENAI_API_KEY, timeout=30.0)
-
-
-async def _stream_text(messages: list[Message]) -> AsyncGenerator[str, None]:
-    """Internal helper that yields text deltas as server-sent-events."""
+# Initialize OpenAI client with same simple config as working repo
+client = OpenAI(api_key=settings.OPENAI_API_KEY)
 
-    # Add a default system message as first instruction.
-    system_msg = {
-        "role": "system",
-        "content": (
-            "You are an AI learning assistant for PlayGo AI, an educational platform. "
-            "Your goal is to help students learn and understand various subjects. "
-            "Provide clear, concise, and accurate explanations."
-        ),
-    }
-
-    formatted_messages = [system_msg] + [msg.model_dump() for msg in messages]
 
+async def stream_text(messages: List[Message]):
     try:
+        formatted_messages = [
+            {"role": "system", "content": """You are an AI learning assistant for PlayGo AI, 
+             an educational platform. Your goal is to help students learn and understand various 
+             subjects. Provide clear, concise, and accurate explanations."""},
+        ] + [{"role": msg.role, "content": msg.content} for msg in messages]
+
         stream = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=formatted_messages,
             temperature=0.7,
-            stream=True,
+            stream=True
         )
 
-        # The new Python SDK returns an iterator of events
         for chunk in stream:
             for choice in chunk.choices:
-                # Skip explicit finished signal – handled after loop
                 if choice.finish_reason == "stop":
                     continue
 
-                # Emit the delta as JSON-encoded string prefixed with 0: (Vercel AI convention)
-                yield f"0:{json.dumps(choice.delta.content)}\n"
-
-        # When the stream is exhausted include usage metadata
-        usage = stream.usage if hasattr(stream, "usage") else None
-        if usage:
-            payload = {
-                "finishReason": "stop",
-                "usage": {
-                    "promptTokens": usage.prompt_tokens,
-                    "completionTokens": usage.completion_tokens,
-                },
-            }
-            yield f"d:{json.dumps(payload)}\n"
-
-    except APIConnectionError as e:
-        logger.error("OpenAI connection error: %s", str(e))
-        yield f"Error: Connection error – {str(e)}"
+                else:
+                    yield '0:{text}\n'.format(text=json.dumps(choice.delta.content))
+
+            if chunk.choices == []:
+                usage = chunk.usage
+                prompt_tokens = usage.prompt_tokens
+                completion_tokens = usage.completion_tokens
+                yield 'd:{{"finishReason":"{reason}","usage":{{"promptTokens":{prompt},"completionTokens":{completion}}}}}\n'.format(
+                    reason="stop",
+                    prompt=prompt_tokens,
+                    completion=completion_tokens
+                )
+
     except Exception as e:
-        logger.exception("Unexpected error during streaming chat")
-        yield f"Error: {str(e)}"
+        print(f"Error in stream_text: {str(e)}")
+        yield f"Error: {str(e)}".encode('utf-8')
 
 
 @router.post("/stream")
 async def chat_stream(request: ChatRequest):
-    """Streaming chat endpoint returning SSE-style chunks compatible with Vercel AI."""
-
-    if not settings.OPENAI_API_KEY:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="OPENAI_API_KEY is not configured on the server.",
-        )
-
     response = StreamingResponse(
-        _stream_text(request.messages),
+        stream_text(request.messages),
     )
-    # Vercel AI convention header so front-end recognises a streamed response
-    response.headers["x-vercel-ai-data-stream"] = "v1"
-    return response 
+    response.headers['x-vercel-ai-data-stream'] = 'v1'
+    return response
+
+
+@router.get("/test")
+async def test_chat():
+    return {"message": "Chat endpoint is working!"}
+
+
+@router.get("/test-simple")
+async def test_simple_chat():
+    """Test simple chat completion without streaming - same as working repo"""
+    try:
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "user", "content": "Say 'Hello from simple chat!' in exactly those words."}
+            ],
+            max_tokens=20
+        )
+        
+        return {
+            "status": "success",
+            "message": "Simple chat works!",
+            "response": response.choices[0].message.content,
+            "model": response.model
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error", 
+            "message": f"Simple chat failed: {str(e)}",
+            "error_type": type(e).__name__
+        } 

backend/app/schemas/chat.py

@@ -1,16 +1,11 @@
-from typing import List
-
 from pydantic import BaseModel
+from typing import List
 
 
 class Message(BaseModel):
-    """Represents a single message in the chat conversation"""
-
     content: str
     role: str
 
 
 class ChatRequest(BaseModel):
-    """Schema for chat completion request body"""
-
     messages: List[Message] 

backend/requirements.txt

@@ -2,5 +2,5 @@ fastapi==0.104.1
 uvicorn[standard]==0.24.0
 pydantic==2.5.0
 pydantic-settings==2.1.0
-openai==1.8.2
+openai==1.82.0
 python-dotenv==1.0.0