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

package/dist/index.js

@@ -1,8 +1,8 @@
-import { a as collectAgentResponseText, c as buildTraceExportPayload, d as toOtelJson, g as serializeForSidecar, h as normalizeRuntimeBackendConfig, i as applySandboxEventText, l as exportTraceBundle, m as parseSSEStream, n as SandboxSession, o as getSandboxEventText, p as encodeTextForWire, r as InteractiveSessionHandle, t as SandboxInstance, u as otelTraceIdForTangleTrace } from "./sandbox-BTBbZupV.js";
+import { a as collectAgentResponseText, c as buildTraceExportPayload, d as toOtelJson, g as serializeForSidecar, h as normalizeRuntimeBackendConfig, i as applySandboxEventText, l as exportTraceBundle, m as parseSSEStream, n as SandboxSession, o as getSandboxEventText, p as encodeTextForWire, r as InteractiveSessionHandle, t as SandboxInstance, u as otelTraceIdForTangleTrace } from "./sandbox-CDKpHv6-.js";
 import { a as PartialFailureError, c as ServerError, d as ValidationError, i as NotFoundError, l as StateError, n as CapabilityError, o as QuotaError, r as NetworkError, s as SandboxError, t as AuthError, u as TimeoutError } from "./errors-DZsfJUuc.js";
-import { a as DEFAULT_SANDBOX_SIZE, c as resolveSandboxResources, i as SandboxFleetClient, l as sandboxResourcesForSize, n as SandboxClient, o as SANDBOX_SIZE_PRESETS, r as SandboxFleet, s as SANDBOX_SIZE_PRESET_NAMES, t as IntelligenceClient } from "./client-BHEh7X6F.js";
+import { a as DEFAULT_SANDBOX_SIZE, c as resolveSandboxResources, i as SandboxFleetClient, l as sandboxResourcesForSize, n as SandboxClient, o as SANDBOX_SIZE_PRESETS, r as SandboxFleet, s as SANDBOX_SIZE_PRESET_NAMES, t as IntelligenceClient } from "./client-9lYm4XHo.js";
 import { a as CollaborationClient, i as parseCollaborationDocumentId, n as buildCollaborationDocumentId, r as normalizeCollaborationPath, t as CollaborationFileBridge } from "./collaboration-BxlfZ2Uh.js";
