tenki 0.5.1__py3-none-any.whl

tenki/__init__.py

@@ -0,0 +1,10 @@
+"""Tenki Cloud Python SDK.
+
+Canonical import namespace for the Tenki sandbox SDK. Everything is
+re-exported from the implementation package :mod:`tenki_sandbox`, so
+``from tenki import Sandbox`` and ``from tenki_sandbox import Sandbox`` are
+equivalent. New code should import from ``tenki``.
+"""
+
+from tenki_sandbox import *  # noqa: F401,F403
+from tenki_sandbox import __all__ as __all__

tenki-0.5.1.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: tenki
+Version: 0.5.1
+Summary: Tenki Cloud Python SDK — cloud sandboxes (microVMs) for AI agents and code execution
+Project-URL: Homepage, https://tenki.cloud
+Project-URL: Documentation, https://tenki.cloud/docs/sandbox/sdk
+Project-URL: Repository, https://github.com/LuxorLabs/tenki-sdk-python
+Project-URL: Issues, https://github.com/LuxorLabs/tenki-sdk-python/issues
+Author: Tenki Cloud
+License-Expression: MIT
+Keywords: agents,ai-agents,cloud,code-execution,code-interpreter,microvm,sandbox,tenki
+Requires-Python: >=3.10
+Requires-Dist: grpcio>=1.73
+Requires-Dist: protobuf>=5.29.5
+Requires-Dist: websocket-client>=1.6
+Provides-Extra: async
+Requires-Dist: websockets>=12; extra == 'async'
+Provides-Extra: dev
+Requires-Dist: grpcio-tools>=1.73; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: websockets>=12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Tenki Python SDK
+
+Python SDK for Tenki: cloud sandboxes (microVMs) for AI agents and code execution.
+
+```bash
+pip install tenki
+```
+
+> The SDK is published as `tenki`. Existing code that does
+> `import tenki_sandbox` keeps working (that module ships inside `tenki`), but
+> new code should use `import tenki`.
+
+## Protobuf compatibility
+
+The SDK supports `protobuf>=5.29.5` with no upper bound. Its Python bindings are
+temporarily generated with protobuf 5.29.5 so applications that require
+`protobuf<6` can install the SDK alongside dependencies such as Memori.
+
+Protobuf 6.31.x emits a benign warning when it loads 5.29.5-generated bindings.
+If a test suite pins that runtime and promotes warnings to errors, scope the
+exception narrowly instead of disabling protobuf's runtime checks:
+
+```toml
+[tool.pytest.ini_options]
+filterwarnings = [
+  "ignore:Protobuf gencode version 5\\.29\\.5 is exactly one major version older than the runtime version 6\\.31\\..*:UserWarning:google\\.protobuf\\.runtime_version",
+]
+```
+
+```python
+from tenki import Sandbox
+
+# create() waits by default via a single server-held request and returns an
+# exec-ready sandbox with data-plane access primed (wait=False to skip).
+with Sandbox.create(cpu_cores=2, memory_mb=4096) as sb:
+    result = sb.exec("python3", "-c", "print('hello')")
+    result.check()
+    print(result.stdout_text)
+
+    # fs paths are relative to the sandbox workdir (absolute paths must stay inside it)
+    sb.fs.write_text("input.txt", "data")
+    print(sb.fs.read_text("input.txt"))
+
+    preview = sb.expose_port(3000, ttl=3600)
+    print(preview.url)
+```
+
+The API key determines the Workspace automatically; ordinary Sandbox calls do not require a Workspace ID.
+
+## Async (asyncio)
+
+`AsyncClient` / `AsyncSandbox` expose the same surface with native `async`/`await`,
+built on `grpc.aio` — no `asyncio.to_thread` wrapping required. Use it inside any
+asyncio server (FastAPI, aiohttp, etc.).
+
+```python
+import asyncio
+from tenki import AsyncSandbox
+
+
+async def main():
+    async with await AsyncSandbox.create(cpu_cores=2) as sb:
+        result = await sb.exec("python3", "-c", "print('hello')")
+        result.check()
+        print(result.stdout_text)
+
+        await sb.fs.write_text("input.txt", "data")
+        print(await sb.fs.read_text("input.txt"))
+
+        proc = await sb.start("bash", "-lc", "read name; echo hi $name")
+        await proc.write_stdin("tenki\n")
+        await proc.close_stdin()
+        async for chunk in proc.stdout:
+            print(chunk.decode(), end="")
+        (await proc.wait()).check()
+
+
+asyncio.run(main())
+```
+
+The sync `Client` / `Sandbox` remain available for non-async consumers. SSH,
+`dial`, and host-port tunnels are also async: `AsyncSandbox.ssh()` returns an
+`AsyncSSHConn` (raw async `read`/`write`/`close`, matching the TS/Go SDKs; needs
+the `tenki[async]` extra for `websockets`), `dial()` returns an
+`AsyncDialConn`, and `expose_host_port()` / `expose_host_port_resilient()` return
+async tunnels with `await tunnel.terminated.wait()` and `on_terminated` callbacks.
+
+## Auth
+
+Auth resolution:
+
+1. `auth_token=` passed to `Client` or `Sandbox.create`
+2. `TENKI_AUTH_TOKEN`
+3. `TENKI_API_KEY`
+
+`TENKI_API_ENDPOINT` overrides the API URL; legacy `TENKI_API_URL` is also accepted.
+
+## Process API
+
+`exec` collects stdout/stderr and returns a result:
+
+```python
+result = sb.exec("npm", "test", cwd="project", timeout=60, env={"CI": "1"})
+print(result.stdout_text)
+result.check()
+```
+
+`start` returns a live process:
+
+```python
+proc = sb.start("bash", "-lc", "read name; echo hello $name")
+proc.write_stdin("tenki\n")
+proc.close_stdin()
+for chunk in proc.stdout:
+    print(chunk.decode(), end="")
+proc.wait().check()
+```
+
+Use `shell()` when you want shell parsing:
+
+```python
+sb.shell("python3 -m http.server 3000 >/tmp/server.log 2>&1 &")
+```
+
+Process `cwd` values follow the guest contract: relative paths are normalized
+under the sandbox guest workdir (`/home/tenki` by default), absolute paths are
+used unchanged, and missing or non-directory targets fail before the process
+starts.
+
+## Sandbox lifetime
+
+Long-lived sandboxes are a parameter choice at `create()`, not a separate API:
+
+```python
+sb = client.create(
+    sticky=True,              # long-lived session: not reaped on idle
+    idle_timeout_minutes=120, # or: generous idle window before auto-pause
+    max_duration=8 * 3600,    # total lifetime cap (seconds)
+    pause_retention=24 * 3600,# how long a paused session is kept resumable
+)
+```
+
+- `max_duration` caps total lifetime; `sb.extend(seconds)` pushes the deadline
+  (`sb.info.timeout_at`) while running.
+- `idle_timeout_minutes` auto-pauses an idle sandbox; `sb.resume()` brings it
+  back with the filesystem intact.
+- `sticky=True` opts the session out of idle reaping for keep-warm use cases
+  (workspaces cap concurrent sticky sessions).
+- `client.list(sticky=True)` filters for long-lived sessions in the API key's Workspace.
+
+## SSH
+
+For tools that speak SSH (paramiko, scp, IDE remote dev), the SDK can mint a
+short-lived OpenSSH user certificate for your session and open a transport to
+the sandbox SSH gateway. No keys are provisioned into the guest; the engine
+signs your local public key and the gateway verifies the certificate.
+
+Requires `pip install websocket-client paramiko` (websocket-client for the
+transport, paramiko if you want a client in-process).
+
+```python
+import subprocess
+import paramiko
+
+# 1. local keypair (any OpenSSH key works; ed25519 shown)
+subprocess.run(["ssh-keygen", "-t", "ed25519", "-N", "", "-q", "-f", "id_tenki"], check=True)
+
+# 2. engine signs a short-lived user cert for this sandbox
+cert = sb.issue_ssh_cert(open("id_tenki.pub").read(), ttl=600)
+open("id_tenki-cert.pub", "w").write(cert.ssh_cert)
+
+# 3. open the gateway transport and run a paramiko session over it
+pkey = paramiko.Ed25519Key.from_private_key_file("id_tenki")
+pkey.load_certificate("id_tenki-cert.pub")
+
+transport = paramiko.Transport(sb.ssh())  # WebSocket-backed socket
+transport.connect(username="tenki", pkey=pkey)
+session = transport.open_session()
+session.exec_command("echo hello-over-ssh")
+print(session.makefile().read().decode())
+transport.close()
+```
+
+Notes:
+
+- `sb.ssh()` / `client.ssh(session_id)` discover an active gateway and return
+  `SSHConn`, an `io.RawIOBase` socket usable anywhere paramiko accepts one.
+- The SSH username is `tenki`.
+- `TENKI_SANDBOX_GATEWAY_URL` overrides the gateway WebSocket URL (it is
+  otherwise derived from the API endpoint).
+- Certificate RPCs use the Connect protocol over HTTPS (same as the Go SDK and
+  the `tenki` CLI), so they work through standard HTTP load balancers.
+- `sb.update_ssh_authorized_keys([...])` additionally plants long-lived public
+  keys in the guest's `authorized_keys` if you prefer key-based auth for the
+  in-guest sshd.
+
+## Resource APIs
+
+```python
+from tenki import Client, GiB
+
+client = Client()
+
+volume = client.volumes.create(
+    name="cache",
+    size_bytes=10 * GiB,
+)
+
+preview = client.preview_urls.create(
+    slug="demo",
+    session_id=sb.id,
+    port=3000,
+)
+```
+
+## Registry
+
+Delete an untagged, non-latest, unshared registry version by image and snapshot
+ID:
+
+```python
+result = client.registry.delete_version(
+    "11111111-1111-1111-1111-111111111111",
+    "55555555-5555-5555-5555-555555555555",
+)
+```
+
+## Templates (typed builder)
+
+`TemplateSpec` is an immutable typed recipe (every builder call returns a new
+value). Builds freeze the normalized spec + `spec_hash` server-side and return
+a private digest-addressed `Image`, the normal sandbox launch source.
+
+```python
+from tenki import Client, TemplateSpec
+
+client = Client()
+
+spec = (
+    TemplateSpec()                     # defaults to base image "sandbox"
+    .from_image("sandbox-v2")          # or .from_template(...) / .from_snapshot(...)
+    .with_git_context("https://github.com/acme/node-api", "main")
+    .run("npm ci", name="Install dependencies")
+    .runtime_env({"NODE_ENV": "production"})
+    .start(["npm", "start"], ready_when=[{"http": "http://localhost:3000/health"}])
+)
+spec.validate()  # aggregate local validation; server stays authoritative
+
+template = client.templates.create(name="node-api", spec=spec)
+
+build = client.templates.build(
+    template,                          # resource objects in, IDs as fallback
+    build_secrets={"GITHUB_TOKEN": token},  # explicit request-time values
+    wait_for_completion=True,
+    on_event=lambda e: print(e),       # one ordered log/progress handler
+)
+
+sb = client.create(image=build.image, wait_for_runtime=True)
+```
+
+`wait_build(build_id)` reconnects to an existing build (ordered, deduplicated
+events). Local interruption (Ctrl-C or `cancel_event`) stops observation only;
+`client.templates.cancel_build(build)` cancels remotely. Waited failures raise
+`TemplateBuildFailedError` carrying the final redacted build; runtime waits
+raise `TemplateRuntimeFailedError` without terminating the running sandbox.
+Strict authored JSON import/export: `spec.to_json()` / `TemplateSpec.from_json(text)`.
+Checkout `mode` uses `"contents"` or `"directory"`; runtime `runAt`,
+`restartPolicy`, and `snapshotMode` use short values such as `"build"`,
+`"on-failure"`, and `"memory"`. Full protobuf enum names remain accepted;
+unknown fields and enum values are rejected.
+See `examples/template_builder.py` for the full filesystem/memory workflow.

