Fix shared pool bugs and add tests

- Add hasattr guard to AsyncAPIClient.close() matching sync version
- Track per-instance _closed flag so is_closed() works correctly for
  shared pool clients (underlying transport stays open for others)
- Add shared_http_pool param to copy()/with_options() to match __init__
- Add 19 tests covering sharing, refcounting, copy propagation

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

Author: jrvb-rl

src/runloop_api_client/_base_client.py

@@ -856,6 +856,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
     _client: httpx.Client
     _default_stream_cls: type[Stream[Any]] | None = None
     _uses_shared_pool: bool
+    _closed: bool
 
     def __init__(
         self,
@@ -899,6 +900,8 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
+        self._closed = False
+
         if http_client is not None:
             self._client = http_client
             self._uses_shared_pool = False
@@ -922,7 +925,7 @@ def __init__(
             self._uses_shared_pool = False
 
     def is_closed(self) -> bool:
-        return self._client.is_closed
+        return self._closed or self._client.is_closed
 
     def close(self) -> None:
         """Close the underlying HTTPX client.
@@ -931,6 +934,7 @@ def close(self) -> None:
         """
         if not hasattr(self, "_client"):
             return
+        self._closed = True
         if self._uses_shared_pool:
             self._release_shared_pool()
         else:
@@ -1511,6 +1515,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
     _client: httpx.AsyncClient
     _default_stream_cls: type[AsyncStream[Any]] | None = None
     _uses_shared_pool: bool
+    _closed: bool
 
     def __init__(
         self,
@@ -1554,6 +1559,8 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
+        self._closed = False
+
         if http_client is not None:
             self._client = http_client
             self._uses_shared_pool = False
@@ -1577,13 +1584,16 @@ def __init__(
             self._uses_shared_pool = False
 
     def is_closed(self) -> bool:
-        return self._client.is_closed
+        return self._closed or self._client.is_closed
 
     async def close(self) -> None:
         """Close the underlying HTTPX client.
 
         The client will *not* be usable after this.
         """
+        if not hasattr(self, "_client"):
+            return
+        self._closed = True
         if self._uses_shared_pool:
             self._release_shared_pool()
         else:

src/runloop_api_client/_client.py

@@ -254,6 +254,7 @@ def copy(
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.Client | None = None,
+        shared_http_pool: bool | None = None,
         max_retries: int | NotGiven = not_given,
         default_headers: Mapping[str, str] | None = None,
         set_default_headers: Mapping[str, str] | None = None,
@@ -283,16 +284,18 @@ def copy(
             params = set_default_query
 
         if http_client is not None:
-            shared_http_pool = False
+            resolved_shared = False
+        elif shared_http_pool is not None:
+            resolved_shared = shared_http_pool
         else:
-            shared_http_pool = self._uses_shared_pool
+            resolved_shared = self._uses_shared_pool
 
         return self.__class__(
             bearer_token=bearer_token or self.bearer_token,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
             http_client=http_client,
-            shared_http_pool=shared_http_pool,
+            shared_http_pool=resolved_shared,
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,
@@ -524,6 +527,7 @@ def copy(
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.AsyncClient | None = None,
+        shared_http_pool: bool | None = None,
         max_retries: int | NotGiven = not_given,
         default_headers: Mapping[str, str] | None = None,
         set_default_headers: Mapping[str, str] | None = None,
@@ -553,16 +557,18 @@ def copy(
             params = set_default_query
 
         if http_client is not None:
-            shared_http_pool = False
+            resolved_shared = False
+        elif shared_http_pool is not None:
+            resolved_shared = shared_http_pool
         else:
-            shared_http_pool = self._uses_shared_pool
+            resolved_shared = self._uses_shared_pool
 
         return self.__class__(
             bearer_token=bearer_token or self.bearer_token,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
             http_client=http_client,
-            shared_http_pool=shared_http_pool,
+            shared_http_pool=resolved_shared,
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,

tests/test_shared_pool.py

@@ -0,0 +1,259 @@
+"""Tests for shared HTTP connection pool behavior.
+
+Verifies that SDK clients share (or don't share) the underlying httpx
+transport, and that refcounting correctly manages the pool lifecycle.
+"""
+
+from __future__ import annotations
+
+import os
+
+import httpx
+import pytest
+
+import runloop_api_client._base_client as _base_mod
+from runloop_api_client import Runloop, AsyncRunloop
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+bearer_token = "My Bearer Token"
+
+
+@pytest.fixture(autouse=True)
+def _reset_shared_pool():
+    """Reset module-level shared pool state before and after each test."""
+    _clear_pool_state()
+    yield
+    _clear_pool_state()
+
+
+def _clear_pool_state():
+    with _base_mod._pool_lock:
+        if _base_mod._shared_sync_client is not None and not _base_mod._shared_sync_client.is_closed:
+            try:
+                _base_mod._shared_sync_client.close()
+            except Exception:
+                pass
+        _base_mod._shared_sync_client = None
+        _base_mod._shared_sync_refcount = 0
+
+        if _base_mod._shared_async_client is not None and not _base_mod._shared_async_client.is_closed:
+            pass  # async close is best-effort in sync context
+        _base_mod._shared_async_client = None
+        _base_mod._shared_async_refcount = 0
+
+
+def _make_client(**kwargs) -> Runloop:
+    kwargs.setdefault("base_url", base_url)
+    kwargs.setdefault("bearer_token", bearer_token)
+    return Runloop(**kwargs)
+
+
+def _make_async_client(**kwargs) -> AsyncRunloop:
+    kwargs.setdefault("base_url", base_url)
+    kwargs.setdefault("bearer_token", bearer_token)
+    return AsyncRunloop(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Sync: sharing behavior
+# ---------------------------------------------------------------------------
+
+
+class TestSyncSharedPool:
+    def test_shared_pool_uses_same_client(self):
+        c1 = _make_client(shared_http_pool=True)
+        c2 = _make_client(shared_http_pool=True)
+
+        assert c1._client is c2._client
+        assert c1._uses_shared_pool is True
+        assert c2._uses_shared_pool is True
+
+        c1.close()
+        c2.close()
+
+    def test_private_pool_uses_different_clients(self):
+        c1 = _make_client(shared_http_pool=False)
+        c2 = _make_client(shared_http_pool=False)
+
+        assert c1._client is not c2._client
+        assert c1._uses_shared_pool is False
+        assert c2._uses_shared_pool is False
+
+        c1.close()
+        c2.close()
+
+    def test_custom_http_client_bypasses_sharing(self):
+        custom = httpx.Client()
+        c1 = _make_client(http_client=custom, shared_http_pool=True)
+
+        assert c1._client is custom
+        assert c1._uses_shared_pool is False
+
+        c1.close()
+        custom.close()
+
+    def test_default_is_shared(self):
+        c1 = _make_client()
+        assert c1._uses_shared_pool is True
+        c1.close()
+
+
+class TestSyncRefcounting:
+    def test_close_one_keeps_pool_alive(self):
+        c1 = _make_client(shared_http_pool=True)
+        c2 = _make_client(shared_http_pool=True)
+        pool = c1._client
+
+        c1.close()
+        assert not pool.is_closed
+        assert _base_mod._shared_sync_refcount == 1
+
+        c2.close()
+        assert pool.is_closed
+        assert _base_mod._shared_sync_client is None
+        assert _base_mod._shared_sync_refcount == 0
+
+    def test_double_close_is_safe(self):
+        c1 = _make_client(shared_http_pool=True)
+        c1.close()
+        c1.close()  # should not raise or go negative
+        assert _base_mod._shared_sync_refcount == 0
+
+    def test_three_clients_refcount(self):
+        c1 = _make_client(shared_http_pool=True)
+        c2 = _make_client(shared_http_pool=True)
+        c3 = _make_client(shared_http_pool=True)
+        pool = c1._client
+
+        assert _base_mod._shared_sync_refcount == 3
+
+        c1.close()
+        assert _base_mod._shared_sync_refcount == 2
+        assert not pool.is_closed
+
+        c2.close()
+        assert _base_mod._shared_sync_refcount == 1
+        assert not pool.is_closed
+
+        c3.close()
+        assert _base_mod._shared_sync_refcount == 0
+        assert pool.is_closed
+
+    def test_pool_recreated_after_full_release(self):
+        c1 = _make_client(shared_http_pool=True)
+        pool1 = c1._client
+        c1.close()
+
+        c2 = _make_client(shared_http_pool=True)
+        pool2 = c2._client
+        assert pool2 is not pool1
+        assert not pool2.is_closed
+
+        c2.close()
+
+
+class TestSyncCopy:
+    def test_copy_inherits_shared_pool(self):
+        c1 = _make_client(shared_http_pool=True)
+        c2 = c1.copy()
+
+        assert c2._uses_shared_pool is True
+        assert c2._client is c1._client
+        assert _base_mod._shared_sync_refcount == 2
+
+        c1.close()
+        c2.close()
+
+    def test_copy_with_custom_client_disables_sharing(self):
+        c1 = _make_client(shared_http_pool=True)
+        custom = httpx.Client()
+        c2 = c1.copy(http_client=custom)
+
+        assert c2._uses_shared_pool is False
+        assert c2._client is custom
+
+        c1.close()
+        c2.close()
+        custom.close()
+
+    def test_copy_of_non_shared_stays_non_shared(self):
+        c1 = _make_client(shared_http_pool=False)
+        c2 = c1.copy()
+
+        assert c2._uses_shared_pool is False
+        assert c2._client is not c1._client
+
+        c1.close()
+        c2.close()
+
+
+# ---------------------------------------------------------------------------
+# Async: sharing behavior
+# ---------------------------------------------------------------------------
+
+
+class TestAsyncSharedPool:
+    def test_shared_pool_uses_same_client(self):
+        c1 = _make_async_client(shared_http_pool=True)
+        c2 = _make_async_client(shared_http_pool=True)
+
+        assert c1._client is c2._client
+        assert c1._uses_shared_pool is True
+        assert c2._uses_shared_pool is True
+
+    def test_private_pool_uses_different_clients(self):
+        c1 = _make_async_client(shared_http_pool=False)
+        c2 = _make_async_client(shared_http_pool=False)
+
+        assert c1._client is not c2._client
+        assert c1._uses_shared_pool is False
+
+    def test_custom_http_client_bypasses_sharing(self):
+        custom = httpx.AsyncClient()
+        c1 = _make_async_client(http_client=custom, shared_http_pool=True)
+
+        assert c1._client is custom
+        assert c1._uses_shared_pool is False
+
+    def test_default_is_shared(self):
+        c1 = _make_async_client()
+        assert c1._uses_shared_pool is True
+
+
+class TestAsyncRefcounting:
+    def test_close_one_keeps_pool_alive(self):
+        c1 = _make_async_client(shared_http_pool=True)
+        c2 = _make_async_client(shared_http_pool=True)
+
+        # Release c1's ref synchronously (the release_shared_pool is sync)
+        c1._release_shared_pool()
+        assert _base_mod._shared_async_refcount == 1
+        assert _base_mod._shared_async_client is not None
+
+        c2._release_shared_pool()
+        assert _base_mod._shared_async_refcount == 0
+        assert _base_mod._shared_async_client is None
+
+    def test_double_release_is_safe(self):
+        c1 = _make_async_client(shared_http_pool=True)
+        c1._release_shared_pool()
+        c1._release_shared_pool()  # should not raise or go negative
+        assert _base_mod._shared_async_refcount == 0
+
+
+class TestAsyncCopy:
+    def test_copy_inherits_shared_pool(self):
+        c1 = _make_async_client(shared_http_pool=True)
+        c2 = c1.copy()
+
+        assert c2._uses_shared_pool is True
+        assert c2._client is c1._client
+        assert _base_mod._shared_async_refcount == 2
+
+    def test_copy_with_custom_client_disables_sharing(self):
+        c1 = _make_async_client(shared_http_pool=True)
+        custom = httpx.AsyncClient()
+        c2 = c1.copy(http_client=custom)
+
+        assert c2._uses_shared_pool is False
+        assert c2._client is custom