@tangle-network/sandbox 1.0.189 → 1.0.191

package/dist/{terminal-stream-types-1YKRrkZB.d.ts → terminal-stream-types-BqNv5EuG.d.ts}

@@ -1,5 +1,124 @@
 import { z } from "zod";
 
+//#region ../../../packages/runtime-contracts/dist/error-catalog.d.ts
+declare const ERROR_CATALOG: {
+  readonly VALIDATION_ERROR: "400 final | The request is malformed or a field is invalid. | Fix the field the message names and send the request again.";
+  readonly INVALID_REQUEST: "400 final | The request is malformed or a field is invalid. | Fix the field the message names and send the request again.";
+  readonly INVALID_TEXT_PART: "400 final | A text part is missing its text or is not base64-encoded UTF-8. | Base64-encode every text part, then send the request again.";
+  readonly UNAUTHORIZED: "401 final | The credential is missing, invalid or expired. | Sign in again or send a valid API key.";
+  readonly PAYMENT_REQUIRED: "402 final | The account has no balance, credit or plan for this request. | Add credit or upgrade the plan, then retry.";
+  readonly FORBIDDEN: "403 final | The caller is authenticated but not allowed to do this. | Use a credential with the role or scope the message names.";
+  readonly FEATURE_DISABLED: "403 final | This capability is switched off for this deployment or account. | Ask the operator to enable it.";
+  readonly NOT_FOUND: "404 final | The resource does not exist or this account cannot see it. | Check the id and the account or team that owns it.";
+  readonly SIDECAR_NOT_FOUND: "404 final | The sandbox runtime does not exist or this account cannot see it. | Check the sandbox id, or create the sandbox again.";
+  readonly CONFLICT: "409 final | The request conflicts with an existing resource or an earlier request. | Read the existing resource, or use a new name or idempotency key.";
+  readonly STALE_STATE: "409 final | The caller's view of the resource is stale. | Read the resource again and repeat the request against its current state.";
+  readonly INVALID_STATE: "409 final | The resource is in the wrong state for this operation. | Bring it to the state the message names, then retry.";
+  readonly IN_PROGRESS: "409 retry | Another operation holds this resource. | Wait for that operation to finish, then retry.";
+  readonly EGRESS_PROXY_RECOVERY_REQUIRED: "409 final | The egress proxy lost the credentials it serves. | Recreate the sandbox to rematerialize its egress credentials.";
+  readonly EGRESS_PROXY_SECRETS_UNAVAILABLE: "409 final | The egress proxy rebuild found no value for secrets the box still references. | Send the missing secrets the response names in one retry, or recreate the sandbox.";
+  readonly EGRESS_IN_PLACE_RELOAD_UNAVAILABLE: "409 final | The egress proxy cannot be re-keyed without a restart. | Re-key once no agent turn is streaming, allowing a proxy restart.";
+  readonly EXPIRED: "410 final | The token, decision or grant has expired. | Request a new one.";
+  readonly PAYLOAD_TOO_LARGE: "413 final | The body or artifact is over its size limit. | Send a smaller body, or split it.";
+  readonly NOT_CONNECTED: "424 final | A required integration connection is missing. | Connect the integration the message names, then retry.";
+  readonly QUOTA_EXCEEDED: "429 final | A plan or concurrency quota is reached. | Stop or delete resources, or raise the quota.";
+  readonly RATE_LIMITED: "429 retry | Too many requests in the current window. | Wait for the Retry-After interval, then retry.";
+  readonly RATE_LIMIT_EXCEEDED: "429 retry | Too many requests in the current window. | Wait for the Retry-After interval, then retry.";
+  readonly INTERNAL_ERROR: "500 final | The server failed for a reason it did not classify. | Report the request id; the request itself did not cause it.";
+  readonly OPERATION_FAILED: "500 final | A server-side operation failed. | Report the request id with the operation the message names.";
+  readonly CONFIGURATION_ERROR: "500 final | The deployment is missing configuration or has an invalid value. | The operator sets the configuration key the message names.";
+  readonly AGENT_EXECUTION_FAILED: "500 final | The agent run failed inside the sandbox. | Read the cause in the message; fix the prompt, model or credential it names.";
+  readonly BACKEND_START_FAILED: "500 final | The agent backend cannot start, and a retry fails the same way. | Fix the configuration, credential or session the cause names.";
+  readonly MESSAGE_RETRIEVAL_FAILED: "500 final | Message storage cannot serve this read. | Report the request id; the stored session needs repair.";
+  readonly UNSUPPORTED: "501 final | This operation is not supported for this runtime, harness or driver. | Choose a runtime or option that supports it.";
+  readonly UPSTREAM_ERROR: "502 retry | An upstream service failed or answered outside its contract. | Retry with backoff; report the request id if it persists.";
+  readonly UNAVAILABLE: "503 retry | A dependency or capacity is temporarily unavailable. | Retry after the Retry-After interval.";
+  readonly NOT_READY: "503 retry | The target is starting, restarting, recovering or draining. | Retry after the Retry-After interval.";
+  readonly BACKEND_UNAVAILABLE: "503 retry | The agent backend did not answer. | Retry after the Retry-After interval.";
+  readonly MESSAGE_RETRIEVAL_UNAVAILABLE: "503 retry | Message storage did not answer. | Retry after the Retry-After interval.";
+  readonly TIMEOUT: "504 retry | The operation exceeded its deadline. | Retry; if it repeats, raise the timeout or split the work.";
+  readonly KV_VALUE_TOO_LARGE: "413 final | A workflow KV value is over the per-value size cap. | Store a smaller value, or put the data in an artifact and keep its id in KV.";
+  readonly KV_KEY_LIMIT: "409 final | The workflow has reached its KV key cap. | Delete keys the workflow no longer reads, then write again.";
+  readonly KV_VERSION_CONFLICT: "409 final | Another writer changed the KV key since it was read. | Read the key again and retry the compare-and-swap against its current version.";
+  readonly PRECONDITION_FAILED: "412 final | The stored version no longer matches the request's precondition. | Read the current version or etag and send it with the request.";
+  readonly UNPROCESSABLE: "422 final | The input has nothing usable for this operation. | Record the history the message names, then ask again.";
+  readonly BASE_IMAGE_NOT_FOUND: "400 final | The requested image does not exist. | Check the image name and tag, then create again.";
+  readonly BASE_IMAGE_MISSING_BEFORE_CREATE: "400 final | The requested image does not exist; the host proved it before creating anything. | Check the image name and tag, then create again.";
+  readonly UNSUPPORTED_EGRESS_POLICY: "400 final | This runtime cannot enforce the requested egress policy. | Choose a policy the runtime supports, or another runtime.";
+  readonly UNSUPPORTED_FOR_RUNTIME: "400 final | The requested runtime cannot honour a create input. | Remove the input the message names, or choose another runtime.";
+  readonly ROOT_USER_FORBIDDEN: "403 final | The sandbox may not run as root. | Run the workload as a non-root user.";
+  readonly EGRESS_DOMAIN_NOT_ALLOWED: "403 final | The sandbox egress allowlist does not include this host. | Add the host to egressPolicy.allowDomains with box.egress.update.";
+  readonly EGRESS_REQUEST_REFUSED: "403 final | The sandbox egress policy refused this request. | Read box.egress.denials() for the rule that refused it.";
+  readonly NOT_MANAGED: "404 final | This host does not manage the named container. | Check the sandbox id; the platform resolves its host again on retry.";
+  readonly SNAPSHOT_NOT_FOUND: "404 final | The snapshot does not exist or this account cannot see it. | List the sandbox snapshots and use an id from that list.";
+  readonly BRANCH_PARENT_NOT_RUNNING: "409 final | The branch parent is not running. | Resume the parent sandbox, then branch again.";
+  readonly CONTAINER_RESERVATION_CONFLICT: "409 retry | Another lifecycle operation holds this sandbox. | Wait for that operation to finish, then retry.";
+  readonly CONTAINER_NETWORK_MISSING: "409 final | The stopped sandbox lost its network, so it cannot start in place; its files remain. | Resume the sandbox so the platform recreates it.";
+  readonly EGRESS_DISABLED: "409 final | Egress is not enabled on this host. | Place the sandbox on a host with egress enabled.";
+  readonly NATIVE_CAPTURE_UNAVAILABLE: "409 final | The host cannot prove the native capture image this create requires. | Retry on another host, or create without native capture.";
+  readonly NETWORK_ISOLATION_REQUIRED: "409 final | The create requires its own network, and the host did not place one. | Retry on a host that supports network isolation.";
+  readonly SESSION_CLAIM_MISMATCH: "409 final | The request names a session other than the one bound to this container. | Use the session id the container was created for.";
+  readonly SNAPSHOT_NOT_SYNCED: "409 retry | The snapshot has not finished uploading. | Retry after the upload completes.";
+  readonly WARM_CLAIM_REMOVED: "409 final | Another lifecycle operation removed the claimed warm sandbox. | Create the sandbox again.";
+  readonly WORKSPACE_STORAGE_MISSING: "409 final | The stopped sandbox storage is gone or replaced, so the host refused to start it. | Restore the sandbox from a snapshot.";
+  readonly RESTORE_QUOTA_EXCEEDED: "413 final | The snapshot is larger than the workspace quota. | Create with a larger disk, or restore a smaller snapshot.";
+  readonly GIT_CLONE_REFUSED: "422 final | The repository refused the clone credential, or the credential cannot see it. | Fix the git credential or repository URL, then create again.";
+  readonly BRANCH_FAILED: "500 final | The live branch of a running sandbox failed. | Report the request id; branch from a snapshot instead.";
+  readonly CONTAINER_START_FAILED: "500 retry | The host started the sandbox and its runtime failed. | Retry; if it repeats, recreate the sandbox from a snapshot.";
+  readonly GIT_CLONE_FAILED: "500 retry | Cloning the repository failed. | Retry; if it repeats, check that the repository URL is reachable.";
+  readonly GIT_CLONE_TIMEOUT: "500 retry | Cloning the repository exceeded its deadline. | Retry, or clone a smaller repository.";
+  readonly HOST_CLEANUP_UNCONFIRMED: "500 retry | The host cannot prove it removed what a failed create made. | Retry; the platform reconciles the earlier attempt first.";
+  readonly HOST_RESERVATION_COMMIT_FAILED: "500 retry | The host could not record the create after cleaning it up. | Retry the create.";
+  readonly MISSING_SIDECAR_AUTH_TOKEN: "500 final | The sandbox has no runtime auth token, so its host cannot route to it. | Recreate the sandbox.";
+  readonly SNAPSHOT_RESTORE_FAILED: "500 final | Restoring the snapshot into the sandbox failed; no empty workspace was served. | Report the request id, or restore another snapshot.";
+  readonly VM_START_FAILED: "500 retry | The microVM failed to start. | Retry; if it repeats, recreate the sandbox.";
+  readonly SIDECAR_UPSTREAM_UNAVAILABLE: "502 retry | The host could not reach the sandbox runtime. | Retry; the request may have reached the sandbox.";
+  readonly BRANCH_UFFD_UNAVAILABLE: "503 retry | The parent host cannot fork live memory now. | Retry, or branch from a snapshot.";
+  readonly CAPACITY_EXHAUSTED: "503 retry | No host has room for this sandbox now. | Retry after the Retry-After interval.";
+  readonly COMPLIANCE_CAPACITY_UNAVAILABLE: "503 retry | No verified compliance-scope host can take this sandbox now. | Retry after the Retry-After interval.";
+  readonly FIRECRACKER_IMAGE_UNAVAILABLE: "503 final | No host carries the requested Firecracker image. | Choose an image the Firecracker hosts carry, or the Docker runtime.";
+  readonly HOST_UNAVAILABLE: "503 retry | The host did not answer; the sandbox and its files remain. | Retry after the Retry-After interval.";
+  readonly IN_BOX_DOCKER_UNAVAILABLE: "503 retry | Docker inside the sandbox is not available. | Retry, or create the sandbox with in-box Docker enabled.";
+  readonly NO_IP: "503 retry | The sandbox has no network address yet. | Retry after the Retry-After interval.";
+  readonly ROUTE_LOOKUP_FAILED: "503 retry | The host could not look up the sandbox route. | Retry after the Retry-After interval.";
+  readonly SNAPSHOT_STORAGE_UNAVAILABLE: "503 retry | Snapshot storage did not answer. | Retry after the Retry-After interval.";
+  readonly THIN_POOL_HEADROOM: "503 final | The sandbox host cannot grow this workspace. | Recreate the sandbox from a snapshot so it lands on another host.";
+  readonly WARM_RECONNECT_MISS: "503 retry | The warm restore path is unavailable. | Retry; the platform restores through the cold path.";
+  readonly WORKSPACE_IMAGE_BUILDER_BUSY: "503 retry | The workspace image builder is busy. | Retry after the Retry-After interval.";
+  readonly WORKSPACE_IMAGE_BUILDER_UNAVAILABLE: "503 retry | The workspace image builder is unavailable. | Retry after the Retry-After interval.";
+  readonly SIDECAR_HEALTH_TIMEOUT: "504 retry | The sandbox runtime did not become ready within its boot attempts. | Retry; if it repeats, recreate the sandbox.";
+  readonly rate_limit_error: "429 retry | The model provider rate-limited this turn. | Wait for the provider's window, then send the turn again.";
+  readonly provider_quota_exhausted: "429 final | The harness subscription quota is spent until its resetAt. | Wait until resetAt, or send the turn with another credential.";
+  readonly native_api_error: "502 final | The harness's model API refused the turn; the message carries its answer. | Fix what the provider's answer names, then send the turn again.";
+  readonly empty_visible_output: "502 retry | The turn ended without visible output from the model. | Send the turn again; if it repeats, change the model or the prompt.";
+  readonly session_rehydration_failed: "409 final | The session's stored transcript cannot be replayed into a new harness session. | Start a new session; this one cannot resume.";
+  readonly SESSION_DIED: "500 final | The harness session process died during the turn; the message says why. | Send the turn again in a new session.";
+  readonly MEMORY_LIMIT_KILLED: "500 final | The harness ran out of memory and was killed. | Give the sandbox more memory or split the work, then send the turn again.";
+  readonly PROCESS_OUTPUT_GAP: "410 final | A process log reader fell behind the spool, so output was evicted before it was read. | Read faster or redirect output to a file; missedBytes says how much.";
+  readonly SESSION_CREDENTIAL_NOT_RETAINED: "409 final | A restored session's model credential is not kept in session storage. | Send the model credential with the turn.";
+  readonly interaction_kind_unsupported: "400 final | The turn asks for an interaction kind this harness cannot originate. | Drop the interaction toggle or choose a harness that supports it.";
+  readonly invalid_attachment: "400 final | An attachment has no url or path, or content the harness cannot take. | Fix the attachment the message names, then send the turn again.";
+  readonly PROFILE_NOT_CACHED: "409 final | The turn names a profile by hash that this runtime does not hold. | Send the full profile object instead of its hash.";
+  readonly MODEL_CALL_LIMIT_REACHED: "400 final | The bounded turn needed more model calls than it allowed. | Raise the turn's model-call limit or split the task.";
+  readonly MODEL_CALL_LIMIT_UNSUPPORTED: "400 final | This harness's model calls cannot be counted, so a call limit cannot hold. | Drop the limit or choose a harness that supports it.";
+  readonly TOOL_DISABLED_TURN_UNSUPPORTED: "400 final | This harness cannot run a turn with its tools disabled. | Allow tools, or choose a harness that supports tool-free turns.";
+  readonly EXECUTION_TTL_EXPIRED: "504 final | The execution ran past its time limit and was stopped. | Raise ttlMs up to the deployment ceiling, or split the work.";
+  readonly EXECUTION_TTL_EXCEEDS_LIMIT: "400 final | The requested execution time limit is above this deployment's ceiling. | Send a ttlMs at or below the ceiling the message names.";
+  readonly MESSAGE_ADMISSION_EXPIRED: "409 final | The message's admission deadline passed before the harness was invoked. | Dispatch the message again with a new deadline.";
+  readonly BACKEND_HARNESS_CONFLICT: "400 final | Running the turn would run a harness other than the one the caller named. | Name one harness for the session and its turns.";
+  readonly HARNESS_MODEL_UNSUPPORTED: "400 final | The named harness cannot run the named model. | Choose a model the harness supports, or another harness.";
+  readonly HARNESS_RUNTIME_UNAVAILABLE: "503 retry | The harness's local daemon exited before it could serve the session. | Retry after the Retry-After interval; the message carries the daemon's reason.";
+  readonly GPU_PROVIDER_NOT_CONFIGURED: "503 final | No GPU provider is configured for this deployment. | Create the sandbox without a GPU, or ask the operator to configure a provider.";
+  readonly COMPLIANCE_NOT_ENTITLED: "403 final | The account is not entitled to the requested compliance placement. | Enable the compliance plan for the account, or create without it.";
+  readonly COMPLIANCE_CELL_UNAVAILABLE: "503 final | No cell serves the requested compliance placement. | Choose another region or compliance mode, or ask the operator.";
+  readonly NETWORK_ERROR: "503 retry | The request did not reach the platform, or its answer was lost. | Check connectivity, then retry; a keyed create joins its earlier attempt.";
+  readonly STREAM_INTERRUPTED: "503 retry | The execution's stream ended without its terminal event; its outcome is unknown. | Rejoin with its executionId and lastEventId, or read the session status.";
+  readonly PUBLIC_PROFILE_PIN_REFUSED: "400 final | The runtime refused the pinned public profile revision this turn named. | Send the turn with the revision and digest the profile has now.";
+  readonly model_credential_refused: "403 final | The account owner refused the model credential for this seat. | Reconnect or replace that seat's credential, or choose another seat.";
+  readonly TEMPLATE_PUBLICATION_WAIT_INTERRUPTED: "504 retry | The SDK stopped waiting for a template publication; the job keeps running. | Resume the wait with resumeJobId instead of publishing again.";
+};
+type ErrorCode = keyof typeof ERROR_CATALOG;
+//#endregion
 //#region src/create-receipt-types.d.ts
 /** Create admission evidence shared by SDK errors and public sandbox types.
  * This contract has no SDK implementation imports. */
