Revert "fix(python): build own HTTP/1.1 transport for Jupyter requests"

This reverts commit d268be9. Duplicating the SDK's transport internals here
only deepened the private-API coupling that broke in the first place, so the
HTTP-version option is going upstream instead — see
.context/upstream-http1-transport-proposal.md.

The `get_transport(config, http2=False)` call sites are the end state already
and need no change once e2b restores the parameter; the Python floor in
pyproject.toml then moves to that release. Until it ships, the Python half of
this bump cannot pass CI.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: mishushakov

.changeset/shaggy-plums-wave.md

@@ -3,6 +3,4 @@
 '@e2b/code-interpreter-python': patch
 ---
 
-Bump the E2B SDK dependency: JavaScript to 2.38.3, Python to 2.38.0.
-
-The Python SDK moved its HTTP stack onto [`pyqwest`](https://pypi.org/project/pyqwest/), and its internal `get_transport()` helper no longer takes an `http2` argument — the HTTP version is negotiated by ALPN instead, which means HTTP/2 against the sandbox. Jupyter requests build their own HTTP/1.1 transport now (`e2b_code_interpreter.transport`), from the same pool tuning and connect-only retry policy the SDK uses, so client disconnects keep propagating to the server as a TCP close and long-running executions stay reliably cancellable.
+Bump E2B SDK dependency: JavaScript to 2.38.3, Python to 2.38.0

python/e2b_code_interpreter/code_interpreter_async.py

@@ -8,7 +8,7 @@
     AsyncSandbox as BaseAsyncSandbox,
     InvalidArgumentException,
 )
-from e2b_code_interpreter.transport import get_async_transport
+from e2b.api.client_async import get_transport
 
 from e2b_code_interpreter.constants import (
     DEFAULT_TEMPLATE,
@@ -70,11 +70,23 @@ def _jupyter_url(self) -> str:
 
     @property
     def _client(self) -> AsyncClient:
-        # Use a dedicated HTTP/1.1 transport for Jupyter requests so that
-        # client disconnects propagate to the server; see the module docstring
-        # of `e2b_code_interpreter.transport`.
+        # TODO: Remove later
+        # Use a dedicated HTTP/1.1 transport for Jupyter requests.
+        #
+        # The base SDK's shared transport now defaults to http2=True. With
+        # HTTP/2, multiple requests are multiplexed over a single TCP
+        # connection, so when a client cancels a request (e.g. the caller
+        # disconnects from the streaming `/execute` endpoint) the server
+        # may not detect the disconnect: only the HTTP/2 stream is
+        # cancelled, the underlying TCP connection stays open.
+        #
+        # Forcing HTTP/1.1 here keeps the 1:1 mapping between TCP
+        # connection and request, so client disconnects propagate to the
+        # server as a TCP close and long-running executions can be
+        # cancelled reliably. The helper also caches the transport
+        # per-event-loop for async.
         return AsyncClient(
-            transport=get_async_transport(self.connection_config),
+            transport=get_transport(self.connection_config, http2=False),
         )
 
     async def _handle_connection_error(self, err: Exception) -> None:

python/e2b_code_interpreter/code_interpreter_sync.py

@@ -4,7 +4,7 @@
 from typing import Optional, Dict, overload, Union, List
 from httpx import Client
 from e2b import Sandbox as BaseSandbox, InvalidArgumentException
-from e2b_code_interpreter.transport import get_sync_transport
+from e2b.api.client_sync import get_transport
 
 from e2b_code_interpreter.constants import (
     DEFAULT_TEMPLATE,
@@ -67,10 +67,21 @@ def _jupyter_url(self) -> str:
 
     @property
     def _client(self) -> Client:
-        # Use a dedicated HTTP/1.1 transport for Jupyter requests so that
-        # client disconnects propagate to the server; see the module docstring
-        # of `e2b_code_interpreter.transport`.
-        return Client(transport=get_sync_transport(self.connection_config))
+        # TODO: Remove later
+        # Use a dedicated HTTP/1.1 transport for Jupyter requests.
+        #
+        # The base SDK's shared transport now defaults to http2=True. With
+        # HTTP/2, multiple requests are multiplexed over a single TCP
+        # connection, so when a client cancels a request (e.g. the caller
+        # disconnects from the streaming `/execute` endpoint) the server
+        # may not detect the disconnect: only the HTTP/2 stream is
+        # cancelled, the underlying TCP connection stays open.
+        #
+        # Forcing HTTP/1.1 here keeps the 1:1 mapping between TCP
+        # connection and request, so client disconnects propagate to the
+        # server as a TCP close and long-running executions can be
+        # cancelled reliably.
+        return Client(transport=get_transport(self.connection_config, http2=False))
 
     def _handle_connection_error(self, err: Exception) -> None:
         """