-import { t as TangleSandboxClient } from "./tangle-D1c-2Jr2.js";
+import { t as TangleSandboxClient } from "./tangle-DdHzeMUH.js";
 import { defineAgentProfile, defineGitHubResource, defineInlineResource, mergeAgentProfiles } from "@tangle-network/agent-interface";
 //#region src/confidential.ts
 function generateAttestationNonce(bytes = 32) {
@@ -595,6 +595,20 @@ function generateDockerfile(spec) {
 	return lines.join("\n");
 }
 //#endregion
+//#region src/types.ts
+const GPU_LEASE_PROVIDER_NAMES = [
+	"runpod",
+	"vast-ai",
+	"lambda-labs",
+	"tensordock",
+	"paperspace",
+	"aws",
+	"gcp",
+	"azure",
+	"crusoe",
+	"fluidstack"
+];
+//#endregion
 //#region src/manage-sandboxes.ts
 const MANAGE_SANDBOXES_TOOL_NAME = "manageSandboxes";
 function createManageSandboxesTool(client, options = {}) {
@@ -605,8 +619,8 @@ function createManageSandboxesTool(client, options = {}) {
 		async execute(input) {
 			switch (input.action) {
 				case "capabilities": return client.fleets.capabilities();
-				case "create": return client.fleets.create(applyToolPolicy(requireCreateOptions(input), options.policy));
-				case "createWithCoordinator": return client.fleets.createWithCoordinator(applyToolPolicy(requireCreateWithCoordinatorOptions(input), options.policy));
+				case "create": return client.fleets.create(applyFleetGpuPolicy(applyToolPolicy(requireCreateOptions(input), options.policy), options.gpuPolicy));
+				case "createWithCoordinator": return client.fleets.createWithCoordinator(applyFleetGpuPolicyToCoordinator(applyToolPolicy(requireCreateWithCoordinatorOptions(input), options.policy), options.gpuPolicy));
 				case "list": return client.fleets.list({ fleetId: requireString(input, "fleetId") });
 				case "delete": return client.fleets.delete(requireString(input, "fleetId"));
 				case "attachMachine": return client.fleets.attachMachine(requireString(input, "fleetId"), requireMachine(input));
@@ -619,6 +633,13 @@ function createManageSandboxesTool(client, options = {}) {
 				case "createWorkspaceSnapshot": return client.fleets.createWorkspaceSnapshot(requireString(input, "fleetId"));
 				case "restoreWorkspaceSnapshot": return client.fleets.restoreWorkspaceSnapshot(requireString(input, "fleetId"), requireString(input, "snapshotId"));
 				case "reconcileWorkspace": return client.fleets.reconcileWorkspace(requireString(input, "fleetId"));
+				case "attachGpuLease": {
+					const attachOptions = applyGpuToolPolicy(requireGpuAttachOptions(input), options.gpuPolicy);
+					return (await requireSandbox(client, requireString(input, "sandboxId"))).gpu.attach(attachOptions);
+				}
+				case "listGpuLeases": return (await requireSandbox(client, requireString(input, "sandboxId"))).gpu.list();
+				case "execGpuLease": return (await requireSandbox(client, requireString(input, "sandboxId"))).gpu.exec(requireString(input, "leaseId"), requireGpuCommand(input));
+				case "detachGpuLease": return (await requireSandbox(client, requireString(input, "sandboxId"))).gpu.detach(requireString(input, "leaseId"));
 				default: throw new Error(`Unsupported manageSandboxes action: ${String(input.action)}`);
 			}
 		}
@@ -650,6 +671,77 @@ function applyToolPolicy(options, policy) {
 		policy
 	};
 }
+function applyFleetGpuPolicy(options, gpuPolicy) {
+	return {
+		...options,
+		defaults: options.defaults ? applyGpuPolicyToCreateFragment(options.defaults, gpuPolicy, "fleet defaults") : void 0,
+		machines: options.machines.map((machine) => applyGpuPolicyToCreateFragment(machine, gpuPolicy, `machine ${machine.machineId}`))
+	};
+}
+function applyFleetGpuPolicyToCoordinator(options, gpuPolicy) {
+	return {
+		...options,
+		coordinator: options.coordinator ? applyGpuPolicyToCreateFragment(options.coordinator, gpuPolicy, "coordinator") : void 0,
+		workers: options.workers.map((worker) => applyGpuPolicyToCreateFragment(worker, gpuPolicy, `worker ${worker.machineId}`))
+	};
+}
+function applyGpuPolicyToCreateFragment(fragment, gpuPolicy, label) {
+	if (fragment.gpuLease !== void 0) throw new Error("manageSandboxes GPU lease budget fields must be supplied by the tool host");
+	if (!fragment.resources?.accelerator) return fragment;
+	if (!gpuPolicy) throw new Error(`manageSandboxes ${label} requested accelerators but no host-owned GPU policy was supplied`);
+	return {
+		...fragment,
+		gpuLease: gpuLeaseFromPolicy(gpuPolicy)
+	};
+}
+function gpuLeaseFromPolicy(policy) {
+	return {
+		...policy.provider ? { provider: policy.provider } : {},
+		maxSpendUsd: policy.maxSpendUsd,
+		maxLifetimeSeconds: policy.maxLifetimeSeconds,
+		...policy.idleTimeoutSeconds !== void 0 ? { idleTimeoutSeconds: policy.idleTimeoutSeconds } : {}
+	};
+}
+async function requireSandbox(client, sandboxId) {
+	const box = await client.get(sandboxId);
+	if (!box) throw new Error(`Sandbox not found: ${sandboxId}`);
+	return box;
+}
+function requireGpuAttachOptions(input) {
+	const value = input.options;
+	if (!value || typeof value !== "object") throw new Error("manageSandboxes requires options");
+	const options = value;
+	for (const key of [
+		"maxSpendUsd",
+		"maxLifetimeSeconds",
+		"idleTimeoutSeconds"
+	]) if (key in options && options[key] !== void 0) throw new Error("manageSandboxes GPU lease budget fields must be supplied by the tool host");
+	const acceleratorValue = options.accelerator;
+	if (!acceleratorValue || typeof acceleratorValue !== "object") throw new Error("manageSandboxes GPU lease attach requires accelerator");
+	requireString(acceleratorValue, "kind");
+	return value;
+}
+function applyGpuToolPolicy(options, policy) {
+	if (!policy) throw new Error("manageSandboxes GPU lease attach requires a host-owned policy");
+	const requestedProvider = options.provider;
+	if (requestedProvider && policy.allowProviders && !policy.allowProviders.includes(requestedProvider)) throw new Error(`GPU provider ${requestedProvider} is not allowed by policy`);
+	const acceleratorCount = options.accelerator.count ?? 1;
+	if (policy.maxAcceleratorCount !== void 0 && acceleratorCount > policy.maxAcceleratorCount) throw new Error(`GPU lease requested ${acceleratorCount} accelerator(s) but policy.maxAcceleratorCount is ${policy.maxAcceleratorCount}`);
+	const provider = policy.provider ?? requestedProvider;
+	return {
+		...options,
+		...provider ? { provider } : {},
+		maxSpendUsd: policy.maxSpendUsd,
+		maxLifetimeSeconds: policy.maxLifetimeSeconds,
+		...policy.idleTimeoutSeconds !== void 0 ? { idleTimeoutSeconds: policy.idleTimeoutSeconds } : {}
+	};
+}
+function requireGpuCommand(input) {
+	const value = input.command;
+	if (!value || typeof value !== "object") throw new Error("manageSandboxes requires command");
+	requireString(value, "command");
+	return value;
+}
 function requireMachine(input) {
 	const value = input.machine;
 	if (!value || typeof value !== "object") throw new Error("manageSandboxes requires machine");
@@ -662,6 +754,135 @@ const fleetId = {
 	type: "string",
 	pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$"
 };
+const accelerator = {
+	type: "object",
+	additionalProperties: false,
+	required: ["kind"],
+	properties: {
+		kind: {
+			type: "string",
+			pattern: "^[A-Za-z0-9][A-Za-z0-9._-]*$",
+			description: "Accelerator kind such as gpu, nvidia, nvidia-l4, or nvidia-h100."
+		},
+		count: {
+			type: "integer",
+			minimum: 1,
+			maximum: 16
+		},
+		memoryMB: {
+			type: "integer",
+			minimum: 1
+		}
+	}
+};
+const gpuLeaseAttachOptions = {
+	type: "object",
+	additionalProperties: false,
+	required: ["accelerator"],
+	properties: {
+		provider: {
+			type: "string",
+			enum: [...GPU_LEASE_PROVIDER_NAMES]
+		},
+		accelerator,
+		image: {
+			type: "string",
+			minLength: 1
+		},
+		env: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		}
+	}
+};
+const gpuLeaseCommand = {
+	type: "object",
+	additionalProperties: false,
+	required: ["command"],
+	properties: {
+		command: {
+			type: "string",
+			minLength: 1
+		},
+		timeoutMs: {
+			type: "integer",
+			minimum: 1,
+			maximum: 36e5
+		},
+		cwd: {
+			type: "string",
+			minLength: 1
+		},
+		env: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		}
+	}
+};
+const resources = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		cpuCores: {
+			type: "number",
+			exclusiveMinimum: 0
+		},
+		memoryMB: {
+			type: "integer",
+			minimum: 1
+		},
+		diskGB: {
+			type: "integer",
+			minimum: 1
+		},
+		accelerator
+	}
+};
+const driver = {
+	type: "object",
+	additionalProperties: true,
+	properties: {
+		type: {
+			type: "string",
+			enum: [
+				"docker",
+				"firecracker",
+				"host-agent",
+				"tangle"
+			]
+		},
+		runtimeBackend: {
+			type: "string",
+			enum: ["docker", "firecracker"]
+		}
+	}
+};
+const fleetMachineSpec = {
+	type: "object",
+	additionalProperties: true,
+	required: ["machineId"],
+	properties: {
+		machineId: fleetId,
+		name: {
+			type: "string",
+			minLength: 1
+		},
+		role: {
+			type: "string",
+			enum: ["coordinator", "worker"]
+		},
+		image: {
+			type: "string",
+			minLength: 1
+		},
+		environment: {
+			type: "string",
+			minLength: 1
+		},
+		resources,
+		driver
+	}
+};
 const MANAGE_SANDBOXES_PARAMETERS = {
 	type: "object",
 	additionalProperties: false,
@@ -684,16 +905,72 @@ const MANAGE_SANDBOXES_PARAMETERS = {
 				"cost",
 				"createWorkspaceSnapshot",
 				"restoreWorkspaceSnapshot",
-				"reconcileWorkspace"
+				"reconcileWorkspace",
+				"attachGpuLease",
+				"listGpuLeases",
+				"execGpuLease",
+				"detachGpuLease"
 			]
 		},
 		fleetId,
 		machineId: fleetId,
