Errors

BuildLogInterruptedError

class BuildLogInterruptedError(DaytonaError)

Observation failed; cursor is the last successfully delivered checkpoint.

A callback failure is never retried. Its cause may have partially applied application effects; persist output and cursor together before resuming.

BuildLogInterruptedError.init

def __init__(message: str,
             *,
             cursor: str | None = None,
             code: str = 'BUILD_LOG_INTERRUPTED',
             status_code: int | None = None) -> None

DaytonaError

class DaytonaError(Exception)

Base class for all SDK errors.

DaytonaError.init

def __init__(message: str,
             *,
             status_code: Optional[int] = None,
             code: Optional[str] = None,
             source: Optional[str] = None,
             details: Optional[ErrorDetails] = None) -> None

SandboxCreateTimeoutError

class SandboxCreateTimeoutError(RequestTimeoutError)

create() ran out of caller budget while the sandbox was still starting.

The sandbox was created and is left running; sandbox_id lets the caller pick it up (daytona.sandbox(sandbox_id)) or delete it.

SandboxCreateTimeoutError.init

def __init__(sandbox_id: str) -> None

DockerWaitTimeoutError

class DockerWaitTimeoutError(RequestTimeoutError)

sandbox.docker.wait_until_ready() ran out of caller budget before Docker was ready.

status is the last observed Docker status (starting, or deferred while the boot has not started Docker yet), or None when no status answer arrived before the deadline (for example a stalled first request).

DockerWaitTimeoutError.init

def __init__(status: Optional[DockerStatus]) -> None

ConflictError

class ConflictError(DaytonaError)

HTTP 409.

DockerNotReadyError

class DockerNotReadyError(ConflictError)

sandbox.docker.wait_until_ready() saw Docker settle in a state that cannot become ready.

The terminal states are failed, not_present, disabled, unmanaged, unsupported, and deferred with reason function-ready-template. status is the observed Docker status; its reason says why, and process_id (when set) names the process whose logs hold Docker's output. The sandbox itself stays usable.

DockerNotReadyError.init

def __init__(status: DockerStatus) -> None

SandboxTerminalStateError

class SandboxTerminalStateError(ConflictError)

wait_for_state() saw the sandbox reach a terminal state before any target.

state is the observed public sandbox state (e.g. "destroyed").

SandboxTerminalStateError.init

def __init__(sandbox_id: str,
             state: SandboxState,
             *,
             raw_state: Optional[str] = None) -> None

PreconditionFailedError

class PreconditionFailedError(DaytonaError)

HTTP 412 — the If-Match revision no longer matches (network policy CAS).

GoneError

class GoneError(DaytonaError)

HTTP 410.

MethodNotAllowedError

class MethodNotAllowedError(DaytonaError)

HTTP 405.

PayloadTooLargeError

class PayloadTooLargeError(DaytonaError)

HTTP 413.

UnsupportedMediaTypeError

class UnsupportedMediaTypeError(DaytonaError)

HTTP 415.

UnprocessableEntityError

class UnprocessableEntityError(DaytonaError)

HTTP 422.

RateLimitError

class RateLimitError(DaytonaError)

HTTP 429.

LimitExceededError

class LimitExceededError(RateLimitError)

LIMIT_EXCEEDED (429): an organization limit is exhausted.

Subclasses RateLimitError, so except RateLimitError keeps matching; limit is the limit's stable machine name (e.g. max_concurrent_vms) and current/max are the counts the refusal was computed from. Attributes are None when a body omits or malforms them.

PreconditionRequiredError

class PreconditionRequiredError(DaytonaError)

ServiceUnavailableError

class ServiceUnavailableError(DaytonaError)

HTTP 503.

InternalServerError

class InternalServerError(DaytonaError)

HTTP 5xx.

NotSupportedError

class NotSupportedError(InternalServerError)

ConnectionError

class ConnectionError(DaytonaError)

Network connection failure.

ClientTimeoutError

class ClientTimeoutError(DaytonaError)

Client-side transport timeout.

TransferCancelledError

class TransferCancelledError(DaytonaError)

A local file transfer was cancelled before completion.

SandboxCreateRequestTimeoutError

