chore: import upstream snapshot with attribution

packages/python-sdk/.gitignore

@@ -0,0 +1,268 @@
+tests/assets/video-downloaded.webm
+
+### Node template
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pdm
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+.idea/
+
+# Test results
+results.csv

packages/python-sdk/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 FOUNDRYLABS, INC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/python-sdk/Makefile

@@ -0,0 +1,59 @@
+ROOT_DIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))/../..)
+
+generate-api:
+	python $(ROOT_DIR)/spec/remove_extra_tags.py sandboxes snapshots templates tags volumes
+	openapi-python-client generate --output-path $(ROOT_DIR)/packages/python-sdk/e2b/api/api --overwrite --path $(ROOT_DIR)/spec/openapi_generated.yml
+	rm -rf e2b/api/client
+	mv e2b/api/api/e2b_api_client e2b/api/client
+	rm -rf e2b/api/api
+	ruff format .
+
+generate-volume-api:
+	openapi-python-client generate --output-path $(ROOT_DIR)/packages/python-sdk/e2b/volume/api --overwrite --path $(ROOT_DIR)/spec/openapi-volumecontent.yml
+	rm -rf e2b/volume/client
+	mv e2b/volume/api/e2b_api_client e2b/volume/client
+	rm -rf e2b/volume/api
+	ruff format .
+
+generate-envd:
+	if [ ! -f "/go/bin/protoc-gen-connect-python" ]; then \
+		$(MAKE) -C $(ROOT_DIR)/packages/connect-python build; \
+	fi
+
+	cd $(ROOT_DIR)/spec/envd && pwd && buf generate --template buf-python.gen.yaml
+	./scripts/fix-python-pb.sh
+
+	ruff format .
+
+generate: generate-api generate-envd generate-mcp generate-volume-api
+
+# Install the code-generation toolchain into the uv env. After this, run the
+# generators locally with e.g. `uv run make generate-api`.
+init:
+	uv sync --group codegen
+
+typecheck:
+	ty check
+
+lint:
+	ruff check .
+	ruff format --check .
+
+format:
+	ruff format .
+
+generate-mcp:
+	datamodel-codegen \
+			--input ../../spec/mcp-server.json \
+			--input-file-type jsonschema \
+			--output e2b/sandbox/mcp.py \
+			--output-model-type typing.TypedDict \
+			--target-python-version 3.10 \
+			--class-name McpServer \
+			--use-field-description \
+			--disable-timestamp \
+			--extra-fields forbid
+
+.PHONY: test
+test:
+	uv run pytest --verbose --numprocesses=4

packages/python-sdk/README.md

@@ -0,0 +1,65 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-white.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png">
+    <img alt="E2B Logo" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-black.png" width="200">
+  </picture>
+</p>
+
+<h4 align="center">
+  <a href="https://pypi.org/project/e2b/">
+    <img alt="Last 1 month downloads for the Python SDK" loading="lazy" decoding="async" style="color:transparent;width:170px;height:18px" src="https://static.pepy.tech/personalized-badge/e2b?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=PyPi%20Monthly%20Downloads">
+  </a>  
+</h4>
+
+
+## What is E2B?
+[E2B](https://www.e2b.dev/) is an open-source infrastructure that allows you to run AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/e2b) or [Python SDK](https://pypi.org/project/e2b).
+
+## Run your first Sandbox
+
+### 1. Install SDK
+
+```
+pip install e2b
+```
+
+### 2. Get your E2B API key
+1. Sign up to E2B [here](https://e2b.dev).
+2. Get your API key [here](https://e2b.dev/dashboard?tab=keys).
+3. Set environment variable with your API key
+```
+E2B_API_KEY=e2b_***
+```
+
+### 3. Start a sandbox and run commands
+
+```py
+from e2b import Sandbox
+
+with Sandbox.create() as sandbox:
+    result = sandbox.commands.run('echo "Hello from E2B!"')
+    print(result.stdout)  # Hello from E2B!
+```
+
+### 4. Code execution with Code Interpreter
+
+If you need [`run_code()`](https://e2b.dev/docs/code-interpreting), install the [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter):
+
+```
+pip install e2b-code-interpreter
+```
+
+```py
+from e2b_code_interpreter import Sandbox
+
+with Sandbox.create() as sandbox:
+    execution = sandbox.run_code("x = 1; x += 1; x")
+    print(execution.text)  # outputs 2
+```
+
+### 5. Check docs
+Visit [E2B documentation](https://e2b.dev/docs).
+
+### 6. E2B cookbook
+Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.

packages/python-sdk/e2b/__init__.py

@@ -0,0 +1,260 @@
+"""
+Secure sandboxed cloud environments made for AI agents and AI apps.
+
+Check docs [here](https://e2b.dev/docs).
+
+E2B Sandbox is a secure cloud sandbox environment made for AI agents and AI
+apps.
+Sandboxes allow AI agents and apps to have long running cloud secure environments.
+In these environments, large language models can use the same tools as humans do.
+
+E2B Python SDK supports both sync and async API:
+
+```py
+from e2b import Sandbox
+
+# Create sandbox
+sandbox = Sandbox.create()
+```
+
+```py
+from e2b import AsyncSandbox
+
+# Create sandbox
+sandbox = await AsyncSandbox.create()
+```
+"""
+
+from .api import (
+    ApiClient,
+    client,
+)
+from .connection_config import (
+    ApiParams,
+    ConnectionConfig,
+    ProxyTypes,
+    Username,
+)
+from .volume.connection_config import VolumeApiParams, VolumeConnectionConfig
+from .exceptions import (
+    AuthenticationException,
+    FileNotFoundException,
+    GitAuthException,
+    GitUpstreamException,
+    BuildException,
+    FileUploadException,
+    InvalidArgumentException,
+    NotEnoughSpaceException,
+    NotFoundException,
+    RateLimitException,
+    SandboxException,
+    SandboxNotFoundException,
+    TemplateException,
+    TimeoutException,
+    VolumeException,
+)
+from .sandbox.commands.command_handle import (
+    CommandExitException,
+    CommandResult,
+    PtyOutput,
+    PtySize,
+    Stderr,
+    Stdout,
+)
+from .sandbox.commands.main import ProcessInfo
+from .sandbox.filesystem.filesystem import EntryInfo, FileType, WriteInfo
+from .sandbox.filesystem.watch_handle import (
+    FilesystemEvent,
+    FilesystemEventType,
+)
+from .sandbox._git import GitBranches, GitFileStatus, GitResetMode, GitStatus
+from .sandbox_sync.git import Git
+from .sandbox.network import ALL_TRAFFIC
+from .sandbox.signature import get_signature
+from .sandbox.sandbox_api import (
+    GitHubMcpServer,
+    GitHubMcpServerConfig,
+    McpServer,
+    SandboxInfo,
+    SandboxInfoLifecycle,
+    SandboxMetrics,
+    SandboxLifecycle,
+    SandboxOnTimeout,
+    SandboxNetworkInfo,
+    SandboxNetworkOpts,
+    SandboxNetworkRule,
+    SandboxNetworkRuleInfo,
+    SandboxNetworkRules,
+    SandboxNetworkSelector,
+    SandboxNetworkSelectorContext,
+    SandboxNetworkTransform,
+    SandboxNetworkUpdate,
+    SandboxQuery,
+    SandboxState,
+    SnapshotInfo,
+)
+from .sandbox_async.commands.command_handle import AsyncCommandHandle
+from .sandbox_async.filesystem.watch_handle import AsyncWatchHandle
+from .sandbox_async.main import AsyncSandbox
+from .sandbox_async.paginator import AsyncSandboxPaginator, AsyncSnapshotPaginator
+from .sandbox_async.utils import OutputHandler
+from .sandbox_sync.commands.command_handle import CommandHandle
+from .sandbox_sync.filesystem.watch_handle import WatchHandle
+from .sandbox_sync.main import Sandbox
+from .sandbox_sync.paginator import SandboxPaginator, SnapshotPaginator
+from .template.logger import (
+    LogEntry,
+    LogEntryEnd,
+    LogEntryLevel,
+    LogEntryStart,
+    default_build_logger,
+)
+from .template.main import TemplateBase, TemplateClass
+from .template.readycmd import (
+    ReadyCmd,
+    wait_for_file,
+    wait_for_port,
+    wait_for_process,
+    wait_for_timeout,
+    wait_for_url,
+)
+from .template.types import (
+    BuildInfo,
+    BuildStatusReason,
+    CopyItem,
+    TemplateBuildStatus,
+    TemplateBuildStatusResponse,
+    TemplateTag,
+    TemplateTagInfo,
+)
+from .template_async.main import AsyncTemplate
+from .template_sync.main import Template
+
+from .volume.volume_sync import Volume
+from .volume.volume_async import AsyncVolume
+from .volume.types import (
+    VolumeInfo,
+    VolumeAndToken,
+    VolumeEntryStat,
+    VolumeFileType,
+)
+
+__all__ = [
+    # API
+    "ApiClient",
+    "client",
+    # Connection config
+    "ConnectionConfig",
+    "VolumeConnectionConfig",
+    "ProxyTypes",
+    "ApiParams",
+    "VolumeApiParams",
+    "Username",
+    # Exceptions
+    "SandboxException",
+    "TimeoutException",
+    "NotFoundException",
+    "FileNotFoundException",
+    "SandboxNotFoundException",
+    "AuthenticationException",
+    "GitAuthException",
+    "GitUpstreamException",
+    "InvalidArgumentException",
+    "NotEnoughSpaceException",
+    "TemplateException",
+    "BuildException",
+    "FileUploadException",
+    "RateLimitException",
+    "VolumeException",
+    # Sandbox API
+    "SandboxInfo",
+    "SandboxInfoLifecycle",
+    "SandboxMetrics",
+    "ProcessInfo",
+    "SandboxQuery",
+    "SandboxState",
+    "SandboxMetrics",
+    "GitStatus",
+    "GitBranches",
+    "GitFileStatus",
+    "GitResetMode",
+    # Command handle
+    "CommandResult",
+    "Stderr",
+    "Stdout",
+    "CommandExitException",
+    "PtyOutput",
+    "PtySize",
+    # Filesystem
+    "FilesystemEvent",
+    "FilesystemEventType",
+    "EntryInfo",
+    "WriteInfo",
+    "FileType",
+    # Network
+    "SandboxNetworkOpts",
+    "SandboxNetworkInfo",
+    "SandboxNetworkSelector",
+    "SandboxNetworkSelectorContext",
+    "SandboxNetworkRule",
+    "SandboxNetworkRuleInfo",
+    "SandboxNetworkRules",
+    "SandboxNetworkTransform",
+    "SandboxNetworkUpdate",
+    "SandboxLifecycle",
+    "SandboxOnTimeout",
+    "ALL_TRAFFIC",
+    # Snapshot
+    "SnapshotInfo",
+    "SnapshotPaginator",
+    "AsyncSnapshotPaginator",
+    # Signature
+    "get_signature",
+    # Sync sandbox
+    "Sandbox",
+    "SandboxPaginator",
+    "WatchHandle",
+    "CommandHandle",
+    # Async sandbox
+    "OutputHandler",
+    "AsyncSandboxPaginator",
+    "AsyncSandbox",
+    "AsyncWatchHandle",
+    "AsyncCommandHandle",
+    # Template
+    "Template",
+    "AsyncTemplate",
+    "TemplateBase",
+    "TemplateClass",
+    "CopyItem",
+    "BuildInfo",
+    "BuildStatusReason",
+    "TemplateBuildStatus",
+    "TemplateBuildStatusResponse",
+    "TemplateTag",
+    "TemplateTagInfo",
+    "ReadyCmd",
+    "wait_for_file",
+    "wait_for_url",
+    "wait_for_port",
+    "wait_for_process",
+    "wait_for_timeout",
+    "LogEntry",
+    "LogEntryStart",
+    "LogEntryEnd",
+    "LogEntryLevel",
+    "default_build_logger",
+    # MCP
+    "McpServer",
+    "GitHubMcpServer",
+    "GitHubMcpServerConfig",
+    # Git
+    "Git",
+    # Volume
+    "Volume",
+    "AsyncVolume",
+    "VolumeInfo",
+    "VolumeAndToken",
+    "VolumeEntryStat",
+    "VolumeFileType",
+]

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

@@ -0,0 +1,287 @@
+import asyncio
+import json
+import logging
+import os
+import re
+import threading
+import weakref
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Callable, Optional, Protocol, Union
+
+import httpx
+from httpx import AsyncBaseTransport, BaseTransport, Limits, Timeout
+
+from e2b.api.client.client import AuthenticatedClient
+from e2b.api.client.types import Response
+from e2b.api.metadata import default_headers
+from e2b.connection_config import ConnectionConfig
+from e2b.exceptions import (
+    AuthenticationException,
+    RateLimitException,
+    SandboxException,
+)
+
+
+def make_logging_event_hooks(log: Optional[logging.Logger]) -> dict:
+    """Build synchronous httpx ``event_hooks`` that log requests and responses
+    to the given ``logging.Logger``. Requests log at ``INFO``, successful
+    responses at ``INFO`` and responses with status >= 400 at ``ERROR``.
+
+    Returns no hooks when ``log`` is ``None`` so that nothing is logged unless a
+    logger was explicitly supplied."""
+    if log is None:
+        return {}
+
+    def on_request(request) -> None:
+        log.info(f"Request {request.method} {request.url}")
+
+    def on_response(response: Response) -> None:
+        if response.status_code >= 400:
+            log.error(f"Response {response.status_code}")
+        else:
+            log.info(f"Response {response.status_code}")
+
+    return {"request": [on_request], "response": [on_response]}
+
+
+def make_async_logging_event_hooks(log: Optional[logging.Logger]) -> dict:
+    """Asynchronous counterpart of :func:`make_logging_event_hooks`."""
+    if log is None:
+        return {}
+
+    async def on_request(request) -> None:
+        log.info(f"Request {request.method} {request.url}")
+
+    async def on_response(response: Response) -> None:
+        if response.status_code >= 400:
+            log.error(f"Response {response.status_code}")
+        else:
+            log.info(f"Response {response.status_code}")
+
+    return {"request": [on_request], "response": [on_response]}
+
+
+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")),
+)
+
+connection_retries = int(os.getenv("E2B_CONNECTION_RETRIES", "3"))
+
+
+@dataclass
+class SandboxCreateResponse:
+    sandbox_id: str
+    sandbox_domain: Optional[str]
+    envd_version: str
+    envd_access_token: Optional[str]
+    traffic_access_token: Optional[str]
+
+
+def handle_api_exception(
+    e: "SupportsApiErrorResponse",
+    default_exception_class: type[Exception] = SandboxException,
+    stack_trace: Optional[TracebackType] = None,
+):
+    try:
+        body = json.loads(e.content) if e.content else {}
+    except json.JSONDecodeError:
+        body = {}
+
+    if e.status_code == 401:
+        message = f"{e.status_code}: Unauthorized, please check your credentials."
+        if body.get("message"):
+            message += f" - {body['message']}"
+        return AuthenticationException(message)
+
+    if e.status_code == 429:
+        message = f"{e.status_code}: Rate limit exceeded, please try again later."
+        if body.get("message"):
+            message += f" - {body['message']}"
+        return RateLimitException(message)
+
+    if "message" in body:
+        return default_exception_class(
+            f"{e.status_code}: {body['message']}"
+        ).with_traceback(stack_trace)
+    return default_exception_class(f"{e.status_code}: {e.content}").with_traceback(
+        stack_trace
+    )
+
+
+class SupportsApiErrorResponse(Protocol):
+    @property
+    def status_code(self) -> int: ...
+
+    @property
+    def content(self) -> Union[str, bytes]: ...
+
+
+_API_KEY_PATTERN = re.compile(r"\Ae2b_[0-9a-f]+\Z")
+_API_KEY_EXAMPLE = "e2b_" + "0" * 40
+
+
+def validate_api_key(api_key: str) -> None:
+    """Validate that an E2B API key has the expected ``e2b_`` prefix
+    followed by hex characters. Raises ``AuthenticationException`` otherwise.
+    """
+    if not _API_KEY_PATTERN.match(api_key):
+        raise AuthenticationException(
+            'Invalid API key format: expected "e2b_" followed by hex '
+            f'characters (e.g. "{_API_KEY_EXAMPLE}"). '
+            "Visit the API Keys tab at https://e2b.dev/dashboard?tab=keys to get your API key."
+        )
+
+
+class ApiClient(AuthenticatedClient):
+    """
+    The client for interacting with the E2B API.
+    """
+
+    def __init__(
+        self,
+        config: ConnectionConfig,
+        transport: Optional[Union[BaseTransport, AsyncBaseTransport]] = None,
+        transport_factory: Optional[Callable[[], BaseTransport]] = None,
+        async_transport_factory: Optional[Callable[[], AsyncBaseTransport]] = None,
+        *args,
+        **kwargs,
+    ):
+        if transport is not None and (
+            transport_factory is not None or async_transport_factory is not None
+        ):
+            raise ValueError("Use either transport or transport_factory, not both")
+
+        self._transport_factory = transport_factory
+        self._async_transport_factory = async_transport_factory
+        self._thread_local = threading.local()
+        # Keyed weakly by the event loop object itself, not id(loop) —
+        # CPython reuses object ids, so a new loop could otherwise inherit
+        # a client bound to a previous, closed loop.
+        self._async_clients: weakref.WeakKeyDictionary[
+            asyncio.AbstractEventLoop, httpx.AsyncClient
+        ] = weakref.WeakKeyDictionary()
+        self._proxy = config.proxy
+
+        if config.api_key is None:
+            raise AuthenticationException(
+                "API key is required, please visit the API Keys tab at https://e2b.dev/dashboard?tab=keys to get your API key. "
+                "You can either set the environment variable `E2B_API_KEY` "
+                'or you can pass it directly to the method like api_key="e2b_..."',
+            )
+
+        if config.api_key is not None and config.validate_api_key:
+            validate_api_key(config.api_key)
+
+        token = config.api_key
+        auth_header_name = "X-API-KEY"
+        prefix = ""
+
+        self._logger = config.logger
+
+        headers = {
+            **default_headers,
+            # Deprecated: send the access token alongside the API key when one
+            # is available, mirroring the JS SDK. Prefer `api_headers` instead.
+            # Spread before `config.headers` so a custom `Authorization` in
+            # `api_headers` wins over the deprecated access token, matching JS.
+            **(
+                {"Authorization": f"Bearer {config.access_token}"}
+                if config.access_token is not None
+                else {}
+            ),
+            **(config.headers or {}),
+        }
+
+        # Prevent passing these parameters twice
+        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)
+
+        httpx_args = {
+            "event_hooks": self._logging_event_hooks(),
+        }
+        if transport is not None:
+            httpx_args["transport"] = transport
+        if (
+            transport is None
+            and transport_factory is None
+            and async_transport_factory is None
+        ):
+            httpx_args["proxy"] = config.proxy
+
+        # config.request_timeout is None when the timeout is explicitly
+        # disabled (request_timeout=0), which httpx.Timeout(None) preserves.
+        kwargs.setdefault("timeout", Timeout(config.request_timeout))
+
+        super().__init__(
+            base_url=config.api_url,
+            httpx_args=httpx_args,
+            headers=headers,
+            token=token or "",
+            auth_header_name=auth_header_name,
+            prefix=prefix,
+            *args,
+            **kwargs,
+        )
+
+    def _logging_event_hooks(self) -> dict:
+        return make_logging_event_hooks(self._logger)
+
+    def _headers_with_auth(self) -> dict:
+        return {
+            **self._headers,
+            self.auth_header_name: (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            ),
+        }
+
+    def get_httpx_client(self) -> httpx.Client:
+        if self._client is not None or self._transport_factory is None:
+            return super().get_httpx_client()
+
+        client = getattr(self._thread_local, "client", None)
+        if client is None:
+            client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers_with_auth(),
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                event_hooks=self._httpx_args.get("event_hooks"),
+                transport=self._transport_factory(),
+            )
+            self._thread_local.client = client
+        return client
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        if self._async_client is not None or self._async_transport_factory is None:
+            return super().get_async_httpx_client()
+
+        loop = asyncio.get_running_loop()
+        client = self._async_clients.get(loop)
+        if client is None:
+            client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers_with_auth(),
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                event_hooks=self._httpx_args.get("event_hooks"),
+                transport=self._async_transport_factory(),
+            )
+            self._async_clients[loop] = client
+        return client
+
+
+# We need to override the logging hooks for the async usage
+class AsyncApiClient(ApiClient):
+    def _logging_event_hooks(self) -> dict:
+        return make_async_logging_event_hooks(self._logger)

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

@@ -0,0 +1,8 @@
+"""A client library for accessing E2B API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

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

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

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

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

packages/python-sdk/e2b/api/client/api/sandboxes/delete_sandboxes_sandbox_id.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/sandboxes/{sandbox_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.listed_sandbox import ListedSandbox
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    metadata: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["metadata"] = metadata
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/sandboxes",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListedSandbox.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return sync_detailed(
+        client=client,
+        metadata=metadata,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            metadata=metadata,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_metrics.py

@@ -0,0 +1,173 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandboxes_with_metrics import SandboxesWithMetrics
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    sandbox_ids: list[str],
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    json_sandbox_ids = sandbox_ids
+
+    params["sandbox_ids"] = ",".join(str(item) for item in json_sandbox_ids)
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/sandboxes/metrics",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, SandboxesWithMetrics]]:
+    if response.status_code == 200:
+        response_200 = SandboxesWithMetrics.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, SandboxesWithMetrics]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    sandbox_ids: list[str],
+) -> Response[Union[Error, SandboxesWithMetrics]]:
+    """List metrics for given sandboxes
+
+    Args:
+        sandbox_ids (list[str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxesWithMetrics]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_ids=sandbox_ids,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    sandbox_ids: list[str],
+) -> Optional[Union[Error, SandboxesWithMetrics]]:
+    """List metrics for given sandboxes
+
+    Args:
+        sandbox_ids (list[str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxesWithMetrics]
+    """
+
+    return sync_detailed(
+        client=client,
+        sandbox_ids=sandbox_ids,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    sandbox_ids: list[str],
+) -> Response[Union[Error, SandboxesWithMetrics]]:
+    """List metrics for given sandboxes
+
+    Args:
+        sandbox_ids (list[str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxesWithMetrics]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_ids=sandbox_ids,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    sandbox_ids: list[str],
+) -> Optional[Union[Error, SandboxesWithMetrics]]:
+    """List metrics for given sandboxes
+
+    Args:
+        sandbox_ids (list[str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxesWithMetrics]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            sandbox_ids=sandbox_ids,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id.py

@@ -0,0 +1,163 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandbox_detail import SandboxDetail
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/sandboxes/{sandbox_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, SandboxDetail]]:
+    if response.status_code == 200:
+        response_200 = SandboxDetail.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, SandboxDetail]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, SandboxDetail]]:
+    """Get a sandbox by id
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxDetail]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, SandboxDetail]]:
+    """Get a sandbox by id
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxDetail]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, SandboxDetail]]:
+    """Get a sandbox by id
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxDetail]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, SandboxDetail]]:
+    """Get a sandbox by id
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxDetail]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id_logs.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandbox_logs import SandboxLogs
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    start: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["start"] = start
+
+    params["limit"] = limit
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/sandboxes/{sandbox_id}/logs",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, SandboxLogs]]:
+    if response.status_code == 200:
+        response_200 = SandboxLogs.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, SandboxLogs]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+) -> Response[Union[Error, SandboxLogs]]:
+    """Get sandbox logs. Use /v2/sandboxes/{sandboxID}/logs instead.
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxLogs]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        start=start,
+        limit=limit,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+) -> Optional[Union[Error, SandboxLogs]]:
+    """Get sandbox logs. Use /v2/sandboxes/{sandboxID}/logs instead.
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxLogs]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        start=start,
+        limit=limit,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+) -> Response[Union[Error, SandboxLogs]]:
+    """Get sandbox logs. Use /v2/sandboxes/{sandboxID}/logs instead.
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxLogs]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        start=start,
+        limit=limit,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+) -> Optional[Union[Error, SandboxLogs]]:
+    """Get sandbox logs. Use /v2/sandboxes/{sandboxID}/logs instead.
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxLogs]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            start=start,
+            limit=limit,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id_metrics.py

