Update app.py

app.py

@@ -149,112 +149,158 @@ async def v1_chat(request: Request, authorization: str = Header(None)):
 # ---------------------------------------------------------------------
 # --------------------- /v1/images/generations (FIXED) ---------------
 # ---------------------------------------------------------------------
+# ---------------------------------------------------------------------
+# --------------------- /v1/images/generations  -----------------------
+# ---------------------------------------------------------------------
 @api.post("/v1/images/generations")
 async def v1_images_generations(request: Request, authorization: str = Header(None)):
     """
-    Fully OpenAI-compatible DALL·E-3 via Bytez
-    → Accepts `model` field (required by Continue.dev, Cursor, etc.)
-    → Ignores it safely (since Bytez uses URL path, not model name)
-    → Returns proper OpenAI format with url + b64_json
+    OpenAI-compatible image generation endpoint that forwards to:
+      https://api.bytez.com/models/v2/openai/dall-e-3
+
+    It accepts the usual OpenAI body:
+      {
+        "model": "dall-e-3",           # REQUIRED by clients, but ignored
+        "prompt": "text",              # REQUIRED
+        "n": 1,
+        "size": "1024x1024",
+        "response_format": "url" | "b64_json",
+        "quality": "standard" | "hd",
+        "style": "vivid" | "natural"
+      }
+    and converts it to the Bytez format from your curl:
+      { "text": "<prompt>" }
     """
     check_key(authorization)
 
-    if not BYTEZ_AUTH_2:
-        raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY_2 not configured")
+    # Use SAME key as chat unless you *really* have a separate one
+    if not BYTEZ_AUTH:
+        raise HTTPException(status_code=500, detail="Server BYTEZ_API_KEY not configured")
 
+    # ---------------- parse request ----------------
     try:
         payload = await request.json()
     except json.JSONDecodeError:
         raise HTTPException(status_code=400, detail="Invalid JSON")
 
-    prompt = payload.get("prompt")
-    if not prompt or not prompt.strip():
-        raise HTTPException(status_code=400, detail="Field 'prompt' is required and cannot be empty")
+    prompt = payload.get("prompt") or payload.get("text")
+    if not prompt or not str(prompt).strip():
+        raise HTTPException(status_code=400, detail="Field 'prompt' is required")
 
-    # These fields are REQUIRED by UI tools even if we ignore some
-    model_name = payload.get("model", "dall-e-3")  # just for show — we ignore it
-    n = payload.get("n", 1)
+    # These are there only to satisfy OpenAI-compatible clients
+    _model = payload.get("model", "dall-e-3")  # ignored
+    n = int(payload.get("n", 1))
+    response_format = payload.get("response_format", "url")  # "url" | "b64_json"
     size = payload.get("size", "1024x1024")
-    quality = payload.get("quality", "standard")
-    style = payload.get("style")  # vivid or natural
-    response_format = payload.get("response_format", "url")  # url or b64_json
-
-    # Map OpenAI sizes → Bytez accepts the same strings
-    if size not in ["1024x1024", "1024x1792", "1792x1024"]:
-        size = "1024x1024"  # fallback
+    quality = payload.get("quality")
+    style = payload.get("style")
 
+    # ---------------- build Bytez request ----------------
+    # Minimal payload that we KNOW works from your curl:
     bytez_payload = {
         "text": prompt,
-        "num_outputs": n,
-        "size": size,
     }
-    if quality in ["standard", "hd"]:
-        bytez_payload["quality"] = quality
-    if style in ["vivid", "natural"]:
-        bytez_payload["style"] = style
+
+    # Only add extras if Bytez actually supports them.
+    # Comment these out if you’re unsure; or keep them if Bytez docs say so.
+    # bytez_payload["num_outputs"] = n
+    # bytez_payload["size"] = size
+    # if quality in ["standard", "hd"]:
+    #     bytez_payload["quality"] = quality
+    # if style in ["vivid", "natural"]:
+    #     bytez_payload["style"] = style
 
     headers = {
-        "Authorization": BYTEZ_AUTH_2,
+        "Authorization": BYTEZ_AUTH,         # << important
         "Content-Type": "application/json",
     }
 
+    # ---------------- call Bytez ----------------
     async with httpx.AsyncClient(timeout=200) as client:
         try:
             resp = await client.post(
-                "https://api.bytez.com/models/v2/openai/dall-e-3",
+                BYTEZ_IMAGE_URL,
                 json=bytez_payload,
                 headers=headers,
             )
             resp.raise_for_status()
         except httpx.HTTPStatusError as e:
+            # Surface Bytez error message directly to client
+            detail = None
             try:
-                error_detail = e.response.json()
-            except:
-                error_detail = e.response.text
-            raise HTTPException(status_code=e.response.status_code, detail=error_detail)
+                detail = e.response.json()
+            except Exception:
+                detail = e.response.text
+            raise HTTPException(
+                status_code=e.response.status_code,
+                detail={"upstream_error": detail},
+            )
         except Exception as e:
             raise HTTPException(status_code=502, detail=f"Bytez unreachable: {str(e)}")
 
-        try:
-            bytez_data = resp.json()
-        except json.JSONDecodeError:
-            raise HTTPException(status_code=502, detail="Bytez returned invalid JSON")
+    try:
+        bytez_data = resp.json()
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=502, detail="Bytez returned invalid JSON")
 
-    # Handle different possible response shapes from Bytez
-    images = bytez_data.get("images") or bytez_data.get("data") or []
-    if isinstance(images, str):
-        images = [images]
-    if not images:
-        raise HTTPException(status_code=500, detail="No images returned from Bytez")
-
-    # Build proper OpenAI response
-    openai_images = []
-    for img_data in images:
-        if img_data.startswith("data:image"):
-            b64 = img_data.split("base64,")[-1]
-            url = img_data
-        else:
-            b64 = img_data
-            url = f"data:image/png;base64,{img_data}"
+    # ---------------- map Bytez → OpenAI image response ----------------
+    # We don't know the exact shape, so we handle several possibilities.
 
-        item = {}
-        if response_format == "b64_json" or response_format is None:
-            item["b64_json"] = b64
-        else:
-            item["url"] = url
+    images = []
+
+    # Case 1: { "images": ["url_or_b64", ...] }
+    if isinstance(bytez_data, dict) and "images" in bytez_data and isinstance(bytez_data["images"], list):
+        images = bytez_data["images"]
+
+    # Case 2: { "data": [ { "url": "..." } , ... ] }
+    elif isinstance(bytez_data, dict) and "data" in bytez_data and isinstance(bytez_data["data"], list):
+        for item in bytez_data["data"]:
+            if "url" in item:
+                images.append(item["url"])
+            elif "b64_json" in item:
+                images.append(item["b64_json"])
+            else:
+                images.append(str(item))
+
+    # Case 3: single string
+    elif isinstance(bytez_data, str):
+        images = [bytez_data]
 
-        # Optional: include revised_prompt if Bytez returns it
-        if "revised_prompt" in bytez_data:
-            item["revised_prompt"] = bytez_data["revised_prompt"]
+    # Fallback: treat whole thing as one string
+    else:
+        images = [str(bytez_data)]
 
-        openai_images.append(item)
+    if not images:
+        raise HTTPException(status_code=500, detail={"error": "No images returned from Bytez", "raw": bytez_data})
+
+    # truncate to n images
+    images = images[:n]
+
+    openai_data = []
+    for img in images:
+        # If it looks like a data URL already
+        if isinstance(img, str) and img.startswith("data:image"):
+            # Already a data URL; extract base64 if needed
+            b64_part = img.split("base64,", 1)[-1]
+            if response_format == "b64_json":
+                openai_data.append({"b64_json": b64_part})
+            else:
+                openai_data.append({"url": img})
 
-    final_response = {
+        else:
+            # Raw URL or base64 – we can't be sure, so:
+            if response_format == "b64_json":
+                # Assume it's base64 or treat as a string anyway
+                openai_data.append({"b64_json": str(img)})
+            else:
+                # Assume it's a URL or make it one if needed
+                openai_data.append({"url": str(img)})
+
+    result = {
         "created": int(time.time()),
-        "data": openai_images
+        "data": openai_data,
     }
-
-    return JSONResponse(final_response, headers={"Access-Control-Allow-Origin": "*"})
+    return JSONResponse(result, headers={"Access-Control-Allow-Origin": "*"})
 
 
 
@@ -422,8 +468,9 @@ with gr.Blocks() as ui:
 
 demo = gr.mount_gradio_app(api, ui, path="/")
 
-# ---------------------------------------------------------------------
-# Local dev entrypoint
-# ---------------------------------------------------------------------
+# This makes it work on Render, Railway, Fly.io, etc.
+app = api
+
 if __name__ == "__main__":
-    uvicorn.run(demo, host="0.0.0.0", port=7860)
+    # Only for local testing with Gradio
+    uvicorn.run(demo, host="0.0.0.0", port=8000)