@@ -47,340 +166,204 @@ interface SandboxCreateReceipt {
 }
 //#endregion
 //#region src/error-classes.d.ts
+type SandboxErrorOrigin = "sidecar" | "sandbox-api" | "control-plane" | "runtime" | "unknown";
+type SandboxErrorJson = string | number | boolean | null | {
+  [key: string]: SandboxErrorJson;
+} | SandboxErrorJson[];
+type SandboxFailureDetail = {
+  [key: string]: SandboxErrorJson;
+};
+/** What one supported GPU provider needs, as a refusal reports it. */
+interface GpuProviderRequirement {
+  provider: string;
+  /** `ready`, `credential-invalid`, `unverified`, `not-configured`, `disabled`. */
+  state: string;
+  /** Orchestrator environment variables it needs (`A|B`: either). */
+  envVars: string[];
+}
+/** Why the SDK stopped rejoining an execution whose stream dropped. */
+type StreamInterruptionReason = /** The caller's reconnect window elapsed while the execution stayed unreachable. */"reconnect-window-elapsed" /** The sandbox is stopped, failed, expired or deleted; the run cannot resume. */ | "sandbox-not-running" /** The runtime kept answering that it has no such execution. */ | "execution-not-found";
+/** Everything a failure carries besides its message. Every field is optional. */
+interface SandboxErrorMetadata {
+  /** The wire code, or a code the SDK names; `SandboxError.code` is its catalog code. */
+  code?: string;
+  /** HTTP status the server answered; absent means the catalog's status. */
+  status?: number;
+  cause?: unknown;
+  origin?: SandboxErrorOrigin;
+  endpoint?: string;
+  retryAfterMs?: number;
+  sidecarVersion?: string;
+  containerImage?: string;
+  etaSeconds?: number;
+  elapsedMs?: number;
+  createFailureDisposition?: "not-admitted";
+  capacityHold?: "customer_floor";
+  resourceType?: string;
+  resourceId?: string;
+  quotaType?: string;
+  current?: number;
+  limit?: number;
+  capability?: string;
+  providers?: GpuProviderRequirement[];
+  failures?: SandboxFailureDetail[];
+  allocationId?: string;
+  idempotencyKey?: string;
+  createReceipt?: SandboxCreateReceipt | null;
+  fields?: Record<string, string>;
+  path?: string;
+  currentState?: string;
+  requiredState?: string;
+  edgeStatus?: "pending" | "failed";
+  expectedHash?: string;
+  currentHash?: string | null;
+  currentMtime?: number | null;
+  keyId?: string;
+  budgetUsd?: number;
+  spentUsd?: number;
+  reservedUsd?: number;
+  missingEnvKeys?: readonly string[];
+  maxChildren?: number;
+  requestedChildren?: number;
+  timeoutMs?: number;
+  executionId?: string;
+  sessionId?: string;
+  lastEventId?: string;
+  reason?: string;
+  lastReplayStatus?: number;
+  lastExecutionStatus?: string;
+  beforeOpen?: boolean;
+}
 /**
- * Base error class for all Sandbox SDK errors.
+ * The one SDK error. `code` is the catalog code callers branch on; `wireCode`
+ * is the code the server sent (it differs while servers still send
+ * pre-catalog codes). `retryable` is the catalog's verdict on whether a later
+ * retry can succeed, and `nextStep` is what the caller does about it.
  */
 declare class SandboxError extends Error {
-  /** HTTP status code if applicable */
-  readonly status?: number;
-  /** Error code for programmatic handling */
-  readonly code: string;
+  readonly code: ErrorCode;
+  readonly wireCode: string;
+  /** HTTP status the server answered, else the catalog status of `code`. */
+  readonly status: number;
+  readonly retryable: boolean;
+  readonly nextStep: string;
+  readonly docs: string;
   /** Best-effort origin of the failing request */
   readonly origin?: SandboxErrorOrigin;
   /** Request path or endpoint when known */
   readonly endpoint?: string;
   /** Retry-after duration in ms when surfaced by the upstream */
   readonly retryAfterMs?: number;
-  /** Sidecar version when the runtime emitted it */
   readonly sidecarVersion?: string;
-  /** Sidecar image/tag/sha when the runtime emitted it */
   readonly containerImage?: string;
   /**
-   * Seconds the control plane expects to need before it can serve this
-   * request, when it published one. Today only a capacity refusal on create
-   * carries it: the cell sizes it from the host add already in flight plus
-   * the measured p95 host-birth time, so it is a real wait, not a backoff
-   * hint. `retryAfterMs` paces the SDK's own retry; this is the number to
-   * show a human or feed to a scheduler.
+   * Seconds the cell measured it needs before it can serve this request (a
+   * capacity refusal on create). A real wait to show a human or a scheduler,
+   * unlike `retryAfterMs`, which paces the SDK's own retry.
    */
   readonly etaSeconds?: number;
+  /** How long the operation ran before this error, when the thrower measured it; never `timeoutMs`. */
+  readonly elapsedMs?: number;
   /**
    * On create's top-level error, proves this call's attempts admitted no
-   * sandbox. Absence is unknown. Earlier errors in `cause` describe only
-   * their attempt prefix, not subsequent attempts or earlier calls using
-   * the same idempotency key.
+   * sandbox. Absence is unknown.
    */
   readonly createFailureDisposition?: "not-admitted";
-  /**
-   * The cell kept its last free slots for customer creates and refused this
-   * internal create at once. Only customers may take that room, so create()
-   * ends on it instead of re-POSTing; a caller records it as held for
-   * customers, not as a failure.
-   */
+  /** The cell kept its last free slots for customers and refused this internal create; create() ends on it. */
   readonly capacityHold?: "customer_floor";
-  constructor(message: string, code: string, status?: number, metadata?: SandboxErrorMetadata);
-}
-type SandboxErrorOrigin = "sidecar" | "sandbox-api" | "control-plane" | "runtime" | "unknown";
-interface SandboxErrorMetadata {
-  origin?: SandboxErrorOrigin;
-  endpoint?: string;
-  retryAfterMs?: number;
-  sidecarVersion?: string;
-  containerImage?: string;
-  etaSeconds?: number;
-  /** How long the operation ran, for a TimeoutError that measured it. */
-  elapsedMs?: number;
-  createFailureDisposition?: "not-admitted";
-  capacityHold?: "customer_floor";
-}
-type SandboxErrorJson = string | number | boolean | null | {
-  [key: string]: SandboxErrorJson;
-} | SandboxErrorJson[];
-type SandboxFailureDetail = {
-  [key: string]: SandboxErrorJson;
-};
-/**
- * Authentication failed or API key is invalid.
- */
-declare class AuthError extends SandboxError {
-  constructor(message?: string, metadata?: SandboxErrorMetadata);
-}
-/**
- * The requested resource was not found.
- */
-declare class NotFoundError extends SandboxError {
-  /** The resource type that was not found */
-  readonly resourceType: string;
-  /** The resource ID that was not found */
-  readonly resourceId: string;
-  constructor(resourceType: string, resourceId: string, metadata?: SandboxErrorMetadata, message?: string, code?: string);
-}
-/**
- * Account quota or rate limit exceeded.
- */
-declare class QuotaError extends SandboxError {
-  /** The type of quota that was exceeded */
-  readonly quotaType: string;
-  /** Current usage */
+  readonly resourceType?: string;
+  readonly resourceId?: string;
+  /** Quota reason: `CONCURRENT_LIMIT`, `CREDIT_EXHAUSTED`, `EGRESS_LIMIT`, or `rate_limit`. */
+  readonly quotaType?: string;
   readonly current?: number;
-  /** Maximum allowed */
   readonly limit?: number;
-  /** Suggested retry-after duration in ms */
-  readonly retryAfterMs?: number;
-  constructor(quotaType: string, message?: string, current?: number, limit?: number, metadata?: SandboxErrorMetadata, status?: number);
-}
-/**
- * The requested capability is unavailable for the account, driver, or sandbox.
- */
-declare class CapabilityError extends SandboxError {
-  /** Capability or feature that was rejected when known */
   readonly capability?: string;
-  constructor(message: string, code?: string, status?: number, metadata?: SandboxErrorMetadata, capability?: string);
-}
-/** What one supported GPU provider needs, as a refusal reports it. */
-interface GpuProviderRequirement {
-  provider: string;
-  /** `ready`, `credential-invalid`, `unverified`, `not-configured`, `disabled`. */
-  state: string;
-  /** Orchestrator environment variables it needs (`A|B`: either). */
-  envVars: string[];
-}
-/**
- * No configured GPU provider can take the lease: none is configured, the
- * named one is not, or the provider refused its credential. Status 503, code
- * `GPU_PROVIDER_NOT_CONFIGURED`. The message names every supported provider
- * and the orchestrator variables it needs; `providers` carries the same.
- */
-declare class GpuProviderNotConfiguredError extends CapabilityError {
-  readonly providers: GpuProviderRequirement[];
-  constructor(message: string, providers?: GpuProviderRequirement[], status?: number, metadata?: SandboxErrorMetadata);
-}
-/**
- * A create that requires HIPAA placement was refused. `code` says why:
- * `COMPLIANCE_NOT_ENTITLED` (403) when the credential carries no HIPAA
- * entitlement, `COMPLIANCE_CELL_UNAVAILABLE` (503) when no HIPAA-designated
- * cell can take the create now. Either way nothing was created, and the
- * create was not placed in any other cell. The SDK does not retry it.
- */
-declare class CompliancePlacementError extends SandboxError {
-  constructor(message: string, code: "COMPLIANCE_NOT_ENTITLED" | "COMPLIANCE_CELL_UNAVAILABLE", status: number, metadata?: SandboxErrorMetadata);
-}
-/**
- * A multi-resource operation failed for one or more branches.
- */
-declare class PartialFailureError extends SandboxError {
-  /** Per-resource failures returned by the API when available */
+  /** Every supported GPU provider and the orchestrator variables it needs. */
+  readonly providers?: GpuProviderRequirement[];
+  /** Per-resource failures of a multi-resource operation. */
   readonly failures?: SandboxFailureDetail[];
-  /** The operation that failed after another resource was already created. */
-  readonly cause?: unknown;
-  /** Allocation returned before create readiness failed. */
+  /** Allocation a create returned before its readiness failed. */
   readonly allocationId?: string;
-  /** Key used for the create call that returned the allocation. */
   readonly idempotencyKey?: string;
-  /** Ownership verdict returned by that create call, if available. */
   readonly createReceipt?: SandboxCreateReceipt | null;
-  constructor(message: string, code?: string, status?: number, metadata?: SandboxErrorMetadata, failures?: SandboxFailureDetail[], cause?: unknown, createFailure?: {
-    allocationId: string;
-    idempotencyKey: string;
-    createReceipt: SandboxCreateReceipt | null;
-  });
-}
-/**
- * The request was invalid or malformed.
- */
-declare class ValidationError extends SandboxError {
   /** Field-level validation errors */
   readonly fields?: Record<string, string>;
-  constructor(message: string, fields?: Record<string, string>, metadata?: SandboxErrorMetadata, code?: string);
-}
-/**
- * A profile file mount the sandbox refuses; a retry with the same profile gets
- * the same refusal. `PROFILE_FILE_MOUNT_OUTSIDE_ROOTS` (422): an absolute path
- * outside `SANDBOX_FILE_API_ABSOLUTE_ROOTS`, refused before any write.
- * `PROFILE_FILE_CONFLICT` (409): the file changed both in the sandbox and in
- * the profile since its last mount, so a turn refuses to replace it.
- */
-declare class ProfileFileMountPathError extends SandboxError {
-  /** The refused mount path, exactly as the profile gave it. */
-  readonly path: string;
-  constructor(path: string, message: string, code: string, metadata?: SandboxErrorMetadata, status?: number);
-}
-/**
- * The sandbox is not in a valid state for the requested operation.
- */
-declare class StateError extends SandboxError {
-  /** Current state of the sandbox */
-  readonly currentState: string;
-  /** Required state for the operation */
+  readonly path?: string;
+  readonly currentState?: string;
   readonly requiredState?: string;
-  constructor(message: string, currentState: string, requiredState?: string, metadata?: SandboxErrorMetadata, code?: string);
-}
-/**
- * The sandbox lifecycle is running, but its consumer-facing runtime edge is
- * still attaching or has failed to attach.
- */
-declare class EdgeNotReadyError extends SandboxError {
-  /** Current public edge state. */
-  readonly edgeStatus: "pending" | "failed";
-  constructor(message: string, edgeStatus: "pending" | "failed", metadata?: SandboxErrorMetadata);
-}
-declare class FileWriteConflictError extends SandboxError {
-  readonly path: string;
-  readonly currentHash: string | null;
-  readonly currentMtime: number | null;
+  readonly edgeStatus?: "pending" | "failed";
   readonly expectedHash?: string;
-  constructor(message: string, path: string, expectedHash: string | undefined, currentHash: string | null, currentMtime: number | null, metadata?: SandboxErrorMetadata);
-}
-/**
- * The Platform key funding the request has no lifetime budget left.
- *
- * A budgeted key funds any number of sandboxes until its budget is spent;
- * then every create, resume, and model credential it funds is refused with
- * this error. The refusal is decided: retrying cannot succeed until the
- * budget is raised or another key is used, so the SDK never retries it.
- */
-declare class KeyBudgetExhaustedError extends SandboxError {
-  /**
-   * The key the refusal names: the budgeted key with nothing left when
-   * Platform refused a delegation, or the presented key when authentication
-   * refused it. Absent when the server named none.
-   */
+  readonly currentHash?: string | null;
+  readonly currentMtime?: number | null;
+  /** The budgeted key a `KEY_BUDGET_EXHAUSTED` refusal names, and its USD budget, spend and reserve. */
   readonly keyId?: string;
-  /** That key's lifetime budget, in USD, when Platform reported it. */
   readonly budgetUsd?: number;
-  /** What that key has spent, in USD. */
   readonly spentUsd?: number;
-  /** What that key has reserved for budgeted children, in USD. */
   readonly reservedUsd?: number;
-  constructor(message: string, details?: {
-    keyId?: string;
-    budgetUsd?: number;
-    spentUsd?: number;
-    reservedUsd?: number;
-  }, metadata?: SandboxErrorMetadata);
-}
-declare class EgressProxyRecoveryError extends SandboxError {
-  readonly phase: "egress_proxy_recovery";
-  constructor(message: string, metadata?: SandboxErrorMetadata);
-}
-/**
- * Resume must build a new runtime, and that runtime needs public env values
- * the platform does not store at rest: a per-run coordination or capability
- * token, or a secret passed at create. Resume again with each key in
- * `missingEnvKeys` in `ResumeOptions.env`.
- */
-declare class ResumeEnvRequiredError extends SandboxError {
-  /** The env keys the next resume must carry. */
-  readonly missingEnvKeys: readonly string[];
-  constructor(message: string, missingEnvKeys: readonly string[], metadata?: SandboxErrorMetadata);
-}
-/**
- * A branch asked for more children than the parent's host has memory for.
- * Children can only live on the parent's host (their clone is local to its
- * volume), so no other host can take the rest. `maxChildren` is how many
- * children that host admits now; branch that many or fewer, or wait for the
- * host to free memory. Nothing was created and nothing is held.
- *
- * A retry under the same idempotency key replays this refusal unchanged,
- * `maxChildren` included, so the count is the host's room when the key was
- * first used. To branch fewer children, use a new key.
- */
-declare class BranchFanoutExceedsHostError extends SandboxError {
-  /** Children the parent's host admitted when it refused (0 when none). */
+  /** The env keys the next resume must carry in `ResumeOptions.env`. */
+  readonly missingEnvKeys?: readonly string[];
+  /** Children the parent's host admitted when a branch fan-out was refused. */
   readonly maxChildren?: number;
-  /** The fan-out width this request asked for. */
   readonly requestedChildren?: number;
-  constructor(message: string, counts: {
-    maxChildren?: number;
-    requestedChildren?: number;
-  }, metadata?: SandboxErrorMetadata);
-}
-/**
- * The request timed out.
- */
-declare class TimeoutError extends SandboxError {
   /** The operation's configured budget, in milliseconds. NOT how long it ran. */
-  readonly timeoutMs: number;
-  /**
-   * How long the operation actually ran before this error, in milliseconds,
-   * when the thrower measured it.
-   *
-   * `create()` can end before its budget: when a server-supplied `Retry-After`
-   * outlasts the remaining budget, no further attempt can follow that sleep,
-   * so the create ends there rather than idling. Reading `timeoutMs` as the
-   * duration would record a two-minute timeout for a three-second refusal.
-   * Absent means the thrower did not measure it; it never means `timeoutMs`.
-   */
-  readonly elapsedMs?: number;
-  /**
-   * The last typed failure the operation had already received when the
-   * deadline fired, when there was one.
-   *
-   * An operation that spends its budget across several attempts (create's
-   * bounded POST retry) usually learns the server's failure class on an
-   * earlier attempt — `CONTAINER_START_FAILED`, `PROVISIONING_ERROR`,
-   * `RATE_LIMIT_EXCEEDED`. Without this field that class dies at the
-   * deadline and the caller is left with a timeout that names no cause,
-   * which is the last discard in a chain built specifically to deliver it.
-   */
-  readonly cause?: SandboxError;
-  constructor(timeoutMs: number, message?: string, metadata?: SandboxErrorMetadata, cause?: SandboxError);
-}
-/**
- * A network or connection error occurred.
- */
-declare class NetworkError extends SandboxError {
-  /** The underlying error */
-  readonly cause?: Error;
-  constructor(message: string, causeOrMetadata?: Error | SandboxErrorMetadata, metadata?: SandboxErrorMetadata);
-}
-/** Why the SDK stopped rejoining an execution whose stream dropped. */
-type StreamInterruptionReason = /** The caller's reconnect window elapsed while the execution stayed unreachable. */"reconnect-window-elapsed" /** The sandbox is stopped, failed, expired or deleted; the run cannot resume. */ | "sandbox-not-running" /** The runtime kept answering that it has no such execution. */ | "execution-not-found";
-/**
- * The stream of an admitted execution ended without its terminal event, and
- * the SDK could not rejoin it. The execution's outcome is UNKNOWN: it may
- * still be running, or it may have finished while no reader was attached.
- * This is never a failure verdict. Rejoin later with `streamPrompt(message,
- * { executionId, lastEventId, sessionId })`, or read the session status.
- */
-declare class StreamInterruptedError extends SandboxError {
-  readonly executionId: string;
+  readonly timeoutMs?: number;
+  readonly executionId?: string;
   readonly sessionId?: string;
-  /** The last event id delivered to the caller; replay resumes after it. */
+  /** The last event id delivered to the caller; a rejoin resumes after it. */
   readonly lastEventId?: string;
-  readonly reason: StreamInterruptionReason;
-  /** Last HTTP status the replay endpoint answered, when it answered. */
+  readonly reason?: string;
   readonly lastReplayStatus?: number;
-  /** Last execution status the runtime reported, when it reported one. */
   readonly lastExecutionStatus?: string;
-  readonly cause?: unknown;
-  constructor(details: {
-    message: string;
-    executionId: string;
-    sessionId?: string;
-    lastEventId?: string;
-    reason: StreamInterruptionReason;
-    lastReplayStatus?: number;
-    lastExecutionStatus?: string;
-    cause?: unknown;
-  });
+  /** A terminal socket that never reached OPEN. */
+  readonly beforeOpen?: boolean;
+  constructor(message: string, metadata?: SandboxErrorMetadata);
 }
