@tangle-network/sandbox 0.9.6 → 0.10.0

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

@@ -343,6 +343,24 @@ interface CreateSandboxOptions {
    * @default false
    */
   bare?: boolean;
+  /**
+   * Provision a public preview URL for this sandbox (the default). Set to
+   * `false` for the fast lane: the server skips the public-edge tunnel
+   * (public URL allocation, tunnel readiness, and scarce public IP capacity),
+   * which is the largest single term in create latency. Use it for workloads
+   * that reach the sandbox only through the SDK / exec — benchmark fleets, CI,
+   * RL rollouts — where no browser-facing URL is needed. `exec()`, streaming,
+   * `stop`/`resume`/`branch` are unaffected; only the public preview URL is
+   * absent. Omit (or leave `true`) for interactive sandboxes.
+   *
+   * @default true
+   * @example
+   * ```typescript
+   * // 1000-way benchmark fork — no preview URLs, faster + no subnet pressure
+   * await client.sandboxes.create({ publicEdge: false })
+   * ```
+   */
+  publicEdge?: boolean;
   /**
    * Infrastructure driver selection.
    * Controls how the sandbox is provisioned and isolated.
@@ -433,6 +451,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 +499,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 +780,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
@@ -754,6 +794,110 @@ interface SandboxInfo {
   /** Source of the egress policy */
   egressPolicySource?: "sandbox" | "team" | "platform";
 }
