@tangle-network/sandbox 0.9.4-develop.20260710200846.ca3d375 → 0.9.4-develop.20260711011249.9d3b3b3

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

@@ -794,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.
  *
@@ -1618,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.
  */
@@ -1887,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.
  */
@@ -1901,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
@@ -1917,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.
  */
@@ -1935,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.
@@ -1953,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.
  *
@@ -2869,6 +3274,18 @@ interface BackendConfig {
     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.
@@ -3842,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.
  */
@@ -3910,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`.
@@ -3974,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 {
@@ -3995,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.
@@ -4003,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.
    *
@@ -4470,6 +4962,8 @@ 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>;
@@ -4529,6 +5023,11 @@ declare class SandboxSession {
    * 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
@@ -4538,6 +5037,8 @@ 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`
@@ -4576,6 +5077,23 @@ declare class SandboxSession {
   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;
@@ -4673,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;
@@ -4891,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
@@ -5029,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.
    *
@@ -5112,6 +5639,8 @@ declare class SandboxInstance {
    * ```
    */
   get fs(): FileSystem;
+  private fsReadBatch;
+  private fsTree;
   private fsUpload;
   private fsDownload;
   private fsUploadDir;
@@ -5562,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
@@ -5597,6 +6140,14 @@ 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
@@ -5683,4 +6234,4 @@ declare class SandboxInstance {
   _answerQuestion(id: string, answers: Record<string, string[]>): Promise<void>;
 }
 //#endregion
-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 };
+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 };