@@ -0,0 +1,212 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandbox_metric import SandboxMetric
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    start: Union[Unset, int] = UNSET,
+    end: Union[Unset, int] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["start"] = start
+
+    params["end"] = end
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/sandboxes/{sandbox_id}/metrics",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["SandboxMetric"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = SandboxMetric.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["SandboxMetric"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    end: Union[Unset, int] = UNSET,
+) -> Response[Union[Error, list["SandboxMetric"]]]:
+    """Get sandbox metrics
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        end (Union[Unset, int]): Unix timestamp for the end of the interval, in seconds, for which
+            the metrics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['SandboxMetric']]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        start=start,
+        end=end,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    end: Union[Unset, int] = UNSET,
+) -> Optional[Union[Error, list["SandboxMetric"]]]:
+    """Get sandbox metrics
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        end (Union[Unset, int]): Unix timestamp for the end of the interval, in seconds, for which
+            the metrics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['SandboxMetric']]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        start=start,
+        end=end,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    end: Union[Unset, int] = UNSET,
+) -> Response[Union[Error, list["SandboxMetric"]]]:
+    """Get sandbox metrics
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        end (Union[Unset, int]): Unix timestamp for the end of the interval, in seconds, for which
+            the metrics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['SandboxMetric']]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        start=start,
+        end=end,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    start: Union[Unset, int] = UNSET,
+    end: Union[Unset, int] = UNSET,
+) -> Optional[Union[Error, list["SandboxMetric"]]]:
+    """Get sandbox metrics
+
+    Args:
+        sandbox_id (str):
+        start (Union[Unset, int]):
+        end (Union[Unset, int]): Unix timestamp for the end of the interval, in seconds, for which
+            the metrics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['SandboxMetric']]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            start=start,
+            end=end,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_v2_sandboxes.py

@@ -0,0 +1,230 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.listed_sandbox import ListedSandbox
+from ...models.sandbox_state import SandboxState
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    metadata: Union[Unset, str] = UNSET,
+    state: Union[Unset, list[SandboxState]] = UNSET,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["metadata"] = metadata
+
+    json_state: Union[Unset, list[str]] = UNSET
+    if not isinstance(state, Unset):
+        json_state = []
+        for state_item_data in state:
+            state_item = state_item_data.value
+            json_state.append(state_item)
+
+    if not isinstance(json_state, Unset):
+        params["state"] = ",".join(str(item) for item in json_state)
+
+    params["nextToken"] = next_token
+
+    params["limit"] = limit
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/v2/sandboxes",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListedSandbox.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+    state: Union[Unset, list[SandboxState]] = UNSET,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+        state (Union[Unset, list[SandboxState]]):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+        state=state,
+        next_token=next_token,
+        limit=limit,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+    state: Union[Unset, list[SandboxState]] = UNSET,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+        state (Union[Unset, list[SandboxState]]):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return sync_detailed(
+        client=client,
+        metadata=metadata,
+        state=state,
+        next_token=next_token,
+        limit=limit,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+    state: Union[Unset, list[SandboxState]] = UNSET,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+        state (Union[Unset, list[SandboxState]]):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+        state=state,
+        next_token=next_token,
+        limit=limit,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+    state: Union[Unset, list[SandboxState]] = UNSET,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+        state (Union[Unset, list[SandboxState]]):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            metadata=metadata,
+            state=state,
+            next_token=next_token,
+            limit=limit,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/get_v_2_sandboxes_sandbox_id_logs.py

@@ -0,0 +1,254 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.log_level import LogLevel
+from ...models.logs_direction import LogsDirection
+from ...models.sandbox_logs_v2_response import SandboxLogsV2Response
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    search: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["cursor"] = cursor
+
+    params["limit"] = limit
+
+    json_direction: Union[Unset, str] = UNSET
+    if not isinstance(direction, Unset):
+        json_direction = direction.value
+
+    params["direction"] = json_direction
+
+    json_level: Union[Unset, str] = UNSET
+    if not isinstance(level, Unset):
+        json_level = level.value
+
+    params["level"] = json_level
+
+    params["search"] = search
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/v2/sandboxes/{sandbox_id}/logs",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, SandboxLogsV2Response]]:
+    if response.status_code == 200:
+        response_200 = SandboxLogsV2Response.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, SandboxLogsV2Response]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    search: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, SandboxLogsV2Response]]:
+    """Get sandbox logs
+
+    Args:
+        sandbox_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        search (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxLogsV2Response]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        search=search,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    search: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, SandboxLogsV2Response]]:
+    """Get sandbox logs
+
+    Args:
+        sandbox_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        search (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxLogsV2Response]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        search=search,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    search: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, SandboxLogsV2Response]]:
+    """Get sandbox logs
+
+    Args:
+        sandbox_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        search (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SandboxLogsV2Response]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        search=search,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 1000,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    search: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, SandboxLogsV2Response]]:
+    """Get sandbox logs
+
+    Args:
+        sandbox_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 1000.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        search (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SandboxLogsV2Response]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            cursor=cursor,
+            limit=limit,
+            direction=direction,
+            level=level,
+            search=search,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.new_sandbox import NewSandbox
+from ...models.sandbox import Sandbox
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: NewSandbox,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/sandboxes",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, Sandbox]]:
+    if response.status_code == 201:
+        response_201 = Sandbox.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, Sandbox]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: NewSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Create a sandbox from the template
+
+    Args:
+        body (NewSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: NewSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Create a sandbox from the template
+
+    Args:
+        body (NewSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: NewSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Create a sandbox from the template
+
+    Args:
+        body (NewSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: NewSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Create a sandbox from the template
+
+    Args:
+        body (NewSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_connect.py

@@ -0,0 +1,193 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.connect_sandbox import ConnectSandbox
+from ...models.error import Error
+from ...models.sandbox import Sandbox
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: ConnectSandbox,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/connect",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, Sandbox]]:
+    if response.status_code == 200:
+        response_200 = Sandbox.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 201:
+        response_201 = Sandbox.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, Sandbox]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_pause.py

@@ -0,0 +1,187 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandbox_pause_request import SandboxPauseRequest
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: SandboxPauseRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/pause",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 409:
+        response_409 = Error.from_dict(response.json())
+
+        return response_409
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxPauseRequest,
+) -> Response[Union[Any, Error]]:
+    """Pause the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (SandboxPauseRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxPauseRequest,
+) -> Optional[Union[Any, Error]]:
+    """Pause the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (SandboxPauseRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxPauseRequest,
+) -> Response[Union[Any, Error]]:
+    """Pause the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (SandboxPauseRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxPauseRequest,
+) -> Optional[Union[Any, Error]]:
+    """Pause the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (SandboxPauseRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_refreshes.py

@@ -0,0 +1,181 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.post_sandboxes_sandbox_id_refreshes_body import (
+    PostSandboxesSandboxIDRefreshesBody,
+)
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: PostSandboxesSandboxIDRefreshesBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/refreshes",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDRefreshesBody,
+) -> Response[Union[Any, Error]]:
+    """Refresh the sandbox extending its time to live
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDRefreshesBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDRefreshesBody,
+) -> Optional[Union[Any, Error]]:
+    """Refresh the sandbox extending its time to live
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDRefreshesBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDRefreshesBody,
+) -> Response[Union[Any, Error]]:
+    """Refresh the sandbox extending its time to live
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDRefreshesBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDRefreshesBody,
+) -> Optional[Union[Any, Error]]:
+    """Refresh the sandbox extending its time to live
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDRefreshesBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_resume.py

@@ -0,0 +1,189 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.resumed_sandbox import ResumedSandbox
+from ...models.sandbox import Sandbox
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: ResumedSandbox,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/resume",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, Sandbox]]:
+    if response.status_code == 201:
+        response_201 = Sandbox.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 409:
+        response_409 = Error.from_dict(response.json())
+
+        return response_409
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, Sandbox]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ResumedSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Resume the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (ResumedSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ResumedSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Resume the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (ResumedSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ResumedSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Resume the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (ResumedSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ResumedSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Resume the sandbox
+
+    Args:
+        sandbox_id (str):
+        body (ResumedSandbox):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Sandbox]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_snapshots.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.post_sandboxes_sandbox_id_snapshots_body import (
+    PostSandboxesSandboxIDSnapshotsBody,
+)
+from ...models.snapshot_info import SnapshotInfo
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: PostSandboxesSandboxIDSnapshotsBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/snapshots",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, SnapshotInfo]]:
+    if response.status_code == 201:
+        response_201 = SnapshotInfo.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, SnapshotInfo]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDSnapshotsBody,
+) -> Response[Union[Error, SnapshotInfo]]:
+    """Create a persistent snapshot from the sandbox's current state. Snapshots can be used to create new
+    sandboxes and persist beyond the original sandbox's lifetime.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDSnapshotsBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SnapshotInfo]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDSnapshotsBody,
+) -> Optional[Union[Error, SnapshotInfo]]:
+    """Create a persistent snapshot from the sandbox's current state. Snapshots can be used to create new
+    sandboxes and persist beyond the original sandbox's lifetime.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDSnapshotsBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SnapshotInfo]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDSnapshotsBody,
+) -> Response[Union[Error, SnapshotInfo]]:
+    """Create a persistent snapshot from the sandbox's current state. Snapshots can be used to create new
+    sandboxes and persist beyond the original sandbox's lifetime.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDSnapshotsBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, SnapshotInfo]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDSnapshotsBody,
+) -> Optional[Union[Error, SnapshotInfo]]:
+    """Create a persistent snapshot from the sandbox's current state. Snapshots can be used to create new
+    sandboxes and persist beyond the original sandbox's lifetime.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDSnapshotsBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, SnapshotInfo]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_timeout.py

