Fix: Use pure ASGI middleware to avoid Content-Length issues

app.py

@@ -517,106 +517,14 @@ with gr.Blocks(
         fn=lambda: ("", ""),
         outputs=[prompt_input, output],
     )
-    
-    # Mount FastAPI routes using middleware to intercept before Gradio processes them
-    # This must be done inside the Blocks context
-    def mount_fastapi_routes():
-        """Mount FastAPI routes using middleware to ensure they're processed first."""
-        try:
-            from fastapi.responses import JSONResponse
-            from starlette.requests import Request
-            from starlette.responses import Response
-            
-            # Define route handlers
-            async def health_handler(request: Request) -> Response:
-                """Handle GET /health requests."""
-                return JSONResponse(content={
-                    "status": "ok",
-                    "model": MODEL_ID,
-                    "strategy": ACTIVE_STRATEGY or "pending",
-                })
-            
-            async def generate_handler(request: Request) -> Response:
-                """Handle POST /v1/generate requests."""
-                try:
-                    data = await request.json()
-                    payload = GeneratePayload(**data)
-                    text = _generate_with_gpu(
-                        prompt=payload.prompt,
-                        max_new_tokens=payload.max_new_tokens or MAX_NEW_TOKENS,
-                        temperature=payload.temperature or DEFAULT_TEMPERATURE,
-                        top_p=payload.top_p or DEFAULT_TOP_P,
-                    )
-                    return JSONResponse(content={"text": text})
-                except Exception as exc:
-                    from fastapi import HTTPException
-                    raise HTTPException(status_code=500, detail=str(exc))
-            
-            async def console_handler(request: Request) -> Response:
-                """Handle GET /console requests."""
-                return HTMLResponse(interactive_ui())
-            
-            # Create pure ASGI middleware to intercept routes before Gradio
-            # This avoids Content-Length issues with BaseHTTPMiddleware
-            class FastAPIRouteMiddleware:
-                def __init__(self, app):
-                    self.app = app
-
-                async def __call__(self, scope, receive, send):
-                    if scope["type"] == "http":
-                        path = scope["path"]
-                        method = scope["method"]
-
-                        # Handle our custom routes
-                        if path == "/health" and method == "GET":
-                            request = Request(scope, receive)
-                            response = await health_handler(request)
-                            await response(scope, receive, send)
-                            return
-                        elif path == "/v1/generate" and method == "POST":
-                            request = Request(scope, receive)
-                            response = await generate_handler(request)
-                            await response(scope, receive, send)
-                            return
-                        elif path == "/console" and method == "GET":
-                            request = Request(scope, receive)
-                            response = await console_handler(request)
-                            await response(scope, receive, send)
-                            return
-
-                    # Let other requests pass through to Gradio
-                    await self.app(scope, receive, send)
-            
-            # Wrap Gradio's app with our pure ASGI middleware
-            try:
-                # Store original app and wrap it with our middleware
-                original_app = gradio_app.app
-                gradio_app.app = FastAPIRouteMiddleware(original_app)
-                print("FastAPI routes mounted successfully via pure ASGI middleware")
-                # Pure ASGI middleware avoids Content-Length issues with BaseHTTPMiddleware
-            except Exception as middleware_error:
-                # Fallback: try to add routes directly to router
-                print(f"Middleware approach failed: {middleware_error}, trying direct route addition...")
-                from starlette.routing import Route
-                gradio_app.app.router.routes.insert(0, Route("/health", health_handler, methods=["GET"]))
-                gradio_app.app.router.routes.insert(0, Route("/v1/generate", generate_handler, methods=["POST"]))
-                gradio_app.app.router.routes.insert(0, Route("/console", console_handler, methods=["GET"]))
-                print("FastAPI routes added directly to router")
-        except Exception as e:
-            print(f"Warning: Could not mount FastAPI routes: {e}")
-            import traceback
-            traceback.print_exc()
-    
-    # Mount routes when Gradio app loads (must be inside Blocks context)
-    gradio_app.load(mount_fastapi_routes)
 
 # Enable queued execution so ZeroGPU can schedule GPU work reliably
 gradio_app.queue(max_size=8)
 
-# Set app to Gradio for Spaces compatibility (sdk: gradio requires Gradio app)
-# Spaces will handle running the server automatically
-app = gradio_app
+# Mount the Gradio UI on the FastAPI app so both live side-by-side
+app = gr.mount_gradio_app(fastapi_app, gradio_app, path="/gradio")
 
 if __name__ == "__main__":  # pragma: no cover
-    # For local testing only - Spaces handles server startup
-    app.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))