Update app.py

app.py

@@ -3,19 +3,21 @@ import json
 import httpx
 import gradio as gr
 import uvicorn
-from fastapi import FastAPI, Request, Header, HTTPException, File, UploadFile
-from fastapi.responses import JSONResponse, StreamingResponse, FileResponse
+from fastapi import FastAPI, Request, Header, HTTPException, File, UploadFile, Form
+from fastapi.responses import JSONResponse, StreamingResponse, Response
 import time
+import base64
+from io import BytesIO
 
 # ---------------------------------------------------------------------
-# Configuration
+# Configuration - FIXED TRAILING SPACES
 # ---------------------------------------------------------------------
-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_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
@@ -61,7 +63,7 @@ async def models(authorization: str = Header(None)):
     )
 
 # ---------------------------------------------------------------------
-# /v1/chat/completions
+# /v1/chat/completions - FIXED STREAMING
 # ---------------------------------------------------------------------
 @api.post("/v1/chat/completions")
 async def chat(request: Request, authorization: str = Header(None)):
@@ -74,7 +76,9 @@ async def chat(request: Request, authorization: str = Header(None)):
         "Authorization": BYTEZ_AUTH,
         "Content-Type": "application/json",
     }
+    
     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():
@@ -82,38 +86,50 @@ async def chat(request: Request, authorization: str = Header(None)):
                     if not line:
                         continue
                     if line.startswith("data: "):
-                        json_str = line[6:]
+                        json_str = line[6:].strip()
                     else:
                         json_str = line
+                    
+                    if json_str == "[DONE]":
+                        yield "data: [DONE]\n\n"
+                        break
+                    
                     try:
                         chunk = json.loads(json_str)
                     except json.JSONDecodeError:
                         continue
-                    if json_str == "[DONE]":
-                        yield "data: [DONE]\n\n"
-                        break
+                    
+                    # Skip metadata chunks
+                    if "usage" in chunk or not chunk.get("choices"):
+                        continue
+                    
+                    choice = chunk["choices"][0]
                     content = ""
-                    if "token" in chunk:
+                    if "delta" in choice and "content" in choice["delta"]:
+                        content = choice["delta"]["content"]
+                    elif "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:
-                        content = str(chunk)
+                        continue
+                    
+                    # Build delta - role only in first chunk
+                    delta = {"content": content}
+                    if first_chunk:
+                        delta["role"] = "assistant"
+                        first_chunk = False
+                    
                     openai_chunk = {
                         "id": "chatcmpl-proxy-stream",
                         "object": "chat.completion.chunk",
                         "created": int(time.time()),
                         "model": payload.get("model", "unknown"),
-                        "choices": [
-                            {
-                                "index": 0,
-                                "delta": {"role": "assistant", "content": content},
-                                "finish_reason": None,
-                            }
-                        ],
+                        "choices": [{
+                            "index": 0,
+                            "delta": delta,
+                            "finish_reason": None,
+                        }],
                     }
                     yield f"data: {json.dumps(openai_chunk)}\n\n"
         yield "data: [DONE]\n\n"
@@ -124,12 +140,15 @@ async def chat(request: Request, authorization: str = Header(None)):
             media_type="text/event-stream",
             headers={"Access-Control-Allow-Origin": "*"}
         )
+    
+    # Non-streaming path
     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")
+    
     if "choices" not in data:
         content = (
             data.get("output")
@@ -147,57 +166,114 @@ async def chat(request: Request, authorization: str = Header(None)):
     return JSONResponse(data, headers={"Access-Control-Allow-Origin": "*"})
 
 # ---------------------------------------------------------------------
-# /v1/tts (Text-to-Speech)
+# /v1/audio/speech → TTS (OpenAI compatible)
 # ---------------------------------------------------------------------
-@api.post("/v1/tts/audio/transcriptions")
+@api.post("/v1/audio/speech")
 async def tts(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()
-    text = payload.get("text", "")
+    
+    try:
+        payload = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON payload")
+    
+    text = payload.get("input", "")
     if not text:
-        raise HTTPException(status_code=400, detail="Text not provided for TTS")
+        raise HTTPException(status_code=400, detail="Missing 'input' text for TTS")
+    
     headers = {
         "Authorization": BYTEZ_AUTH,
         "Content-Type": "application/json",
     }
-    async with httpx.AsyncClient(timeout=120) as c:
-        r = await c.post(BYTEZ_TTS_URL, headers=headers, json={"text": text})
+    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 httpx.RequestError as e:
+            raise HTTPException(status_code=502, detail=f"TTS request failed: {str(e)}")
+    
     if r.status_code != 200:
-        raise HTTPException(status_code=r.status_code, detail="TTS request failed")
-    audio_data = r.content
-    return StreamingResponse(io.BytesIO(audio_data), media_type="audio/wav")
+        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 with proper content type
+    return Response(
+        content=r.content,
+        media_type="audio/mpeg",
+        headers={"Access-Control-Allow-Origin": "*"}
+    )
 
 # ---------------------------------------------------------------------
-# /v1/stt (Speech-to-Text)
+# /v1/audio/transcriptions → STT (OpenAI compatible)
 # ---------------------------------------------------------------------
-@api.post("/v1/stt")
-async def stt(file: UploadFile = File(...), authorization: str = Header(None)):
+@api.post("/v1/audio/transcriptions")
+async def stt(
+    authorization: str = Header(None),
+    file: UploadFile = File(...),
+    model: str = Form("whisper-1")
+):
     check_key(authorization)
     if not BYTEZ_AUTH:
         raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
-    headers = {"Authorization": BYTEZ_AUTH}
-    file_content = await file.read()
-    files = {"file": (file.filename, file_content, file.content_type)}
-
-    async with httpx.AsyncClient(timeout=120) as c:
-        r = await c.post(BYTEZ_STT_URL, headers=headers, files=files)
-
+    
+    # Read audio file
+    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 httpx.RequestError 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:
-        raise HTTPException(status_code=502, detail="Upstream returned invalid JSON")
-
-    transcript = data.get("transcription", "")
-    return {"transcription": transcript}
+        raise HTTPException(status_code=502, detail="Invalid STT response format")
+    
+    # Extract transcript - handle multiple 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": "*"})
 
 # ---------------------------------------------------------------------
-# Minimal Gradio UI (to make HF Space start)
+# Minimal Gradio UI
 # ---------------------------------------------------------------------
 with gr.Blocks() as ui:
     gr.Markdown("### ✅ Jwero Bytez → OpenAI Proxy\n"
-                "Endpoints: `/v1/models`, `/v1/chat/completions`, `/v1/tts`, `/v1/stt`")
+                "Endpoints:\n"
+                "- `/v1/models`\n"
+                "- `/v1/chat/completions`\n"
+                "- `/v1/audio/speech` (TTS)\n"
+                "- `/v1/audio/transcriptions` (STT)")
 
 demo = gr.mount_gradio_app(api, ui, path="/")