@@ -0,0 +1,193 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.post_sandboxes_sandbox_id_timeout_body import (
+    PostSandboxesSandboxIDTimeoutBody,
+)
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: PostSandboxesSandboxIDTimeoutBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/timeout",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDTimeoutBody,
+) -> Response[Union[Any, Error]]:
+    """Set the timeout for the sandbox. The sandbox will expire x seconds from the time of the request.
+    Calling this method multiple times overwrites the TTL, each time using the current timestamp as the
+    starting point to measure the timeout duration.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDTimeoutBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDTimeoutBody,
+) -> Optional[Union[Any, Error]]:
+    """Set the timeout for the sandbox. The sandbox will expire x seconds from the time of the request.
+    Calling this method multiple times overwrites the TTL, each time using the current timestamp as the
+    starting point to measure the timeout duration.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDTimeoutBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDTimeoutBody,
+) -> Response[Union[Any, Error]]:
+    """Set the timeout for the sandbox. The sandbox will expire x seconds from the time of the request.
+    Calling this method multiple times overwrites the TTL, each time using the current timestamp as the
+    starting point to measure the timeout duration.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDTimeoutBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: PostSandboxesSandboxIDTimeoutBody,
+) -> Optional[Union[Any, Error]]:
+    """Set the timeout for the sandbox. The sandbox will expire x seconds from the time of the request.
+    Calling this method multiple times overwrites the TTL, each time using the current timestamp as the
+    starting point to measure the timeout duration.
+
+    Args:
+        sandbox_id (str):
+        body (PostSandboxesSandboxIDTimeoutBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/sandboxes/put_sandboxes_sandbox_id_network.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.sandbox_network_update_config import SandboxNetworkUpdateConfig
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: SandboxNetworkUpdateConfig,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": f"/sandboxes/{sandbox_id}/network",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 409:
+        response_409 = Error.from_dict(response.json())
+
+        return response_409
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxNetworkUpdateConfig,
+) -> Response[Union[Any, Error]]:
+    """Update the network configuration for a running sandbox. Replaces the current egress rules with the
+    provided configuration. Omitting field clears it.
+
+    Args:
+        sandbox_id (str):
+        body (SandboxNetworkUpdateConfig): Network configuration update for a running sandbox.
+            Replaces the current egress rules with the provided configuration. Omitting a field clears
+            it.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxNetworkUpdateConfig,
+) -> Optional[Union[Any, Error]]:
+    """Update the network configuration for a running sandbox. Replaces the current egress rules with the
+    provided configuration. Omitting field clears it.
+
+    Args:
+        sandbox_id (str):
+        body (SandboxNetworkUpdateConfig): Network configuration update for a running sandbox.
+            Replaces the current egress rules with the provided configuration. Omitting a field clears
+            it.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxNetworkUpdateConfig,
+) -> Response[Union[Any, Error]]:
+    """Update the network configuration for a running sandbox. Replaces the current egress rules with the
+    provided configuration. Omitting field clears it.
+
+    Args:
+        sandbox_id (str):
+        body (SandboxNetworkUpdateConfig): Network configuration update for a running sandbox.
+            Replaces the current egress rules with the provided configuration. Omitting a field clears
+            it.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: SandboxNetworkUpdateConfig,
+) -> Optional[Union[Any, Error]]:
+    """Update the network configuration for a running sandbox. Replaces the current egress rules with the
+    provided configuration. Omitting field clears it.
+
+    Args:
+        sandbox_id (str):
+        body (SandboxNetworkUpdateConfig): Network configuration update for a running sandbox.
+            Replaces the current egress rules with the provided configuration. Omitting a field clears
+            it.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

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

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

packages/python-sdk/e2b/api/client/api/snapshots/get_snapshots.py

@@ -0,0 +1,202 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.snapshot_info import SnapshotInfo
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    sandbox_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+    next_token: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["sandboxID"] = sandbox_id
+
+    params["limit"] = limit
+
+    params["nextToken"] = next_token
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/snapshots",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["SnapshotInfo"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = SnapshotInfo.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["SnapshotInfo"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    sandbox_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+    next_token: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["SnapshotInfo"]]]:
+    """List all snapshots for the team
+
+    Args:
+        sandbox_id (Union[Unset, str]): Filter snapshots by source sandbox ID
+        limit (Union[Unset, int]):  Default: 100.
+        next_token (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['SnapshotInfo']]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        limit=limit,
+        next_token=next_token,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    sandbox_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+    next_token: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["SnapshotInfo"]]]:
+    """List all snapshots for the team
+
+    Args:
+        sandbox_id (Union[Unset, str]): Filter snapshots by source sandbox ID
+        limit (Union[Unset, int]):  Default: 100.
+        next_token (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['SnapshotInfo']]
+    """
+
+    return sync_detailed(
+        client=client,
+        sandbox_id=sandbox_id,
+        limit=limit,
+        next_token=next_token,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    sandbox_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+    next_token: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["SnapshotInfo"]]]:
+    """List all snapshots for the team
+
+    Args:
+        sandbox_id (Union[Unset, str]): Filter snapshots by source sandbox ID
+        limit (Union[Unset, int]):  Default: 100.
+        next_token (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['SnapshotInfo']]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        limit=limit,
+        next_token=next_token,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    sandbox_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+    next_token: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["SnapshotInfo"]]]:
+    """List all snapshots for the team
+
+    Args:
+        sandbox_id (Union[Unset, str]): Filter snapshots by source sandbox ID
+        limit (Union[Unset, int]):  Default: 100.
+        next_token (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['SnapshotInfo']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            sandbox_id=sandbox_id,
+            limit=limit,
+            next_token=next_token,
+        )
+    ).parsed

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

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

packages/python-sdk/e2b/api/client/api/tags/delete_templates_tags.py

@@ -0,0 +1,174 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.delete_template_tags_request import DeleteTemplateTagsRequest
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: DeleteTemplateTagsRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/templates/tags",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: DeleteTemplateTagsRequest,
+) -> Response[Union[Any, Error]]:
+    """Delete multiple tags from templates
+
+    Args:
+        body (DeleteTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: DeleteTemplateTagsRequest,
+) -> Optional[Union[Any, Error]]:
+    """Delete multiple tags from templates
+
+    Args:
+        body (DeleteTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: DeleteTemplateTagsRequest,
+) -> Response[Union[Any, Error]]:
+    """Delete multiple tags from templates
+
+    Args:
+        body (DeleteTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: DeleteTemplateTagsRequest,
+) -> Optional[Union[Any, Error]]:
+    """Delete multiple tags from templates
+
+    Args:
+        body (DeleteTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/tags/get_templates_template_id_tags.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_tag import TemplateTag
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/{template_id}/tags",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["TemplateTag"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = TemplateTag.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 403:
+        response_403 = Error.from_dict(response.json())
+
+        return response_403
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["TemplateTag"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, list["TemplateTag"]]]:
+    """List all tags for a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['TemplateTag']]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, list["TemplateTag"]]]:
+    """List all tags for a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['TemplateTag']]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, list["TemplateTag"]]]:
+    """List all tags for a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['TemplateTag']]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, list["TemplateTag"]]]:
+    """List all tags for a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['TemplateTag']]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/tags/post_templates_tags.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.assign_template_tags_request import AssignTemplateTagsRequest
+from ...models.assigned_template_tags import AssignedTemplateTags
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: AssignTemplateTagsRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/templates/tags",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[AssignedTemplateTags, Error]]:
+    if response.status_code == 201:
+        response_201 = AssignedTemplateTags.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[AssignedTemplateTags, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: AssignTemplateTagsRequest,
+) -> Response[Union[AssignedTemplateTags, Error]]:
+    """Assign tag(s) to a template build
+
+    Args:
+        body (AssignTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[AssignedTemplateTags, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: AssignTemplateTagsRequest,
+) -> Optional[Union[AssignedTemplateTags, Error]]:
+    """Assign tag(s) to a template build
+
+    Args:
+        body (AssignTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[AssignedTemplateTags, Error]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: AssignTemplateTagsRequest,
+) -> Response[Union[AssignedTemplateTags, Error]]:
+    """Assign tag(s) to a template build
+
+    Args:
+        body (AssignTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[AssignedTemplateTags, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: AssignTemplateTagsRequest,
+) -> Optional[Union[AssignedTemplateTags, Error]]:
+    """Assign tag(s) to a template build
+
+    Args:
+        body (AssignTemplateTagsRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[AssignedTemplateTags, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

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

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

packages/python-sdk/e2b/api/client/api/templates/delete_templates_template_id.py

@@ -0,0 +1,157 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/templates/{template_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Delete a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Delete a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Delete a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Delete a template
+
+    Args:
+        template_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template import Template
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    team_id: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["teamID"] = team_id
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/templates",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["Template"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = Template.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["Template"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    team_id: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["Template"]]]:
+    """List all templates
+
+    Args:
+        team_id (Union[Unset, str]): Identifier of the team
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['Template']]]
+    """
+
+    kwargs = _get_kwargs(
+        team_id=team_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    team_id: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["Template"]]]:
+    """List all templates
+
+    Args:
+        team_id (Union[Unset, str]): Identifier of the team
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['Template']]
+    """
+
+    return sync_detailed(
+        client=client,
+        team_id=team_id,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    team_id: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["Template"]]]:
+    """List all templates
+
+    Args:
+        team_id (Union[Unset, str]): Identifier of the team
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['Template']]]
+    """
+
+    kwargs = _get_kwargs(
+        team_id=team_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    team_id: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["Template"]]]:
+    """List all templates
+
+    Args:
+        team_id (Union[Unset, str]): Identifier of the team
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['Template']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            team_id=team_id,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates_aliases_alias.py

