runloop_api_client 1.24.0__tar.gz → 1.27.0__tar.gz

runloop_api_client-1.27.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.27.0"
+}

{runloop_api_client-1.24.0 → runloop_api_client-1.27.0}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.27.0 (2026-07-28)
+
+Full Changelog: [v1.24.0...v1.27.0](https://github.com/runloopai/api-client-python/compare/v1.24.0...v1.27.0)
+
+### Features
+
+* **mux:** wait_for_eviction endpoint for flex eviction notifications ([#10325](https://github.com/runloopai/api-client-python/issues/10325)) ([7e86af9](https://github.com/runloopai/api-client-python/commit/7e86af9421218becca73ebaf0aa110c40c2a2e1a))
+
+
+### Bug Fixes
+
+* isolate long-polls and file transfers on separate HTTP/2 pools ([#825](https://github.com/runloopai/api-client-python/issues/825)) ([d316188](https://github.com/runloopai/api-client-python/commit/d3161880b655904c31664975bb6f210c4df623b7))
+* **mux:** field-level merge on network policy egress updates ([#10338](https://github.com/runloopai/api-client-python/issues/10338)) ([366a3ee](https://github.com/runloopai/api-client-python/commit/366a3eefecb5239ccd7842c7b333c77740fbe8bc))
+* **mux:** move eviction-watch SSE route off the /{id} slot ([#10409](https://github.com/runloopai/api-client-python/issues/10409)) ([61f4143](https://github.com/runloopai/api-client-python/commit/61f4143ae27b6efd1d1abda4a2ceceb725a1709d))
+
+
+### Chores
+
+* **stainless:** generate watch_evictions as an SSE stream ([#10404](https://github.com/runloopai/api-client-python/issues/10404)) ([cb82bca](https://github.com/runloopai/api-client-python/commit/cb82bca1fe679a72499256738b18e2d270a321f8))
+
 ## 1.24.0 (2026-07-22)
 
 Full Changelog: [v1.23.3...v1.24.0](https://github.com/runloopai/api-client-python/compare/v1.23.3...v1.24.0)

{runloop_api_client-1.24.0 → runloop_api_client-1.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: runloop_api_client
-Version: 1.24.0
+Version: 1.27.0
 Summary: The official Python library for the runloop API
 Project-URL: Homepage, https://github.com/runloopai/api-client-python
 Project-URL: Repository, https://github.com/runloopai/api-client-python

{runloop_api_client-1.24.0 → runloop_api_client-1.27.0}/api.md

@@ -201,6 +201,7 @@ Types:
 ```python
 from runloop_api_client.types import (
     DevboxAsyncExecutionDetailView,
+    DevboxEvictionEventView,
     DevboxExecutionDetailView,
     DevboxKillExecutionRequest,
     DevboxListView,
@@ -244,6 +245,7 @@ Methods:
 - <code title="post /v1/devboxes/{id}/suspend">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">suspend</a>(id) -> <a href="./src/runloop_api_client/types/devbox_view.py">DevboxView</a></code>
 - <code title="post /v1/devboxes/{id}/upload_file">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">upload_file</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_upload_file_params.py">params</a>) -> object</code>
 - <code title="post /v1/devboxes/{devbox_id}/executions/{execution_id}/wait_for_status">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">wait_for_command</a>(execution_id, \*, devbox_id, \*\*<a href="src/runloop_api_client/types/devbox_wait_for_command_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_async_execution_detail_view.py">DevboxAsyncExecutionDetailView</a></code>
+- <code title="get /v1/devboxes/evictions/watch">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">watch_evictions</a>() -> <a href="./src/runloop_api_client/types/devbox_eviction_event_view.py">DevboxEvictionEventView</a></code>
 - <code title="post /v1/devboxes/{id}/write_file_contents">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">write_file_contents</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_write_file_contents_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_execution_detail_view.py">DevboxExecutionDetailView</a></code>
 
 

{runloop_api_client-1.24.0 → runloop_api_client-1.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runloop_api_client"
-version = "1.24.0"
+version = "1.27.0"
 description = "The official Python library for the runloop API"
 dynamic = ["readme"]
 license = "MIT"

{runloop_api_client-1.24.0 → runloop_api_client-1.27.0}/src/runloop_api_client/_base_client.py

@@ -8,6 +8,7 @@ import email
 import asyncio
 import inspect
 import logging
+import secrets
 import weakref
 import platform
 import warnings
@@ -24,6 +25,7 @@ from typing import (
     Generic,
     Mapping,
     TypeVar,
+    Callable,
     Iterable,
     Iterator,
     Optional,
@@ -78,8 +80,11 @@ from ._constants import (
     DEFAULT_MAX_RETRIES,
     INITIAL_RETRY_DELAY,
     RAW_RESPONSE_HEADER,
+    DEFAULT_API_POOL_SHARDS,
     OVERRIDE_CAST_TO_HEADER,
     DEFAULT_CONNECTION_LIMITS,
+    DEFAULT_TRANSFER_POOL_SHARDS,
+    DEFAULT_BACKGROUND_POOL_SHARDS,
 )
 from ._streaming import Stream, SSEDecoder, AsyncStream, SSEBytesDecoder
 from ._exceptions import (
@@ -98,6 +103,10 @@ log: logging.Logger = logging.getLogger(__name__)
 # when the last user releases it.
 # The async transport is keyed by event loop because connections bind to the
 # loop that created them and cannot be reused across asyncio.run() calls.
+#
+# httpx/httpcore use a single H2 connection per transport, so each workload
+# category uses a sharded Registry of SharedTransport instances. Per-client
+# round-robin spreads requests across shards.
 _pool_lock = threading.Lock()
 
 
@@ -134,6 +143,35 @@ class _SharedTransport(httpx.BaseTransport):
         if should_close:
             self._transport.close()
 
+    class Registry:
+        """Process-global map of shard index → shared H2 transport."""
+
+        def __init__(self) -> None:
+            self._shards: dict[int, _SharedTransport] = {}
+
+        def acquire(self, shard: int) -> _SharedTransport:
+            with _pool_lock:
+                existing = self._shards.get(shard)
+                if existing is not None and existing.acquire():
+                    return existing
+                transport = _SharedTransport(
+                    httpx.HTTPTransport(limits=DEFAULT_CONNECTION_LIMITS, http2=True),
+                )
+                self._shards[shard] = transport
+                return transport
+
+        def take_all(self) -> list[_SharedTransport]:
+            """Test-only: remove and return all transports for fixture cleanup."""
+            with _pool_lock:
+                values = list(self._shards.values())
+                self._shards.clear()
+                return values
+
+        def shard_ids(self) -> set[int]:
+            """Test-only: which shard indexes currently hold a shared transport."""
+            with _pool_lock:
+                return set(self._shards)
+
 
 class _SharedAsyncTransport(httpx.AsyncBaseTransport):
     """Async refcounted wrapper: delegates to a real async transport."""
@@ -168,11 +206,150 @@ class _SharedAsyncTransport(httpx.AsyncBaseTransport):
         if should_close:
             await self._transport.aclose()
 
+    class Registry:
+        """Per-event-loop map of shard index → shared async H2 transport."""
+
+        def __init__(self) -> None:
+            self._by_loop: weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, dict[int, _SharedAsyncTransport]] = (
+                weakref.WeakKeyDictionary()
+            )
+
+        def acquire(self, loop: asyncio.AbstractEventLoop, shard: int) -> _SharedAsyncTransport:
+            with _pool_lock:
+                bucket = self._by_loop.get(loop)
+                if bucket is None:
+                    bucket = {}
+                    self._by_loop[loop] = bucket
+                existing = bucket.get(shard)
+                if existing is not None and existing.acquire():
+                    return existing
+                transport = _SharedAsyncTransport(
+                    httpx.AsyncHTTPTransport(limits=DEFAULT_CONNECTION_LIMITS, http2=True),
+                )
+                bucket[shard] = transport
+                return transport
+
+        def clear(self) -> None:
+            """Test-only: drop all per-loop shard maps (does not close transports)."""
+            with _pool_lock:
+                self._by_loop.clear()
+
+
+# Process-global sharded registries (one ≈ H2 connection per shard index).
+_shared_sync_api_transports = _SharedTransport.Registry()
+_shared_sync_background_transports = _SharedTransport.Registry()
+_shared_sync_transfer_transports = _SharedTransport.Registry()
+_shared_async_api_transports = _SharedAsyncTransport.Registry()
+_shared_async_background_transports = _SharedAsyncTransport.Registry()
+_shared_async_transfer_transports = _SharedAsyncTransport.Registry()
+
+_BACKGROUND_PATH_SUFFIXES = ("/wait_for_status",)
+_TRANSFER_PATH_SUFFIXES = ("/upload_file", "/download_file")
+
+
+def _is_background_path(path: str) -> bool:
+    return path.endswith(_BACKGROUND_PATH_SUFFIXES)
+
+
+def _is_transfer_path(path: str) -> bool:
+    return path.endswith(_TRANSFER_PATH_SUFFIXES)
+
+
+class _SyncClientPool:
+    """Per-SDK-client round-robin over sharded httpx.Client wrappers."""
+
+    def __init__(
+        self,
+        *,
+        shards: int,
+        shared: bool,
+        registry: _SharedTransport.Registry | None,
+        make_client: Callable[[httpx.BaseTransport | None], httpx.Client],
+    ) -> None:
+        if shards < 1:
+            raise ValueError("shards must be >= 1")
+        self.shards = shards
+        self._shared = shared
+        self._registry = registry
+        self._make_client = make_client
+        self._clients: dict[int, httpx.Client] = {}
+        self._lock = threading.Lock()
+        self._next = secrets.randbelow(shards)
+
+    def ensure(self, shard: int) -> httpx.Client:
+        existing = self._clients.get(shard)
+        if existing is not None:
+            return existing
+        with self._lock:
+            existing = self._clients.get(shard)
+            if existing is not None:
+                return existing
+            transport: httpx.BaseTransport | None = None
+            if self._shared and self._registry is not None:
+                transport = self._registry.acquire(shard)
+            client = self._make_client(transport)
+            self._clients[shard] = client
+            return client
+
+    def next_client(self) -> httpx.Client:
+        with self._lock:
+            shard = self._next % self.shards
+            self._next += 1
+        return self.ensure(shard)
+
+    def close(self) -> None:
+        for client in self._clients.values():
+            client.close()
+        self._clients.clear()
+
+
+class _AsyncClientPool:
+    """Per-SDK-client round-robin over sharded httpx.AsyncClient wrappers."""
+
+    def __init__(
+        self,
+        *,
+        shards: int,
+        shared: bool,
+        registry: _SharedAsyncTransport.Registry | None,
+        make_client: Callable[[httpx.AsyncBaseTransport | None], httpx.AsyncClient],
+    ) -> None:
+        if shards < 1:
+            raise ValueError("shards must be >= 1")
+        self.shards = shards
+        self._shared = shared
+        self._registry = registry
+        self._make_client = make_client
+        self._clients: dict[int, httpx.AsyncClient] = {}
+        self._next = secrets.randbelow(shards)
+
+    def ensure(self, shard: int) -> httpx.AsyncClient:
+        existing = self._clients.get(shard)
+        if existing is not None:
+            return existing
+        transport: httpx.AsyncBaseTransport | None = None
+        if self._shared and self._registry is not None:
+            try:
+                loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+            if loop is not None:
+                transport = self._registry.acquire(loop, shard)
+        client = self._make_client(transport)
+        self._clients[shard] = client
+        return client
+
+    def next_client(self) -> httpx.AsyncClient:
+        # Single-threaded event loop: counter bump needs no lock when there is no await.
+        shard = self._next % self.shards
+        self._next += 1
+        return self.ensure(shard)
+
+    async def aclose(self) -> None:
+        for client in self._clients.values():
+            await client.aclose()
+        self._clients.clear()
 
-_shared_sync_transport: _SharedTransport | None = None
-_shared_async_transports: weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, _SharedAsyncTransport] = (
-    weakref.WeakKeyDictionary()
-)
 
 # TODO: make base page type vars covariant
 SyncPageT = TypeVar("SyncPageT", bound="BaseSyncPage[Any]")
@@ -929,8 +1106,15 @@ class SyncHttpxClientWrapper(DefaultHttpxClient):
 
 class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
     _client: httpx.Client
+    _api_pool: _SyncClientPool | None
+    _background_pool: _SyncClientPool | None
+    _transfer_pool: _SyncClientPool | None
     _default_stream_cls: type[Stream[Any]] | None = None
     _uses_shared_pool: bool
+    _isolate_workload_pools: bool
+    _api_pool_shards: int
+    _background_pool_shards: int
+    _transfer_pool_shards: int
     _closed: bool
 
     def __init__(
@@ -945,6 +1129,9 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         custom_query: Mapping[str, object] | None = None,
         _strict_response_validation: bool,
         shared_http_pool: bool = True,
+        api_pool_shards: int = DEFAULT_API_POOL_SHARDS,
+        background_pool_shards: int = DEFAULT_BACKGROUND_POOL_SHARDS,
+        transfer_pool_shards: int = DEFAULT_TRANSFER_POOL_SHARDS,
     ) -> None:
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
@@ -964,6 +1151,13 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
                 f"Invalid `http_client` argument; Expected an instance of `httpx.Client` but got {type(http_client)}"
             )
 
+        if api_pool_shards < 1:
+            raise ValueError("api_pool_shards must be >= 1")
+        if background_pool_shards < 1:
+            raise ValueError("background_pool_shards must be >= 1")
+        if transfer_pool_shards < 1:
+            raise ValueError("transfer_pool_shards must be >= 1")
+
         super().__init__(
             version=version,
             # cast to a valid type because mypy doesn't understand our type narrowing
@@ -976,29 +1170,72 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         )
 
         self._closed = False
+        self._api_pool_shards = api_pool_shards
+        self._background_pool_shards = background_pool_shards
+        self._transfer_pool_shards = transfer_pool_shards
+        # Custom http_client owns the full transport stack; don't invent sibling pools.
+        self._isolate_workload_pools = http_client is None
 
         if http_client is not None:
             self._client = http_client
             self._uses_shared_pool = False
-        elif shared_http_pool:
-            global _shared_sync_transport
-            with _pool_lock:
-                if _shared_sync_transport is None or not _shared_sync_transport.acquire():
-                    _shared_sync_transport = _SharedTransport(
-                        httpx.HTTPTransport(limits=DEFAULT_CONNECTION_LIMITS, http2=True),
-                    )
-            self._client = SyncHttpxClientWrapper(
-                base_url=base_url,
-                timeout=cast(Timeout, timeout),
-                transport=_shared_sync_transport,
-            )
-            self._uses_shared_pool = True
-        else:
-            self._client = SyncHttpxClientWrapper(
-                base_url=base_url,
-                timeout=cast(Timeout, timeout),
+            self._api_pool = None
+            self._background_pool = None
+            self._transfer_pool = None
+            return
+
+        self._uses_shared_pool = shared_http_pool
+
+        def make_client(transport: httpx.BaseTransport | None) -> httpx.Client:
+            timeout_ = cast(Timeout, self.timeout)
+            if transport is not None:
+                return SyncHttpxClientWrapper(
+                    base_url=self._base_url,
+                    timeout=timeout_,
+                    transport=transport,
+                )
+            return SyncHttpxClientWrapper(
+                base_url=self._base_url,
+                timeout=timeout_,
             )
-            self._uses_shared_pool = False
+
+        api_registry = _shared_sync_api_transports if shared_http_pool else None
+        bg_registry = _shared_sync_background_transports if shared_http_pool else None
+        xfer_registry = _shared_sync_transfer_transports if shared_http_pool else None
+
+        self._api_pool = _SyncClientPool(
+            shards=api_pool_shards,
+            shared=shared_http_pool,
+            registry=api_registry,
+            make_client=make_client,
+        )
+        self._background_pool = _SyncClientPool(
+            shards=background_pool_shards,
+            shared=shared_http_pool,
+            registry=bg_registry,
+            make_client=make_client,
+        )
+        self._transfer_pool = _SyncClientPool(
+            shards=transfer_pool_shards,
+            shared=shared_http_pool,
+            registry=xfer_registry,
+            make_client=make_client,
+        )
+        # Eager primary client (shard 0) for lifecycle / cookie-jar compatibility.
+        self._client = self._api_pool.ensure(0)
+
+    def _get_client_for_path(self, path: str) -> httpx.Client:
+        if not self._isolate_workload_pools or self._api_pool is None:
+            return self._client
+        assert self._background_pool is not None and self._transfer_pool is not None
+        if _is_background_path(path):
+            return self._background_pool.next_client()
+        if _is_transfer_path(path):
+            return self._transfer_pool.next_client()
+        return self._api_pool.next_client()
+
+    def _send_client_for_request(self, request: httpx.Request) -> httpx.Client:
+        return self._get_client_for_path(request.url.path)
 
     def is_closed(self) -> bool:
         return self._closed or self._client.is_closed
@@ -1013,7 +1250,14 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         if self._closed:
             return
         self._closed = True
-        self._client.close()
+        if self._api_pool is not None:
+            # Closes _client (api shard 0) along with any other API shards.
+            self._api_pool.close()
+            assert self._background_pool is not None and self._transfer_pool is not None
+            self._background_pool.close()
+            self._transfer_pool.close()
+        else:
+            self._client.close()
 
     def __enter__(self: _T) -> _T:
         return self
@@ -1114,7 +1358,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
 
             response = None
             try:
-                response = self._client.send(
+                response = self._send_client_for_request(request).send(
                     request,
                     stream=stream or self._should_stream_response_body(request=request),
                     **kwargs,
@@ -1561,8 +1805,15 @@ class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):
 
 class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
     _client: httpx.AsyncClient
+    _api_pool: _AsyncClientPool | None
+    _background_pool: _AsyncClientPool | None
+    _transfer_pool: _AsyncClientPool | None
     _default_stream_cls: type[AsyncStream[Any]] | None = None
     _uses_shared_pool: bool
+    _isolate_workload_pools: bool
+    _api_pool_shards: int
+    _background_pool_shards: int
+    _transfer_pool_shards: int
     _closed: bool
 
     def __init__(
@@ -1577,6 +1828,9 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
         shared_http_pool: bool = True,
+        api_pool_shards: int = DEFAULT_API_POOL_SHARDS,
+        background_pool_shards: int = DEFAULT_BACKGROUND_POOL_SHARDS,
+        transfer_pool_shards: int = DEFAULT_TRANSFER_POOL_SHARDS,
     ) -> None:
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
@@ -1596,6 +1850,13 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
                 f"Invalid `http_client` argument; Expected an instance of `httpx.AsyncClient` but got {type(http_client)}"
             )
 
+        if api_pool_shards < 1:
+            raise ValueError("api_pool_shards must be >= 1")
+        if background_pool_shards < 1:
+            raise ValueError("background_pool_shards must be >= 1")
+        if transfer_pool_shards < 1:
+            raise ValueError("transfer_pool_shards must be >= 1")
+
         super().__init__(
             version=version,
             base_url=base_url,
@@ -1608,43 +1869,79 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         )
 
         self._closed = False
+        self._api_pool_shards = api_pool_shards
+        self._background_pool_shards = background_pool_shards
+        self._transfer_pool_shards = transfer_pool_shards
+        # Custom http_client owns the full transport stack; don't invent sibling pools.
+        self._isolate_workload_pools = http_client is None
 
         if http_client is not None:
             self._client = http_client
             self._uses_shared_pool = False
-        elif shared_http_pool:
+            self._api_pool = None
+            self._background_pool = None
+            self._transfer_pool = None
+            return
+
+        # Async shared transports require a running loop; without one, fall back to private.
+        can_share = shared_http_pool
+        if shared_http_pool:
             try:
-                loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+                asyncio.get_running_loop()
             except RuntimeError:
-                loop = None
-            if loop is not None:
-                with _pool_lock:
-                    existing = _shared_async_transports.get(loop)
-                    if existing is not None and existing.acquire():
-                        transport: _SharedAsyncTransport = existing
-                    else:
-                        transport = _SharedAsyncTransport(
-                            httpx.AsyncHTTPTransport(limits=DEFAULT_CONNECTION_LIMITS, http2=True),
-                        )
-                        _shared_async_transports[loop] = transport
-                self._client = AsyncHttpxClientWrapper(
-                    base_url=base_url,
-                    timeout=cast(Timeout, timeout),
+                can_share = False
+
+        self._uses_shared_pool = can_share
+
+        def make_client(transport: httpx.AsyncBaseTransport | None) -> httpx.AsyncClient:
+            timeout_ = cast(Timeout, self.timeout)
+            if transport is not None:
+                return AsyncHttpxClientWrapper(
+                    base_url=self._base_url,
+                    timeout=timeout_,
                     transport=transport,
                 )
-                self._uses_shared_pool = True
-            else:
-                self._client = AsyncHttpxClientWrapper(
-                    base_url=base_url,
-                    timeout=cast(Timeout, timeout),
-                )
-                self._uses_shared_pool = False
-        else:
-            self._client = AsyncHttpxClientWrapper(
-                base_url=base_url,
-                timeout=cast(Timeout, timeout),
+            return AsyncHttpxClientWrapper(
+                base_url=self._base_url,
+                timeout=timeout_,
             )
-            self._uses_shared_pool = False
+
+        api_registry = _shared_async_api_transports if can_share else None
+        bg_registry = _shared_async_background_transports if can_share else None
+        xfer_registry = _shared_async_transfer_transports if can_share else None
+
+        self._api_pool = _AsyncClientPool(
+            shards=api_pool_shards,
+            shared=can_share,
+            registry=api_registry,
+            make_client=make_client,
+        )
+        self._background_pool = _AsyncClientPool(
+            shards=background_pool_shards,
+            shared=can_share,
+            registry=bg_registry,
+            make_client=make_client,
+        )
+        self._transfer_pool = _AsyncClientPool(
+            shards=transfer_pool_shards,
+            shared=can_share,
+            registry=xfer_registry,
+            make_client=make_client,
+        )
+        self._client = self._api_pool.ensure(0)
+
+    def _get_client_for_path(self, path: str) -> httpx.AsyncClient:
+        if not self._isolate_workload_pools or self._api_pool is None:
+            return self._client
+        assert self._background_pool is not None and self._transfer_pool is not None
+        if _is_background_path(path):
+            return self._background_pool.next_client()
+        if _is_transfer_path(path):
+            return self._transfer_pool.next_client()
+        return self._api_pool.next_client()
+
+    def _send_client_for_request(self, request: httpx.Request) -> httpx.AsyncClient:
+        return self._get_client_for_path(request.url.path)
 
     def is_closed(self) -> bool:
         return self._closed or self._client.is_closed
@@ -1659,7 +1956,13 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         if self._closed:
             return
         self._closed = True
-        await self._client.aclose()
+        if self._api_pool is not None:
+            await self._api_pool.aclose()
+            assert self._background_pool is not None and self._transfer_pool is not None
+            await self._background_pool.aclose()
+            await self._transfer_pool.aclose()
+        else:
+            await self._client.aclose()
 
     async def __aenter__(self: _T) -> _T:
         return self
@@ -1765,7 +2068,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
 
             response = None
             try:
-                response = await self._client.send(
+                response = await self._send_client_for_request(request).send(
                     request,
                     stream=stream or self._should_stream_response_body(request=request),
                     **kwargs,