+/** Basic health reported by the runtime inside a sandbox. */
+interface SandboxRuntimeHealth {
+  status: string;
+  docker: {
+    enabled: boolean;
+    status: string;
+    dockerHost?: string;
+    error?: string;
+  };
+  backends: {
+    total: number;
+    byType: Record<string, number>;
+    pending: number;
+  };
+  timestamp: string;
+}
+/** Public preview link associated with a listening runtime port. */
+interface SandboxPortPreviewLink {
+  previewId: string;
+  url: string;
+  status: string;
+}
+/** One process listening on a port inside a sandbox. */
+interface SandboxPortBinding {
+  pid: number;
+  processName: string;
+  commandPath: string;
+  port: number;
+  protocol: "tcp" | "udp";
+  localAddress: string;
+  family: "tcp4" | "tcp6" | "udp4" | "udp6";
+  allowlisted: boolean;
+  firstSeenAt: string;
+  lastSeenAt: string;
+  previewLink?: SandboxPortPreviewLink;
+}
+/** Options for creating an interactive terminal. */
+interface SandboxTerminalCreateOptions {
+  name?: string;
+  description?: string;
+  shell?: string;
+  cwd?: string;
+  cols?: number;
+  rows?: number;
+}
+/** Runtime request context used to attribute terminal events to an agent session. */
+interface SandboxTerminalRequestOptions {
+  sessionId?: string;
+}
+/** Interactive terminal metadata returned by the runtime. */
+interface SandboxTerminalInfo {
+  sessionId: string;
+  connectionId?: string;
+  name?: string;
+  description?: string;
+  shell?: string;
+  command?: string;
+  cwd?: string;
+  cols?: number;
+  rows?: number;
+  createdAt?: string;
+  lastActivityAt?: string;
+  isRunning?: boolean;
+  exitCode?: number;
+  exitSignal?: string;
+  /** WebSocket path for terminal input/output. */
+  streamUrl?: string;
+  history?: unknown[];
+}
+/** Interactive terminal operations. Input/output flows over `streamUrl`. */
+interface SandboxTerminalManager {
+  create(options?: SandboxTerminalCreateOptions, request?: SandboxTerminalRequestOptions): Promise<SandboxTerminalInfo>;
+  /** Send input through the runtime's HTTP fallback for an existing terminal. */
+  input(terminalId: string, data: string, request?: SandboxTerminalRequestOptions): Promise<void>;
+  list(): Promise<SandboxTerminalInfo[]>;
+  get(sessionId: string): Promise<SandboxTerminalInfo | null>;
+}
+/** Runtime-local agent profile. */
+interface SandboxRuntimeProfile {
+  name: string;
+  description?: string;
+  systemPrompt?: string;
+  tools?: string[];
+  mcpServers?: string[];
+  env?: Record<string, string>;
+  model?: {
+    provider?: string;
+    model?: string;
+  };
+}
+/** Runtime-local profile listing and selected default. */
+interface SandboxRuntimeProfileList {
+  profiles: SandboxRuntimeProfile[];
+  defaultProfile?: string;
+}
+/** Profile summary returned before a sandbox runtime exists. */
+interface SandboxProfileSummary {
+  id: string;
+  name: string;
+  description?: string;
+  model?: string;
+  tags?: string[];
+  extends?: string;
+}
 /**
  * Raw TEE attestation evidence returned by the sandbox runtime.
  *
@@ -1383,6 +1527,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) */
@@ -1543,6 +1693,8 @@ type SessionStatus = "queued" | "running" | "completed" | "failed" | "cancelled"
 interface SessionInfo {
   /** Stable session id assigned by the sandbox runtime. */
   id: string;
+  /** Parent session id when this session was forked from another session. */
+  parentId?: string;
   /** Current lifecycle state. */
   status: SessionStatus;
   /** Backend identifier (e.g. provider name). */
@@ -1570,6 +1722,136 @@ interface SessionListOptions {
   /** Filter by backend identifier. */
   backend?: string;
 }
+/** Options for creating a runtime agent session. */
+interface CreateSessionOptions {
+  title?: string;
+  parentId?: string;
+  backend: BackendConfig;
+}
+/** Backend credentials forwarded to the platform if a sandbox must restart. */
+interface SessionBackendCredentials {
+  apiKey: string;
+  baseUrl?: string;
+}
+/** One content part accepted by the runtime session message endpoint. */
+type SessionMessageInputPart = PromptInputPart | {
+  type: "reasoning";
+  text: string;
+} | {
+  type: "tool";
+  tool: string;
+  state: {
+    status: "pending" | "running" | "completed" | "failed";
+    input?: unknown;
+    output?: unknown;
+  };
+} | {
+  type: "step-start";
+} | {
+  type: "step-finish";
+  reason?: string;
+  tokens?: {
+    total?: number;
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: {
+      write?: number;
+      read?: number;
+    };
+  };
+  cost?: number;
+};
+/** Message body accepted by `SandboxSession.sendMessage`. */
+interface SendSessionMessageRequest {
+  messageId?: string;
+  parts: SessionMessageInputPart[];
+  system?: string;
+  agent?: string;
+  model?: {
+    providerId: string;
+    modelId: string;
+  };
+  reasoningEffort?: "low" | "medium" | "high";
+  turnId?: string;
+  interactions?: BackendConfig["interactions"];
+}
+/** Per-call controls for `SandboxSession.sendMessage`. */
+interface SendSessionMessageOptions {
+  credentials?: SessionBackendCredentials;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+/** Response returned after a session message finishes processing. */
+interface SentSessionMessage {
+  info: {
+    id: string;
+    role: "user" | "assistant" | "system";
+    timestamp?: string;
+  };
+  parts: unknown[];
+}
+/** Canonical portable profile attached to a task session. */
+type TaskSessionProfile = AgentProfile & {
+  name: string;
+};
+/** Options for creating an isolated background task session. */
+interface CreateTaskSessionOptions {
+  sessionId: string;
+  backend: BackendConfig;
+  title: string;
+  profile?: TaskSessionProfile;
+  parentSessionId?: string;
+  isolateFileWrites?: boolean;
+}
+/** Task-session metadata returned at creation time. */
+interface TaskSessionInfo {
+  id: string;
+  title?: string;
+  parentSessionId?: string;
+  worktreeInfo?: {
+    worktreePath: string;
+    branchName: string;
+    baseCommitSha: string;
+  };
+  profile?: TaskSessionProfile;
+}
+/** One changed file in an isolated task session. */
+interface TaskSessionFileChange {
+  file: string;
+  operation: "added" | "modified" | "deleted";
+  additions: number;
+  deletions: number;
+}
+/** Current diff and commit history for an isolated task session. */
+interface TaskSessionChanges {
+  sessionId: string;
+  files: TaskSessionFileChange[];
+  diff: string;
+  commits: Array<{
+    sha: string;
+    message: string;
+    date: string;
+  }>;
+  worktreeInfo: {
+    worktreePath: string;
+    branchName: string;
+    baseCommitSha: string;
+    headCommitSha?: string;
+  };
+}
+/** Options for merging task-session changes into the main workspace. */
+interface CommitTaskSessionOptions {
+  message?: string;
+  files?: string[];
+}
+/** Result of merging task-session changes into the main workspace. */
+interface TaskSessionCommitResult {
+  success: true;
+  commitSha?: string;
+  conflicts?: string[];
+  appliedFiles: number;
+}
 /**
  * Options for `SandboxSession.events()` streaming.
  */
@@ -1604,6 +1886,28 @@ interface ListMessagesOptions {
   /** Only return messages newer than this Unix-ms timestamp. */
   since?: number;
 }
+/**
+ * Options for `box.session(id).fork()` — create a new session from an
+ * existing conversation, optionally at a message boundary.
+ */
+interface SessionForkOptions {
+  /** Fork at this message boundary. */
+  messageId?: string;
+  /** Target backend type for cross-backend forks. Defaults to parent backend. */
+  targetBackend?: BackendType;
+  /** Model override for the target backend. */
+  targetModel?: {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+  };
+  /**
+   * Files to include. The runtime currently rejects non-empty file lists;
+   * exposed here so the SDK type tracks the wire contract exactly.
+   */
+  files?: string[];
+}
 /**
  * One message on a session — user, assistant, or system. The metadata
  * field carries the durability marker set by the sidecar:
@@ -1817,6 +2121,10 @@ interface BatchTask {
   /** Per-task timeout in milliseconds */
   timeoutMs?: number;
 }
+/** Backend configuration accepted by batch execution, including named profiles. */
+type BatchBackend = Omit<Partial<BackendConfig>, "type"> & {
+  type?: BackendType | `${BackendType}:${string}`;
+};
 /**
  * Options for batch execution.
  */
@@ -1831,11 +2139,38 @@ interface BatchOptions {
    * Use `backend.profile` with a string for a named profile or a provider-neutral
    * `AgentProfile` object for inline profile configuration.
    */
-  backend?: Partial<BackendConfig>;
+  backend?: BatchBackend;
+  /** Run every task against each backend for comparison. */
+  backends?: BatchBackend[];
+  /** User identifier attached to the batch for platform attribution. */
+  userId?: string;
+  /** Partner identifier attached to the batch for credit attribution. */
+  partnerId?: string;
+  /** Request identifier used in events and metrics. */
+  identifier?: string;
+  /** Workload class used by capacity and lifecycle policy. */
+  executionClass?: "project" | "simulation" | "background";
+  /** Capacity to provision before execution starts. */
+  desiredCapacity?: number;
+  /** Maximum time to wait for requested capacity. */
+  provisionTimeoutMs?: number;
   /** Keep sandboxes alive after completion (default: false) */
   persistent?: boolean;
+  /** Lifecycle policy for persistent batch sandboxes. */
+  lifecycle?: {
+    idleTimeoutMs?: number;
+    coldTimeoutMs?: number;
+  };
+  /** Use deterministic mock model responses. Intended for tests. */
+  mock?: boolean;
   /** Milliseconds to keep non-persistent batch sandboxes alive after completion. */
   graceMs?: number;
+  /** Repository cloned into persistent batch workspaces. */
+  git?: GitConfig;
+  /** Full replacement for the default agent system prompt. */
+  systemPrompt?: string;
+  /** Instructions appended to the default agent system prompt. */
+  instructions?: string;
   /**
    * AbortSignal to cancel the batch mid-stream. When aborted, the HTTP
    * request to `/batch/run` is torn down; the SSE generator stops
@@ -1847,6 +2182,14 @@ interface BatchOptions {
    */
   signal?: AbortSignal;
 }
+/** Complete request accepted by `runBatch` and `streamBatch`. */
+interface BatchRunRequest extends Omit<BatchOptions, "signal"> {
+  tasks: BatchTask[];
+}
+/** Per-call controls that are not serialized into a batch request. */
+interface BatchRunOptions {
+  signal?: AbortSignal;
+}
 /**
  * Result of a single task in a batch.
  */
@@ -1865,6 +2208,16 @@ interface BatchTaskResult {
   retries: number;
   /** Token usage if available */
   tokensUsed?: number;
+  /** Backend identifier for multi-backend batches. */
+  backend?: string;
+  /** Human-readable backend label emitted by the server. */
+  backendLabel?: string;
+  /** Model identifier emitted by the server. */
+  backendModel?: string;
+  /** Runtime session created for this task execution. */
+  sessionId?: string;
+  /** Sandbox used for this task execution. */
+  sandboxId?: string;
 }
 /**
  * Summary of batch execution.
@@ -1883,23 +2236,145 @@ interface BatchResult {
   /** Individual task results */
   results: BatchTaskResult[];
 }