@@ -0,0 +1,167 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_alias_response import TemplateAliasResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    alias: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/aliases/{alias}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateAliasResponse]]:
+    if response.status_code == 200:
+        response_200 = TemplateAliasResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 403:
+        response_403 = Error.from_dict(response.json())
+
+        return response_403
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateAliasResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    alias: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, TemplateAliasResponse]]:
+    """Check if template with given alias exists
+
+    Args:
+        alias (str): Template alias
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateAliasResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        alias=alias,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    alias: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, TemplateAliasResponse]]:
+    """Check if template with given alias exists
+
+    Args:
+        alias (str): Template alias
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateAliasResponse]
+    """
+
+    return sync_detailed(
+        alias=alias,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    alias: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, TemplateAliasResponse]]:
+    """Check if template with given alias exists
+
+    Args:
+        alias (str): Template alias
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateAliasResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        alias=alias,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    alias: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, TemplateAliasResponse]]:
+    """Check if template with given alias exists
+
+    Args:
+        alias (str): Template alias
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateAliasResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            alias=alias,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates_template_id.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_with_builds import TemplateWithBuilds
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    template_id: str,
+    *,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["nextToken"] = next_token
+
+    params["limit"] = limit
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/{template_id}",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateWithBuilds]]:
+    if response.status_code == 200:
+        response_200 = TemplateWithBuilds.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateWithBuilds]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Response[Union[Error, TemplateWithBuilds]]:
+    """List all builds for a template
+
+    Args:
+        template_id (str):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateWithBuilds]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        next_token=next_token,
+        limit=limit,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Optional[Union[Error, TemplateWithBuilds]]:
+    """List all builds for a template
+
+    Args:
+        template_id (str):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateWithBuilds]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+        next_token=next_token,
+        limit=limit,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Response[Union[Error, TemplateWithBuilds]]:
+    """List all builds for a template
+
+    Args:
+        template_id (str):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateWithBuilds]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        next_token=next_token,
+        limit=limit,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    next_token: Union[Unset, str] = UNSET,
+    limit: Union[Unset, int] = 100,
+) -> Optional[Union[Error, TemplateWithBuilds]]:
+    """List all builds for a template
+
+    Args:
+        template_id (str):
+        next_token (Union[Unset, str]):
+        limit (Union[Unset, int]):  Default: 100.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateWithBuilds]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+            next_token=next_token,
+            limit=limit,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates_template_id_builds_build_id_logs.py

@@ -0,0 +1,272 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.log_level import LogLevel
+from ...models.logs_direction import LogsDirection
+from ...models.logs_source import LogsSource
+from ...models.template_build_logs_response import TemplateBuildLogsResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    template_id: str,
+    build_id: str,
+    *,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 100,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    source: Union[Unset, LogsSource] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["cursor"] = cursor
+
+    params["limit"] = limit
+
+    json_direction: Union[Unset, str] = UNSET
+    if not isinstance(direction, Unset):
+        json_direction = direction.value
+
+    params["direction"] = json_direction
+
+    json_level: Union[Unset, str] = UNSET
+    if not isinstance(level, Unset):
+        json_level = level.value
+
+    params["level"] = json_level
+
+    json_source: Union[Unset, str] = UNSET
+    if not isinstance(source, Unset):
+        json_source = source.value
+
+    params["source"] = json_source
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/{template_id}/builds/{build_id}/logs",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateBuildLogsResponse]]:
+    if response.status_code == 200:
+        response_200 = TemplateBuildLogsResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateBuildLogsResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 100,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    source: Union[Unset, LogsSource] = UNSET,
+) -> Response[Union[Error, TemplateBuildLogsResponse]]:
+    """Get template build logs
+
+    Args:
+        template_id (str):
+        build_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 100.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        source (Union[Unset, LogsSource]): Source of the logs that should be returned
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildLogsResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        source=source,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 100,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    source: Union[Unset, LogsSource] = UNSET,
+) -> Optional[Union[Error, TemplateBuildLogsResponse]]:
+    """Get template build logs
+
+    Args:
+        template_id (str):
+        build_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 100.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        source (Union[Unset, LogsSource]): Source of the logs that should be returned
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildLogsResponse]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        build_id=build_id,
+        client=client,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        source=source,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 100,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    source: Union[Unset, LogsSource] = UNSET,
+) -> Response[Union[Error, TemplateBuildLogsResponse]]:
+    """Get template build logs
+
+    Args:
+        template_id (str):
+        build_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 100.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        source (Union[Unset, LogsSource]): Source of the logs that should be returned
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildLogsResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        cursor=cursor,
+        limit=limit,
+        direction=direction,
+        level=level,
+        source=source,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    cursor: Union[Unset, int] = UNSET,
+    limit: Union[Unset, int] = 100,
+    direction: Union[Unset, LogsDirection] = UNSET,
+    level: Union[Unset, LogLevel] = UNSET,
+    source: Union[Unset, LogsSource] = UNSET,
+) -> Optional[Union[Error, TemplateBuildLogsResponse]]:
+    """Get template build logs
+
+    Args:
+        template_id (str):
+        build_id (str):
+        cursor (Union[Unset, int]):
+        limit (Union[Unset, int]):  Default: 100.
+        direction (Union[Unset, LogsDirection]): Direction of the logs that should be returned
+        level (Union[Unset, LogLevel]): State of the sandbox
+        source (Union[Unset, LogsSource]): Source of the logs that should be returned
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildLogsResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            build_id=build_id,
+            client=client,
+            cursor=cursor,
+            limit=limit,
+            direction=direction,
+            level=level,
+            source=source,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates_template_id_builds_build_id_status.py

@@ -0,0 +1,232 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.log_level import LogLevel
+from ...models.template_build_info import TemplateBuildInfo
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    template_id: str,
+    build_id: str,
+    *,
+    logs_offset: Union[Unset, int] = 0,
+    limit: Union[Unset, int] = 100,
+    level: Union[Unset, LogLevel] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["logsOffset"] = logs_offset
+
+    params["limit"] = limit
+
+    json_level: Union[Unset, str] = UNSET
+    if not isinstance(level, Unset):
+        json_level = level.value
+
+    params["level"] = json_level
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/{template_id}/builds/{build_id}/status",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateBuildInfo]]:
+    if response.status_code == 200:
+        response_200 = TemplateBuildInfo.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateBuildInfo]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    logs_offset: Union[Unset, int] = 0,
+    limit: Union[Unset, int] = 100,
+    level: Union[Unset, LogLevel] = UNSET,
+) -> Response[Union[Error, TemplateBuildInfo]]:
+    """Get template build info
+
+    Args:
+        template_id (str):
+        build_id (str):
+        logs_offset (Union[Unset, int]):  Default: 0.
+        limit (Union[Unset, int]):  Default: 100.
+        level (Union[Unset, LogLevel]): State of the sandbox
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildInfo]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        logs_offset=logs_offset,
+        limit=limit,
+        level=level,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    logs_offset: Union[Unset, int] = 0,
+    limit: Union[Unset, int] = 100,
+    level: Union[Unset, LogLevel] = UNSET,
+) -> Optional[Union[Error, TemplateBuildInfo]]:
+    """Get template build info
+
+    Args:
+        template_id (str):
+        build_id (str):
+        logs_offset (Union[Unset, int]):  Default: 0.
+        limit (Union[Unset, int]):  Default: 100.
+        level (Union[Unset, LogLevel]): State of the sandbox
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildInfo]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        build_id=build_id,
+        client=client,
+        logs_offset=logs_offset,
+        limit=limit,
+        level=level,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    logs_offset: Union[Unset, int] = 0,
+    limit: Union[Unset, int] = 100,
+    level: Union[Unset, LogLevel] = UNSET,
+) -> Response[Union[Error, TemplateBuildInfo]]:
+    """Get template build info
+
+    Args:
+        template_id (str):
+        build_id (str):
+        logs_offset (Union[Unset, int]):  Default: 0.
+        limit (Union[Unset, int]):  Default: 100.
+        level (Union[Unset, LogLevel]): State of the sandbox
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildInfo]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        logs_offset=logs_offset,
+        limit=limit,
+        level=level,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    logs_offset: Union[Unset, int] = 0,
+    limit: Union[Unset, int] = 100,
+    level: Union[Unset, LogLevel] = UNSET,
+) -> Optional[Union[Error, TemplateBuildInfo]]:
+    """Get template build info
+
+    Args:
+        template_id (str):
+        build_id (str):
+        logs_offset (Union[Unset, int]):  Default: 0.
+        limit (Union[Unset, int]):  Default: 100.
+        level (Union[Unset, LogLevel]): State of the sandbox
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildInfo]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            build_id=build_id,
+            client=client,
+            logs_offset=logs_offset,
+            limit=limit,
+            level=level,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/get_templates_template_id_files_hash.py

@@ -0,0 +1,180 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_file_upload import TemplateBuildFileUpload
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    hash_: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/templates/{template_id}/files/{hash_}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateBuildFileUpload]]:
+    if response.status_code == 201:
+        response_201 = TemplateBuildFileUpload.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateBuildFileUpload]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    hash_: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, TemplateBuildFileUpload]]:
+    """Get an upload link for a tar file containing build layer files
+
+    Args:
+        template_id (str):
+        hash_ (str): Hash of the files
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildFileUpload]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        hash_=hash_,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    hash_: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, TemplateBuildFileUpload]]:
+    """Get an upload link for a tar file containing build layer files
+
+    Args:
+        template_id (str):
+        hash_ (str): Hash of the files
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildFileUpload]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        hash_=hash_,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    hash_: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, TemplateBuildFileUpload]]:
+    """Get an upload link for a tar file containing build layer files
+
+    Args:
+        template_id (str):
+        hash_ (str): Hash of the files
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateBuildFileUpload]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        hash_=hash_,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    hash_: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, TemplateBuildFileUpload]]:
+    """Get an upload link for a tar file containing build layer files
+
+    Args:
+        template_id (str):
+        hash_ (str): Hash of the files
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateBuildFileUpload]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            hash_=hash_,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/patch_templates_template_id.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_update_request import TemplateUpdateRequest
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    *,
+    body: TemplateUpdateRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "patch",
+        "url": f"/templates/{template_id}",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 200:
+        response_200 = cast(Any, None)
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Response[Union[Any, Error]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Optional[Union[Any, Error]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Response[Union[Any, Error]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Optional[Union[Any, Error]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/patch_v_2_templates_template_id.py

@@ -0,0 +1,185 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_update_request import TemplateUpdateRequest
+from ...models.template_update_response import TemplateUpdateResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    *,
+    body: TemplateUpdateRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "patch",
+        "url": f"/v2/templates/{template_id}",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateUpdateResponse]]:
+    if response.status_code == 200:
+        response_200 = TemplateUpdateResponse.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateUpdateResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Response[Union[Error, TemplateUpdateResponse]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateUpdateResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Optional[Union[Error, TemplateUpdateResponse]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateUpdateResponse]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Response[Union[Error, TemplateUpdateResponse]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateUpdateResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateUpdateRequest,
+) -> Optional[Union[Error, TemplateUpdateResponse]]:
+    """Update template
+
+    Args:
+        template_id (str):
+        body (TemplateUpdateRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateUpdateResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_templates.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_request import TemplateBuildRequest
+from ...models.template_legacy import TemplateLegacy
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: TemplateBuildRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/templates",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateLegacy]]:
+    if response.status_code == 202:
+        response_202 = TemplateLegacy.from_dict(response.json())
+
+        return response_202
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateLegacy]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_templates_template_id.py

@@ -0,0 +1,181 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_request import TemplateBuildRequest
+from ...models.template_legacy import TemplateLegacy
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    *,
+    body: TemplateBuildRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/templates/{template_id}",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateLegacy]]:
+    if response.status_code == 202:
+        response_202 = TemplateLegacy.from_dict(response.json())
+
+        return response_202
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateLegacy]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Rebuild an template
+
+    Args:
+        template_id (str):
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Rebuild an template
+
+    Args:
+        template_id (str):
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Rebuild an template
+
+    Args:
+        template_id (str):
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequest,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Rebuild an template
+
+    Args:
+        template_id (str):
+        body (TemplateBuildRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_templates_template_id_builds_build_id.py

@@ -0,0 +1,170 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    build_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/templates/{template_id}/builds/{build_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 202:
+        response_202 = cast(Any, None)
+        return response_202
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        build_id=build_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            build_id=build_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_v2_templates.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_request_v2 import TemplateBuildRequestV2
+from ...models.template_legacy import TemplateLegacy
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: TemplateBuildRequestV2,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v2/templates",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateLegacy]]:
+    if response.status_code == 202:
+        response_202 = TemplateLegacy.from_dict(response.json())
+
+        return response_202
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateLegacy]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV2,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV2,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV2,
+) -> Response[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateLegacy]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV2,
+) -> Optional[Union[Error, TemplateLegacy]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateLegacy]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_v3_templates.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_request_v3 import TemplateBuildRequestV3
+from ...models.template_request_response_v3 import TemplateRequestResponseV3
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: TemplateBuildRequestV3,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v3/templates",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, TemplateRequestResponseV3]]:
+    if response.status_code == 202:
+        response_202 = TemplateRequestResponseV3.from_dict(response.json())
+
+        return response_202
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 403:
+        response_403 = Error.from_dict(response.json())
+
+        return response_403
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, TemplateRequestResponseV3]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV3,
+) -> Response[Union[Error, TemplateRequestResponseV3]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV3):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateRequestResponseV3]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV3,
+) -> Optional[Union[Error, TemplateRequestResponseV3]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV3):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateRequestResponseV3]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV3,
+) -> Response[Union[Error, TemplateRequestResponseV3]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV3):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, TemplateRequestResponseV3]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildRequestV3,
+) -> Optional[Union[Error, TemplateRequestResponseV3]]:
+    """Create a new template
+
+    Args:
+        body (TemplateBuildRequestV3):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, TemplateRequestResponseV3]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/templates/post_v_2_templates_template_id_builds_build_id.py

@@ -0,0 +1,192 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.template_build_start_v2 import TemplateBuildStartV2
+from ...types import Response
+
+
+def _get_kwargs(
+    template_id: str,
+    build_id: str,
+    *,
+    body: TemplateBuildStartV2,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/v2/templates/{template_id}/builds/{build_id}",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 202:
+        response_202 = cast(Any, None)
+        return response_202
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildStartV2,
+) -> Response[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+        body (TemplateBuildStartV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildStartV2,
+) -> Optional[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+        body (TemplateBuildStartV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        template_id=template_id,
+        build_id=build_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildStartV2,
+) -> Response[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+        body (TemplateBuildStartV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        template_id=template_id,
+        build_id=build_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    template_id: str,
+    build_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: TemplateBuildStartV2,
+) -> Optional[Union[Any, Error]]:
+    """Start the build
+
+    Args:
+        template_id (str):
+        build_id (str):
+        body (TemplateBuildStartV2):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            template_id=template_id,
+            build_id=build_id,
+            client=client,
+            body=body,
+        )
+    ).parsed

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

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

packages/python-sdk/e2b/api/client/api/volumes/delete_volumes_volume_id.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    volume_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/volumes/{volume_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Delete a team volume
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        volume_id=volume_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Delete a team volume
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        volume_id=volume_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Delete a team volume
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        volume_id=volume_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Delete a team volume
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            volume_id=volume_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/volumes/get_volumes.py

@@ -0,0 +1,140 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.volume import Volume
+from ...types import Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/volumes",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["Volume"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = Volume.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["Volume"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, list["Volume"]]]:
+    """List all team volumes
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['Volume']]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, list["Volume"]]]:
+    """List all team volumes
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['Volume']]
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, list["Volume"]]]:
+    """List all team volumes
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['Volume']]]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, list["Volume"]]]:
+    """List all team volumes
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['Volume']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/volumes/get_volumes_volume_id.py

@@ -0,0 +1,163 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.volume_and_token import VolumeAndToken
+from ...types import Response
+
+
+def _get_kwargs(
+    volume_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/volumes/{volume_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, VolumeAndToken]]:
+    if response.status_code == 200:
+        response_200 = VolumeAndToken.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, VolumeAndToken]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, VolumeAndToken]]:
+    """Get team volume info
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, VolumeAndToken]]
+    """
+
+    kwargs = _get_kwargs(
+        volume_id=volume_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, VolumeAndToken]]:
+    """Get team volume info
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, VolumeAndToken]
+    """
+
+    return sync_detailed(
+        volume_id=volume_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Error, VolumeAndToken]]:
+    """Get team volume info
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, VolumeAndToken]]
+    """
+
+    kwargs = _get_kwargs(
+        volume_id=volume_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    volume_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Error, VolumeAndToken]]:
+    """Get team volume info
+
+    Args:
+        volume_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, VolumeAndToken]
+    """
+
+    return (
+        await asyncio_detailed(
+            volume_id=volume_id,
+            client=client,
+        )
+    ).parsed

packages/python-sdk/e2b/api/client/api/volumes/post_volumes.py

@@ -0,0 +1,172 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.new_volume import NewVolume
+from ...models.volume_and_token import VolumeAndToken
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: NewVolume,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/volumes",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, VolumeAndToken]]:
+    if response.status_code == 201:
+        response_201 = VolumeAndToken.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, VolumeAndToken]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: NewVolume,
+) -> Response[Union[Error, VolumeAndToken]]:
+    """Create a new team volume
+
+    Args:
+        body (NewVolume):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, VolumeAndToken]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: NewVolume,
+) -> Optional[Union[Error, VolumeAndToken]]:
+    """Create a new team volume
+
+    Args:
+        body (NewVolume):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, VolumeAndToken]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: NewVolume,
+) -> Response[Union[Error, VolumeAndToken]]:
+    """Create a new team volume
+
+    Args:
+        body (NewVolume):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, VolumeAndToken]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: NewVolume,
+) -> Optional[Union[Error, VolumeAndToken]]:
+    """Create a new team volume
+
+    Args:
+        body (NewVolume):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, VolumeAndToken]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

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

@@ -0,0 +1,286 @@
+import ssl
+from typing import Any, Optional, Union
+
+import httpx
+from attrs import define, evolve, field
+
+
+@define
+class Client:
+    """A class for keeping track of data related to the API
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: Optional[httpx.Timeout] = field(
+        default=None, kw_only=True, alias="timeout"
+    )
+    _verify_ssl: Union[str, bool, ssl.SSLContext] = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: Optional[httpx.Client] = field(default=None, init=False)
+    _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+    def with_headers(self, headers: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "Client":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "Client":
+        """Get a new client matching this one with a new timeout (in seconds)"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "Client":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "Client":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "Client":
+        """Manually the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "Client":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)
+
+
+@define
+class AuthenticatedClient:
+    """A Client which has been authenticated for use on secured endpoints
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+        token: The token to use for authentication
+        prefix: The prefix to use for the Authorization header
+        auth_header_name: The name of the Authorization header
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: Optional[httpx.Timeout] = field(
+        default=None, kw_only=True, alias="timeout"
+    )
+    _verify_ssl: Union[str, bool, ssl.SSLContext] = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: Optional[httpx.Client] = field(default=None, init=False)
+    _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+    token: str
+    prefix: str = "Bearer"
+    auth_header_name: str = "Authorization"
+
+    def with_headers(self, headers: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> "AuthenticatedClient":
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> "AuthenticatedClient":
+        """Get a new client matching this one with a new timeout (in seconds)"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> "AuthenticatedClient":
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(
+        self, async_client: httpx.AsyncClient
+    ) -> "AuthenticatedClient":
+        """Manually the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> "AuthenticatedClient":
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)

packages/python-sdk/e2b/api/client/errors.py

@@ -0,0 +1,16 @@
+"""Contains shared errors types that can be raised from API functions"""
+
+
+class UnexpectedStatus(Exception):
+    """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True"""
+
+    def __init__(self, status_code: int, content: bytes):
+        self.status_code = status_code
+        self.content = content
+
+        super().__init__(
+            f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}"
+        )
+
+
+__all__ = ["UnexpectedStatus"]

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

