fix(rotation): delegate to original receive to prevent event loop starvation

Starlette 0.52+ with ASGI spec <2.4 spawns a listen_for_disconnect
task inside StreamingResponse that calls receive() in a loop. The old
_make_receive returned immediately on every call after the first,
causing an infinite busy-loop that starved the event loop and prevented
streaming responses from ever sending data.

Now delegates to the original ASGI receive after the buffered body is
consumed, which properly blocks until the client disconnects.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: joachimBrindeau

src/claude_code_proxy/rotation/middleware.py

@@ -1,5 +1,7 @@
 """Rotation middleware for injecting account into requests with retry support."""
 
+from typing import Any
+
 from fastapi.responses import JSONResponse
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 from structlog import get_logger
@@ -40,9 +42,10 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
             ACCOUNT_NAME_HEADER.lower().encode(),
             headers.get(ACCOUNT_NAME_HEADER.encode()),
         )
+        make_recv = lambda b: self._make_receive(b, receive)  # noqa: E731
         if manual:
             name = manual.decode() if isinstance(manual, bytes) else manual
-            await self._handle_manual(scope, body, send, name)
+            await self._handle_manual(scope, body, send, name, make_recv)
         else:
             await handle_auto(
                 self.app,
@@ -51,7 +54,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
                 body,
                 send,
                 self.max_retries,
-                self._make_receive,
+                make_recv,
             )
 
     async def _read_body(self, receive: Receive) -> bytes:
@@ -64,20 +67,29 @@ async def _read_body(self, receive: Receive) -> bytes:
                 break
         return b"".join(parts)
 
-    def _make_receive(self, body: bytes) -> Receive:
+    def _make_receive(self, body: bytes, original_receive: Receive) -> Receive:
         sent = False
 
         async def receive() -> Message:
             nonlocal sent
             if not sent:
                 sent = True
                 return {"type": "http.request", "body": body, "more_body": False}
-            return {"type": "http.request", "body": b"", "more_body": False}
+            # Delegate to original receive for disconnect detection.
+            # Returning immediately here would busy-loop Starlette's
+            # listen_for_disconnect task and starve the event loop,
+            # blocking StreamingResponse from ever sending data.
+            return await original_receive()
 
         return receive
 
     async def _handle_manual(
-        self, scope: Scope, body: bytes, send: Send, name: str
+        self,
+        scope: Scope,
+        body: bytes,
+        send: Send,
+        name: str,
+        make_recv: Any,
     ) -> None:
         account = self.pool.get_account(name)
         if account is None:
@@ -90,7 +102,7 @@ async def _handle_manual(
                     }
                 },
             )
-            await r(scope, self._make_receive(body), send)
+            await r(scope, make_recv(body), send)
             return
         if not account.is_available:
             r = JSONResponse(
@@ -103,7 +115,7 @@ async def _handle_manual(
                     }
                 },
             )
-            await r(scope, self._make_receive(body), send)
+            await r(scope, make_recv(body), send)
             return
         scope.setdefault("state", {}).update(
             {
@@ -126,4 +138,4 @@ async def send_wrapper(message: Message) -> None:
                 )
             await send(message)
 
-        await self.app(scope, self._make_receive(body), send_wrapper)
+        await self.app(scope, make_recv(body), send_wrapper)