Update app.py

app.py

@@ -1,108 +1,68 @@
-import os
-import json
-from flask import Flask, request, jsonify, Response, stream_with_context
+# app.py (minimal SSE + CORS)
+from flask import Flask, request, Response, jsonify, stream_with_context
 from flask_cors import CORS
-import httpx
-
+import os, json, httpx
 
 app = Flask(__name__)
-CORS(app)
+CORS(app)  # simple: allow all origins for testing
 
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_NEW")
 
-@app.route("/health", methods=["GET"])
+@app.get("/health")
 def health():
     return jsonify({"status": "ready"}), 200
 
-def openrouter_headers():
+def _headers():
     return {
         "Authorization": f"Bearer {OPENROUTER_API_KEY}",
         "Content-Type": "application/json",
-        "HTTP-Referer": "https://sreepathi-ravikumar-sample1.hf.space",
-        "X-Title": "Educational AI Assistant",
+        "HTTP-Referer": "https://YOURSPACE.hf.space",
+        "X-Title": "Minimal Streaming Test",
     }
 
-def build_payload(question: str) -> dict:
+def _payload(q: str):
     return {
         "model": "deepseek/deepseek-chat-v3-0324:free",
         "stream": True,
-        "messages": [{
-            "role": "user",
-            "content": "condition every topics or heading only must startswith # and endswith :\n\n" + question,
-        }],
-        "temperature": 0.3,
-        "max_tokens": 599,
+        "messages": [{"role": "user", "content": q}],
+        "temperature": 0.2,
+        "max_tokens": 200,
     }
 
-def stream_openrouter(question: str):
+def stream_openrouter(q: str):
+    if not OPENROUTER_API_KEY:
+        yield "data: Missing OPENROUTER_API_NEW\n\n"; return
     with httpx.Client(timeout=None) as client:
-        with client.stream(
-            "POST",
-            "https://openrouter.ai/api/v1/chat/completions",
-            headers=openrouter_headers(),
-            json=build_payload(question),
-        ) as r:
+        with client.stream("POST", "https://openrouter.ai/api/v1/chat/completions",
+                           headers=_headers(), json=_payload(q)) as r:
             r.raise_for_status()
-            # Optional start signal
-            yield "event: start\ndata: stream\n\n"
             for raw in r.iter_lines():
-                if not raw:
+                if not raw: 
                     continue
-                # OpenRouter uses SSE-like "data:" lines
-                if raw.startswith(b"data:"):
-                    data = raw[5:].strip()
-                else:
-                    data = raw.strip()
-
+                data = raw[5:].strip() if raw.startswith(b"data:") else raw.strip()
                 if data == b"[DONE]":
-                    yield "event: done\ndata: [DONE]\n\n"
+                    yield "data: [DONE]\n\n"
                     break
-
                 try:
                     obj = json.loads(data.decode("utf-8"))
                     delta = obj.get("choices", [{}])[0].get("delta", {}).get("content")
                     if delta:
-                        # Wrap each token in JSON so the frontend can parse safely
-                        yield f"data: {json.dumps({'text': delta})}\n\n"
+                        # Send plain text chunks (still framed as SSE data)
+                        yield f"data: {json.dumps(delta)}\n\n"
                 except Exception:
-                    # Fallback: forward as plain text
-                    try:
-                        txt = data.decode("utf-8")
-                    except Exception:
-                        txt = ""
-                    if txt:
-                        yield f"data: {json.dumps({'text': txt})}\n\n"
+                    pass
 
-@app.route("/ask", methods=["POST"])
+@app.post("/ask")
 def ask():
-    try:
-        if not OPENROUTER_API_KEY:
-            return jsonify({"error": "OPENROUTER_API_NEW is not set"}), 500
-
-        data = request.get_json(silent=True) or {}
-        # Accept both keys for compatibility
-        question = (data.get("question") or data.get("userPrompt") or "").strip()
-        if not question:
-            return jsonify({"error": "Question is required"}), 400
-
-        # Stream back as SSE
-        resp = Response(
-            stream_with_context(stream_openrouter(question)),
-            mimetype="text/event-stream",
-        )
-        # Important headers to avoid buffering by proxies/CDNs
-        resp.headers["Cache-Control"] = "no-cache"
-        resp.headers["X-Accel-Buffering"] = "no"
-        resp.headers["Connection"] = "keep-alive"
-        # CORS for SSE: allow the local frontend origins
-        origin = request.headers.get("Origin")
-        if origin in ALLOWED_ORIGINS:
-            resp.headers["Access-Control-Allow-Origin"] = origin
-            resp.headers["Vary"] = "Origin"
-        return resp
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
+    payload = request.get_json(silent=True) or {}
+    q = (payload.get("question") or payload.get("userPrompt") or "").strip()
+    if not q:
+        q = "Say hello in one short sentence."
+    resp = Response(stream_with_context(stream_openrouter(q)), mimetype="text/event-stream")
+    resp.headers["Cache-Control"] = "no-cache"
+    resp.headers["X-Accel-Buffering"] = "no"
+    resp.headers["Connection"] = "keep-alive"
+    return resp
 
 if __name__ == "__main__":
-    # In Spaces, use the default port; locally, 7860 is fine.
-    app.run(host="0.0.0.0", port=7860, debug=True, threaded=True)
+    app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)