Update app.py

app.py

@@ -1,23 +1,14 @@
-import os
-import json
-import httpx
-import gradio as gr
-import uvicorn
-from fastapi import FastAPI, Request, Header, HTTPException, File, UploadFile, Form
-from fastapi.responses import JSONResponse, StreamingResponse, Response
+import os, json, httpx, gradio as gr, uvicorn
+from fastapi import FastAPI, Request, Header, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
 import time
-import base64
-import io
-
 # ---------------------------------------------------------------------
-# Configuration - FIXED TRAILING SPACES
+# Configuration
 # ---------------------------------------------------------------------
 BYTEZ_CHAT_URL   = "https://api.bytez.com/models/v2/openai/v1/chat/completions"
 BYTEZ_MODELS_URL = "https://api.bytez.com/models/v2/list/models"
-BYTEZ_TTS_URL    = "https://api.bytez.com/models/v2/openai/tts-1-hd"
-BYTEZ_STT_URL    = "https://api.bytez.com/models/v2/openai/whisper-1"
-BYTEZ_AUTH       = os.getenv("BYTEZ_API_KEY")
-LOCAL_API_KEY    = os.getenv("LOCAL_API_KEY")
+BYTEZ_AUTH  = os.getenv("BYTEZ_API_KEY")
+LOCAL_API_KEY = os.getenv("LOCAL_API_KEY")
 
 # ---------------------------------------------------------------------
 # FastAPI backend
@@ -39,19 +30,21 @@ def root():
     return {"status": "ok", "message": "Bytez proxy running"}
 
 # ---------------------------------------------------------------------
-# /v1/models → must look OpenAI-style
+# /v1/models  →  must look OpenAI-style
 # ---------------------------------------------------------------------
 @api.get("/v1/models")
 async def models(authorization: str = Header(None)):
     check_key(authorization)
     if not BYTEZ_AUTH:
         raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
+
     async with httpx.AsyncClient(timeout=30) as c:
         r = await c.get(BYTEZ_MODELS_URL, headers={"Authorization": BYTEZ_AUTH})
     try:
         data = r.json()
     except json.JSONDecodeError:
         raise HTTPException(status_code=502, detail="Upstream returned invalid JSON")
+
     # Transform Bytez format → OpenAI format
     models_list = [
         {"id": m.get("id") or m.get("name"), "object": "model"}
@@ -63,75 +56,82 @@ async def models(authorization: str = Header(None)):
     )
 
 # ---------------------------------------------------------------------
-# /v1/chat/completions - FIXED STREAMING AND SYNTAX
+# /v1/chat/completions
 # ---------------------------------------------------------------------
 @api.post("/v1/chat/completions")
 async def chat(request: Request, authorization: str = Header(None)):
     check_key(authorization)
     if not BYTEZ_AUTH:
         raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
+
     payload = await request.json()
     stream = payload.get("stream", False)
+
     headers = {
         "Authorization": BYTEZ_AUTH,
         "Content-Type": "application/json",
     }
-    
+
+    # Helper to transform Bytez stream chunk → OpenAI stream format
     async def event_stream():
-        first_chunk = True  # Track first chunk for role
         async with httpx.AsyncClient(timeout=120) as client:
             async with client.stream("POST", BYTEZ_CHAT_URL, headers=headers, json=payload) as upstream:
                 async for line in upstream.aiter_lines():
                     line = line.strip()
                     if not line:
                         continue
+
+                    # If line starts with "data: ", strip it; else assume raw JSON
                     if line.startswith("data: "):
-                        json_str = line[6:].strip()
+                        json_str = line[6:]  # remove "data: "
                     else:
                         json_str = line
-                    
-                    if json_str == "[DONE]":
-                        yield "data: [DONE]\n\n"
-                        break
-                    
+
                     try:
                         chunk = json.loads(json_str)
                     except json.JSONDecodeError:
-                        continue
-                    
-                    # Skip metadata chunks
-                    if "usage" in chunk or not chunk.get("choices"):
-                        continue
-                    
-                    choice = chunk["choices"][0]
+                        continue  # skip malformed
+
+                    # Check for [DONE] signal
+                    if json_str == "[DONE]":
+                        yield "data: [DONE]\n\n"
+                        break
+
+                    # Extract content from Bytez chunk
+                    # ⚠️ ADJUST THIS BASED ON ACTUAL BYTEZ STREAM FORMAT!
+                    # Example: if Bytez returns {"token": "hello"} → use token
+                    # Or if it returns {"choices": [{"delta": {"content": "x"}}]} → use delta.content
+
                     content = ""
-                    if "delta" in choice and "content" in choice["delta"]:
-                        content = choice["delta"]["content"]
-                    elif "token" in chunk:
+                    if "token" in chunk:
                         content = chunk["token"]
+                    elif "choices" in chunk and len(chunk["choices"]) > 0:
+                        delta = chunk["choices"][0].get("delta", {})
+                        content = delta.get("content", "")
                     elif "text" in chunk:
                         content = chunk["text"]
                     else:
-                        continue
-                    
-                    # Build delta - role only in first chunk
-                    delta = {"content": content}
-                    if first_chunk:
-                        delta["role"] = "assistant"
-                        first_chunk = False
-                    
+                        content = str(chunk)  # fallback
+
+                    # Build OpenAI-compatible chunk
                     openai_chunk = {
                         "id": "chatcmpl-proxy-stream",
                         "object": "chat.completion.chunk",
                         "created": int(time.time()),
                         "model": payload.get("model", "unknown"),
-                        "choices": [{
-                            "index": 0,
-                            "delta": delta,
-                            "finish_reason": None,
-                        }],
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {"role": "assistant", "content": content},
+                                "finish_reason": None,
+                            }
+                        ],
                     }
+
+                    # Send in correct SSE format
                     yield f"data: {json.dumps(openai_chunk)}\n\n"
+
+        # Always send [DONE] at end (even if upstream didn't)
         yield "data: [DONE]\n\n"
 
     if stream:
@@ -140,16 +140,15 @@ async def chat(request: Request, authorization: str = Header(None)):
             media_type="text/event-stream",
             headers={"Access-Control-Allow-Origin": "*"}
         )
-    
-    # Non-streaming path - FIXED SYNTAX ERROR HERE
+
+    # Non-streaming path (unchanged)
     async with httpx.AsyncClient(timeout=120) as c:
         r = await c.post(BYTEZ_CHAT_URL, headers=headers, json=payload)
     try:
         data = r.json()
     except json.JSONDecodeError:
         raise HTTPException(status_code=502, detail="Upstream returned invalid JSON")
-    
-    # FIXED: Complete the condition
+
     if "choices" not in data:
         content = (
             data.get("output")
@@ -164,144 +163,17 @@ async def chat(request: Request, authorization: str = Header(None)):
                 {"index": 0, "message": {"role": "assistant", "content": content}}
             ],
         }
