Ensure that httpx transport is reused across calls by default (#997)

This takes some shortcuts in order to keep backwards compatibility.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Reuses a singleton httpx transport/client across the SDK, introduces a
generic retry decorator for connect calls, and refactors code/tests to
use the shared clients and fixtures.
> 
> - **SDK (transport/client reuse)**
> - Add global `limits` (configurable via `E2B_*` env vars) and switch
`ApiClient` to accept `transport` instead of `limits`.
> - Introduce `e2b.api.client_async/client_sync` with `get_transport()`
(singleton) and `get_api_client()`; update `Sandbox`/`AsyncSandbox`,
paginators, and sandbox APIs to use them.
> - Remove per-class `_limits` from `SandboxBase`/`TemplateBase`; merge
extra headers correctly; pass `E2b-Sandbox-Port` as string.
> - Template build flows (sync/async) now reuse the API client's
underlying httpx client for file uploads.
> - **Connect client** (`e2b_connect/client.py`)
> - Add `_retry` decorator and apply to unary/server-stream methods;
simplify reconnection logic; minor typing/headers cleanups.
> - **Tests**
> - Add retry unit tests; introduce
`sandbox_factory`/`async_sandbox_factory` and a session `event_loop`;
refactor tests to use factories and shared transports; adjust tar
archive expectations.
> - **Misc**
>   - Add `.editorconfig`, CLI `.envrc`, and changeset entries.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
1d35923. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Tomas Valenta <[email protected]>
Co-authored-by: Mish <[email protected]>

Author: 3 people

.changeset/popular-spoons-attack.md

@@ -0,0 +1,6 @@
+---
+"@e2b/cli": patch
+"@e2b/python-sdk": patch
+---
+
+Ensure that httpx transport is reused across calls by default

.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*.py]
+indent_size = 4

packages/cli/.envrc

@@ -0,0 +1,3 @@
+source_up
+
+dotenv ../../../.env.local

packages/python-sdk/e2b/api/__init__.py

@@ -1,11 +1,11 @@
+import os
 from types import TracebackType
 import json
 import logging
-from typing import Optional
-from httpx import Limits
+from typing import Optional, Union
+from httpx import Limits, BaseTransport, AsyncBaseTransport
 from dataclasses import dataclass
 
-
 from e2b.api.client.client import AuthenticatedClient
 from e2b.connection_config import ConnectionConfig
 from e2b.api.metadata import default_headers
@@ -18,6 +18,12 @@
 
 logger = logging.getLogger(__name__)
 
+limits = Limits(
+    max_keepalive_connections=int(os.getenv("E2B_MAX_KEEPALIVE_CONNECTIONS", "20")),
+    max_connections=int(os.getenv("E2B_MAX_CONNECTIONS", "2000")),
+    keepalive_expiry=int(os.getenv("E2B_KEEPALIVE_EXPIRY", "300")),
+)
+
 
 @dataclass
 class SandboxCreateResponse:
@@ -68,7 +74,7 @@ def __init__(
         config: ConnectionConfig,
         require_api_key: bool = True,
         require_access_token: bool = False,
-        limits: Optional[Limits] = None,
+        transport: Optional[Union[BaseTransport, AsyncBaseTransport]] = None,
         *args,
         **kwargs,
     ):
@@ -109,7 +115,9 @@ def __init__(
         }
 
         # Prevent passing these parameters twice
-        kwargs.pop("headers", None)
+        more_headers: Optional[dict] = kwargs.pop("headers", None)
+        if more_headers:
+            headers.update(more_headers)
         kwargs.pop("token", None)
         kwargs.pop("auth_header_name", None)
         kwargs.pop("prefix", None)
@@ -122,7 +130,7 @@ def __init__(
                     "response": [self._log_response],
                 },
                 "proxy": config.proxy,
-                "limits": limits,
+                "transport": transport,
             },
             headers=headers,
             token=token,

packages/python-sdk/e2b/api/client_async/__init__.py