+		sandboxId: {
+			type: "string",
+			minLength: 1,
+			maxLength: 128
+		},
+		leaseId: {
+			type: "string",
+			minLength: 1,
+			maxLength: 128
+		},
 		snapshotId: {
 			type: "string",
 			minLength: 1
 		},
-		options: { type: "object" },
+		options: { anyOf: [{
+			type: "object",
+			additionalProperties: true,
+			properties: {
+				fleetId,
+				defaults: {
+					type: "object",
+					additionalProperties: true,
+					properties: {
+						image: {
+							type: "string",
+							minLength: 1
+						},
+						environment: {
+							type: "string",
+							minLength: 1
+						},
+						resources,
+						driver
+					}
+				},
+				machines: {
+					type: "array",
+					items: fleetMachineSpec,
+					minItems: 1
+				},
+				workers: {
+					type: "array",
+					items: fleetMachineSpec,
+					minItems: 1
+				},
+				coordinator: fleetMachineSpec,
+				workspace: {
+					type: "object",
+					additionalProperties: true,
+					properties: { mode: {
+						type: "string",
+						enum: ["isolated", "shared"]
+					} }
+				}
+			}
+		}, gpuLeaseAttachOptions] },
+		command: gpuLeaseCommand,
 		machine: {
 			type: "object",
 			required: ["machineId", "sandboxId"],
@@ -1452,4 +1729,4 @@ function stripUndefined(value) {
 	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => [k, stripUndefined(v)]));
 }
 //#endregion
