opensandbox-code-interpreter 1.1.0__tar.gz → 1.2.0__tar.gz

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opensandbox-code-interpreter
-Version: 1.1.0
+Version: 1.2.0
 Summary: OpenSandbox Code Interpreter Python SDK - Advanced code execution with persistent contexts
 Project-URL: Homepage, https://open-sandbox.ai
 Project-URL: Repository, https://github.com/opensandbox-group/OpenSandbox
@@ -223,24 +223,20 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: opensandbox<2.0.0,>=1.1.0
+Requires-Dist: opensandbox<2.0.0,>=1.2.0
 Requires-Dist: pydantic<3.0,>=2.4.2
 Description-Content-Type: text/markdown
 
 # OpenSandbox Code Interpreter SDK for Python
 
 
-A Python SDK for executing code in secure, isolated sandboxes. It provides a high-level API for running Python, Java,
-Go, TypeScript, and other languages safely, with support for code execution contexts.
+A Python SDK for executing code in secure, isolated sandboxes. It provides a high-level API for running Python, Java, Go, TypeScript, and other languages safely, with support for code execution contexts.
 
 ## Prerequisites
 
-This SDK requires a Docker image containing the Code Interpreter runtime environment. You must use the
-`opensandbox/code-interpreter` image (or a derivative) which includes pre-installed runtimes for Python, Java, Go,
-Node.js, etc.
+This SDK requires a Docker image containing the Code Interpreter runtime environment. You must use the `opensandbox/code-interpreter` image (or a derivative) which includes pre-installed runtimes for Python, Java, Go, Node.js, etc.
 