-/**
- * SSE event from batch streaming.
- */
-interface BatchEvent {
-  /** Event type (batch.started, task.completed, etc.) */
-  type: string;
-  /** Event data */
-  data: Record<string, unknown>;
-  /**
-   * Optional `id:` from the SSE frame. Present at runtime whenever
-   * the server emits an `id:` line (used by EventSource-style
-   * reconnection). Declared optional because the batch protocol
-   * doesn't currently emit it — downstream consumers that want to
-   * implement resume should feature-detect.
-   */
-  id?: string;
+/** Token and tool usage emitted when one batch task completes. */
+interface BatchTaskUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  toolCallCount?: number;
+}
+/** Per-backend aggregate emitted by `batch.completed`. */
+interface BatchBackendStats {
+  backend: string;
+  backendLabel?: string;
+  backendModel?: string;
+  success: number;
+  failure: number;
+  retries: number;
+  successRate: number;
+}
+/** Sidecars allocated to one backend configuration. */
+interface BatchSidecarGroup {
+  backend: string;
+  sidecarIds: string[];
 }
+interface BatchTaskEventIdentity {
+  taskId: string;
+  backend: string;
+  backendLabel?: string;
+  backendModel?: string;
+}
+/** Data payloads keyed by the SSE event name emitted by `/batch/run`. */
+interface BatchEventDataMap {
+  "batch.provisioning": {
+    desiredCapacity: number;
+    currentCapacity: number;
+    provisionTimeoutMs: number;
+  };
+  "batch.provisioned": {
+    capacity: number;
+  };
+  "batch.started": {
+    taskCount: number;
+    backendCount: number;
+    totalExecutions: number;
+    maxConcurrent: number;
+    scalingMode: string;
+    backends: string[];
+  };
+  "sidecars.allocated": {
+    count: number;
+    groups: BatchSidecarGroup[];
+  };
+  "batch.completed": {
+    taskCount: number;
+    backendCount: number;
+    totalExecutions: number;
+    totalSuccess: number;
+    totalFailure: number;
+    totalRetries: number;
+    successRate: number;
+    byBackend: BatchBackendStats[];
+  };
+  "batch.failed": {
+    error: string;
+    backends?: string[];
+  };
+  "batch.persistent": {
+    message: string;
+    sidecarCount: number;
+  };
+  "batch.grace_period": {
+    message: string;
+    sidecarCount: number;
+    graceMs: number;
+    sidecarIds: string[];
+  };
+  "task.started": BatchTaskEventIdentity & {
+    sidecarId: string;
+    projectRef?: string;
+    attempt: number;
+  };
+  "task.message.delta": BatchTaskEventIdentity & {
+    sidecarId: string;
+    projectRef?: string;
+    value: string;
+    part: Record<string, unknown>;
+  };
+  "task.reasoning": BatchTaskEventIdentity & {
+    sidecarId: string;
+    projectRef?: string;
+    value: string;
+    part: Record<string, unknown>;
+  };
+  "task.tool.updated": BatchTaskEventIdentity & {
+    sidecarId: string;
+    projectRef?: string;
+    part: Record<string, unknown>;
+  };
+  "task.completed": BatchTaskEventIdentity & {
+    durationMs: number;
+    attempt: number;
+    retries: number;
+    sidecarId: string;
+    projectRef?: string;
+    resultSummary?: string;
+    sessionId?: string;
+    usage: BatchTaskUsage;
+  };
+  "task.failed": BatchTaskEventIdentity & {
+    durationMs: number;
+    attempt: number;
+    retries: number;
+    error: string;
+    sidecarId?: string;
+  };
+  "task.retry": BatchTaskEventIdentity & {
+    attempt: number;
+    maxRetries: number;
+    error: string;
+    delayMs: number;
+  };
+  "backend.completed": {
+    backend: string;
+    backendLabel?: string;
+    backendModel?: string;
+    success: number;
+    failure: number;
+    retries: number;
+    successRate: number;
+  };
+  "sidecar.releasing": {
+    sidecarId: string;
+  };
+}
+/** Discriminated SSE event from a batch execution. */
+type BatchEvent = { [K in keyof BatchEventDataMap]: {
+  type: K;
+  data: BatchEventDataMap[K]; /** Optional SSE id used by reconnecting consumers. */
+  id?: string;
+} }[keyof BatchEventDataMap];
 /**
  * Stable worker identifier inside a sandbox fleet.
  *
@@ -2421,74 +2896,24 @@ 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 */
-  resources?: SandboxResources;
-  /** Custom metadata for the fork */
+  /**
+   * Custom metadata applied to every child.
+   *
+   * Resource overrides are intentionally NOT accepted: a live branch restores
+   * the parent's memory copy-on-write into each child, which requires
+   * matching resources — children always inherit the parent's.
+   */
   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 +2945,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.
  *
