@yielded/agent 0.1.0-beta.172 → 0.1.0-beta.174

package/dist/{AgentRuntime-CQ-qcETl.mjs → AgentRuntime-B6qZlD3f.mjs}

@@ -4,7 +4,7 @@ import { n as utf8ByteLength } from "./utf8-B5pAmhTo.mjs";
 import { ToolParameterRejection, ToolResultBounds, TruncatedToolResult, applyToolResultBounds, unserializableToolResult } from "./core/ToolResult.mjs";
 import { IdempotencyKey } from "./core/Receipt.mjs";
 import { Emitter, Update, UpdateError } from "./core/AgentUpdates.mjs";
-import { i as isModelResolver } from "./Agent-0WvBWWbM.mjs";
+import { i as isModelResolver } from "./Agent-BiRbr73L.mjs";
 import { AgentApprovalDenied, AgentApprovalPending, AgentInputDecodeError, AgentInputError, AgentOutputError, AgentPersistenceCapacityError, AgentPolicyError, AgentRunDispositionError, AgentToolAuthorizationDenied, ContextBudgetError, ContextOverflowError, ModelProtocolError } from "./core/AgentError.mjs";
 import { IdGenerator } from "./core/IdGenerator.mjs";
 import { t as copyJson } from "./json-BlJVQZxN.mjs";