tenki-0.5.1.dist-info/RECORD

@@ -0,0 +1,58 @@
+tenki/__init__.py,sha256=Ehndqrw3KWVhieB7e_YJB3zuA03wHhzW7JO9OcPjUwI,389
+tenki/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/__init__.py,sha256=BYcOwyYmS2Y_PxQrLMChKsXw28PHmP1hEJM0v_USzIU,3974
+tenki_sandbox/_convert.py,sha256=3Fw7njSx5jX0cKoqTHtjXJymD9GA3PgWZOf37I5jc1Y,18279
+tenki_sandbox/_pagination.py,sha256=COO_5BUQXiooFK3Ulb8_FGtPJlaN2uoDu1a_kYcP4Yw,292
+tenki_sandbox/_pb.py,sha256=_s4GkzR1F8gZAZisHcKLC3geoK_lTio4J1lTcHYTugg,401
+tenki_sandbox/_resource_validation.py,sha256=hIY3aKIcI68kY7bZNRK7xhyR2PA81FKpA1w_pzzQQ0o,2231
+tenki_sandbox/_time.py,sha256=4C7X5dwrolIwuj0PrTpY-HI3fiotgPAyBLcvTec826U,1347
+tenki_sandbox/_transport.py,sha256=bpvRQorrjhrMWt2W5y4Tc473Mb6HVj9XV1MEzK1k-1k,13034
+tenki_sandbox/client.py,sha256=6BCm4ipCxaRCE4ri0fE6qkq396_EkPuFhCqMhLvEumQ,13365
+tenki_sandbox/constants.py,sha256=bn7kyHjDMvjZ2Ww2ML7Q8LkjWmk3TlMBvdRccOPUIs0,521
+tenki_sandbox/data_plane.py,sha256=nwzWqUgkI8mWFnbEuPRevg9kNyPnXnJlkYXck4MD2h0,8679
+tenki_sandbox/dial.py,sha256=UYQkmzn_FOHyzFSJTO5pyNIWcxepu4AWo7G_elQw2To,4051
+tenki_sandbox/errors.py,sha256=RUBrYLIboiVSEUORcso6adat_gyEBu9eUQtWYuHFFcA,12001
+tenki_sandbox/fs.py,sha256=yzbZxpht_5ApmJlnYblt7pgH-WDQk8-k-j4EdLloWcQ,4908
+tenki_sandbox/git.py,sha256=e6AT5Qsi1-hGk8x5-L4I7CIHfU8xaTEhDAgen7NyQBY,2194
+tenki_sandbox/models.py,sha256=1f5qudKefUNtDnvvwEaPwEV2jGcJTwXCz3PxciZixKc,9893
+tenki_sandbox/preview_url.py,sha256=brhZwWRhl34l0lsOF2yD9K1JS838HvYVV0QsMF3ycOo,3032
+tenki_sandbox/process.py,sha256=SL8lbpohD_BnLWjeITIGbZzjueo5unU0Cbrt7qnUQwY,9448
+tenki_sandbox/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+tenki_sandbox/registry.py,sha256=TjBhmXAH8Y5yB9jzNdSt9PI9jj5l_6VRaV0aIdA8WjM,7385
+tenki_sandbox/resources.py,sha256=pwJB9r0N-L2uwHb65EJ1AlXEL2nSBTF3zFuA06GYG4A,25105
+tenki_sandbox/sandbox.py,sha256=5vBvkvNNMMA_5v_6XI6OQETTOyS32jeyHLf69wf2mwM,19754
+tenki_sandbox/ssh.py,sha256=gqQEcgQfI1cqOkQdR5_gNRxCdirqyVFlou_DQj8nouI,6548
+tenki_sandbox/template_spec.py,sha256=uPgzoR-BugdYr8tOBDOjLt0zD5t4xw7bF-GGRregyXE,37739
+tenki_sandbox/tunnel.py,sha256=uHTQJZM6ypOfL0WeuPy3BOWhxtXZmyAEtLbTz17HHOc,17473
+tenki_sandbox/_internal/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/buf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/buf/validate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/buf/validate/validate_pb2.py,sha256=HXD5LsgU-4CAvpGLIRfazoXCXRG-b-QlRv3lY1-cUlk,154194
+tenki_sandbox/_internal/proto/tenki/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/tenki/sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/registry_pb2.py,sha256=MvuaKGHb3v5VO6DuLeXM3qSX1a1RjI5y7ZZaYsp3ZTk,34209
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/registry_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/sandbox_pb2.py,sha256=aE-HHd3omM48qIdXWUm1-Y42JqTZHfqU94UZNzguwzs,151069
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/sandbox_pb2_grpc.py,sha256=bmWRJdmgaAES81iFPugNQRfu0oyRFpn2o3g0WZxZUcc,180052
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/ssh_gateway_client_pb2.py,sha256=nQ8COQfqMYLPpGq5d-21WHpVpEZYFEMjDAUMc0E5log,6099
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/ssh_gateway_client_pb2_grpc.py,sha256=TrC_NiW3IwKblAP05p_-bNrn6uHciT9YHPHBXn1fg8Y,6057
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/template_pb2.py,sha256=mBAXWMMPIrwQKhcMUsVATdT_ijkYsgqgaD8awP2ks_c,63118
+tenki_sandbox/_internal/proto/tenki/sandbox/v1/template_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
+tenki_sandbox/aio/__init__.py,sha256=2jfWY6NjNws1VWylUP783J5yHrEN7bSh4u4CS9P5iY0,1037
+tenki_sandbox/aio/_transport.py,sha256=NgIFSkT6or-6SdYheO7Us7nlr3vKktbc-J2CBCSjyEA,4920
+tenki_sandbox/aio/client.py,sha256=e-YAkYp5MsvwvZUjx94QFhOpZkBiSkQm_jiLDfkoL0g,8895
+tenki_sandbox/aio/data_plane.py,sha256=iZ7cQ9iHSa3D4KW6fgvK6Dbu1KnAW0wdRFU4rQqG1Z4,9777
+tenki_sandbox/aio/dial.py,sha256=cp68SeyawvBfQU3Zt2tBS6k0Llto__OARBkIOfaMMyw,5263
+tenki_sandbox/aio/fs.py,sha256=4XX8yMfmIJfWlwPWBGScHAxU8wVDjs70Yk-WbJNEmLU,6243
+tenki_sandbox/aio/git.py,sha256=e2KttYMjNTkhT3NwTGdKiwXOeSU1P6Qlpj3fDMvE7OQ,2294
+tenki_sandbox/aio/preview_url.py,sha256=3uUblNF3S5A-2TgyFWDqQfqeIVSNx8nGBBzRYtC6EEo,3114
+tenki_sandbox/aio/process.py,sha256=ZQQkU1Sl8AATItIorua7NyGKkhpyEmeTPYtwnQ-unoQ,8745
+tenki_sandbox/aio/registry.py,sha256=bphAiKZT2QV62OptwWcuptMFcvO6qYskJjU_RvHwj3I,7135
+tenki_sandbox/aio/resources.py,sha256=V6H7g4YSNCVMqgnHrOnCoNDSA3S31lTqYSPCoZsfCs8,21187
+tenki_sandbox/aio/sandbox.py,sha256=HmNLVqCOQ1nkm0j3tmFQkybo-KjdU5xh8wX2VG8Hgto,20556
+tenki_sandbox/aio/ssh.py,sha256=O-ONv_QoKzp7dlNRSYYer_M0pREpgjD9Xa51s-fo4Cs,5699
+tenki_sandbox/aio/tunnel.py,sha256=hBFnCFoy6MR7ZB9cKySOwsTRcw6kSRIzEXYrrwcltT0,16831
+tenki-0.5.1.dist-info/METADATA,sha256=kJ5UtxKdgrltvwkj8dyi57OGbhsegeYtwu6RRbOxe04,10350
+tenki-0.5.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+tenki-0.5.1.dist-info/RECORD,,