-export { AuthError, CONTROL_PLANE_MCP_SERVER_NAME, CapabilityError, CollaborationClient, CollaborationFileBridge, DEFAULT_SANDBOX_SIZE, Image, ImageBuilder, IntelligenceClient, InteractiveSessionHandle, MANAGE_SANDBOXES_PARAMETERS, MANAGE_SANDBOXES_TOOL_NAME, NetworkError, NotFoundError, PartialFailureError, QuotaError, SANDBOX_MCP_SERVER_NAME, SANDBOX_SIZE_PRESETS, SANDBOX_SIZE_PRESET_NAMES, SandboxClient as Sandbox, SandboxClient, SandboxError, SandboxFleet, SandboxFleetClient, SandboxInstance, SandboxSession, ServerError, StateError, TangleSandboxClient, TimeoutError, ValidationError, applySandboxEventText, buildCollaborationDocumentId, buildControlPlaneMcpConfig, buildSandboxMcpConfig, buildTangleRouterEvalMatrixRequest, buildTangleRouterResponsesWebSearchRequest, buildTangleRouterSearchBackend, buildTangleRouterSearchProfile, buildTraceExportPayload, collectAgentResponseText, createConfidentialSandbox, createManageSandboxesTool, defineAgentProfile, defineGitHubResource, defineInlineResource, exportTraceBundle, fetchTangleRouterSearchConfig, generateAttestationNonce, generateDockerfile, getSandboxEventText, materializeProfileFileMounts, mergeAgentProfiles, normalizeCollaborationPath, normalizeRuntimeBackendConfig, otelTraceIdForTangleTrace, parseCollaborationDocumentId, parseSSEStream, resolveSandboxResources, runTangleRouterEvalMatrixInSandbox, sandboxResourcesForSize, serializeForSidecar, splitInlineProfileFileMounts, startTeeAttestationHeartbeat, toOtelJson };
+export { AuthError, CONTROL_PLANE_MCP_SERVER_NAME, CapabilityError, CollaborationClient, CollaborationFileBridge, DEFAULT_SANDBOX_SIZE, GPU_LEASE_PROVIDER_NAMES, Image, ImageBuilder, IntelligenceClient, InteractiveSessionHandle, MANAGE_SANDBOXES_PARAMETERS, MANAGE_SANDBOXES_TOOL_NAME, NetworkError, NotFoundError, PartialFailureError, QuotaError, SANDBOX_MCP_SERVER_NAME, SANDBOX_SIZE_PRESETS, SANDBOX_SIZE_PRESET_NAMES, SandboxClient as Sandbox, SandboxClient, SandboxError, SandboxFleet, SandboxFleetClient, SandboxInstance, SandboxSession, ServerError, StateError, TangleSandboxClient, TimeoutError, ValidationError, applySandboxEventText, buildCollaborationDocumentId, buildControlPlaneMcpConfig, buildSandboxMcpConfig, buildTangleRouterEvalMatrixRequest, buildTangleRouterResponsesWebSearchRequest, buildTangleRouterSearchBackend, buildTangleRouterSearchProfile, buildTraceExportPayload, collectAgentResponseText, createConfidentialSandbox, createManageSandboxesTool, defineAgentProfile, defineGitHubResource, defineInlineResource, exportTraceBundle, fetchTangleRouterSearchConfig, generateAttestationNonce, generateDockerfile, getSandboxEventText, materializeProfileFileMounts, mergeAgentProfiles, normalizeCollaborationPath, normalizeRuntimeBackendConfig, otelTraceIdForTangleTrace, parseCollaborationDocumentId, parseSSEStream, resolveSandboxResources, runTangleRouterEvalMatrixInSandbox, sandboxResourcesForSize, serializeForSidecar, splitInlineProfileFileMounts, startTeeAttestationHeartbeat, toOtelJson };

