Update app.py

app.py

@@ -20,7 +20,6 @@ app.add_middleware(
     expose_headers=["*"]
 )
 
-# --- Konfiguracja backendów ---
 BACKENDS = {
     "qwen": {
         "url": os.environ.get("KAI_QWEN_URL", "https://your-qwen-space.hf.space"),
@@ -45,7 +44,6 @@ class ChatRequest(BaseModel):
     stream: bool = True
     model: Optional[str] = None
 
-# --- Heurystyka wyboru modelu ---
 CODE_KEYWORDS = re.compile(r'\b(def|class|import|function|const|let|var|public|private|return|python|javascript|java|c\+\+|sql|html|css|json|api|docker|git|kod|funkcja|program|skrypt|algorytm)\b', re.I)
 MATH_KEYWORDS = re.compile(r'\b(oblicz|policz|równanie|całka|pochodna|macierz|prawdopodobieństwo|logarytm|pierwiastek|ile to|=\?|\d+\s*[\+\-\*\/]\s*\d+)\b', re.I)
 CREATIVE_KEYWORDS = re.compile(r'\b(napisz|wiersz|opowiadanie|historia|bajka|rap|tekst|piosenka|kreatywny|stwórz|wymyśl|zrób post|dialog)\b', re.I)
@@ -56,24 +54,20 @@ def route_model(messages: List[Message], forced_model: Optional[str] = None) ->
 
     user_text = " ".join([m.content for m in messages if m.role == "user"]).lower()
 
-    # Priorytet 1: Kod lub matma -> Qwen
     if CODE_KEYWORDS.search(user_text) or MATH_KEYWORDS.search(user_text):
         return "qwen"
 
-    # Priorytet 2: Kreatywne PL -> Mistral
     if CREATIVE_KEYWORDS.search(user_text):
         return "mistral"
 
-    # Domyślnie: Mistral dla PL, Qwen dla reszty
-    # Prosta heurystyka PL
     pl_chars = len(re.findall(r'[ąćęłńóśźż]', user_text))
     if pl_chars > 2:
         return "mistral"
 
-    return "qwen" # domyślnie Qwen bo szybszy
+    return "qwen"
 
-# --- Proxy do backendu ---
-async def proxy_to_backend(backend_name: str, request_data: dict, stream: bool):
+# --- 2 oddzielne funkcje: stream i non-stream ---
+async def proxy_stream(backend_name: str, request_data: dict):
     backend = BACKENDS[backend_name]
     url = f"{backend['url']}/v1/chat/completions"
     headers = {
@@ -82,27 +76,33 @@ async def proxy_to_backend(backend_name: str, request_data: dict, stream: bool):
     }
 
     async with httpx.AsyncClient(timeout=180.0) as client:
-        if stream:
-            async with client.stream("POST", url, json=request_data, headers=headers) as r:
-                if r.status_code!= 200:
-                    err = await r.aread()
-                    raise HTTPException(r.status_code, f"Backend {backend_name} error: {err.decode()}")
-
-                # Wysyłamy info który model został użyty
-                yield f": x-kai-model-used {backend_name}\n\n"
-                yield f": connected\n\n"
-
-                async for chunk in r.aiter_bytes():
-                    yield chunk
-        else:
-            r = await client.post(url, json=request_data, headers=headers)
+        async with client.stream("POST", url, json=request_data, headers=headers) as r:
             if r.status_code!= 200:
-                raise HTTPException(r.status_code, f"Backend {backend_name} error: {r.text}")
-            data = r.json()
-            data["kai_model_used"] = backend_name
-            return data
+                err = await r.aread()
+                raise HTTPException(r.status_code, f"Backend {backend_name} error: {err.decode()}")
+
+            yield f": x-kai-model-used {backend_name}\n\n"
+            yield f": connected\n\n"
+
+            async for chunk in r.aiter_bytes():
+                yield chunk
+
+async def proxy_non_stream(backend_name: str, request_data: dict):
+    backend = BACKENDS[backend_name]
+    url = f"{backend['url']}/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {backend['key']}",
+        "Content-Type": "application/json"
+    }
+
+    async with httpx.AsyncClient(timeout=180.0) as client:
+        r = await client.post(url, json=request_data, headers=headers)
+        if r.status_code!= 200:
+            raise HTTPException(r.status_code, f"Backend {backend_name} error: {r.text}")
+        data = r.json()
+        data["kai_model_used"] = backend_name
+        return data
 
-# --- Endpointy ---
 @app.get("/", response_class=HTMLResponse)
 async def serve_frontend():
     with open("static/index.html", "r", encoding="utf-8") as f:
@@ -113,18 +113,17 @@ async def chat_completions(data: ChatRequest, request: Request):
     chosen_backend = route_model(data.messages, data.model)
 
     request_data = data.dict()
-    request_data.pop("model", None) # usuwamy bo backendy nie potrzebują
+    request_data.pop("model", None)
 
     if data.stream:
-        generator = proxy_to_backend(chosen_backend, request_data, True)
+        generator = proxy_stream(chosen_backend, request_data)
         return StreamingResponse(generator, media_type="text/event-stream")
     else:
-        result = await proxy_to_backend(chosen_backend, request_data, False)
+        result = await proxy_non_stream(chosen_backend, request_data)
         return JSONResponse(content=result)
 
 @app.get("/health")
 async def health():
     return {"status": "ok", "backends": list(BACKENDS.keys())}
 
-# Serwuj pliki statyczne
 app.mount("/static", StaticFiles(directory="static"), name="static")