@tangle-network/agent-runtime 0.131.6 → 0.132.0

package/dist/{runtime-ZNVnT8h1.js → runtime-D5GueIHH.js}

@@ -1,21 +1,21 @@
 import { n as AnalystError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
-import "./stream-agent-turn-DE8_alvm.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore, x as contentAddress } from "./spawn-journal-saHQzqYi.js";
-import { a as randomSuffix, c as stringifySafe, f as zeroTokenUsage, r as isAbortError, s as sleep, t as addTokenUsage } from "./util-Bw6srryQ.js";
+import "./stream-agent-turn-BxwZJVfZ.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore, x as contentAddress } from "./spawn-journal-Cd5L-Ie9.js";
+import { a as isAbortError, i as hasCompleteCacheBreakdown, l as sleep, m as zeroTokenUsage, n as cloneTokenUsage, s as randomSuffix, t as addTokenUsage, u as stringifySafe } from "./util-Dr--8wAL.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import { a as notifySandboxEventObserver } from "./sandbox-events-CRDwc5WN.js";
+import { a as notifySandboxEventObserver, c as parseCanonicalTransportEvent, s as extractTransportEventIdentity } from "./sandbox-events-vIwmuPdl.js";
 import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-mWSoToiQ.js";
 import { v as executableAgentProfileSnapshot, y as executableAgentSpecSnapshot } from "./materialization-DBXuH34A.js";
-import { $ as createSandboxLineage, I as createWorktreeCliExecutor, N as createExecutor, P as createExecutorRegistry, Q as runAgentRounds, U as createPushTraceSource, Z as defaultSelectWinner, et as probeSandboxCapabilities, l as withDriverExecutor, m as settledToIteration, n as createSupervisor, nt as routerBrain, rt as runBrainLoop, w as rollingDispatch } from "./supervisor-C16p9KqO.js";
-import "./environment-provider-Dyg8DtLK.js";
+import { $ as createSandboxLineage, I as createWorktreeCliExecutor, N as createExecutor, P as createExecutorRegistry, Q as runAgentRounds, U as createPushTraceSource, Z as defaultSelectWinner, et as probeSandboxCapabilities, l as withDriverExecutor, m as settledToIteration, n as createSupervisor, nt as routerBrain, rt as runBrainLoop, w as rollingDispatch } from "./supervisor-DAHeTMAT.js";
+import "./environment-provider-mDsjfGjY.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-n089ZP33.js";
-import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-msTRhTN7.js";
-import "./authoring-DI778qK7.js";
-import "./graph-CoN60QtH.js";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-9jcaIsxA.js";
+import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-C9iPh1y6.js";
+import "./authoring-D0wM2FaY.js";
+import "./graph-DyWVymtQ.js";
 import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
-import { agentProfileSchema, canonicalAgentProfileDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, RuntimeEventEnvelopeSchema, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, nativeContextContinuationTurnDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
@@ -1036,14 +1036,122 @@ async function runLoopWithCampaignContext(opts, loopOptions, ctx, cost) {
 	return (opts.toArtifact ?? ((r) => r.winner?.output))(result);
 }
 function loopCostReceipt(result, model) {
+	return costReceiptFromUsage(result.tokenUsage, model, {
+		usageUnknown: result.tokenUsage.tokensKnown === false,
+		actualCostUsd: result.costUsdKnown !== false ? result.costUsd : void 0,
+		costUnknown: result.costUsdKnown === false,
+		estimatedCostUsd: result.estimatedCostUsd
+	});
+}
+/** Map Runtime usage into Eval's canonical paid-call receipt without inventing cache classes. */
+function costReceiptFromUsage(usage, model, cost) {
+	const cacheComplete = hasCompleteCacheBreakdown(usage) && (usage.freshInput !== void 0 || usage.cacheRead !== void 0 || usage.cacheWrite !== void 0);
+	const cacheRead = cacheComplete ? usage.cacheRead ?? 0 : void 0;
+	const cacheWrite = cacheComplete ? usage.cacheWrite ?? 0 : void 0;
+	const classified = (cacheRead ?? 0) + (cacheWrite ?? 0);
 	return {
 		model,
-		inputTokens: result.tokenUsage.input,
-		outputTokens: result.tokenUsage.output,
-		...result.tokenUsage.tokensKnown === false ? { usageUnknown: true } : {},
-		...result.costUsdKnown !== false ? { actualCostUsd: result.costUsd } : {},
-		...result.costUsdKnown === false ? { costUnknown: true } : {},
-		...result.estimatedCostUsd !== void 0 ? { estimatedCostUsd: result.estimatedCostUsd } : {}
+		inputTokens: cacheComplete ? usage.input - classified : usage.input,
+		outputTokens: usage.output,
+		...cacheComplete ? {
+			cachedTokens: cacheRead,
+			cacheWriteTokens: cacheWrite
+		} : {},
+		...usage.tokensKnown === false || cost.usageUnknown ? { usageUnknown: true } : {},
+		...cost.actualCostUsd !== void 0 ? { actualCostUsd: cost.actualCostUsd } : {},
+		...cost.costUnknown ? { costUnknown: true } : {},
+		...cost.estimatedCostUsd !== void 0 ? { estimatedCostUsd: cost.estimatedCostUsd } : {}
+	};
+}
+/**
+* Eval has one pre-admitted paid call for this dispatch. A tree can only settle that one call when
+* Runtime can prove every visible leaf used the same model. Child identities come from Runtime's
+* materialization receipts. A router root is validated against its exact profile model before
+* Runtime accepts each response. A nested tree is not flattened in this result view, so it remains
+* unknown rather than being relabelled from its parent. A caller-supplied override would be false.
+*/
+function supervisedTreeModel(result, rootProfile) {
+	const models = /* @__PURE__ */ new Set();
+	const rootModel = rootProfile.harness === void 0 || rootProfile.harness === "cli-base" ? rootProfile.model?.default : void 0;
+	if (rootModel === void 0) return { kind: "unknown" };
+	models.add(rootModel);
+	let unknown = false;
+	for (const node of result.tree.nodes) {
+		if (node.ownedTreeRoot !== void 0) {
+			unknown = true;
+			continue;
+		}
+		const materialization = node.materialization;
+		if (materialization?.status !== "known" || materialization.model.status !== "known") {
+			unknown = true;
+			continue;
+		}
+		models.add(materialization.model.id);
+	}
+	if (unknown || models.size === 0) return { kind: "unknown" };
+	if (models.size !== 1) return {
+		kind: "mixed",
+		models: [...models].sort()
+	};
+	return {
+		kind: "known",
+		model: [...models][0]
+	};
+}
+/** The Eval receipt surface has no pre-admitted per-model recursive-tree receipt bundle yet. */
+var SupervisedTreeModelIdentityError = class extends Error {
+	constructor(identity) {
+		const detail = identity.kind === "mixed" ? `multiple models (${identity.models.join(", ")})` : "an unknown materialized model";
+		super(`superviseDispatch: cannot settle one Eval paid-call receipt for a tree with ${detail}`);
+		this.name = "SupervisedTreeModelIdentityError";
+	}
+};
+function unknownSupervisedTreeReceipt() {
+	return {
+		model: "unknown",
+		inputTokens: 0,
+		outputTokens: 0,
+		usageUnknown: true,
+		costUnknown: true
+	};
+}
+/** Run one recursive supervised tree inside Eval's pre-execution paid-call lifecycle. */
+function superviseDispatch(opts) {
+	return async (profile, scenario, ctx) => {
+		const superviseOptions = opts.toSuperviseOptions(scenario, profile);
+		const task = opts.toTask(scenario, profile);
+		const maximumCharge = typeof opts.maximumCharge === "function" ? opts.maximumCharge(scenario, profile) : opts.maximumCharge;
+		const paid = await ctx.cost.runPaidCall({
+			channel: "agent",
+			actor: opts.costSource ?? "supervise",
+			model: "unknown",
+			signal: ctx.signal,
+			...maximumCharge ? { maximumCharge } : {},
+			execute: async (executionSignal) => {
+				const result = await supervise(profile, task, {
+					...superviseOptions,
+					signal: executionSignal
+				});
+				const identity = supervisedTreeModel(result, profile);
+				if (identity.kind !== "known") throw new SupervisedTreeModelIdentityError(identity);
+				return result;
+			},
+			receipt: (result) => {
+				const identity = supervisedTreeModel(result, profile);
+				if (identity.kind !== "known") throw new SupervisedTreeModelIdentityError(identity);
+				return costReceiptFromUsage(result.spentTotal.tokens, identity.model, {
+					usageUnknown: result.spentTotal.tokensKnown === false,
+					actualCostUsd: result.spentTotal.usdKnown !== false ? result.spentTotal.usd : void 0,
+					costUnknown: result.spentTotal.usdKnown === false
+				});
+			},
+			receiptFromError: (error) => error instanceof SupervisedTreeModelIdentityError ? unknownSupervisedTreeReceipt() : void 0
+		});
+		if (!paid.succeeded) throw paid.error;
+		return (opts.toArtifact ?? ((result) => {
+			if (result.kind !== "winner") throw new Error(`superviseDispatch: supervised tree ended without a winner (${result.reason})`);
+			return result.out;
+		}))(paid.value);
 	};
 }
 function modelFromLoopOptions(options) {
@@ -2936,7 +3044,7 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
 			continue;
 		}
 		node.status = ev.status === "done" ? "done" : "failed";
-		node.ownSpend = ev.spent;
+		node.ownSpend = cloneSpend(ev.spent);
 		node.verdict = ev.verdict;
 		node.outRef = ev.outRef;
 	}
@@ -3072,13 +3180,13 @@ function zeroSpend() {
 function addNodeSpend(a, b) {
 	return {
 		iterations: a.iterations + b.iterations,
-		tokens: {
-			input: a.tokens.input + b.tokens.input,
-			output: a.tokens.output + b.tokens.output
-		},
+		tokens: (() => {
+			const tokens = cloneTokenUsage(a.tokens);
+			addTokenUsage(tokens, b.tokens);
+			return tokens;
+		})(),
 		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
 		usd: a.usd + b.usd,
-		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
 		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
 		ms: a.ms + b.ms
 	};
@@ -3086,13 +3194,9 @@ function addNodeSpend(a, b) {
 function cloneSpend(spend) {
 	return {
 		iterations: spend.iterations,
-		tokens: {
-			input: spend.tokens.input,
-			output: spend.tokens.output
-		},
+		tokens: cloneTokenUsage(spend.tokens),
 		...spend.tokensKnown === false ? { tokensKnown: false } : {},
 		usd: spend.usd,
-		...spend.tokensKnown === false ? { tokensKnown: false } : {},
 		...spend.usdKnown === false ? { usdKnown: false } : {},
 		ms: spend.ms
 	};
@@ -3103,7 +3207,6 @@ function addSpend(acc, delta) {
 	addTokenUsage(acc.tokens, delta.tokens);
 	if (delta.tokensKnown === false) acc.tokensKnown = false;
 	acc.usd += delta.usd;
-	if (delta.tokensKnown === false) acc.tokensKnown = false;
 	if (delta.usdKnown === false) acc.usdKnown = false;
 	acc.ms += delta.ms;
 }
@@ -3322,6 +3425,453 @@ function promotionGate(opts) {
 	};
 }
 //#endregion
+//#region src/runtime/retained-run-binding.ts
+function exactSession(environment, controlRef) {
+	if (environment.id !== controlRef.environmentId || environment.provider !== controlRef.provider) throw new Error("provider reconstructed a different retained environment");
+	if (!environment.session || !controlRef.sessionId) throw new Error("retained run control requires a provider session id");
+	const session = environment.session(controlRef.sessionId, { controlRef });
+	if (session.id !== controlRef.sessionId) throw new Error("provider reconstructed a different session");
+	if (session.controlRef === void 0) throw new Error("provider session did not return its provider-owned run control reference");
+	const currentControlRef = AgentExactRunControlRefSchema.parse(session.controlRef);
+	if (!sameControlCoordinates(currentControlRef, controlRef)) throw new Error("provider session reconstructed a different retained session");
+	if (canonicalCandidateDigest(currentControlRef) !== canonicalCandidateDigest(controlRef)) throw new Error("provider session did not retain the exact run control reference");
+	return {
+		session,
+		controlRef: currentControlRef
+	};
+}
+function sameControlCoordinates(left, right) {
+	return canonicalCandidateDigest(left) === canonicalCandidateDigest(right);
+}
+function freezeControlRef(controlRef) {
+	return Object.freeze({ ...AgentExactRunControlRefSchema.parse(controlRef) });
+}
+function copyControlRef(controlRef) {
+	return { ...controlRef };
+}
+function exactControlRef(candidate, expected) {
+	if (!candidate) throw new Error("provider dispatch returned no durable run control reference");
+	const controlRef = AgentExactRunControlRefSchema.parse(candidate);
+	if (controlRef.provider !== expected.provider || controlRef.environmentId !== expected.environmentId || controlRef.sessionId !== expected.sessionId) throw new Error("provider dispatch returned control coordinates for another run");
+	return controlRef;
+}
+function exactContinuedControlRef(candidate, initial) {
+	const controlRef = AgentExactRunControlRefSchema.parse(candidate);
+	if (controlRef.provider !== initial.provider || controlRef.environmentId !== initial.environmentId || controlRef.sessionId !== initial.sessionId) throw new Error("provider continuation advanced to another retained session");
+	if (controlRef.runId === initial.runId && controlRef.executionId === initial.executionId) throw new Error("provider continuation did not return a new exact run execution");
+	return controlRef;
+}
+function assertInteractionBinding(controlRef, command) {
+	if (command.binding.runId !== controlRef.runId || command.binding.provider !== controlRef.provider || command.binding.environmentId !== controlRef.environmentId || command.binding.sessionId !== controlRef.sessionId || command.binding.executionId !== controlRef.executionId || command.binding.requestDigest !== controlRef.requestDigest) throw new Error("interaction response command does not target this retained run");
+}
+function assertBoundaryBinding(controlRef, proof) {
+	if (proof.runId !== controlRef.runId || proof.provider !== controlRef.provider || proof.environmentId !== controlRef.environmentId || proof.sessionId !== controlRef.sessionId || proof.executionId !== controlRef.executionId || proof.requestDigest !== controlRef.requestDigest) throw new Error("native context proof does not identify this retained run");
+}
+function assertSequence(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative safe integer`);
+}
+function assertResultBinding(controlRef, result) {
+	if (result.sessionId !== controlRef.sessionId) throw new Error("provider returned a result for another retained session");
+	const metadata = result.metadata;
+	if (controlRef.executionId !== void 0 && metadata?.executionId !== controlRef.executionId) throw new Error("provider returned a result for another retained execution");
+	if (metadata?.runId !== controlRef.runId) throw new Error("provider returned a result for another retained run");
+	if (metadata?.requestDigest !== controlRef.requestDigest) throw new Error("provider returned a result for another retained request");
+}
+var RetainedRunProviderContractError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RetainedRunProviderContractError";
+	}
+};
+function cancellationRequest(controlRef, operationId, reason) {
+	const material = {
+		operationId,
+		run: AgentExactRunControlRefSchema.parse(controlRef),
+		...reason === void 0 ? {} : { reason }
+	};
+	return AgentRunCancellationRequestSchema.parse({
+		...material,
+		requestDigest: agentRunCancellationRequestDigest(material)
+	});
+}
+async function exactSessionCancel(session, request, options) {
+	if (!session.cancelRun) throw new Error("provider session does not expose durable cancellation operations");
+	let acknowledgement;
+	try {
+		acknowledgement = await awaitAbortable(Promise.resolve().then(() => session.cancelRun(request, options)), options.signal);
+	} catch (error) {
+		if (error instanceof RetainedRunProviderContractError) throw error;
+		throw error;
+	}
+	let exactAcknowledgement;
+	try {
+		exactAcknowledgement = AgentRunCancellationAcknowledgementSchema.parse(acknowledgement);
+	} catch {
+		throw new RetainedRunProviderContractError("provider returned an invalid retained cancellation acknowledgement");
+	}
+	if (!agentRunCancellationAcknowledgementMatchesRequest(request, exactAcknowledgement)) throw new RetainedRunProviderContractError("provider returned a retained cancellation acknowledgement for another request");
+	return exactAcknowledgement;
+}
+function hasDurableCancel(session) {
+	return typeof session.cancelRun === "function";
+}
+async function awaitAbortable(work, signal) {
+	if (signal === void 0) return await work;
+	if (signal.aborted) {
+		Promise.resolve(work).catch(() => void 0);
+		throw abortError(signal.reason);
+	}
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			queueMicrotask(() => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(abortError(signal.reason));
+			});
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		Promise.resolve(work).then((value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		});
+	});
+}
+async function exactSessionResult(session) {
+	return session.result();
+}
+function assertEventBinding(source, controlRef) {
+	const values = [
+		isRecord(source) ? source : void 0,
+		isRecord(source.data) ? source.data : void 0,
+		isRecord(source.providerEvent) ? source.providerEvent : void 0
+	].filter((value) => value !== void 0);
+	for (const value of values) {
+		if (value.runId !== void 0 && value.runId !== controlRef.runId) throw new Error("provider returned an event for another retained run");
+		if (value.executionId !== void 0 && value.executionId !== controlRef.executionId) throw new Error("provider returned an event for another retained execution");
+		if (value.sessionId !== void 0 && value.sessionId !== controlRef.sessionId) throw new Error("provider returned an event for another retained session");
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertStableText(value, label) {
+	if (value.length === 0 || value.trim() !== value) throw new Error(`${label} must be non-empty and have no outer whitespace`);
+}
+function abortError(reason) {
+	const error = new Error(reason === void 0 ? "aborted" : String(reason));
+	error.name = "AbortError";
+	return error;
+}
+function assertWaitDuration(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative safe integer`);
+}
+function isTerminalSessionStatus(status) {
+	return status === "completed" || status === "failed" || status === "cancelled" || status === "expired";
+}
+function delay(ms, signal) {
+	if (signal?.aborted) return Promise.reject(abortError(signal.reason));
+	return new Promise((resolveDelay, rejectDelay) => {
+		const timer = setTimeout(finish, ms);
+		function finish() {
+			signal?.removeEventListener("abort", onAbort);
+			resolveDelay();
+		}
+		function onAbort() {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			rejectDelay(abortError(signal?.reason));
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/runtime/retained-run-events.ts
+async function* retainedRunEvents(session, controlRef, options, now) {
+	const after = options?.after;
+	if (after) {
+		assertStableText(after.cursor, "replay cursor");
+		assertSequence(after.sequence, "replay sequence");
+	}
+	let nextSequence = after === void 0 ? 1 : after.sequence + 1;
+	let lastSequence = after?.sequence ?? -1;
+	const seen = /* @__PURE__ */ new Set();
+	let firstAfterEvent = after !== void 0;
+	const iterator = session.events({
+		...after === void 0 ? {} : { since: after.cursor },
+		...controlRef.executionId === void 0 ? {} : { executionId: controlRef.executionId },
+		...options?.signal === void 0 ? {} : { signal: options.signal }
+	})[Symbol.asyncIterator]();
+	try {
+		for (;;) {
+			const next = await awaitAbortable(Promise.resolve().then(() => iterator.next()), options?.signal);
+			if (next.done) break;
+			const source = next.value;
+			const identity = extractTransportEventIdentity(source);
+			const sourceCursor = identity.cursor ?? identity.eventId;
+			assertEventBinding(source, controlRef);
+			if (sourceCursor === after?.cursor) continue;
+			const event = canonicalEvent(source);
+			if (!event) continue;
+			if (firstAfterEvent && after !== void 0) {
+				if (identity.sequence !== void 0 && identity.sequence <= after.sequence) throw new Error("provider replay did not prove that the first event follows the requested cursor");
+				firstAfterEvent = false;
+			}
+			const eventId = identity.eventId ?? identity.cursor;
+			if (!eventId) throw new Error("replayable canonical event has no stable provider event id or cursor");
+			assertStableText(eventId, "provider event id");
+			if (seen.has(eventId)) throw new Error(`provider replay repeated event id "${eventId}"`);
+			seen.add(eventId);
+			const sequence = identity.sequence ?? nextSequence;
+			if (sequence <= lastSequence) throw new Error(`provider event sequence is not monotonic: ${sequence} follows ${lastSequence}`);
+			const occurredAt = identity.occurredAt;
+			yield RuntimeEventEnvelopeSchema.parse({
+				runId: controlRef.runId,
+				eventId,
+				sequence,
+				cursor: identity.cursor ?? eventId,
+				...occurredAt === void 0 ? {} : { occurredAt },
+				receivedAt: new Date(now()).toISOString(),
+				event
+			});
+			lastSequence = sequence;
+			nextSequence = sequence + 1;
+		}
+	} catch (error) {
+		if (options?.signal?.aborted) {
+			try {
+				Promise.resolve(iterator.return?.()).catch(() => void 0);
+			} catch {}
+			throw abortError(options.signal.reason);
+		}
+		throw error;
+	} finally {
+		if (!options?.signal?.aborted) await iterator.return?.();
+	}
+}
+function canonicalEvent(source) {
+	return parseCanonicalTransportEvent(source.type, source.data, source.normalized ?? source.data.normalized, "provider");
+}
+//#endregion
+//#region src/runtime/retained-run-handle.ts
+function createRetainedRunHandle(environment, session, initialControlRef, capabilities, now) {
+	const clock = now ?? Date.now;
+	let activeControlRef = freezeControlRef(initialControlRef);
+	const snapshot = async (reason, signal) => {
+		if (signal?.aborted) throw abortError(signal.reason);
+		let status;
+		try {
+			status = await awaitAbortable(Promise.resolve().then(() => session.status({ signal })), signal);
+		} catch {
+			if (signal?.aborted) throw abortError(signal.reason);
+			status = "unknown";
+		}
+		const effect = status === "cancelled" ? "cancelled" : status === "completed" || status === "failed" || status === "expired" ? "not_live" : "unknown";
+		return {
+			runId: activeControlRef.runId,
+			controlRef: copyControlRef(activeControlRef),
+			status,
+			effect,
+			observedAt: new Date(clock()).toISOString(),
+			...reason === void 0 ? {} : { reason },
+			...signal?.aborted ? { signal: String(signal.reason ?? "aborted") } : {}
+		};
+	};
+	return {
+		get controlRef() {
+			return copyControlRef(activeControlRef);
+		},
+		status: async (options) => {
+			const waitMs = options?.waitMs ?? 0;
+			assertWaitDuration(waitMs, "retained status wait");
+			const initial = await snapshot(void 0, options?.signal);
+			if (waitMs === 0 || isTerminalSessionStatus(initial.status)) return initial;
+			const deadline = Date.now() + waitMs;
+			let current = initial;
+			while (Date.now() < deadline) {
+				await delay(Math.min(25, Math.max(1, deadline - Date.now())), options?.signal);
+				current = await snapshot(void 0, options?.signal);
+				if (current.status !== initial.status || isTerminalSessionStatus(current.status)) return current;
+			}
+			return current;
+		},
+		events: (options) => retainedRunEvents(session, copyControlRef(activeControlRef), options, clock),
+		result: async () => {
+			const result = AgentTurnResultSchema.parse(await exactSessionResult(session));
+			assertResultBinding(activeControlRef, result);
+			return structuredClone(result);
+		},
+		async respondToInteraction(command, options) {
+			const exactCommand = InteractionResponseCommandSchema.parse(command);
+			assertInteractionBinding(activeControlRef, exactCommand);
+			if (capabilities.interactions?.responseIdempotency !== true) throw new Error(`provider "${activeControlRef.provider}" does not promise retry-safe interaction responses`);
+			const respond = session.respondToInteraction ?? environment.respondToInteraction;
+			if (!respond) throw new Error(`provider "${activeControlRef.provider}" does not support interaction responses`);
+			const acknowledgement = InteractionAcknowledgementSchema.parse(await awaitAbortable(Promise.resolve().then(() => respond.call(session.respondToInteraction ? session : environment, exactCommand, options)), options?.signal));
+			if (acknowledgement.operationId !== exactCommand.operationId || acknowledgement.commandDigest !== exactCommand.commandDigest || canonicalCandidateDigest(acknowledgement.binding) !== canonicalCandidateDigest(exactCommand.binding)) throw new Error("provider returned an interaction acknowledgement for another command");
+			return structuredClone(acknowledgement);
+		},
+		async contextBoundary(options) {
+			if (!session.contextBoundary) return null;
+			const proof = await awaitAbortable(Promise.resolve().then(() => session.contextBoundary(options)), options?.signal);
+			if (proof === null) return null;
+			const exactProof = NativeContextBoundaryProofSchema.parse(proof);
+			assertBoundaryBinding(activeControlRef, exactProof);
+			return structuredClone(exactProof);
+		},
+		async continueNative(request, turn) {
+			const exactRequest = NativeContextContinuationRequestSchema.parse(request);
+			if (!sameControlCoordinates(exactRequest.run, activeControlRef)) throw new Error("native continuation request targets another retained run");
+			const { timeoutMs, signal, ...semanticTurn } = turn;
+			if (nativeContextContinuationTurnDigest(semanticTurn) !== exactRequest.turnDigest) throw new Error("native continuation request targets another user turn");
+			if (capabilities.nativeContinuation?.atomicBoundary !== true || capabilities.nativeContinuation.requestIdempotency !== true || !session.continueNative) throw new Error(`provider "${activeControlRef.provider}" does not support retry-safe native continuation`);
+			const outcome = AgentNativeContextContinuationResultSchema.parse(await awaitAbortable(Promise.resolve().then(() => session.continueNative(exactRequest, {
+				turn: semanticTurn,
+				...timeoutMs === void 0 ? {} : { timeoutMs },
+				...signal === void 0 ? {} : { signal }
+			})), signal));
+			if (outcome.acknowledgement.operationId !== exactRequest.operationId || outcome.acknowledgement.requestDigest !== exactRequest.requestDigest) throw new Error("provider returned a native continuation result for another request");
+			if (outcome.acknowledgement.actualBoundary !== void 0) {
+				const actualBoundary = NativeContextBoundaryProofSchema.parse(outcome.acknowledgement.actualBoundary);
+				assertBoundaryBinding(exactRequest.run, actualBoundary);
+			}
+			if (outcome.acknowledgement.status !== "accepted" && outcome.acknowledgement.status !== "replayed") return structuredClone(outcome);
+			if (!("result" in outcome) || !("controlRef" in outcome)) throw new Error("provider omitted the successful native continuation result");
+			if (!agentNativeContextContinuationResultMatchesRequest(exactRequest, outcome)) throw new Error("provider returned a native continuation result for another request");
+			const nextControlRef = exactContinuedControlRef(outcome.controlRef, activeControlRef);
+			assertResultBinding(nextControlRef, outcome.result);
+			activeControlRef = freezeControlRef(nextControlRef);
+			return structuredClone({
+				...outcome,
+				controlRef: copyControlRef(activeControlRef)
+			});
+		},
+		async cancel(options) {
+			assertStableText(options.operationId, "retained cancellation operation id");
+			if (options.reason !== void 0) assertStableText(options.reason, "retained cancellation reason");
+			if (options.signal?.aborted) throw abortError(options.signal.reason);
+			if (!hasDurableCancel(session)) throw new Error(`provider "${activeControlRef.provider}" does not expose durable cancellation operations`);
+			const request = cancellationRequest(activeControlRef, options.operationId, options.reason);
+			let effect = "unknown";
+			let providerStatus;
+			try {
+				const acknowledgement = await exactSessionCancel(session, request, { signal: options.signal });
+				effect = acknowledgement.effect;
+				providerStatus = acknowledgement.status;
+			} catch (error) {
+				if (error instanceof RetainedRunProviderContractError) throw error;
+				if (error instanceof Error && error.name === "AbortError") throw error;
+				effect = "unknown";
+			}
+			const current = await snapshot(options.reason, options.signal);
+			const observedEffect = effect === "unknown" && providerStatus === void 0 && current.status === "cancelled" ? "cancelled" : effect;
+			const acknowledgement = {
+				operationId: options.operationId,
+				requestDigest: request.requestDigest,
+				status: providerStatus ?? (observedEffect === "unknown" ? "unknown" : "accepted"),
+				effect: observedEffect,
+				snapshot: {
+					...current,
+					effect: observedEffect
+				},
+				...options.reason === void 0 ? {} : { reason: options.reason },
+				...options.signal?.aborted ? { signal: String(options.signal.reason ?? "aborted") } : {}
+			};
+			return structuredClone(acknowledgement);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/turn-input.ts
+/**
+* Copy only fields that describe a new provider turn.
+*
+* Session, replay, continuation, and transfer coordinates are runtime-owned
+* and are injected by the caller that owns that lifecycle. Keeping this copy
+* explicit also makes JavaScript callers subject to the same boundary.
+*/
+function freshTurnInput(input, runtime) {
+	return {
+		...input.prompt === void 0 ? {} : { prompt: input.prompt },
+		...input.parts === void 0 ? {} : { parts: input.parts },
+		...input.model === void 0 ? {} : { model: input.model },
+		...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+		...input.context === void 0 ? {} : { context: input.context },
+		...input.providerOptions === void 0 ? {} : { providerOptions: input.providerOptions },
+		...input.signal === void 0 ? {} : { signal: input.signal },
+		turnId: runtime.turnId,
+		detach: runtime.detach,
+		...runtime.sessionId === void 0 ? {} : { sessionId: runtime.sessionId },
+		...runtime.executionId === void 0 ? {} : { executionId: runtime.executionId },
+		...runtime.contextTransfer === void 0 ? {} : { contextTransfer: runtime.contextTransfer }
+	};
+}
+//#endregion
+//#region src/runtime/retained-run-start.ts
+/**
+* Dispatch one detached, replayable run and return only after exact durable
+* coordinates are confirmed by the provider.
+*
+* @stable
+*/
+async function startRetainedRun(options) {
+	assertStableText(options.environment.idempotencyKey, "environment idempotency key");
+	assertStableText(options.turn.turnId, "turn idempotency key");
+	if (options.identity !== void 0) {
+		assertStableText(options.identity.sessionId, "retained session id");
+		assertStableText(options.identity.executionId, "retained execution id");
+	}
+	const capabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.create(options.environment);
+	if (!environment.dispatch || !environment.session) {
+		try {
+			await environment.destroy?.();
+		} catch (cleanupError) {
+			throw new AggregateError([/* @__PURE__ */ new Error(`provider "${options.provider.name}" does not expose detached session control`), cleanupError], "retained run could not start and its unused environment could not be destroyed");
+		}
+		throw new Error(`provider "${options.provider.name}" does not expose detached session control`);
+	}
+	const reference = await environment.dispatch(freshTurnInput(options.turn, {
+		turnId: options.turn.turnId,
+		detach: true,
+		...options.identity === void 0 ? {} : options.identity
+	}));
+	if (reference.provider !== void 0 && reference.provider !== options.provider.name) throw new Error("provider dispatch returned a session reference for another provider");
+	const exact = exactSession(environment, exactControlRef(reference.controlRef, {
+		provider: options.provider.name,
+		environmentId: environment.id,
+		sessionId: reference.id
+	}));
+	return createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now);
+}
+/** Rebuild a retained-run client without retaining any object from the starter. @stable */
+async function reconnectRetainedRun(options) {
+	const controlRef = AgentExactRunControlRefSchema.parse(options.controlRef);
+	if (controlRef.provider !== options.provider.name) throw new Error(`run provider "${controlRef.provider}" does not match "${options.provider.name}"`);
+	const capabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.get(controlRef.environmentId);
+	if (!environment) return null;
+	const exact = exactSession(environment, controlRef);
+	return createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now);
+}
+async function assertRetainedCapabilities(provider) {
+	const capabilities = AgentEnvironmentCapabilitiesSchema.parse(await provider.capabilities());
+	const retained = capabilities.retainedControl;
+	if (retained?.exactRunIdentity !== true || retained.resultIdentity !== true || retained.eventIdentity !== true || retained.cancellationIdempotency !== true || !capabilities.streaming.detach || !capabilities.streaming.replay || !capabilities.streaming.turnIdempotency) throw new Error(`provider "${provider.name}" cannot control a retry-safe retained run`);
+	return capabilities;
+}
+//#endregion
 //#region src/runtime/run-benchmark.ts
 /**
 * runBenchmark — the packaged optimization suite. Define a domain by implementing an
@@ -5625,6 +6175,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { pipeline as $, assertStrategyContract as A, createMcpEnvironment as At, trajectoryReport as B, chatTransportExecutor as C, renderLeaderboardSvg as Ct, pickChampion as D, McpSpawnFault as Dt, discriminatingMeans as E, defaultAuditorInstruction as Et, openSandboxRun as F, resolveSecretEnv as Ft, registerShape as G, runPersonified as H, printBenchmarkReport as I, secretEnvOfMcpServer as It, renderCorpusToInstructions as J, FileCorpus as K, runBenchmark as L, strategyAuthorContract as M, envKeyProvider as Mt, strategyAuthorSystemPrompt as N, mcpSecretEnvMetadataKey as Nt, runStrategyEvolution as O, connectStdioMcp as Ot, SandboxRunAbortError as P, resolveMcpServerLaunch as Pt, panel as Q, promotionGate as R, runCoderChecks as S, renderLeaderboardMarkdown as St, createChatSessionStore as T, auditIntent as Tt, builtinShapes as U, definePersona as V, createShapeRegistry as W, flatWidenGate as X, fanout as Y, loopUntil as Z, settledWorkerOut as _, sentinelCompletion as _t, localShell as a, createScopeAnalyst as at, analyzeTrace as b, pairwiseSignificance as bt, createVerifierEnvironment as c, harvestCorpus as ct, worktreeFanout as d, localSandboxClient as dt, selectValidWinner as et, EVIDENCE_MAX_CHARS as f, inlineSandboxClient as ft, composeWorkerEvidence as g, deterministicCompletion as gt, closingWorkerNote as h, completionAuthorizes as ht, jjWorkspace as i, buildSteerContext as it, authorStrategy as j, sanitizeMcpToolSchema as jt, selectChampion as k, materializeLocalMcp as kt, failuresAnalyst as l, defineLeaderboard as lt, VERIFY_TAIL_CHARS as m, loopDispatch as mt, makeFinding$1 as n, widen as nt, runInWorkspace as o, registryScopeAnalyst as ot, NOTE_MAX_CHARS as p, loopCampaignDispatch as pt, InMemoryCorpus as q, gitWorkspace as r, assertTraceDerivedFindings as rt, createWaterfallCollector as s, inProcessSandboxClient as st, computeFindingId$1 as t, verify as tt, superviseSurface as u, resolveSandboxClient as ut, copyUntrackedIntoClone as v, stopSentinel as vt, chatWorkerSeam as w, renderPairwiseMarkdown as wt, patchDelivered as x, renderLeaderboardHtml as xt, withUntrackedArtifacts as y, leaderboard as yt, equalKOnCost as z };
+export { loopUntil as $, assertStrategyContract as A, McpSpawnFault as At, promotionGate as B, chatTransportExecutor as C, pairwiseSignificance as Ct, pickChampion as D, renderPairwiseMarkdown as Dt, discriminatingMeans as E, renderLeaderboardSvg as Et, openSandboxRun as F, envKeyProvider as Ft, builtinShapes as G, trajectoryReport as H, printBenchmarkReport as I, mcpSecretEnvMetadataKey as It, FileCorpus as J, createShapeRegistry as K, runBenchmark as L, resolveMcpServerLaunch as Lt, strategyAuthorContract as M, materializeLocalMcp as Mt, strategyAuthorSystemPrompt as N, createMcpEnvironment as Nt, runStrategyEvolution as O, auditIntent as Ot, SandboxRunAbortError as P, sanitizeMcpToolSchema as Pt, flatWidenGate as Q, reconnectRetainedRun as R, resolveSecretEnv as Rt, runCoderChecks as S, leaderboard as St, createChatSessionStore as T, renderLeaderboardMarkdown as Tt, definePersona as U, equalKOnCost as V, runPersonified as W, renderCorpusToInstructions as X, InMemoryCorpus as Y, fanout as Z, settledWorkerOut as _, superviseDispatch as _t, localShell as a, assertTraceDerivedFindings as at, analyzeTrace as b, sentinelCompletion as bt, createVerifierEnvironment as c, registryScopeAnalyst as ct, worktreeFanout as d, defineLeaderboard as dt, panel as et, EVIDENCE_MAX_CHARS as f, resolveSandboxClient as ft, composeWorkerEvidence as g, loopDispatch as gt, closingWorkerNote as h, loopCampaignDispatch as ht, jjWorkspace as i, widen as it, authorStrategy as j, connectStdioMcp as jt, selectChampion as k, defaultAuditorInstruction as kt, failuresAnalyst as l, inProcessSandboxClient as lt, VERIFY_TAIL_CHARS as m, inlineSandboxClient as mt, makeFinding$1 as n, selectValidWinner as nt, runInWorkspace as o, buildSteerContext as ot, NOTE_MAX_CHARS as p, localSandboxClient as pt, registerShape as q, gitWorkspace as r, verify as rt, createWaterfallCollector as s, createScopeAnalyst as st, computeFindingId$1 as t, pipeline as tt, superviseSurface as u, harvestCorpus as ut, copyUntrackedIntoClone as v, completionAuthorizes as vt, chatWorkerSeam as w, renderLeaderboardHtml as wt, patchDelivered as x, stopSentinel as xt, withUntrackedArtifacts as y, deterministicCompletion as yt, startRetainedRun as z, secretEnvOfMcpServer as zt };
 
-//# sourceMappingURL=runtime-ZNVnT8h1.js.map
+//# sourceMappingURL=runtime-D5GueIHH.js.map