-    return JSONResponse(data, headers={"Access-Control-Allow-Origin": "*"})
-
-# ---------------------------------------------------------------------
-# TTS ENDPOINTS (ALL VARIATIONS)
-# ---------------------------------------------------------------------
-@api.post("/v1/audio/speech")
-@api.post("/v1/tts/audio/speech")
-@api.post("/v1/tts")
-@api.post("/v1/tts/audio/transcriptions")
-async def tts_endpoint(
-    request: Request = None,
-    authorization: str = Header(None),
-    text: str = Form(None),
-    file: UploadFile = File(None)
-):
-    check_key(authorization)
-    if not BYTEZ_AUTH:
-        raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
-    
-    # Handle different content types
-    if request and request.headers.get("Content-Type", "").startswith("application/json"):
-        try:
-            payload = await request.json()
-            text = payload.get("input") or payload.get("text", "")
-        except:
-            text = ""
-    
-    if not text:
-        raise HTTPException(status_code=400, detail="Missing text for TTS conversion")
-    
-    headers = {
-        "Authorization": BYTEZ_AUTH,
-        "Content-Type": "application/json",
-    }
-    bytez_payload = {"text": text}
-    
-    async with httpx.AsyncClient(timeout=30) as c:
-        try:
-            r = await c.post(BYTEZ_TTS_URL, headers=headers, json=bytez_payload)
-        except Exception as e:
-            raise HTTPException(status_code=502, detail=f"TTS request failed: {str(e)}")
-    
-    if r.status_code != 200:
-        error_detail = r.text[:200] if r.text else f"Status {r.status_code}"
-        raise HTTPException(status_code=r.status_code, detail=f"TTS failed: {error_detail}")
-    
-    # Return raw audio
-    return Response(
-        content=r.content,
-        media_type="audio/mpeg",
-        headers={"Access-Control-Allow-Origin": "*"}
-    )
-
-# ---------------------------------------------------------------------
-# STT ENDPOINTS (ALL VARIATIONS)
-# ---------------------------------------------------------------------
-@api.post("/v1/audio/transcriptions")
-@api.post("/v1/stt")
-@api.post("/v1/stt/audio/transcriptions")
-@api.get("/v1/audio/voices")
-@api.get("/v1/stt/audio/models")
-async def stt_endpoint(
-    request: Request = None,
-    authorization: str = Header(None),
-    file: UploadFile = File(None),
-    model: str = Form("whisper-1")
-):
-    # Handle fake endpoints that just return empty responses
-    if request and request.url.path in ["/v1/audio/voices", "/v1/stt/audio/models"]:
-        return JSONResponse({"data": []})
-    
-    check_key(authorization)
-    if not BYTEZ_AUTH:
-        raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
-    
-    if file is None:
-        raise HTTPException(status_code=400, detail="No audio file provided")
-    
-    try:
-        audio_data = await file.read()
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"File read error: {str(e)}")
-    
-    # Convert to base64 data URL
-    mime_type = file.content_type or "audio/wav"
-    audio_b64 = base64.b64encode(audio_data).decode('utf-8')
-    data_url = f"data:{mime_type};base64,{audio_b64}"
-    
-    headers = {
-        "Authorization": BYTEZ_AUTH,
-        "Content-Type": "application/json",
-    }
-    bytez_payload = {
-        "url": data_url,
-        "model": model
-    }
-    
-    async with httpx.AsyncClient(timeout=60) as c:
-        try:
-            r = await c.post(BYTEZ_STT_URL, headers=headers, json=bytez_payload)
-        except Exception as e:
-            raise HTTPException(status_code=502, detail=f"STT request failed: {str(e)}")
-    
-    if r.status_code != 200:
-        error_detail = r.text[:200] if r.text else f"Status {r.status_code}"
-        raise HTTPException(status_code=r.status_code, detail=f"STT failed: {error_detail}")
-    
-    try:
-        data = r.json()
-    except json.JSONDecodeError:
-        transcript = r.text.strip()
-        if not transcript:
-            raise HTTPException(status_code=502, detail="STT returned empty response")
-        return JSONResponse({"text": transcript}, headers={"Access-Control-Allow-Origin": "*"})
-    
-    # Extract transcript from various possible formats
-    transcript = (
-        data.get("text") or 
-        data.get("transcript") or 
-        data.get("result", {}).get("text", "") or
-        str(data)
-    )
-    
-    return JSONResponse({"text": transcript}, headers={"Access-Control-Allow-Origin": "*"})
 
+    return JSONResponse(data, headers={"Access-Control-Allow-Origin": "*"})
 # ---------------------------------------------------------------------
-# Minimal Gradio UI
+# Minimal Gradio UI (to make HF Space start)
 # ---------------------------------------------------------------------
 with gr.Blocks() as ui:
     gr.Markdown("### ✅ Jwero Bytez → OpenAI Proxy\n"
-                "**Supported Endpoints:**\n"
-                "- `/v1/models`\n"
-                "- `/v1/chat/completions`\n"
-                "- `/v1/audio/speech` (TTS)\n"
-                "- `/v1/audio/transcriptions` (STT)\n\n"
-                "**Also compatible with non-standard endpoints**")
+                "Endpoints: `/v1/models`, `/v1/chat/completions`")
 
 demo = gr.mount_gradio_app(api, ui, path="/")
 
+# local only
 if __name__ == "__main__":
     uvicorn.run(demo, host="0.0.0.0", port=7860)