blaxel 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/workspace_status.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+
+class WorkspaceStatus(str, Enum):
+    ACCOUNT_BINDED = "account_binded"
+    ACCOUNT_CONFIGURED = "account_configured"
+    CREATED = "created"
+    ERROR = "error"
+    READY = "ready"
+    WORKSPACE_CONFIGURED = "workspace_configured"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "WorkspaceStatus | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/common/__init__.py

@@ -1,7 +1,7 @@
 from .autoload import autoload
 from .env import env
-from .sentry import capture_exception, flush_sentry, init_sentry, is_sentry_initialized
 from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
+from .sentry import capture_exception, flush_sentry, init_sentry, is_sentry_initialized
 from .settings import Settings, settings
 from .webhook import (
     AsyncSidecarCallback,

blaxel/core/jobs/__init__.py

@@ -229,7 +229,6 @@ class BlJob:
             client=client,
             body=request,
         )
-
         if response.status_code != 200:
             raise Exception(f"Failed to create job execution: {response.status_code}")
 

blaxel/core/sandbox/__init__.py

@@ -6,6 +6,7 @@ from .client.models import (
 )
 from .default import (
     CodeInterpreter,
+    SandboxAPIError,
     SandboxCodegen,
     SandboxFileSystem,
     SandboxInstance,
@@ -34,6 +35,7 @@ from .types import (
 
 __all__ = [
     "SandboxInstance",
+    "SandboxAPIError",
     "SessionCreateOptions",
     "SessionWithToken",
     "SandboxConfiguration",

blaxel/core/sandbox/client/api/process/post_process.py

@@ -77,7 +77,8 @@ def sync_detailed(
 ) -> Response[Union[ErrorResponse, ProcessResponse]]:
     """Execute a command
 
-     Execute a command and return process information
+     Execute a command and return process information. If Accept header is text/event-stream, streams
+    logs in SSE format and returns the process response as a final event.
 
     Args:
         body (ProcessRequest):
@@ -108,7 +109,8 @@ def sync(
 ) -> Union[ErrorResponse, ProcessResponse] | None:
     """Execute a command
 
-     Execute a command and return process information
+     Execute a command and return process information. If Accept header is text/event-stream, streams
+    logs in SSE format and returns the process response as a final event.
 
     Args:
         body (ProcessRequest):
@@ -134,7 +136,8 @@ async def asyncio_detailed(
 ) -> Response[Union[ErrorResponse, ProcessResponse]]:
     """Execute a command
 
-     Execute a command and return process information
+     Execute a command and return process information. If Accept header is text/event-stream, streams
+    logs in SSE format and returns the process response as a final event.
 
     Args:
         body (ProcessRequest):
@@ -163,7 +166,8 @@ async def asyncio(
 ) -> Union[ErrorResponse, ProcessResponse] | None:
     """Execute a command
 
-     Execute a command and return process information
+     Execute a command and return process information. If Accept header is text/event-stream, streams
+    logs in SSE format and returns the process response as a final event.
 
     Args:
         body (ProcessRequest):

blaxel/core/sandbox/client/models/__init__.py

@@ -41,7 +41,6 @@ from .subdirectory import Subdirectory
 from .success_response import SuccessResponse
 from .tree_request import TreeRequest
 from .tree_request_files import TreeRequestFiles
-from .welcome_response import WelcomeResponse
 
 __all__ = (
     "ApplyEditRequest",
@@ -83,5 +82,4 @@ __all__ = (
     "SuccessResponse",
     "TreeRequest",
     "TreeRequestFiles",
-    "WelcomeResponse",
 )

blaxel/core/sandbox/client/models/process_response.py

@@ -21,6 +21,8 @@ class ProcessResponse:
         pid (str):  Example: 1234.
         started_at (str):  Example: Wed, 01 Jan 2023 12:00:00 GMT.
         status (ProcessResponseStatus):  Example: running.
+        stderr (str):  Example: stderr output.
+        stdout (str):  Example: stdout output.
         working_dir (str):  Example: /home/user.
         max_restarts (Union[Unset, int]):  Example: 3.
         restart_count (Union[Unset, int]):  Example: 2.
@@ -35,6 +37,8 @@ class ProcessResponse:
     pid: str
     started_at: str
     status: ProcessResponseStatus
+    stderr: str
+    stdout: str
     working_dir: str
     max_restarts: Union[Unset, int] = UNSET
     restart_count: Union[Unset, int] = UNSET
@@ -58,6 +62,10 @@ class ProcessResponse:
 
         status = self.status.value
 
+        stderr = self.stderr
+
+        stdout = self.stdout
+
         working_dir = self.working_dir
 
         max_restarts = self.max_restarts
@@ -78,6 +86,8 @@ class ProcessResponse:
                 "pid": pid,
                 "startedAt": started_at,
                 "status": status,
+                "stderr": stderr,
+                "stdout": stdout,
                 "workingDir": working_dir,
             }
         )
@@ -111,6 +121,10 @@ class ProcessResponse:
 
         status = ProcessResponseStatus(d.pop("status"))
 
+        stderr = d.pop("stderr")
+
+        stdout = d.pop("stdout")
+
         working_dir = d.pop("workingDir") if "workingDir" in d else d.pop("working_dir")
 
         max_restarts = d.pop("maxRestarts", d.pop("max_restarts", UNSET))
@@ -128,6 +142,8 @@ class ProcessResponse:
             pid=pid,
             started_at=started_at,
             status=status,
+            stderr=stderr,
+            stdout=stdout,
             working_dir=working_dir,
             max_restarts=max_restarts,
             restart_count=restart_count,

blaxel/core/sandbox/client/models/process_response_status.py

@@ -10,3 +10,12 @@ class ProcessResponseStatus(str, Enum):
 
     def __str__(self) -> str:
         return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "ProcessResponseStatus | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/sandbox/default/__init__.py

@@ -1,5 +1,6 @@
 from .interpreter import CodeInterpreter
 from .sandbox import (
+    SandboxAPIError,
     SandboxCodegen,
     SandboxFileSystem,
     SandboxInstance,
@@ -9,6 +10,7 @@ from .sandbox import (
 
 __all__ = [
     "SandboxInstance",
+    "SandboxAPIError",
     "SandboxFileSystem",
     "SandboxPreviews",
     "SandboxProcess",

blaxel/core/sandbox/default/interpreter.py

@@ -52,7 +52,7 @@ class CodeInterpreter(SandboxInstance):
         }
 
         # Whitelist a minimal set of fields that can be propagated from input
-        allowed_copy_keys = {"name", "envs", "memory", "region", "headers"}
+        allowed_copy_keys = {"name", "envs", "memory", "region", "headers", "labels"}
 
         if isinstance(sandbox, dict):
             for k in allowed_copy_keys:
@@ -67,10 +67,14 @@ class CodeInterpreter(SandboxInstance):
                 payload["memory"] = sandbox.memory
             if getattr(sandbox, "region", None):
                 payload["region"] = sandbox.region
+            if getattr(sandbox, "labels", None):
+                payload["labels"] = sandbox.labels
         elif isinstance(sandbox, Sandbox):
             # Extract a few basics if available
             if sandbox.metadata and getattr(sandbox.metadata, "name", None):
                 payload["name"] = sandbox.metadata.name
+            if sandbox.metadata and getattr(sandbox.metadata, "labels", None):
+                payload["labels"] = sandbox.metadata.labels
             if sandbox.spec and sandbox.spec.runtime:
                 if getattr(sandbox.spec.runtime, "envs", None):
                     payload["envs"] = sandbox.spec.runtime.envs

blaxel/core/sandbox/default/preview.py

@@ -29,6 +29,7 @@ from ...client.models import (
     Preview,
     PreviewSpec,
     PreviewToken,
+    PreviewTokenMetadata,
     PreviewTokenSpec,
     Sandbox,
 )
@@ -69,9 +70,10 @@ class SandboxPreviewTokens:
             self.resource_name,
             self.preview_name,
             body=PreviewToken(
+                metadata=PreviewTokenMetadata(name=""),
                 spec=PreviewTokenSpec(
                     expires_at=to_utc_z(expires_at),
-                )
+                ),
             ),
             client=client,
         )

blaxel/core/sandbox/default/sandbox.py

@@ -1,6 +1,6 @@
 import logging
 import uuid
-from typing import Any, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union
 
 from ...client.api.compute.create_sandbox import asyncio as create_sandbox
 from ...client.api.compute.delete_sandbox import asyncio as delete_sandbox
@@ -8,7 +8,9 @@ from ...client.api.compute.get_sandbox import asyncio as get_sandbox
 from ...client.api.compute.list_sandboxes import asyncio as list_sandboxes
 from ...client.api.compute.update_sandbox import asyncio as update_sandbox
 from ...client.client import client
-from ...client.models import Metadata, Runtime, Sandbox, SandboxSpec
+from ...client.models import Metadata, Sandbox, SandboxRuntime, SandboxSpec
+from ...client.models.error import Error
+from ...client.models.sandbox_error import SandboxError
 from ...client.types import UNSET
 from ..types import (
     SandboxConfiguration,
@@ -23,10 +25,40 @@ from .preview import SandboxPreviews
 from .process import SandboxProcess
 from .session import SandboxSessions
 
+
+class SandboxAPIError(Exception):
+    """Exception raised when sandbox API returns an error."""
+
+    def __init__(self, message: str, status_code: int | None = None, code: str | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+
+
 logger = logging.getLogger(__name__)
 
 
+class _AsyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SandboxInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            async def instance_delete() -> Sandbox:
+                return await self._delete_func(instance.metadata.name)
+
+            return instance_delete
+
+
 class SandboxInstance:
+    delete: "_AsyncDeleteDescriptor"
+
     def __init__(
         self,
         sandbox: Union[Sandbox, SandboxConfiguration],
@@ -107,6 +139,7 @@ class SandboxInstance:
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "snapshot_enabled"
                     in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "labels" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -135,14 +168,13 @@ class SandboxInstance:
 
             # Create full Sandbox object
             sandbox = Sandbox(
-                metadata=Metadata(name=name),
+                metadata=Metadata(name=name, labels=config.labels),
                 spec=SandboxSpec(
-                    runtime=Runtime(
+                    runtime=SandboxRuntime(
                         image=image,
                         memory=memory,
                         ports=ports,
                         envs=envs,
-                        generation="mk3",
                     ),
                     volumes=volumes,
                 ),
@@ -167,19 +199,26 @@ class SandboxInstance:
                 sandbox.metadata = Metadata(name=default_name)
             if not sandbox.spec:
                 sandbox.spec = SandboxSpec(
-                    runtime=Runtime(image=default_image, memory=default_memory)
+                    runtime=SandboxRuntime(image=default_image, memory=default_memory)
                 )
             if not sandbox.spec.runtime:
-                sandbox.spec.runtime = Runtime(image=default_image, memory=default_memory)
+                sandbox.spec.runtime = SandboxRuntime(image=default_image, memory=default_memory)
 
             sandbox.spec.runtime.image = sandbox.spec.runtime.image or default_image
             sandbox.spec.runtime.memory = sandbox.spec.runtime.memory or default_memory
-            sandbox.spec.runtime.generation = sandbox.spec.runtime.generation or "mk3"
 
         response = await create_sandbox(
             client=client,
             body=sandbox,
         )
+
+        # Check if response is an error
+        if isinstance(response, SandboxError):
+            status_code = response.status_code if response.status_code is not UNSET else None
+            code = response.code if response.code else None
+            message = response.message if response.message else str(response)
+            raise SandboxAPIError(message, status_code=status_code, code=code)
+
         instance = cls(response)
         # TODO remove this part once we have a better way to handle this
         if safe:
@@ -195,21 +234,23 @@ class SandboxInstance:
             sandbox_name,
             client=client,
         )
+
+        # Check if response is an error
+        if isinstance(response, Error):
+            status_code = response.code if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise SandboxAPIError(message, status_code=status_code, code=response.error)
+
+        if response is None:
+            raise SandboxAPIError(f"Sandbox '{sandbox_name}' not found", status_code=404)
+
         return cls(response)
 
     @classmethod
     async def list(cls) -> List["SandboxInstance"]:
-        response = await list_sandboxes()
+        response = await list_sandboxes(client=client)
         return [cls(sandbox) for sandbox in response]
 
-    @classmethod
-    async def delete(cls, sandbox_name: str) -> Sandbox:
-        response = await delete_sandbox(
-            sandbox_name,
-            client=client,
-        )
-        return response
-
     @classmethod
     async def update_metadata(
         cls, sandbox_name: str, metadata: SandboxUpdateMetadata
@@ -229,10 +270,12 @@ class SandboxInstance:
 
         # Prepare the updated sandbox object
         updated_sandbox = Sandbox.from_dict(sandbox.to_dict())
+        if updated_sandbox is None:
+            raise ValueError(f"Sandbox {sandbox_name} not found")
 
         # Merge metadata
         if updated_sandbox.metadata is None:
-            updated_sandbox.metadata = Metadata()
+            updated_sandbox.metadata = Metadata(name=sandbox_name)
 
         # Update labels if provided
         if metadata.labels is not None:
@@ -240,8 +283,11 @@ class SandboxInstance:
             if updated_sandbox.metadata.labels is None or updated_sandbox.metadata.labels is UNSET:
                 updated_sandbox.metadata.labels = {}
             else:
-                # If labels exist, ensure it's a dict
-                updated_sandbox.metadata.labels = dict(updated_sandbox.metadata.labels)
+                # If labels exist, convert to dict (MetadataLabels stores in additional_properties)
+                if hasattr(updated_sandbox.metadata.labels, "to_dict"):
+                    updated_sandbox.metadata.labels = updated_sandbox.metadata.labels.to_dict()
+                else:
+                    updated_sandbox.metadata.labels = dict(updated_sandbox.metadata.labels)
             updated_sandbox.metadata.labels.update(metadata.labels)
 
         # Update display_name if provided
@@ -265,11 +311,9 @@ class SandboxInstance:
         """Create a sandbox if it doesn't exist, otherwise return existing."""
         try:
             return await cls.create(sandbox)
-        except Exception as e:
+        except SandboxAPIError as e:
             # Check if it's a 409 conflict error (sandbox already exists)
-            if (hasattr(e, "status_code") and e.status_code == 409) or (
-                hasattr(e, "code") and e.code in [409, "SANDBOX_ALREADY_EXISTS"]
-            ):
+            if e.status_code == 409 or e.code in [409, "SANDBOX_ALREADY_EXISTS"]:
                 # Extract name from different configuration types
                 if isinstance(sandbox, SandboxCreateConfiguration):
                     name = sandbox.name
@@ -298,7 +342,7 @@ class SandboxInstance:
 
                 # Otherwise return the existing active sandbox
                 return sandbox_instance
-            raise e
+            raise
 
     @classmethod
     async def from_session(
@@ -310,7 +354,7 @@ class SandboxInstance:
 
         # Create a minimal sandbox configuration for session-based access
         sandbox_name = session.name.split("-")[0] if "-" in session.name else session.name
-        sandbox = Sandbox(metadata=Metadata(name=sandbox_name))
+        sandbox = Sandbox(metadata=Metadata(name=sandbox_name), spec=SandboxSpec())
 
         # Use the constructor with force_url, headers, and params
         return cls(
@@ -319,3 +363,18 @@ class SandboxInstance:
             headers={"X-Blaxel-Preview-Token": session.token},
             params={"bl_preview_token": session.token},
         )
+
+
+async def _delete_sandbox_by_name(sandbox_name: str) -> Sandbox:
+    """Delete a sandbox by name."""
+    response = await delete_sandbox(
+        sandbox_name,
+        client=client,
+    )
+    if response is None:
+        raise ValueError(f"Sandbox {sandbox_name} not found")
+    return response
+
+
+# Assign the delete descriptor to support both class-level and instance-level calls
+SandboxInstance.delete = _AsyncDeleteDescriptor(_delete_sandbox_by_name)

blaxel/core/sandbox/sync/process.py

@@ -186,7 +186,8 @@ class SyncSandboxProcess(SyncSandboxAction):
 
                 if on_log or on_stdout or on_stderr:
                     stream_control = self._stream_logs(
-                        result.pid, {"on_log": on_log, "on_stdout": on_stdout, "on_stderr": on_stderr}
+                        result.pid,
+                        {"on_log": on_log, "on_stdout": on_stdout, "on_stderr": on_stderr},
                     )
                     return ProcessResponseWithLog(
                         result,

blaxel/core/sandbox/sync/sandbox.py

@@ -1,6 +1,6 @@
 import logging
 import uuid
-from typing import Any, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union
 
 from ...client.api.compute.create_sandbox import sync as create_sandbox
 from ...client.api.compute.delete_sandbox import sync as delete_sandbox
@@ -8,8 +8,11 @@ from ...client.api.compute.get_sandbox import sync as get_sandbox
 from ...client.api.compute.list_sandboxes import sync as list_sandboxes
 from ...client.api.compute.update_sandbox import sync as update_sandbox
 from ...client.client import client
-from ...client.models import Metadata, Runtime, Sandbox, SandboxSpec
+from ...client.models import Metadata, Sandbox, SandboxRuntime, SandboxSpec
+from ...client.models.error import Error
+from ...client.models.sandbox_error import SandboxError
 from ...client.types import UNSET
+from ..default.sandbox import SandboxAPIError
 from ..types import (
     SandboxConfiguration,
     SandboxCreateConfiguration,
@@ -26,6 +29,24 @@ from .session import SyncSandboxSessions
 logger = logging.getLogger(__name__)
 
 
+class _SyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SyncSandboxInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            def instance_delete() -> Sandbox:
+                return self._delete_func(instance.metadata.name)
+
+            return instance_delete
+
+
 class SyncSandboxInstance:
     def __init__(
         self,
@@ -102,6 +123,7 @@ class SyncSandboxInstance:
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "snapshot_enabled"
                     in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "labels" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -125,14 +147,13 @@ class SyncSandboxInstance:
             region = config.region
             lifecycle = config.lifecycle
             sandbox = Sandbox(
-                metadata=Metadata(name=name),
+                metadata=Metadata(name=name, labels=config.labels),
                 spec=SandboxSpec(
-                    runtime=Runtime(
+                    runtime=SandboxRuntime(
                         image=image,
                         memory=memory,
                         ports=ports,
                         envs=envs,
-                        generation="mk3",
                     ),
                     volumes=volumes,
                 ),
@@ -152,17 +173,24 @@ class SyncSandboxInstance:
                 sandbox.metadata = Metadata(name=default_name)
             if not sandbox.spec:
                 sandbox.spec = SandboxSpec(
-                    runtime=Runtime(image=default_image, memory=default_memory)
+                    runtime=SandboxRuntime(image=default_image, memory=default_memory)
                 )
             if not sandbox.spec.runtime:
-                sandbox.spec.runtime = Runtime(image=default_image, memory=default_memory)
+                sandbox.spec.runtime = SandboxRuntime(image=default_image, memory=default_memory)
             sandbox.spec.runtime.image = sandbox.spec.runtime.image or default_image
             sandbox.spec.runtime.memory = sandbox.spec.runtime.memory or default_memory
-            sandbox.spec.runtime.generation = sandbox.spec.runtime.generation or "mk3"
         response = create_sandbox(
             client=client,
             body=sandbox,
         )
+
+        # Check if response is an error
+        if isinstance(response, SandboxError):
+            status_code = response.status_code if response.status_code is not UNSET else None
+            code = response.code if response.code else None
+            message = response.message if response.message else str(response)
+            raise SandboxAPIError(message, status_code=status_code, code=code)
+
         instance = cls(response)
         if safe:
             try:
@@ -177,6 +205,16 @@ class SyncSandboxInstance:
             sandbox_name,
             client=client,
         )
+
+        # Check if response is an error
+        if isinstance(response, Error):
+            status_code = response.code if response.code is not UNSET else None
+            message = response.message if response.message is not UNSET else response.error
+            raise SandboxAPIError(message, status_code=status_code, code=response.error)
+
+        if response is None:
+            raise SandboxAPIError(f"Sandbox '{sandbox_name}' not found", status_code=404)
+
         return cls(response)
 
     @classmethod
@@ -184,14 +222,6 @@ class SyncSandboxInstance:
         response = list_sandboxes(client=client)
         return [cls(sandbox) for sandbox in response]
 
-    @classmethod
-    def delete(cls, sandbox_name: str) -> Sandbox:
-        response = delete_sandbox(
-            sandbox_name,
-            client=client,
-        )
-        return response
-
     @classmethod
     def update_metadata(
         cls, sandbox_name: str, metadata: SandboxUpdateMetadata
@@ -205,7 +235,11 @@ class SyncSandboxInstance:
             if updated_sandbox.metadata.labels is None or updated_sandbox.metadata.labels is UNSET:
                 updated_sandbox.metadata.labels = {}
             else:
-                updated_sandbox.metadata.labels = dict(updated_sandbox.metadata.labels)
+                # MetadataLabels stores in additional_properties, use to_dict()
+                if hasattr(updated_sandbox.metadata.labels, "to_dict"):
+                    updated_sandbox.metadata.labels = updated_sandbox.metadata.labels.to_dict()
+                else:
+                    updated_sandbox.metadata.labels = dict(updated_sandbox.metadata.labels)
             updated_sandbox.metadata.labels.update(metadata.labels)
         if metadata.display_name is not None:
             updated_sandbox.metadata.display_name = metadata.display_name
@@ -222,10 +256,8 @@ class SyncSandboxInstance:
     ) -> "SyncSandboxInstance":
         try:
             return cls.create(sandbox)
-        except Exception as e:
-            if (hasattr(e, "status_code") and e.status_code == 409) or (
-                hasattr(e, "code") and e.code in [409, "SANDBOX_ALREADY_EXISTS"]
-            ):
+        except SandboxAPIError as e:
+            if e.status_code == 409 or e.code in [409, "SANDBOX_ALREADY_EXISTS"]:
                 if isinstance(sandbox, SandboxCreateConfiguration):
                     name = sandbox.name
                 elif isinstance(sandbox, dict):
@@ -245,7 +277,7 @@ class SyncSandboxInstance:
                 if sandbox_instance.status == "TERMINATED":
                     return cls.create(sandbox)
                 return sandbox_instance
-            raise e
+            raise
 
     @classmethod
     def from_session(
@@ -254,10 +286,23 @@ class SyncSandboxInstance:
         if isinstance(session, dict):
             session = SessionWithToken.from_dict(session)
         sandbox_name = session.name.split("-")[0] if "-" in session.name else session.name
-        sandbox = Sandbox(metadata=Metadata(name=sandbox_name))
+        sandbox = Sandbox(metadata=Metadata(name=sandbox_name), spec=SandboxSpec())
         return cls(
             sandbox=sandbox,
             force_url=session.url,
             headers={"X-Blaxel-Preview-Token": session.token},
             params={"bl_preview_token": session.token},
         )
+
+
+def _delete_sandbox_by_name(sandbox_name: str) -> Sandbox:
+    """Delete a sandbox by name."""
+    response = delete_sandbox(
+        sandbox_name,
+        client=client,
+    )
+    return response
+
+
+# Assign the delete descriptor to support both class-level and instance-level calls
+SyncSandboxInstance.delete = _SyncDeleteDescriptor(_delete_sandbox_by_name)