@@ -0,0 +1,50 @@
+import httpx
+import logging
+
+from typing import Optional
+
+from typing_extensions import Self
+
+from e2b.connection_config import ConnectionConfig
+from e2b.api import limits, AsyncApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_api_client(config: ConnectionConfig, **kwargs) -> AsyncApiClient:
+    return AsyncApiClient(
+        config,
+        transport=get_transport(config),
+        **kwargs,
+    )
+
+
+class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
+    singleton: Optional[Self] = None
+
+    async def handle_async_request(self, request):
+        url = f"{request.url.scheme}://{request.url.host}{request.url.path}"
+        logger.info(f"Request: {request.method} {url}")
+        response = await super().handle_async_request(request)
+
+        # data = connect.GzipCompressor.decompress(response.read()).decode()
+        logger.info(f"Response: {response.status_code} {url}")
+
+        return response
+
+    @property
+    def pool(self):
+        return self._pool
+
+
+def get_transport(config: ConnectionConfig) -> AsyncTransportWithLogger:
+    if AsyncTransportWithLogger.singleton is not None:
+        return AsyncTransportWithLogger.singleton
+
+    transport = AsyncTransportWithLogger(
+        limits=limits,
+        proxy=config.proxy,
+    )
+    AsyncTransportWithLogger.singleton = transport
+    return transport

packages/python-sdk/e2b/api/client_sync/__init__.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+import httpx
+import logging
+
+from typing_extensions import Self
+
+from e2b.api import ApiClient, limits
+from e2b.connection_config import ConnectionConfig
+
+logger = logging.getLogger(__name__)
+
+
+def get_api_client(config: ConnectionConfig, **kwargs) -> ApiClient:
+    return ApiClient(
+        config,
+        transport=get_transport(config),
+        **kwargs,
+    )
+
+
+class TransportWithLogger(httpx.HTTPTransport):
+    singleton: Optional[Self] = None
+
+    def handle_request(self, request):
+        url = f"{request.url.scheme}://{request.url.host}{request.url.path}"
+        logger.info(f"Request: {request.method} {url}")
+        response = super().handle_request(request)
+
+        # data = connect.GzipCompressor.decompress(response.read()).decode()
+        logger.info(f"Response: {response.status_code} {url}")
+
+        return response
+
+    @property
+    def pool(self):
+        return self._pool
+
+
+_transport: Optional[TransportWithLogger] = None
+
+
+def get_transport(config: ConnectionConfig) -> TransportWithLogger:
+    if TransportWithLogger.singleton is not None:
+        return TransportWithLogger.singleton
+
+    transport = TransportWithLogger(
+        limits=limits,
+        proxy=config.proxy,
+    )
+    TransportWithLogger.singleton = transport
+    return transport

packages/python-sdk/e2b/connection_config.py

@@ -1,6 +1,7 @@
 import os
 
 from typing import Optional, Dict, TypedDict
+
 from httpx._types import ProxyTypes
 from typing_extensions import Unpack
 

packages/python-sdk/e2b/sandbox/main.py

@@ -7,7 +7,6 @@
 from e2b.connection_config import ConnectionConfig, default_username
 from e2b.envd.api import ENVD_API_FILES_ROUTE
 from e2b.envd.versions import ENVD_DEFAULT_USER
-from httpx import Limits
 
 
 class SandboxOpts(TypedDict):
@@ -20,12 +19,6 @@ class SandboxOpts(TypedDict):
 
 
 class SandboxBase:
-    _limits = Limits(
-        max_keepalive_connections=40,
-        max_connections=40,
-        keepalive_expiry=300,
-    )
-
     mcp_port = 50005
 
     default_sandbox_timeout = 300

packages/python-sdk/e2b/sandbox_async/main.py

@@ -21,26 +21,11 @@
 from e2b.sandbox_async.commands.command import Commands
 from e2b.sandbox_async.commands.pty import Pty
 from e2b.sandbox_async.sandbox_api import SandboxApi, SandboxInfo
