@tangle-network/sandbox 0.9.4-develop.20260629071229.145161 → 0.9.4-develop.20260701061438.a81baba

package/dist/{sandbox-DcOyvnIy.d.ts → sandbox-CglV4-cN.d.ts}

@@ -433,6 +433,15 @@ interface CreateSandboxOptions {
   name?: string;
   /** Resource limits (CPU cores, memory, disk) */
   resources?: SandboxResources;
+  /**
+   * Attach an on-demand GPU worker during sandbox creation.
+   *
+   * Requires `resources.accelerator` so the workload shape and the lease
+   * spend caps are both explicit. Docker and Firecracker sandboxes use the
+   * same lease path; the GPU is a temporary external worker, not host
+   * placement.
+   */
+  gpuLease?: CreateGpuLeaseOptions;
   /** Environment variables injected into the sandbox */
   env?: Record<string, string>;
   /**
@@ -472,6 +481,17 @@ interface CreateSandboxOptions {
    * instead of Tangle's managed storage.
    */
   storage?: StorageConfig;
+  /**
+   * Run as a throwaway sandbox: the home directory is NOT persisted across restarts.
+   *
+   * By default an egress-enabled sandbox is provisioned a persistent home
+   * volume (so a stop/resume workspace keeps its state). Set `ephemeral: true` for
+   * a one-shot run — a benchmark case, a CI job, any box that produces output and
+   * is deleted — to skip that volume and run on a writable scratch home. Egress
+   * still works; you only lose the home directory on restart, which a throwaway box
+   * never relies on. Independent of `storage`/snapshots (durability stays opt-in).
+   */
+  ephemeral?: boolean;
   /** Snapshot ID to restore from when creating the sandbox */
   fromSnapshot?: string;
   /** Source sandbox ID that owns the snapshot (required when fromSnapshot is set) */
@@ -742,6 +762,8 @@ interface SandboxInfo {
   expiresAt?: Date;
   /** Error message if status is 'failed' */
   error?: string;
+  /** GPU lease attached during sandbox creation, when requested. */
+  gpuLease?: GpuLease;
   /**
    * Startup phase breakdown, present only on the create response (the
    * platform emits it once, at provision time). Use
@@ -1383,6 +1405,12 @@ interface ResumeOptions {
 interface UsageInfo {
   /** Total compute minutes used today */
   computeMinutes: number;
+  /** GPU lease seconds billed today */
+  gpuSeconds: number;
+  /** Customer-billed GPU lease spend today in USD */
+  gpuCostUsd: number;
+  /** Provider GPU lease cost basis today in USD */
+  gpuProviderCostUsd: number;
   /** Number of currently active sandboxes */
   activeSandboxes: number;
   /** Total sandboxes created (lifetime) */
@@ -2421,74 +2449,20 @@ interface ListSandboxFleetOptions extends ListSandboxOptions {
   fleetId: string;
 }
 /**
- * Options for creating a checkpoint.
- */
-interface CheckpointOptions {
-  /** Tags to apply to the checkpoint */
-  tags?: string[];
-  /** Keep sandbox running after checkpoint (default: false - sandbox stops) */
-  leaveRunning?: boolean;
-  /** Also create a filesystem snapshot for data consistency */
-  includeSnapshot?: boolean;
-}
-/**
- * Result of a checkpoint operation.
- */
-interface CheckpointResult {
-  /** Unique checkpoint identifier */
-  checkpointId: string;
-  /** When the checkpoint was created */
-  createdAt: Date;
-  /** Size of checkpoint in bytes (memory state) */
-  sizeBytes?: number;
-  /** Tags applied to the checkpoint */
-  tags: string[];
-}
-/**
- * Information about an existing checkpoint.
- */
-interface CheckpointInfo {
-  /** Unique checkpoint identifier */
-  checkpointId: string;
-  /** Sandbox this checkpoint belongs to */
-  sandboxId: string;
-  /** When the checkpoint was created */
-  createdAt: Date;
-  /** Tags applied to the checkpoint */
-  tags: string[];
-  /** Size of checkpoint in bytes */
-  sizeBytes?: number;
-  /** Whether checkpoint includes memory state */
-  hasMemoryState: boolean;
-  /** Whether checkpoint includes filesystem snapshot */
-  hasFilesystemSnapshot: boolean;
-}
-/**
- * Options for forking a sandbox from a checkpoint.
+ * Options for branching a running sandbox into N copy-on-write children.
+ *
+ * Branch forks a LIVE VM's memory into many children at once (Firecracker
+ * UFFD copy-on-write): the children share the parent's clean pages and the
+ * parent stays running. For durable filesystem state use snapshots instead.
  */
-interface ForkOptions {
-  /** Name for the forked sandbox */
-  name?: string;
-  /** Override environment variables in the fork */
+interface BranchOptions {
+  /** Override environment variables in every child. */
   env?: Record<string, string>;
-  /** Override resource limits in the fork */
+  /** Override resource limits for every child. */
   resources?: SandboxResources;
-  /** Custom metadata for the fork */
+  /** Custom metadata applied to every child. */
   metadata?: Record<string, unknown>;
 }
-/**
- * Result of a fork operation.
- */
-interface ForkResult {
-  /** The newly created sandbox instance */
-  sandbox: SandboxInfo;
-  /** The checkpoint that was forked from */
-  sourceCheckpoint: CheckpointInfo;
-  /** ID of the source sandbox */
-  sourceId: string;
-  /** Time taken to fork in milliseconds */
-  forkTimeMs: number;
-}
 /**
  * Infrastructure driver identifier.
  *
@@ -2520,6 +2494,104 @@ interface SandboxAccelerator {
   /** Minimum device memory in megabytes when the exact GPU class is flexible. */
   memoryMB?: number;
 }
+declare const GPU_LEASE_PROVIDER_NAMES: readonly ["runpod", "vast-ai", "lambda-labs", "tensordock", "paperspace", "aws", "gcp", "azure", "crusoe", "fluidstack"];
+type GpuLeaseProviderName = (typeof GPU_LEASE_PROVIDER_NAMES)[number];
+interface GpuLeaseProviderSelection {
+  strategy: "explicit" | "cheapest";
+  selectedProvider: GpuLeaseProviderName;
+  requestedProvider?: GpuLeaseProviderName;
+  candidates: Array<{
+    provider: GpuLeaseProviderName;
+    accelerator: SandboxAccelerator & {
+      count: number;
+    };
+    providerInstanceType?: string;
+    region?: string;
+    pricingSource?: "live" | "configured" | "static";
+    providerCostPerHourUsd: number;
+    customerPricePerHourUsd: number;
+    maxLifetimeSeconds: number;
+    estimatedProviderCostUsd: number;
+    estimatedCustomerCostUsd: number;
+  }>;
+  rejected: Array<{
+    provider: GpuLeaseProviderName;
+    error: string;
+  }>;
+}
+type GpuLeaseStatus = "provisioning" | "ready" | "detaching" | "destroyed" | "failed";
+interface GpuLeaseBilling {
+  seconds: number;
+  providerCostUsd: number;
+  customerCostUsd: number;
+  providerCostPerHourUsd: number;
+  customerPricePerHourUsd: number;
+  startedAt: string;
+  stoppedAt: string;
+}
+interface GpuLease {
+  id: string;
+  projectRef: string;
+  ownerUserId: string;
+  productId?: string;
+  provider: GpuLeaseProviderName;
+  providerLeaseId?: string;
+  providerInstanceType?: string;
+  region?: string;
+  workerUrl?: string;
+  status: GpuLeaseStatus;
+  accelerator: SandboxAccelerator & {
+    count: number;
+  };
+  image?: string;
+  maxSpendUsd: number;
+  maxLifetimeSeconds: number;
+  idleTimeoutSeconds?: number;
+  providerCostPerHourUsd?: number;
+  customerPricePerHourUsd?: number;
+  estimatedProviderCostUsd?: number;
+  estimatedCustomerCostUsd?: number;
+  providerSelection?: GpuLeaseProviderSelection;
+  createdAt: string;
+  updatedAt: string;
+  readyAt?: string;
+  lastUsedAt?: string;
+  destroyedAt?: string;
+  failure?: string;
+  billing?: GpuLeaseBilling;
+}
+interface AttachGpuLeaseOptions {
+  provider?: GpuLeaseProviderName;
+  accelerator: SandboxAccelerator;
+  image?: string;
+  env?: Record<string, string>;
+  maxSpendUsd: number;
+  maxLifetimeSeconds: number;
+  idleTimeoutSeconds?: number;
+}
+type CreateGpuLeaseOptions = Omit<AttachGpuLeaseOptions, "accelerator">;
+interface GpuLeaseExecOptions {
+  command: string;
+  timeoutMs?: number;
+  env?: Record<string, string>;
+  cwd?: string;
+}
+interface GpuLeaseCommandResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  durationMs?: number;
+}
+interface GpuLeaseExecResult {
+  lease: GpuLease;
+  result: GpuLeaseCommandResult;
+}
+interface GpuLeaseManager {
+  attach(options: AttachGpuLeaseOptions): Promise<GpuLease>;
+  list(): Promise<GpuLease[]>;
+  exec(leaseId: string, options: GpuLeaseExecOptions): Promise<GpuLeaseExecResult>;
+  detach(leaseId: string): Promise<GpuLease>;
+}
 /**
  * Infrastructure driver configuration.
  *
@@ -4520,6 +4592,8 @@ declare class SandboxInstance {
   get expiresAt(): Date | undefined;
   /** Error message if status is 'failed' */
   get error(): string | undefined;
+  /** GPU lease attached during sandbox creation, when requested. */
+  get gpuLease(): GpuLease | undefined;
   /** Web terminal URL for browser-based access */
   get url(): string | undefined;
   /**
@@ -5098,12 +5172,23 @@ declare class SandboxInstance {
    * ```
    */
   get egress(): EgressManager;
+  /**
+   * On-demand GPU leases attached to this sandbox.
+   *
+   * The base sandbox stays cheap; `attach` starts a temporary external GPU
+   * worker with an explicit spend cap, and `detach` destroys it.
+   */
+  get gpu(): GpuLeaseManager;
   private networkUpdate;
   private networkExposePort;
   private networkListUrls;
   private networkGetConfig;
   private egressGet;
   private egressUpdate;
+  private gpuAttach;
+  private gpuList;
+  private gpuExec;
+  private gpuDetach;
   /**
    * Validate CIDR notation (IPv4 and IPv6)
    */
@@ -5227,91 +5312,46 @@ declare class SandboxInstance {
    */
   restoreFromStorage(storage: SnapshotOptions["storage"], options?: RestoreSnapshotOptions): Promise<SnapshotResult | null>;
   /**
-   * Create a CRIU checkpoint of the sandbox's memory state.
-   *
-   * Checkpoints capture the complete memory state of the running sandbox,
-   * enabling true pause/resume and fork operations. Unlike snapshots which
-   * only preserve filesystem state, checkpoints preserve process memory,
-   * open file descriptors, and execution state.
-   *
-   * **Requirements:** CRIU must be available on the host. Check availability
-   * with `client.criuStatus()` before calling.
-   *
-   * **Note:** By default, checkpoint stops the sandbox. Use `leaveRunning: true`
-   * to keep it running (creates a copy-on-write checkpoint).
-   *
-   * @param options - Checkpoint options
-   * @returns Checkpoint result with ID and metadata
-   *
-   * @example Basic checkpoint (stops sandbox)
-   * ```typescript
-   * const checkpoint = await box.checkpoint();
-   * console.log(`Checkpoint: ${checkpoint.checkpointId}`);
-   * // Sandbox is now stopped, resume with box.resume()
-   * ```
-   *
-   * @example Checkpoint without stopping
-   * ```typescript
-   * const checkpoint = await box.checkpoint({
-   *   tags: ["before-deploy"],
-   *   leaveRunning: true,
-   * });
-   * // Sandbox continues running
-   * ```
+   * @deprecated CRIU checkpoints were removed. To branch live memory into
+   * copy-on-write children of a running sandbox use {@link branch}; for durable
+   * filesystem state use {@link snapshot}. This method now throws.
    */
-  checkpoint(options?: CheckpointOptions): Promise<CheckpointResult>;
+  checkpoint(): never;
   /**
-   * List all checkpoints for this sandbox.
-   *
-   * @returns Array of checkpoint metadata
-   *
-   * @example
-   * ```typescript
-   * const checkpoints = await box.listCheckpoints();
-   * for (const cp of checkpoints) {
-   *   console.log(`${cp.checkpointId}: ${cp.createdAt}`);
-   * }
-   * ```
+   * @deprecated CRIU checkpoints were removed. List durable filesystem state
+   * with {@link listSnapshots}. This method now throws.
    */
-  listCheckpoints(): Promise<CheckpointInfo[]>;
+  listCheckpoints(): never;
   /**
-   * Delete a checkpoint.
-   *
-   * @param checkpointId - ID of the checkpoint to delete
+   * @deprecated CRIU checkpoints were removed. This method now throws.
    */
-  deleteCheckpoint(checkpointId: string): Promise<void>;
+  deleteCheckpoint(): never;
   /**
-   * Fork a new sandbox from a checkpoint.
-   *
-   * Creates a new sandbox with the same memory state as this sandbox
-   * at the time of the checkpoint. The fork has a new identity but
-   * preserves the execution state.
-   *
-   * **Use cases:**
-   * - Branch workflows: Create parallel execution paths
-   * - A/B testing: Run same state with different configurations
-   * - Debugging: Fork at a specific point to investigate
-   *
-   * @param checkpointId - ID of the checkpoint to fork from
-   * @param options - Fork configuration
-   * @returns The new sandbox instance
+   * @deprecated Forking from a CRIU checkpoint was removed. Use {@link branch}
+   * to fork a running sandbox's live memory into copy-on-write children, or
+   * `client.create({ fromSnapshot })` to provision from durable disk state.
+   * This method now throws.
+   */
+  fork(): never;
+  /**
+   * Branch this RUNNING sandbox into `count` copy-on-write children
+   * (Morph Infinibranch parity). Unlike {@link fork} — which rehydrates one
+   * sandbox from a CRIU checkpoint — branch forks the live VM's memory into
+   * many children at once via Firecracker UFFD copy-on-write: the children
+   * share the parent's clean pages instead of each copying full guest
+   * memory. The parent stays running.
    *
-   * @example Basic fork
-   * ```typescript
-   * const checkpoint = await box.checkpoint({ leaveRunning: true });
-   * const forked = await box.fork(checkpoint.checkpointId);
-   * // forked has same memory state as box at checkpoint time
-   * ```
+   * @param count - Number of children to create (must be >= 1).
+   * @param options - Per-child overrides.
+   * @returns Exactly `count` new sandbox instances.
    *
-   * @example Fork with custom config
+   * @example
    * ```typescript
-   * const forked = await box.fork(checkpointId, {
-   *   name: "experiment-branch",
-   *   env: { EXPERIMENT: "true" },
-   * });
+   * const [a, b, c] = await box.branch(3);
+   * // a, b, c each share box's memory state at branch time
    * ```
    */
-  fork(checkpointId: string, options?: ForkOptions): Promise<SandboxInstance>;
+  branch(count: number, options?: BranchOptions): Promise<SandboxInstance[]>;
   /**
    * Stop the sandbox (keeps state for resume).
    */
@@ -5365,7 +5405,6 @@ declare class SandboxInstance {
    * delivers progress callbacks while waiting for a target status.
    */
   private waitForWithSSE;
-  private parseCheckpointInfo;
   private ensureRunning;
   private runtimeFetch;
   /**
@@ -5525,4 +5564,4 @@ declare class SandboxInstance {
   _answerQuestion(id: string, answers: Record<string, string[]>): Promise<void>;
 }
 //#endregion
-export { CreateSandboxFleetOptions as $, SandboxFleetTraceBundle as $n, WriteFileOptions as $r, NetworkConfig as $t, AttachSandboxFleetMachineOptions as A, SSHCredentials as An, SnapshotInfo as Ar, ForkResult as At, BatchTask as B, SandboxFleetDriverCapability as Bn, TeeAttestationOptions as Br, InstalledTool as Bt, SandboxMcpEndpoint as C, PublishPublicTemplateVersionOptions as Cn, SecretInfo as Cr, FleetDispatchStreamOptions as Ct, AcceleratorKind as D, ReconcileSandboxFleetsResult as Dn, SessionListOptions as Dr, FleetPromptDispatchOptions as Dt, buildSandboxMcpConfig as E, ReconcileSandboxFleetsOptions as En, SessionInfo as Er, FleetMachineId as Et, BackendStatus as F, SandboxFleetArtifact as Fn, StartupOperation as Fr, GitDiff as Ft, CodeExecutionOptions as G, SandboxFleetMachineMeteredUsage as Gn, TokenRefreshHandler as Gr, IntelligenceReportWindow as Gt, CheckpointInfo as H, SandboxFleetInfo as Hn, TeeAttestationResponse as Hr, IntelligenceReportBudget as Ht, BackendType as I, SandboxFleetArtifactSpec as In, StorageConfig as Ir, GitStatus as It, CodeResult as J, SandboxFleetManifest as Jn, UpdateUserOptions as Jr, ListSandboxFleetOptions as Jt, CodeExecutionResult as K, SandboxFleetMachineRecord as Kn, ToolsConfig as Kr, ListMessagesOptions as Kt, BatchEvent as L, SandboxFleetCostEstimate as Ln, SubscriptionInfo as Lr, GpuType as Lt, BackendConfig as M, SandboxConnection as Mn, SnapshotResult as Mr, GitBranch as Mt, BackendInfo as N, SandboxEnvironment as Nn, SshKeysManager as Nr, GitCommit as Nt, AccessPolicyRule as O, RunCodeOptions as On, SessionMessage as Or, FleetPromptDispatchResult as Ot, BackendManager as P, SandboxEvent as Pn, StartupDiagnostics as Pr, GitConfig as Pt, CreateRequestOptions as Q, SandboxFleetToken as Qn, WaitForOptions as Qr, MkdirOptions as Qt, BatchOptions as R, SandboxFleetDispatchFailureClass as Rn, TaskOptions as Rr, HostAgentDriverConfig as Rt, SandboxMcpConfig as S, PublishPublicTemplateOptions as Sn, SearchOptions as Sr, FleetDispatchResultBufferOptions as St, buildControlPlaneMcpConfig as T, ReapExpiredSandboxFleetsResult as Tn, SessionEventStreamOptions as Tr, FleetExecDispatchResult as Tt, CheckpointOptions as U, SandboxFleetIntelligenceEnvelope as Un, TeePublicKey as Ur, IntelligenceReportCompareTo as Ut, BatchTaskResult as V, SandboxFleetDriverTimings as Vn, TeeAttestationReport as Vr, IntelligenceReport as Vt, CheckpointResult as W, SandboxFleetMachine as Wn, TeePublicKeyResponse as Wr, IntelligenceReportSubjectType as Wt, CompletedTurnResult as X, SandboxFleetOperationsSummary as Xn, UploadProgress as Xr, McpServerConfig as Xt, CodeResultPart as Y, SandboxFleetManifestMachine as Yn, UploadOptions as Yr, ListSandboxOptions as Yt, CreateIntelligenceReportOptions as Z, SandboxFleetPolicy as Zn, UsageInfo as Zr, MintScopedTokenOptions as Zt, StartInteractiveOptions as _, defineGitHubResource as _i, ProvisionResult as _n, SandboxTraceOptions as _r, ExecResult as _t, TraceExportSink as a, AgentProfileConnection as ai, PreviewLinkManager as an, SandboxFleetWorkspaceReconcileResult as ar, DispatchPromptOptions as at, CONTROL_PLANE_MCP_SERVER_NAME as b, PublicTemplateInfo as bn, ScopedTokenScope as br, FleetDispatchCancelResult as bt, otelTraceIdForTangleTrace as c, AgentProfileModelHints as ci, ProcessLogEntry as cn, SandboxInfo as cr, DownloadProgress as ct, InteractiveAuthFile as d, AgentProfileResourceRef as di, ProcessSpawnOptions as dn, SandboxResourceUsage as dr, DriverInfo as dt, WriteManyFile as ei, NetworkManager as en, SandboxFleetTraceEvent as er, CreateSandboxFleetTokenOptions as et, InteractiveSessionHandle as f, AgentProfileResources as fi, ProcessStatus as fn, SandboxResources as fr, DriverType as ft, RespondToPermissionOptions as g, defineAgentProfile as gi, ProvisionEvent as gn, SandboxTraceExport as gr, ExecOptions as gt, InterruptResult as h, AgentSubagentProfile as hi, PromptResult as hn, SandboxTraceEvent as hr, EventStreamOptions as ht, TraceExportResult as i, AgentProfileConfidential as ii, PreviewLinkInfo as in, SandboxFleetWorkspace as ir, DirectoryPermission as it, BackendCapabilities as j, SandboxClientConfig as jn, SnapshotOptions as jr, GitAuth as jt, AddUserOptions as k, SSHCommandDescriptor as kn, SessionStatus as kr, ForkOptions as kt, toOtelJson as l, AgentProfilePermissionValue as li, ProcessManager as ln, SandboxIntelligenceEnvelope as lr, DriveTurnOptions as lt, InteractiveSessionInfo as m, AgentProfileValidationResult as mi, PromptOptions as mn, SandboxTraceBundle as mr, EgressPolicy as mt, SandboxInstance as n, AgentProfile as ni, PermissionLevel as nn, SandboxFleetTraceOptions as nr, CreateSandboxOptions as nt, buildTraceExportPayload as o, AgentProfileFileMount as oi, Process as on, SandboxFleetWorkspaceRestoreResult as or, DispatchedSession as ot, InteractiveSessionHost as p, AgentProfileValidationIssue as pi, PromptInputPart as pn, SandboxStatus as pr, EgressManager as pt, CodeLanguage as q, SandboxFleetMachineSpec as qn, TurnDriveResult as qr, ListOptions as qt, TraceExportFormat as r, AgentProfileCapabilities as ri, PermissionsManager as rn, SandboxFleetUsage as rr, DeleteOptions as rt, exportTraceBundle as s, AgentProfileMcpServer as si, ProcessInfo as sn, SandboxFleetWorkspaceSnapshotResult as sr, DownloadOptions as st, HttpClient as t, WriteManyOptions as ti, NonHostAgentDriverConfig as tn, SandboxFleetTraceExport as tr, CreateSandboxFleetWithCoordinatorOptions as tt, SandboxSession as u, AgentProfilePrompt as ui, ProcessSignal as un, SandboxPermissionsConfig as ur, DriverConfig as ut, BuildControlPlaneMcpConfigOptions as v, defineInlineResource as vi, ProvisionStatus as vn, SandboxUser as vr, FileInfo as vt, SandboxMcpServerEntry as w, ReapExpiredSandboxFleetsOptions as wn, SecretsManager as wr, FleetExecDispatchOptions as wt, SANDBOX_MCP_SERVER_NAME as x, PublicTemplateVersionInfo as xn, SearchMatch as xr, FleetDispatchResultBuffer as xt, BuildSandboxMcpConfigOptions as y, mergeAgentProfiles as yi, ProvisionStep as yn, ScopedToken as yr, FileSystem as yt, BatchResult as z, SandboxFleetDispatchResponse as zn, TaskResult as zr, HostAgentRuntimeBackend as zt };
+export { CreateSandboxFleetOptions as $, SandboxFleetMachineRecord as $n, ToolsConfig as $r, ListMessagesOptions as $t, AttachGpuLeaseOptions as A, PublishPublicTemplateVersionOptions as An, SecretInfo as Ar, GitAuth as At, BatchResult as B, SandboxEnvironment as Bn, SshKeysManager as Br, GpuLeaseExecResult as Bt, SandboxMcpEndpoint as C, defineAgentProfile as Ci, ProvisionEvent as Cn, SandboxTraceExport as Cr, FleetDispatchStreamOptions as Ct, AcceleratorKind as D, PublicTemplateInfo as Dn, ScopedTokenScope as Dr, FleetPromptDispatchOptions as Dt, buildSandboxMcpConfig as E, mergeAgentProfiles as Ei, ProvisionStep as En, ScopedToken as Er, FleetMachineId as Et, BackendManager as F, RunCodeOptions as Fn, SessionMessage as Fr, GitStatus as Ft, CodeExecutionResult as G, SandboxFleetDispatchFailureClass as Gn, TaskOptions as Gr, HostAgentDriverConfig as Gt, BatchTaskResult as H, SandboxFleetArtifact as Hn, StartupOperation as Hr, GpuLeaseProviderName as Ht, BackendStatus as I, SSHCommandDescriptor as In, SessionStatus as Ir, GpuLease as It, CodeResultPart as J, SandboxFleetDriverTimings as Jn, TeeAttestationReport as Jr, IntelligenceReport as Jt, CodeLanguage as K, SandboxFleetDispatchResponse as Kn, TaskResult as Kr, HostAgentRuntimeBackend as Kt, BackendType as L, SSHCredentials as Ln, SnapshotInfo as Lr, GpuLeaseBilling as Lt, BackendCapabilities as M, ReapExpiredSandboxFleetsResult as Mn, SessionEventStreamOptions as Mr, GitCommit as Mt, BackendConfig as N, ReconcileSandboxFleetsOptions as Nn, SessionInfo as Nr, GitConfig as Nt, AccessPolicyRule as O, PublicTemplateVersionInfo as On, SearchMatch as Or, FleetPromptDispatchResult as Ot, BackendInfo as P, ReconcileSandboxFleetsResult as Pn, SessionListOptions as Pr, GitDiff as Pt, CreateRequestOptions as Q, SandboxFleetMachineMeteredUsage as Qn, TokenRefreshHandler as Qr, IntelligenceReportWindow as Qt, BatchEvent as R, SandboxClientConfig as Rn, SnapshotOptions as Rr, GpuLeaseCommandResult as Rt, SandboxMcpConfig as S, AgentSubagentProfile as Si, PromptResult as Sn, SandboxTraceEvent as Sr, FleetDispatchResultBufferOptions as St, buildControlPlaneMcpConfig as T, defineInlineResource as Ti, ProvisionStatus as Tn, SandboxUser as Tr, FleetExecDispatchResult as Tt, BranchOptions as U, SandboxFleetArtifactSpec as Un, StorageConfig as Ur, GpuLeaseStatus as Ut, BatchTask as V, SandboxEvent as Vn, StartupDiagnostics as Vr, GpuLeaseManager as Vt, CodeExecutionOptions as W, SandboxFleetCostEstimate as Wn, SubscriptionInfo as Wr, GpuType as Wt, CreateGpuLeaseOptions as X, SandboxFleetIntelligenceEnvelope as Xn, TeePublicKey as Xr, IntelligenceReportCompareTo as Xt, CompletedTurnResult as Y, SandboxFleetInfo as Yn, TeeAttestationResponse as Yr, IntelligenceReportBudget as Yt, CreateIntelligenceReportOptions as Z, SandboxFleetMachine as Zn, TeePublicKeyResponse as Zr, IntelligenceReportSubjectType as Zt, StartInteractiveOptions as _, AgentProfilePrompt as _i, ProcessSignal as _n, SandboxPermissionsConfig as _r, ExecResult as _t, TraceExportSink as a, WaitForOptions as ai, MkdirOptions as an, SandboxFleetToken as ar, DispatchPromptOptions as at, CONTROL_PLANE_MCP_SERVER_NAME as b, AgentProfileValidationIssue as bi, PromptInputPart as bn, SandboxStatus as br, FleetDispatchCancelResult as bt, otelTraceIdForTangleTrace as c, WriteManyOptions as ci, NonHostAgentDriverConfig as cn, SandboxFleetTraceExport as cr, DownloadProgress as ct, InteractiveAuthFile as d, AgentProfileConfidential as di, PreviewLinkInfo as dn, SandboxFleetWorkspace as dr, DriverInfo as dt, TurnDriveResult as ei, ListOptions as en, SandboxFleetMachineSpec as er, CreateSandboxFleetTokenOptions as et, InteractiveSessionHandle as f, AgentProfileConnection as fi, PreviewLinkManager as fn, SandboxFleetWorkspaceReconcileResult as fr, DriverType as ft, RespondToPermissionOptions as g, AgentProfilePermissionValue as gi, ProcessManager as gn, SandboxIntelligenceEnvelope as gr, ExecOptions as gt, InterruptResult as h, AgentProfileModelHints as hi, ProcessLogEntry as hn, SandboxInfo as hr, EventStreamOptions as ht, TraceExportResult as i, UsageInfo as ii, MintScopedTokenOptions as in, SandboxFleetPolicy as ir, DirectoryPermission as it, AttachSandboxFleetMachineOptions as j, ReapExpiredSandboxFleetsOptions as jn, SecretsManager as jr, GitBranch as jt, AddUserOptions as k, PublishPublicTemplateOptions as kn, SearchOptions as kr, GPU_LEASE_PROVIDER_NAMES as kt, toOtelJson as l, AgentProfile as li, PermissionLevel as ln, SandboxFleetTraceOptions as lr, DriveTurnOptions as lt, InteractiveSessionInfo as m, AgentProfileMcpServer as mi, ProcessInfo as mn, SandboxFleetWorkspaceSnapshotResult as mr, EgressPolicy as mt, SandboxInstance as n, UploadOptions as ni, ListSandboxOptions as nn, SandboxFleetManifestMachine as nr, CreateSandboxOptions as nt, buildTraceExportPayload as o, WriteFileOptions as oi, NetworkConfig as on, SandboxFleetTraceBundle as or, DispatchedSession as ot, InteractiveSessionHost as p, AgentProfileFileMount as pi, Process as pn, SandboxFleetWorkspaceRestoreResult as pr, EgressManager as pt, CodeResult as q, SandboxFleetDriverCapability as qn, TeeAttestationOptions as qr, InstalledTool as qt, TraceExportFormat as r, UploadProgress as ri, McpServerConfig as rn, SandboxFleetOperationsSummary as rr, DeleteOptions as rt, exportTraceBundle as s, WriteManyFile as si, NetworkManager as sn, SandboxFleetTraceEvent as sr, DownloadOptions as st, HttpClient as t, UpdateUserOptions as ti, ListSandboxFleetOptions as tn, SandboxFleetManifest as tr, CreateSandboxFleetWithCoordinatorOptions as tt, SandboxSession as u, AgentProfileCapabilities as ui, PermissionsManager as un, SandboxFleetUsage as ur, DriverConfig as ut, BuildControlPlaneMcpConfigOptions as v, AgentProfileResourceRef as vi, ProcessSpawnOptions as vn, SandboxResourceUsage as vr, FileInfo as vt, SandboxMcpServerEntry as w, defineGitHubResource as wi, ProvisionResult as wn, SandboxTraceOptions as wr, FleetExecDispatchOptions as wt, SANDBOX_MCP_SERVER_NAME as x, AgentProfileValidationResult as xi, PromptOptions as xn, SandboxTraceBundle as xr, FleetDispatchResultBuffer as xt, BuildSandboxMcpConfigOptions as y, AgentProfileResources as yi, ProcessStatus as yn, SandboxResources as yr, FileSystem as yt, BatchOptions as z, SandboxConnection as zn, SnapshotResult as zr, GpuLeaseExecOptions as zt };

package/dist/tangle/index.d.ts

@@ -1,2 +1,2 @@
-import { a as TANGLE_JOBS_CONTRACT, c as AgentSandboxBlueprintAbi, d as SandboxCreateParamTypes, f as SandboxCreateResponseParamTypes, i as TANGLE_CHAIN_ID, l as ITangleJobsAbi, n as JOB_SANDBOX_CREATE, o as TANGLE_MAINNET_RPC, p as SandboxIdParamTypes, r as JOB_SANDBOX_DELETE, s as TangleSandboxClientConfig, t as TangleSandboxClient, u as JsonResponseParamTypes } from "../index-CAay0NFR.js";
+import { a as TANGLE_JOBS_CONTRACT, c as AgentSandboxBlueprintAbi, d as SandboxCreateParamTypes, f as SandboxCreateResponseParamTypes, i as TANGLE_CHAIN_ID, l as ITangleJobsAbi, n as JOB_SANDBOX_CREATE, o as TANGLE_MAINNET_RPC, p as SandboxIdParamTypes, r as JOB_SANDBOX_DELETE, s as TangleSandboxClientConfig, t as TangleSandboxClient, u as JsonResponseParamTypes } from "../index-ugDiHZbM.js";
 export { AgentSandboxBlueprintAbi, ITangleJobsAbi, JOB_SANDBOX_CREATE, JOB_SANDBOX_DELETE, JsonResponseParamTypes, SandboxCreateParamTypes, SandboxCreateResponseParamTypes, SandboxIdParamTypes, TANGLE_CHAIN_ID, TANGLE_JOBS_CONTRACT, TANGLE_MAINNET_RPC, TangleSandboxClient, TangleSandboxClientConfig };

package/dist/tangle/index.js

@@ -1,2 +1,2 @@
-import { a as TANGLE_JOBS_CONTRACT, c as ITangleJobsAbi, d as SandboxCreateResponseParamTypes, f as SandboxIdParamTypes, i as TANGLE_CHAIN_ID, l as JsonResponseParamTypes, n as JOB_SANDBOX_CREATE, o as TANGLE_MAINNET_RPC, r as JOB_SANDBOX_DELETE, s as AgentSandboxBlueprintAbi, t as TangleSandboxClient, u as SandboxCreateParamTypes } from "../tangle-D1c-2Jr2.js";
+import { a as TANGLE_JOBS_CONTRACT, c as ITangleJobsAbi, d as SandboxCreateResponseParamTypes, f as SandboxIdParamTypes, i as TANGLE_CHAIN_ID, l as JsonResponseParamTypes, n as JOB_SANDBOX_CREATE, o as TANGLE_MAINNET_RPC, r as JOB_SANDBOX_DELETE, s as AgentSandboxBlueprintAbi, t as TangleSandboxClient, u as SandboxCreateParamTypes } from "../tangle-DdHzeMUH.js";
 export { AgentSandboxBlueprintAbi, ITangleJobsAbi, JOB_SANDBOX_CREATE, JOB_SANDBOX_DELETE, JsonResponseParamTypes, SandboxCreateParamTypes, SandboxCreateResponseParamTypes, SandboxIdParamTypes, TANGLE_CHAIN_ID, TANGLE_JOBS_CONTRACT, TANGLE_MAINNET_RPC, TangleSandboxClient };

package/dist/{tangle-D1c-2Jr2.js → tangle-DdHzeMUH.js}

@@ -1,4 +1,4 @@
-import { t as SandboxInstance } from "./sandbox-BTBbZupV.js";
+import { t as SandboxInstance } from "./sandbox-CDKpHv6-.js";
 //#region src/tangle/abi.ts
 /**
 * Tangle Contract ABI Definitions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/sandbox",
-  "version": "0.9.4-develop.20260629071229.0145161",
+  "version": "0.9.4-develop.20260701061438.a81baba",
   "description": "Client SDK for the Tangle Sandbox platform - build AI agent applications with dev containers",
   "type": "module",
   "main": "./dist/index.js",