@@ -2727,6 +3250,42 @@ interface BackendConfig {
     /** Server port (auto-assigned if not specified) */port?: number; /** Server hostname */
     hostname?: string;
   };
+  /**
+   * Enable structured human interactions by kind.
+   *
+   * Each enabled kind surfaces as an `interaction` event on the session stream
+   * and is answered through the same `/agents/sessions/{id}/interactions`
+   * route. The object form is the public shape:
+   * `{ question: true }`, `{ permission: true }`, `{ plan: true }`.
+   *
+   * Use `{ question: true }` when the agent should ask the user clarifying
+   * questions without enabling permission prompts. Unsupported requested kinds
+   * reject session initialization loudly rather than silently disappearing.
+   *
+   * @example question-enabled codex session
+   * ```typescript
+   * backend: { type: "codex", interactions: { question: true } }
+   * ```
+   *
+   * @default false
+   */
+  interactions?: {
+    permission?: boolean;
+    question?: boolean;
+    plan?: boolean;
+  };
+  /** Runtime session metadata used for attribution and workspace selection. */
+  metadata?: {
+    containerType?: string;
+    telemetry?: {
+      otlp: {
+        endpoint: string;
+        headers: string;
+      };
+      resourceAttributes: Record<string, string>;
+    };
+    [key: string]: unknown;
+  };
 }
 /**
  * Backend capabilities.
@@ -3700,6 +4259,71 @@ interface FileInfo {
   /** Last access time */
   accessTime: Date;
 }
+/** File metadata returned by the recursive workspace tree endpoint. */
+interface FileTreeFile {
+  path: string;
+  size: number;
+  /** File modification time as Unix milliseconds. */
+  mtime: number;
+}
+/** Options for recursively scanning a workspace tree. */
+interface FileTreeOptions {
+  sessionId?: string;
+  maxDepth?: number;
+}
+/** Recursive workspace tree with scan statistics. */
+interface FileTreeResult {
+  root: string;
+  directories: string[];
+  files: FileTreeFile[];
+  stats: {
+    totalDirectories: number;
+    totalFiles: number;
+    scanDurationMs: number;
+    truncated: boolean;
+  };
+}
+/** File content and metadata returned by a batch read. */
+interface FileReadResult {
+  path: string;
+  content: string;
+  encoding: "utf8" | "base64";
+  hash: string;
+  size: number;
+  /** File modification time as Unix milliseconds. */
+  mtime: number;
+}
+/** One file that could not be read during a partial-success batch. */
+interface FileReadError {
+  path: string;
+  error: string;
+  code?: string;
+}
+/** Options for reading files in a batch. */
+interface FileReadBatchOptions {
+  encoding?: "utf8" | "base64";
+  sessionId?: string;
+}
+/** Partial-success result from a batch file read. */
+interface FileReadBatchResult {
+  files: FileReadResult[];
+  errors: FileReadError[];
+  stats: {
+    requested: number;
+    succeeded: number;
+    failed: number;
+  };
+}
+/** Metadata returned after a successful file write. */
+interface FileWriteResult {
+  path: string;
+  hash: string;
+  size: number;
+  /** File modification time as Unix milliseconds. */
+  mtime: number;
+  /** Encoding echoed by runtimes that include it in write responses. */
+  encoding?: "utf8" | "base64";
+}
 /**
  * Options for uploading files.
  */
@@ -3750,6 +4374,8 @@ interface ListOptions {
   all?: boolean;
   /** Include full metadata (like ls -l) */
   long?: boolean;
+  /** Task session id for session-specific workspace isolation. */
+  sessionId?: string;
 }
 /**
  * Options for creating directories.
@@ -3766,6 +4392,8 @@ interface MkdirOptions {
 interface DeleteOptions {
   /** Recursively delete directories (like rm -rf) */
   recursive?: boolean;
