@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/environment-provider-CfLUmKmf.js

@@ -0,0 +1,1168 @@
+import { f as zeroTokenUsage } from "./util-MVgdwuIS.js";
+import { isDeepStrictEqual } from "node:util";
+//#region src/runtime/tangle-sandbox-exact-process-provider.ts
+const exactProcessProviderMarker = "agent-runtime.exact-process-provider";
+const exactProcessEgressMarker = "agent-runtime.exact-process-egress";
+/**
+* Adapt Tangle Sandbox's managed control runtime to Runtime's exact-process provider.
+*
+* The adapter deliberately exposes no ordinary agent environment: an exact experiment
+* must start a fresh Sandbox with no managed agent and launch its declared argv directly.
+*/
+function createTangleSandboxExactProcessProvider(client, options = {}) {
+	const name = options.name ?? "tangle-sandbox-exact-process";
+	if (!name.trim()) throw new Error("Tangle Sandbox exact-process provider name must not be empty");
+	return {
+		name,
+		exactProcess: {
+			async create(input) {
+				throwIfAborted(input.signal);
+				assertNoProviderOptions(input.providerOptions);
+				const egressPolicy = sandboxEgressPolicy(input.egress);
+				const metadata = exactMetadata(input.metadata, name, egressPolicy);
+				const sandbox = await client.create({
+					environment: requiredText(input.image, "exact-process image"),
+					agent: false,
+					bare: false,
+					ephemeral: true,
+					egressPolicy,
+					resources: sandboxResources(input),
+					maxLifetimeSeconds: sandboxLifetimeSeconds(input.maxLifetimeMs),
+					metadata,
+					idempotencyKey: requiredText(input.idempotencyKey, "exact-process idempotency key")
+				}, {
+					...input.provisionTimeoutMs === void 0 ? {} : { timeoutMs: positiveInteger(input.provisionTimeoutMs, "provision timeout") },
+					...input.signal === void 0 ? {} : { signal: input.signal }
+				});
+				try {
+					throwIfAborted(input.signal);
+					assertExactSandboxMetadata(sandbox, metadata);
+					await assertExactSandboxEgress(sandbox, egressPolicy);
+				} catch (error) {
+					await discardInvalidSandbox(sandbox, error);
+				}
+				return sandboxAsExactProcessEnvironment(sandbox, name);
+			},
+			async get(id) {
+				const sandbox = await client.get(id);
+				if (!sandbox || !isExactSandbox(sandbox, name)) return null;
+				await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
+				return sandboxAsExactProcessEnvironment(sandbox, name);
+			},
+			async list(query) {
+				assertNoProviderOptions(query?.providerOptions);
+				const sandboxes = await client.list();
+				return Promise.all(sandboxes.filter((sandbox) => isExactSandbox(sandbox, name)).filter((sandbox) => metadataMatches(sandbox.metadata, query?.metadata)).map(async (sandbox) => {
+					await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
+					return sandboxAsExactProcessEnvironment(sandbox, name);
+				}));
+			}
+		},
+		capabilities: exactProcessOnlyCapabilities,
+		async create() {
+			throw new Error(`agent environment provider "${name}" supports exactProcess.create() only`);
+		}
+	};
+}
+function sandboxAsExactProcessEnvironment(sandbox, provider) {
+	return {
+		id: requiredText(sandbox.id, "Sandbox id"),
+		provider,
+		...sandbox.metadata ? { metadata: sandbox.metadata } : {},
+		process: {
+			async list() {
+				return (await sandbox.process.list()).map((status) => exactProcessStatus(status));
+			},
+			async get(pid) {
+				const process = await sandbox.process.get(pid);
+				return process ? sandboxProcessAsExactProcess(process) : null;
+			},
+			async spawn(input, options) {
+				return sandboxProcessAsExactProcess(await afterAbortCheck(options?.signal, () => sandbox.process.spawnExact(input.executable, [...input.args], {
+					cwd: input.cwd,
+					env: { ...input.env },
+					inheritEnv: false,
+					...input.stdin === void 0 ? {} : { stdin: input.stdin },
+					timeoutMs: input.timeoutMs
+				})));
+			}
+		},
+		async writeFile(path, bytes, options) {
+			if (sandbox.fs.supportsWriteMode !== true) throw new Error("Tangle Sandbox does not declare exact file-mode support");
+			await afterAbortCheck(options.signal, () => sandbox.fs.write(path, Buffer.from(bytes).toString("base64"), {
+				encoding: "base64",
+				mode: fileMode(options.mode)
+			}));
+		},
+		async readFile(path, options) {
+			const maxBytes = nonnegativeInteger(options.maxBytes, "exact-process file read maximum");
+			const initialSize = nonnegativeInteger((await afterAbortCheck(options.signal, () => sandbox.fs.stat(path))).size, `Tangle Sandbox file size for "${path}"`);
+			if (initialSize > maxBytes) throw new Error(`Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`);
+			const result = await afterAbortCheck(options.signal, () => sandbox.fs.readBatch([path], { encoding: "base64" }));
+			const failure = result.errors.find((entry) => entry.path === path);
+			if (failure) throw new Error(`Tangle Sandbox failed to read "${path}": ${failure.error}`);
+			const files = result.files.filter((entry) => entry.path === path);
+			if (files.length !== 1) throw new Error(`Tangle Sandbox returned ${files.length} files for exact read "${path}"`);
+			const file = files[0];
+			if (file.encoding !== "base64") throw new Error(`Tangle Sandbox returned non-binary content for exact read "${path}"`);
+			const size = nonnegativeInteger(file.size, `Tangle Sandbox file size for "${path}"`);
+			if (size !== initialSize) throw new Error(`Tangle Sandbox file "${path}" changed during exact read`);
+			if (size > maxBytes) throw new Error(`Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`);
+			const bytes = Buffer.from(file.content, "base64");
+			if (bytes.byteLength !== size || bytes.toString("base64") !== file.content) throw new Error(`Tangle Sandbox returned an invalid binary payload for exact read "${path}"`);
+			return Uint8Array.from(bytes);
+		},
+		async destroy() {
+			await sandbox.delete();
+		}
+	};
+}
+function sandboxProcessAsExactProcess(process) {
+	const pid = positiveInteger(process.pid, "Tangle Sandbox process pid");
+	return {
+		pid,
+		async status() {
+			return exactProcessStatus(await process.status(), pid);
+		},
+		async wait() {
+			const waitExitCode = await process.wait();
+			if (!Number.isSafeInteger(waitExitCode)) throw new Error("Tangle Sandbox process wait returned an invalid exit code");
+			const status = exactProcessStatus(await process.status(), pid);
+			if (status.running || !status.termination) throw new Error("Tangle Sandbox process wait returned before terminal status");
+			if (status.termination.kind === "exit" && status.termination.exitCode !== waitExitCode) throw new Error("Tangle Sandbox process wait and status disagree on exit code");
+			return status.termination;
+		},
+		async kill() {
+			await process.kill("SIGKILL", { tree: true });
+		},
+		async *stdout() {
+			yield* process.stdout();
+		},
+		async *stderr() {
+			yield* process.stderr();
+		}
+	};
+}
+function exactProcessStatus(status, expectedPid) {
+	const pid = positiveInteger(status.pid, "Tangle Sandbox process pid");
+	if (expectedPid !== void 0 && pid !== expectedPid) throw new Error("Tangle Sandbox process status changed process identity");
+	if (typeof status.running !== "boolean") throw new Error("Tangle Sandbox process status is missing running state");
+	if (!Number.isSafeInteger(status.exitCode)) throw new Error("Tangle Sandbox process status is missing an integer exit code");
+	const exitSignal = optionalText(status.exitSignal, "Tangle Sandbox process exit signal");
+	if (status.running) {
+		if (status.exitCode !== -1) throw new Error("Tangle Sandbox running process must report exit code -1");
+		if (exitSignal) throw new Error("Tangle Sandbox running process must not report an exit signal");
+		return {
+			pid,
+			running: true,
+			exitCode: -1
+		};
+	}
+	const termination = exitSignal ? {
+		kind: "signal",
+		signal: exitSignal
+	} : status.exitCode >= 0 ? {
+		kind: "exit",
+		exitCode: status.exitCode
+	} : void 0;
+	if (!termination) throw new Error("Tangle Sandbox stopped process has no terminal reason");
+	return {
+		pid,
+		running: false,
+		exitCode: status.exitCode,
+		...exitSignal ? { exitSignal } : {},
+		termination
+	};
+}
+function exactMetadata(metadata, provider, egressPolicy) {
+	for (const marker of [exactProcessProviderMarker, exactProcessEgressMarker]) if (Object.hasOwn(metadata, marker)) throw new Error(`exact-process metadata must not set "${marker}"`);
+	return {
+		...metadata,
+		[exactProcessProviderMarker]: provider,
+		[exactProcessEgressMarker]: serializeEgressPolicy(egressPolicy)
+	};
+}
+function isExactSandbox(sandbox, provider) {
+	return sandbox.metadata?.[exactProcessProviderMarker] === provider;
+}
+function metadataMatches(metadata, expected) {
+	return expected === void 0 || Object.entries(expected).every(([key, value]) => isDeepStrictEqual(metadata?.[key], value));
+}
+function assertExactSandboxMetadata(sandbox, expected) {
+	if (!metadataMatches(sandbox.metadata, expected)) throw new Error("Tangle Sandbox did not persist exact-process metadata");
+}
+function egressFromMetadata(metadata) {
+	const encoded = metadata?.[exactProcessEgressMarker];
+	if (typeof encoded !== "string") throw new Error("Tangle Sandbox exact-process environment is missing egress metadata");
+	try {
+		const parsed = JSON.parse(encoded);
+		if (!parsed || typeof parsed !== "object") throw new Error("expected egress object");
+		const policy = parsed;
+		if (policy.mode === "blocked" && policy.allowDomains === void 0) return { mode: "blocked" };
+		if (policy.mode === "strict" && policy.includeImplicitDomains === false && Array.isArray(policy.allowDomains) && policy.allowDomains.every((domain) => typeof domain === "string")) {
+			const allowDomains = sortedDomains(policy.allowDomains);
+			if (new Set(allowDomains).size === allowDomains.length) return {
+				mode: "strict",
+				allowDomains,
+				includeImplicitDomains: false
+			};
+		}
+	} catch {
+		throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
+	}
+	throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
+}
+async function assertExactSandboxEgress(sandbox, expected) {
+	const actual = (await sandbox.egress.get()).policy;
+	if (actual.mode !== expected.mode) throw new Error(`Tangle Sandbox egress mismatch: expected ${expected.mode}, received ${actual.mode}`);
+	if (expected.mode === "blocked") {
+		const allowDomains = actual.allowDomains;
+		if (actual.mode === "blocked" && (allowDomains === void 0 || Array.isArray(allowDomains) && allowDomains.length === 0)) return;
+		throw new Error("Tangle Sandbox blocked egress retained an allowlist");
+	}
+	if (actual.mode !== "strict") throw new Error("Tangle Sandbox did not return strict egress policy");
+	const expectedDomains = sortedDomains(expected.allowDomains);
+	if (!isDeepStrictEqual(sortedDomains(actual.allowDomains ?? []), expectedDomains)) throw new Error("Tangle Sandbox strict egress differs from the exact allowlist");
+	if (actual.includeImplicitDomains !== false) throw new Error("Tangle Sandbox strict egress retained implicit domains");
+}
+function sandboxEgressPolicy(input) {
+	if (input.mode === "blocked") return { mode: "blocked" };
+	const allowDomains = input.allowDomains.map((domain) => requiredText(domain, "strict egress domain"));
+	if (new Set(allowDomains).size !== allowDomains.length) throw new Error("strict egress domains must not contain duplicates");
+	return {
+		mode: "strict",
+		allowDomains,
+		includeImplicitDomains: false
+	};
+}
+function serializeEgressPolicy(policy) {
+	return JSON.stringify(policy.mode === "blocked" ? { mode: "blocked" } : {
+		mode: "strict",
+		allowDomains: sortedDomains(policy.allowDomains),
+		includeImplicitDomains: false
+	});
+}
+function sandboxResources(input) {
+	const cpuCores = positiveNumber(input.resources.cpu, "exact-process cpu");
+	const memoryMB = positiveInteger(input.resources.memoryMb, "exact-process memory");
+	const diskMb = positiveInteger(input.resources.diskMb, "exact-process disk");
+	if (diskMb % 1024 !== 0) throw new Error("Tangle Sandbox exact-process disk must be a whole GiB");
+	return {
+		cpuCores,
+		memoryMB,
+		diskGB: diskMb / 1024
+	};
+}
+function sandboxLifetimeSeconds(maxLifetimeMs) {
+	const milliseconds = positiveInteger(maxLifetimeMs, "exact-process maximum lifetime");
+	if (milliseconds % 1e3 !== 0) throw new Error("Tangle Sandbox exact-process maximum lifetime must be a whole number of seconds");
+	return milliseconds / 1e3;
+}
+function fileMode(value) {
+	const mode = nonnegativeInteger(value, "exact-process file mode");
+	if (mode > 4095) throw new Error("exact-process file mode exceeds POSIX mode bits");
+	return mode;
+}
+function assertNoProviderOptions(providerOptions) {
+	if (providerOptions && Object.keys(providerOptions).length > 0) throw new Error("Tangle Sandbox exact-process provider does not accept providerOptions");
+}
+function exactProcessOnlyCapabilities() {
+	return {
+		profile: {
+			namedProfiles: false,
+			systemPrompt: false,
+			instructions: false,
+			tools: false,
+			permissions: false,
+			mcp: false,
+			subagents: false,
+			resources: {
+				files: false,
+				instructions: false,
+				tools: false,
+				skills: false,
+				agents: false,
+				commands: false
+			},
+			hooks: false,
+			modes: false,
+			runtimeUpdate: false,
+			validation: false
+		},
+		streaming: {
+			live: false,
+			replay: false,
+			detach: false,
+			turnIdempotency: false
+		},
+		sessions: {
+			continue: false,
+			list: false,
+			messages: false
+		},
+		workspace: {
+			read: false,
+			write: false,
+			exec: false,
+			git: false,
+			upload: false,
+			download: false
+		},
+		branching: {
+			checkpoint: false,
+			fork: false
+		},
+		placement: false,
+		usage: false,
+		confidential: false,
+		exactProcess: { egress: ["blocked", "strict"] }
+	};
+}
+async function discardInvalidSandbox(sandbox, cause) {
+	try {
+		await sandbox.delete();
+	} catch (destroyError) {
+		throw new AggregateError([cause, destroyError], "Tangle Sandbox exact-process creation failed and cleanup failed");
+	}
+	throw cause;
+}
+function sortedDomains(domains) {
+	return [...domains].sort((left, right) => left.localeCompare(right));
+}
+function requiredText(value, label) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+	return value;
+}
+function optionalText(value, label) {
+	if (value === void 0) return void 0;
+	return requiredText(value, label);
+}
+function positiveNumber(value, label) {
+	if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be positive`);
+	return value;
+}
+function positiveInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${label} must be a positive integer`);
+	return value;
+}
+function nonnegativeInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer`);
+	return value;
+}
+function throwIfAborted(signal) {
+	signal?.throwIfAborted();
+}
+async function afterAbortCheck(signal, operation) {
+	throwIfAborted(signal);
+	const result = await operation();
+	throwIfAborted(signal);
+	return result;
+}
+//#endregion
+//#region src/runtime/environment-provider.ts
+var ValidationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ValidationError";
+	}
+};
+/** Create a registry that resolves provider names to concrete provider instances.
+* @experimental */
+function createAgentEnvironmentProviderRegistry(providers = []) {
+	const entries = /* @__PURE__ */ new Map();
+	const registry = {
+		register(provider, options = {}) {
+			if (!provider.name) throw new ValidationError("agent environment provider registry: provider.name required");
+			if (!options.replace && entries.has(provider.name)) throw new ValidationError(`agent environment provider registry: provider "${provider.name}" already registered`);
+			entries.set(provider.name, provider);
+		},
+		has(name) {
+			return entries.has(name);
+		},
+		get(name) {
+			return entries.get(name);
+		},
+		require(name) {
+			const provider = entries.get(name);
+			if (!provider) {
+				const available = Array.from(entries.keys()).sort();
+				throw new ValidationError(`agent environment provider registry: provider "${name}" is not registered${available.length > 0 ? `; available: ${available.join(", ")}` : ""}`);
+			}
+			return provider;
+		},
+		names() {
+			return Array.from(entries.keys()).sort();
+		},
+		providers() {
+			return registry.names().map((name) => registry.require(name));
+		},
+		async capabilities(name) {
+			return registry.require(name).capabilities();
+		}
+	};
+	for (const provider of providers) registry.register(provider);
+	return registry;
+}
+/** Resolve a provider instance or registry name, failing loudly when a name is unknown.
+* @experimental */
+function resolveAgentEnvironmentProvider(provider, registry) {
+	if (typeof provider !== "string") return provider;
+	if (!registry) throw new ValidationError(`agent environment provider "${provider}" requires an AgentEnvironmentProviderRegistry`);
+	return registry.require(provider);
+}
+/** Adapt a neutral environment provider to the `SandboxClient` interface used by existing loop paths.
+* @experimental */
+function providerAsSandboxClient(provider, options = {}) {
+	return { async create(createOptions) {
+		const mapped = {
+			...options.defaults ?? {},
+			...createInputFromSandboxOptions(createOptions),
+			...options.mapCreateOptions?.(createOptions) ?? {}
+		};
+		if (mapped.profile === void 0) throw new ValidationError(`providerAsSandboxClient(${provider.name}): profile required in defaults or CreateSandboxOptions.backend.profile`);
+		return environmentAsSandboxInstance(await provider.create(mapped), { requireTerminalEvent: options.requireTerminalEvent ?? true });
+	} };
+}
+/** Adapt a `SandboxClient` into the shared `AgentEnvironmentProvider` contract.
+* @experimental */
+function sandboxClientAsProvider(client, options = {}) {
+	const providerName = options.name ?? "tangle-sandbox";
+	return {
+		name: providerName,
+		capabilities: async () => {
+			if (options.capabilities) return typeof options.capabilities === "function" ? options.capabilities() : options.capabilities;
+			return defaultTangleSandboxCapabilities({ namedProfiles: options.resolveProfile !== void 0 });
+		},
+		...options.validateProfile ? { validateProfile: options.validateProfile } : {},
+		async create(input) {
+			const createOptions = options.mapCreateInput?.(input) ?? await sandboxOptionsFromCreateInput(input, options.defaultBackend ?? "opencode", options.resolveProfile);
+			return sandboxInstanceAsEnvironment(await client.create(createOptions), providerName, client);
+		},
+		...hasGet(client) ? { async get(id) {
+			const box = await client.get(id);
+			return box ? sandboxInstanceAsEnvironment(box, providerName, client) : null;
+		} } : {},
+		...hasList(client) ? { async list(query) {
+			return (await client.list(query?.providerOptions)).map((box) => ({
+				id: String(box.id),
+				provider: providerName,
+				name: typeof box.name === "string" ? box.name : void 0,
+				status: statusFromUnknown(readBoxStatus(box)),
+				metadata: readBoxMetadata(box)
+			}));
+		} } : {}
+	};
+}
+/** Adapt an environment provider into an `ExecutorFactory` for `createExecutor`.
+* @experimental */
+function providerAsExecutor(provider, options = {}) {
+	return (spec, ctx) => createProviderExecutor(provider, spec.profile, ctx, options);
+}
+function createProviderExecutor(provider, profile, ctx, options) {
+	const controller = new AbortController();
+	const abortIfSignalled = () => {
+		if (ctx.signal.aborted) controller.abort();
+	};
+	abortIfSignalled();
+	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	let environment;
+	let artifact;
+	return {
+		runtime: options.runtime ?? provider.name,
+		execute(task, signal) {
+			return streamProviderExecutor({
+				provider,
+				profile,
+				task,
+				signal,
+				controller,
+				options,
+				onEnvironment: (env) => {
+					environment = env;
+				},
+				onArtifact: (next) => {
+					artifact = next;
+				}
+			});
+		},
+		async teardown(_grace) {
+			controller.abort();
+			await environment?.destroy?.();
+			return { destroyed: true };
+		},
+		resultArtifact() {
+			if (!artifact) throw new ValidationError(`providerAsExecutor(${provider.name}): resultArtifact() read before stream drained`);
+			return artifact;
+		}
+	};
+}
+async function* streamProviderExecutor(args) {
+	const started = Date.now();
+	const linked = mergeAbortSignals(args.signal, args.controller.signal);
+	const environment = await args.provider.create({
+		...args.options.defaults ?? {},
+		profile: args.profile,
+		signal: linked
+	});
+	args.onEnvironment(environment);
+	const turn = args.options.taskToTurn?.(args.task, args.profile) ?? taskToTurnInput(args.task, linked);
+	const events = [];
+	const tokens = zeroTokenUsage();
+	let usd = 0;
+	let text = "";
+	let terminal = false;
+	try {
+		for await (const event of environment.stream({
+			...turn,
+			signal: linked
+		})) {
+			events.push(event);
+			text += textFromEnvironmentEvent(event);
+			const usage = usageFromEnvironmentEvent(event);
+			if (usage.input || usage.output) {
+				tokens.input += usage.input;
+				tokens.output += usage.output;
+				yield {
+					kind: "tokens",
+					input: usage.input,
+					output: usage.output
+				};
+			}
+			if (usage.usd) {
+				usd += usage.usd;
+				yield {
+					kind: "cost",
+					usd: usage.usd
+				};
+			}
+			if (isTerminalEnvironmentEvent(event)) terminal = true;
+		}
+		if ((args.options.requireTerminalEvent ?? true) && !terminal) throw new ValidationError(`providerAsExecutor(${args.provider.name}): stream ended without a terminal result/done/status event`);
+		yield { kind: "iteration" };
+		const result = resultFromEvents(events, text);
+		const spent = {
+			iterations: 1,
+			tokens,
+			usd,
+			ms: Date.now() - started
+		};
+		args.onArtifact({
+			outRef: contentRef(`provider:${args.provider.name}`, result),
+			out: result,
+			spent
+		});
+	} finally {
+		if (args.options.destroyOnSettle ?? true) await environment.destroy?.();
+	}
+}
+function createInputFromSandboxOptions(options) {
+	const profile = options?.backend?.profile;
+	const backend = options?.backend?.type;
+	return {
+		...profile !== void 0 ? { profile } : {},
+		...backend ? { backend } : {},
+		workspace: {
+			...options?.environment ? { environment: options.environment } : {},
+			...options?.git?.url ? { repoUrl: options.git.url } : {},
+			...options?.git?.ref ? { gitRef: options.git.ref } : {}
+		},
+		...options?.resources ? { resources: options.resources } : {},
+		...options?.env ? { env: options.env } : {},
+		...options?.secrets ? { secrets: options.secrets } : {},
+		...options?.metadata ? { metadata: options.metadata } : {},
+		...options?.name ? { name: options.name } : {},
+		...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+		providerOptions: { sandboxCreateOptions: options ?? {} }
+	};
+}
+async function sandboxOptionsFromCreateInput(input, defaultBackend, resolveProfile) {
+	const backendType = input.backend ?? defaultBackend;
+	const workspace = input.workspace ?? {};
+	const environment = sandboxEnvironmentFromWorkspace(workspace);
+	const providerOptions = input.providerOptions?.sandboxCreateOptions;
+	const base = providerOptions && typeof providerOptions === "object" ? { ...providerOptions } : {};
+	assertSandboxSecretNames(input.secrets);
+	assertSandboxSecretNames(base.secrets);
+	const profile = await sandboxProfileFromReference(input.profile, resolveProfile);
+	const { profile: _baseProfile, ...baseBackend } = base.backend ?? {};
+	return {
+		...base,
+		...environment ? { environment } : {},
+		...workspace.repoUrl ? { git: {
+			url: workspace.repoUrl,
+			ref: workspace.gitRef
+		} } : {},
+		...input.resources ? { resources: input.resources } : {},
+		...input.env ? { env: input.env } : {},
+		...Array.isArray(input.secrets) ? { secrets: input.secrets } : {},
+		...input.metadata ? { metadata: input.metadata } : {},
+		...input.name ? { name: input.name } : {},
+		...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {},
+		backend: {
+			...baseBackend,
+			type: backendType,
+			profile
+		}
+	};
+}
+function assertSandboxSecretNames(secrets) {
+	if (secrets !== void 0 && (!Array.isArray(secrets) || secrets.some((secret) => typeof secret !== "string" || secret.trim().length === 0))) throw new ValidationError("Tangle Sandbox secret names must be non-empty strings; secret values are unsupported");
+}
+function sandboxEnvironmentFromWorkspace(workspace) {
+	if (workspace.environment !== void 0 && workspace.image !== void 0 && workspace.environment !== workspace.image) throw new ValidationError("Tangle Sandbox accepts one environment value; workspace.environment and workspace.image must match");
+	return workspace.environment ?? workspace.image;
+}
+async function sandboxProfileFromReference(profile, resolveProfile) {
+	if (typeof profile !== "string") return profile;
+	if (!resolveProfile) throw new ValidationError(`Tangle Sandbox requires an inline AgentProfile; named profile "${profile}" needs SandboxClientProviderOptions.resolveProfile`);
+	return resolveProfile(profile);
+}
+function environmentAsSandboxInstance(environment, options) {
+	return {
+		id: environment.id,
+		name: environment.name,
+		status: "running",
+		async refresh() {
+			await environment.refresh?.();
+		},
+		async *streamPrompt(message, promptOptions) {
+			let terminal = false;
+			const input = turnInputFromPrompt(message, promptOptions);
+			for await (const event of environment.stream(input)) {
+				if (isTerminalEnvironmentEvent(event)) terminal = true;
+				const usageEvent = usageSandboxEvent(event);
+				if (usageEvent) yield usageEvent;
+				yield sandboxEventFromEnvironmentEvent(event);
+			}
+			if (options.requireTerminalEvent && !terminal) throw new ValidationError(`providerAsSandboxClient(${environment.provider}): stream ended without a terminal result/done/status event`);
+		},
+		async prompt(message, promptOptions) {
+			const events = [];
+			let text = "";
+			let usage;
+			let terminal = false;
+			for await (const event of environment.stream(turnInputFromPrompt(message, promptOptions))) {
+				events.push(event);
+				if (isTerminalEnvironmentEvent(event)) terminal = true;
+				text += textFromEnvironmentEvent(event);
+				usage = mergeTokenUsage(usage, event.usage);
+			}
+			if (options.requireTerminalEvent && !terminal) throw new ValidationError(`providerAsSandboxClient(${environment.provider}): prompt ended without a terminal result/done/status event`);
+			return {
+				response: resultFromEvents(events, text).content,
+				success: true,
+				status: "success",
+				durationMs: 0,
+				...usage ? { usage } : {}
+			};
+		},
+		...environment.dispatch && environment.session ? { async dispatchPrompt(message, promptOptions) {
+			const session = await environment.dispatch?.(turnInputFromPrompt(message, promptOptions));
+			if (!session) throw new ValidationError("providerAsSandboxClient: dispatch returned no session");
+			return sandboxDispatchResultFromSessionRef(session);
+		} } : {},
+		...environment.session ? { session(id) {
+			return sandboxSessionFromAgentSession(environment.session?.(id));
+		} } : {},
+		...environment.read ? { read: environment.read.bind(environment) } : {},
+		...environment.write ? { write: environment.write.bind(environment) } : {},
+		...environment.exec ? { exec: environment.exec.bind(environment) } : {},
+		...environment.checkpoint ? { async checkpoint(checkpointOptions) {
+			const checkpoint = await environment.checkpoint?.(checkpointOptions);
+			return {
+				checkpointId: checkpoint?.id,
+				id: checkpoint?.id
+			};
+		} } : {},
+		...environment.fork ? { async fork(checkpointId, forkOptions) {
+			const forked = await environment.fork?.({ id: checkpointId }, forkOptions);
+			if (!forked) throw new ValidationError("providerAsSandboxClient: fork returned no environment");
+			return environmentAsSandboxInstance(forked, options);
+		} } : {},
+		async delete() {
+			await environment.destroy?.();
+		}
+	};
+}
+function sandboxInstanceAsEnvironment(box, providerName, client) {
+	return {
+		id: String(box.id),
+		provider: providerName,
+		...typeof box.name === "string" ? { name: box.name } : {},
+		async status() {
+			await maybeRefresh(box);
+			return statusFromUnknown(readBoxStatus(box));
+		},
+		async *stream(input) {
+			for await (const event of box.streamPrompt(promptFromTurnInput(input), promptOptionsFromTurnInput(input))) yield environmentEventFromSandboxEvent(event);
+		},
+		...hasDispatchPrompt(box) ? { async dispatch(input) {
+			return sessionRefFromSandboxDispatch(await box.dispatchPrompt(promptFromTurnInput(input), promptOptionsFromTurnInput(input)), providerName);
+		} } : {},
+		...hasSession(box) ? { session(id) {
+			return sandboxSessionAsAgentSession(box.session(id));
+		} } : {},
+		...hasRead(box) ? { read: box.read.bind(box) } : {},
+		...hasWrite(box) ? { write: box.write.bind(box) } : {},
+		...hasExec(box) ? { async exec(command, options) {
+			return execResultFromSandboxExecResult(await box.exec(command, options));
+		} } : {},
+		async checkpoint(options) {
+			return {
+				id: (await box.snapshot({ ...options?.name ? { tags: [options.name] } : {} })).snapshotId,
+				provider: providerName,
+				...options?.metadata ? { metadata: options.metadata } : {}
+			};
+		},
+		async fork(checkpoint, options) {
+			return sandboxInstanceAsEnvironment(await client.create({
+				fromSnapshot: checkpoint.id,
+				fromSandboxId: String(box.id),
+				...options?.name ? { name: options.name } : {},
+				...options?.metadata ? { metadata: options.metadata } : {}
+			}), providerName, client);
+		},
+		async placement() {
+			return placementInfoFromLoopPlacement(client.describePlacement?.(box), box);
+		},
+		async refresh() {
+			await maybeRefresh(box);
+		},
+		async destroy() {
+			await destroyBox(box);
+		}
+	};
+}
+function sandboxSessionAsAgentSession(session) {
+	return {
+		id: session.id,
+		async status() {
+			const status = await session.status();
+			if (!status) return null;
+			return sessionStatusFromUnknown(status.status);
+		},
+		async *events(options) {
+			for await (const event of session.events(options)) yield environmentEventFromSandboxEvent(event);
+		},
+		async result() {
+			return agentTurnResultFromPromptResult(await session.result());
+		},
+		async prompt(input) {
+			return agentTurnResultFromPromptResult(await session.prompt(promptFromTurnInput(input), promptOptionsFromTurnInput(input)));
+		},
+		cancel() {
+			return session.interrupt().then(() => void 0);
+		}
+	};
+}
+function sandboxSessionFromAgentSession(session) {
+	if (!session) throw new ValidationError("providerAsSandboxClient: session is unavailable");
+	return {
+		id: session.id,
+		async status() {
+			const status = await session.status();
+			if (!status) return null;
+			return {
+				id: session.id,
+				status: sandboxSessionStatusFromAgentSessionStatus(status)
+			};
+		},
+		async *events(options) {
+			for await (const event of session.events(options)) yield sandboxEventFromEnvironmentEvent(event);
+		},
+		async result() {
+			return promptResultFromAgentTurnResult(await session.result());
+		},
+		async prompt(message, options) {
+			return promptResultFromAgentTurnResult(await session.prompt(turnInputFromPrompt(message, options)));
+		},
+		async interrupt() {
+			await session.cancel();
+			return { cancelled: true };
+		}
+	};
+}
+function sandboxSessionStatusFromAgentSessionStatus(status) {
+	switch (status) {
+		case "pending":
+		case "provisioning": return "queued";
+		case "running": return "running";
+		case "completed": return "completed";
+		case "cancelled": return "cancelled";
+		case "stopped":
+		case "failed":
+		case "expired":
+		case "unknown": return "failed";
+	}
+}
+function promptResultFromAgentTurnResult(result) {
+	return {
+		response: result.text,
+		success: result.success,
+		status: result.success ? "success" : "failed",
+		durationMs: 0,
+		...result.error ? { error: result.error } : {},
+		...result.usage ? {
+			usage: {
+				inputTokens: result.usage.inputTokens,
+				outputTokens: result.usage.outputTokens
+			},
+			...result.usage.cost === void 0 ? {} : { costUsd: result.usage.cost }
+		} : {}
+	};
+}
+function environmentEventFromSandboxEvent(event) {
+	const data = event.data && typeof event.data === "object" ? event.data : {};
+	return {
+		type: String(event.type),
+		data,
+		...event.id ? { id: event.id } : {},
+		usage: tokenUsageFromData(data),
+		providerEvent: event
+	};
+}
+function sandboxEventFromEnvironmentEvent(event) {
+	return {
+		type: event.type,
+		data: {
+			...event.data,
+			...event.usage ? { usage: tokenUsageData(event.usage) } : {}
+		},
+		...event.id ? { id: event.id } : {}
+	};
+}
+function usageSandboxEvent(event) {
+	if (!event.usage || isUsageType(event.type)) return void 0;
+	const usage = tokenUsageData(event.usage);
+	if (usage.inputTokens === void 0 && usage.outputTokens === void 0 && usage.totalCostUsd === void 0) return;
+	return {
+		type: "llm_call",
+		data: usage
+	};
+}
+function tokenUsageData(usage) {
+	return {
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		totalCostUsd: usage.cost
+	};
+}
+function turnInputFromPrompt(message, options) {
+	return {
+		...typeof message === "string" ? { prompt: message } : { parts: message },
+		...options?.sessionId ? { sessionId: options.sessionId } : {},
+		...options?.model ? { model: options.model } : {},
+		...options?.timeoutMs ? { timeoutMs: options.timeoutMs } : {},
+		...options?.executionId ? { executionId: options.executionId } : {},
+		...options?.lastEventId ? { lastEventId: options.lastEventId } : {},
+		...options?.turnId ? { turnId: options.turnId } : {},
+		...options?.detach !== void 0 ? { detach: options.detach } : {},
+		...options?.context ? { context: options.context } : {},
+		...options?.signal ? { signal: options.signal } : {},
+		...options?.backend ? { providerOptions: { backend: options.backend } } : {}
+	};
+}
+function promptFromTurnInput(input) {
+	if (input.parts) return input.parts.map(promptPartFromInputPart);
+	return input.prompt ?? "";
+}
+function promptPartFromInputPart(part) {
+	if (part.type === "text" || part.type === "image") return part;
+	if (part.content !== void 0 || part.path !== void 0) throw new ValidationError("Tangle Sandbox file prompt parts require a URL; inline content and local paths are not representable");
+	if (!part.filename || !part.url) throw new ValidationError("Tangle Sandbox file prompt parts require both filename and URL");
+	return {
+		type: "file",
+		filename: part.filename,
+		...part.mediaType ? { mediaType: part.mediaType } : {},
+		url: part.url
+	};
+}
+function promptOptionsFromTurnInput(input) {
+	return {
+		...input.sessionId ? { sessionId: input.sessionId } : {},
+		...input.model ? { model: input.model } : {},
+		...input.timeoutMs ? { timeoutMs: input.timeoutMs } : {},
+		...input.context ? { context: input.context } : {},
+		...input.signal ? { signal: input.signal } : {},
+		...input.executionId ? { executionId: input.executionId } : {},
+		...input.lastEventId ? { lastEventId: input.lastEventId } : {},
+		...input.turnId ? { turnId: input.turnId } : {},
+		...input.detach !== void 0 ? { detach: input.detach } : {}
+	};
+}
+function taskToTurnInput(task, signal) {
+	return {
+		prompt: taskToPrompt(task),
+		signal
+	};
+}
+function taskToPrompt(task) {
+	if (typeof task === "string") return task;
+	if (task && typeof task === "object") {
+		const record = task;
+		for (const key of [
+			"prompt",
+			"content",
+			"task",
+			"message"
+		]) if (typeof record[key] === "string") return record[key];
+	}
+	return JSON.stringify(task);
+}
+function resultFromEvents(events, fallbackText) {
+	for (let i = events.length - 1; i >= 0; i -= 1) {
+		const event = events[i];
+		const text = event ? resultTextFromData(event.data) : void 0;
+		if (text !== void 0) return {
+			content: text,
+			events
+		};
+	}
+	return {
+		content: fallbackText,
+		events
+	};
+}
+function textFromEnvironmentEvent(event) {
+	if (typeof event.normalized === "object" && event.normalized && event.normalized.type === "message.part.updated") return typeof event.normalized.delta === "string" ? event.normalized.delta : "";
+	const data = event.data;
+	for (const key of [
+		"delta",
+		"chunk",
+		"content",
+		"text"
+	]) if (typeof data[key] === "string" && !isTerminalEnvironmentEvent(event)) return data[key];
+	return "";
+}
+function resultTextFromData(data) {
+	for (const key of [
+		"finalText",
+		"text",
+		"response",
+		"resultSummary",
+		"content"
+	]) if (typeof data[key] === "string") return data[key];
+}
+function isTerminalEnvironmentEvent(event) {
+	if (event.type === "result" || event.type === "done" || event.type === "final") return true;
+	if (event.type.endsWith(".completed") || event.type.endsWith(".failed")) return true;
+	if (event.type === "status") {
+		const status = event.data.status;
+		return status === "completed" || status === "failed" || status === "cancelled";
+	}
+	return false;
+}
+function isUsageType(type) {
+	return type === "llm_call" || type === "usage" || type === "cost.usage";
+}
+function usageFromEnvironmentEvent(event) {
+	const usage = event.usage ?? tokenUsageFromData(event.data);
+	return {
+		input: finiteNumber(usage?.inputTokens) ?? 0,
+		output: finiteNumber(usage?.outputTokens) ?? 0,
+		usd: finiteNumber(usage?.cost) ?? finiteNumber(event.data.costUsd) ?? finiteNumber(event.data.totalCostUsd) ?? 0
+	};
+}
+function tokenUsageFromData(data) {
+	const usageRecord = data.usage && typeof data.usage === "object" ? data.usage : data.tokenUsage && typeof data.tokenUsage === "object" ? data.tokenUsage : data;
+	const inputTokens = finiteNumber(usageRecord.inputTokens) ?? finiteNumber(usageRecord.tokensIn) ?? finiteNumber(usageRecord.prompt_tokens);
+	const outputTokens = finiteNumber(usageRecord.outputTokens) ?? finiteNumber(usageRecord.tokensOut) ?? finiteNumber(usageRecord.completion_tokens);
+	const cost = finiteNumber(usageRecord.cost) ?? finiteNumber(usageRecord.costUsd) ?? finiteNumber(usageRecord.totalCostUsd) ?? finiteNumber(data.costUsd) ?? finiteNumber(data.totalCostUsd);
+	if (inputTokens === void 0 && outputTokens === void 0 && cost === void 0) return void 0;
+	return {
+		inputTokens: inputTokens ?? 0,
+		outputTokens: outputTokens ?? 0,
+		...cost !== void 0 ? { cost } : {}
+	};
+}
+function mergeTokenUsage(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return {
+		inputTokens: left.inputTokens + right.inputTokens,
+		outputTokens: left.outputTokens + right.outputTokens,
+		...left.cost !== void 0 || right.cost !== void 0 ? { cost: (left.cost ?? 0) + (right.cost ?? 0) } : {}
+	};
+}
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function agentTurnResultFromPromptResult(result) {
+	const record = result;
+	return {
+		text: typeof record.response === "string" ? record.response : typeof record.text === "string" ? record.text : typeof record.finalText === "string" ? record.finalText : "",
+		success: typeof record.success === "boolean" ? record.success : true,
+		...typeof record.error === "string" ? { error: record.error } : {},
+		usage: tokenUsageFromData(record)
+	};
+}
+function sandboxDispatchResultFromSessionRef(session) {
+	const status = session.metadata && Object.hasOwn(session.metadata, "status") ? sessionStatusFromUnknown(session.metadata?.status) : "running";
+	return {
+		sessionId: session.id,
+		status,
+		alreadyExisted: session.metadata?.alreadyExisted === true
+	};
+}
+function sessionRefFromSandboxDispatch(dispatched, providerName) {
+	const record = dispatched && typeof dispatched === "object" ? dispatched : void 0;
+	const id = record?.sessionId ?? record?.id;
+	if (typeof id !== "string" || id.length === 0) throw new ValidationError("sandboxClientAsProvider: dispatch returned no session id");
+	if (!record) throw new ValidationError("sandboxClientAsProvider: dispatch returned no session record");
+	return {
+		id,
+		provider: providerName,
+		metadata: {
+			...record.status ? { status: record.status } : {},
+			...record.alreadyExisted !== void 0 ? { alreadyExisted: record.alreadyExisted } : {}
+		}
+	};
+}
+function execResultFromSandboxExecResult(result) {
+	const record = result;
+	const exitCode = finiteNumber(record.exitCode) ?? finiteNumber(record.code);
+	if (exitCode === void 0) throw new ValidationError("sandboxClientAsProvider: exec returned no exit code");
+	return {
+		exitCode,
+		stdout: typeof record.stdout === "string" ? record.stdout : "",
+		stderr: typeof record.stderr === "string" ? record.stderr : ""
+	};
+}
+function statusFromUnknown(status) {
+	if (status === "pending" || status === "provisioning" || status === "running") return status;
+	if (status === "stopped" || status === "failed" || status === "expired") return status;
+	if (status === "completed") return "stopped";
+	if (status === "cancelled") return "stopped";
+	return "unknown";
+}
+function sessionStatusFromUnknown(status) {
+	if (status === "completed" || status === "cancelled") return status;
+	return statusFromUnknown(status);
+}
+function readBoxStatus(box) {
+	return box.status;
+}
+function readBoxMetadata(box) {
+	const metadata = box.metadata;
+	return metadata && typeof metadata === "object" ? metadata : void 0;
+}
+async function maybeRefresh(box) {
+	const refresh = box.refresh;
+	if (typeof refresh === "function") await refresh.call(box);
+}
+async function destroyBox(box) {
+	const deleteBox = box.delete;
+	if (typeof deleteBox === "function") await deleteBox.call(box);
+}
+function placementInfoFromLoopPlacement(placement, box) {
+	if (!placement) return {
+		kind: "sandbox",
+		sandboxId: String(box.id)
+	};
+	return {
+		kind: placement.kind === "fleet" ? "fleet" : "sandbox",
+		...placement.sandboxId ? { sandboxId: placement.sandboxId } : { sandboxId: String(box.id) },
+		...placement.fleetId ? { fleetId: placement.fleetId } : {},
+		...placement.machineId ? { machineId: placement.machineId } : {}
+	};
+}
+function defaultTangleSandboxCapabilities(options) {
+	return {
+		profile: {
+			namedProfiles: options.namedProfiles,
+			systemPrompt: true,
+			instructions: true,
+			tools: true,
+			permissions: true,
+			mcp: true,
+			subagents: true,
+			resources: {
+				files: true,
+				instructions: true,
+				tools: true,
+				skills: true,
+				agents: true,
+				commands: true
+			},
+			hooks: true,
+			modes: true,
+			runtimeUpdate: true,
+			validation: true
+		},
+		streaming: {
+			live: true,
+			replay: true,
+			detach: true,
+			turnIdempotency: true
+		},
+		sessions: {
+			continue: true,
+			list: true,
+			messages: true
+		},
+		workspace: {
+			read: true,
+			write: true,
+			exec: true,
+			git: true,
+			upload: true,
+			download: true
+		},
+		branching: {
+			checkpoint: true,
+			fork: true
+		},
+		placement: true,
+		usage: true,
+		confidential: true
+	};
+}
+function mergeAbortSignals(a, b) {
+	const controller = new AbortController();
+	const abort = () => controller.abort();
+	if (a.aborted || b.aborted) controller.abort();
+	else {
+		a.addEventListener("abort", abort, { once: true });
+		b.addEventListener("abort", abort, { once: true });
+	}
+	return controller.signal;
+}
+function contentRef(prefix, value) {
+	let str;
+	try {
+		str = JSON.stringify(value) ?? String(value);
+	} catch {
+		str = String(value);
+	}
+	let hash = 2166136261;
+	for (let i = 0; i < str.length; i += 1) {
+		hash ^= str.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `${prefix}:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function hasGet(client) {
+	return typeof client.get === "function";
+}
+function hasList(client) {
+	return typeof client.list === "function";
+}
+function hasDispatchPrompt(box) {
+	return typeof box.dispatchPrompt === "function";
+}
+function hasSession(box) {
+	return typeof box.session === "function";
+}
+function hasRead(box) {
+	return typeof box.read === "function";
+}
+function hasWrite(box) {
+	return typeof box.write === "function";
+}
+function hasExec(box) {
+	return typeof box.exec === "function";
+}
+//#endregion
+export { sandboxClientAsProvider as a, resolveAgentEnvironmentProvider as i, providerAsExecutor as n, createTangleSandboxExactProcessProvider as o, providerAsSandboxClient as r, createAgentEnvironmentProviderRegistry as t };
+
+//# sourceMappingURL=environment-provider-CfLUmKmf.js.map