@tangle-network/sandbox 0.9.6 → 0.10.0

package/dist/index.js

@@ -1,8 +1,8 @@
-import { a as collectAgentResponseText, c as buildTraceExportPayload, d as toOtelJson, h as serializeForSidecar, i as applySandboxEventText, l as exportTraceBundle, m as normalizeRuntimeBackendConfig, n as SandboxSession, o as getSandboxEventText, p as parseSSEStream, r as InteractiveSessionHandle, t as SandboxInstance, u as otelTraceIdForTangleTrace } from "./sandbox-UQrmff8d.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-vBERsxhj.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-DRzRB6z1.js";
+import { _ as normalizeRuntimeBackendConfig, a as InteractiveSessionHandle, c as getSandboxEventText, d as exportTraceBundle, f as otelTraceIdForTangleTrace, g as parseSSEStream, h as encodeTextForWire, i as SandboxSession, o as applySandboxEventText, p as toOtelJson, r as SandboxTaskSession, s as collectAgentResponseText, t as SandboxInstance, u as buildTraceExportPayload, v as serializeForSidecar } from "./sandbox-CeimsfC8.js";
+import { a as NotFoundError, c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, n as CapabilityError, o as PartialFailureError, r as EgressProxyRecoveryError, s as QuotaError, t as AuthError, u as StateError } from "./errors-DSz87Rkk.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-InX98Zxk.js";
+import { a as CollaborationClient, i as parseCollaborationDocumentId, n as buildCollaborationDocumentId, r as normalizeCollaborationPath, t as CollaborationFileBridge } from "./collaboration-D17lnOJX.js";
+import { t as TangleSandboxClient } from "./tangle-DayyZe-i.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"],
@@ -784,6 +1061,281 @@ function buildControlPlaneMcpConfig(options) {
 	};
 }
 //#endregion
+//#region src/profile-file-mounts.ts
+const PROFILE_FILE_MOUNT_B64_CHUNK_CHARS = 3e3;
+const PROFILE_FILE_MOUNT_MAX_RETRIES = 4;
+const PROFILE_FILE_MOUNT_RETRY_BASE_MS = 250;
+const PROFILE_FILE_MOUNT_RETRY_MAX_MS = 2e3;
+const PROFILE_FILE_MOUNT_EXEC_TIMEOUT_MS = 3e4;
+const PROFILE_FILE_MOUNT_PACE_MS = 150;
+const PROFILE_BIN_DIR_RE = /(^|\/)(s?bin)\//;
+const DEFAULT_PROFILE_FILE_API_ABSOLUTE_PREFIXES = [
+	["/home", "agent"].join("/"),
+	["/home", "user"].join("/"),
+	"/tmp",
+	"/output"
+];
+function inlineContent(mount) {
+	const resource = mount.resource;
+	if (resource.kind !== "inline") throw new Error(`materializeProfileFileMounts: ${mount.path} requires an inline resource`);
+	if (typeof resource.content !== "string") throw new Error(`materializeProfileFileMounts: ${mount.path} inline resource requires string content`);
+	return resource.content;
+}
+function splitInlineProfileFileMounts(profile) {
+	const files = profile.resources?.files ?? [];
+	const deferredFiles = [];
+	const keptFiles = [];
+	for (const mount of files) if (mount.resource.kind === "inline") deferredFiles.push(mount);
+	else keptFiles.push(mount);
+	if (deferredFiles.length === 0) return {
+		leanProfile: profile,
+		deferredFiles
+	};
+	return {
+		leanProfile: {
+			...profile,
+			resources: {
+				...profile.resources ?? {},
+				files: keptFiles
+			}
+		},
+		deferredFiles
+	};
+}
+function shellSingleQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function shellPath(path) {
+	if (path === "~") return "\"$HOME\"";
+	if (path.startsWith("~/")) {
+		const rest = path.slice(2);
+		return rest ? `"$HOME"/${shellSingleQuote(rest)}` : "\"$HOME\"";
+	}
+	return shellSingleQuote(path);
+}
+function validateProfileFilePath(path) {
+	if (!path) throw new Error("materializeProfileFileMounts: file path is required");
+	if (path.endsWith("/")) throw new Error(`materializeProfileFileMounts: refusing directory-shaped file path ${path}`);
+	if (hasControlCharacter(path)) throw new Error(`materializeProfileFileMounts: refusing unsafe file path ${JSON.stringify(path)}`);
+	if (path === "~" || /^~[^/]/.test(path)) throw new Error(`materializeProfileFileMounts: refusing unsupported home path ${path}`);
+	if (hasUnsafeFileApiSegment(path)) throw new Error(`materializeProfileFileMounts: refusing unsafe file path ${path}`);
+}
+function hasUnsafeFileApiSegment(path) {
+	return path.split("/").some((segment) => segment === "." || segment === ".." || segment === ".sidecar");
+}
+function hasControlCharacter(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function normalizeAbsolutePrefixes(prefixes) {
+	return prefixes.map((prefix) => {
+		const normalized = prefix.trim().replace(/\/+$/, "");
+		if (!normalized.startsWith("/") || hasControlCharacter(normalized)) throw new Error(`materializeProfileFileMounts: fileApiAbsolutePrefixes must contain absolute paths; received ${JSON.stringify(prefix)}`);
+		if (hasUnsafeFileApiSegment(normalized)) throw new Error(`materializeProfileFileMounts: fileApiAbsolutePrefixes contains unsafe path ${JSON.stringify(prefix)}`);
+		return normalized;
+	});
+}
+function isAllowedAbsoluteFileApiPath(path, prefixes) {
+	for (const prefix of prefixes) if (path === prefix || path.startsWith(`${prefix}/`)) return true;
+	return false;
+}
+function fileApiTarget(mount, absolutePrefixes) {
+	if (mount.path.startsWith("~/")) return null;
+	if (mount.path.startsWith("/")) return isAllowedAbsoluteFileApiPath(mount.path, absolutePrefixes) ? mount.path : null;
+	if (mount.path.startsWith("~")) return null;
+	if (mount.path.length === 0) return null;
+	return mount.path;
+}
+function isExecutableProfileFile(mount) {
+	return mount.executable ?? PROFILE_BIN_DIR_RE.test(mount.path);
+}
+function profileFileMode(mount) {
+	return isExecutableProfileFile(mount) ? 493 : void 0;
+}
+function fileApiSupportsMode(box) {
+	return box.fs?.supportsWriteMode === true;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var ProfileFileMountExecTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`exec exceeded ${timeoutMs}ms`);
+		this.name = "ProfileFileMountExecTimeoutError";
+	}
+};
+function execWithTimeout(box, cmd, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			reject(new ProfileFileMountExecTimeoutError(timeoutMs));
+		}, timeoutMs);
+		box.exec(cmd, { timeoutMs }).then((res) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(res);
+		}, (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+const TRANSIENT_EXEC_STATUS_CODES = new Set([
+	408,
+	409,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const TRANSIENT_EXEC_CODE_RE = /^(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EPIPE|ECONNABORTED)$/i;
+const TRANSIENT_EXEC_MESSAGE_RE = /\b(408|409|425|429|500|502|503|504)\b|rate.?limit|too many requests|\bfetch failed\b|network error|connection reset|socket hang up|timed? out|service unavailable|bad gateway|gateway timeout|internal server error|\b(?:sidecar|runtime|exec(?:ution)?|terminal|sandbox|service|command(?:s)?|proxy)\b.{0,80}\bnot ready\b|\bnot ready\b.{0,80}\b(?:sidecar|runtime|exec(?:ution)?|terminal|sandbox|service|command(?:s)?|proxy)\b/i;
+function errorStatus(err) {
+	const rawStatus = err.status ?? err.statusCode ?? (err.response && typeof err.response === "object" ? err.response.status : void 0);
+	if (typeof rawStatus === "number") return rawStatus;
+	if (typeof rawStatus === "string" && /^\d+$/.test(rawStatus)) return Number(rawStatus);
+}
+function retryAfterMs(err, seen = /* @__PURE__ */ new Set()) {
+	if (!err || typeof err !== "object") return void 0;
+	if (seen.has(err)) return void 0;
+	seen.add(err);
+	const e = err;
+	if (typeof e.retryAfterMs === "number") return e.retryAfterMs;
+	return retryAfterMs(e.cause, seen);
+}
+function isTransientExecError(err, seen = /* @__PURE__ */ new Set()) {
+	if (!err || typeof err !== "object") return false;
+	if (seen.has(err)) return false;
+	seen.add(err);
+	const e = err;
+	const status = errorStatus(e);
+	if (status !== void 0 && TRANSIENT_EXEC_STATUS_CODES.has(status)) return true;
+	if (typeof e.code === "string") {
+		if (TRANSIENT_EXEC_CODE_RE.test(e.code)) return true;
+		if (/rate.?limit|too.?many.?requests|429|server.?error|service.?unavailable/i.test(e.code)) return true;
+	}
+	if (typeof e.message === "string" && TRANSIENT_EXEC_MESSAGE_RE.test(e.message)) return true;
+	return isTransientExecError(e.cause, seen);
+}
+function transientExecError(err) {
+	if (err instanceof ProfileFileMountExecTimeoutError) return { retryable: false };
+	if (isTransientExecError(err)) return {
+		retryable: true,
+		retryAfterMs: retryAfterMs(err)
+	};
+	return { retryable: false };
+}
+async function sha256Hex(content) {
+	const bytes = new TextEncoder().encode(content);
+	const webSubtle = globalThis.crypto?.subtle;
+	if (webSubtle) {
+		const digest = await webSubtle.digest("SHA-256", bytes);
+		return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	const { createHash } = await import("node:crypto");
+	return createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function execProfileFileMount(box, mount, content, options, execState) {
+	const maxRetries = options.maxRetries ?? PROFILE_FILE_MOUNT_MAX_RETRIES;
+	const path = mount.path;
+	const b64 = encodeTextForWire(content);
+	const b64Chunks = [];
+	for (let i = 0; i < b64.length; i += PROFILE_FILE_MOUNT_B64_CHUNK_CHARS) b64Chunks.push(b64.slice(i, i + PROFILE_FILE_MOUNT_B64_CHUNK_CHARS));
+	const expectedSha256 = await sha256Hex(content);
+	const dir = path.replace(/\/[^/]*$/, "");
+	const executable = isExecutableProfileFile(mount);
+	const q = shellPath(path);
+	const qb64 = shellPath(`${path}.b64`);
+	const qtmp = shellPath(`${path}.tmp`);
+	const qpartPrefix = shellPath(`${path}.b64.part.`);
+	const homeGuard = path.startsWith("~/") ? `[ -n "$HOME" ] || { echo ${shellSingleQuote(`materializeProfileFileMounts: HOME is unset for ${path}`)} >&2; exit 1; }; ` : "";
+	const run = async (cmd) => {
+		for (let attempt = 0;; attempt++) {
+			if (execState.started && options.paceMs > 0) await sleep(options.paceMs);
+			execState.started = true;
+			try {
+				return await execWithTimeout(box, cmd, options.execTimeoutMs);
+			} catch (err) {
+				const { retryable, retryAfterMs: retryAfter } = transientExecError(err);
+				if (retryable && attempt < maxRetries) {
+					const backoff = Math.min(PROFILE_FILE_MOUNT_RETRY_BASE_MS * 2 ** attempt, PROFILE_FILE_MOUNT_RETRY_MAX_MS);
+					await sleep(Math.min(retryAfter ?? backoff, PROFILE_FILE_MOUNT_RETRY_MAX_MS));
+					continue;
+				}
+				throw new Error(`materializeProfileFileMounts: exec failed for ${path}`, { cause: err });
+			}
+		}
+	};
+	const step = async (cmd) => {
+		const result = await run(`${homeGuard}${cmd}`);
+		if (result.exitCode !== 0) throw new Error(`materializeProfileFileMounts: failed to write ${path} (exit ${result.exitCode}): ${result.stderr.slice(0, 500)}`);
+	};
+	await step(dir ? `mkdir -p ${shellPath(dir)}` : ":");
+	for (let i = 0; i < b64Chunks.length; i++) {
+		const slice = b64Chunks[i];
+		if (slice === void 0) continue;
+		await step(`printf '%s' '${slice}' > ${shellPath(`${path}.b64.part.${i}`)}`);
+	}
+	const chmod = executable ? `chmod +x ${q} || exit 1; ` : "";
+	const checksumMismatch = shellSingleQuote(`materializeProfileFileMounts: checksum mismatch for ${path}`);
+	await step(`cleanup() { ${`rm -f ${qb64} ${qtmp}; i=0; while [ "$i" -lt ${b64Chunks.length} ]; do rm -f ${qpartPrefix}$i; i=$((i+1)); done`}; }; trap cleanup EXIT; expected='${expectedSha256}'; if [ -f ${q} ] && [ "$(sha256sum ${q} | awk '{print $1}')" = "$expected" ]; then ${chmod}exit 0; fi; : > ${qb64} && i=0; while [ "$i" -lt ${b64Chunks.length} ]; do cat ${qpartPrefix}$i >> ${qb64} || exit 1; i=$((i+1)); done && base64 -d ${qb64} > ${qtmp} && [ "$(sha256sum ${qtmp} | awk '{print $1}')" = "$expected" ] || { echo ${checksumMismatch} >&2; exit 1; }; mv ${qtmp} ${q} && ${executable ? `chmod +x ${q} && ` : ""}[ "$(sha256sum ${q} | awk '{print $1}')" = "$expected" ] || { echo ${checksumMismatch} >&2; exit 1; }`);
+}
+async function materializeProfileFileMounts(box, files, options = {}) {
+	const execTimeoutMs = options.execTimeoutMs ?? PROFILE_FILE_MOUNT_EXEC_TIMEOUT_MS;
+	const paceMs = options.paceMs ?? PROFILE_FILE_MOUNT_PACE_MS;
+	const maxRetries = options.maxRetries ?? PROFILE_FILE_MOUNT_MAX_RETRIES;
+	const absolutePrefixes = normalizeAbsolutePrefixes(options.fileApiAbsolutePrefixes ?? DEFAULT_PROFILE_FILE_API_ABSOLUTE_PREFIXES);
+	const fs = box.fs;
+	const fileApiAvailable = typeof fs?.writeMany === "function";
+	const modeAwareFileApi = fileApiSupportsMode(box);
+	const viaFileApi = [];
+	const viaExec = [];
+	for (const mount of files) {
+		const content = inlineContent(mount);
+		validateProfileFilePath(mount.path);
+		const target = fileApiAvailable ? fileApiTarget(mount, absolutePrefixes) : null;
+		const executable = isExecutableProfileFile(mount);
+		if (target !== null && (!executable || modeAwareFileApi)) {
+			const mode = profileFileMode(mount);
+			viaFileApi.push({
+				path: target,
+				content,
+				...mode !== void 0 ? { mode } : {}
+			});
+		} else viaExec.push({
+			mount,
+			content
+		});
+	}
+	if (viaFileApi.length > 0) try {
+		await fs?.writeMany(viaFileApi, {
+			paceMs,
+			maxRetries
+		});
+	} catch (err) {
+		throw new Error("materializeProfileFileMounts: file API batch write failed", { cause: err });
+	}
+	const execState = { started: false };
+	for (const item of viaExec) await execProfileFileMount(box, item.mount, item.content, {
+		execTimeoutMs,
+		paceMs,
+		maxRetries
+	}, execState);
+	return {
+		written: viaFileApi.length + viaExec.length,
+		viaFileApi: viaFileApi.length,
+		viaExec: viaExec.length
+	};
+}
+//#endregion
 //#region src/router-search.ts
 const DEFAULT_ROUTER_URL = "https://router.tangle.tools";
 async function fetchTangleRouterSearchConfig(options = {}) {
@@ -1177,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, mergeAgentProfiles, normalizeCollaborationPath, normalizeRuntimeBackendConfig, otelTraceIdForTangleTrace, parseCollaborationDocumentId, parseSSEStream, resolveSandboxResources, runTangleRouterEvalMatrixInSandbox, sandboxResourcesForSize, serializeForSidecar, startTeeAttestationHeartbeat, toOtelJson };
+export { AuthError, CONTROL_PLANE_MCP_SERVER_NAME, CapabilityError, CollaborationClient, CollaborationFileBridge, DEFAULT_SANDBOX_SIZE, EgressProxyRecoveryError, 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, SandboxTaskSession, 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/intelligence/index.js

@@ -1,4 +1,4 @@
-import { f as parseErrorResponse, r as NetworkError, u as TimeoutError } from "../errors-DZsfJUuc.js";
+import { d as TimeoutError, i as NetworkError, p as parseErrorResponse } from "../errors-DSz87Rkk.js";
 //#region src/intelligence/index.ts
 /**
 * `@tangle-network/sandbox/intelligence` — browser-safe typed client for the