@@ -359,9 +359,8 @@ const makeAttempt = Effect.fnUntraced(function* (threadId, submissionId, attempt
 		submissionId,
 		attemptId
 	};
-	const active = /* @__PURE__ */ new Set();
 	let closed = false;
-	let generation = 0;
+	let nextGeneration = 0;
 	const offerUnsafe = (event) => {
 		try {
 			return publisher.offerUnsafe(event);
@@ -373,12 +372,7 @@ const makeAttempt = Effect.fnUntraced(function* (threadId, submissionId, attempt
 		threadId,
 		openModel: (runId, turnId) => {
 			if (closed) return void 0;
-			const model = {
-				...identity,
-				runId,
-				turnId,
-				generation: ++generation
-			};
+			const generation = ++nextGeneration;
 			let open = true;
 			const handle = {
 				offerUnsafe: (part) => {
@@ -389,31 +383,34 @@ const makeAttempt = Effect.fnUntraced(function* (threadId, submissionId, attempt
 					}) : Response.makePart(part.type, { id: part.id });
 					return offerUnsafe({
 						_tag: "Text",
-						...model,
+						...identity,
+						runId,
+						turnId,
+						generation,
 						part: detached
 					});
 				},
 				discard: () => {
-					if (!open) return;
+					if (!open || closed) return;
 					handle.close();
 					offerUnsafe({
 						_tag: "Discard",
-						...model
+						...identity,
+						runId,
+						turnId,
+						generation
 					});
 				},
 				close: () => {
 					if (!open) return;
 					open = false;
-					active.delete(handle);
 				}
 			};
-			active.add(handle);
 			return handle;
 		},
 		close: () => {
 			if (closed) return;
 			closed = true;
-			for (const handle of active) handle.close();
 			offerUnsafe({
 				_tag: "AttemptEnded",
 				...identity
@@ -508,19 +505,24 @@ const exposureSnapshot = Effect.fnUntraced(function* (definition, selection, ent
 			maxSchemaBytes: definition.toolExposure?.maxSchemaBytes ?? 262144
 		}).pipe(Effect.mapError(() => invalid("Invalid Tool exposure bounds")));
 		if (names.length > limits.maxTools) return yield* invalid("Tool exposure exceeds the configured Tool count bound");
-		if ((yield* Effect.try({
-			try: () => utf8ByteLength(JSON.stringify(names.map((name) => {
-				const tool = definition.toolkit.tools[name];
-				if (tool === void 0) throw new Error("Selected Tool is unavailable");
-				return Tool.isProviderDefined(tool) ? {
+		const declarations = [];
+		for (const name of names) {
+			const tool = definition.toolkit.tools[name];
+			if (tool === void 0) return yield* invalid("A selected Tool schema cannot be rendered");
+			declarations.push(yield* Effect.try({
+				try: () => Tool.isProviderDefined(tool) ? {
 					type: tool.providerName,
 					args: tool.args
 				} : {
 					name,
 					description: Tool.getDescription(tool),
 					parameters: Tool.getJsonSchema(tool, { transformer })
-				};
-			}))),
+				},
+				catch: () => invalid("A selected Tool schema cannot be rendered")
+			}));
+		}
+		if ((yield* Effect.try({
+			try: () => utf8ByteLength(JSON.stringify(declarations)),
 			catch: () => invalid("A selected Tool schema cannot be rendered")
 		})) > limits.maxSchemaBytes) return yield* invalid("Tool exposure exceeds the configured schema byte bound");
 	}
@@ -590,11 +592,9 @@ const restoreToolSpanFailureCause = (cause, marker, original) => {
 };
 const MAX_REPORTED_SPAN_LIFECYCLE_DEFECTS = 16;
 /** Content-free marker used only to close a delegate that cannot be wrapped safely. */
-var ToolSpanLifecycleFailure = class extends Error {
+var ToolSpanLifecycleFailure = class extends Schema.TaggedError()("ToolSpanLifecycleFailure", {}) {
 	name = "ToolSpanLifecycleFailure";
-	constructor() {
-		super("Tool span lifecycle failed");
-	}
+	message = "Tool span lifecycle failed";
 };
 /**
 * @internal Guard one host span so synchronous exporter defects cannot alter Tool execution.
@@ -636,7 +636,7 @@ var IsolatedToolSpan = class {
 	}
 	end(endTime, exit) {
 		if (this.status._tag === "Ended") return;
-		const exportedExit = this.#terminalOutcome === "failure" ? Exit.fail(this.#terminalFailure ?? new ToolSpanLifecycleFailure()) : this.#terminalOutcome === "success" ? Exit.succeed(void 0) : exit;
+		const exportedExit = this.#terminalOutcome === "failure" ? Exit.fail(this.#terminalFailure ?? ToolSpanLifecycleFailure.make({})) : this.#terminalOutcome === "success" ? Exit.succeed(void 0) : exit;
 		this.status = {
 			_tag: "Ended",
 			startTime: this.status.startTime,
@@ -780,7 +780,7 @@ const makeIsolatedToolTracer = (delegate) => {
 				} catch (defect) {
 					recordDefect(defect);
 					try {
-						delegateSpan.end(options.startTime, Exit.fail(new ToolSpanLifecycleFailure()));
+						delegateSpan.end(options.startTime, Exit.fail(ToolSpanLifecycleFailure.make({})));
 					} catch (closeDefect) {
 						recordDefect(closeDefect);
 					}
@@ -990,15 +990,14 @@ const schemaClassToolPartPreflight = (part, toolkit) => {
 		if (part === null || typeof part !== "object") return void 0;
 		const read = (key) => {
 			const descriptor = Object.getOwnPropertyDescriptor(part, key);
-			if (descriptor === void 0 || !("value" in descriptor)) throw new TypeError(`response part ${key} must be an own data property`);
-			return descriptor.value;
+			return descriptor !== void 0 && "value" in descriptor ? descriptor : void 0;
 		};
-		const type = read("type");
+		const type = read("type")?.value;
 		if (type !== "tool-call" && type !== "tool-result") return void 0;
-		const name = read("name");
+		const name = read("name")?.value;
 		if (typeof name !== "string" || !hasTool(toolkit.tools, name)) return void 0;
 		const tool = toolkit.tools[name];
-		const payload = read(type === "tool-call" ? "params" : "result");
+		const payload = read(type === "tool-call" ? "params" : "result")?.value;
 		if (payload === null || typeof payload !== "object") return void 0;
 		const payloadPrototype = Object.getPrototypeOf(payload);
 		if (!(type === "tool-call" ? [tool.parametersSchema] : [tool.successSchema, tool.failureSchema]).some((schema) => schemaClassPrototype(schema) === payloadPrototype)) return;
@@ -1019,7 +1018,11 @@ const schemaClassToolPartPreflight = (part, toolkit) => {
 			"metadata",
 			"encodedResult"
 		];
-		for (const key of retainedKeys) preflight[key] = read(key);
+		for (const key of retainedKeys) {
+			const descriptor = read(key);
+			if (descriptor === void 0) return void 0;
+			preflight[key] = descriptor.value;
+		}
 		return preflight;
 	} catch {
 		return;
@@ -1072,10 +1075,10 @@ const captureModelResponsePartGeneral = Effect.fnUntraced(function* (part, toolk
 	}
 	const encoded = yield* modelResponseParsersFor(toolkit).encode(part).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Model response part failed canonical encoding" })));
 	const retainedBytes = yield* inspectModelResponsePartCapacity(usage, encoded, limits);
+	if (typeof structuredCloneFunction !== "function") return yield* ModelProtocolError.make({ message: "Model response part could not be converted into engine-owned data" });
 	return {
 		encodedPart: yield* Effect.try({
 			try: () => {
-				if (typeof structuredCloneFunction !== "function") throw new TypeError("structuredClone is unavailable");
 				return Reflect.apply(structuredCloneFunction, globalThis, [encoded]);
 			},
 			catch: () => ModelProtocolError.make({ message: "Model response part could not be converted into engine-owned data" })
@@ -1121,25 +1124,29 @@ const encodeToolCallParameters = (tool, toolName, decodedParams) => {
 const decodeToolCallParameters = (tool, toolName, encodedParams, boundary = "execution") => {
 	return Schema.decodeUnknownEffect(tool.parametersSchema)(encodedParams).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: boundary === "model" ? `Invalid parameters for Tool ${toolName}: ${cause.message}` : `Recorded parameters for Tool ${toolName} failed validation${boundary === "resume" ? " on resume" : ""}: ${cause.message}` })));
 };
+/** Native identity proves encoding does not transform the already validated parameters. */
+const reusesValidatedToolParameters = (tool) => (tool.needsApproval === void 0 || tool.needsApproval === false) && SchemaAST.toEncoded(tool.parametersSchema.ast) === tool.parametersSchema.ast;
 /**
-* Decode executable parameters for approval while retaining their encoded form for
-* Toolkit.handle. A recorded rejection is a terminal failure, never an executable call.
+* Fresh responses and resumed batches validate every call before reaching this boundary.
+* Identity encodings with no approval need no second decoded value. Other codecs retain the
+* complete batch preflight, including validation of their canonical round trip, before dispatch.
 */
 const prepareToolCall = (toolkit, call, declarationIndex, rejection) => {
 	const name = call.name;
 	if (!hasTool(toolkit.tools, name)) return Effect.fail(ModelProtocolError.make({ message: `Model requested unknown Tool ${call.name}` }));
 	const tool = toolkit.tools[name];
-	return Effect.gen(function* () {
-		const toolCallId = yield* decodeToolCallId(call.id);
-		const validation = rejection === void 0 ? Result.succeed(yield* decodeToolCallParameters(tool, call.name, copyJson(call.params))) : Result.fail(rejection);
-		return {
+	return Effect.flatMap(decodeToolCallId(call.id), (toolCallId) => {
+		const prepared = (validation) => ({
 			call,
 			name,
 			toolCallId,
 			validation,
 			tool,
 			declarationIndex
-		};
+		});
+		if (rejection !== void 0) return Effect.succeed(prepared(Result.fail(rejection)));
+		if (reusesValidatedToolParameters(tool)) return Effect.succeed(prepared(Result.succeed(Option.none())));
+		return Effect.map(decodeToolCallParameters(tool, call.name, copyJson(call.params)), (parameters) => prepared(Result.succeed(Option.some(parameters))));
 	});
 };
 /**
@@ -1166,29 +1173,36 @@ const effectiveRunBounds = (policy, options) => ({
 	maxTurns: boundedAllowance(policy.maxTurns, options.turnAllowance),
 	maxToolCalls: boundedAllowance(policy.maxToolCalls, options.toolCallAllowance)
 });
+const readSnapshotProperty = Effect.fnUntraced(function* (input, key, invalid, optional = false) {
+	const descriptor = yield* Effect.try({
+		try: () => Object.getOwnPropertyDescriptor(input, key),
+		catch: invalid
+	});
+	if (descriptor === void 0 && optional) return void 0;
+	if (descriptor === void 0 || !("value" in descriptor)) return yield* invalid();
+	return descriptor.value;
+});
 const decodeResumedSettledCall = Effect.fnUntraced(function* (input) {
-	const raw = yield* Effect.try({
-		try: () => {
-			if (input === null || typeof input !== "object") throw new TypeError("settled Tool Call must be an object");
-			const readOwnDataProperty = (key) => {
-				const descriptor = Object.getOwnPropertyDescriptor(input, key);
-				if (descriptor === void 0 || !("value" in descriptor)) throw new TypeError(`settled Tool Call ${key} must be an own data property`);
-				return descriptor.value;
-			};
-			const selection = Object.getOwnPropertyDescriptor(input, "toolSelection");
-			if (selection !== void 0 && !("value" in selection)) throw new TypeError("settled Tool selection must be an own data property");
-			const rejected = Object.getOwnPropertyDescriptor(input, "budgetRejected");
-			if (rejected !== void 0 && !("value" in rejected)) throw new TypeError("settled Tool Call budgetRejected must be an own data property");
-			return {
-				id: readOwnDataProperty("id"),
-				result: readOwnDataProperty("result"),
-				isFailure: readOwnDataProperty("isFailure"),
-				...rejected === void 0 ? {} : { budgetRejected: rejected.value },
-				...selection === void 0 ? {} : { toolSelection: selection.value }
-			};
-		},
-		catch: () => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call" })
+	const invalid = () => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call" });
+	if (input === null || typeof input !== "object") return yield* invalid();
+	const id = yield* readSnapshotProperty(input, "id", invalid);
+	const resultValue = yield* readSnapshotProperty(input, "result", invalid);
+	const isFailure = yield* readSnapshotProperty(input, "isFailure", invalid);
+	const { selection, rejected } = yield* Effect.try({
+		try: () => ({
+			selection: Object.getOwnPropertyDescriptor(input, "toolSelection"),
+			rejected: Object.getOwnPropertyDescriptor(input, "budgetRejected")
+		}),
+		catch: invalid
 	});
+	if (selection !== void 0 && !("value" in selection) || rejected !== void 0 && !("value" in rejected)) return yield* invalid();
+	const raw = {
+		id,
+		result: resultValue,
+		isFailure,
+		...rejected === void 0 ? {} : { budgetRejected: rejected.value },
+		...selection === void 0 ? {} : { toolSelection: selection.value }
+	};
 	const result = boundedCanonicalJsonSnapshot(raw.result, MAX_RESUMED_RESULT_BYTES);
 	if (result === void 0) return yield* ModelProtocolError.make({ message: "Turn resume settled Tool result is not bounded canonical JSON" });
 	return yield* Schema.decodeUnknownEffect(RunTurnResumeSettledCallSchema)({
@@ -1196,59 +1210,48 @@ const decodeResumedSettledCall = Effect.fnUntraced(function* (input) {
 		result: result.value
 	}).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call" })));
 });
-const snapshotResumedSettledCalls = (resume, maximum) => Effect.try({
-	try: () => {
-		if (resume === null || typeof resume !== "object") throw new TypeError("Turn resume must be an object");
-		const settledDescriptor = Object.getOwnPropertyDescriptor(resume, "settled");
-		if (settledDescriptor === void 0 || !("value" in settledDescriptor)) throw new TypeError("Turn resume settled must be an own data property");
-		const settled = settledDescriptor.value;
-		if (!Array.isArray(settled)) throw new TypeError("Turn resume settled must be an array");
-		const lengthDescriptor = Object.getOwnPropertyDescriptor(settled, "length");
-		if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > maximum) throw new TypeError("Turn resume settled has an invalid length");
-		const snapshot = [];
-		for (let index = 0; index < lengthDescriptor.value; index += 1) {
-			const entryDescriptor = Object.getOwnPropertyDescriptor(settled, String(index));
-			if (entryDescriptor === void 0 || !("value" in entryDescriptor)) throw new TypeError("Turn resume settled entries must be own data properties");
-			snapshot.push(entryDescriptor.value);
-		}
-		return snapshot;
-	},
-	catch: () => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call collection" })
+const snapshotResumedSettledCalls = Effect.fnUntraced(function* (resume, maximum) {
+	const invalid = () => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call collection" });
+	if (resume === null || typeof resume !== "object") return yield* invalid();
+	const settled = yield* readSnapshotProperty(resume, "settled", invalid);
+	if (!(yield* Effect.try({
+		try: () => Array.isArray(settled),
+		catch: invalid
+	})) || settled === null || typeof settled !== "object") return yield* invalid();
+	const length = yield* readSnapshotProperty(settled, "length", invalid);
+	if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > maximum) return yield* invalid();
+	const snapshot = [];
+	for (let index = 0; index < length; index += 1) snapshot.push(yield* readSnapshotProperty(settled, String(index), invalid));
+	return snapshot;
 });
 const decodeResumeUsage = Effect.fnUntraced(function* (input) {
-	const snapshot = yield* Effect.try({
-		try: () => {
-			if (input === null || typeof input !== "object") throw new TypeError("Run resume usage must be an object");
-			const read = (key, optional = false) => {
-				const descriptor = Object.getOwnPropertyDescriptor(input, key);
-				if (descriptor === void 0 && optional) return void 0;
-				if (descriptor === void 0 || !("value" in descriptor)) throw new TypeError(`Run resume usage ${key} must be an own data property`);
-				return descriptor.value;
-			};
-			return {
-				...Object.fromEntries([
-					"usageStatus",
-					"pricingStatus",
-					"unobservedModelCalls",
-					"children",
-					"modelRestarts",
-					"webSearchCalls"
-				].map((key) => [key, read(key, true)]).filter(([, value]) => value !== void 0)),
-				modelCalls: read("modelCalls"),
-				inputTokens: read("inputTokens"),
-				outputTokens: read("outputTokens"),
-				lastInputTokens: read("lastInputTokens"),
-				lastOutputTokens: read("lastOutputTokens"),
-				costMicrousd: read("costMicrousd"),
-				committedTurns: read("committedTurns"),
-				toolCalls: read("toolCalls"),
-				programmaticToolCalls: read("programmaticToolCalls"),
-				consecutiveToolFailures: read("consecutiveToolFailures"),
-				finalizationUsed: read("finalizationUsed")
-			};
-		},
-		catch: () => ModelProtocolError.make({ message: "Run resume usage requires own data properties with non-negative safe-integer totals and last-call tokens no greater than their cumulative totals" })
-	});
+	const invalid = () => ModelProtocolError.make({ message: "Run resume usage requires own data properties with non-negative safe-integer totals and last-call tokens no greater than their cumulative totals" });
+	if (input === null || typeof input !== "object") return yield* invalid();
+	const snapshot = {};
+	for (const key of [
+		"usageStatus",
+		"pricingStatus",
+		"unobservedModelCalls",
+		"children",
+		"modelRestarts",
+		"webSearchCalls"
+	]) {
+		const value = yield* readSnapshotProperty(input, key, invalid, true);
+		if (value !== void 0) snapshot[key] = value;
+	}
+	for (const key of [
+		"modelCalls",
+		"inputTokens",
+		"outputTokens",
+		"lastInputTokens",
+		"lastOutputTokens",
+		"costMicrousd",
+		"committedTurns",
+		"toolCalls",
+		"programmaticToolCalls",
+		"consecutiveToolFailures",
+		"finalizationUsed"
+	]) snapshot[key] = yield* readSnapshotProperty(input, key, invalid);
 	return yield* Schema.decodeUnknownEffect(RunResumeUsageSchema)(snapshot).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Run resume usage requires own data properties with non-negative safe-integer totals and last-call tokens no greater than their cumulative totals" })));
 });
 const makeToolFailedEvent = Effect.fnUntraced(function* (context, turnId, call, error, failureHandling, budgetRejected) {
@@ -1354,7 +1357,8 @@ const stampSubagentEvent = Effect.fnUntraced(function* (context, turnId, payload
 });
 const prepareApprovalRequest = (context, turnId, prepared) => prepareWithinDeadline(context, Effect.gen(function* () {
 	if (Result.isFailure(prepared.validation)) return void 0;
-	const decodedParams = prepared.validation.success;
+	if (Option.isNone(prepared.validation.success)) return void 0;
+	const decodedParams = prepared.validation.success.value;
 	const approval = prepared.tool.needsApproval;
 	if (!(typeof approval === "function" ? yield* Effect.suspend(() => {
 		const result = approval(decodedParams, {
@@ -1678,7 +1682,7 @@ const executePreparedToolCall = Effect.fnUntraced(function* (context, turnId, to
 		}));
 		if (result.isFailure) return yield* failureMarker();
 	});
-	const failTerminalResult = (cause) => Effect.gen(function* () {
+	const failTerminalResult = Effect.fnUntraced(function* (cause) {
 		terminal = true;
 		terminalResult = void 0;
 		propagatedFailure = cause;
@@ -1716,10 +1720,11 @@ const executeToolBatch = Effect.fnUntraced(function* (context, turnId, turn, too
 	const visibility = yield* RunToolVisibility;
 	const eligible = new Set(context.toolCatalog.filter((entry) => entry.kind === "native").map((entry) => entry.nativeToolName));
 	if (calls.some((call) => exposed !== void 0 && !exposed.includes(call.name) || visibility !== void 0 && !settledCallIds?.has(call.id) && !eligible.has(call.name))) return yield* ModelProtocolError.make({ message: "Tool batch calls a Tool outside its request exposure or current visibility" });
-	const prepared = yield* prepareWithinDeadline(context, Effect.forEach(calls.flatMap((call, declarationIndex) => settledCallIds?.has(call.id) ? [] : [{
+	const prepareCalls = Effect.forEach(calls.flatMap((call, declarationIndex) => settledCallIds?.has(call.id) ? [] : [{
 		call,
 		declarationIndex
-	}]), ({ call, declarationIndex }) => prepareToolCall(toolkit, call, declarationIndex, trace.toolParameterRejections.get(call.id))));
+	}]), ({ call, declarationIndex }) => prepareToolCall(toolkit, call, declarationIndex, trace.toolParameterRejections.get(call.id)));
+	const prepared = yield* calls.some((call) => !settledCallIds?.has(call.id) && !trace.toolParameterRejections.has(call.id) && hasTool(toolkit.tools, call.name) && !reusesValidatedToolParameters(toolkit.tools[call.name])) ? prepareWithinDeadline(context, prepareCalls) : Effect.flatMap(Clock.currentTimeMillis, (now) => context.durationDeadlineMillis - now <= 0 ? Effect.fail(context.durationFailure) : prepareCalls);
 	if (prepared.some((call) => Context.get(call.tool.annotations, ContextRolloverTool)) && calls.length !== 1) return yield* ModelProtocolError.make({ message: "A context rollover Tool must be the only Tool Call in its batch" });
 	const descriptors = trace.applicationCallDescriptors.filter((call) => !trace.toolParameterRejections.has(call.toolCallId));
 	const executable = settledCallIds === void 0 ? prepared : prepared.filter((call) => !settledCallIds.has(call.call.id));
@@ -1792,25 +1797,25 @@ const executeToolBatch = Effect.fnUntraced(function* (context, turnId, turn, too
 		"SubagentFailed",
 		"SubagentInterrupted",
 		"SubagentJoined"
-	].includes(payload._tag) ? Effect.fail(new RunEventSinkClosedError({ message: "Unsupported Tool event payload" })) : emitPayload(payload) };
+	].includes(payload._tag) ? Effect.fail(RunEventSinkClosedError.make({ message: "Unsupported Tool event payload" })) : emitPayload(payload) };
 	const updateAcceptance = yield* AgentUpdateAcceptance;
 	const updateEmitter = { emit: (request) => context.updatePermits.withPermit(Effect.gen(function* () {
-		if (!updatesOpen) return yield* new UpdateError({ reason: "unavailable" });
-		if (request.target.id !== context.agentId || request.target.updates !== context.definition.updates || context.definition.updates === void 0) return yield* new UpdateError({ reason: "identity" });
-		const updateId = yield* Schema.decodeEffect(IdempotencyKey)(request.updateId).pipe(Effect.mapError(() => new UpdateError({ reason: "validation" })));
-		const value = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Json))(JSON.stringify(request.value)).pipe(Effect.mapError(() => new UpdateError({ reason: "validation" })));
+		if (!updatesOpen) return yield* UpdateError.make({ reason: "unavailable" });
+		if (request.target.id !== context.agentId || request.target.updates !== context.definition.updates || context.definition.updates === void 0) return yield* UpdateError.make({ reason: "identity" });
+		const updateId = yield* Schema.decodeEffect(IdempotencyKey)(request.updateId).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
+		const value = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Json))(JSON.stringify(request.value)).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
 		yield* context.validateUpdate(value);
 		const existing = context.updates.get(updateId);
 		if (existing !== void 0) {
-			if (!Schema.toEquivalence(Schema.Json)(existing.value, value)) return yield* new UpdateError({ reason: "conflict" });
+			if (!Schema.toEquivalence(Schema.Json)(existing.value, value)) return yield* UpdateError.make({ reason: "conflict" });
 			return existing;
 		}
 		const bytes = utf8ByteLength(JSON.stringify(value));
 		const maxCount = options.updates?.maxCount ?? 32;
 		const maxBytes = options.updates?.maxBytes ?? 16384;
-		if (!Number.isSafeInteger(maxCount) || maxCount < 1 || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || context.updates.size >= maxCount || context.updateBytes + bytes > maxBytes) return yield* new UpdateError({ reason: "capacity" });
+		if (!Number.isSafeInteger(maxCount) || maxCount < 1 || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || context.updates.size >= maxCount || context.updateBytes + bytes > maxBytes) return yield* UpdateError.make({ reason: "capacity" });
 		const snapshot = boundedCanonicalJsonSnapshot(value, bytes);
-		if (snapshot === void 0) return yield* new UpdateError({ reason: "validation" });
+		if (snapshot === void 0) return yield* UpdateError.make({ reason: "validation" });
 		const accepted = yield* updateAcceptance.accept(Object.freeze(Update.make({
 			schemaVersion: 1,
 			agentId: context.agentId,
@@ -1820,8 +1825,8 @@ const executeToolBatch = Effect.fnUntraced(function* (context, turnId, turn, too
 			sequence: context.updates.size + 1,
 			value: snapshot.value
 		})));
-		const validated = yield* Schema.decodeEffect(Update)(accepted).pipe(Effect.mapError(() => new UpdateError({ reason: "validation" })));
-		if (validated.agentId !== context.agentId || validated.threadId !== context.threadId || validated.runId !== context.runId || validated.updateId !== request.updateId || !Schema.toEquivalence(Schema.Json)(validated.value, value)) return yield* new UpdateError({ reason: "identity" });
+		const validated = yield* Schema.decodeEffect(Update)(accepted).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
+		if (validated.agentId !== context.agentId || validated.threadId !== context.threadId || validated.runId !== context.runId || validated.updateId !== request.updateId || !Schema.toEquivalence(Schema.Json)(validated.value, value)) return yield* UpdateError.make({ reason: "identity" });
 		const update = Object.freeze(Update.make({
 			...validated,
 			value: snapshot.value
@@ -1831,43 +1836,43 @@ const executeToolBatch = Effect.fnUntraced(function* (context, turnId, turn, too
 		yield* emitPayload({
 			_tag: "AgentUpdateEmitted",
 			update
-		}).pipe(Effect.mapError(() => new UpdateError({ reason: "unavailable" })));
+		}).pipe(Effect.mapError(() => UpdateError.make({ reason: "unavailable" })));
 		return update;
 	})) };
 	const permits = yield* Semaphore.make(concurrency);
 	const handlers = Effect.gen(function* () {
 		for (const group of groups) {
-			yield* Effect.forEach(group, (call) => permits.withPermit(Effect.scoped(Effect.gen(function* () {
-				const callBody = Effect.scoped(Effect.gen(function* () {
-					yield* checkpointExecution(context, durability);
-					const subagentHost = yield* SubagentHost.forTool;
-					const messagingHost = yield* MessagingHost.forTool;
-					const source = {
-						_tag: "tool",
-						agentId: context.agentId,
-						threadId: context.threadId,
-						runId: context.runId,
-						toolCallId: call.toolCallId
-					};
-					const broker = yield* makeToolBrokerService({
-						context,
-						turnId,
-						outerToolCallId: call.toolCallId,
-						turn,
-						maxToolCalls: brokerAccounting.maxToolCalls,
-						declaredToolCalls: brokerAccounting.declaredToolCalls,
-						budget: options.budget,
-						reservePolicyUsage: durability?.reservePolicyUsage,
-						hookServices
-					});
-					return yield* executePreparedToolCall(context, turnId, toolkit, call, trace, resultBounds, (waiting) => {
-						waitingByDeclaration.set(call.declarationIndex, waiting);
-					}).pipe(Effect.provideService(DurableStep, stepServiceFor(call)), Effect.provideService(SubagentHost, subagentHost(source)), Effect.provideService(MessagingHost, messagingHost(source)), Effect.provideService(ToolBroker, broker.service), Effect.provideService(CurrentToolCatalog, { entries: context.toolCatalog }), Effect.ensuring(Effect.sync(() => broker.close())));
-				}));
-				const fiber = yield* Effect.forkScoped(callBody);
-				return yield* Fiber.join(fiber);
-			}))), {
-				concurrency: "unbounded",
+			yield* Effect.forEach(group, (call) => permits.withPermit(Effect.acquireUseRelease(Effect.forkScoped(Effect.scoped(Effect.gen(function* () {
+				yield* checkpointExecution(context, durability);
+				const subagentHost = yield* SubagentHost.forTool;
+				const messagingHost = yield* MessagingHost.forTool;
+				const source = {
+					_tag: "tool",
+					agentId: context.agentId,
+					threadId: context.threadId,
+					runId: context.runId,
+					toolCallId: call.toolCallId
+				};
+				const broker = yield* makeToolBrokerService({
+					context,
+					turnId,
+					outerToolCallId: call.toolCallId,
+					turn,
+					maxToolCalls: brokerAccounting.maxToolCalls,
+					declaredToolCalls: brokerAccounting.declaredToolCalls,
+					budget: options.budget,
+					reservePolicyUsage: durability?.reservePolicyUsage,
+					hookServices
+				});
+				const step = stepServiceFor(call);
+				const subagent = subagentHost(source);
+				const messaging = messagingHost(source);
+				const catalog = { entries: context.toolCatalog };
+				return yield* executePreparedToolCall(context, turnId, toolkit, call, trace, resultBounds, (waiting) => {
+					waitingByDeclaration.set(call.declarationIndex, waiting);
+				}).pipe(Effect.updateContext((services) => services.pipe(Context.add(CurrentToolCatalog, catalog), Context.add(ToolBroker, broker.service), Context.add(MessagingHost, messaging), Context.add(SubagentHost, subagent), Context.add(DurableStep, step))), Effect.ensuring(Effect.sync(() => broker.close())));
+			}))), Fiber.join, Fiber.interrupt)), {
+				concurrency: group.length === 1 ? 1 : "unbounded",
 				discard: true
 			});
 			yield* checkpointExecution(context, durability);
@@ -2451,7 +2456,7 @@ const compactContext = (agent, context, source, turn, options, resolvedModelInpu
 			let summaryFailure;
 			const textParts = /* @__PURE__ */ new Map();
 			const reasoningParts = /* @__PURE__ */ new Map();
-			const consumeSummaryPart = (owned) => Effect.gen(function* () {
+			const consumeSummaryPart = Effect.fnUntraced(function* (owned) {
 				responseUsage.responsePartCount++;
 				responseUsage.responsePartBytes += owned.retainedBytes;
 				const ownedPart = owned.ownedPart;
@@ -2604,13 +2609,13 @@ const evaluateInstructions = (instructions, input) => Effect.suspend(() => {
 	return Effect.isEffect(result) ? result : Effect.succeed(result);
 });
 const encodeInput = (agent, input) => Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
-const renderInputPromptEffect = (inputPrompt, decodedInput, encodedInput) => inputPrompt === void 0 ? Effect.try({
-	try: () => {
-		const encoded = JSON.stringify(encodedInput);
-		if (encoded === void 0) throw new Error("Agent input cannot be represented as JSON");
-		return encoded;
-	},
-	catch: (cause) => AgentInputError.make({ message: `Unable to materialize Agent input: ${errorMessage(cause)}` })
+const renderInputPromptEffect = (inputPrompt, decodedInput, encodedInput) => inputPrompt === void 0 ? Effect.gen(function* () {
+	const encoded = yield* Effect.try({
+		try: () => JSON.stringify(encodedInput),
+		catch: (cause) => AgentInputError.make({ message: `Unable to materialize Agent input: ${errorMessage(cause)}` })
+	});
+	if (encoded === void 0) return yield* AgentInputError.make({ message: "Unable to materialize Agent input: Agent input cannot be represented as JSON" });
+	return encoded;
 }) : Effect.suspend(() => {
 	const result = inputPrompt(decodedInput);
 	return Effect.isEffect(result) ? result : Effect.succeed(result);
@@ -2782,7 +2787,7 @@ const processModelPart = Effect.fnUntraced(function* (context, turnId, turn, too
 				const error = AiError.make({
 					module: "Toolkit",
 					method: `${part.name}.handle`,
-					reason: new AiError.ToolParameterValidationError({
+					reason: AiError.ToolParameterValidationError.make({
 						toolName: part.name,
 						description: decoded.failure.message
 					})
@@ -3030,10 +3035,10 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 		...outputContractMessage === void 0 ? {} : { outputContract: outputContractMessage }
 	};
 	const modelContext = options.context === void 0 ? { prompt } : yield* prepareWithinDeadline(context, options.context.prepare(contextRequest));
-	if (context.resolvedModel && modelContext.modelCall !== void 0) return yield* new AiError.AiError({
+	if (context.resolvedModel && modelContext.modelCall !== void 0) return yield* AiError.AiError.make({
 		module: "AgentRuntime",
 		method: "resolveModel",
-		reason: new AiError.InvalidRequestError({ description: "Context preparation cannot replace a thread-resolved model" })
+		reason: AiError.InvalidRequestError.make({ description: "Context preparation cannot replace a thread-resolved model" })
 	});
 	const callContext = modelContext.modelCall === void 0 ? void 0 : yield* Schema.decodeEffect(ModelCallContext)(modelContext.modelCall.context).pipe(Effect.mapError((cause) => CompactionError.make({
 		message: "Invalid resolved model context bounds",
@@ -3384,10 +3389,12 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 	}))));
 	const attemptWithRetries = Effect.suspend(() => attempt(compactedOutgoing())).pipe(Effect.retry(($) => $(Schedule.exponential(MODEL_RETRY_BASE)).pipe(Schedule.upTo({ times: policy.modelRetries ?? 0 }), Schedule.while(({ input: error }) => {
 		const lastPart = trace.parts.at(-1);
-		return canRepeatModelCall && !hasStreamedContent(trace) && (lastPart?.type === "error" && isTransientErrorPayload(lastPart.error) || AiError.isAiError(error) && error.isRetryable);
+		const providerError = error;
+		return canRepeatModelCall && !hasStreamedContent(trace) && (lastPart?.type === "error" && isTransientErrorPayload(lastPart.error) || AiError.isAiError(providerError) && providerError.isRetryable);
 	}), Schedule.modifyDelay(({ input: error, duration }) => Effect.gen(function* () {
 		const backoff = Duration.min(duration, MODEL_RETRY_MAX_DELAY);
-		const retryAfter = AiError.isAiError(error) ? error.retryAfter : void 0;
+		const providerError = error;
+		const retryAfter = AiError.isAiError(providerError) ? providerError.retryAfter : void 0;
 		const requested = retryAfter === void 0 ? backoff : Duration.max(backoff, retryAfter);
 		const remaining = Math.max(0, context.durationDeadlineMillis - (yield* Clock.currentTimeMillis));
 		return Duration.min(requested, Duration.millis(remaining));
@@ -3551,7 +3558,7 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 		* steering at the safe seam, and start the next Turn. The `maxTurns`
 		* guard already ran for these Tool Call sites.
 		*/
-		const continueTurn = (history) => Effect.gen(function* () {
+		const continueTurn = Effect.fnUntraced(function* (history) {
 			trace.historyAccepted = true;
 			yield* advanceHistory(context, history, options);
 			yield* settleTurn(context, trace, turn, turnId, options);
@@ -3565,7 +3572,7 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 		* under the `maxTurns` and repeated-failure Stop Policy bounds or
 		* complete the Run with the Turn's decoded final output.
 		*/
-		const settleOrFollowUp = (history) => Effect.gen(function* () {
+		const settleOrFollowUp = Effect.fnUntraced(function* (history) {
 			trace.historyAccepted = true;
 			yield* advanceHistory(context, history, options);
 			const turnsBlocked = policy.onExhaustion === "fail" ? turn >= bounds.maxTurns : turn > bounds.maxTurns;
@@ -4081,7 +4088,7 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 			const initialToolSelection = options.toolSelection ?? (agent.definition.toolExposure === void 0 ? void 0 : { toolNames: agent.definition.toolExposure.initialToolNames ?? [] });
 			const updateSchema = agent.definition.updates;
 			const updateContext = yield* Effect.context();
-			const validateUpdate = updateSchema === void 0 ? () => Effect.fail(new UpdateError({ reason: "unavailable" })) : (value) => Schema.decodeEffect(updateSchema)(value).pipe(Effect.provide(updateContext), Effect.asVoid, Effect.mapError(() => new UpdateError({ reason: "validation" })));
+			const validateUpdate = updateSchema === void 0 ? () => Effect.fail(UpdateError.make({ reason: "unavailable" })) : (value) => Schema.decodeEffect(updateSchema)(value).pipe(Effect.provide(updateContext), Effect.asVoid, Effect.mapError(() => UpdateError.make({ reason: "validation" })));
 			const languageModel = yield* LanguageModel.LanguageModel;
 			const resolver = isModelResolver(languageModel) ? languageModel : void 0;
 			const context = {
@@ -4270,10 +4277,10 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 					turn: pending.turn,
 					input: context.input
 				}, options.subagentGrant, options.delegationDepth ?? options.parentLink?.depth ?? 0);
-				const selectionPrompt = yield* Schema.encodeEffect(Schema.fromJsonString(Prompt.Prompt))(pending.prompt).pipe(Effect.mapError((cause) => new AiError.AiError({
+				const selectionPrompt = yield* Schema.encodeEffect(Schema.fromJsonString(Prompt.Prompt))(pending.prompt).pipe(Effect.mapError((cause) => AiError.AiError.make({
 					module: "AgentRuntime",
 					method: "resolveModel",
-					reason: new AiError.InvalidRequestError({ description: `Cannot encode model selection context: ${cause.message}` })
+					reason: AiError.InvalidRequestError.make({ description: `Cannot encode model selection context: ${cause.message}` })
 				})));
 				const selected = yield* prepareWithinDeadline(context, resolver.resolve({
 					threadId,
@@ -4289,11 +4296,11 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 				return Effect.provide(turns, services);
 			}));
 			const nativeUpdateTool = agent.definition.toolkit.tools.emit_update;
-			const updateHandlers = agent.definition.updates === void 0 || nativeUpdateTool === void 0 ? Context.empty() : yield* Toolkit.make(nativeUpdateTool).toHandlers({ emit_update: (parameters, call) => Effect.gen(function* () {
-				if (call.toolCallId === void 0) return yield* new UpdateError({ reason: "unavailable" });
-				const decoded = yield* Schema.decodeUnknownEffect(Schema.Struct({ value: Schema.Unknown }))(parameters).pipe(Effect.mapError(() => new UpdateError({ reason: "validation" })));
-				const value = yield* Schema.encodeUnknownEffect(agent.definition.updates)(decoded.value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Json)), Effect.mapError(() => new UpdateError({ reason: "validation" })));
-				const updateId = yield* Schema.decodeEffect(IdempotencyKey)(`tool:${context.runId}:${call.toolCallId}`).pipe(Effect.mapError(() => new UpdateError({ reason: "validation" })));
+			const updateHandlers = agent.definition.updates === void 0 || nativeUpdateTool === void 0 ? Context.empty() : yield* Toolkit.make(nativeUpdateTool).toHandlers({ emit_update: Effect.fnUntraced(function* (parameters, call) {
+				if (call.toolCallId === void 0) return yield* UpdateError.make({ reason: "unavailable" });
+				const decoded = yield* Schema.decodeUnknownEffect(Schema.Struct({ value: Schema.Unknown }))(parameters).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
+				const value = yield* Schema.encodeUnknownEffect(agent.definition.updates)(decoded.value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Json)), Effect.mapError(() => UpdateError.make({ reason: "validation" })));
+				const updateId = yield* Schema.decodeEffect(IdempotencyKey)(`tool:${context.runId}:${call.toolCallId}`).pipe(Effect.mapError(() => UpdateError.make({ reason: "validation" })));
 				yield* (yield* Emitter).emit({
 					target: agent.definition,
 					updateId,
@@ -4323,7 +4330,7 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 					contextTokenLimit,
 					remainingTokens: contextTokenLimit === null ? null : Math.max(0, contextTokenLimit - estimatedTokens)
 				});
-			}) }), Context.merge(updateHandlers), Context.add(Emitter, { emit: () => Effect.fail(new UpdateError({ reason: "unavailable" })) }), Context.add(CurrentToolCatalog, { entries: [] }), Context.add(RunToolVisibility, visibility), Context.add(RunEventSink, closedRunEventSink), Context.add(DurableStep, closedDurableStep), Context.add(SubagentDurability, closedSubagentDurability), Context.add(SubagentHost, SubagentHost.unavailable), Context.add(MessagingHost, MessagingHost.unavailable), Context.add(CurrentSubagentAuthority, options.subagentGrant === void 0 ? void 0 : {
+			}) }), Context.merge(updateHandlers), Context.add(Emitter, { emit: () => Effect.fail(UpdateError.make({ reason: "unavailable" })) }), Context.add(CurrentToolCatalog, { entries: [] }), Context.add(RunToolVisibility, visibility), Context.add(RunEventSink, closedRunEventSink), Context.add(DurableStep, closedDurableStep), Context.add(SubagentDurability, closedSubagentDurability), Context.add(SubagentHost, SubagentHost.unavailable), Context.add(MessagingHost, MessagingHost.unavailable), Context.add(CurrentSubagentAuthority, options.subagentGrant === void 0 ? void 0 : {
 				grant: options.subagentGrant,
 				depth: options.delegationDepth ?? options.parentLink?.depth ?? 0
 			}), Context.add(ToolBroker, closedToolBroker));
@@ -4470,13 +4477,13 @@ const executeWithUsageAccountingUnknown = (agent, input, options) => executeWith
 /** Accept schema-encoded input, retaining runtime validation. Use streamUnknown for external data. */
 const stream = (agent, input, options) => streamUnknown(agent, input, options);
 function runUnknown(agent, input, options = {}) {
-	const program = "definition" in agent ? agent : { definition: agent };
+	const program = { definition: "definition" in agent ? agent.definition : agent };
 	return runProgram(program, (onCompleted) => executeWithCompletion(agent, input, options, onCompleted).pipe(Effect.provide(Layer.mergeAll(ModelUsageAccounting.layerEphemeral, AgentUpdateAcceptance.layerEphemeral))));
 }
 /** Accept schema-encoded input, retaining runtime validation. Use runUnknown for external data. */
 const run = (agent, input, options) => runUnknown(agent, input, options);
 function startUnknown(agent, input, options = {}) {
-	const program = "definition" in agent ? agent : { definition: agent };
+	const program = { definition: "definition" in agent ? agent.definition : agent };
 	return startProgram(program, (executionOptions, onCompleted, onUsage, publish) => executeWithCompletion(agent, input, executionOptions, onCompleted, onUsage, publish).pipe(Effect.provide(Layer.mergeAll(ModelUsageAccounting.layerEphemeral, AgentUpdateAcceptance.layerEphemeral))), options);
 }
 /** Accept schema-encoded input, retaining runtime validation. Use startUnknown for external data. */
@@ -4607,11 +4614,12 @@ const makeToolBrokerService = Effect.fnUntraced(function* (binding) {
 		permits: Semaphore.makeUnsafe(1)
 	};
 	return {
-		service: { openPass: (toolkit, passOptions) => Effect.gen(function* () {
+		service: { openPass: Effect.fnUntraced(function* (toolkit, passOptions) {
 			const inheritedAuthority = yield* CurrentSubagentAuthority;
 			if (lifecycle.closed) return yield* ToolBrokerUnavailableError.make({ message: "The outer Tool Call for this broker has already settled" });
 			if (passOptions === void 0 || !Number.isSafeInteger(passOptions.maxResultBytes) || passOptions.maxResultBytes <= 0) return yield* ToolBrokerConfigurationError.make({ message: `maxResultBytes must be a positive safe integer; received ${String(passOptions?.maxResultBytes)}` });
 			const handlerServices = yield* Effect.context();
+			const handle = toolkit.handle;
 			const concurrency = passOptions.concurrency ?? 4;
 			if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 64) return yield* ToolBrokerConfigurationError.make({ message: "concurrency must be an integer between 1 and 64" });
 			const permits = yield* Semaphore.make(concurrency);
@@ -4740,7 +4748,7 @@ const makeToolBrokerService = Effect.fnUntraced(function* (binding) {
 					yield* Metric.update(toolCounter, 1);
 					let terminal;
 					let resultAfterTerminal = false;
-					const handlerFailed = yield* Stream.unwrap(toolSpanTelemetry.isolateToolkitHandle(toolkit.handle(input.toolName, input.encodedArguments, handleId))).pipe(Stream.runForEach((result) => Effect.sync(() => {
+					const handlerFailed = yield* Stream.unwrap(toolSpanTelemetry.isolateToolkitHandle(handle(input.toolName, input.encodedArguments, handleId))).pipe(Stream.runForEach((result) => Effect.sync(() => {
 						if (terminal !== void 0) {
 							resultAfterTerminal = true;
 							return;
@@ -4818,7 +4826,7 @@ const makeToolBrokerService = Effect.fnUntraced(function* (binding) {
 					};
 				})));
 				return yield* observer === void 0 ? recorded : recorded.pipe(Effect.tap(() => failureObservation === void 0 ? Effect.void : deliverToolFailure(observer, failureObservation)));
-			}).pipe(Effect.provideContext(handlerServices));
+			}).pipe(Effect.updateContext((current) => Context.merge(current, handlerServices)));
 			return {
 				snapshot: Effect.sync(() => records.map((record) => ({ ...record }))),
 				invoke: (input) => Effect.suspend(() => {
@@ -4890,7 +4898,7 @@ const passthroughDurableStep = () => {
 const provideHookServices = (effect, services) => effect.pipe(Effect.provideContext(services));
 const makeDurableStepService = (toolCallId, hook, hookServices) => {
 	const usedNames = /* @__PURE__ */ new Set();
-	return { do: (name, output, execute) => Effect.gen(function* () {
+	return { do: Effect.fnUntraced(function* (name, output, execute) {
 		if (usedNames.has(name)) return yield* DurableStepError.make({
 			toolCallId,
 			stepName: name,
@@ -5199,4 +5207,4 @@ var AgentRuntime_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 export { boundedValueFootprint as C, withAttempt as S, startUnknown as _, SubagentDurability as a, streamWithUsageAccountingUnknown as b, decodeFinalOutput as c, projectCompletionFromToolOutput as d, projectCompletionOutput as f, start as g, runUnknown as h, AgentSpawner as i, encodeRunDisposition as l, run as m, AgentChildPending as n, SubagentDurabilityError as o, renderInputPrompt as p, AgentResultSchema as r, ToolCallWaiting as s, AgentRuntime_exports as t, executeWithUsageAccountingUnknown as u, stream as v, withTerminalDefectEvent as x, streamUnknown as y };
 
-//# sourceMappingURL=AgentRuntime-CQ-qcETl.mjs.map
+//# sourceMappingURL=AgentRuntime-B6qZlD3f.mjs.map