-For detailed information about supported languages and versions, refer to the
-[Environment Documentation](https://github.com/opensandbox-group/sandbox-images).
+For detailed information about supported languages and versions, refer to the [Environment Documentation](https://github.com/opensandbox-group/sandbox-images).
 
 ## Installation
 
@@ -258,8 +254,7 @@ uv add opensandbox-code-interpreter
 
 ## Quick Start
 
-The following example demonstrates how to create a sandbox with a specific runtime configuration and execute a simple
-script.
+The following example demonstrates how to create a sandbox with a specific runtime configuration and execute a simple script.
 
 ```python
 import asyncio
@@ -366,13 +361,11 @@ execution = await sandbox.commands.run("pip install pandas numpy")
 
 ### Docker Image
 
-The Code Interpreter SDK relies on a specialized environment. Ensure your sandbox provider has the
-`opensandbox/code-interpreter` image available.
+The Code Interpreter SDK relies on a specialized environment. Ensure your sandbox provider has the `opensandbox/code-interpreter` image available.
 
 ### Language Version Selection
 
-You can specify the desired version of a programming language by setting the corresponding environment variable when
-creating the `Sandbox`.
+You can specify the desired version of a programming language by setting the corresponding environment variable when creating the `Sandbox`.
 
 | Language | Environment Variable | Example Value | Default (if unset) |
 | -------- | -------------------- | ------------- | ------------------ |
@@ -385,9 +378,7 @@ creating the `Sandbox`.
 
 ### 0. Run with `language` (default language context)
 
-You can pass `language` directly (recommended: `SupportedLanguage.*`) and skip `create_context`.
-When `context.id` is omitted, **execd will create/reuse a default session for that language**, so
-state can persist across runs:
+You can pass `language` directly (recommended: `SupportedLanguage.*`) and skip `create_context`. When `context.id` is omitted, **execd will create/reuse a default session for that language**, so state can persist across runs:
 
 ```python
 from code_interpreter import SupportedLanguage

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/README.md

@@ -1,17 +1,13 @@
 # OpenSandbox Code Interpreter SDK for Python
 
 
-A Python SDK for executing code in secure, isolated sandboxes. It provides a high-level API for running Python, Java,
-Go, TypeScript, and other languages safely, with support for code execution contexts.
+A Python SDK for executing code in secure, isolated sandboxes. It provides a high-level API for running Python, Java, Go, TypeScript, and other languages safely, with support for code execution contexts.
 
 ## Prerequisites
 
-This SDK requires a Docker image containing the Code Interpreter runtime environment. You must use the
-`opensandbox/code-interpreter` image (or a derivative) which includes pre-installed runtimes for Python, Java, Go,
-Node.js, etc.
+This SDK requires a Docker image containing the Code Interpreter runtime environment. You must use the `opensandbox/code-interpreter` image (or a derivative) which includes pre-installed runtimes for Python, Java, Go, Node.js, etc.
 
-For detailed information about supported languages and versions, refer to the
-[Environment Documentation](https://github.com/opensandbox-group/sandbox-images).
+For detailed information about supported languages and versions, refer to the [Environment Documentation](https://github.com/opensandbox-group/sandbox-images).
 
 ## Installation
 
@@ -29,8 +25,7 @@ uv add opensandbox-code-interpreter
 
 ## Quick Start
 
-The following example demonstrates how to create a sandbox with a specific runtime configuration and execute a simple
-script.
+The following example demonstrates how to create a sandbox with a specific runtime configuration and execute a simple script.
 
 ```python
 import asyncio
@@ -137,13 +132,11 @@ execution = await sandbox.commands.run("pip install pandas numpy")
 
 ### Docker Image
 
-The Code Interpreter SDK relies on a specialized environment. Ensure your sandbox provider has the
-`opensandbox/code-interpreter` image available.
+The Code Interpreter SDK relies on a specialized environment. Ensure your sandbox provider has the `opensandbox/code-interpreter` image available.
 
 ### Language Version Selection
 
-You can specify the desired version of a programming language by setting the corresponding environment variable when
-creating the `Sandbox`.
+You can specify the desired version of a programming language by setting the corresponding environment variable when creating the `Sandbox`.
 
 | Language | Environment Variable | Example Value | Default (if unset) |
 | -------- | -------------------- | ------------- | ------------------ |
@@ -156,9 +149,7 @@ creating the `Sandbox`.
 
 ### 0. Run with `language` (default language context)
 
-You can pass `language` directly (recommended: `SupportedLanguage.*`) and skip `create_context`.
-When `context.id` is omitted, **execd will create/reuse a default session for that language**, so
-state can persist across runs:
+You can pass `language` directly (recommended: `SupportedLanguage.*`) and skip `create_context`. When `context.id` is omitted, **execd will create/reuse a default session for that language**, so state can persist across runs:
 
 ```python
 from code_interpreter import SupportedLanguage

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/pyproject.toml

@@ -43,7 +43,7 @@ classifiers = [
 ]
 dependencies = [
     "pydantic>=2.4.2,<3.0",
-    "opensandbox>=1.1.0,<2.0.0",
+    "opensandbox>=1.2.0,<2.0.0",
 ]
 
 [project.urls]

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/adapters/code_adapter.py

@@ -33,15 +33,15 @@ from opensandbox.adapters.converter.execution_event_dispatcher import (
     ExecutionEventDispatcher,
 )
 from opensandbox.adapters.converter.response_handler import (
-    extract_request_id,
+    build_api_exception_from_httpx,
     handle_api_error,
     require_parsed,
 )
 from opensandbox.config import ConnectionConfig
-from opensandbox.exceptions import InvalidArgumentException, SandboxApiException
+from opensandbox.exceptions import InvalidArgumentException
 from opensandbox.models.execd import Execution, ExecutionHandlers
 from opensandbox.models.sandboxes import SandboxEndpoint
-from opensandbox.transport import unwrap_retry_transport
+from opensandbox.transport import streaming_transport
 
 from code_interpreter.adapters.converter.code_execution_converter import (
     CodeExecutionConverter,
@@ -72,14 +72,8 @@ class CodesAdapter(Codes):
     """
     Adapter implementation for code execution service.
 
-    This adapter wraps auto-generated API clients and provides the concrete
-    implementation of the Codes interface. It handles both standard
-    API calls and SSE streaming for real-time code execution output.
-
-    Similar to CommandServiceAdapter, this adapter uses:
-    - Generated API clients for simple operations (create_context, interrupt)
-    - Direct httpx SSE streaming for run
-    - ExceptionConverter for unified exception handling
+    Handles standard API calls plus direct httpx SSE streaming for
+    real-time code execution output.
     """
 
     RUN_CODE_PATH = "/code"
@@ -104,11 +98,7 @@ class CodesAdapter(Codes):
         timeout_seconds = self.connection_config.request_timeout.total_seconds()
         timeout = httpx.Timeout(timeout_seconds)
 
-        headers = {
-            "User-Agent": self.connection_config.user_agent,
-            **self.connection_config.headers,
-            **self.execd_endpoint.headers,
-        }
+        headers = self.execd_endpoint.build_request_headers(self.connection_config)
 
         # Execd API does not require authentication
         self._client = Client(
@@ -116,12 +106,19 @@ class CodesAdapter(Codes):
             timeout=timeout,
         )
 
-        # Inject httpx client (adapter-owned)
+        # Adapter clients must own their transports: aclose() closes them,
+        # and the shared/user connection_config transport must survive that.
+        self._owns_clients = self.connection_config.owns_transport
+        main_transport: httpx.AsyncBaseTransport | None
+        if self._owns_clients:
+            main_transport = self.connection_config.new_owned_transport()
+        else:
+            main_transport = self.connection_config.transport
         self._httpx_client = httpx.AsyncClient(
             base_url=base_url,
             headers=headers,
             timeout=timeout,
-            transport=self.connection_config.transport,
+            transport=main_transport,
         )
         self._client.set_async_httpx_client(self._httpx_client)
 
@@ -131,9 +128,13 @@ class CodesAdapter(Codes):
             "Accept": "text/event-stream",
             "Cache-Control": "no-cache",
         }
-        # SSE bootstraps bypass the retry wrapper: request bodies are
-        # not replayable and a non-idempotent status opt-in would cause
-        # duplicate execution on a resent SSE POST.
+        # SSE bootstraps keep only the wake-timeout retry: a non-idempotent
+        # status opt-in would cause duplicate execution on a resent SSE POST.
+        sse_transport = (
+            self.connection_config.new_owned_transport()
+            if self._owns_clients
+            else self.connection_config.transport
+        )
         self._sse_client = httpx.AsyncClient(
             headers=sse_headers,
             timeout=httpx.Timeout(
@@ -142,7 +143,7 @@ class CodesAdapter(Codes):
                 write=timeout_seconds,
                 pool=None,
             ),
-            transport=unwrap_retry_transport(self.connection_config.transport),
+            transport=streaming_transport(sse_transport),
         )
 
     async def _get_client(self):
@@ -158,6 +159,21 @@ class CodesAdapter(Codes):
         """Return SSE client (read timeout disabled) for execd streaming."""
         return self._sse_client
 
+    async def aclose(self) -> None:
+        """Release the adapter-owned HTTP clients.
+
+        Never closes the shared ``connection_config.transport``; the sandbox
+        stays usable after ``aclose()``. Clients wrapping a user-supplied
+        transport are left open (httpx would close the caller's transport
+        with them).
+        """
+        if not self._owns_clients:
+            return
+        try:
+            await self._httpx_client.aclose()
+        finally:
+            await self._sse_client.aclose()
+
     async def create_context(self, language: str) -> CodeContext:
         """
         Creates a new execution context for code interpretation.
@@ -268,7 +284,7 @@ class CodesAdapter(Codes):
         """
         Executes code within the specified context using SSE streaming.
 
-        Similar to CommandServiceAdapter.run, this uses direct httpx
+        Uses direct httpx
         streaming to handle SSE responses from the execd service.
         """
         if not code.strip():
@@ -299,6 +315,7 @@ class CodesAdapter(Codes):
                 result=[],
                 error=None,
             )
+            execution._is_code_execution = True
 
             # Use SSE client for streaming responses (read timeout disabled)
             client = await self._get_sse_client()
@@ -307,15 +324,10 @@ class CodesAdapter(Codes):
             async with client.stream("POST", url, json=api_request) as response:
                 if response.status_code != 200:
                     await response.aread()
-                    error_body = response.text
                     logger.error(
-                        f"Failed to run code. Status: {response.status_code}, Body: {error_body}"
-                    )
-                    raise SandboxApiException(
-                        message=f"Failed to run code. Status code: {response.status_code}, Body: {error_body}",
-                        status_code=response.status_code,
-                        request_id=extract_request_id(response.headers),
+                        f"Failed to run code. Status: {response.status_code}, Body: {response.text}"
                     )
+                    raise build_api_exception_from_httpx(response, "Run code")
 
                 dispatcher = ExecutionEventDispatcher(execution, handlers)
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/code_interpreter.py

@@ -22,6 +22,7 @@ support, session management, and variable persistence.
 """
 
 import asyncio
+import contextlib
 import logging
 import time
 from datetime import timedelta
@@ -64,7 +65,7 @@ class CodeInterpreter:
 
     Key Features:
 
-    - Multi-language Code Execution: Support for Python, JavaScript, Bash, Java, Kotlin
+    - Multi-language Code Execution: Python, JavaScript, TypeScript, Go, Bash
     - Session Management: Persistent execution contexts with variable state
     - Sandbox Integration: Full access to underlying sandbox file system and command execution
     - Streaming Execution: Real-time code execution with output streaming
@@ -73,11 +74,12 @@ class CodeInterpreter:
     Usage Example:
 
     ```python
-    # First create a sandbox instance
-
+    # The sandbox must use the opensandbox/code-interpreter image (or a
+    # derivative); the strict health check requires the Jupyter runtime.
     sandbox = await Sandbox.create(
-        "python:3.11",
-        resource={"cpu": "1", "memory": "2Gi"}
+        "opensandbox/code-interpreter:latest",
+        entrypoint=["/opt/code-interpreter/code-interpreter.sh"],
+        resource={"cpu": "1", "memory": "2Gi"},
     )
 
     # Then create a code interpreter wrapping the sandbox
@@ -87,9 +89,10 @@ class CodeInterpreter:
     from code_interpreter.models.code import SupportedLanguage
     context = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
     result = await interpreter.codes.run("print('Hello World')", context=context)
-    print(result.logs.stdout)  # Output: Hello World
+    print(result.text)  # Output: Hello World
 
     # Access underlying sandbox for file operations
+    from opensandbox.models.filesystem import WriteEntry
     await interpreter.sandbox.files.write_files([
         WriteEntry(path="data.txt", data="Hello")
     ])
@@ -98,10 +101,16 @@ class CodeInterpreter:
         context=context,
     )
 
-    # Always clean up resources
+    # Clean up: closing the interpreter releases its HTTP clients; the
+    # underlying sandbox lifecycle stays caller-owned.
+    await interpreter.aclose()
     await sandbox.kill()
     await sandbox.close()
     ```
+
+    CodeInterpreter also supports the async context-manager protocol; exiting
+    the ``async with`` block releases the interpreter's HTTP clients (not the
+    sandbox).
     """
 
     def __init__(self, sandbox: Sandbox, code_service: Codes) -> None:
@@ -161,6 +170,24 @@ class CodeInterpreter:
         """
         return self._sandbox.commands
 
+    async def aclose(self) -> None:
+        """
+        Release resources owned by the code interpreter.
+
+        Closes the HTTP clients used by the code execution service. The
+        underlying sandbox is NOT affected; manage its lifecycle separately
+        (``sandbox.kill()`` / ``sandbox.close()``). Safe to call multiple times.
+        """
+        aclose = getattr(self._code_service, "aclose", None)
+        if aclose is not None:
+            await aclose()
+
+    async def __aenter__(self) -> "CodeInterpreter":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.aclose()
+
     @property
     def metrics(self):
         """
@@ -335,9 +362,16 @@ class CodeInterpreter:
             )
 
             interpreter = cls(sandbox, code_execution_service)
-
-            if not skip_health_check:
-                await interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            try:
+                if not skip_health_check:
+                    await interpreter.check_ready(
+                        ready_timeout, health_check_polling_interval
+                    )
+            except Exception:
+                # Don't leak the service's clients on a failed creation.
+                with contextlib.suppress(Exception):
+                    await interpreter.aclose()
+                raise
 
             logger.info(f"Code interpreter {sandbox.id} created successfully")
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/models/code_sync.py

@@ -27,6 +27,7 @@ class SupportedLanguageSync:
     GO = "go"
     TYPESCRIPT = "typescript"
     BASH = "bash"
+    JAVASCRIPT = "javascript"
 
 
 class CodeContextSync(BaseModel):

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/services/code.py

@@ -38,10 +38,10 @@ class Codes(Protocol):
     Supported Languages:
 
     - Python: Full Python 3.x support with package management
-    - JavaScript/Node.js: ES6+ with npm package support
+    - JavaScript: ES6+ with npm package support
+    - TypeScript
+    - Go
     - Bash: Shell scripting with full system access
-    - Java: Compilation and execution with classpath management
-    - Kotlin: Script and compiled Kotlin execution
 
     Key Features:
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/sync/adapters/code_adapter.py

@@ -27,19 +27,19 @@ from opensandbox.adapters.converter.exception_converter import (
     ExceptionConverter,
 )
 from opensandbox.adapters.converter.response_handler import (
-    extract_request_id,
+    build_api_exception_from_httpx,
     handle_api_error,
     require_parsed,
 )
 from opensandbox.config.connection_sync import ConnectionConfigSync
-from opensandbox.exceptions import InvalidArgumentException, SandboxApiException
+from opensandbox.exceptions import InvalidArgumentException
 from opensandbox.models.execd import Execution
 from opensandbox.models.execd_sync import ExecutionHandlersSync
 from opensandbox.models.sandboxes import SandboxEndpoint
 from opensandbox.sync.adapters.converter.execution_event_dispatcher import (
     ExecutionEventDispatcherSync,
 )
-from opensandbox.transport import unwrap_retry_transport
+from opensandbox.transport import streaming_transport
 
 from code_interpreter.models.code_sync import CodeContextSync, SupportedLanguageSync
 from code_interpreter.sync.services.code import CodesSync
@@ -99,18 +99,22 @@ class CodesAdapterSync(CodesSync):
         base_url = f"{self.connection_config.protocol}://{self.execd_endpoint.endpoint}"
         timeout_seconds = self.connection_config.request_timeout.total_seconds()
         timeout = httpx.Timeout(timeout_seconds)
-        headers = {
-            "User-Agent": self.connection_config.user_agent,
-            **self.connection_config.headers,
-            **(self.execd_endpoint.headers or {}),
-        }
-
+        headers = self.execd_endpoint.build_request_headers(self.connection_config)
+
+        # Adapter clients must own their transports: close() closes them,
+        # and the shared/user connection_config transport must survive that.
+        self._owns_clients = self.connection_config.owns_transport
+        main_transport: httpx.BaseTransport | None
+        if self._owns_clients:
+            main_transport = self.connection_config.new_owned_transport()
+        else:
+            main_transport = self.connection_config.transport
         self._client = Client(base_url=base_url, timeout=timeout)
         self._httpx_client = httpx.Client(
             base_url=base_url,
             headers=headers,
             timeout=timeout,
-            transport=self.connection_config.transport,
+            transport=main_transport,
         )
         self._client.set_httpx_client(self._httpx_client)
 
@@ -119,15 +123,19 @@ class CodesAdapterSync(CodesSync):
             "Accept": "text/event-stream",
             "Cache-Control": "no-cache",
         }
-        # SSE bootstraps bypass the retry wrapper: request bodies are
-        # not replayable and a non-idempotent status opt-in would cause
-        # duplicate execution on a resent SSE POST.
+        # SSE bootstraps keep only the wake-timeout retry: a non-idempotent
+        # status opt-in would cause duplicate execution on a resent SSE POST.
+        sse_transport = (
+            self.connection_config.new_owned_transport()
+            if self._owns_clients
+            else self.connection_config.transport
+        )
         self._sse_client = httpx.Client(
             headers=sse_headers,
             timeout=httpx.Timeout(
                 connect=timeout_seconds, read=None, write=timeout_seconds, pool=None
             ),
-            transport=unwrap_retry_transport(self.connection_config.transport),
+            transport=streaming_transport(sse_transport),
         )
 
     def _get_execd_url(self, path: str) -> str:
@@ -136,6 +144,21 @@ class CodesAdapterSync(CodesSync):
             f"{self.connection_config.protocol}://{self.execd_endpoint.endpoint}{path}"
         )
 
+    def close(self) -> None:
+        """Release the adapter-owned HTTP clients.
+
+        Never closes the shared ``connection_config.transport``; the sandbox
+        stays usable after ``close()``. Clients wrapping a user-supplied
+        transport are left open (httpx would close the caller's transport
+        with them).
+        """
+        if not self._owns_clients:
+            return
+        try:
+            self._httpx_client.close()
+        finally:
+            self._sse_client.close()
+
     def create_context(self, language: str) -> CodeContextSync:
         """
         Create a new execution context for code interpretation (sync).
@@ -286,17 +309,13 @@ class CodesAdapterSync(CodesSync):
 
             url = self._get_execd_url(self.RUN_CODE_PATH)
             execution = Execution(id=None, execution_count=None, result=[], error=None)
+            execution._is_code_execution = True
             dispatcher = ExecutionEventDispatcherSync(execution, handlers)
 
             with self._sse_client.stream("POST", url, json=api_request) as response:
                 if response.status_code != 200:
                     response.read()
-                    error_body = response.text
-                    raise SandboxApiException(
-                        message=f"Failed to run code. Status code: {response.status_code}, Body: {error_body}",
-                        status_code=response.status_code,
-                        request_id=extract_request_id(response.headers),
-                    )
+                    raise build_api_exception_from_httpx(response, "Run code")
 
                 for line in response.iter_lines():
                     if not line or not line.strip():

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.2.0}/src/code_interpreter/sync/code_interpreter.py

@@ -17,6 +17,7 @@
 Synchronous Code Interpreter SDK.
 """
 
+import contextlib
 import logging
 import time
 from datetime import timedelta
@@ -73,14 +74,18 @@ class CodeInterpreterSync:
     ```python
     from opensandbox.sync.sandbox import SandboxSync
     from code_interpreter.sync.code_interpreter import CodeInterpreterSync
-    from code_interpreter.models.code import SupportedLanguage
+    from code_interpreter.models.code_sync import SupportedLanguageSync
 
-    sandbox = SandboxSync.create("python:3.11")
+    sandbox = SandboxSync.create(
+        "opensandbox/code-interpreter:latest",
+        entrypoint=["/opt/code-interpreter/code-interpreter.sh"],
+    )
     interpreter = CodeInterpreterSync.create(sandbox=sandbox)
 
-    ctx = interpreter.codes.create_context(SupportedLanguage.PYTHON)
+    ctx = interpreter.codes.create_context(SupportedLanguageSync.PYTHON)
     result = interpreter.codes.run("print('hi')", context=ctx)
 
+    interpreter.close()
     sandbox.kill()
     sandbox.close()
     ```
@@ -139,6 +144,24 @@ class CodeInterpreterSync:
         """
         return self._sandbox.commands
 
+    def close(self) -> None:
+        """
+        Release resources owned by the code interpreter.
+
+        Closes the HTTP clients used by the code execution service. The
+        underlying sandbox is NOT affected; manage its lifecycle separately
+        (``sandbox.kill()`` / ``sandbox.close()``). Safe to call multiple times.
+        """
+        close = getattr(self._code_service, "close", None)
+        if close is not None:
+            close()
+
+    def __enter__(self) -> "CodeInterpreterSync":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
     @property
     def metrics(self):
         """
@@ -289,9 +312,14 @@ class CodeInterpreterSync:
             code_service = factory.create_code_execution_service(endpoint)
 
             interpreter = cls(sandbox, code_service)
-
-            if not skip_health_check:
-                interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            try:
+                if not skip_health_check:
+                    interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            except Exception:
+                # Don't leak the service's clients on a failed creation.
+                with contextlib.suppress(Exception):
+                    interpreter.close()
+                raise
 
             logger.info(f"Code interpreter {sandbox.id} created successfully")
             return interpreter