@tangle-network/sandbox 0.10.5 → 0.11.0

package/dist/runtime-api-kukaWPtF.js

@@ -0,0 +1,678 @@
+import { c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, p as parseErrorResponse, s as QuotaError } from "./errors-Cbs78OlF.js";
+//#region src/backend-config.ts
+const LEGACY_QUESTION_ALIAS_KEY = ["question", "Channel"].join("");
+function parseModelString(model) {
+	const parts = model.split("/");
+	if (parts.length >= 2) return {
+		provider: parts[0],
+		model: parts.slice(1).join("/")
+	};
+	return { model };
+}
+/**
+* Normalize runtime backend config for the wire format.
+*
+* Canonical profile objects are already accepted by the sidecar and are
+* forwarded without translation.
+*/
+function normalizeRuntimeBackendConfig(backend, options = {}) {
+	if (!backend && !options.model) return void 0;
+	if (backend && LEGACY_QUESTION_ALIAS_KEY in backend) throw new Error(`[sandbox-sdk] backend.${LEGACY_QUESTION_ALIAS_KEY} was removed. Use backend.interactions.question instead.`);
+	const callerInlineProfile = backend?.inlineProfile;
+	if (callerInlineProfile !== void 0) console.warn("[sandbox-sdk] backend.inlineProfile is deprecated. Use backend.profile (AgentProfile) instead.");
+	return {
+		...backend?.type ? { type: backend.type } : {},
+		...backend?.profile !== void 0 ? { profile: backend.profile } : {},
+		...callerInlineProfile !== void 0 ? { inlineProfile: callerInlineProfile } : {},
+		...backend?.model ? { model: backend.model } : options.model ? { model: parseModelString(options.model) } : {},
+		...backend?.server ? { server: backend.server } : {},
+		...backend?.interactions !== void 0 ? { interactions: backend.interactions } : {},
+		...backend?.metadata !== void 0 ? { metadata: backend.metadata } : {}
+	};
+}
+/**
+* @deprecated Canonical profile objects can be sent directly as
+* `backend.profile`; this compatibility export now preserves that object.
+*/
+function serializeForSidecar(profile) {
+	return profile;
+}
+//#endregion
+//#region src/lib/wire-encoding.ts
+/**
+* Encode a prompt text part for the wire. Server decodes at the route
+* boundary; the LLM only ever sees the original UTF-8. Done
+* unconditionally because readable bodies false-positive on ingress WAF
+* rules that pattern-match shell-injection-shaped substrings (which
+* legitimate prompts routinely contain — e.g. Step-0 dev-server
+* bootstrap).
+*/
+function encodeTextForWire(text) {
+	if (typeof Buffer !== "undefined") return Buffer.from(text, "utf8").toString("base64");
+	if (typeof btoa === "function") return btoa(encodeURIComponent(text).replace(/%([0-9A-F]{2})/g, (_, h) => String.fromCharCode(Number.parseInt(h, 16))));
+	throw new Error("encodeTextForWire: no base64 encoder available (Buffer and btoa both undefined)");
+}
+/**
+* Convert a caller-supplied prompt (string or parts array) into the
+* wire-format parts array. Every text part is base64-encoded; non-text
+* parts pass through. A bare string is wrapped in a single text part.
+*/
+function encodePromptForWire(message) {
+	return (typeof message === "string" ? [{
+		type: "text",
+		text: message
+	}] : message).map((part) => part.type === "text" ? {
+		type: "text",
+		text: encodeTextForWire(part.text)
+	} : part);
+}
+//#endregion
+//#region src/lib/abort-signal.ts
+function combineAbortSignals(signals) {
+	return AbortSignal.any(signals);
+}
+//#endregion
+//#region ../../../packages/runtime-contracts/dist/file-limits.js
+const MEBIBYTE$1 = 1024 * 1024;
+10 * MEBIBYTE$1;
+const FILE_DECODED_WRITE_MAX_BYTES = 5 * MEBIBYTE$1;
+5 * MEBIBYTE$1;
+10 * MEBIBYTE$1;
+5 * MEBIBYTE$1;
+//#endregion
+//#region ../../../packages/runtime-contracts/dist/request-limits.js
+/**
+* Raw WIRE/TRANSPORT caps: request-byte limits checked while the body
+* streams in (bodyLimit middleware, Content-Length, encoded proxy bodies),
+* before anything is parsed or decoded. Rejections against these carry
+* code `PAYLOAD_TOO_LARGE` (`payload-too-large.ts`) — the remedy is to
+* split the delivery. Decoded/parsed-content caps (code `FILE_TOO_LARGE`)
+* live in `file-io.ts`.
+*/
+const MEBIBYTE = 1024 * 1024;
+/**
+* Gateway (CF Worker) proxy cap on any request body it forwards — both
+* pass-through requests and route-constructed (`options.body`) proxy
+* payloads. Workers buffer forwarded bodies (streaming upstream stalls),
+* so this bounds Worker memory per request.
+*/
+const SANDBOX_PROXY_REQUEST_MAX_BYTES = MEBIBYTE;
+32 * MEBIBYTE;
+/**
+* Max assembled size of one chunked-upload session — the ceiling of the
+* sanctioned >1 MiB delivery path. Parts stage in sidecar memory until
+* commit, so this bounds per-session memory, not the destination
+* filesystem.
+*/
+const FILE_UPLOAD_SESSION_MAX_BYTES = 64 * MEBIBYTE;
+128 * MEBIBYTE;
+//#endregion
+//#region ../../../packages/runtime-contracts/dist/size-limit-errors.js
+/** Canonical error codes for wire-size and decoded-content rejections. */
+const PAYLOAD_TOO_LARGE_CODE = "PAYLOAD_TOO_LARGE";
+const FILE_TOO_LARGE_CODE = "FILE_TOO_LARGE";
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isSizeLimitErrorBodyFor(value, code) {
+	if (!isRecord(value) || value.success !== false || !isRecord(value.error)) return false;
+	const error = value.error;
+	return error.code === code && typeof error.message === "string" && typeof error.surface === "string" && isPositiveInteger(error.limitBytes) && (error.actualBytes === void 0 || isPositiveInteger(error.actualBytes));
+}
+function isPayloadTooLargeErrorBody(value) {
+	return isSizeLimitErrorBodyFor(value, PAYLOAD_TOO_LARGE_CODE);
+}
+function isFileTooLargeErrorBody(value) {
+	return isSizeLimitErrorBodyFor(value, FILE_TOO_LARGE_CODE);
+}
+//#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 > 67108864) 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 {
+	terminals;
+	constructor(transport) {
+		this.transport = transport;
+		this.terminals = {
+			create: (options, request) => this.createTerminal(options, request),
+			input: (terminalId, data, request) => this.writeTerminal(terminalId, data, request),
+			list: () => this.listTerminals(),
+			get: (terminalId) => this.getTerminal(terminalId)
+		};
+	}
+	async health() {
+		await this.transport.ensureRunning();
+		return this.json("/health", { method: "GET" });
+	}
+	async ports() {
+		await this.transport.ensureRunning();
+		return (await this.json("/ports", { method: "GET" })).data?.ports ?? [];
+	}
+	async profiles() {
+		await this.transport.ensureRunning();
+		return this.json("/profiles", { method: "GET" });
+	}
+	async readFiles(paths, options = {}) {
+		if (paths.length === 0) return {
+			files: [],
+			errors: [],
+			stats: {
+				requested: 0,
+				succeeded: 0,
+				failed: 0
+			}
+		};
+		await this.transport.ensureRunning();
+		const files = [];
+		const errors = [];
+		let requested = 0;
+		let succeeded = 0;
+		let failed = 0;
+		for (let offset = 0; offset < paths.length; offset += 100) {
+			const chunk = paths.slice(offset, offset + 100);
+			const params = new URLSearchParams();
+			if (options.sessionId) params.set("sessionId", options.sessionId);
+			const query = params.toString();
+			const payload = await this.json(`/files/read-batch${query ? `?${query}` : ""}`, {
+				method: "POST",
+				body: JSON.stringify({
+					paths: chunk,
+					encoding: options.encoding ?? "utf8"
+				})
+			});
+			for (const [path, result] of Object.entries(payload.data.files)) if (result.success) files.push({
+				path,
+				content: result.content,
+				encoding: result.encoding,
+				hash: result.hash,
+				size: result.size,
+				mtime: result.mtime
+			});
+			else errors.push({
+				path,
+				error: result.error,
+				code: result.code
+			});
+			const results = Object.values(payload.data.files);
+			requested += payload.data.stats?.requested ?? chunk.length;
+			succeeded += payload.data.stats?.succeeded ?? results.filter((entry) => entry.success).length;
+			failed += payload.data.stats?.failed ?? results.filter((entry) => !entry.success).length;
+		}
+		return {
+			files,
+			errors,
+			stats: {
+				requested,
+				succeeded,
+				failed
+			}
+		};
+	}
+	async writeFile(path, content, options = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams();
+		if (options.sessionId) params.set("sessionId", options.sessionId);
+		const query = params.toString();
+		return (await this.json(`/files/write${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify({
+				path,
+				content,
+				...options.encoding !== void 0 ? { encoding: options.encoding } : {},
+				...options.mode !== void 0 ? { mode: options.mode } : {}
+			})
+		})).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();
+		if (options.sessionId) params.set("sessionId", options.sessionId);
+		const query = params.toString();
+		await this.request(`/files/delete${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify({ path })
+		});
+	}
+	async renameFile(sourcePath, destinationPath, options = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams();
+		if (options.sessionId) params.set("sessionId", options.sessionId);
+		const query = params.toString();
+		return (await this.json(`/files/rename${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify({
+				sourcePath,
+				destinationPath
+			})
+		})).data;
+	}
+	async fileTree(path, options = {}) {
+		if (options.maxDepth !== void 0 && (!Number.isInteger(options.maxDepth) || options.maxDepth < 1 || options.maxDepth > 20)) throw new ValidationError("maxDepth must be an integer between 1 and 20");
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams({ path });
+		if (options.maxDepth !== void 0) params.set("maxDepth", String(options.maxDepth));
+		if (options.sessionId) params.set("sessionId", options.sessionId);
+		return (await this.json(`/files/tree?${params}`, { method: "GET" })).data;
+	}
+	async createSession(options) {
+		await this.transport.ensureRunning();
+		const info = normalizeSessionInfo(await this.json("/agents/sessions", {
+			method: "POST",
+			body: JSON.stringify({
+				...options.sessionId !== void 0 ? { sessionId: options.sessionId } : {},
+				...options.title !== void 0 ? { title: options.title } : {},
+				...options.parentId !== void 0 ? { parentID: options.parentId } : {},
+				backend: normalizeRuntimeBackendConfig(options.backend)
+			})
+		}));
+		if (!info) throw new ServerError("Session creation response missing session id", 502, {
+			endpoint: "/agents/sessions",
+			origin: "runtime"
+		});
+		return info;
+	}
+	async messages(id, options = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams({ sessionId: id });
+		if (options.limit !== void 0) params.set("limit", String(options.limit));
+		if (options.offset !== void 0) params.set("offset", String(options.offset));
+		if (options.since !== void 0) params.set("since", String(options.since));
+		const query = params.toString();
+		return (await this.json(`/messages${query ? `?${query}` : ""}`, { method: "GET" })).map((message) => ({
+			id: message.info.id,
+			role: message.info.role,
+			timestamp: message.info.timestamp,
+			parts: message.parts,
+			metadata: message.info.metadata
+		}));
+	}
+	async createTaskSession(options) {
+		await this.transport.ensureRunning();
+		const info = await this.json("/tasks", {
+			method: "POST",
+			body: JSON.stringify({
+				sessionId: options.sessionId,
+				backend: normalizeRuntimeBackendConfig(options.backend),
+				title: options.title,
+				...options.parentSessionId !== void 0 ? { parentSessionId: options.parentSessionId } : {},
+				...options.profile !== void 0 ? { profile: options.profile } : {},
+				...options.isolateFileWrites !== void 0 ? { isolateFileWrites: options.isolateFileWrites } : {}
+			})
+		});
+		if (!info.id) throw new ServerError("Task session creation response missing session id", 502, {
+			endpoint: "/tasks",
+			origin: "runtime"
+		});
+		return info;
+	}
+	async sendSessionMessage(id, request, options = {}) {
+		if (options.timeoutMs !== void 0 && options.timeoutMs <= 0) throw new ValidationError("timeoutMs must be greater than zero");
+		await this.transport.ensureRunning();
+		const headers = new Headers({ "x-no-retry": "true" });
+		if (options.credentials?.apiKey) headers.set("X-Backend-Api-Key", options.credentials.apiKey);
+		if (options.credentials?.baseUrl) headers.set("X-Backend-Base-Url", options.credentials.baseUrl);
+		const timeoutSignal = options.timeoutMs !== void 0 ? AbortSignal.timeout(options.timeoutMs) : void 0;
+		const signal = options.signal && timeoutSignal ? combineAbortSignals([options.signal, timeoutSignal]) : options.signal ?? timeoutSignal;
+		return this.json(`/agents/sessions/${encodeURIComponent(id)}/messages`, {
+			method: "POST",
+			headers,
+			signal,
+			body: JSON.stringify({
+				...request.messageId !== void 0 ? { messageID: request.messageId } : {},
+				parts: request.parts.map((part) => part.type === "text" ? {
+					...part,
+					text: encodeTextForWire(part.text)
+				} : part),
+				...request.system !== void 0 ? { system: request.system } : {},
+				...request.agent !== void 0 ? { agent: request.agent } : {},
+				...request.model !== void 0 ? { model: {
+					providerID: request.model.providerId,
+					modelID: request.model.modelId
+				} } : {},
+				...request.reasoningEffort !== void 0 ? { reasoningEffort: request.reasoningEffort } : {},
+				...request.turnId !== void 0 ? { turnId: request.turnId } : {},
+				...request.interactions !== void 0 ? { interactions: request.interactions } : {}
+			})
+		});
+	}
+	async deleteSession(id) {
+		await this.transport.ensureRunning();
+		await this.request(`/agents/sessions/${encodeURIComponent(id)}`, { method: "DELETE" });
+	}
+	async taskSessionChanges(id) {
+		await this.transport.ensureRunning();
+		return this.json(`/tasks/${encodeURIComponent(id)}/changes`, { method: "GET" });
+	}
+	async commitTaskSession(id, options = {}) {
+		await this.transport.ensureRunning();
+		return this.json(`/tasks/${encodeURIComponent(id)}/changes`, {
+			method: "POST",
+			body: JSON.stringify({
+				...options.message !== void 0 ? { message: options.message } : {},
+				...options.files !== void 0 ? { files: options.files } : {}
+			})
+		});
+	}
+	async createTerminal(options = {}, request = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams();
+		if (request.sessionId) params.set("sessionId", request.sessionId);
+		const query = params.toString();
+		return (await this.json(`/terminals${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		})).data;
+	}
+	async writeTerminal(terminalId, data, request = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams();
+		if (request.sessionId) params.set("sessionId", request.sessionId);
+		const query = params.toString();
+		await this.request(`/terminals/${encodeURIComponent(terminalId)}/input${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify({ data })
+		});
+	}
+	async listTerminals() {
+		await this.transport.ensureRunning();
+		return (await this.json("/terminals", { method: "GET" })).data ?? [];
+	}
+	async getTerminal(terminalId) {
+		await this.transport.ensureRunning();
+		const response = await this.transport.fetch(`/terminals/${encodeURIComponent(terminalId)}`, { method: "GET" });
+		if (response.status === 404) return null;
+		await this.assertOk(response);
+		return (await response.json()).data;
+	}
+	async json(path, init) {
+		return await (await this.request(path, init)).json();
+	}
+	async request(path, init) {
+		const response = await this.transport.fetch(path, init);
+		await this.assertOk(response);
+		return response;
+	}
+	async assertOk(response) {
+		if (response.ok) return;
+		const body = await response.text();
+		throw parseErrorResponse(response.status, body, void 0, response.headers);
+	}
+};
+function normalizeSessionInfo(raw) {
+	const id = raw.id;
+	if (typeof id !== "string") return null;
+	const status = raw.status || "running";
+	return {
+		id,
+		parentId: typeof raw.parentID === "string" ? raw.parentID : typeof raw.parentId === "string" ? raw.parentId : void 0,
+		status: [
+			"queued",
+			"running",
+			"completed",
+			"failed",
+			"cancelled"
+		].includes(status) ? status : "running",
+		backend: typeof raw.backendType === "string" ? raw.backendType : typeof raw.backend === "string" ? raw.backend : void 0,
+		model: typeof raw.model === "string" ? raw.model : void 0,
+		promptCount: typeof raw.promptCount === "number" ? raw.promptCount : void 0,
+		createdAt: raw.createdAt ? new Date(raw.createdAt) : void 0,
+		startedAt: raw.startedAt ? new Date(raw.startedAt) : void 0,
+		endedAt: raw.endedAt ? new Date(raw.endedAt) : void 0,
+		raw
+	};
+}
+//#endregion
+export { FILE_DECODED_WRITE_MAX_BYTES as a, encodeTextForWire as c, SANDBOX_PROXY_REQUEST_MAX_BYTES as i, normalizeRuntimeBackendConfig as l, normalizeSessionInfo as n, combineAbortSignals as o, uploadChunked as r, encodePromptForWire as s, SandboxRuntimeApi as t, serializeForSidecar as u };