class SandboxCreateRequestTimeoutError(ClientTimeoutError)

The create() request itself timed out before the server answered.

The server may still have created the sandbox. idempotency_key is the key the request was sent with. Retry with that key and the identical source and create arguments, in the same project and coordinator or cell, to recover the sandbox (or create it if the first request never landed). New records reject changed requests; historical mappings without a request digest may replay the original without detecting changes.

SandboxCreateRequestTimeoutError.init

def __init__(idempotency_key: str) -> None

SandboxCreateConnectionError

class SandboxCreateConnectionError(ConnectionError)

The connection failed while the create() request was in flight.

Same outcome as SandboxCreateRequestTimeoutError: the sandbox may or may not exist; retry create() with the same idempotency_key, source and create arguments, in the same project and coordinator or cell.

SandboxCreateConnectionError.init

def __init__(idempotency_key: str, detail: str) -> None

ProcessNotFoundError

class ProcessNotFoundError(NotFoundError)

PROCESS_NOT_FOUND.

ProcessStartFailedError

class ProcessStartFailedError(BadRequestError)

PROCESS_START_FAILED.

ProcessTerminalError

class ProcessTerminalError(ConflictError)

PROCESS_TERMINAL.

ProcessExecutionTimeoutError

class ProcessExecutionTimeoutError(RequestTimeoutError)

PROCESS_EXECUTION_TIMEOUT.

NameConflictError

class NameConflictError(ConflictError)

NAME_CONFLICT.

InvalidCursorError

class InvalidCursorError(BadRequestError)

INVALID_CURSOR.

CursorExpiredError

class CursorExpiredError(ConflictError)

CURSOR_EXPIRED.

StdinClosedError

class StdinClosedError(ConflictError)

STDIN_CLOSED.

StdinUnavailableError

class StdinUnavailableError(ConflictError)

STDIN_UNAVAILABLE.

ProtectedProcessError

class ProtectedProcessError(ForbiddenError)

PROTECTED_PROCESS.

UnsupportedOperationError

class UnsupportedOperationError(BadRequestError)

UNSUPPORTED_OPERATION.

SessionNotFoundError

class SessionNotFoundError(NotFoundError)

SESSION_NOT_FOUND.

SessionEndedError

class SessionEndedError(GoneError)

SESSION_ENDED.

KernelUnavailableError

class KernelUnavailableError(ServiceUnavailableError)

KERNEL_UNAVAILABLE.

LspServerUnavailableError

class LspServerUnavailableError(ServiceUnavailableError)

LSP_SERVER_UNAVAILABLE.

LspNotStartedError

class LspNotStartedError(ConflictError)

LSP_NOT_STARTED.

AddonUnavailableError

class AddonUnavailableError(ServiceUnavailableError)

ADDON_UNAVAILABLE.

FileNotFoundError

class FileNotFoundError(NotFoundError)

FILE_NOT_FOUND.

InvalidFilePathError

class InvalidFilePathError(BadRequestError)

INVALID_FILE_PATH.

FileAccessDeniedError

class FileAccessDeniedError(ForbiddenError)

FILE_ACCESS_DENIED.

FileReadFailedError

class FileReadFailedError(InternalServerError)

FILE_READ_FAILED.

GitAuthFailedError

class GitAuthFailedError(UnauthorizedError)

GIT_AUTH_FAILED.

GitRepoNotFoundError

class GitRepoNotFoundError(NotFoundError)

GIT_REPO_NOT_FOUND.

GitBranchNotFoundError

class GitBranchNotFoundError(NotFoundError)

GIT_BRANCH_NOT_FOUND.

GitBranchExistsError

class GitBranchExistsError(ConflictError)

GIT_BRANCH_EXISTS.

DesktopNotReadyError

class DesktopNotReadyError(ConflictError)

DESKTOP_NOT_READY.

FsFreezeUnsupportedError

class FsFreezeUnsupportedError(ConflictError)

FS_FREEZE_UNSUPPORTED (runner-only control route).

NoDefaultGatewayError

class NoDefaultGatewayError(ServiceUnavailableError)

NO_DEFAULT_GATEWAY (runner-only control route; retry).

AtomicUploadUnsupportedError