+/** @deprecated Removed in 0.62; check `code === "UNAUTHORIZED"`. */
+declare class AuthError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "NOT_FOUND"`. */
+declare class NotFoundError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "QUOTA_EXCEEDED"` or `"RATE_LIMITED"`. */
+declare class QuotaError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "UNSUPPORTED"` or `"FEATURE_DISABLED"`. */
+declare class CapabilityError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "GPU_PROVIDER_NOT_CONFIGURED"`. */
+declare class GpuProviderNotConfiguredError extends CapabilityError {}
+/** @deprecated Removed in 0.62; check `wireCode` for `COMPLIANCE_NOT_ENTITLED` or `COMPLIANCE_CELL_UNAVAILABLE`. */
+declare class CompliancePlacementError extends SandboxError {}
+/** @deprecated Removed in 0.62; read `failures`. */
+declare class PartialFailureError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "VALIDATION_ERROR"`. */
+declare class ValidationError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode` and read `path`. */
+declare class ProfileFileMountPathError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "INVALID_STATE"`. */
+declare class StateError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "EDGE_NOT_READY"`. */
+declare class EdgeNotReadyError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "FILE_WRITE_CONFLICT"`. */
+declare class FileWriteConflictError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "KEY_BUDGET_EXHAUSTED"`. */
+declare class KeyBudgetExhaustedError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "EGRESS_PROXY_RECOVERY_REQUIRED"`. */
+declare class EgressProxyRecoveryError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "RESUME_ENV_REQUIRED"` and read `missingEnvKeys`. */
+declare class ResumeEnvRequiredError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `wireCode === "BRANCH_FANOUT_EXCEEDS_HOST"` and read `maxChildren`. */
+declare class BranchFanoutExceedsHostError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "TIMEOUT"`. */
+declare class TimeoutError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `code === "NETWORK_ERROR"`. */
+declare class NetworkError extends SandboxError {}
 /**
- * The server returned an unexpected error.
+ * The stream of an admitted execution ended without its terminal event and
+ * the SDK could not rejoin it. The outcome is UNKNOWN, never a failure
+ * verdict: rejoin with `streamPrompt(message, { executionId, lastEventId,
+ * sessionId })`, or read the session status.
+ * @deprecated Removed in 0.62; check `code === "STREAM_INTERRUPTED"`.
  */
-declare class ServerError extends SandboxError {
-  constructor(message: string, status?: number, metadata?: SandboxErrorMetadata, code?: string);
-}
+declare class StreamInterruptedError extends SandboxError {}
+/** @deprecated Removed in 0.62; check `status >= 500`. */
+declare class ServerError extends SandboxError {}
 //#endregion
 //#region src/errors.d.ts
 /**
@@ -394,21 +377,13 @@ declare function parseErrorResponse(status: number, body: string, context?: {
   path?: string;
   allPreviousCreateAttemptsRefused?: boolean;
 }, headers?: Headers): SandboxError;
-/** A protocol `error` control frame or a transport failure. */
-declare class TerminalStreamError extends Error {
-  /** Protocol error code (e.g. `INIT_FAILED`) or `TRANSPORT` for socket faults. */
-  readonly code: string;
-  /**
-   * True when the socket never reached OPEN: the upgrade was refused (a
-   * WebSocket client cannot read the HTTP status, so a 401 and a network drop
-   * look alike) or the runtime rejected the dial's options. No PTY work had
-   * started on the client's side of that dial.
-   */
-  readonly beforeOpen: boolean;
-  constructor(message: string, code: string, options?: {
-    beforeOpen?: boolean;
-  });
-}
+/**
+ * A terminal protocol `error` frame (`wireCode` is its protocol code, e.g.
+ * `INIT_FAILED`) or a socket fault (`TRANSPORT`). `beforeOpen` is true when
+ * the socket never reached OPEN, so no PTY work started on this dial.
+ * @deprecated Removed in 0.62; check `code`.
+ */
+declare class TerminalStreamError extends SandboxError {}
 //#endregion
 //#region ../../../node_modules/.pnpm/@tangle-network+agent-interface@5.10.13/node_modules/@tangle-network/agent-interface/dist/plan.d.ts
 /**