+  /** Agent session whose workspace and change history receive the deletion. */
+  sessionId?: string;
 }
 /**
  * File system operations for sandboxes. Access via `sandbox.fs`.
@@ -3830,6 +4458,10 @@ interface WriteManyFile {
 interface WriteFileOptions {
   /** Unix mode bits applied after write, e.g. 0o755. */
   mode?: number;
+  /** Encoding of `content` on the wire. */
+  encoding?: "utf8" | "base64";
+  /** Agent session whose workspace and change history receive the write. */
+  sessionId?: string;
 }
 /** Options for {@link FileSystem.writeMany}. */
 interface WriteManyOptions {
@@ -3851,6 +4483,10 @@ interface FileSystem {
    * @throws NotFoundError if file doesn't exist
    */
   read(path: string): Promise<string>;
+  /** Read up to any number of files with content metadata and per-file errors. */
+  readBatch(paths: string[], options?: FileReadBatchOptions): Promise<FileReadBatchResult>;
+  /** Recursively scan the workspace and return file metadata. */
+  tree(path: string, options?: FileTreeOptions): Promise<FileTreeResult>;
   /**
    * Write string content to a file.
    * For binary files, use upload() instead.
@@ -3859,7 +4495,7 @@ interface FileSystem {
    * @param path - Path to file (relative to workspace)
    * @param content - Content to write
    */
-  write(path: string, content: string, options?: WriteFileOptions): Promise<void>;
+  write(path: string, content: string, options?: WriteFileOptions): Promise<FileWriteResult>;
   /**
    * Write many files in one paced, retry-aware batch.
    *
@@ -4326,6 +4962,10 @@ interface SandboxSessionHost extends InteractiveSessionHost {
   _sessionEvents(id: string, opts?: SessionEventStreamOptions): AsyncGenerator<SandboxEvent>;
   _sessionResult(id: string): Promise<PromptResult>;
   _sessionCancel(id: string): Promise<void>;
+  _sessionDelete(id: string): Promise<void>;
+  _sessionSendMessage(id: string, request: SendSessionMessageRequest, options?: SendSessionMessageOptions): Promise<SentSessionMessage>;
+  messages(opts: ListMessagesOptions): Promise<SessionMessage[]>;
+  _sessionFork(id: string, opts?: SessionForkOptions): Promise<SessionInfo>;
   _respondToPermission(id: string, permissionID: string, options: RespondToPermissionOptions): Promise<void>;
   _interrupt(id: string): Promise<InterruptResult>;
   _answerQuestion(id: string, answers: Record<string, string[]>): Promise<void>;
@@ -4372,12 +5012,22 @@ declare class SandboxSession {
    * (e.g. `dispatchPrompt`).
    */
   result(): Promise<PromptResult>;
+  /**
+   * List persisted messages for this session, including in-flight assistant
+   * content when the runtime has flushed partial output.
+   */
+  messages(opts?: Omit<ListMessagesOptions, "sessionId">): Promise<SessionMessage[]>;
   /**
    * Continue this session with an additional prompt. Equivalent to
    * `box.prompt(message, { ...opts, sessionId: this.id })` but reads
    * naturally on a Session reference.
    */
   prompt(message: string | PromptInputPart[], opts?: PromptOptions): Promise<PromptResult>;
+  /**
+   * Send a structured message through the session message endpoint. Model and
+   * message identifiers are translated to the runtime's wire names by the SDK.
+   */
+  sendMessage(request: SendSessionMessageRequest, options?: SendSessionMessageOptions): Promise<SentSessionMessage>;
   /**
    * Abort the session's in-flight execution; the session and its messages
    * are preserved (this does not delete the session). Void-returning alias
@@ -4387,6 +5037,17 @@ declare class SandboxSession {
    * aborting a session with nothing in flight is a no-op.
    */
   cancel(): Promise<void>;
+  /** Delete this session and its persisted runtime state. */
+  delete(): Promise<void>;
+  /**
+   * Fork this session into a new queued session. The fork shares the
+   * parent workspace and copies conversation history up to `messageId`
+   * when supplied.
+   */
+  fork(opts?: SessionForkOptions): Promise<{
+    session: SandboxSession;
+    info: SessionInfo;
+  }>;
   /**
    * Drive this session's harness in INTERACTIVE mode: spawn its native TUI,
    * stream the live framebuffer, and inject prompts as keystrokes. Distinct
@@ -4408,12 +5069,31 @@ declare class SandboxSession {
   interrupt(): Promise<InterruptResult>;
   /**
    * Answer a question the agent asked via a question tool invocation. `answers`
-   * maps each question id to the selected option(s). OpenCode-only; other
-   * backends reject loudly.
+   * maps each question id to the selected option(s). Backend-agnostic: works
+   * with any backend that raises kind:"question" interactions — OpenCode
+   * natively, or CLI backends with `BackendConfig.interactions.question`
+   * enabled. Backends with no question support reject loudly.
    */
   answer(answers: Record<string, string[]>): Promise<void>;
 }
 //#endregion
+//#region src/task-session.d.ts
+/** @internal Operations implemented by `SandboxInstance`. */
+interface SandboxTaskSessionHost extends SandboxSessionHost {
+  _taskSessionChanges(id: string): Promise<TaskSessionChanges>;
+  _taskSessionCommit(id: string, options?: CommitTaskSessionOptions): Promise<TaskSessionCommitResult>;
+}
+/** A background task session with isolated changeset operations. */
+declare class SandboxTaskSession extends SandboxSession {
+  private readonly taskBox;
+  /** @internal Apps should call `box.taskSession(id)`. */
+  constructor(taskBox: SandboxTaskSessionHost, id: string);
+  /** Read the task's isolated file changes. */
+  changes(): Promise<TaskSessionChanges>;
+  /** Apply all or a selected subset of the task's isolated file changes. */
+  commit(options?: CommitTaskSessionOptions): Promise<TaskSessionCommitResult>;
+}
+//#endregion
 //#region src/trace-exporter.d.ts
 type JsonObject = {
   [key: string]: JsonValue;
@@ -4439,6 +5119,18 @@ declare function toOtelJson(bundle: TraceExportBundle, serviceName?: string): Js
 declare function otelTraceIdForTangleTrace(traceId: string): string;
 //#endregion
 //#region src/sandbox.d.ts
+/**
+ * Result of registering a sidecar session mapping. `reprovisionRequired` is
+ * true when the server reports the mapped sidecar is stale (HTTP 410) and the
+ * caller must reprovision the sandbox before retrying.
+ */
+interface SessionMappingResult {
+  success: boolean;
+  sessionId: string;
+  sidecarSessionId?: string;
+  reprovisionRequired: boolean;
+  code?: string;
+}
 /**
  * HTTP client interface for making requests.
  */
@@ -4499,6 +5191,7 @@ declare class SandboxInstance {
   private readonly client;
   private info;
   private readonly defaultRuntimeBackend?;
+  private readonly runtime;
   constructor(client: HttpClient, info: SandboxInfo, defaultRuntimeBackend?: BackendConfig);
   /** Unique sandbox identifier */
   get id(): string;
@@ -4520,6 +5213,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;
   /**
@@ -4715,7 +5410,7 @@ declare class SandboxInstance {
    * await box.write("/tmp/config.json", JSON.stringify(config));
    * ```
    */
-  write(path: string, content: string, options?: WriteFileOptions): Promise<void>;
+  write(path: string, content: string, options?: WriteFileOptions): Promise<FileWriteResult>;
   /**
    * Write many files in one paced, retry-aware batch — see
    * {@link FileSystem.writeMany}. Each file goes through {@link write}; a small
@@ -4730,6 +5425,7 @@ declare class SandboxInstance {
    * Returns the complete response after the agent finishes.
    */
   prompt(message: string | PromptInputPart[], options?: PromptOptions): Promise<PromptResult>;
+  private logStreamCheckpoint;
   /**
    * Stream events from an agent prompt.
    * Use this for real-time updates during agent execution.
@@ -4852,6 +5548,14 @@ declare class SandboxInstance {
    * ```
    */
   search(pattern: string, options?: SearchOptions): AsyncGenerator<SearchMatch>;
+  /** Basic health reported by the runtime inside this sandbox. */
+  runtimeHealth(): Promise<SandboxRuntimeHealth>;
+  /** Return the runtime's current listening-port snapshot. */
+  ports(): Promise<SandboxPortBinding[]>;
+  /** Interactive terminal operations for this runtime. */
+  get terminals(): SandboxTerminalManager;
+  /** List profiles installed in this sandbox runtime. */
+  listProfiles(): Promise<SandboxRuntimeProfileList>;
   /**
    * Live whole-sandbox resource usage (memory + CPU) from the container cgroup.
    *
@@ -4935,6 +5639,8 @@ declare class SandboxInstance {
    * ```
    */
   get fs(): FileSystem;
+  private fsReadBatch;
+  private fsTree;
   private fsUpload;
   private fsDownload;
   private fsUploadDir;
@@ -5098,12 +5804,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 +5944,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 +6037,6 @@ declare class SandboxInstance {
    * delivers progress callbacks while waiting for a target status.
    */
   private waitForWithSSE;
-  private parseCheckpointInfo;
   private ensureRunning;
   private runtimeFetch;
   /**
@@ -5394,9 +6065,24 @@ declare class SandboxInstance {
    * ```
    */
   registerSessionMapping(opts: {
+    sessionId: string;
+    userId: string; /** The runtime (sidecar) session id this agent session routes to. */
+    runtimeSessionId: string; /** Optional container id for direct routing. */
+    sidecarId?: string; /** Optional projectRef so the server can detect a stale sidecar. */
+    projectRef?: string;
+  }): Promise<SessionMappingResult>;
+  /**
+   * Remove the sidecar session mapping for an agent session. Sandbox deletion
+   * also cleans mappings, so this is only needed to release a mapping while the
+   * sandbox stays alive.
+   */
+  unregisterSessionMapping(opts: {
     sessionId: string;
     userId: string;
-  }): Promise<void>;
+  }): Promise<{
+    success: boolean;
+    sessionId: string;
+  }>;
   private parseInfo;
   private sleep;
   /**
@@ -5405,6 +6091,20 @@ declare class SandboxInstance {
    * Use {@link sessions} to discover existing session ids.
    */
   session(id: string): SandboxSession;
+  /** Create an agent session and return both its handle and initial metadata. */
+  createSession(options: CreateSessionOptions): Promise<{
+    session: SandboxSession;
+    info: SessionInfo;
+  }>;
+  /** Delete an agent session by id. */
+  deleteSession(id: string): Promise<void>;
+  /** Get a lazy background-task session reference. */
+  taskSession(id: string): SandboxTaskSession;
+  /** Create a background task session. Dispatch work with `session.sendMessage()`. */
+  createTaskSession(options: CreateTaskSessionOptions): Promise<{
+    session: SandboxTaskSession;
+    info: TaskSessionInfo;
+  }>;
   /**
    * List sessions on this sandbox, optionally filtering by status. Returns
    * `SandboxSession` instances paired with their last-known
@@ -5440,6 +6140,15 @@ declare class SandboxInstance {
    * abort stamps `interrupted: true` explicitly.
    */
   messages(opts: ListMessagesOptions): Promise<SessionMessage[]>;
+  /** @internal — invoked by SandboxSession.sendMessage(). */
+  _sessionSendMessage(id: string, request: SendSessionMessageRequest, options?: SendSessionMessageOptions): Promise<SentSessionMessage>;
+  /** @internal — invoked by SandboxSession.delete(). */
+  _sessionDelete(id: string): Promise<void>;
+  /** @internal — invoked by SandboxTaskSession.changes(). */
+  _taskSessionChanges(id: string): Promise<TaskSessionChanges>;
+  /** @internal — invoked by SandboxTaskSession.commit(). */
+  _taskSessionCommit(id: string, options?: CommitTaskSessionOptions): Promise<TaskSessionCommitResult>;
+  _sessionFork(id: string, opts?: SessionForkOptions): Promise<SessionInfo>;
   /**
    * Look up a cached turn result by idempotency key. Returns the cached
    * payload if a turn with this `turnId` previously completed on the
@@ -5525,4 +6234,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 { CodeExecutionResult as $, AgentProfileFileMount as $i, ReconcileSandboxFleetsResult as $n, SandboxTraceOptions as $r, GitDiff as $t, AddUserOptions as A, TaskSessionFileChange as Ai, PreviewLinkInfo as An, SandboxFleetWorkspace as Ar, FileReadBatchOptions as At, BatchBackendStats as B, TurnDriveResult as Bi, PromptOptions as Bn, SandboxResourceUsage as Br, FleetDispatchResultBuffer as Bt, SandboxMcpConfig as C, StartupOperation as Ci, MintScopedTokenOptions as Cn, SandboxFleetPolicy as Cr, DriverType as Ct, buildSandboxMcpConfig as D, TaskResult as Di, NonHostAgentDriverConfig as Dn, SandboxFleetTraceExport as Dr, ExecOptions as Dt, buildControlPlaneMcpConfig as E, TaskOptions as Ei, NetworkManager as En, SandboxFleetTraceEvent as Er, EventStreamOptions as Et, BackendInfo as F, TeeAttestationResponse as Fi, ProcessManager as Fn, SandboxIntelligenceEnvelope as Fr, FileTreeFile as Ft, BatchRunOptions as G, WaitForOptions as Gi, ProvisionStep as Gn, SandboxStatus as Gr, FleetMachineId as Gt, BatchEventDataMap as H, UploadOptions as Hi, ProvisionEvent as Hn, SandboxRuntimeHealth as Hr, FleetDispatchStreamOptions as Ht, BackendManager as I, TeePublicKey as Ii, ProcessSignal as In, SandboxPermissionsConfig as Ir, FileTreeOptions as It, BatchTask as J, WriteManyOptions as Ji, PublishPublicTemplateOptions as Jn, SandboxTerminalManager as Jr, GPU_LEASE_PROVIDER_NAMES as Jt, BatchRunRequest as K, WriteFileOptions as Ki, PublicTemplateInfo as Kn, SandboxTerminalCreateOptions as Kr, FleetPromptDispatchOptions as Kt, BackendStatus as L, TeePublicKeyResponse as Li, ProcessSpawnOptions as Ln, SandboxPortBinding as Lr, FileTreeResult as Lt, AttachSandboxFleetMachineOptions as M, TaskSessionProfile as Mi, Process as Mn, SandboxFleetWorkspaceRestoreResult as Mr, FileReadError as Mt, BackendCapabilities as N, TeeAttestationOptions as Ni, ProcessInfo as Nn, SandboxFleetWorkspaceSnapshotResult as Nr, FileReadResult as Nt, AcceleratorKind as O, TaskSessionChanges as Oi, PermissionLevel as On, SandboxFleetTraceOptions as Or, ExecResult as Ot, BackendConfig as P, TeeAttestationReport as Pi, ProcessLogEntry as Pn, SandboxInfo as Pr, FileSystem as Pt, CodeExecutionOptions as Q, AgentProfileConnection as Qi, ReconcileSandboxFleetsOptions as Qn, SandboxTraceExport as Qr, GitConfig as Qt, BackendType as R, TokenRefreshHandler as Ri, ProcessStatus as Rn, SandboxPortPreviewLink as Rr, FileWriteResult as Rt, SANDBOX_MCP_SERVER_NAME as S, StartupDiagnostics as Si, McpServerConfig as Sn, SandboxFleetOperationsSummary as Sr, DriverInfo as St, SandboxMcpServerEntry as T, SubscriptionInfo as Ti, NetworkConfig as Tn, SandboxFleetTraceBundle as Tr, EgressPolicy as Tt, BatchOptions as U, UploadProgress as Ui, ProvisionResult as Un, SandboxRuntimeProfile as Ur, FleetExecDispatchOptions as Ut, BatchEvent as V, UpdateUserOptions as Vi, PromptResult as Vn, SandboxResources as Vr, FleetDispatchResultBufferOptions as Vt, BatchResult as W, UsageInfo as Wi, ProvisionStatus as Wn, SandboxRuntimeProfileList as Wr, FleetExecDispatchResult as Wt, BatchTaskUsage as X, AgentProfileCapabilities as Xi, ReapExpiredSandboxFleetsOptions as Xn, SandboxTraceBundle as Xr, GitBranch as Xt, BatchTaskResult as Y, AgentProfile as Yi, PublishPublicTemplateVersionOptions as Yn, SandboxTerminalRequestOptions as Yr, GitAuth as Yt, BranchOptions as Z, AgentProfileConfidential as Zi, ReapExpiredSandboxFleetsResult as Zn, SandboxTraceEvent as Zr, GitCommit as Zt, RespondToPermissionOptions as _, SessionStatus as _i, IntelligenceReportWindow as _n, SandboxFleetMachineMeteredUsage as _r, DispatchedSession as _t, TraceExportSink as a, AgentProfileResources as aa, SecretInfo as ai, GpuLeaseExecResult as an, SandboxEnvironment as ar, CreateGpuLeaseOptions as at, BuildSandboxMcpConfigOptions as b, SnapshotResult as bi, ListSandboxFleetOptions as bn, SandboxFleetManifest as br, DriveTurnOptions as bt, otelTraceIdForTangleTrace as c, AgentSubagentProfile as ca, SendSessionMessageRequest as ci, GpuLeaseStatus as cn, SandboxFleetArtifactSpec as cr, CreateSandboxFleetOptions as ct, SandboxSession as d, defineInlineResource as da, SessionEventStreamOptions as di, HostAgentRuntimeBackend as dn, SandboxFleetDispatchResponse as dr, CreateSandboxOptions as dt, AgentProfileMcpServer as ea, SandboxUser as ei, GitStatus as en, RunCodeOptions as er, CodeLanguage as et, InteractiveAuthFile as f, mergeAgentProfiles as fa, SessionForkOptions as fi, InstalledTool as fn, SandboxFleetDriverCapability as fr, CreateSessionOptions as ft, InterruptResult as g, SessionMessageInputPart as gi, IntelligenceReportSubjectType as gn, SandboxFleetMachine as gr, DispatchPromptOptions as gt, InteractiveSessionInfo as h, SessionMessage as hi, IntelligenceReportCompareTo as hn, SandboxFleetIntelligenceEnvelope as hr, DirectoryPermission as ht, TraceExportResult as i, AgentProfileResourceRef as ia, SearchOptions as ii, GpuLeaseExecOptions as in, SandboxConnection as ir, CompletedTurnResult as it, AttachGpuLeaseOptions as j, TaskSessionInfo as ji, PreviewLinkManager as jn, SandboxFleetWorkspaceReconcileResult as jr, FileReadBatchResult as jt, AccessPolicyRule as k, TaskSessionCommitResult as ki, PermissionsManager as kn, SandboxFleetUsage as kr, FileInfo as kt, toOtelJson as l, defineAgentProfile as la, SentSessionMessage as li, GpuType as ln, SandboxFleetCostEstimate as lr, CreateSandboxFleetTokenOptions as lt, InteractiveSessionHost as m, SessionListOptions as mi, IntelligenceReportBudget as mn, SandboxFleetInfo as mr, DeleteOptions as mt, SandboxInstance as n, AgentProfilePermissionValue as na, ScopedTokenScope as ni, GpuLeaseBilling as nn, SSHCredentials as nr, CodeResultPart as nt, buildTraceExportPayload as o, AgentProfileValidationIssue as oa, SecretsManager as oi, GpuLeaseManager as on, SandboxEvent as or, CreateIntelligenceReportOptions as ot, InteractiveSessionHandle as p, SessionInfo as pi, IntelligenceReport as pn, SandboxFleetDriverTimings as pr, CreateTaskSessionOptions as pt, BatchSidecarGroup as q, WriteManyFile as qi, PublicTemplateVersionInfo as qn, SandboxTerminalInfo as qr, FleetPromptDispatchResult as qt, TraceExportFormat as r, AgentProfilePrompt as ra, SearchMatch as ri, GpuLeaseCommandResult as rn, SandboxClientConfig as rr, CommitTaskSessionOptions as rt, exportTraceBundle as s, AgentProfileValidationResult as sa, SendSessionMessageOptions as si, GpuLeaseProviderName as sn, SandboxFleetArtifact as sr, CreateRequestOptions as st, HttpClient as t, AgentProfileModelHints as ta, ScopedToken as ti, GpuLease as tn, SSHCommandDescriptor as tr, CodeResult as tt, SandboxTaskSession as u, defineGitHubResource as ua, SessionBackendCredentials as ui, HostAgentDriverConfig as un, SandboxFleetDispatchFailureClass as ur, CreateSandboxFleetWithCoordinatorOptions as ut, StartInteractiveOptions as v, SnapshotInfo as vi, ListMessagesOptions as vn, SandboxFleetMachineRecord as vr, DownloadOptions as vt, SandboxMcpEndpoint as w, StorageConfig as wi, MkdirOptions as wn, SandboxFleetToken as wr, EgressManager as wt, CONTROL_PLANE_MCP_SERVER_NAME as x, SshKeysManager as xi, ListSandboxOptions as xn, SandboxFleetManifestMachine as xr, DriverConfig as xt, BuildControlPlaneMcpConfigOptions as y, SnapshotOptions as yi, ListOptions as yn, SandboxFleetMachineSpec as yr, DownloadProgress as yt, BatchBackend as z, ToolsConfig as zi, PromptInputPart as zn, SandboxProfileSummary as zr, FleetDispatchCancelResult as zt };