@@ -0,0 +1,185 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from .admin_build_cancel_result import AdminBuildCancelResult
+from .admin_sandbox_kill_result import AdminSandboxKillResult
+from .assign_template_tags_request import AssignTemplateTagsRequest
+from .assigned_template_tags import AssignedTemplateTags
+from .aws_registry import AWSRegistry
+from .aws_registry_type import AWSRegistryType
+from .build_log_entry import BuildLogEntry
+from .build_status_reason import BuildStatusReason
+from .connect_sandbox import ConnectSandbox
+from .created_access_token import CreatedAccessToken
+from .created_team_api_key import CreatedTeamAPIKey
+from .delete_template_tags_request import DeleteTemplateTagsRequest
+from .disk_metrics import DiskMetrics
+from .error import Error
+from .gcp_registry import GCPRegistry
+from .gcp_registry_type import GCPRegistryType
+from .general_registry import GeneralRegistry
+from .general_registry_type import GeneralRegistryType
+from .identifier_masking_details import IdentifierMaskingDetails
+from .listed_sandbox import ListedSandbox
+from .log_level import LogLevel
+from .logs_direction import LogsDirection
+from .logs_source import LogsSource
+from .machine_info import MachineInfo
+from .max_team_metric import MaxTeamMetric
+from .mcp_type_0 import McpType0
+from .new_access_token import NewAccessToken
+from .new_sandbox import NewSandbox
+from .new_team_api_key import NewTeamAPIKey
+from .new_volume import NewVolume
+from .node import Node
+from .node_detail import NodeDetail
+from .node_metrics import NodeMetrics
+from .node_status import NodeStatus
+from .node_status_change import NodeStatusChange
+from .post_sandboxes_sandbox_id_refreshes_body import (
+    PostSandboxesSandboxIDRefreshesBody,
+)
+from .post_sandboxes_sandbox_id_snapshots_body import (
+    PostSandboxesSandboxIDSnapshotsBody,
+)
+from .post_sandboxes_sandbox_id_timeout_body import PostSandboxesSandboxIDTimeoutBody
+from .resumed_sandbox import ResumedSandbox
+from .sandbox import Sandbox
+from .sandbox_auto_resume_config import SandboxAutoResumeConfig
+from .sandbox_detail import SandboxDetail
+from .sandbox_lifecycle import SandboxLifecycle
+from .sandbox_log import SandboxLog
+from .sandbox_log_entry import SandboxLogEntry
+from .sandbox_log_entry_fields import SandboxLogEntryFields
+from .sandbox_logs import SandboxLogs
+from .sandbox_logs_v2_response import SandboxLogsV2Response
+from .sandbox_metric import SandboxMetric
+from .sandbox_network_config import SandboxNetworkConfig
+from .sandbox_network_config_rules import SandboxNetworkConfigRules
+from .sandbox_network_rule import SandboxNetworkRule
+from .sandbox_network_transform import SandboxNetworkTransform
+from .sandbox_network_transform_headers import SandboxNetworkTransformHeaders
+from .sandbox_network_update_config import SandboxNetworkUpdateConfig
+from .sandbox_network_update_config_rules import SandboxNetworkUpdateConfigRules
+from .sandbox_on_timeout import SandboxOnTimeout
+from .sandbox_pause_request import SandboxPauseRequest
+from .sandbox_state import SandboxState
+from .sandbox_volume_mount import SandboxVolumeMount
+from .sandboxes_with_metrics import SandboxesWithMetrics
+from .snapshot_info import SnapshotInfo
+from .team import Team
+from .team_api_key import TeamAPIKey
+from .team_metric import TeamMetric
+from .team_user import TeamUser
+from .template import Template
+from .template_alias_response import TemplateAliasResponse
+from .template_build import TemplateBuild
+from .template_build_file_upload import TemplateBuildFileUpload
+from .template_build_info import TemplateBuildInfo
+from .template_build_logs_response import TemplateBuildLogsResponse
+from .template_build_request import TemplateBuildRequest
+from .template_build_request_v2 import TemplateBuildRequestV2
+from .template_build_request_v3 import TemplateBuildRequestV3
+from .template_build_start_v2 import TemplateBuildStartV2
+from .template_build_status import TemplateBuildStatus
+from .template_legacy import TemplateLegacy
+from .template_request_response_v3 import TemplateRequestResponseV3
+from .template_step import TemplateStep
+from .template_tag import TemplateTag
+from .template_update_request import TemplateUpdateRequest
+from .template_update_response import TemplateUpdateResponse
+from .template_with_builds import TemplateWithBuilds
+from .update_team_api_key import UpdateTeamAPIKey
+from .volume import Volume
+from .volume_and_token import VolumeAndToken
+from .volume_token import VolumeToken
+
+__all__ = (
+    "AdminBuildCancelResult",
+    "AdminSandboxKillResult",
+    "AssignedTemplateTags",
+    "AssignTemplateTagsRequest",
+    "AWSRegistry",
+    "AWSRegistryType",
+    "BuildLogEntry",
+    "BuildStatusReason",
+    "ConnectSandbox",
+    "CreatedAccessToken",
+    "CreatedTeamAPIKey",
+    "DeleteTemplateTagsRequest",
+    "DiskMetrics",
+    "Error",
+    "GCPRegistry",
+    "GCPRegistryType",
+    "GeneralRegistry",
+    "GeneralRegistryType",
+    "IdentifierMaskingDetails",
+    "ListedSandbox",
+    "LogLevel",
+    "LogsDirection",
+    "LogsSource",
+    "MachineInfo",
+    "MaxTeamMetric",
+    "McpType0",
+    "NewAccessToken",
+    "NewSandbox",
+    "NewTeamAPIKey",
+    "NewVolume",
+    "Node",
+    "NodeDetail",
+    "NodeMetrics",
+    "NodeStatus",
+    "NodeStatusChange",
+    "PostSandboxesSandboxIDRefreshesBody",
+    "PostSandboxesSandboxIDSnapshotsBody",
+    "PostSandboxesSandboxIDTimeoutBody",
+    "ResumedSandbox",
+    "Sandbox",
+    "SandboxAutoResumeConfig",
+    "SandboxDetail",
+    "SandboxesWithMetrics",
+    "SandboxLifecycle",
+    "SandboxLog",
+    "SandboxLogEntry",
+    "SandboxLogEntryFields",
+    "SandboxLogs",
+    "SandboxLogsV2Response",
+    "SandboxMetric",
+    "SandboxNetworkConfig",
+    "SandboxNetworkConfigRules",
+    "SandboxNetworkRule",
+    "SandboxNetworkTransform",
+    "SandboxNetworkTransformHeaders",
+    "SandboxNetworkUpdateConfig",
+    "SandboxNetworkUpdateConfigRules",
+    "SandboxOnTimeout",
+    "SandboxPauseRequest",
+    "SandboxState",
+    "SandboxVolumeMount",
+    "SnapshotInfo",
+    "Team",
+    "TeamAPIKey",
+    "TeamMetric",
+    "TeamUser",
+    "Template",
+    "TemplateAliasResponse",
+    "TemplateBuild",
+    "TemplateBuildFileUpload",
+    "TemplateBuildInfo",
+    "TemplateBuildLogsResponse",
+    "TemplateBuildRequest",
+    "TemplateBuildRequestV2",
+    "TemplateBuildRequestV3",
+    "TemplateBuildStartV2",
+    "TemplateBuildStatus",
+    "TemplateLegacy",
+    "TemplateRequestResponseV3",
+    "TemplateStep",
+    "TemplateTag",
+    "TemplateUpdateRequest",
+    "TemplateUpdateResponse",
+    "TemplateWithBuilds",
+    "UpdateTeamAPIKey",
+    "Volume",
+    "VolumeAndToken",
+    "VolumeToken",
+)

packages/python-sdk/e2b/api/client/models/admin_build_cancel_result.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AdminBuildCancelResult")
+
+
+@_attrs_define
+class AdminBuildCancelResult:
+    """
+    Attributes:
+        cancelled_count (int): Number of builds successfully cancelled
+        failed_count (int): Number of builds that failed to cancel
+    """
+
+    cancelled_count: int
+    failed_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cancelled_count = self.cancelled_count
+
+        failed_count = self.failed_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cancelledCount": cancelled_count,
+                "failedCount": failed_count,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cancelled_count = d.pop("cancelledCount")
+
+        failed_count = d.pop("failedCount")
+
+        admin_build_cancel_result = cls(
+            cancelled_count=cancelled_count,
+            failed_count=failed_count,
+        )
+
+        admin_build_cancel_result.additional_properties = d
+        return admin_build_cancel_result
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/admin_sandbox_kill_result.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AdminSandboxKillResult")
+
+
+@_attrs_define
+class AdminSandboxKillResult:
+    """
+    Attributes:
+        failed_count (int): Number of sandboxes that failed to kill
+        killed_count (int): Number of sandboxes successfully killed
+    """
+
+    failed_count: int
+    killed_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        failed_count = self.failed_count
+
+        killed_count = self.killed_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "failedCount": failed_count,
+                "killedCount": killed_count,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        failed_count = d.pop("failedCount")
+
+        killed_count = d.pop("killedCount")
+
+        admin_sandbox_kill_result = cls(
+            failed_count=failed_count,
+            killed_count=killed_count,
+        )
+
+        admin_sandbox_kill_result.additional_properties = d
+        return admin_sandbox_kill_result
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/assign_template_tags_request.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AssignTemplateTagsRequest")
+
+
+@_attrs_define
+class AssignTemplateTagsRequest:
+    """
+    Attributes:
+        tags (list[str]): Tags to assign to the template
+        target (str): Target template in "name:tag" format
+    """
+
+    tags: list[str]
+    target: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tags = self.tags
+
+        target = self.target
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tags": tags,
+                "target": target,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        tags = cast(list[str], d.pop("tags"))
+
+        target = d.pop("target")
+
+        assign_template_tags_request = cls(
+            tags=tags,
+            target=target,
+        )
+
+        assign_template_tags_request.additional_properties = d
+        return assign_template_tags_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/assigned_template_tags.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AssignedTemplateTags")
+
+
+@_attrs_define
+class AssignedTemplateTags:
+    """
+    Attributes:
+        build_id (UUID): Identifier of the build associated with these tags
+        tags (list[str]): Assigned tags of the template
+    """
+
+    build_id: UUID
+    tags: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        build_id = str(self.build_id)
+
+        tags = self.tags
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "buildID": build_id,
+                "tags": tags,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        build_id = UUID(d.pop("buildID"))
+
+        tags = cast(list[str], d.pop("tags"))
+
+        assigned_template_tags = cls(
+            build_id=build_id,
+            tags=tags,
+        )
+
+        assigned_template_tags.additional_properties = d
+        return assigned_template_tags
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/aws_registry.py

@@ -0,0 +1,85 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.aws_registry_type import AWSRegistryType
+
+T = TypeVar("T", bound="AWSRegistry")
+
+
+@_attrs_define
+class AWSRegistry:
+    """
+    Attributes:
+        aws_access_key_id (str): AWS Access Key ID for ECR authentication
+        aws_region (str): AWS Region where the ECR registry is located
+        aws_secret_access_key (str): AWS Secret Access Key for ECR authentication
+        type_ (AWSRegistryType): Type of registry authentication
+    """
+
+    aws_access_key_id: str
+    aws_region: str
+    aws_secret_access_key: str
+    type_: AWSRegistryType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        aws_access_key_id = self.aws_access_key_id
+
+        aws_region = self.aws_region
+
+        aws_secret_access_key = self.aws_secret_access_key
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "awsAccessKeyId": aws_access_key_id,
+                "awsRegion": aws_region,
+                "awsSecretAccessKey": aws_secret_access_key,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        aws_access_key_id = d.pop("awsAccessKeyId")
+
+        aws_region = d.pop("awsRegion")
+
+        aws_secret_access_key = d.pop("awsSecretAccessKey")
+
+        type_ = AWSRegistryType(d.pop("type"))
+
+        aws_registry = cls(
+            aws_access_key_id=aws_access_key_id,
+            aws_region=aws_region,
+            aws_secret_access_key=aws_secret_access_key,
+            type_=type_,
+        )
+
+        aws_registry.additional_properties = d
+        return aws_registry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/aws_registry_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class AWSRegistryType(str, Enum):
+    AWS = "aws"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/build_log_entry.py

@@ -0,0 +1,89 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.log_level import LogLevel
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BuildLogEntry")
+
+
+@_attrs_define
+class BuildLogEntry:
+    """
+    Attributes:
+        level (LogLevel): State of the sandbox
+        message (str): Log message content
+        timestamp (datetime.datetime): Timestamp of the log entry
+        step (Union[Unset, str]): Step in the build process related to the log entry
+    """
+
+    level: LogLevel
+    message: str
+    timestamp: datetime.datetime
+    step: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        level = self.level.value
+
+        message = self.message
+
+        timestamp = self.timestamp.isoformat()
+
+        step = self.step
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "level": level,
+                "message": message,
+                "timestamp": timestamp,
+            }
+        )
+        if step is not UNSET:
+            field_dict["step"] = step
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        level = LogLevel(d.pop("level"))
+
+        message = d.pop("message")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        step = d.pop("step", UNSET)
+
+        build_log_entry = cls(
+            level=level,
+            message=message,
+            timestamp=timestamp,
+            step=step,
+        )
+
+        build_log_entry.additional_properties = d
+        return build_log_entry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/build_status_reason.py

@@ -0,0 +1,95 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.build_log_entry import BuildLogEntry
+
+
+T = TypeVar("T", bound="BuildStatusReason")
+
+
+@_attrs_define
+class BuildStatusReason:
+    """
+    Attributes:
+        message (str): Message with the status reason, currently reporting only for error status
+        log_entries (Union[Unset, list['BuildLogEntry']]): Log entries related to the status reason
+        step (Union[Unset, str]): Step that failed
+    """
+
+    message: str
+    log_entries: Union[Unset, list["BuildLogEntry"]] = UNSET
+    step: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        log_entries: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.log_entries, Unset):
+            log_entries = []
+            for log_entries_item_data in self.log_entries:
+                log_entries_item = log_entries_item_data.to_dict()
+                log_entries.append(log_entries_item)
+
+        step = self.step
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "message": message,
+            }
+        )
+        if log_entries is not UNSET:
+            field_dict["logEntries"] = log_entries
+        if step is not UNSET:
+            field_dict["step"] = step
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.build_log_entry import BuildLogEntry
+
+        d = dict(src_dict)
+        message = d.pop("message")
+
+        log_entries = []
+        _log_entries = d.pop("logEntries", UNSET)
+        for log_entries_item_data in _log_entries or []:
+            log_entries_item = BuildLogEntry.from_dict(log_entries_item_data)
+
+            log_entries.append(log_entries_item)
+
+        step = d.pop("step", UNSET)
+
+        build_status_reason = cls(
+            message=message,
+            log_entries=log_entries,
+            step=step,
+        )
+
+        build_status_reason.additional_properties = d
+        return build_status_reason
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/connect_sandbox.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ConnectSandbox")
+
+
+@_attrs_define
+class ConnectSandbox:
+    """
+    Attributes:
+        timeout (int): Timeout in seconds from the current time after which the sandbox should expire
+    """
+
+    timeout: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timeout": timeout,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        timeout = d.pop("timeout")
+
+        connect_sandbox = cls(
+            timeout=timeout,
+        )
+
+        connect_sandbox.additional_properties = d
+        return connect_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/created_access_token.py

@@ -0,0 +1,100 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.identifier_masking_details import IdentifierMaskingDetails
+
+
+T = TypeVar("T", bound="CreatedAccessToken")
+
+
+@_attrs_define
+class CreatedAccessToken:
+    """
+    Attributes:
+        created_at (datetime.datetime): Timestamp of access token creation
+        id (UUID): Identifier of the access token
+        mask (IdentifierMaskingDetails):
+        name (str): Name of the access token
+        token (str): The fully created access token
+    """
+
+    created_at: datetime.datetime
+    id: UUID
+    mask: "IdentifierMaskingDetails"
+    name: str
+    token: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        id = str(self.id)
+
+        mask = self.mask.to_dict()
+
+        name = self.name
+
+        token = self.token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "id": id,
+                "mask": mask,
+                "name": name,
+                "token": token,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.identifier_masking_details import IdentifierMaskingDetails
+
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        id = UUID(d.pop("id"))
+
+        mask = IdentifierMaskingDetails.from_dict(d.pop("mask"))
+
+        name = d.pop("name")
+
+        token = d.pop("token")
+
+        created_access_token = cls(
+            created_at=created_at,
+            id=id,
+            mask=mask,
+            name=name,
+            token=token,
+        )
+
+        created_access_token.additional_properties = d
+        return created_access_token
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/created_team_api_key.py