package/dist/{sandbox-BTBbZupV.js → sandbox-CDKpHv6-.js}

@@ -1,4 +1,4 @@
-import { c as ServerError, d as ValidationError, f as parseErrorResponse, l as StateError, o as QuotaError, r as NetworkError, s as SandboxError, t as AuthError, u as TimeoutError } from "./errors-DZsfJUuc.js";
+import { c as ServerError, d as ValidationError, f as parseErrorResponse, l as StateError, n as CapabilityError, o as QuotaError, r as NetworkError, s as SandboxError, t as AuthError, u as TimeoutError } from "./errors-DZsfJUuc.js";
 import { addTokenUsage, readTokenCostUsd, readTokenUsage } from "@tangle-network/agent-core";
 //#region src/backend-config.ts
 function parseModelString(model) {
@@ -21,6 +21,10 @@ function normalizeRuntimeBackendConfig(backend, options = {}) {
 	const inlineProfile = portableProfile ? toBackendProfile(portableProfile) : void 0;
 	const callerInlineProfile = backend?.inlineProfile;
 	if (callerInlineProfile && !inlineProfile) console.warn("[sandbox-sdk] backend.inlineProfile is deprecated. Use backend.profile (AgentPortableProfile) instead.");
+	if (inlineProfile && portableProfile) {
+		const reasoningEffort = portableProfile.model?.reasoningEffort ?? portableProfile.extensions?.[backend?.type ?? ""]?.reasoningEffort;
+		if (typeof reasoningEffort === "string" && reasoningEffort !== "auto" && reasoningEffort !== "none") inlineProfile.reasoningEffort = reasoningEffort;
+	}
 	return {
 		...backend?.type ? { type: backend.type } : {},
 		...typeof backend?.profile === "string" ? { profile: backend.profile } : {},
@@ -1041,6 +1045,10 @@ var SandboxInstance = class SandboxInstance {
 	get error() {
 		return this.info.error;
 	}
+	/** GPU lease attached during sandbox creation, when requested. */
+	get gpuLease() {
+		return this.info.gpuLease;
+	}
 	/** Web terminal URL for browser-based access */
 	get url() {
 		return this.info.connection?.webTerminalUrl;
@@ -1081,7 +1089,8 @@ var SandboxInstance = class SandboxInstance {
 			startedAt: this.startedAt,
 			lastActivityAt: this.lastActivityAt,
 			expiresAt: this.expiresAt,
-			error: this.error
+			error: this.error,
+			gpuLease: this.gpuLease
 		};
 	}
 	/**
@@ -3038,6 +3047,20 @@ var SandboxInstance = class SandboxInstance {
 			update: (policy) => this.egressUpdate(policy)
 		};
 	}
+	/**
+	* 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() {
+		return {
+			attach: (options) => this.gpuAttach(options),
+			list: () => this.gpuList(),
+			exec: (leaseId, options) => this.gpuExec(leaseId, options),
+			detach: (leaseId) => this.gpuDetach(leaseId)
+		};
+	}
 	async networkUpdate(config) {
 		if (config.blockOutbound !== void 0 && config.allowList !== void 0) {
 			if (config.blockOutbound && config.allowList.length > 0) throw new Error("blockOutbound and allowList are mutually exclusive");
@@ -3115,6 +3138,44 @@ var SandboxInstance = class SandboxInstance {
 			source: data.source
 		};
 	}
+	async gpuAttach(options) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).lease;
+	}
+	async gpuList() {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases`);
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).leases ?? [];
+	}
+	async gpuExec(leaseId, options) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases/${encodeURIComponent(leaseId)}/exec`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return await response.json();
+	}
+	async gpuDetach(leaseId) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases/${encodeURIComponent(leaseId)}`, { method: "DELETE" });
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).lease;
+	}
 	/**
 	* Validate CIDR notation (IPv4 and IPv6)
 	*/
@@ -3515,130 +3576,59 @@ var SandboxInstance = class SandboxInstance {
 		};
 	}
 	/**
-	* 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.
 	*/
-	async checkpoint(options) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints`, {
-			method: "POST",
-			body: JSON.stringify({
-				tags: options?.tags,
-				leaveRunning: options?.leaveRunning,
-				includeSnapshot: options?.includeSnapshot
-			})
-		});
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
-		const data = await response.json();
-		return {
-			checkpointId: data.checkpointId ?? data.id,
-			createdAt: new Date(data.createdAt ?? ""),
-			sizeBytes: data.sizeBytes,
-			tags: data.tags ?? []
-		};
+	checkpoint() {
+		throw new CapabilityError("checkpoint() was removed: use branch() to fork live memory into copy-on-write children, or snapshot() for durable disk state", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* 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.
 	*/
-	async listCheckpoints() {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints`);
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
-		const data = await response.json();
-		return (Array.isArray(data) ? data : data.checkpoints ?? []).map((cp) => this.parseCheckpointInfo(cp));
+	listCheckpoints() {
+		throw new CapabilityError("listCheckpoints() was removed: checkpoints no longer exist; use listSnapshots() for durable disk state", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* Delete a checkpoint.
-	*
-	* @param checkpointId - ID of the checkpoint to delete
+	* @deprecated CRIU checkpoints were removed. This method now throws.
 	*/
-	async deleteCheckpoint(checkpointId) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints/${encodeURIComponent(checkpointId)}`, { method: "DELETE" });
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
+	deleteCheckpoint() {
+		throw new CapabilityError("deleteCheckpoint() was removed: checkpoints no longer exist", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* 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() {
+		throw new CapabilityError("fork() was removed: use branch() to fork live memory into copy-on-write children, or create({ fromSnapshot }) for durable disk state", "FORK_REMOVED", 410);
+	}
+	/**
+	* 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
 	* ```
 	*/
-	async fork(checkpointId, options) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/fork`, {
+	async branch(count, options) {
+		if (!Number.isInteger(count) || count < 1) throw new ValidationError(`branch count must be an integer >= 1 (got ${count})`);
+		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/branch`, {
 			method: "POST",
 			body: JSON.stringify({
-				checkpointId,
-				name: options?.name,
+				count,
 				env: options?.env,
 				resources: options?.resources,
 				metadata: options?.metadata
@@ -3648,8 +3638,7 @@ var SandboxInstance = class SandboxInstance {
 			const body = await response.text();
 			throw parseErrorResponse(response.status, body, void 0, response.headers);
 		}
-		const data = await response.json();
-		return new SandboxInstance(this.client, this.parseInfo(data.sandbox ?? data), this.defaultRuntimeBackend);
+		return ((await response.json()).children ?? []).map((child) => new SandboxInstance(this.client, this.parseInfo(child), this.defaultRuntimeBackend));
 	}
 	/**
 	* Stop the sandbox (keeps state for resume).
@@ -3886,17 +3875,6 @@ var SandboxInstance = class SandboxInstance {
 			abortController.abort();
 		}
 	}
-	parseCheckpointInfo(cp) {
-		return {
-			checkpointId: cp.checkpointId ?? cp.id,
-			sandboxId: cp.sandboxId ?? cp.projectRef ?? this.id,
-			createdAt: new Date(cp.createdAt),
-			tags: cp.tags ?? [],
-			sizeBytes: cp.sizeBytes,
-			hasMemoryState: cp.hasMemoryState ?? true,
-			hasFilesystemSnapshot: cp.hasFilesystemSnapshot ?? false
-		};
-	}
 	async ensureRunning() {
 		await this.refresh();
 		if (this.status !== "running") throw new StateError(`Sandbox is not running (status: ${this.status})`, this.status, "running");
@@ -3970,6 +3948,7 @@ var SandboxInstance = class SandboxInstance {
 			lastActivityAt: data.lastActivityAt ? new Date(data.lastActivityAt) : void 0,
 			expiresAt: data.expiresAt ? new Date(data.expiresAt) : void 0,
 			error: data.error,
+			gpuLease: data.gpuLease ?? this.info.gpuLease,
 			startupDiagnostics: normalizeStartupDiagnostics(data.startupDiagnostics) ?? this.info?.startupDiagnostics
 		};
 	}