Update app.py

app.py

@@ -7,10 +7,10 @@ from fastapi import FastAPI, Request, Header, HTTPException, File, UploadFile, F
 from fastapi.responses import JSONResponse, StreamingResponse, Response
 import time
 import base64
-from io import BytesIO
+import io
 
 # ---------------------------------------------------------------------
-# Configuration - FIXED TRAILING SPACES
+# Configuration - FIXED TRAILING SPACES AND URLS
 # ---------------------------------------------------------------------
 BYTEZ_CHAT_URL   = "https://api.bytez.com/models/v2/openai/v1/chat/completions"
 BYTEZ_MODELS_URL = "https://api.bytez.com/models/v2/list/models"
@@ -63,7 +63,7 @@ async def models(authorization: str = Header(None)):
     )
 
 # ---------------------------------------------------------------------
-# /v1/chat/completions - FIXED STREAMING
+# /v1/chat/completions - CORRECT STREAMING
 # ---------------------------------------------------------------------
 @api.post("/v1/chat/completions")
 async def chat(request: Request, authorization: str = Header(None)):
@@ -85,13 +85,13 @@ async def chat(request: Request, authorization: str = Header(None)):
                     line = line.strip()
                     if not line:
                         continue
-                    if line.startswith("data: "):
+                    if line.startswith(""):
                         json_str = line[6:].strip()
                     else:
                         json_str = line
                     
                     if json_str == "[DONE]":
-                        yield "data: [DONE]\n\n"
+                        yield " [DONE]\n\n"
                         break
                     
                     try:
@@ -131,8 +131,8 @@ async def chat(request: Request, authorization: str = Header(None)):
                             "finish_reason": None,
                         }],
                     }
-                    yield f"data: {json.dumps(openai_chunk)}\n\n"
-        yield "data: [DONE]\n\n"
+                    yield f" {json.dumps(openai_chunk)}\n\n"
+        yield " [DONE]\n\n"
 
     if stream:
         return StreamingResponse(
@@ -149,7 +149,7 @@ async def chat(request: Request, authorization: str = Header(None)):
     except json.JSONDecodeError:
         raise HTTPException(status_code=502, detail="Upstream returned invalid JSON")
     
-    if "choices" not in data:
+    if "choices" not in 
         content = (
             data.get("output")
             or data.get("response")
@@ -166,22 +166,36 @@ async def chat(request: Request, authorization: str = Header(None)):
     return JSONResponse(data, headers={"Access-Control-Allow-Origin": "*"})
 
 # ---------------------------------------------------------------------
-# /v1/audio/speech → TTS (OpenAI compatible)
+# TTS ENDPOINTS (BOTH STANDARD AND NON-STANDARD)
 # ---------------------------------------------------------------------
 @api.post("/v1/audio/speech")
-async def tts(request: Request, authorization: str = Header(None)):
+@api.post("/v1/tts/audio/speech")
+@api.post("/v1/tts")
+@api.post("/v1/tts/audio/transcriptions")  # For backward compatibility
+async def tts_endpoint(
+    request: Request,
+    authorization: str = Header(None),
+    text: str = Form(None),  # For form-data requests
+    file: UploadFile = File(None)  # For file uploads (though TTS doesn't need files)
+):
     check_key(authorization)
     if not BYTEZ_AUTH:
         raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
     
-    try:
-        payload = await request.json()
-    except Exception:
-        raise HTTPException(status_code=400, detail="Invalid JSON payload")
+    # Handle JSON payload
+    if request.headers.get("Content-Type", "").startswith("application/json"):
+        try:
+            payload = await request.json()
+            text = payload.get("input") or payload.get("text", "")
+        except:
+            text = ""
+    # Handle form data
+    elif text is None and file is not None:
+        # This shouldn't happen for TTS but handle gracefully
+        text = ""
     
-    text = payload.get("input", "")
     if not text:
-        raise HTTPException(status_code=400, detail="Missing 'input' text for TTS")
+        raise HTTPException(status_code=400, detail="Missing text for TTS conversion")
     
     headers = {
         "Authorization": BYTEZ_AUTH,
@@ -192,34 +206,47 @@ async def tts(request: Request, authorization: str = Header(None)):
     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:
+        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 with proper content type
+    # Return raw audio
     return Response(
         content=r.content,
-        media_type="audio/mpeg",
+        media_type="audio/mpeg",  # Bytez returns MP3
         headers={"Access-Control-Allow-Origin": "*"}
     )
 
 # ---------------------------------------------------------------------
-# /v1/audio/transcriptions → STT (OpenAI compatible)
+# STT ENDPOINTS (BOTH STANDARD AND NON-STANDARD)
 # ---------------------------------------------------------------------
 @api.post("/v1/audio/transcriptions")
-async def stt(
+@api.post("/v1/stt")
+@api.post("/v1/stt/audio/transcriptions")
+@api.post("/v1/audio/voices")  # Fake endpoint for compatibility
+@api.get("/v1/audio/voices")   # Fake GET endpoint
+@api.get("/v1/stt/audio/models")  # Fake endpoint
+async def stt_endpoint(
+    request: Request = None,
     authorization: str = Header(None),
-    file: UploadFile = File(...),
+    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({"voices": [], "models": []})
+    
     check_key(authorization)
     if not BYTEZ_AUTH:
         raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
     
-    # Read audio file
+    # Handle file upload
+    if file is None:
+        raise HTTPException(status_code=400, detail="No audio file provided")
+    
     try:
         audio_data = await file.read()
     except Exception as e:
@@ -242,7 +269,7 @@ async def stt(
     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:
+        except Exception as e:
             raise HTTPException(status_code=502, detail=f"STT request failed: {str(e)}")
     
     if r.status_code != 200:
@@ -252,9 +279,13 @@ async def stt(
     try:
         data = r.json()
     except json.JSONDecodeError:
-        raise HTTPException(status_code=502, detail="Invalid STT response format")
+        # If response isn't JSON, try to extract text from raw response
+        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 - handle multiple possible formats
+    # Extract transcript from various possible formats
     transcript = (
         data.get("text") or 
         data.get("transcript") or 
@@ -269,11 +300,12 @@ async def stt(
 # ---------------------------------------------------------------------
 with gr.Blocks() as ui:
     gr.Markdown("### ✅ Jwero Bytez → OpenAI Proxy\n"
-                "Endpoints:\n"
+                "**Supported Endpoints:**\n"
                 "- `/v1/models`\n"
                 "- `/v1/chat/completions`\n"
                 "- `/v1/audio/speech` (TTS)\n"
-                "- `/v1/audio/transcriptions` (STT)")
+                "- `/v1/audio/transcriptions` (STT)\n\n"
+                "**Also compatible with non-standard endpoints used by some clients**")
 
 demo = gr.mount_gradio_app(api, ui, path="/")