@@ -0,0 +1,166 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.identifier_masking_details import IdentifierMaskingDetails
+    from ..models.team_user import TeamUser
+
+
+T = TypeVar("T", bound="CreatedTeamAPIKey")
+
+
+@_attrs_define
+class CreatedTeamAPIKey:
+    """
+    Attributes:
+        created_at (datetime.datetime): Timestamp of API key creation
+        id (UUID): Identifier of the API key
+        key (str): Raw value of the API key
+        mask (IdentifierMaskingDetails):
+        name (str): Name of the API key
+        created_by (Union['TeamUser', None, Unset]):
+        last_used (Union[None, Unset, datetime.datetime]): Last time this API key was used
+    """
+
+    created_at: datetime.datetime
+    id: UUID
+    key: str
+    mask: "IdentifierMaskingDetails"
+    name: str
+    created_by: Union["TeamUser", None, Unset] = UNSET
+    last_used: Union[None, Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.team_user import TeamUser
+
+        created_at = self.created_at.isoformat()
+
+        id = str(self.id)
+
+        key = self.key
+
+        mask = self.mask.to_dict()
+
+        name = self.name
+
+        created_by: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.created_by, Unset):
+            created_by = UNSET
+        elif isinstance(self.created_by, TeamUser):
+            created_by = self.created_by.to_dict()
+        else:
+            created_by = self.created_by
+
+        last_used: Union[None, Unset, str]
+        if isinstance(self.last_used, Unset):
+            last_used = UNSET
+        elif isinstance(self.last_used, datetime.datetime):
+            last_used = self.last_used.isoformat()
+        else:
+            last_used = self.last_used
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "id": id,
+                "key": key,
+                "mask": mask,
+                "name": name,
+            }
+        )
+        if created_by is not UNSET:
+            field_dict["createdBy"] = created_by
+        if last_used is not UNSET:
+            field_dict["lastUsed"] = last_used
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.identifier_masking_details import IdentifierMaskingDetails
+        from ..models.team_user import TeamUser
+
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        id = UUID(d.pop("id"))
+
+        key = d.pop("key")
+
+        mask = IdentifierMaskingDetails.from_dict(d.pop("mask"))
+
+        name = d.pop("name")
+
+        def _parse_created_by(data: object) -> Union["TeamUser", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                created_by_type_1 = TeamUser.from_dict(data)
+
+                return created_by_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union["TeamUser", None, Unset], data)
+
+        created_by = _parse_created_by(d.pop("createdBy", UNSET))
+
+        def _parse_last_used(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_used_type_0 = isoparse(data)
+
+                return last_used_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        last_used = _parse_last_used(d.pop("lastUsed", UNSET))
+
+        created_team_api_key = cls(
+            created_at=created_at,
+            id=id,
+            key=key,
+            mask=mask,
+            name=name,
+            created_by=created_by,
+            last_used=last_used,
+        )
+
+        created_team_api_key.additional_properties = d
+        return created_team_api_key
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/delete_template_tags_request.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DeleteTemplateTagsRequest")
+
+
+@_attrs_define
+class DeleteTemplateTagsRequest:
+    """
+    Attributes:
+        name (str): Name of the template
+        tags (list[str]): Tags to delete
+    """
+
+    name: str
+    tags: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        tags = self.tags
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "tags": tags,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        tags = cast(list[str], d.pop("tags"))
+
+        delete_template_tags_request = cls(
+            name=name,
+            tags=tags,
+        )
+
+        delete_template_tags_request.additional_properties = d
+        return delete_template_tags_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/disk_metrics.py

@@ -0,0 +1,91 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DiskMetrics")
+
+
+@_attrs_define
+class DiskMetrics:
+    """
+    Attributes:
+        device (str): Device name
+        filesystem_type (str): Filesystem type (e.g., ext4, xfs)
+        mount_point (str): Mount point of the disk
+        total_bytes (int): Total space in bytes
+        used_bytes (int): Used space in bytes
+    """
+
+    device: str
+    filesystem_type: str
+    mount_point: str
+    total_bytes: int
+    used_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        device = self.device
+
+        filesystem_type = self.filesystem_type
+
+        mount_point = self.mount_point
+
+        total_bytes = self.total_bytes
+
+        used_bytes = self.used_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "device": device,
+                "filesystemType": filesystem_type,
+                "mountPoint": mount_point,
+                "totalBytes": total_bytes,
+                "usedBytes": used_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        device = d.pop("device")
+
+        filesystem_type = d.pop("filesystemType")
+
+        mount_point = d.pop("mountPoint")
+
+        total_bytes = d.pop("totalBytes")
+
+        used_bytes = d.pop("usedBytes")
+
+        disk_metrics = cls(
+            device=device,
+            filesystem_type=filesystem_type,
+            mount_point=mount_point,
+            total_bytes=total_bytes,
+            used_bytes=used_bytes,
+        )
+
+        disk_metrics.additional_properties = d
+        return disk_metrics
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/error.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """
+    Attributes:
+        code (int): Error code
+        message (str): Error
+    """
+
+    code: int
+    message: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        message = d.pop("message")
+
+        error = cls(
+            code=code,
+            message=message,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/gcp_registry.py

@@ -0,0 +1,69 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.gcp_registry_type import GCPRegistryType
+
+T = TypeVar("T", bound="GCPRegistry")
+
+
+@_attrs_define
+class GCPRegistry:
+    """
+    Attributes:
+        service_account_json (str): Service Account JSON for GCP authentication
+        type_ (GCPRegistryType): Type of registry authentication
+    """
+
+    service_account_json: str
+    type_: GCPRegistryType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        service_account_json = self.service_account_json
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "serviceAccountJson": service_account_json,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        service_account_json = d.pop("serviceAccountJson")
+
+        type_ = GCPRegistryType(d.pop("type"))
+
+        gcp_registry = cls(
+            service_account_json=service_account_json,
+            type_=type_,
+        )
+
+        gcp_registry.additional_properties = d
+        return gcp_registry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/gcp_registry_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class GCPRegistryType(str, Enum):
+    GCP = "gcp"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/general_registry.py

@@ -0,0 +1,77 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.general_registry_type import GeneralRegistryType
+
+T = TypeVar("T", bound="GeneralRegistry")
+
+
+@_attrs_define
+class GeneralRegistry:
+    """
+    Attributes:
+        password (str): Password to use for the registry
+        type_ (GeneralRegistryType): Type of registry authentication
+        username (str): Username to use for the registry
+    """
+
+    password: str
+    type_: GeneralRegistryType
+    username: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        password = self.password
+
+        type_ = self.type_.value
+
+        username = self.username
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "password": password,
+                "type": type_,
+                "username": username,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        password = d.pop("password")
+
+        type_ = GeneralRegistryType(d.pop("type"))
+
+        username = d.pop("username")
+
+        general_registry = cls(
+            password=password,
+            type_=type_,
+            username=username,
+        )
+
+        general_registry.additional_properties = d
+        return general_registry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/general_registry_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class GeneralRegistryType(str, Enum):
+    REGISTRY = "registry"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/identifier_masking_details.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="IdentifierMaskingDetails")
+
+
+@_attrs_define
+class IdentifierMaskingDetails:
+    """
+    Attributes:
+        masked_value_prefix (str): Prefix used in masked version of the token or key
+        masked_value_suffix (str): Suffix used in masked version of the token or key
+        prefix (str): Prefix that identifies the token or key type
+        value_length (int): Length of the token or key
+    """
+
+    masked_value_prefix: str
+    masked_value_suffix: str
+    prefix: str
+    value_length: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        masked_value_prefix = self.masked_value_prefix
+
+        masked_value_suffix = self.masked_value_suffix
+
+        prefix = self.prefix
+
+        value_length = self.value_length
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "maskedValuePrefix": masked_value_prefix,
+                "maskedValueSuffix": masked_value_suffix,
+                "prefix": prefix,
+                "valueLength": value_length,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        masked_value_prefix = d.pop("maskedValuePrefix")
+
+        masked_value_suffix = d.pop("maskedValueSuffix")
+
+        prefix = d.pop("prefix")
+
+        value_length = d.pop("valueLength")
+
+        identifier_masking_details = cls(
+            masked_value_prefix=masked_value_prefix,
+            masked_value_suffix=masked_value_suffix,
+            prefix=prefix,
+            value_length=value_length,
+        )
+
+        identifier_masking_details.additional_properties = d
+        return identifier_masking_details
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/listed_sandbox.py

@@ -0,0 +1,179 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.sandbox_state import SandboxState
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+
+T = TypeVar("T", bound="ListedSandbox")
+
+
+@_attrs_define
+class ListedSandbox:
+    """
+    Attributes:
+        client_id (str): Identifier of the client
+        cpu_count (int): CPU cores for the sandbox
+        disk_size_mb (int): Disk size for the sandbox in MiB
+        end_at (datetime.datetime): Time when the sandbox will expire
+        envd_version (str): Version of the envd running in the sandbox
+        memory_mb (int): Memory for the sandbox in MiB
+        sandbox_id (str): Identifier of the sandbox
+        started_at (datetime.datetime): Time when the sandbox was started
+        state (SandboxState): State of the sandbox
+        template_id (str): Identifier of the template from which is the sandbox created
+        alias (Union[Unset, str]): Alias of the template
+        metadata (Union[Unset, Any]):
+        volume_mounts (Union[Unset, list['SandboxVolumeMount']]):
+    """
+
+    client_id: str
+    cpu_count: int
+    disk_size_mb: int
+    end_at: datetime.datetime
+    envd_version: str
+    memory_mb: int
+    sandbox_id: str
+    started_at: datetime.datetime
+    state: SandboxState
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    volume_mounts: Union[Unset, list["SandboxVolumeMount"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        cpu_count = self.cpu_count
+
+        disk_size_mb = self.disk_size_mb
+
+        end_at = self.end_at.isoformat()
+
+        envd_version = self.envd_version
+
+        memory_mb = self.memory_mb
+
+        sandbox_id = self.sandbox_id
+
+        started_at = self.started_at.isoformat()
+
+        state = self.state.value
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        metadata = self.metadata
+
+        volume_mounts: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.volume_mounts, Unset):
+            volume_mounts = []
+            for volume_mounts_item_data in self.volume_mounts:
+                volume_mounts_item = volume_mounts_item_data.to_dict()
+                volume_mounts.append(volume_mounts_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clientID": client_id,
+                "cpuCount": cpu_count,
+                "diskSizeMB": disk_size_mb,
+                "endAt": end_at,
+                "envdVersion": envd_version,
+                "memoryMB": memory_mb,
+                "sandboxID": sandbox_id,
+                "startedAt": started_at,
+                "state": state,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if volume_mounts is not UNSET:
+            field_dict["volumeMounts"] = volume_mounts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+        d = dict(src_dict)
+        client_id = d.pop("clientID")
+
+        cpu_count = d.pop("cpuCount")
+
+        disk_size_mb = d.pop("diskSizeMB")
+
+        end_at = isoparse(d.pop("endAt"))
+
+        envd_version = d.pop("envdVersion")
+
+        memory_mb = d.pop("memoryMB")
+
+        sandbox_id = d.pop("sandboxID")
+
+        started_at = isoparse(d.pop("startedAt"))
+
+        state = SandboxState(d.pop("state"))
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", UNSET)
+
+        metadata = d.pop("metadata", UNSET)
+
+        volume_mounts = []
+        _volume_mounts = d.pop("volumeMounts", UNSET)
+        for volume_mounts_item_data in _volume_mounts or []:
+            volume_mounts_item = SandboxVolumeMount.from_dict(volume_mounts_item_data)
+
+            volume_mounts.append(volume_mounts_item)
+
+        listed_sandbox = cls(
+            client_id=client_id,
+            cpu_count=cpu_count,
+            disk_size_mb=disk_size_mb,
+            end_at=end_at,
+            envd_version=envd_version,
+            memory_mb=memory_mb,
+            sandbox_id=sandbox_id,
+            started_at=started_at,
+            state=state,
+            template_id=template_id,
+            alias=alias,
+            metadata=metadata,
+            volume_mounts=volume_mounts,
+        )
+
+        listed_sandbox.additional_properties = d
+        return listed_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/log_level.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class LogLevel(str, Enum):
+    DEBUG = "debug"
+    ERROR = "error"
+    INFO = "info"
+    WARN = "warn"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/logs_direction.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LogsDirection(str, Enum):
+    BACKWARD = "backward"
+    FORWARD = "forward"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/logs_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LogsSource(str, Enum):
+    PERSISTENT = "persistent"
+    TEMPORARY = "temporary"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/machine_info.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MachineInfo")
+
+
+@_attrs_define
+class MachineInfo:
+    """
+    Attributes:
+        cpu_architecture (str): CPU architecture of the node
+        cpu_family (str): CPU family of the node
+        cpu_model (str): CPU model of the node
+        cpu_model_name (str): CPU model name of the node
+    """
+
+    cpu_architecture: str
+    cpu_family: str
+    cpu_model: str
+    cpu_model_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cpu_architecture = self.cpu_architecture
+
+        cpu_family = self.cpu_family
+
+        cpu_model = self.cpu_model
+
+        cpu_model_name = self.cpu_model_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cpuArchitecture": cpu_architecture,
+                "cpuFamily": cpu_family,
+                "cpuModel": cpu_model,
+                "cpuModelName": cpu_model_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cpu_architecture = d.pop("cpuArchitecture")
+
+        cpu_family = d.pop("cpuFamily")
+
+        cpu_model = d.pop("cpuModel")
+
+        cpu_model_name = d.pop("cpuModelName")
+
+        machine_info = cls(
+            cpu_architecture=cpu_architecture,
+            cpu_family=cpu_family,
+            cpu_model=cpu_model,
+            cpu_model_name=cpu_model_name,
+        )
+
+        machine_info.additional_properties = d
+        return machine_info
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/max_team_metric.py

@@ -0,0 +1,78 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="MaxTeamMetric")
+
+
+@_attrs_define
+class MaxTeamMetric:
+    """Team metric with timestamp
+
+    Attributes:
+        timestamp (datetime.datetime): Timestamp of the metric entry
+        timestamp_unix (int): Timestamp of the metric entry in Unix time (seconds since epoch)
+        value (float): The maximum value of the requested metric in the given interval
+    """
+
+    timestamp: datetime.datetime
+    timestamp_unix: int
+    value: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timestamp = self.timestamp.isoformat()
+
+        timestamp_unix = self.timestamp_unix
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timestamp": timestamp,
+                "timestampUnix": timestamp_unix,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        timestamp = isoparse(d.pop("timestamp"))
+
+        timestamp_unix = d.pop("timestampUnix")
+
+        value = d.pop("value")
+
+        max_team_metric = cls(
+            timestamp=timestamp,
+            timestamp_unix=timestamp_unix,
+            value=value,
+        )
+
+        max_team_metric.additional_properties = d
+        return max_team_metric
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/mcp_type_0.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="McpType0")
+
+
+@_attrs_define
+class McpType0:
+    """MCP configuration for the sandbox"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        mcp_type_0 = cls()
+
+        mcp_type_0.additional_properties = d
+        return mcp_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/new_access_token.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="NewAccessToken")
+
+
+@_attrs_define
+class NewAccessToken:
+    """
+    Attributes:
+        name (str): Name of the access token
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        new_access_token = cls(
+            name=name,
+        )
+
+        new_access_token.additional_properties = d
+        return new_access_token
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/new_sandbox.py

@@ -0,0 +1,224 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.mcp_type_0 import McpType0
+    from ..models.sandbox_auto_resume_config import SandboxAutoResumeConfig
+    from ..models.sandbox_network_config import SandboxNetworkConfig
+    from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+
+T = TypeVar("T", bound="NewSandbox")
+
+
+@_attrs_define
+class NewSandbox:
+    """
+    Attributes:
+        template_id (str): Identifier of the required template
+        allow_internet_access (Union[Unset, bool]): Allow sandbox to access the internet. When set to false, it behaves
+            the same as specifying denyOut to 0.0.0.0/0 in the network config.
+        auto_pause (Union[Unset, bool]): Automatically pauses the sandbox after the timeout Default: False.
+        auto_pause_memory (Union[Unset, bool]): Controls the snapshot kind taken when the sandbox auto-pauses on timeout
+            (only relevant when autoPause is true). When false, the auto-pause drops the in-memory state and persists only
+            the filesystem (a filesystem-only snapshot); resuming it cold-boots (reboots) the sandbox from disk. Such a
+            snapshot cannot be auto-resumed by traffic and must be resumed explicitly, so it cannot be combined with
+            autoResume. Defaults to true (full memory snapshot). Default: True.
+        auto_resume (Union[Unset, SandboxAutoResumeConfig]): Auto-resume configuration for paused sandboxes.
+        env_vars (Union[Unset, Any]):
+        mcp (Union['McpType0', None, Unset]): MCP configuration for the sandbox
+        metadata (Union[Unset, Any]):
+        network (Union[Unset, SandboxNetworkConfig]):
+        secure (Union[Unset, bool]): Secure all system communication with sandbox
+        timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
+        volume_mounts (Union[Unset, list['SandboxVolumeMount']]):
+    """
+
+    template_id: str
+    allow_internet_access: Union[Unset, bool] = UNSET
+    auto_pause: Union[Unset, bool] = False
+    auto_pause_memory: Union[Unset, bool] = True
+    auto_resume: Union[Unset, "SandboxAutoResumeConfig"] = UNSET
+    env_vars: Union[Unset, Any] = UNSET
+    mcp: Union["McpType0", None, Unset] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    network: Union[Unset, "SandboxNetworkConfig"] = UNSET
+    secure: Union[Unset, bool] = UNSET
+    timeout: Union[Unset, int] = 15
+    volume_mounts: Union[Unset, list["SandboxVolumeMount"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.mcp_type_0 import McpType0
+
+        template_id = self.template_id
+
+        allow_internet_access = self.allow_internet_access
+
+        auto_pause = self.auto_pause
+
+        auto_pause_memory = self.auto_pause_memory
+
+        auto_resume: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.auto_resume, Unset):
+            auto_resume = self.auto_resume.to_dict()
+
+        env_vars = self.env_vars
+
+        mcp: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.mcp, Unset):
+            mcp = UNSET
+        elif isinstance(self.mcp, McpType0):
+            mcp = self.mcp.to_dict()
+        else:
+            mcp = self.mcp
+
+        metadata = self.metadata
+
+        network: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.network, Unset):
+            network = self.network.to_dict()
+
+        secure = self.secure
+
+        timeout = self.timeout
+
+        volume_mounts: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.volume_mounts, Unset):
+            volume_mounts = []
+            for volume_mounts_item_data in self.volume_mounts:
+                volume_mounts_item = volume_mounts_item_data.to_dict()
+                volume_mounts.append(volume_mounts_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "templateID": template_id,
+            }
+        )
+        if allow_internet_access is not UNSET:
+            field_dict["allow_internet_access"] = allow_internet_access
+        if auto_pause is not UNSET:
+            field_dict["autoPause"] = auto_pause
+        if auto_pause_memory is not UNSET:
+            field_dict["autoPauseMemory"] = auto_pause_memory
+        if auto_resume is not UNSET:
+            field_dict["autoResume"] = auto_resume
+        if env_vars is not UNSET:
+            field_dict["envVars"] = env_vars
+        if mcp is not UNSET:
+            field_dict["mcp"] = mcp
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if network is not UNSET:
+            field_dict["network"] = network
+        if secure is not UNSET:
+            field_dict["secure"] = secure
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
+        if volume_mounts is not UNSET:
+            field_dict["volumeMounts"] = volume_mounts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.mcp_type_0 import McpType0
+        from ..models.sandbox_auto_resume_config import SandboxAutoResumeConfig
+        from ..models.sandbox_network_config import SandboxNetworkConfig
+        from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+        d = dict(src_dict)
+        template_id = d.pop("templateID")
+
+        allow_internet_access = d.pop("allow_internet_access", UNSET)
+
+        auto_pause = d.pop("autoPause", UNSET)
+
+        auto_pause_memory = d.pop("autoPauseMemory", UNSET)
+
+        _auto_resume = d.pop("autoResume", UNSET)
+        auto_resume: Union[Unset, SandboxAutoResumeConfig]
+        if isinstance(_auto_resume, Unset):
+            auto_resume = UNSET
+        else:
+            auto_resume = SandboxAutoResumeConfig.from_dict(_auto_resume)
+
+        env_vars = d.pop("envVars", UNSET)
+
+        def _parse_mcp(data: object) -> Union["McpType0", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_mcp_type_0 = McpType0.from_dict(data)
+
+                return componentsschemas_mcp_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["McpType0", None, Unset], data)
+
+        mcp = _parse_mcp(d.pop("mcp", UNSET))
+
+        metadata = d.pop("metadata", UNSET)
+
+        _network = d.pop("network", UNSET)
+        network: Union[Unset, SandboxNetworkConfig]
+        if isinstance(_network, Unset):
+            network = UNSET
+        else:
+            network = SandboxNetworkConfig.from_dict(_network)
+
+        secure = d.pop("secure", UNSET)
+
+        timeout = d.pop("timeout", UNSET)
+
+        volume_mounts = []
+        _volume_mounts = d.pop("volumeMounts", UNSET)
+        for volume_mounts_item_data in _volume_mounts or []:
+            volume_mounts_item = SandboxVolumeMount.from_dict(volume_mounts_item_data)
+
+            volume_mounts.append(volume_mounts_item)
+
+        new_sandbox = cls(
+            template_id=template_id,
+            allow_internet_access=allow_internet_access,
+            auto_pause=auto_pause,
+            auto_pause_memory=auto_pause_memory,
+            auto_resume=auto_resume,
+            env_vars=env_vars,
+            mcp=mcp,
+            metadata=metadata,
+            network=network,
+            secure=secure,
+            timeout=timeout,
+            volume_mounts=volume_mounts,
+        )
+
+        new_sandbox.additional_properties = d
+        return new_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/new_team_api_key.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="NewTeamAPIKey")
+
+
+@_attrs_define
+class NewTeamAPIKey:
+    """
+    Attributes:
+        name (str): Name of the API key
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        new_team_api_key = cls(
+            name=name,
+        )
+
+        new_team_api_key.additional_properties = d
+        return new_team_api_key
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/new_volume.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="NewVolume")
+
+
+@_attrs_define
+class NewVolume:
+    """
+    Attributes:
+        name (str): Name of the volume
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        new_volume = cls(
+            name=name,
+        )
+
+        new_volume.additional_properties = d
+        return new_volume
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/node.py