tenki-0.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tenki_sandbox/__init__.py

@@ -0,0 +1,164 @@
+from .aio import AsyncClient, AsyncSandbox
+from .client import Client
+from .constants import GB, GiB, KB, KiB, MB, MiB, TB, TiB
+from .dial import DialConn
+from .tunnel import HostPortTunnel, ResilientHostPortTunnel
+from .errors import (
+    CapabilityUnavailableError,
+    CommandFailedError,
+    CommandTimeoutError,
+    FileNotFoundError,
+    GitOperationFailedError,
+    InboundDisabledError,
+    InvalidResourceConfigError,
+    InvalidStateError,
+    MissingAuthTokenError,
+    PaginationStalledError,
+    PermissionDeniedError,
+    PortLimitExceededError,
+    PrimitiveTimeoutError,
+    QuotaExceededError,
+    RateLimitedError,
+    RegistryImageNotFoundError,
+    SSHUnavailableError,
+    SandboxError,
+    SessionNotFoundError,
+    SessionTerminatedError,
+    SnapshotNotDurableError,
+    SnapshotNotFoundError,
+    StreamClosedError,
+    TemplateBuildFailedError,
+    TemplateBuildInProgressError,
+    TemplateBuildWaitCancelledError,
+    TemplateRuntimeFailedError,
+    TemplateExistsError,
+    TemplateNotFoundError,
+    TemplateSpecValidationError,
+    UnauthorizedError,
+    VolumeInUseError,
+    VolumeNotFoundError,
+    VolumeSyncPendingError,
+)
+from .models import (
+    CommandResult,
+    ExposedPort,
+    FileInfo,
+    Identity,
+    IdentityWorkspace,
+    Image,
+    PreviewUrl,
+    RegistryImage,
+    RegistryImageDetail,
+    RegistryImageSummary,
+    RegistryListResult,
+    RegistryShareGrant,
+    RegistryShareResult,
+    RegistryTag,
+    RegistryVersionDeleteResult,
+    ResolvedRegistryRef,
+    SSHCert,
+    SandboxInfo,
+    Snapshot,
+    SnapshotDownloadURL,
+    Template,
+    TemplateBuild,
+    TemplateBuildEvent,
+    TemplateBuildFailure,
+    TemplateBuildLogEvent,
+    TemplateBuildProgressEvent,
+    TemplateBuildProvenance,
+    TemplateBuildStepReference,
+    TunnelTermination,
+    Volume,
+    VolumeAttachment,
+    WorkspaceUsageLimit,
+)
+from .sandbox import Sandbox
+from .ssh import SSHConn
+from .template_spec import TemplateSpec
+
+__all__ = [
+    "Client",
+    "Sandbox",
+    "AsyncClient",
+    "AsyncSandbox",
+    "SSHConn",
+    "DialConn",
+    "HostPortTunnel",
+    "ResilientHostPortTunnel",
+    "TunnelTermination",
+    "WorkspaceUsageLimit",
+    "SandboxError",
+    "MissingAuthTokenError",
+    "PaginationStalledError",
+    "UnauthorizedError",
+    "PermissionDeniedError",
+    "SessionNotFoundError",
+    "SessionTerminatedError",
+    "InvalidStateError",
+    "InvalidResourceConfigError",
+    "CommandTimeoutError",
+    "FileNotFoundError",
+    "GitOperationFailedError",
+    "CommandFailedError",
+    "CapabilityUnavailableError",
+    "PrimitiveTimeoutError",
+    "QuotaExceededError",
+    "PortLimitExceededError",
+    "InboundDisabledError",
+    "RateLimitedError",
+    "SSHUnavailableError",
+    "VolumeNotFoundError",
+    "VolumeInUseError",
+    "VolumeSyncPendingError",
+    "SnapshotNotDurableError",
+    "SnapshotNotFoundError",
+    "TemplateNotFoundError",
+    "TemplateExistsError",
+    "TemplateBuildFailedError",
+    "TemplateBuildInProgressError",
+    "TemplateBuildWaitCancelledError",
+    "TemplateRuntimeFailedError",
+    "TemplateSpecValidationError",
+    "StreamClosedError",
+    "RegistryImageNotFoundError",
+    "RegistryImage",
+    "RegistryImageDetail",
+    "RegistryImageSummary",
+    "RegistryListResult",
+    "RegistryShareGrant",
+    "RegistryShareResult",
+    "RegistryTag",
+    "RegistryVersionDeleteResult",
+    "ResolvedRegistryRef",
+    "SSHCert",
+    "CommandResult",
+    "ExposedPort",
+    "FileInfo",
+    "Identity",
+    "IdentityWorkspace",
+    "Image",
+    "PreviewUrl",
+    "SandboxInfo",
+    "Snapshot",
+    "SnapshotDownloadURL",
+    "Template",
+    "TemplateBuild",
+    "TemplateSpec",
+    "TemplateBuildEvent",
+    "TemplateBuildFailure",
+    "TemplateBuildLogEvent",
+    "TemplateBuildProgressEvent",
+    "TemplateBuildProvenance",
+    "TemplateBuildStepReference",
+    "Volume",
+    "VolumeAttachment",
+    "KB",
+    "MB",
+    "GB",
+    "TB",
+    "KiB",
+    "MiB",
+    "GiB",
+    "TiB",
+]