@tangle-network/sandbox 0.9.7 → 0.10.1

package/dist/{sandbox-bDWrUu8i.js → sandbox-CeimsfC8.js}

@@ -1,6 +1,7 @@
-import { c as ServerError, d as ValidationError, f as parseErrorResponse, l as StateError, o as QuotaError, r as NetworkError, s as SandboxError, t as AuthError, u as TimeoutError } from "./errors-DZsfJUuc.js";
+import { c as 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-DSz87Rkk.js";
 import { addTokenUsage, readTokenCostUsd, readTokenUsage } from "@tangle-network/agent-core";
 //#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 {
@@ -17,6 +18,7 @@ function parseModelString(model) {
 */
 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 portableProfile = backend?.profile && typeof backend.profile !== "string" ? backend.profile : void 0;
 	const inlineProfile = portableProfile ? toBackendProfile(portableProfile) : void 0;
 	const callerInlineProfile = backend?.inlineProfile;
@@ -32,7 +34,7 @@ function normalizeRuntimeBackendConfig(backend, options = {}) {
 		...backend?.model ? { model: backend.model } : options.model ? { model: parseModelString(options.model) } : {},
 		...backend?.server ? { server: backend.server } : {},
 		...backend?.interactions !== void 0 ? { interactions: backend.interactions } : {},
-		...backend?.questionChannel !== void 0 ? { questionChannel: backend.questionChannel } : {}
+		...backend?.metadata !== void 0 ? { metadata: backend.metadata } : {}
 	};
 }
 /**
@@ -99,19 +101,42 @@ function toBackendProfile(profile) {
 			...timeout !== void 0 ? { timeout } : {}
 		}];
 	})) : void 0;
+	const openCodeExtension = profile.extensions?.opencode;
+	const plugins = openCodeExtension?.plugins;
+	if (plugins !== void 0 && (!Array.isArray(plugins) || plugins.some((plugin) => typeof plugin !== "string" || !plugin.trim()))) throw new Error("backend.profile.extensions.opencode.plugins must be an array of non-empty package names");
+	const commands = openCodeExtension?.commands;
+	if (commands !== void 0 && (commands === null || typeof commands !== "object" || Array.isArray(commands))) throw new Error("backend.profile.extensions.opencode.commands must be an object");
+	const profileExtends = openCodeExtension?.extends;
+	if (profileExtends !== void 0 && typeof profileExtends !== "string" && (!Array.isArray(profileExtends) || profileExtends.some((entry) => typeof entry !== "string" || !entry.trim()))) throw new Error("backend.profile.extensions.opencode.extends must be a profile name or array of profile names");
+	const agents = profile.subagents ? Object.fromEntries(Object.entries(profile.subagents).map(([name, subagent]) => [name, {
+		description: subagent.description,
+		prompt: subagent.prompt,
+		model: subagent.model,
+		tools: subagent.tools,
+		permission: subagent.permissions,
+		maxSteps: subagent.maxSteps,
+		...subagent.metadata ?? {}
+	}])) : void 0;
 	return {
 		name: profile.name,
+		description: profile.description,
+		version: profile.version,
+		tags: profile.tags,
+		...profileExtends ? { extends: profileExtends } : {},
 		model: profile.model?.default,
+		small_model: profile.model?.small,
 		...profile.prompt?.systemPrompt ? { systemPrompt: profile.prompt.systemPrompt } : {},
 		...Object.keys(tools).length > 0 ? { tools } : {},
 		...profile.prompt?.instructions?.length ? { instructions: profile.prompt.instructions } : {},
 		...Object.keys(permission).length > 0 ? { permission } : {},
 		...mcp ? { mcp } : {},
 		...profile.connections?.length ? { connections: profile.connections } : {},
-		...profile.subagents ? { subagents: profile.subagents } : {},
+		...agents ? { agent: agents } : {},
 		...profile.resources && hasAnyProfileResource(profile.resources) ? { resources: profile.resources } : {},
 		...profile.hooks ? { hooks: profile.hooks } : {},
 		...profile.modes ? { modes: profile.modes } : {},
+		...commands ? { command: commands } : {},
+		...plugins?.length ? { plugin: plugins } : {},
 		...profile.extensions ? { extensions: profile.extensions } : {}
 	};
 }
@@ -574,6 +599,244 @@ function collectAgentResponseText(events) {
 	return responseText && responseText.trim().length > 0 ? responseText : void 0;
 }
 //#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,
+					...options.encoding ? { encoding: options.encoding } : {}
+				})
+			});
+			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 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.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 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 ? AbortSignal.any([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,
+				...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
 //#region src/interactive.ts
 /**
 * Handle for one session's interactive harness. Obtained via
@@ -631,7 +894,7 @@ var InteractiveSessionHandle = class {
 * A single agent session inside a sandbox. Created via
 * `box.session(id)` — does not hit the network until a method is called.
 */
-var SandboxSession = class {
+var SandboxSession = class SandboxSession {
 	/**
 	* @internal SDK-internal constructor — apps should call `box.session(id)`.
 	*/
@@ -674,6 +937,16 @@ var SandboxSession = class {
 		return this.box._sessionResult(this.id);
 	}
 	/**
+	* List persisted messages for this session, including in-flight assistant
+	* content when the runtime has flushed partial output.
+	*/
+	async messages(opts = {}) {
+		return this.box.messages({
+			...opts,
+			sessionId: this.id
+		});
+	}
+	/**
 	* Continue this session with an additional prompt. Equivalent to
 	* `box.prompt(message, { ...opts, sessionId: this.id })` but reads
 	* naturally on a Session reference.
@@ -685,6 +958,13 @@ var SandboxSession = class {
 		});
 	}
 	/**
+	* Send a structured message through the session message endpoint. Model and
+	* message identifiers are translated to the runtime's wire names by the SDK.
+	*/
+	async sendMessage(request, options) {
+		return this.box._sessionSendMessage(this.id, request, options);
+	}
+	/**
 	* Abort the session's in-flight execution; the session and its messages
 	* are preserved (this does not delete the session). Void-returning alias
 	* of `interrupt()` — use `interrupt()` when you need to know whether an
@@ -695,6 +975,22 @@ var SandboxSession = class {
 	async cancel() {
 		return this.box._sessionCancel(this.id);
 	}
+	/** Delete this session and its persisted runtime state. */
+	async delete() {
+		return this.box._sessionDelete(this.id);
+	}
+	/**
+	* Fork this session into a new queued session. The fork shares the
+	* parent workspace and copies conversation history up to `messageId`
+	* when supplied.
+	*/
+	async fork(opts) {
+		const info = await this.box._sessionFork(this.id, opts);
+		return {
+			session: new SandboxSession(this.box, info.id),
+			info
+		};
+	}
 	/**
 	* Drive this session's harness in INTERACTIVE mode: spawn its native TUI,
 	* stream the live framebuffer, and inject prompts as keystrokes. Distinct
@@ -732,6 +1028,24 @@ var SandboxSession = class {
 	}
 };
 //#endregion
+//#region src/task-session.ts
+/** A background task session with isolated changeset operations. */
+var SandboxTaskSession = class extends SandboxSession {
+	/** @internal Apps should call `box.taskSession(id)`. */
+	constructor(taskBox, id) {
+		super(taskBox, id);
+		this.taskBox = taskBox;
+	}
+	/** Read the task's isolated file changes. */
+	async changes() {
+		return this.taskBox._taskSessionChanges(this.id);
+	}
+	/** Apply all or a selected subset of the task's isolated file changes. */
+	async commit(options) {
+		return this.taskBox._taskSessionCommit(this.id, options);
+	}
+};
+//#endregion
 //#region src/sandbox.ts
 /**
 * Sandbox Instance
@@ -1004,10 +1318,15 @@ var SandboxInstance = class SandboxInstance {
 	client;
 	info;
 	defaultRuntimeBackend;
+	runtime;
 	constructor(client, info, defaultRuntimeBackend) {
 		this.client = client;
 		this.info = info;
 		this.defaultRuntimeBackend = defaultRuntimeBackend;
+		this.runtime = new SandboxRuntimeApi({
+			ensureRunning: () => this.ensureRunning(),
+			fetch: (path, init) => this.runtimeFetch(path, init)
+		});
 	}
 	/** Unique sandbox identifier */
 	get id() {
@@ -1049,6 +1368,10 @@ var SandboxInstance = class SandboxInstance {
 	get error() {
 		return this.info.error;
 	}
+	/** GPU lease attached during sandbox creation, when requested. */
+	get gpuLease() {
+		return this.info.gpuLease;
+	}
 	/** Web terminal URL for browser-based access */
 	get url() {
 		return this.info.connection?.webTerminalUrl;
@@ -1089,7 +1412,8 @@ var SandboxInstance = class SandboxInstance {
 			startedAt: this.startedAt,
 			lastActivityAt: this.lastActivityAt,
 			expiresAt: this.expiresAt,
-			error: this.error
+			error: this.error,
+			gpuLease: this.gpuLease
 		};
 	}
 	/**
@@ -1419,11 +1743,15 @@ var SandboxInstance = class SandboxInstance {
 	*/
 	async write(path, content, options) {
 		await this.ensureRunning();
-		const response = await this.runtimeFetch("/files/write", {
+		const params = new URLSearchParams();
+		if (options?.sessionId) params.set("sessionId", options.sessionId);
+		const query = params.toString();
+		const response = await this.runtimeFetch(`/files/write${query ? `?${query}` : ""}`, {
 			method: "POST",
 			body: JSON.stringify({
 				path,
 				content,
+				encoding: options?.encoding,
 				mode: options?.mode
 			})
 		});
@@ -1431,6 +1759,7 @@ var SandboxInstance = class SandboxInstance {
 			const body = await response.text();
 			throw parseErrorResponse(response.status, body, void 0, response.headers);
 		}
+		return (await response.json()).data;
 	}
 	/**
 	* Write many files in one paced, retry-aware batch — see
@@ -1531,6 +1860,13 @@ var SandboxInstance = class SandboxInstance {
 			controller.abort();
 		}
 	}
+	logStreamCheckpoint(checkpoint, data = {}) {
+		if (globalThis.process?.env?.TANGLE_SANDBOX_SDK_STREAM_DEBUG !== "1") return;
+		console.debug("[sandbox-sdk] stream checkpoint", {
+			checkpoint,
+			...data
+		});
+	}
 	/**
 	* Stream events from an agent prompt.
 	* Use this for real-time updates during agent execution.
@@ -1562,16 +1898,27 @@ var SandboxInstance = class SandboxInstance {
 			}
 		} catch (err) {
 			if (isCallerAbort()) return;
+			this.logStreamCheckpoint("synthetic_error", {
+				sessionId,
+				executionId,
+				error: err instanceof Error ? err.message : String(err)
+			});
 			yield toStreamErrorEvent(err);
 		} finally {
-			if (!receivedTerminal && !isCallerAbort()) yield {
-				type: "done",
-				data: {
-					status: "failed",
-					...sessionId ? { sessionId } : {},
-					...executionId ? { executionId } : {}
-				}
-			};
+			if (!receivedTerminal && !isCallerAbort()) {
+				this.logStreamCheckpoint("synthetic_terminal", {
+					sessionId,
+					executionId
+				});
+				yield {
+					type: "done",
+					data: {
+						status: "failed",
+						...sessionId ? { sessionId } : {},
+						...executionId ? { executionId } : {}
+					}
+				};
+			}
 		}
 	}
 	/**
@@ -1593,8 +1940,22 @@ var SandboxInstance = class SandboxInstance {
 				origin: "runtime"
 			});
 		};
+		const streamStartedAt = Date.now();
+		const logStreamCheckpoint = (checkpoint, data = {}) => {
+			this.logStreamCheckpoint(checkpoint, {
+				elapsedMs: Date.now() - streamStartedAt,
+				...data
+			});
+		};
 		let response;
 		try {
+			logStreamCheckpoint("runtime_post_start", {
+				endpoint: "/agents/run/stream",
+				sessionId: options?.sessionId,
+				executionId: options?.executionId,
+				hasLastEventId: Boolean(options?.lastEventId),
+				detach: options?.detach === true
+			});
 			response = await this.runtimeFetch("/agents/run/stream", {
 				method: "POST",
 				signal: streamSignal,
@@ -1610,11 +1971,17 @@ var SandboxInstance = class SandboxInstance {
 					turnId: options?.turnId,
 					metadata: options?.context,
 					requireVisibleAssistantOutput: options?.requireVisibleAssistantOutput,
+					...timeoutMs ? { timeoutMs } : {},
 					...options?.detach ? { detach: true } : {},
 					backend: normalizeRuntimeBackendConfig(options?.backend ?? this.defaultRuntimeBackend, { model: options?.model })
 				})
 			});
+			logStreamCheckpoint("runtime_response_headers", {
+				status: response.status,
+				ok: response.ok
+			});
 		} catch (err) {
+			logStreamCheckpoint("runtime_post_failed", { error: err instanceof Error ? err.message : String(err) });
 			throwIfTimedOut();
 			throw err;
 		}
@@ -1637,17 +2004,39 @@ var SandboxInstance = class SandboxInstance {
 		const MAX_RECONNECT_ATTEMPTS = RECONNECT_BACKOFF_MS.length;
 		let lastReplayStatus;
 		let lastExecutionStatus;
+		let firstSseEventSeen = false;
 		for await (const event of this.parseSSEStream(response, streamSignal)) {
+			if (!firstSseEventSeen) {
+				firstSseEventSeen = true;
+				logStreamCheckpoint("first_sse_event", {
+					eventType: event.type,
+					eventId: event.id
+				});
+			}
 			if (event.id) lastEventId = event.id;
 			if (event.type === "execution.started" && event.data?.executionId) executionId = event.data.executionId;
 			const eventSessionId = event.data?.sessionId;
 			if (typeof eventSessionId === "string" && eventSessionId.length > 0) sessionId = eventSessionId;
-			if (event.type === "result" || event.type === "done") receivedTerminal = true;
+			if (event.type === "result" || event.type === "done") {
+				receivedTerminal = true;
+				logStreamCheckpoint("terminal_event", {
+					eventType: event.type,
+					eventId: event.id,
+					sessionId,
+					executionId
+				});
+			}
 			yield event;
 		}
 		if (receivedTerminal) return;
 		throwIfTimedOut();
 		if (options?.signal?.aborted || streamSignal?.aborted) return;
+		logStreamCheckpoint("stream_drop", {
+			executionId,
+			sessionId,
+			lastEventId,
+			receivedTerminal
+		});
 		if (!executionId) throw new NetworkError("Prompt stream dropped before execution.started; cannot reconnect", {
 			endpoint: "/agents/run/stream",
 			origin: "runtime"
@@ -1656,6 +2045,12 @@ var SandboxInstance = class SandboxInstance {
 			throwIfTimedOut();
 			if (options?.signal?.aborted || streamSignal?.aborted) return;
 			console.warn(`[sandbox-sdk] Stream dropped without terminal event, reconnecting (attempt ${attempt}/${MAX_RECONNECT_ATTEMPTS})`);
+			logStreamCheckpoint("reconnect_attempt_start", {
+				attempt,
+				executionId,
+				sessionId,
+				lastEventId
+			});
 			await new Promise((resolve) => setTimeout(resolve, RECONNECT_BACKOFF_MS[attempt - 1]));
 			throwIfTimedOut();
 			if (options?.signal?.aborted || streamSignal?.aborted) return;
@@ -1665,6 +2060,11 @@ var SandboxInstance = class SandboxInstance {
 					method: "GET",
 					signal: streamSignal
 				});
+				logStreamCheckpoint("replay_response_status", {
+					attempt,
+					status: replayResponse.status,
+					ok: replayResponse.ok
+				});
 				if (!replayResponse.ok) {
 					lastReplayStatus = replayResponse.status;
 					console.warn(`[sandbox-sdk] Replay endpoint returned ${replayResponse.status}, attempt ${attempt}`);
@@ -1674,6 +2074,13 @@ var SandboxInstance = class SandboxInstance {
 							lastExecutionStatus = info.status;
 							if (info.status === "completed" || info.status === "failed" || info.status === "cancelled") {
 								console.warn(`[sandbox-sdk] Replay 404 but session ${sessionId} is terminal (${info.status}); ending stream gracefully`);
+								logStreamCheckpoint("terminal_event", {
+									eventType: "done",
+									synthetic: true,
+									reason: "replay_unavailable_terminal_session",
+									sessionId,
+									executionId
+								});
 								yield {
 									type: "done",
 									data: {
@@ -1692,18 +2099,46 @@ var SandboxInstance = class SandboxInstance {
 					continue;
 				}
 				for await (const event of this.parseSSEStream(replayResponse, streamSignal)) {
+					if (!firstSseEventSeen) {
+						firstSseEventSeen = true;
+						logStreamCheckpoint("first_sse_event", {
+							eventType: event.type,
+							eventId: event.id,
+							replay: true
+						});
+					}
 					if (event.type === "history.replay.start" || event.type === "history.replay.end") continue;
 					if (event.id) lastEventId = event.id;
 					const eventSessionId = event.data?.sessionId;
 					if (typeof eventSessionId === "string" && eventSessionId.length > 0) sessionId = eventSessionId;
-					if (event.type === "result" || event.type === "done") receivedTerminal = true;
+					if (event.type === "result" || event.type === "done") {
+						receivedTerminal = true;
+						logStreamCheckpoint("terminal_event", {
+							eventType: event.type,
+							eventId: event.id,
+							replay: true,
+							sessionId,
+							executionId
+						});
+					}
 					yield event;
 				}
-				if (receivedTerminal) return;
+				if (receivedTerminal) {
+					logStreamCheckpoint("reconnect_attempt_end", {
+						attempt,
+						status: "terminal_received"
+					});
+					return;
+				}
 				throwIfTimedOut();
 				if (options?.signal?.aborted || streamSignal?.aborted) return;
 			} catch (err) {
 				throwIfTimedOut();
+				logStreamCheckpoint("reconnect_attempt_end", {
+					attempt,
+					status: "failed",
+					error: err instanceof Error ? err.message : String(err)
+				});
 				console.warn(`[sandbox-sdk] Reconnection attempt ${attempt} failed: ${err instanceof Error ? err.message : String(err)}`);
 			}
 		}
@@ -2015,6 +2450,22 @@ var SandboxInstance = class SandboxInstance {
 			after: match.after
 		};
 	}
+	/** Basic health reported by the runtime inside this sandbox. */
+	async runtimeHealth() {
+		return this.runtime.health();
+	}
+	/** Return the runtime's current listening-port snapshot. */
+	async ports() {
+		return this.runtime.ports();
+	}
+	/** Interactive terminal operations for this runtime. */
+	get terminals() {
+		return this.runtime.terminals;
+	}
+	/** List profiles installed in this sandbox runtime. */
+	async listProfiles() {
+		return this.runtime.profiles();
+	}
 	/**
 	* Live whole-sandbox resource usage (memory + CPU) from the container cgroup.
 	*
@@ -2249,6 +2700,8 @@ var SandboxInstance = class SandboxInstance {
 		return {
 			supportsWriteMode: true,
 			read: (path) => this.read(path),
+			readBatch: (paths, options) => this.fsReadBatch(paths, options),
+			tree: (path, options) => this.fsTree(path, options),
 			write: (path, content, options) => this.write(path, content, options),
 			writeMany: (files, options) => this.writeMany(files, options),
 			search: (query, options) => this.search(query, options),
@@ -2263,6 +2716,12 @@ var SandboxInstance = class SandboxInstance {
 			exists: (path) => this.fsExists(path)
 		};
 	}
+	async fsReadBatch(paths, options = {}) {
+		return this.runtime.readFiles(paths, options);
+	}
+	async fsTree(path, options = {}) {
+		return this.runtime.fileTree(path, options);
+	}
 	async fsUpload(localPath, remotePath, options) {
 		await this.ensureRunning();
 		const fs = await import("node:fs/promises");
@@ -2369,6 +2828,7 @@ var SandboxInstance = class SandboxInstance {
 		const params = new URLSearchParams();
 		if (options?.all) params.set("all", "true");
 		if (options?.long) params.set("long", "true");
+		if (options?.sessionId) params.set("sessionId", options.sessionId);
 		const query = params.toString();
 		const url = query ? `/fs/list${path}?${query}` : `/fs/list${path}`;
 		const response = await this.runtimeFetch(url, { method: "GET" });
@@ -2414,8 +2874,21 @@ var SandboxInstance = class SandboxInstance {
 	}
 	async fsDelete(path, options) {
 		await this.ensureRunning();
+		if (options?.sessionId && !options.recursive) {
+			const params = new URLSearchParams({ sessionId: options.sessionId });
+			const response = await this.runtimeFetch(`/files/delete?${params}`, {
+				method: "POST",
+				body: JSON.stringify({ path })
+			});
+			if (!response.ok) {
+				const body = await response.text();
+				throw parseErrorResponse(response.status, body, void 0, response.headers);
+			}
+			return;
+		}
 		const params = new URLSearchParams();
 		if (options?.recursive) params.set("recursive", "true");
+		if (options?.sessionId) params.set("sessionId", options.sessionId);
 		const query = params.toString();
 		const url = query ? `/fs${path}?${query}` : `/fs${path}`;
 		const response = await this.runtimeFetch(url, { method: "DELETE" });
@@ -3046,6 +3519,20 @@ var SandboxInstance = class SandboxInstance {
 			update: (policy) => this.egressUpdate(policy)
 		};
 	}
+	/**
+	* On-demand GPU leases attached to this sandbox.
+	*
+	* The base sandbox stays cheap; `attach` starts a temporary external GPU
+	* worker with an explicit spend cap, and `detach` destroys it.
+	*/
+	get gpu() {
+		return {
+			attach: (options) => this.gpuAttach(options),
+			list: () => this.gpuList(),
+			exec: (leaseId, options) => this.gpuExec(leaseId, options),
+			detach: (leaseId) => this.gpuDetach(leaseId)
+		};
+	}
 	async networkUpdate(config) {
 		if (config.blockOutbound !== void 0 && config.allowList !== void 0) {
 			if (config.blockOutbound && config.allowList.length > 0) throw new Error("blockOutbound and allowList are mutually exclusive");
@@ -3123,6 +3610,44 @@ var SandboxInstance = class SandboxInstance {
 			source: data.source
 		};
 	}
+	async gpuAttach(options) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).lease;
+	}
+	async gpuList() {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases`);
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).leases ?? [];
+	}
+	async gpuExec(leaseId, options) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases/${encodeURIComponent(leaseId)}/exec`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return await response.json();
+	}
+	async gpuDetach(leaseId) {
+		const response = await this.client.fetch(`/v1/sandboxes/${encodeURIComponent(this.id)}/gpu/leases/${encodeURIComponent(leaseId)}`, { method: "DELETE" });
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		return (await response.json()).lease;
+	}
 	/**
 	* Validate CIDR notation (IPv4 and IPv6)
 	*/
@@ -3523,132 +4048,60 @@ var SandboxInstance = class SandboxInstance {
 		};
 	}
 	/**
-	* Create a CRIU checkpoint of the sandbox's memory state.
-	*
-	* Checkpoints capture the complete memory state of the running sandbox,
-	* enabling true pause/resume and fork operations. Unlike snapshots which
-	* only preserve filesystem state, checkpoints preserve process memory,
-	* open file descriptors, and execution state.
-	*
-	* **Requirements:** CRIU must be available on the host. Check availability
-	* with `client.criuStatus()` before calling.
-	*
-	* **Note:** By default, checkpoint stops the sandbox. Use `leaveRunning: true`
-	* to keep it running (creates a copy-on-write checkpoint).
-	*
-	* @param options - Checkpoint options
-	* @returns Checkpoint result with ID and metadata
-	*
-	* @example Basic checkpoint (stops sandbox)
-	* ```typescript
-	* const checkpoint = await box.checkpoint();
-	* console.log(`Checkpoint: ${checkpoint.checkpointId}`);
-	* // Sandbox is now stopped, resume with box.resume()
-	* ```
-	*
-	* @example Checkpoint without stopping
-	* ```typescript
-	* const checkpoint = await box.checkpoint({
-	*   tags: ["before-deploy"],
-	*   leaveRunning: true,
-	* });
-	* // Sandbox continues running
-	* ```
+	* @deprecated CRIU checkpoints were removed. To branch live memory into
+	* copy-on-write children of a running sandbox use {@link branch}; for durable
+	* filesystem state use {@link snapshot}. This method now throws.
 	*/
-	async checkpoint(options) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints`, {
-			method: "POST",
-			body: JSON.stringify({
-				tags: options?.tags,
-				leaveRunning: options?.leaveRunning,
-				includeSnapshot: options?.includeSnapshot
-			})
-		});
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
-		const data = await response.json();
-		return {
-			checkpointId: data.checkpointId ?? data.id,
-			createdAt: new Date(data.createdAt ?? ""),
-			sizeBytes: data.sizeBytes,
-			tags: data.tags ?? []
-		};
+	checkpoint() {
+		throw new CapabilityError("checkpoint() was removed: use branch() to fork live memory into copy-on-write children, or snapshot() for durable disk state", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* List all checkpoints for this sandbox.
-	*
-	* @returns Array of checkpoint metadata
-	*
-	* @example
-	* ```typescript
-	* const checkpoints = await box.listCheckpoints();
-	* for (const cp of checkpoints) {
-	*   console.log(`${cp.checkpointId}: ${cp.createdAt}`);
-	* }
-	* ```
+	* @deprecated CRIU checkpoints were removed. List durable filesystem state
+	* with {@link listSnapshots}. This method now throws.
 	*/
-	async listCheckpoints() {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints`);
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
-		const data = await response.json();
-		return (Array.isArray(data) ? data : data.checkpoints ?? []).map((cp) => this.parseCheckpointInfo(cp));
+	listCheckpoints() {
+		throw new CapabilityError("listCheckpoints() was removed: checkpoints no longer exist; use listSnapshots() for durable disk state", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* Delete a checkpoint.
-	*
-	* @param checkpointId - ID of the checkpoint to delete
+	* @deprecated CRIU checkpoints were removed. This method now throws.
 	*/
-	async deleteCheckpoint(checkpointId) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/checkpoints/${encodeURIComponent(checkpointId)}`, { method: "DELETE" });
-		if (!response.ok) {
-			const body = await response.text();
-			throw parseErrorResponse(response.status, body, void 0, response.headers);
-		}
+	deleteCheckpoint() {
+		throw new CapabilityError("deleteCheckpoint() was removed: checkpoints no longer exist", "CHECKPOINT_REMOVED", 410);
 	}
 	/**
-	* Fork a new sandbox from a checkpoint.
-	*
-	* Creates a new sandbox with the same memory state as this sandbox
-	* at the time of the checkpoint. The fork has a new identity but
-	* preserves the execution state.
-	*
-	* **Use cases:**
-	* - Branch workflows: Create parallel execution paths
-	* - A/B testing: Run same state with different configurations
-	* - Debugging: Fork at a specific point to investigate
+	* @deprecated Forking from a CRIU checkpoint was removed. Use {@link branch}
+	* to fork a running sandbox's live memory into copy-on-write children, or
+	* `client.create({ fromSnapshot })` to provision from durable disk state.
+	* This method now throws.
+	*/
+	fork() {
+		throw new CapabilityError("fork() was removed: use branch() to fork live memory into copy-on-write children, or create({ fromSnapshot }) for durable disk state", "FORK_REMOVED", 410);
+	}
+	/**
+	* Branch this RUNNING sandbox into `count` copy-on-write children
+	* (Morph Infinibranch parity). Unlike {@link fork} — which rehydrates one
+	* sandbox from a CRIU checkpoint — branch forks the live VM's memory into
+	* many children at once via Firecracker UFFD copy-on-write: the children
+	* share the parent's clean pages instead of each copying full guest
+	* memory. The parent stays running.
 	*
-	* @param checkpointId - ID of the checkpoint to fork from
-	* @param options - Fork configuration
-	* @returns The new sandbox instance
+	* @param count - Number of children to create (must be >= 1).
+	* @param options - Per-child overrides.
+	* @returns Exactly `count` new sandbox instances.
 	*
-	* @example Basic fork
-	* ```typescript
-	* const checkpoint = await box.checkpoint({ leaveRunning: true });
-	* const forked = await box.fork(checkpoint.checkpointId);
-	* // forked has same memory state as box at checkpoint time
-	* ```
-	*
-	* @example Fork with custom config
+	* @example
 	* ```typescript
-	* const forked = await box.fork(checkpointId, {
-	*   name: "experiment-branch",
-	*   env: { EXPERIMENT: "true" },
-	* });
+	* const [a, b, c] = await box.branch(3);
+	* // a, b, c each share box's memory state at branch time
 	* ```
 	*/
-	async fork(checkpointId, options) {
-		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/fork`, {
+	async branch(count, options) {
+		if (!Number.isInteger(count) || count < 1) throw new ValidationError(`branch count must be an integer >= 1 (got ${count})`);
+		const response = await this.client.fetch(`/v1/sandboxes/${this.id}/branch`, {
 			method: "POST",
 			body: JSON.stringify({
-				checkpointId,
-				name: options?.name,
+				count,
 				env: options?.env,
-				resources: options?.resources,
 				metadata: options?.metadata
 			})
 		});
@@ -3656,8 +4109,7 @@ var SandboxInstance = class SandboxInstance {
 			const body = await response.text();
 			throw parseErrorResponse(response.status, body, void 0, response.headers);
 		}
-		const data = await response.json();
-		return new SandboxInstance(this.client, this.parseInfo(data.sandbox ?? data), this.defaultRuntimeBackend);
+		return ((await response.json()).children ?? []).map((child) => new SandboxInstance(this.client, this.parseInfo(child), this.defaultRuntimeBackend));
 	}
 	/**
 	* Stop the sandbox (keeps state for resume).
@@ -3894,17 +4346,6 @@ var SandboxInstance = class SandboxInstance {
 			abortController.abort();
 		}
 	}
-	parseCheckpointInfo(cp) {
-		return {
-			checkpointId: cp.checkpointId ?? cp.id,
-			sandboxId: cp.sandboxId ?? cp.projectRef ?? this.id,
-			createdAt: new Date(cp.createdAt),
-			tags: cp.tags ?? [],
-			sizeBytes: cp.sizeBytes,
-			hasMemoryState: cp.hasMemoryState ?? true,
-			hasFilesystemSnapshot: cp.hasFilesystemSnapshot ?? false
-		};
-	}
 	async ensureRunning() {
 		await this.refresh();
 		if (this.status !== "running") throw new StateError(`Sandbox is not running (status: ${this.status})`, this.status, "running");
@@ -3956,15 +4397,51 @@ var SandboxInstance = class SandboxInstance {
 	async registerSessionMapping(opts) {
 		const response = await this.client.fetch(`/v1/session/${encodeURIComponent(opts.sessionId)}/mapping`, {
 			method: "PUT",
+			headers: { "x-user-id": opts.userId },
 			body: JSON.stringify({
-				userId: opts.userId,
-				sandboxId: this.id
+				sidecarSessionId: opts.runtimeSessionId,
+				...opts.sidecarId ? { sidecarId: opts.sidecarId } : {},
+				...opts.projectRef ? { projectRef: opts.projectRef } : {}
 			})
 		});
+		if (response.status === 410) return {
+			success: false,
+			sessionId: opts.sessionId,
+			reprovisionRequired: true,
+			code: "STALE_SIDECAR"
+		};
 		if (!response.ok) {
 			const body = await response.text();
 			throw parseErrorResponse(response.status, body, void 0, response.headers);
 		}
+		const data = await response.json().catch(() => ({}));
+		return {
+			success: data.success ?? true,
+			sessionId: data.sessionId ?? opts.sessionId,
+			sidecarSessionId: data.sidecarSessionId,
+			reprovisionRequired: data.reprovisionRequired ?? false,
+			code: data.code
+		};
+	}
+	/**
+	* Remove the sidecar session mapping for an agent session. Sandbox deletion
+	* also cleans mappings, so this is only needed to release a mapping while the
+	* sandbox stays alive.
+	*/
+	async unregisterSessionMapping(opts) {
+		const response = await this.client.fetch(`/v1/session/${encodeURIComponent(opts.sessionId)}/mapping`, {
+			method: "DELETE",
+			headers: { "x-user-id": opts.userId }
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			throw parseErrorResponse(response.status, body, void 0, response.headers);
+		}
+		const data = await response.json().catch(() => ({}));
+		return {
+			success: data.success ?? true,
+			sessionId: data.sessionId ?? opts.sessionId
+		};
 	}
 	parseInfo(data) {
 		return {
@@ -3978,6 +4455,7 @@ var SandboxInstance = class SandboxInstance {
 			lastActivityAt: data.lastActivityAt ? new Date(data.lastActivityAt) : void 0,
 			expiresAt: data.expiresAt ? new Date(data.expiresAt) : void 0,
 			error: data.error,
+			gpuLease: data.gpuLease ?? this.info.gpuLease,
 			startupDiagnostics: normalizeStartupDiagnostics(data.startupDiagnostics) ?? this.info?.startupDiagnostics
 		};
 	}
@@ -3992,6 +4470,30 @@ var SandboxInstance = class SandboxInstance {
 	session(id) {
 		return new SandboxSession(this, id);
 	}
+	/** Create an agent session and return both its handle and initial metadata. */
+	async createSession(options) {
+		const info = await this.runtime.createSession(options);
+		return {
+			session: this.session(info.id),
+			info
+		};
+	}
+	/** Delete an agent session by id. */
+	async deleteSession(id) {
+		return this._sessionDelete(id);
+	}
+	/** Get a lazy background-task session reference. */
+	taskSession(id) {
+		return new SandboxTaskSession(this, id);
+	}
+	/** Create a background task session. Dispatch work with `session.sendMessage()`. */
+	async createTaskSession(options) {
+		const info = await this.runtime.createTaskSession(options);
+		return {
+			session: this.taskSession(info.id),
+			info
+		};
+	}
 	/**
 	* List sessions on this sandbox, optionally filtering by status. Returns
 	* `SandboxSession` instances paired with their last-known
@@ -4099,6 +4601,44 @@ var SandboxInstance = class SandboxInstance {
 			metadata: m.info.metadata
 		}));
 	}
+	/** @internal — invoked by SandboxSession.sendMessage(). */
+	async _sessionSendMessage(id, request, options = {}) {
+		return this.runtime.sendSessionMessage(id, request, options);
+	}
+	/** @internal — invoked by SandboxSession.delete(). */
+	async _sessionDelete(id) {
+		return this.runtime.deleteSession(id);
+	}
+	/** @internal — invoked by SandboxTaskSession.changes(). */
+	async _taskSessionChanges(id) {
+		return this.runtime.taskSessionChanges(id);
+	}
+	/** @internal — invoked by SandboxTaskSession.commit(). */
+	async _taskSessionCommit(id, options = {}) {
+		return this.runtime.commitTaskSession(id, options);
+	}
+	async _sessionFork(id, opts = {}) {
+		await this.ensureRunning();
+		const body = {};
+		if (opts.messageId !== void 0) body.messageID = opts.messageId;
+		if (opts.targetBackend !== void 0) body.targetBackend = opts.targetBackend;
+		if (opts.targetModel !== void 0) body.targetModel = opts.targetModel;
+		if (opts.files !== void 0) body.files = opts.files;
+		const response = await this.runtimeFetch(`/agents/sessions/${encodeURIComponent(id)}/forks`, {
+			method: "POST",
+			body: JSON.stringify(body)
+		});
+		if (!response.ok) {
+			const responseBody = await response.text();
+			throw parseErrorResponse(response.status, responseBody, void 0, response.headers);
+		}
+		const info = normalizeSessionInfo(await response.json());
+		if (!info) throw new ServerError("Session fork response missing session id", 502, {
+			origin: "runtime",
+			endpoint: `/agents/sessions/${encodeURIComponent(id)}/forks`
+		});
+		return info;
+	}
 	/**
 	* Look up a cached turn result by idempotency key. Returns the cached
 	* payload if a turn with this `turnId` previously completed on the
@@ -4441,28 +4981,6 @@ function settleTurnDrive(result) {
 		result
 	};
 }
-function normalizeSessionInfo(raw) {
-	const id = raw.id;
-	if (typeof id !== "string") return null;
-	const status = raw.status || "running";
-	return {
-		id,
-		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
-	};
-}
 var DirectRuntimeHttpClient = class {
 	baseClient;
 	sandboxId;
@@ -4529,4 +5047,4 @@ function quoteForShell(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 //#endregion
-export { collectAgentResponseText as a, buildTraceExportPayload as c, toOtelJson as d, encodePromptForWire as f, serializeForSidecar as h, applySandboxEventText as i, exportTraceBundle as l, normalizeRuntimeBackendConfig as m, SandboxSession as n, getSandboxEventText as o, parseSSEStream as p, InteractiveSessionHandle as r, normalizeConnection as s, SandboxInstance as t, otelTraceIdForTangleTrace as u };
+export { normalizeRuntimeBackendConfig as _, InteractiveSessionHandle as a, getSandboxEventText as c, exportTraceBundle as d, otelTraceIdForTangleTrace as f, parseSSEStream as g, encodeTextForWire as h, SandboxSession as i, normalizeConnection as l, encodePromptForWire as m, normalizeStartupDiagnostics as n, applySandboxEventText as o, toOtelJson as p, SandboxTaskSession as r, collectAgentResponseText as s, SandboxInstance as t, buildTraceExportPayload as u, serializeForSidecar as v };