@@ -0,0 +1,160 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+if TYPE_CHECKING:
+    from ..models.machine_info import MachineInfo
+    from ..models.node_metrics import NodeMetrics
+
+
+T = TypeVar("T", bound="Node")
+
+
+@_attrs_define
+class Node:
+    """
+    Attributes:
+        cluster_id (str): Identifier of the cluster
+        commit (str): Commit of the orchestrator
+        create_fails (int): Number of sandbox create fails
+        create_successes (int): Number of sandbox create successes
+        id (str): Identifier of the node
+        machine_info (MachineInfo):
+        metrics (NodeMetrics): Node metrics
+        sandbox_count (int): Number of sandboxes running on the node
+        sandbox_starting_count (int): Number of starting Sandboxes
+        service_instance_id (str): Service instance identifier of the node
+        status (NodeStatus): Status of the node.
+            - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing
+            sandboxes are done.
+            - standby: the node is not actively used, but it can return to ready and continue serving traffic.
+        version (str): Version of the orchestrator
+    """
+
+    cluster_id: str
+    commit: str
+    create_fails: int
+    create_successes: int
+    id: str
+    machine_info: "MachineInfo"
+    metrics: "NodeMetrics"
+    sandbox_count: int
+    sandbox_starting_count: int
+    service_instance_id: str
+    status: NodeStatus
+    version: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cluster_id = self.cluster_id
+
+        commit = self.commit
+
+        create_fails = self.create_fails
+
+        create_successes = self.create_successes
+
+        id = self.id
+
+        machine_info = self.machine_info.to_dict()
+
+        metrics = self.metrics.to_dict()
+
+        sandbox_count = self.sandbox_count
+
+        sandbox_starting_count = self.sandbox_starting_count
+
+        service_instance_id = self.service_instance_id
+
+        status = self.status.value
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clusterID": cluster_id,
+                "commit": commit,
+                "createFails": create_fails,
+                "createSuccesses": create_successes,
+                "id": id,
+                "machineInfo": machine_info,
+                "metrics": metrics,
+                "sandboxCount": sandbox_count,
+                "sandboxStartingCount": sandbox_starting_count,
+                "serviceInstanceID": service_instance_id,
+                "status": status,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.machine_info import MachineInfo
+        from ..models.node_metrics import NodeMetrics
+
+        d = dict(src_dict)
+        cluster_id = d.pop("clusterID")
+
+        commit = d.pop("commit")
+
+        create_fails = d.pop("createFails")
+
+        create_successes = d.pop("createSuccesses")
+
+        id = d.pop("id")
+
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
+        metrics = NodeMetrics.from_dict(d.pop("metrics"))
+
+        sandbox_count = d.pop("sandboxCount")
+
+        sandbox_starting_count = d.pop("sandboxStartingCount")
+
+        service_instance_id = d.pop("serviceInstanceID")
+
+        status = NodeStatus(d.pop("status"))
+
+        version = d.pop("version")
+
+        node = cls(
+            cluster_id=cluster_id,
+            commit=commit,
+            create_fails=create_fails,
+            create_successes=create_successes,
+            id=id,
+            machine_info=machine_info,
+            metrics=metrics,
+            sandbox_count=sandbox_count,
+            sandbox_starting_count=sandbox_starting_count,
+            service_instance_id=service_instance_id,
+            status=status,
+            version=version,
+        )
+
+        node.additional_properties = d
+        return node
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/node_detail.py

@@ -0,0 +1,160 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+if TYPE_CHECKING:
+    from ..models.machine_info import MachineInfo
+    from ..models.node_metrics import NodeMetrics
+
+
+T = TypeVar("T", bound="NodeDetail")
+
+
+@_attrs_define
+class NodeDetail:
+    """
+    Attributes:
+        cached_builds (list[str]): List of cached builds id on the node
+        cluster_id (str): Identifier of the cluster
+        commit (str): Commit of the orchestrator
+        create_fails (int): Number of sandbox create fails
+        create_successes (int): Number of sandbox create successes
+        id (str): Identifier of the node
+        machine_info (MachineInfo):
+        metrics (NodeMetrics): Node metrics
+        sandbox_count (int): Number of sandboxes running on the node
+        service_instance_id (str): Service instance identifier of the node
+        status (NodeStatus): Status of the node.
+            - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing
+            sandboxes are done.
+            - standby: the node is not actively used, but it can return to ready and continue serving traffic.
+        version (str): Version of the orchestrator
+    """
+
+    cached_builds: list[str]
+    cluster_id: str
+    commit: str
+    create_fails: int
+    create_successes: int
+    id: str
+    machine_info: "MachineInfo"
+    metrics: "NodeMetrics"
+    sandbox_count: int
+    service_instance_id: str
+    status: NodeStatus
+    version: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cached_builds = self.cached_builds
+
+        cluster_id = self.cluster_id
+
+        commit = self.commit
+
+        create_fails = self.create_fails
+
+        create_successes = self.create_successes
+
+        id = self.id
+
+        machine_info = self.machine_info.to_dict()
+
+        metrics = self.metrics.to_dict()
+
+        sandbox_count = self.sandbox_count
+
+        service_instance_id = self.service_instance_id
+
+        status = self.status.value
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cachedBuilds": cached_builds,
+                "clusterID": cluster_id,
+                "commit": commit,
+                "createFails": create_fails,
+                "createSuccesses": create_successes,
+                "id": id,
+                "machineInfo": machine_info,
+                "metrics": metrics,
+                "sandboxCount": sandbox_count,
+                "serviceInstanceID": service_instance_id,
+                "status": status,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.machine_info import MachineInfo
+        from ..models.node_metrics import NodeMetrics
+
+        d = dict(src_dict)
+        cached_builds = cast(list[str], d.pop("cachedBuilds"))
+
+        cluster_id = d.pop("clusterID")
+
+        commit = d.pop("commit")
+
+        create_fails = d.pop("createFails")
+
+        create_successes = d.pop("createSuccesses")
+
+        id = d.pop("id")
+
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
+        metrics = NodeMetrics.from_dict(d.pop("metrics"))
+
+        sandbox_count = d.pop("sandboxCount")
+
+        service_instance_id = d.pop("serviceInstanceID")
+
+        status = NodeStatus(d.pop("status"))
+
+        version = d.pop("version")
+
+        node_detail = cls(
+            cached_builds=cached_builds,
+            cluster_id=cluster_id,
+            commit=commit,
+            create_fails=create_fails,
+            create_successes=create_successes,
+            id=id,
+            machine_info=machine_info,
+            metrics=metrics,
+            sandbox_count=sandbox_count,
+            service_instance_id=service_instance_id,
+            status=status,
+            version=version,
+        )
+
+        node_detail.additional_properties = d
+        return node_detail
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/node_metrics.py

@@ -0,0 +1,122 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.disk_metrics import DiskMetrics
+
+
+T = TypeVar("T", bound="NodeMetrics")
+
+
+@_attrs_define
+class NodeMetrics:
+    """Node metrics
+
+    Attributes:
+        allocated_cpu (int): Number of allocated CPU cores
+        allocated_memory_bytes (int): Amount of allocated memory in bytes
+        cpu_count (int): Total number of CPU cores on the node
+        cpu_percent (int): Node CPU usage percentage
+        disks (list['DiskMetrics']): Detailed metrics for each disk/mount point
+        memory_total_bytes (int): Total node memory in bytes
+        memory_used_bytes (int): Node memory used in bytes
+    """
+
+    allocated_cpu: int
+    allocated_memory_bytes: int
+    cpu_count: int
+    cpu_percent: int
+    disks: list["DiskMetrics"]
+    memory_total_bytes: int
+    memory_used_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allocated_cpu = self.allocated_cpu
+
+        allocated_memory_bytes = self.allocated_memory_bytes
+
+        cpu_count = self.cpu_count
+
+        cpu_percent = self.cpu_percent
+
+        disks = []
+        for disks_item_data in self.disks:
+            disks_item = disks_item_data.to_dict()
+            disks.append(disks_item)
+
+        memory_total_bytes = self.memory_total_bytes
+
+        memory_used_bytes = self.memory_used_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "allocatedCPU": allocated_cpu,
+                "allocatedMemoryBytes": allocated_memory_bytes,
+                "cpuCount": cpu_count,
+                "cpuPercent": cpu_percent,
+                "disks": disks,
+                "memoryTotalBytes": memory_total_bytes,
+                "memoryUsedBytes": memory_used_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.disk_metrics import DiskMetrics
+
+        d = dict(src_dict)
+        allocated_cpu = d.pop("allocatedCPU")
+
+        allocated_memory_bytes = d.pop("allocatedMemoryBytes")
+
+        cpu_count = d.pop("cpuCount")
+
+        cpu_percent = d.pop("cpuPercent")
+
+        disks = []
+        _disks = d.pop("disks")
+        for disks_item_data in _disks:
+            disks_item = DiskMetrics.from_dict(disks_item_data)
+
+            disks.append(disks_item)
+
+        memory_total_bytes = d.pop("memoryTotalBytes")
+
+        memory_used_bytes = d.pop("memoryUsedBytes")
+
+        node_metrics = cls(
+            allocated_cpu=allocated_cpu,
+            allocated_memory_bytes=allocated_memory_bytes,
+            cpu_count=cpu_count,
+            cpu_percent=cpu_percent,
+            disks=disks,
+            memory_total_bytes=memory_total_bytes,
+            memory_used_bytes=memory_used_bytes,
+        )
+
+        node_metrics.additional_properties = d
+        return node_metrics
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/node_status.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class NodeStatus(str, Enum):
+    CONNECTING = "connecting"
+    DRAINING = "draining"
+    READY = "ready"
+    STANDBY = "standby"
+    UNHEALTHY = "unhealthy"
+
+    def __str__(self) -> str:
+        return str(self.value)