class AtomicUploadUnsupportedError(ConflictError)

ATOMIC_UPLOAD_UNSUPPORTED.

OrgSuspendedError

class OrgSuspendedError(DaytonaError)

ProjectBudgetExceededError

class ProjectBudgetExceededError(DaytonaError)

PROJECT_BUDGET_EXCEEDED (402): the project reached its monthly budget.

New sandboxes cannot start in the project until the budget is raised or removed, or the next calendar month (UTC) begins.

RateLimitedError

class RateLimitedError(RateLimitError)

OverloadedError

class OverloadedError(RateLimitError)

NotSupportedForClassError

class NotSupportedForClassError(ConflictError)

UnsupportedVolumeTypeError

class UnsupportedVolumeTypeError(BadRequestError)

BucketCreateFailedError

class BucketCreateFailedError(InternalServerError)

BucketDeleteFailedError

class BucketDeleteFailedError(InternalServerError)

BucketNotEmptyError

class BucketNotEmptyError(ConflictError)

OriginImportOnlyError

class OriginImportOnlyError(BadRequestError)

ReadOnlyUnsupportedError

class ReadOnlyUnsupportedError(BadRequestError)

BillingDisabledError

class BillingDisabledError(NotSupportedError)

BillingUnreachableError

class BillingUnreachableError(InternalServerError)

SearchNotConfiguredError

class SearchNotConfiguredError(NotSupportedError)

SearchUnavailableError

class SearchUnavailableError(ServiceUnavailableError)

SandboxWakingError

class SandboxWakingError(ServiceUnavailableError)

SandboxNotRunningError

class SandboxNotRunningError(ConflictError)

SandboxStartFailedError

class SandboxStartFailedError(ConflictError)

ImageNotFoundError

class ImageNotFoundError(NotFoundError)

ImageNotReadyError

class ImageNotReadyError(ConflictError)

ImageFormatOutdatedError

class ImageFormatOutdatedError(ConflictError)

IMAGE_FORMAT_OUTDATED (409): the image is stored in an older format than the current one (Image.format_outdated) and this door cannot convert it. Convert it with POST /images/{id}/convert, or create a Linux sandbox from it, which converts it first.

ImageBuildFailedError

class ImageBuildFailedError(ConflictError)

IMAGE_BUILD_FAILED (409), or the SDK-minted refusal when create_from_build()'s image build ends failed. image_id names the failed image (so its build log can be fetched) when the SDK knows it; build_error is the build's recorded error, when any.

ImageBuildFailedError.init

def __init__(message: str,
             *,
             status_code: Optional[int] = None,
             code: Optional[str] = None,
             source: Optional[str] = None,
             details: Optional[ErrorDetails] = None,
             image_id: Optional[str] = None,
             build_error: Optional[str] = None) -> None

ImageClassMismatchError

class ImageClassMismatchError(ConflictError)

ImageNameTakenError

class ImageNameTakenError(ConflictError)

ImageNameReservedError

class ImageNameReservedError(BadRequestError)

IdleOutOfRangeError

class IdleOutOfRangeError(BadRequestError)

CreateTtlOutOfRangeError

class CreateTtlOutOfRangeError(BadRequestError)

SnapshotNotFoundError

class SnapshotNotFoundError(NotFoundError)

SnapshotNotReadyError

class SnapshotNotReadyError(ConflictError)

SnapshotClassMismatchError

class SnapshotClassMismatchError(ConflictError)

DaytonaValidationError

DaytonaValidationError = BadRequestError

DaytonaAuthenticationError

DaytonaAuthenticationError = UnauthorizedError

DaytonaAuthorizationError

DaytonaAuthorizationError = ForbiddenError

DaytonaNotFoundError

DaytonaNotFoundError = NotFoundError

DaytonaConflictError

DaytonaConflictError = ConflictError

DaytonaRateLimitError

DaytonaRateLimitError = RateLimitError

DaytonaTimeoutError

DaytonaTimeoutError = ClientTimeoutError

DaytonaConnectionError

DaytonaConnectionError = ConnectionError

DaytonaNotSupportedError

DaytonaNotSupportedError = NotSupportedError

On this page

Computersfor Agents