Fix: Use middleware to intercept API routes before Gradio processes them

app.py

@@ -524,7 +524,6 @@ with gr.Blocks(
         """Mount FastAPI routes using middleware to ensure they're processed first."""
         try:
             from fastapi.responses import JSONResponse
-            from starlette.middleware.base import BaseHTTPMiddleware
             from starlette.requests import Request
             from starlette.responses import Response
             
@@ -557,28 +556,43 @@ with gr.Blocks(
                 """Handle GET /console requests."""
                 return HTMLResponse(interactive_ui())
             
-            # Create middleware to intercept routes before Gradio
-            class FastAPIRouteMiddleware(BaseHTTPMiddleware):
-                async def dispatch(self, request: Request, call_next):
-                    path = request.url.path
-                    method = request.method
-                    
-                    # Handle our custom routes
-                    if path == "/health" and method == "GET":
-                        return await health_handler(request)
-                    elif path == "/v1/generate" and method == "POST":
-                        return await generate_handler(request)
-                    elif path == "/console" and method == "GET":
-                        return await console_handler(request)
-                    
+            # 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
-                    return await call_next(request)
+                    await self.app(scope, receive, send)
             
-            # Add middleware to Gradio's app (must be added before app is built)
-            # Use add_middleware to properly register it
+            # Wrap Gradio's app with our pure ASGI middleware
             try:
-                gradio_app.app.add_middleware(FastAPIRouteMiddleware)
-                print("FastAPI routes mounted successfully via middleware")
+                # 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")
             except Exception as middleware_error:
                 # Fallback: try to add routes directly to router
                 print(f"Middleware approach failed: {middleware_error}, trying direct route addition...")