packages/python-sdk/e2b/api/client/models/node_status_change.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="NodeStatusChange")
+
+
+@_attrs_define
+class NodeStatusChange:
+    """
+    Attributes:
+        status (NodeStatus): Status of the node.
+            - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing
+            sandboxes are done.
+            - standby: the node is not actively used, but it can return to ready and continue serving traffic.
+        cluster_id (Union[Unset, UUID]): Identifier of the cluster
+    """
+
+    status: NodeStatus
+    cluster_id: Union[Unset, UUID] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        cluster_id: Union[Unset, str] = UNSET
+        if not isinstance(self.cluster_id, Unset):
+            cluster_id = str(self.cluster_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+        if cluster_id is not UNSET:
+            field_dict["clusterID"] = cluster_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = NodeStatus(d.pop("status"))
+
+        _cluster_id = d.pop("clusterID", UNSET)
+        cluster_id: Union[Unset, UUID]
+        if isinstance(_cluster_id, Unset):
+            cluster_id = UNSET
+        else:
+            cluster_id = UUID(_cluster_id)
+
+        node_status_change = cls(
+            status=status,
+            cluster_id=cluster_id,
+        )
+
+        node_status_change.additional_properties = d
+        return node_status_change
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/post_sandboxes_sandbox_id_refreshes_body.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PostSandboxesSandboxIDRefreshesBody")
+
+
+@_attrs_define
+class PostSandboxesSandboxIDRefreshesBody:
+    """
+    Attributes:
+        duration (Union[Unset, int]): Duration for which the sandbox should be kept alive in seconds
+    """
+
+    duration: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        duration = self.duration
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if duration is not UNSET:
+            field_dict["duration"] = duration
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        duration = d.pop("duration", UNSET)
+
+        post_sandboxes_sandbox_id_refreshes_body = cls(
+            duration=duration,
+        )
+
+        post_sandboxes_sandbox_id_refreshes_body.additional_properties = d
+        return post_sandboxes_sandbox_id_refreshes_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/post_sandboxes_sandbox_id_snapshots_body.py

@@ -0,0 +1,60 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PostSandboxesSandboxIDSnapshotsBody")
+
+
+@_attrs_define
+class PostSandboxesSandboxIDSnapshotsBody:
+    """
+    Attributes:
+        name (Union[Unset, str]): Optional name for the snapshot template. If a snapshot template with this name already
+            exists, a new build will be assigned to the existing template instead of creating a new one.
+    """
+
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        post_sandboxes_sandbox_id_snapshots_body = cls(
+            name=name,
+        )
+
+        post_sandboxes_sandbox_id_snapshots_body.additional_properties = d
+        return post_sandboxes_sandbox_id_snapshots_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/post_sandboxes_sandbox_id_timeout_body.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PostSandboxesSandboxIDTimeoutBody")
+
+
+@_attrs_define
+class PostSandboxesSandboxIDTimeoutBody:
+    """
+    Attributes:
+        timeout (int): Timeout in seconds from the current time after which the sandbox should expire
+    """
+
+    timeout: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timeout": timeout,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        timeout = d.pop("timeout")
+
+        post_sandboxes_sandbox_id_timeout_body = cls(
+            timeout=timeout,
+        )
+
+        post_sandboxes_sandbox_id_timeout_body.additional_properties = d
+        return post_sandboxes_sandbox_id_timeout_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/resumed_sandbox.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ResumedSandbox")
+
+
+@_attrs_define
+class ResumedSandbox:
+    """
+    Attributes:
+        auto_pause (Union[Unset, bool]): Automatically pauses the sandbox after the timeout
+        timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
+    """
+
+    auto_pause: Union[Unset, bool] = UNSET
+    timeout: Union[Unset, int] = 15
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        auto_pause = self.auto_pause
+
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if auto_pause is not UNSET:
+            field_dict["autoPause"] = auto_pause
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        auto_pause = d.pop("autoPause", UNSET)
+
+        timeout = d.pop("timeout", UNSET)
+
+        resumed_sandbox = cls(
+            auto_pause=auto_pause,
+            timeout=timeout,
+        )
+
+        resumed_sandbox.additional_properties = d
+        return resumed_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox.py

@@ -0,0 +1,145 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Sandbox")
+
+
+@_attrs_define
+class Sandbox:
+    """
+    Attributes:
+        client_id (str): Identifier of the client
+        envd_version (str): Version of the envd running in the sandbox
+        sandbox_id (str): Identifier of the sandbox
+        template_id (str): Identifier of the template from which is the sandbox created
+        alias (Union[Unset, str]): Alias of the template
+        domain (Union[None, Unset, str]): Base domain where the sandbox traffic is accessible
+        envd_access_token (Union[Unset, str]): Access token used for envd communication
+        traffic_access_token (Union[None, Unset, str]): Token required for accessing sandbox via proxy.
+    """
+
+    client_id: str
+    envd_version: str
+    sandbox_id: str
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    domain: Union[None, Unset, str] = UNSET
+    envd_access_token: Union[Unset, str] = UNSET
+    traffic_access_token: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        envd_version = self.envd_version
+
+        sandbox_id = self.sandbox_id
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        domain: Union[None, Unset, str]
+        if isinstance(self.domain, Unset):
+            domain = UNSET
+        else:
+            domain = self.domain
+
+        envd_access_token = self.envd_access_token
+
+        traffic_access_token: Union[None, Unset, str]
+        if isinstance(self.traffic_access_token, Unset):
+            traffic_access_token = UNSET
+        else:
+            traffic_access_token = self.traffic_access_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clientID": client_id,
+                "envdVersion": envd_version,
+                "sandboxID": sandbox_id,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if envd_access_token is not UNSET:
+            field_dict["envdAccessToken"] = envd_access_token
+        if traffic_access_token is not UNSET:
+            field_dict["trafficAccessToken"] = traffic_access_token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        client_id = d.pop("clientID")
+
+        envd_version = d.pop("envdVersion")
+
+        sandbox_id = d.pop("sandboxID")
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", UNSET)
+
+        def _parse_domain(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        domain = _parse_domain(d.pop("domain", UNSET))
+
+        envd_access_token = d.pop("envdAccessToken", UNSET)
+
+        def _parse_traffic_access_token(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        traffic_access_token = _parse_traffic_access_token(
+            d.pop("trafficAccessToken", UNSET)
+        )
+
+        sandbox = cls(
+            client_id=client_id,
+            envd_version=envd_version,
+            sandbox_id=sandbox_id,
+            template_id=template_id,
+            alias=alias,
+            domain=domain,
+            envd_access_token=envd_access_token,
+            traffic_access_token=traffic_access_token,
+        )
+
+        sandbox.additional_properties = d
+        return sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox_auto_resume_config.py

@@ -0,0 +1,60 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SandboxAutoResumeConfig")
+
+
+@_attrs_define
+class SandboxAutoResumeConfig:
+    """Auto-resume configuration for paused sandboxes.
+
+    Attributes:
+        enabled (bool): Auto-resume enabled flag for paused sandboxes. Default false.
+    """
+
+    enabled: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled = self.enabled
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "enabled": enabled,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        enabled = d.pop("enabled")
+
+        sandbox_auto_resume_config = cls(
+            enabled=enabled,
+        )
+
+        sandbox_auto_resume_config.additional_properties = d
+        return sandbox_auto_resume_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox_detail.py

@@ -0,0 +1,267 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.sandbox_state import SandboxState
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_lifecycle import SandboxLifecycle
+    from ..models.sandbox_network_config import SandboxNetworkConfig
+    from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+
+T = TypeVar("T", bound="SandboxDetail")
+
+
+@_attrs_define
+class SandboxDetail:
+    """
+    Attributes:
+        client_id (str): Identifier of the client
+        cpu_count (int): CPU cores for the sandbox
+        disk_size_mb (int): Disk size for the sandbox in MiB
+        end_at (datetime.datetime): Time when the sandbox will expire
+        envd_version (str): Version of the envd running in the sandbox
+        memory_mb (int): Memory for the sandbox in MiB
+        sandbox_id (str): Identifier of the sandbox
+        started_at (datetime.datetime): Time when the sandbox was started
+        state (SandboxState): State of the sandbox
+        template_id (str): Identifier of the template from which is the sandbox created
+        alias (Union[Unset, str]): Alias of the template
+        allow_internet_access (Union[None, Unset, bool]): Whether internet access was explicitly enabled or disabled for
+            the sandbox. Null means it was not explicitly set.
+        domain (Union[None, Unset, str]): Base domain where the sandbox traffic is accessible
+        envd_access_token (Union[Unset, str]): Access token used for envd communication
+        lifecycle (Union[Unset, SandboxLifecycle]): Sandbox lifecycle policy returned by sandbox info.
+        metadata (Union[Unset, Any]):
+        network (Union[Unset, SandboxNetworkConfig]):
+        volume_mounts (Union[Unset, list['SandboxVolumeMount']]):
+    """
+
+    client_id: str
+    cpu_count: int
+    disk_size_mb: int
+    end_at: datetime.datetime
+    envd_version: str
+    memory_mb: int
+    sandbox_id: str
+    started_at: datetime.datetime
+    state: SandboxState
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    allow_internet_access: Union[None, Unset, bool] = UNSET
+    domain: Union[None, Unset, str] = UNSET
+    envd_access_token: Union[Unset, str] = UNSET
+    lifecycle: Union[Unset, "SandboxLifecycle"] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    network: Union[Unset, "SandboxNetworkConfig"] = UNSET
+    volume_mounts: Union[Unset, list["SandboxVolumeMount"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        cpu_count = self.cpu_count
+
+        disk_size_mb = self.disk_size_mb
+
+        end_at = self.end_at.isoformat()
+
+        envd_version = self.envd_version
+
+        memory_mb = self.memory_mb
+
+        sandbox_id = self.sandbox_id
+
+        started_at = self.started_at.isoformat()
+
+        state = self.state.value
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        allow_internet_access: Union[None, Unset, bool]
+        if isinstance(self.allow_internet_access, Unset):
+            allow_internet_access = UNSET
+        else:
+            allow_internet_access = self.allow_internet_access
+
+        domain: Union[None, Unset, str]
+        if isinstance(self.domain, Unset):
+            domain = UNSET
+        else:
+            domain = self.domain
+
+        envd_access_token = self.envd_access_token
+
+        lifecycle: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.lifecycle, Unset):
+            lifecycle = self.lifecycle.to_dict()
+
+        metadata = self.metadata
+
+        network: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.network, Unset):
+            network = self.network.to_dict()
+
+        volume_mounts: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.volume_mounts, Unset):
+            volume_mounts = []
+            for volume_mounts_item_data in self.volume_mounts:
+                volume_mounts_item = volume_mounts_item_data.to_dict()
+                volume_mounts.append(volume_mounts_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clientID": client_id,
+                "cpuCount": cpu_count,
+                "diskSizeMB": disk_size_mb,
+                "endAt": end_at,
+                "envdVersion": envd_version,
+                "memoryMB": memory_mb,
+                "sandboxID": sandbox_id,
+                "startedAt": started_at,
+                "state": state,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if allow_internet_access is not UNSET:
+            field_dict["allowInternetAccess"] = allow_internet_access
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if envd_access_token is not UNSET:
+            field_dict["envdAccessToken"] = envd_access_token
+        if lifecycle is not UNSET:
+            field_dict["lifecycle"] = lifecycle
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if network is not UNSET:
+            field_dict["network"] = network
+        if volume_mounts is not UNSET:
+            field_dict["volumeMounts"] = volume_mounts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_lifecycle import SandboxLifecycle
+        from ..models.sandbox_network_config import SandboxNetworkConfig
+        from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+        d = dict(src_dict)
+        client_id = d.pop("clientID")
+
+        cpu_count = d.pop("cpuCount")
+
+        disk_size_mb = d.pop("diskSizeMB")
+
+        end_at = isoparse(d.pop("endAt"))
+
+        envd_version = d.pop("envdVersion")
+
+        memory_mb = d.pop("memoryMB")
+
+        sandbox_id = d.pop("sandboxID")
+
+        started_at = isoparse(d.pop("startedAt"))
+
+        state = SandboxState(d.pop("state"))
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", UNSET)
+
+        def _parse_allow_internet_access(data: object) -> Union[None, Unset, bool]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, bool], data)
+
+        allow_internet_access = _parse_allow_internet_access(
+            d.pop("allowInternetAccess", UNSET)
+        )
+
+        def _parse_domain(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        domain = _parse_domain(d.pop("domain", UNSET))
+
+        envd_access_token = d.pop("envdAccessToken", UNSET)
+
+        _lifecycle = d.pop("lifecycle", UNSET)
+        lifecycle: Union[Unset, SandboxLifecycle]
+        if isinstance(_lifecycle, Unset):
+            lifecycle = UNSET
+        else:
+            lifecycle = SandboxLifecycle.from_dict(_lifecycle)
+
+        metadata = d.pop("metadata", UNSET)
+
+        _network = d.pop("network", UNSET)
+        network: Union[Unset, SandboxNetworkConfig]
+        if isinstance(_network, Unset):
+            network = UNSET
+        else:
+            network = SandboxNetworkConfig.from_dict(_network)
+
+        volume_mounts = []
+        _volume_mounts = d.pop("volumeMounts", UNSET)
+        for volume_mounts_item_data in _volume_mounts or []:
+            volume_mounts_item = SandboxVolumeMount.from_dict(volume_mounts_item_data)
+
+            volume_mounts.append(volume_mounts_item)
+
+        sandbox_detail = cls(
+            client_id=client_id,
+            cpu_count=cpu_count,
+            disk_size_mb=disk_size_mb,
+            end_at=end_at,
+            envd_version=envd_version,
+            memory_mb=memory_mb,
+            sandbox_id=sandbox_id,
+            started_at=started_at,
+            state=state,
+            template_id=template_id,
+            alias=alias,
+            allow_internet_access=allow_internet_access,
+            domain=domain,
+            envd_access_token=envd_access_token,
+            lifecycle=lifecycle,
+            metadata=metadata,
+            network=network,
+            volume_mounts=volume_mounts,
+        )
+
+        sandbox_detail.additional_properties = d
+        return sandbox_detail
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox_lifecycle.py

@@ -0,0 +1,70 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.sandbox_on_timeout import SandboxOnTimeout
+
+T = TypeVar("T", bound="SandboxLifecycle")
+
+
+@_attrs_define
+class SandboxLifecycle:
+    """Sandbox lifecycle policy returned by sandbox info.
+
+    Attributes:
+        auto_resume (bool): Whether the sandbox can auto-resume.
+        on_timeout (SandboxOnTimeout): Action taken when the sandbox times out.
+    """
+
+    auto_resume: bool
+    on_timeout: SandboxOnTimeout
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        auto_resume = self.auto_resume
+
+        on_timeout = self.on_timeout.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "autoResume": auto_resume,
+                "onTimeout": on_timeout,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        auto_resume = d.pop("autoResume")
+
+        on_timeout = SandboxOnTimeout(d.pop("onTimeout"))
+
+        sandbox_lifecycle = cls(
+            auto_resume=auto_resume,
+            on_timeout=on_timeout,
+        )
+
+        sandbox_lifecycle.additional_properties = d
+        return sandbox_lifecycle
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox_log.py

@@ -0,0 +1,70 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="SandboxLog")
+
+
+@_attrs_define
+class SandboxLog:
+    """Log entry with timestamp and line
+
+    Attributes:
+        line (str): Log line content
+        timestamp (datetime.datetime): Timestamp of the log entry
+    """
+
+    line: str
+    timestamp: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        line = self.line
+
+        timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "line": line,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        line = d.pop("line")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        sandbox_log = cls(
+            line=line,
+            timestamp=timestamp,
+        )
+
+        sandbox_log.additional_properties = d
+        return sandbox_log
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

packages/python-sdk/e2b/api/client/models/sandbox_log_entry.py

@@ -0,0 +1,93 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.log_level import LogLevel
+
+if TYPE_CHECKING:
+    from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
+
+
+T = TypeVar("T", bound="SandboxLogEntry")
+
+
+@_attrs_define
+class SandboxLogEntry:
+    """
+    Attributes:
+        fields (SandboxLogEntryFields):
+        level (LogLevel): State of the sandbox
+        message (str): Log message content
+        timestamp (datetime.datetime): Timestamp of the log entry
+    """
+
+    fields: "SandboxLogEntryFields"
+    level: LogLevel
+    message: str
+    timestamp: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        fields = self.fields.to_dict()
+
+        level = self.level.value
+
+        message = self.message
+
+        timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "fields": fields,
+                "level": level,
+                "message": message,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
+
+        d = dict(src_dict)
+        fields = SandboxLogEntryFields.from_dict(d.pop("fields"))
+
+        level = LogLevel(d.pop("level"))
+
+        message = d.pop("message")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        sandbox_log_entry = cls(
+            fields=fields,
+            level=level,
+            message=message,
+            timestamp=timestamp,
+        )
+
+        sandbox_log_entry.additional_properties = d
+        return sandbox_log_entry
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties