@tangle-network/sandbox 0.10.5-develop.20260713235503.8f2cefc → 0.10.5-develop.20260715115519.fee3d86

package/dist/{runtime-api-CaXI7Kl2.js → runtime-api-BWq4XSrb.js}

@@ -1,4 +1,5 @@
-import { f as ValidationError, l as ServerError, p as parseErrorResponse } from "./errors-wd266B9Q.js";
+import { c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, p as parseErrorResponse, s as QuotaError } from "./errors-wd266B9Q.js";
+import { FILE_UPLOAD_SESSION_MAX_BYTES, isFileTooLargeErrorBody, isPayloadTooLargeErrorBody } from "@tangle-network/runtime-contracts";
 //#region src/backend-config.ts
 const LEGACY_QUESTION_ALIAS_KEY = ["question", "Channel"].join("");
 function parseModelString(model) {
@@ -153,6 +154,238 @@ function serializeForSidecar(profile) {
 	return toBackendProfile(profile);
 }
 //#endregion
+//#region src/lib/chunked-upload.ts
+/**
+* Chunked upload — the sanctioned SDK path for delivering payloads larger
+* than the sandbox API's single-request body caps. Splits the payload into
+* server-sized parts against a `/fs/upload-session` session, PUTs each part
+* with transient retry, then commits with a whole-payload SHA-256 so the
+* runtime can verify nothing was dropped or reordered in transit.
+*
+* Browser/Worker-safe: no `node:` imports, no `Buffer`. Input normalizes to
+* a `Uint8Array` and hashes via Web Crypto (`crypto.subtle`), available in
+* browsers, Workers, and Node 18+ — the same environments this module must
+* run in unmodified.
+*/
+const DEFAULT_MAX_RETRIES = 4;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2e3;
+const delay = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(signal.reason ?? /* @__PURE__ */ new Error("aborted"));
+		return;
+	}
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	function onAbort() {
+		clearTimeout(timer);
+		reject(signal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+	}
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/** Transient part-upload failures worth retrying: rate-limit/budget (429),
+*  5xx, transport (network), and request timeouts — mirrors
+*  `isTransientWriteError` in `sandbox.ts`. A non-transient error (bad path,
+*  auth, checksum, containment) fails loud immediately. */
+function isTransientUploadError(err) {
+	return err instanceof QuotaError || err instanceof ServerError || err instanceof NetworkError || err instanceof TimeoutError;
+}
+function isChecksumMismatch(err) {
+	return err instanceof SandboxError && err.code === "CHECKSUM_MISMATCH";
+}
+/** Cheap size probe used for the pre-flight cap check, read directly off
+*  the input shape (`Blob.size` / `ArrayBuffer.byteLength` / view
+*  `byteLength`) so an oversized `Blob` never has its bytes materialized
+*  just to be rejected. Strings have no cheap length in UTF-8, so they're
+*  encoded once here (and once more in {@link normalizeToBytes} — an
+*  acceptable cost given strings are never the multi-MB case this path
+*  exists for). */
+function sizeOfInput(data) {
+	if (typeof data === "string") return new TextEncoder().encode(data).byteLength;
+	if (data instanceof ArrayBuffer) return data.byteLength;
+	if (ArrayBuffer.isView(data)) return data.byteLength;
+	return data.size;
+}
+/**
+* Normalizes to a `Uint8Array` backed by a plain (never shared)
+* `ArrayBuffer`. A caller-supplied view may be backed by a
+* `SharedArrayBuffer`, which `crypto.subtle.digest` and `fetch`'s
+* `BodyInit` both reject at the type level (and some engines reject at
+* runtime) — copying here keeps every downstream call on one concrete,
+* always-accepted buffer type.
+*/
+async function normalizeToBytes(data) {
+	if (typeof data === "string") return new TextEncoder().encode(data);
+	if (data instanceof ArrayBuffer) return new Uint8Array(data.slice(0));
+	if (ArrayBuffer.isView(data)) {
+		const copy = new Uint8Array(data.byteLength);
+		copy.set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		return copy;
+	}
+	return new Uint8Array(await data.arrayBuffer());
+}
+function webCryptoSubtle() {
+	const subtle = globalThis.crypto?.subtle;
+	if (!subtle) throw new Error("chunked upload requires Web Crypto (crypto.subtle) for SHA-256 hashing — available in browsers, Workers, and Node 18+");
+	return subtle;
+}
+async function sha256Hex(bytes) {
+	const digest = await webCryptoSubtle().digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Canonical size-cap bodies (413 `PAYLOAD_TOO_LARGE` / `FILE_TOO_LARGE`)
+* carry `surface`/`limitBytes`/`actualBytes` that the generic error parser
+* drops; fold them into the message before delegating to
+* `parseErrorResponse` for the rest (status→class mapping, retryAfterMs,
+* origin).
+*/
+async function parseUploadError(response) {
+	const bodyText = await response.text();
+	let parsedBody;
+	try {
+		parsedBody = JSON.parse(bodyText);
+	} catch {
+		parsedBody = void 0;
+	}
+	if (isPayloadTooLargeErrorBody(parsedBody) || isFileTooLargeErrorBody(parsedBody)) {
+		const { code, message, surface, limitBytes, actualBytes } = parsedBody.error;
+		const detail = typeof actualBytes === "number" ? `${message} (${surface}: ${actualBytes} of ${limitBytes} bytes)` : `${message} (${surface}: limit ${limitBytes} bytes)`;
+		return parseErrorResponse(response.status, JSON.stringify({
+			code,
+			message: detail
+		}), void 0, response.headers);
+	}
+	return parseErrorResponse(response.status, bodyText, void 0, response.headers);
+}
+async function initUploadSession(transport, remotePath, totalBytes, sha256, mode, signal) {
+	signal?.throwIfAborted();
+	const response = await transport.fetch("/fs/upload-session", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			path: remotePath,
+			mode,
+			totalBytes,
+			sha256
+		}),
+		signal
+	});
+	if (!response.ok) throw await parseUploadError(response);
+	return (await response.json()).data;
+}
+async function putPart(transport, uploadId, index, chunk, options) {
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	for (let attempt = 0;; attempt++) {
+		options.signal?.throwIfAborted();
+		try {
+			const response = await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}/parts/${index}`, {
+				method: "PUT",
+				headers: { "Content-Type": "application/octet-stream" },
+				body: chunk,
+				signal: options.signal
+			});
+			if (!response.ok) throw await parseUploadError(response);
+			return;
+		} catch (err) {
+			if (isTransientUploadError(err) && attempt < maxRetries) {
+				const retryAfterMs = err instanceof SandboxError ? err.retryAfterMs : void 0;
+				const backoff = Math.min(RETRY_BASE_MS * 2 ** attempt, RETRY_MAX_MS);
+				await delay(retryAfterMs ?? backoff, options.signal);
+				continue;
+			}
+			throw err;
+		}
+	}
+}
+function partCount(totalBytes, partSize) {
+	return Math.ceil(totalBytes / partSize);
+}
+async function uploadAllParts(transport, uploadId, bytes, partSize, totalParts, options) {
+	const totalBytes = bytes.byteLength;
+	const paceMs = options.paceMs ?? 0;
+	let uploadedBytes = 0;
+	let started = false;
+	for (let index = 0; index < totalParts; index++) {
+		if (started && paceMs > 0) await delay(paceMs, options.signal);
+		started = true;
+		const start = index * partSize;
+		const end = Math.min(start + partSize, totalBytes);
+		await putPart(transport, uploadId, index, bytes.subarray(start, end), options);
+		uploadedBytes += end - start;
+		options.onProgress?.({
+			bytesUploaded: uploadedBytes,
+			totalBytes,
+			percentage: totalBytes === 0 ? 100 : Math.round(uploadedBytes / totalBytes * 100)
+		});
+	}
+}
+async function commitSession(transport, uploadId, totalParts, sha256, signal) {
+	signal?.throwIfAborted();
+	const response = await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}/commit`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			totalParts,
+			sha256
+		}),
+		signal
+	});
+	if (!response.ok) throw await parseUploadError(response);
+	return (await response.json()).data;
+}
+/** Best-effort abort of an in-progress session — never masks the real
+*  failure that triggered it, and never itself throws. An orphaned session
+*  also self-expires server-side (`expiresAt`), so a failed DELETE here is
+*  not a leak, just deferred cleanup. */
+async function abortSession(transport, uploadId) {
+	try {
+		await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}`, { method: "DELETE" });
+	} catch {}
+}
+/**
+* Upload arbitrary binary or text data to the sandbox via the chunked
+* upload-session protocol, verifying integrity with a whole-payload
+* SHA-256 at commit. Browser/Worker-safe and works identically over the
+* gateway proxy or a direct sidecar connection — see
+* {@link FileSystem.uploadData}.
+*
+* @param transport - Fetch-shaped adapter scoped to the sandbox runtime
+*   (paths are relative to it, e.g. `/fs/upload-session`).
+* @param remotePath - Destination path in the sandbox.
+* @param data - Payload to upload. Strings encode as UTF-8.
+* @param options - See {@link ChunkedUploadOptions}.
+* @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately (zero requests) if
+*   the payload exceeds {@link FILE_UPLOAD_SESSION_MAX_BYTES}; otherwise the
+*   typed error from whichever step (init/part/commit) failed after retries
+*   are exhausted.
+*/
+async function uploadChunked(transport, remotePath, data, options = {}) {
+	const estimatedSize = sizeOfInput(data);
+	if (estimatedSize > FILE_UPLOAD_SESSION_MAX_BYTES) throw new SandboxError(`Payload for ${remotePath} is ${estimatedSize} bytes, over the ${FILE_UPLOAD_SESSION_MAX_BYTES} byte chunked-upload session cap`, "PAYLOAD_TOO_LARGE", 413);
+	options.signal?.throwIfAborted();
+	const bytes = await normalizeToBytes(data);
+	options.signal?.throwIfAborted();
+	const sha256 = await sha256Hex(bytes);
+	const init = await initUploadSession(transport, remotePath, bytes.byteLength, sha256, options.mode, options.signal);
+	const totalParts = partCount(bytes.byteLength, init.partSize);
+	try {
+		await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options);
+		try {
+			return await commitSession(transport, init.uploadId, totalParts, sha256, options.signal);
+		} catch (err) {
+			if (!isChecksumMismatch(err)) throw err;
+			await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options);
+			return await commitSession(transport, init.uploadId, totalParts, sha256, options.signal);
+		}
+	} catch (err) {
+		await abortSession(transport, init.uploadId);
+		throw err;
+	}
+}
+//#endregion
 //#region src/runtime-api.ts
 /** Internal typed client for routes served by a sandbox runtime. */
 var SandboxRuntimeApi = class {
@@ -249,6 +482,25 @@ var SandboxRuntimeApi = class {
 			})
 		})).data;
 	}
+	/**
+	* Upload in-memory binary or text data to the sandbox over the chunked
+	* upload-session protocol — the browser/Worker-safe sanctioned path for
+	* payloads over ~1 MiB, sized to clear the gateway proxy's per-request cap
+	* (parts stay under {@link FILE_UPLOAD_PART_MAX_BYTES}). Binary-safe:
+	* accepts a `Blob`, `ArrayBuffer`, `ArrayBufferView`, or UTF-8 `string`.
+	* Delegates to the shared `uploadChunked` engine in `lib/chunked-upload.js`,
+	* wired to this client's `transport.fetch` so requests carry the same
+	* scoped-token `Authorization` header and base URL as every other method
+	* on this class (e.g. {@link SandboxRuntimeApi.writeFile}) — works
+	* identically over the gateway proxy or a direct sidecar connection.
+	*
+	* @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately, before any
+	*   request, if the payload exceeds the chunked-upload session cap.
+	*/
+	async uploadData(remotePath, data, options) {
+		await this.transport.ensureRunning();
+		return uploadChunked({ fetch: (path, init) => this.transport.fetch(path, init) }, remotePath, data, options);
+	}
 	async deleteFile(path, options = {}) {
 		await this.transport.ensureRunning();
 		const params = new URLSearchParams();
@@ -445,4 +697,4 @@ function normalizeSessionInfo(raw) {
 	};
 }
 //#endregion
-export { serializeForSidecar as i, normalizeSessionInfo as n, normalizeRuntimeBackendConfig as r, SandboxRuntimeApi as t };
+export { serializeForSidecar as a, normalizeRuntimeBackendConfig as i, normalizeSessionInfo as n, uploadChunked as r, SandboxRuntimeApi as t };

package/dist/runtime.d.ts

@@ -1,6 +1,31 @@
-import { A as CommitTaskSessionOptions, B as CreateTaskSessionOptions, Dr as SandboxRuntimeHealth, Jr as SentSessionMessage, Kr as SendSessionMessageOptions, Mi as WriteFileOptions, Mr as SandboxTerminalInfo, Nr as SandboxTerminalManager, Pr as SandboxTerminalRequestOptions, Qr as SessionInfo, Sr as SandboxPortBinding, dt as FileTreeResult, ei as SessionMessage, ft as FileWriteResult, gi as TaskSessionInfo, it as FileReadBatchResult, jr as SandboxTerminalCreateOptions, kn as RenameOptions, kr as SandboxRuntimeProfileList, mi as TaskSessionCommitResult, pi as TaskSessionChanges, qr as SendSessionMessageRequest, qt as ListMessagesOptions, rt as FileReadBatchOptions, st as FileRenameResult, ut as FileTreeOptions, z as CreateSessionOptions } from "./types-yNRVRww-.js";
+import { Ai as UploadProgress, E as ChunkedUploadResult, Fr as SandboxTerminalManager, H as CreateTaskSessionOptions, Ir as SandboxTerminalRequestOptions, Jr as SendSessionMessageOptions, M as CommitTaskSessionOptions, Nr as SandboxTerminalCreateOptions, Pi as WriteFileOptions, Pr as SandboxTerminalInfo, T as ChunkedUploadOptions, V as CreateSessionOptions, Xr as SentSessionMessage, Yr as SendSessionMessageRequest, Yt as ListMessagesOptions, at as FileReadBatchOptions, ei as SessionInfo, ft as FileTreeOptions, gi as TaskSessionCommitResult, hi as TaskSessionChanges, jn as RenameOptions, jr as SandboxRuntimeProfileList, kr as SandboxRuntimeHealth, lt as FileRenameResult, mt as FileWriteResult, ni as SessionMessage, ot as FileReadBatchResult, pt as FileTreeResult, vi as TaskSessionInfo, wr as SandboxPortBinding } from "./types-LNLeU9Ub.js";
 import { a as NotFoundError, c as SandboxError, d as ServerError, f as StateError, i as NetworkError, l as SandboxErrorJson, m as ValidationError, n as CapabilityError, o as PartialFailureError, p as TimeoutError, s as QuotaError, t as AuthError, u as SandboxFailureDetail } from "./errors-CNCz3Ms9.js";
 
+//#region src/lib/chunked-upload.d.ts
+/** The transport a caller wires this module to — {@link SandboxInstance.runtimeFetch}
+ *  in the SDK, or any fetch-shaped adapter in a standalone consumer. */
+interface ChunkedUploadTransport {
+  fetch(path: string, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Upload arbitrary binary or text data to the sandbox via the chunked
+ * upload-session protocol, verifying integrity with a whole-payload
+ * SHA-256 at commit. Browser/Worker-safe and works identically over the
+ * gateway proxy or a direct sidecar connection — see
+ * {@link FileSystem.uploadData}.
+ *
+ * @param transport - Fetch-shaped adapter scoped to the sandbox runtime
+ *   (paths are relative to it, e.g. `/fs/upload-session`).
+ * @param remotePath - Destination path in the sandbox.
+ * @param data - Payload to upload. Strings encode as UTF-8.
+ * @param options - See {@link ChunkedUploadOptions}.
+ * @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately (zero requests) if
+ *   the payload exceeds {@link FILE_UPLOAD_SESSION_MAX_BYTES}; otherwise the
+ *   typed error from whichever step (init/part/commit) failed after retries
+ *   are exhausted.
+ */
+declare function uploadChunked(transport: ChunkedUploadTransport, remotePath: string, data: Blob | ArrayBuffer | ArrayBufferView | string, options?: ChunkedUploadOptions): Promise<ChunkedUploadResult>;
+//#endregion
 //#region src/runtime-api.d.ts
 interface RuntimeTransport {
   ensureRunning(): Promise<void>;
@@ -16,6 +41,22 @@ declare class SandboxRuntimeApi {
   profiles(): Promise<SandboxRuntimeProfileList>;
   readFiles(paths: string[], options?: FileReadBatchOptions): Promise<FileReadBatchResult>;
   writeFile(path: string, content: string, options?: WriteFileOptions): Promise<FileWriteResult>;
+  /**
+   * Upload in-memory binary or text data to the sandbox over the chunked
+   * upload-session protocol — the browser/Worker-safe sanctioned path for
+   * payloads over ~1 MiB, sized to clear the gateway proxy's per-request cap
+   * (parts stay under {@link FILE_UPLOAD_PART_MAX_BYTES}). Binary-safe:
+   * accepts a `Blob`, `ArrayBuffer`, `ArrayBufferView`, or UTF-8 `string`.
+   * Delegates to the shared `uploadChunked` engine in `lib/chunked-upload.js`,
+   * wired to this client's `transport.fetch` so requests carry the same
+   * scoped-token `Authorization` header and base URL as every other method
+   * on this class (e.g. {@link SandboxRuntimeApi.writeFile}) — works
+   * identically over the gateway proxy or a direct sidecar connection.
+   *
+   * @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately, before any
+   *   request, if the payload exceeds the chunked-upload session cap.
+   */
+  uploadData(remotePath: string, data: Blob | ArrayBuffer | ArrayBufferView | string, options?: ChunkedUploadOptions): Promise<ChunkedUploadResult>;
   deleteFile(path: string, options?: Pick<WriteFileOptions, "sessionId">): Promise<void>;
   renameFile(sourcePath: string, destinationPath: string, options?: RenameOptions): Promise<FileRenameResult>;
   fileTree(path: string, options?: FileTreeOptions): Promise<FileTreeResult>;
@@ -62,4 +103,4 @@ declare class SandboxRuntimeClient extends SandboxRuntimeApi {
 }
 declare function createSandboxRuntimeClient(config: SandboxRuntimeClientConfig): SandboxRuntimeClient;
 //#endregion
-export { AuthError, CapabilityError, type FileReadBatchOptions, type FileReadBatchResult, type FileRenameResult, type FileTreeOptions, type FileTreeResult, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, type RenameOptions, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, ValidationError, type WriteFileOptions, createSandboxRuntimeClient };
+export { AuthError, CapabilityError, type ChunkedUploadOptions, type ChunkedUploadResult, type ChunkedUploadTransport, type FileReadBatchOptions, type FileReadBatchResult, type FileRenameResult, type FileTreeOptions, type FileTreeResult, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, type RenameOptions, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, type UploadProgress, ValidationError, type WriteFileOptions, createSandboxRuntimeClient, uploadChunked };

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { t as SandboxRuntimeApi } from "./runtime-api-CaXI7Kl2.js";
+import { r as uploadChunked, t as SandboxRuntimeApi } from "./runtime-api-BWq4XSrb.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, s as QuotaError, t as AuthError, u as StateError } from "./errors-wd266B9Q.js";
 //#region src/runtime-client.ts
 const DEFAULT_RUNTIME_TIMEOUT_MS = 3e4;
@@ -80,4 +80,4 @@ function createSandboxRuntimeClient(config) {
 	return new SandboxRuntimeClient(config);
 }
 //#endregion
-export { AuthError, CapabilityError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient };
+export { AuthError, CapabilityError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient, uploadChunked };

package/dist/{sandbox-BvNEOnIl.d.ts → sandbox-B9P4tyt4.d.ts}

@@ -1,4 +1,4 @@
-import { $ as EventStreamOptions, $r as SessionListOptions, A as CommitTaskSessionOptions, Ai as WaitForOptions, An as RestoreSnapshotOptions, Ar as SandboxStatus, B as CreateTaskSessionOptions, Bn as SSHCommandDescriptor, Br as ScopedToken, Bt as InstalledTool, D as CodeLanguage, Dr as SandboxRuntimeHealth, Dt as GitDiff, E as CodeExecutionResult, Fr as SandboxTraceBundle, Gn as SandboxEvent, Gt as IntelligenceReportWindow, Hr as SearchMatch, Ht as IntelligenceReportBudget, In as RolloutStartResult, Jr as SentSessionMessage, Kr as SendSessionMessageOptions, Kt as JsonValue, Mi as WriteFileOptions, Mn as Rollout, Ni as WriteManyFile, Nr as SandboxTerminalManager, Ot as GitStatus, Pi as WriteManyOptions, Pn as RolloutOptions, Pt as GpuLeaseManager, Qr as SessionInfo, Qt as MintScopedTokenOptions, Rr as SandboxTraceOptions, Si as TeePublicKeyResponse, Sr as SandboxPortBinding, T as CodeExecutionOptions, Ti as TurnDriveResult, Tr as SandboxResourceUsage, Tt as GitCommit, U as DispatchPromptOptions, Un as SandboxConnection, Ur as SearchOptions, Ut as IntelligenceReportCompareTo, Vn as SSHCredentials, Vt as IntelligenceReport, W as DispatchedSession, Xr as SessionEventStreamOptions, Y as DriverInfo, Z as EgressManager, Zr as SessionForkOptions, _n as ProvisionEvent, ai as SnapshotResult, bi as TeeAttestationResponse, ct as FileSystem, di as TaskOptions, ei as SessionMessage, et as ExecOptions, fi as TaskResult, ft as FileWriteResult, gi as TaskSessionInfo, gn as PromptResult, hn as PromptOptions, ii as SnapshotOptions, in as PermissionsManager, j as CompletedTurnResult, ji as WaitForRolloutOptions, jn as ResumeOptions, kr as SandboxRuntimeProfileList, kt as GpuLease, l as BackendManager, mi as TaskSessionCommitResult, mn as PromptInputPart, on as PreviewLinkManager, pi as TaskSessionChanges, q as DriveTurnOptions, qr as SendSessionMessageRequest, qt as ListMessagesOptions, ri as SnapshotInfo, s as BackendConfig, si as StartupDiagnostics, tn as NetworkManager, tt as ExecResult, un as ProcessManager, ur as SandboxFleetTraceBundle, vi as TeeAttestationOptions, vn as ProvisionResult, w as BranchOptions, wt as GitBranch, yr as SandboxInfo, z as CreateSessionOptions } from "./types-yNRVRww-.js";
+import { $ as EgressManager, $r as SessionForkOptions, At as GitStatus, Br as SandboxTraceOptions, D as CodeExecutionOptions, Di as TurnDriveResult, Dr as SandboxResourceUsage, Dt as GitCommit, Et as GitBranch, Fi as WriteManyFile, Fr as SandboxTerminalManager, G as DispatchPromptOptions, Gn as SandboxConnection, Gr as SearchOptions, Gt as IntelligenceReportCompareTo, H as CreateTaskSessionOptions, Hn as SSHCommandDescriptor, Hr as ScopedToken, Ht as InstalledTool, Ii as WriteManyOptions, In as RolloutOptions, It as GpuLeaseManager, Jr as SendSessionMessageOptions, Jt as JsonValue, K as DispatchedSession, Lr as SandboxTraceBundle, M as CommitTaskSessionOptions, Mi as WaitForOptions, Mn as RestoreSnapshotOptions, Mr as SandboxStatus, N as CompletedTurnResult, Ni as WaitForRolloutOptions, Nn as ResumeOptions, O as CodeExecutionResult, Pi as WriteFileOptions, Pn as Rollout, Qr as SessionEventStreamOptions, Rn as RolloutStartResult, Si as TeeAttestationResponse, Un as SSHCredentials, Ut as IntelligenceReport, V as CreateSessionOptions, Wr as SearchMatch, Wt as IntelligenceReportBudget, Xr as SentSessionMessage, Y as DriveTurnOptions, Yr as SendSessionMessageRequest, Yt as ListMessagesOptions, Z as DriverInfo, _n as PromptOptions, ai as SnapshotInfo, bi as TeeAttestationOptions, bn as ProvisionResult, cn as PreviewLinkManager, ei as SessionInfo, en as MintScopedTokenOptions, fn as ProcessManager, fr as SandboxFleetTraceBundle, gi as TaskSessionCommitResult, gn as PromptInputPart, hi as TaskSessionChanges, jr as SandboxRuntimeProfileList, jt as GpuLease, k as CodeLanguage, kr as SandboxRuntimeHealth, kt as GitDiff, l as BackendManager, li as StartupDiagnostics, mi as TaskResult, mt as FileWriteResult, ni as SessionMessage, nt as ExecOptions, oi as SnapshotOptions, on as PermissionsManager, pi as TaskOptions, qn as SandboxEvent, qt as IntelligenceReportWindow, rn as NetworkManager, rt as ExecResult, s as BackendConfig, si as SnapshotResult, ti as SessionListOptions, tt as EventStreamOptions, ut as FileSystem, vi as TaskSessionInfo, vn as PromptResult, w as BranchOptions, wi as TeePublicKeyResponse, wr as SandboxPortBinding, xr as SandboxInfo, yn as ProvisionEvent } from "./types-LNLeU9Ub.js";
 
 //#region src/mcp.d.ts
 /**
@@ -894,6 +894,11 @@ declare class SandboxInstance {
   private fsReadBatch;
   private fsTree;
   private fsUpload;
+  /** See {@link FileSystem.uploadData}. Delegates to the shared, browser-safe
+   *  chunked-upload flow in `lib/chunked-upload.ts`, wired to this sandbox's
+   *  runtime endpoint (works over the gateway proxy or a direct connection —
+   *  both are transparent through `runtimeFetch`). */
+  private fsUploadData;
   private fsDownload;
   private fsUploadDir;
   private fsDownloadDir;

package/dist/{sandbox-CIHssZCH.js → sandbox-KiKLRbR_.js}

@@ -1,4 +1,4 @@
-import { n as normalizeSessionInfo, r as normalizeRuntimeBackendConfig, t as SandboxRuntimeApi } from "./runtime-api-CaXI7Kl2.js";
+import { i as normalizeRuntimeBackendConfig, n as normalizeSessionInfo, r as uploadChunked, t as SandboxRuntimeApi } from "./runtime-api-BWq4XSrb.js";
 import { c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, n as CapabilityError, p as parseErrorResponse, s as QuotaError, t as AuthError, u as StateError } from "./errors-wd266B9Q.js";
 import { addTokenUsage, readTokenCostUsd, readTokenUsage } from "@tangle-network/agent-core";
 //#region src/lib/sse-parser.ts
@@ -1411,7 +1411,10 @@ var SandboxInstance = class SandboxInstance {
 			if (started && paceMs > 0) await delay(paceMs);
 			started = true;
 			try {
-				await this.write(file.path, file.content, { mode: file.mode });
+				await this.write(file.path, file.content, {
+					mode: file.mode,
+					encoding: file.encoding
+				});
 				break;
 			} catch (err) {
 				if (isTransientWriteError(err) && attempt < maxRetries) {
@@ -2363,6 +2366,7 @@ var SandboxInstance = class SandboxInstance {
 			writeMany: (files, options) => this.writeMany(files, options),
 			search: (query, options) => this.search(query, options),
 			upload: (localPath, remotePath, options) => this.fsUpload(localPath, remotePath, options),
+			uploadData: (remotePath, data, options) => this.fsUploadData(remotePath, data, options),
 			download: (remotePath, localPath, options) => this.fsDownload(remotePath, localPath, options),
 			uploadDir: (localDir, remoteDir) => this.fsUploadDir(localDir, remoteDir),
 			downloadDir: (remoteDir, localDir) => this.fsDownloadDir(remoteDir, localDir),
@@ -2410,6 +2414,14 @@ var SandboxInstance = class SandboxInstance {
 			percentage: 100
 		});
 	}
+	/** See {@link FileSystem.uploadData}. Delegates to the shared, browser-safe
+	*  chunked-upload flow in `lib/chunked-upload.ts`, wired to this sandbox's
+	*  runtime endpoint (works over the gateway proxy or a direct connection —
+	*  both are transparent through `runtimeFetch`). */
+	async fsUploadData(remotePath, data, options) {
+		await this.ensureRunning();
+		return uploadChunked({ fetch: (path, init) => this.runtimeFetch(path, init) }, remotePath, data, options);
+	}
 	async fsDownload(remotePath, localPath, options) {
 		await this.ensureRunning();
 		const fs = await import("node:fs/promises");

package/dist/tangle/index.d.ts

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

package/dist/tangle/index.js

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

package/dist/{tangle-C-5OvIj8.js → tangle-Os9sH-ms.js}

@@ -1,5 +1,5 @@
 import { p as parseErrorResponse } from "./errors-wd266B9Q.js";
-import { t as SandboxInstance } from "./sandbox-CIHssZCH.js";
+import { t as SandboxInstance } from "./sandbox-KiKLRbR_.js";
 //#region src/tangle/abi.ts
 /**
 * Tangle Contract ABI Definitions

package/dist/{types-yNRVRww-.d.ts → types-LNLeU9Ub.d.ts}

@@ -662,6 +662,25 @@ interface CreateSandboxOptions {
    * timeout-driven retries.
    */
   idempotencyKey?: string;
+  /**
+   * Auto-split inline file mounts out of an inline `backend.profile` object
+   * at create time, send the lean profile (mount refs stripped) in the
+   * create request, then write the deferred files back once the sandbox is
+   * running.
+   *
+   * When `true` (the default), a profile with sizeable inline mounts (e.g.
+   * skills, tool scripts) does not bloat the create POST; the SDK
+   * materializes those files via {@link FileSystem.writeMany} /
+   * {@link FileSystem.uploadData} after the sandbox reaches `running`. Only
+   * applies to an inline `AgentProfile` object on `backend.profile` — a
+   * named-profile string is never split, and the deprecated untyped
+   * `backend.inlineProfile` passthrough is not split either. Set `false`
+   * to send the full profile inline in the create request (no post-create
+   * materialization step).
+   *
+   * @default true
+   */
+  autoMaterializeProfileFiles?: boolean;
 }
 /**
  * Per-call overrides for {@link SandboxClient.create}.
@@ -4452,6 +4471,36 @@ interface UploadProgress {
   /** Percentage complete (0-100) */
   percentage: number;
 }
+/**
+ * Options for {@link FileSystem.uploadData}.
+ */
+interface ChunkedUploadOptions {
+  /** Unix mode bits applied to the file after upload, e.g. 0o644. */
+  mode?: number;
+  /** Progress callback fired after each part completes. On the rare
+   *  checksum-mismatch recovery (one automatic full re-upload),
+   *  `bytesUploaded` restarts from 0 for the second pass. */
+  onProgress?: (progress: UploadProgress) => void;
+  /** Cancel the upload. A pending upload session is best-effort deleted
+   *  server-side when the signal fires mid-flow. */
+  signal?: AbortSignal;
+  /** Delay between part PUTs (ms) to pace bursts. 0 disables pacing (default). */
+  paceMs?: number;
+  /** Max retries per part on a transient error before failing loud. Default 4. */
+  maxRetries?: number;
+}
+/**
+ * Result of a successful {@link FileSystem.uploadData} call — the
+ * upload-session commit response.
+ */
+interface ChunkedUploadResult {
+  /** The path the runtime wrote the assembled payload to. */
+  path: string;
+  /** Total assembled size in bytes. */
+  size: number;
+  /** Server-computed content hash of the assembled payload. */
+  hash: string;
+}
 /**
  * Options for downloading files.
  */
@@ -4560,10 +4609,12 @@ interface RenameOptions {
 interface WriteManyFile {
   /** Destination path. Relative paths resolve from the workspace root. */
   path: string;
-  /** File content (UTF-8). */
+  /** File content: UTF-8 by default, or base64 when `encoding: "base64"` (for binary payloads). */
   content: string;
   /** Unix mode bits applied after write, e.g. 0o755. */
   mode?: number;
+  /** Encoding of `content` on the wire. */
+  encoding?: "utf8" | "base64";
 }
 /** Options for {@link FileSystem.write}. */
 interface WriteFileOptions {
@@ -4654,6 +4705,35 @@ interface FileSystem {
    * ```
    */
   upload(localPath: string, remotePath: string, options?: UploadOptions): Promise<void>;
+  /**
+   * Upload in-memory binary or text data to the sandbox over the chunked
+   * upload-session protocol, without touching the local filesystem.
+   *
+   * Browser/Worker-safe (no `node:` APIs) — this is the sanctioned path for
+   * delivering payloads over ~1 MiB from a browser tab, a Worker, or any
+   * runtime without `node:fs`, where {@link FileSystem.upload}'s local-file
+   * read isn't available. Binary-safe: accepts a `Blob`, `ArrayBuffer`,
+   * `ArrayBufferView`, or UTF-8 `string`. The upload is chunked into
+   * server-sized parts transparently — callers see one call and one
+   * awaited result — and verified end-to-end with a whole-payload SHA-256
+   * at commit. Works identically whether the sandbox is reached through
+   * the gateway proxy or a direct sidecar connection.
+   *
+   * @param remotePath - Destination path in the sandbox.
+   * @param data - Payload to upload. Strings encode as UTF-8.
+   * @param options - Chunking, retry, progress, and cancellation options.
+   * @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately, before any
+   *   request, if the payload exceeds the chunked-upload session cap.
+   *
+   * @example
+   * ```typescript
+   * const blob = await fetch("https://example.com/model.bin").then((r) => r.blob());
+   * await box.fs.uploadData("/workspace/models/model.bin", blob, {
+   *   onProgress: (p) => console.log(`${p.percentage.toFixed(1)}%`),
+   * });
+   * ```
+   */
+  uploadData(remotePath: string, data: Blob | ArrayBuffer | ArrayBufferView | string, options?: ChunkedUploadOptions): Promise<ChunkedUploadResult>;
   /**
    * Download a file from the sandbox.
    * Handles binary files correctly.
@@ -4880,4 +4960,4 @@ interface CodeExecutionOptions {
   idempotencyKey?: string;
 }
 //#endregion
-export { EventStreamOptions as $, SandboxFleetInfo as $n, SessionListOptions as $r, MkdirOptions as $t, CommitTaskSessionOptions as A, WaitForOptions as Ai, RestoreSnapshotOptions as An, SandboxStatus as Ar, GpuLeaseBilling as At, CreateTaskSessionOptions as B, AgentProfileMcpServer as Bi, SSHCommandDescriptor as Bn, ScopedToken as Br, InstalledTool as Bt, BatchTaskUsage as C, TokenRefreshHandler as Ci, PublishPublicTemplateOptions as Cn, SandboxPortPreviewLink as Cr, GitAuth as Ct, CodeLanguage as D, UploadOptions as Di, ReconcileSandboxFleetsOptions as Dn, SandboxRuntimeHealth as Dr, GitDiff as Dt, CodeExecutionResult as E, UpdateUserOptions as Ei, ReapExpiredSandboxFleetsResult as En, SandboxResources as Er, GitConfig as Et, CreateSandboxFleetOptions as F, AgentProfile as Fi, RolloutScorer as Fn, SandboxTraceBundle as Fr, GpuLeaseProviderName as Ft, DownloadOptions as G, AgentProfileResources as Gi, SandboxEvent as Gn, SecretsManager as Gr, IntelligenceReportWindow as Gt, DirectoryPermission as H, AgentProfilePermissionValue as Hi, SandboxClientConfig as Hn, SearchMatch as Hr, IntelligenceReportBudget as Ht, CreateSandboxFleetTokenOptions as I, AgentProfileCapabilities as Ii, RolloutStartResult as In, SandboxTraceEvent as Ir, GpuLeaseStatus as It, DriverConfig as J, AgentSubagentProfile as Ji, SandboxFleetCostEstimate as Jn, SentSessionMessage as Jr, ListOptions as Jt, DownloadProgress as K, AgentProfileValidationIssue as Ki, SandboxFleetArtifact as Kn, SendSessionMessageOptions as Kr, JsonValue as Kt, CreateSandboxFleetWithCoordinatorOptions as L, AgentProfileConfidential as Li, RolloutStatus as Ln, SandboxTraceExport as Lr, GpuType as Lt, CreateGpuLeaseOptions as M, WriteFileOptions as Mi, Rollout as Mn, SandboxTerminalInfo as Mr, GpuLeaseExecOptions as Mt, CreateIntelligenceReportOptions as N, WriteManyFile as Ni, RolloutChildResult as Nn, SandboxTerminalManager as Nr, GpuLeaseExecResult as Nt, CodeResult as O, UploadProgress as Oi, ReconcileSandboxFleetsResult as On, SandboxRuntimeProfile as Or, GitStatus as Ot, CreateRequestOptions as P, WriteManyOptions as Pi, RolloutOptions as Pn, SandboxTerminalRequestOptions as Pr, GpuLeaseManager as Pt, EgressPolicy as Q, mergeAgentProfiles as Qi, SandboxFleetDriverTimings as Qn, SessionInfo as Qr, MintScopedTokenOptions as Qt, CreateSandboxOptions as R, AgentProfileConnection as Ri, RolloutTurnPart as Rn, SandboxTraceOptions as Rr, HostAgentDriverConfig as Rt, BatchTaskResult as S, TeePublicKeyResponse as Si, PublicTemplateVersionInfo as Sn, SandboxPortBinding as Sr, GPU_LEASE_PROVIDER_NAMES as St, CodeExecutionOptions as T, TurnDriveResult as Ti, ReapExpiredSandboxFleetsOptions as Tn, SandboxResourceUsage as Tr, GitCommit as Tt, DispatchPromptOptions as U, AgentProfilePrompt as Ui, SandboxConnection as Un, SearchOptions as Ur, IntelligenceReportCompareTo as Ut, DeleteOptions as V, AgentProfileModelHints as Vi, SSHCredentials as Vn, ScopedTokenScope as Vr, IntelligenceReport as Vt, DispatchedSession as W, AgentProfileResourceRef as Wi, SandboxEnvironment as Wn, SecretInfo as Wr, IntelligenceReportSubjectType as Wt, DriverType as X, defineGitHubResource as Xi, SandboxFleetDispatchResponse as Xn, SessionEventStreamOptions as Xr, ListSandboxOptions as Xt, DriverInfo as Y, defineAgentProfile as Yi, SandboxFleetDispatchFailureClass as Yn, SessionBackendCredentials as Yr, ListSandboxFleetOptions as Yt, EgressManager as Z, defineInlineResource as Zi, SandboxFleetDriverCapability as Zn, SessionForkOptions as Zr, McpServerConfig as Zt, BatchResult as _, TaskSessionProfile as _i, ProvisionEvent as _n, SandboxFleetWorkspaceRestoreResult as _r, FleetExecDispatchOptions as _t, AttachSandboxFleetMachineOptions as a, SnapshotResult as ai, PreviewLinkInfo as an, SandboxFleetManifest as ar, FileReadError as at, BatchSidecarGroup as b, TeeAttestationResponse as bi, ProvisionStep as bn, SandboxIntelligenceEnvelope as br, FleetPromptDispatchOptions as bt, BackendInfo as c, StartupOperation as ci, ProcessInfo as cn, SandboxFleetPolicy as cr, FileSystem as ct, BackendType as d, TaskOptions as di, ProcessSignal as dn, SandboxFleetTraceEvent as dr, FileTreeResult as dt, SessionMessage as ei, NetworkConfig as en, SandboxFleetIntelligenceEnvelope as er, ExecOptions as et, BatchBackend as f, TaskResult as fi, ProcessSpawnOptions as fn, SandboxFleetTraceExport as fr, FileWriteResult as ft, BatchOptions as g, TaskSessionInfo as gi, PromptResult as gn, SandboxFleetWorkspaceReconcileResult as gr, FleetDispatchStreamOptions as gt, BatchEventDataMap as h, TaskSessionFileChange as hi, PromptOptions as hn, SandboxFleetWorkspace as hr, FleetDispatchResultBufferOptions as ht, AttachGpuLeaseOptions as i, SnapshotOptions as ii, PermissionsManager as in, SandboxFleetMachineSpec as ir, FileReadBatchResult as it, CompletedTurnResult as j, WaitForRolloutOptions as ji, ResumeOptions as jn, SandboxTerminalCreateOptions as jr, GpuLeaseCommandResult as jt, CodeResultPart as k, UsageInfo as ki, RenameOptions as kn, SandboxRuntimeProfileList as kr, GpuLease as kt, BackendManager as l, StorageConfig as li, ProcessLogEntry as ln, SandboxFleetToken as lr, FileTreeFile as lt, BatchEvent as m, TaskSessionCommitResult as mi, PromptInputPart as mn, SandboxFleetUsage as mr, FleetDispatchResultBuffer as mt, AccessPolicyRule as n, SessionStatus as ni, NonHostAgentDriverConfig as nn, SandboxFleetMachineMeteredUsage as nr, FileInfo as nt, BackendCapabilities as o, SshKeysManager as oi, PreviewLinkManager as on, SandboxFleetManifestMachine as or, FileReadResult as ot, BatchBackendStats as p, TaskSessionChanges as pi, ProcessStatus as pn, SandboxFleetTraceOptions as pr, FleetDispatchCancelResult as pt, DriveTurnOptions as q, AgentProfileValidationResult as qi, SandboxFleetArtifactSpec as qn, SendSessionMessageRequest as qr, ListMessagesOptions as qt, AddUserOptions as r, SnapshotInfo as ri, PermissionLevel as rn, SandboxFleetMachineRecord as rr, FileReadBatchOptions as rt, BackendConfig as s, StartupDiagnostics as si, Process as sn, SandboxFleetOperationsSummary as sr, FileRenameResult as st, AcceleratorKind as t, SessionMessageInputPart as ti, NetworkManager as tn, SandboxFleetMachine as tr, ExecResult as tt, BackendStatus as u, SubscriptionInfo as ui, ProcessManager as un, SandboxFleetTraceBundle as ur, FileTreeOptions as ut, BatchRunOptions as v, TeeAttestationOptions as vi, ProvisionResult as vn, SandboxFleetWorkspaceSnapshotResult as vr, FleetExecDispatchResult as vt, BranchOptions as w, ToolsConfig as wi, PublishPublicTemplateVersionOptions as wn, SandboxProfileSummary as wr, GitBranch as wt, BatchTask as x, TeePublicKey as xi, PublicTemplateInfo as xn, SandboxPermissionsConfig as xr, FleetPromptDispatchResult as xt, BatchRunRequest as y, TeeAttestationReport as yi, ProvisionStatus as yn, SandboxInfo as yr, FleetMachineId as yt, CreateSessionOptions as z, AgentProfileFileMount as zi, RunCodeOptions as zn, SandboxUser as zr, HostAgentRuntimeBackend as zt };
+export { EgressManager as $, defineInlineResource as $i, SandboxFleetDriverCapability as $n, SessionForkOptions as $r, McpServerConfig as $t, CodeResult as A, UploadProgress as Ai, ReconcileSandboxFleetsResult as An, SandboxRuntimeProfile as Ar, GitStatus as At, CreateSandboxOptions as B, AgentProfileConnection as Bi, RolloutTurnPart as Bn, SandboxTraceOptions as Br, HostAgentDriverConfig as Bt, BatchTaskUsage as C, TeePublicKey as Ci, PublicTemplateInfo as Cn, SandboxPermissionsConfig as Cr, FleetPromptDispatchResult as Ct, CodeExecutionOptions as D, TurnDriveResult as Di, ReapExpiredSandboxFleetsOptions as Dn, SandboxResourceUsage as Dr, GitCommit as Dt, ChunkedUploadResult as E, ToolsConfig as Ei, PublishPublicTemplateVersionOptions as En, SandboxProfileSummary as Er, GitBranch as Et, CreateIntelligenceReportOptions as F, WriteManyFile as Fi, RolloutChildResult as Fn, SandboxTerminalManager as Fr, GpuLeaseExecResult as Ft, DispatchPromptOptions as G, AgentProfilePrompt as Gi, SandboxConnection as Gn, SearchOptions as Gr, IntelligenceReportCompareTo as Gt, CreateTaskSessionOptions as H, AgentProfileMcpServer as Hi, SSHCommandDescriptor as Hn, ScopedToken as Hr, InstalledTool as Ht, CreateRequestOptions as I, WriteManyOptions as Ii, RolloutOptions as In, SandboxTerminalRequestOptions as Ir, GpuLeaseManager as It, DownloadProgress as J, AgentProfileValidationIssue as Ji, SandboxFleetArtifact as Jn, SendSessionMessageOptions as Jr, JsonValue as Jt, DispatchedSession as K, AgentProfileResourceRef as Ki, SandboxEnvironment as Kn, SecretInfo as Kr, IntelligenceReportSubjectType as Kt, CreateSandboxFleetOptions as L, AgentProfile as Li, RolloutScorer as Ln, SandboxTraceBundle as Lr, GpuLeaseProviderName as Lt, CommitTaskSessionOptions as M, WaitForOptions as Mi, RestoreSnapshotOptions as Mn, SandboxStatus as Mr, GpuLeaseBilling as Mt, CompletedTurnResult as N, WaitForRolloutOptions as Ni, ResumeOptions as Nn, SandboxTerminalCreateOptions as Nr, GpuLeaseCommandResult as Nt, CodeExecutionResult as O, UpdateUserOptions as Oi, ReapExpiredSandboxFleetsResult as On, SandboxResources as Or, GitConfig as Ot, CreateGpuLeaseOptions as P, WriteFileOptions as Pi, Rollout as Pn, SandboxTerminalInfo as Pr, GpuLeaseExecOptions as Pt, DriverType as Q, defineGitHubResource as Qi, SandboxFleetDispatchResponse as Qn, SessionEventStreamOptions as Qr, ListSandboxOptions as Qt, CreateSandboxFleetTokenOptions as R, AgentProfileCapabilities as Ri, RolloutStartResult as Rn, SandboxTraceEvent as Rr, GpuLeaseStatus as Rt, BatchTaskResult as S, TeeAttestationResponse as Si, ProvisionStep as Sn, SandboxIntelligenceEnvelope as Sr, FleetPromptDispatchOptions as St, ChunkedUploadOptions as T, TokenRefreshHandler as Ti, PublishPublicTemplateOptions as Tn, SandboxPortPreviewLink as Tr, GitAuth as Tt, DeleteOptions as U, AgentProfileModelHints as Ui, SSHCredentials as Un, ScopedTokenScope as Ur, IntelligenceReport as Ut, CreateSessionOptions as V, AgentProfileFileMount as Vi, RunCodeOptions as Vn, SandboxUser as Vr, HostAgentRuntimeBackend as Vt, DirectoryPermission as W, AgentProfilePermissionValue as Wi, SandboxClientConfig as Wn, SearchMatch as Wr, IntelligenceReportBudget as Wt, DriverConfig as X, AgentSubagentProfile as Xi, SandboxFleetCostEstimate as Xn, SentSessionMessage as Xr, ListOptions as Xt, DriveTurnOptions as Y, AgentProfileValidationResult as Yi, SandboxFleetArtifactSpec as Yn, SendSessionMessageRequest as Yr, ListMessagesOptions as Yt, DriverInfo as Z, defineAgentProfile as Zi, SandboxFleetDispatchFailureClass as Zn, SessionBackendCredentials as Zr, ListSandboxFleetOptions as Zt, BatchResult as _, TaskSessionFileChange as _i, PromptOptions as _n, SandboxFleetWorkspace as _r, FleetDispatchResultBufferOptions as _t, AttachSandboxFleetMachineOptions as a, SnapshotInfo as ai, PermissionLevel as an, SandboxFleetMachineRecord as ar, FileReadBatchOptions as at, BatchSidecarGroup as b, TeeAttestationOptions as bi, ProvisionResult as bn, SandboxFleetWorkspaceSnapshotResult as br, FleetExecDispatchResult as bt, BackendInfo as c, SshKeysManager as ci, PreviewLinkManager as cn, SandboxFleetManifestMachine as cr, FileReadResult as ct, BackendType as d, StorageConfig as di, ProcessLogEntry as dn, SandboxFleetToken as dr, FileTreeFile as dt, mergeAgentProfiles as ea, SessionInfo as ei, MintScopedTokenOptions as en, SandboxFleetDriverTimings as er, EgressPolicy as et, BatchBackend as f, SubscriptionInfo as fi, ProcessManager as fn, SandboxFleetTraceBundle as fr, FileTreeOptions as ft, BatchOptions as g, TaskSessionCommitResult as gi, PromptInputPart as gn, SandboxFleetUsage as gr, FleetDispatchResultBuffer as gt, BatchEventDataMap as h, TaskSessionChanges as hi, ProcessStatus as hn, SandboxFleetTraceOptions as hr, FleetDispatchCancelResult as ht, AttachGpuLeaseOptions as i, SessionStatus as ii, NonHostAgentDriverConfig as in, SandboxFleetMachineMeteredUsage as ir, FileInfo as it, CodeResultPart as j, UsageInfo as ji, RenameOptions as jn, SandboxRuntimeProfileList as jr, GpuLease as jt, CodeLanguage as k, UploadOptions as ki, ReconcileSandboxFleetsOptions as kn, SandboxRuntimeHealth as kr, GitDiff as kt, BackendManager as l, StartupDiagnostics as li, Process as ln, SandboxFleetOperationsSummary as lr, FileRenameResult as lt, BatchEvent as m, TaskResult as mi, ProcessSpawnOptions as mn, SandboxFleetTraceExport as mr, FileWriteResult as mt, AccessPolicyRule as n, SessionMessage as ni, NetworkConfig as nn, SandboxFleetIntelligenceEnvelope as nr, ExecOptions as nt, BackendCapabilities as o, SnapshotOptions as oi, PermissionsManager as on, SandboxFleetMachineSpec as or, FileReadBatchResult as ot, BatchBackendStats as p, TaskOptions as pi, ProcessSignal as pn, SandboxFleetTraceEvent as pr, FileTreeResult as pt, DownloadOptions as q, AgentProfileResources as qi, SandboxEvent as qn, SecretsManager as qr, IntelligenceReportWindow as qt, AddUserOptions as r, SessionMessageInputPart as ri, NetworkManager as rn, SandboxFleetMachine as rr, ExecResult as rt, BackendConfig as s, SnapshotResult as si, PreviewLinkInfo as sn, SandboxFleetManifest as sr, FileReadError as st, AcceleratorKind as t, SessionListOptions as ti, MkdirOptions as tn, SandboxFleetInfo as tr, EventStreamOptions as tt, BackendStatus as u, StartupOperation as ui, ProcessInfo as un, SandboxFleetPolicy as ur, FileSystem as ut, BatchRunOptions as v, TaskSessionInfo as vi, PromptResult as vn, SandboxFleetWorkspaceReconcileResult as vr, FleetDispatchStreamOptions as vt, BranchOptions as w, TeePublicKeyResponse as wi, PublicTemplateVersionInfo as wn, SandboxPortBinding as wr, GPU_LEASE_PROVIDER_NAMES as wt, BatchTask as x, TeeAttestationReport as xi, ProvisionStatus as xn, SandboxInfo as xr, FleetMachineId as xt, BatchRunRequest as y, TaskSessionProfile as yi, ProvisionEvent as yn, SandboxFleetWorkspaceRestoreResult as yr, FleetExecDispatchOptions as yt, CreateSandboxFleetWithCoordinatorOptions as z, AgentProfileConfidential as zi, RolloutStatus as zn, SandboxTraceExport as zr, GpuType as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/sandbox",
-  "version": "0.10.5-develop.20260713235503.8f2cefc",
+  "version": "0.10.5-develop.20260715115519.fee3d86",
   "description": "Client SDK for the Tangle Sandbox platform - build AI agent applications with dev containers",
   "type": "module",
   "main": "./dist/index.js",
@@ -88,7 +88,8 @@
   },
   "dependencies": {
     "@tangle-network/agent-core": "^0.4.0",
-    "@tangle-network/agent-interface": "^0.21.0"
+    "@tangle-network/agent-interface": "^0.21.0",
+    "@tangle-network/runtime-contracts": "0.1.0"
   },
   "peerDependencies": {
     "@mastra/core": "^1.36.0",