+from e2b.api.client_async import get_transport
 
 logger = logging.getLogger(__name__)
 
 
-class AsyncTransportWithLogger(httpx.AsyncHTTPTransport):
-    async def handle_async_request(self, request):
-        url = f"{request.url.scheme}://{request.url.host}{request.url.path}"
-        logger.info(f"Request: {request.method} {url}")
-        response = await super().handle_async_request(request)
-
-        # data = connect.GzipCompressor.decompress(response.read()).decode()
-        logger.info(f"Response: {response.status_code} {url}")
-
-        return response
-
-    @property
-    def pool(self):
-        return self._pool
-
-
 class AsyncSandbox(SandboxApi):
     """
     E2B cloud sandbox is a secure and isolated cloud environment.
@@ -85,15 +70,16 @@ def pty(self) -> Pty:
         """
         return self._pty
 
-    def __init__(self, **opts: Unpack[SandboxOpts]):
+    def __init__(
+        self,
+        **opts: Unpack[SandboxOpts],
+    ):
         """
         Use `AsyncSandbox.create()` to create a new sandbox instead.
         """
         super().__init__(**opts)
 
-        self._transport = AsyncTransportWithLogger(
-            limits=self._limits, proxy=self.connection_config.proxy
-        )
+        self._transport = get_transport(self.connection_config)
         self._envd_api = httpx.AsyncClient(
             base_url=self.connection_config.get_sandbox_url(
                 self.sandbox_id, self.sandbox_domain

packages/python-sdk/e2b/sandbox_async/paginator.py

@@ -4,10 +4,10 @@
 from e2b.api.client.api.sandboxes import get_v2_sandboxes
 from e2b.api.client.types import UNSET
 from e2b.exceptions import SandboxException
-from e2b.sandbox.main import SandboxBase
 from e2b.sandbox.sandbox_api import SandboxPaginatorBase, SandboxInfo
-from e2b.api import AsyncApiClient, handle_api_exception
+from e2b.api import handle_api_exception
 from e2b.api.client.models.error import Error
+from e2b.api.client_async import get_api_client
 
 
 class AsyncSandboxPaginator(SandboxPaginatorBase):
@@ -44,29 +44,26 @@ async def next_items(self) -> List[SandboxInfo]:
             }
             metadata = urllib.parse.urlencode(quoted_metadata)
 
-        async with AsyncApiClient(
-            self._config,
-            limits=SandboxBase._limits,
-        ) as api_client:
-            res = await get_v2_sandboxes.asyncio_detailed(
-                client=api_client,
-                metadata=metadata if metadata else UNSET,
-                state=self.query.state if self.query and self.query.state else UNSET,
-                limit=self.limit if self.limit else UNSET,
-                next_token=self._next_token if self._next_token else UNSET,
-            )
+        api_client = get_api_client(self._config)
+        res = await get_v2_sandboxes.asyncio_detailed(
+            client=api_client,
+            metadata=metadata if metadata else UNSET,
+            state=self.query.state if self.query and self.query.state else UNSET,
+            limit=self.limit if self.limit else UNSET,
+            next_token=self._next_token if self._next_token else UNSET,
+        )
 
-            if res.status_code >= 300:
-                raise handle_api_exception(res)
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
 
-            self._next_token = res.headers.get("x-next-token")
-            self._has_next = bool(self._next_token)
+        self._next_token = res.headers.get("x-next-token")
+        self._has_next = bool(self._next_token)
 
-            if res.parsed is None:
-                return []
+        if res.parsed is None:
+            return []
 
-            # Check if res.parse is Error
-            if isinstance(res.parsed, Error):
-                raise SandboxException(f"{res.parsed.message}: Request failed")
+        # Check if res.parse is Error
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
 
-            return [SandboxInfo._from_listed_sandbox(sandbox) for sandbox in res.parsed]
+        return [SandboxInfo._from_listed_sandbox(sandbox) for sandbox in res.parsed]