@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.175

package/dist/{AgentRuntime-CQ-qcETl.mjs → AgentRuntime-DaDKMasp.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";
@@ -13,11 +13,11 @@ import { a as PinnedTool, c as ToolNames, i as Limits, l as ToolNamespace, n as
 import { InputTokenUsage, ModelCallUsage, ModelResponseIdentity, OutputTokenUsage, RunTotals, RunUsageReport, emptyRunTotals, sumRunTotals, unknownRunTotals } from "./core/Usage.mjs";
 import { AgentUpdateEmitted, ApprovalRequested, BudgetWarning, CompactionPerformed, ModelRestarted, ModelStarted, ReasoningDelta, RunCompleted, RunFailed, RunStarted, RunSuspended, SubagentCompleted, SubagentFailed, SubagentInterrupted, SubagentJoined, SubagentProgress, SubagentRequested, SubagentStarted, TextDelta, ToolCallDeclared, ToolCallFailed, ToolCallStarted, ToolCallSucceeded, ToolProgress, TurnCompleted, TurnStarted } from "./core/RunEvent.mjs";
 import { r as FrameworkMessage, t as AssignmentDisposition } from "./Worker-DZjdMjZn.mjs";
-import { t as MessagingHost } from "./MessagingHost-CRUK4JBi.mjs";
+import { t as MessagingHost } from "./MessagingHost-CZCyrnvJ.mjs";
 import { SubagentHost } from "./engine/SubagentHost.mjs";
 import { ThreadHistory, ThreadHistoryError } from "./engine/ThreadHistory.mjs";
 import { n as RunToolVisibility, t as CurrentToolCatalog } from "./ToolExposure-DBATXxmL.mjs";
-import { n as outputSchemaContract, r as prepareModelPrompt, t as isTextOutput } from "./output-contract-CMIhu4Cw.mjs";
+import { n as outputSchemaContract, r as prepareModelPrompt, t as isTextOutput } from "./output-contract-DCnLYCdp.mjs";
 import { _ as initialCompactionState, b as boundedCanonicalJsonSnapshot, d as collectCoveredMessages, f as contextWindowId, g as evaluateMessageTokenEstimates, h as estimatePromptTokens, m as estimateMessageTokens, s as buildCompactedView, v as isContextOverflowMessage, x as boundedJsonSnapshot } from "./compaction-CgFMDiXL.mjs";
 import { Publisher, noopPublisher } from "./core/ProvisionalText.mjs";
 import { ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext } from "./engine/ContextWindow.mjs";
@@ -301,7 +301,7 @@ const overheads = {
 	"reasoning-end": boundaryOverhead("reasoning-end")
 };
 /**
-* Capture primitive text and reasoning encodings for the native Schema decoder.
+* Capture complete primitive text and reasoning values for native Schema validation.
 * Descriptor checks select this optimization; they do not replace the native codec.
 * Extra fields, accessors, and nonempty metadata use the general ownership path.
 * No provider object survives, including an empty metadata object's hidden storage.
@@ -339,9 +339,8 @@ const capturePrimitiveTextPart = (part, maxBytes) => {
 		const bytes = utf8ByteLength(id) + (typeof delta === "string" ? utf8ByteLength(delta) : 0);
 		if (bytes + fixed.source > maxBytes || bytes + fixed.encoded > maxBytes) return void 0;
 		snapshot.metadata = {};
-		delete snapshot[brand];
 		return {
-			encodedPart: snapshot,
+			part: snapshot,
 			retainedBytes: bytes + fixed.encoded
 		};
 	} catch {
@@ -359,9 +358,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 +371,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 +382,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 +504,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 +591,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 +635,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 +779,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);
 					}
@@ -800,7 +799,7 @@ const makeIsolatedToolTracer = (delegate) => {
 * decorating, or locally providing a Tracer implementation.
 */
 var ToolSpanTelemetry = class ToolSpanTelemetry extends Context.Service()("@effect-agent/engine/ToolSpanTelemetry") {
-	static layer = Layer.effect(ToolSpanTelemetry, Effect.map(Tracer.Tracer, (delegate) => ToolSpanTelemetry.of({
+	static make = Effect.map(Tracer.Tracer, (delegate) => ToolSpanTelemetry.of({
 		isolateEffectSpanLifecycle: (effect) => Effect.suspend(() => {
 			const isolated = makeIsolatedToolTracer(delegate);
 			return effect.pipe(Effect.provideService(Tracer.Tracer, isolated.tracer), Effect.ensuring(isolated.reportLifecycleDefects));
@@ -825,7 +824,7 @@ var ToolSpanTelemetry = class ToolSpanTelemetry extends Context.Service()("@effe
 			const isolated = makeIsolatedToolTracer(delegate);
 			return stream.pipe(Stream.provideService(Tracer.Tracer, isolated.tracer), Stream.ensuring(isolated.reportLifecycleDefects));
 		}))
-	})));
+	}));
 };
 //#endregion
 //#region src/engine/internal/error-diagnostic.ts
@@ -917,20 +916,20 @@ const toolCounter = Metric.counter("effect_agent_tool_calls_total", { descriptio
 /** Publish from the Turn owner; failed storage acceptance is never retried by failure cleanup. */
 const acceptTurnCommit = (context, trace, durability, commit) => Effect.suspend(() => {
 	if (trace.commitFailed) return Effect.void;
-	return checkpointExecution(context, durability).pipe(Effect.andThen(() => durability?.commitTurn(commit) ?? Effect.succeed("committed"))).pipe(Effect.flatMap((receipt) => {
+	const accepted = checkpointExecution(context, durability).pipe(Effect.andThen(() => durability?.commitTurn(commit) ?? Effect.succeed("committed")));
+	return Effect.onExitPrimitive(Effect.flatMap(accepted, (receipt) => {
 		if (receipt === "deferred") return commit._tag === "Response" && commit.defer === true ? Effect.void : Effect.fail(ModelProtocolError.make({ message: "Durability deferred an ineligible Turn commit" }));
-		return Effect.sync(() => {
-			if (commit._tag !== "Partial") {
-				if (commit.response !== void 0) {
-					context.pendingCommitInputs.splice(0, trace.commitInputCount ?? 0);
-					trace.responseCommitted = true;
-				}
-				if (commit._tag === "Settled") trace.resultsCommitted = true;
+		if (commit._tag !== "Partial") {
+			if (commit.response !== void 0) {
+				context.pendingCommitInputs.splice(0, trace.commitInputCount ?? 0);
+				trace.responseCommitted = true;
 			}
-		});
-	}), Effect.onExit((exit) => Effect.sync(() => {
+			if (commit._tag === "Settled") trace.resultsCommitted = true;
+		}
+		return Effect.void;
+	}), (exit) => {
 		if (Exit.isFailure(exit)) trace.commitFailed = true;
-	})));
+	});
 });
 /** Only stream-closed application outcomes enter the trace; provider results stay in response. */
 const turnToolResults = (trace) => Effect.forEach(trace.applicationToolResults.filter((result) => result !== void 0), (result) => Effect.map(decodeToolCallId(result.id), (toolCallId) => ({
@@ -990,15 +989,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 +1017,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 +1074,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" })
@@ -1083,18 +1085,32 @@ const captureModelResponsePartGeneral = Effect.fnUntraced(function* (part, toolk
 		retainedBytes
 	};
 });
-const captureModelResponsePart = (part, toolkit, usage, limits) => Effect.suspend(() => {
-	const primitive = usage.responsePartCount < limits.maxModelResponseParts ? capturePrimitiveTextPart(part, limits.maxModelResponseBytes - usage.responsePartBytes) : void 0;
-	return primitive === void 0 ? captureModelResponsePartGeneral(part, toolkit, usage, limits) : Effect.succeed(primitive);
-});
+const decodePrimitiveModelResponsePart = Schema.decodeUnknownEffect(Schema.toType(Schema.Union([
+	Response.TextStartPart,
+	Response.TextDeltaPart,
+	Response.TextEndPart,
+	Response.ReasoningStartPart,
+	Response.ReasoningDeltaPart,
+	Response.ReasoningEndPart
+])));
 /** Reject trailing content before its capture can run an application codec or suspend. */
-const ownModelResponsePart = Effect.fnUntraced(function* (part, toolkit, usage, limits, finished) {
-	if (finished) return yield* ModelProtocolError.make({ message: "Model response emitted content after its finish part" });
-	const captured = yield* captureModelResponsePart(part, toolkit, usage, limits);
-	return {
-		ownedPart: yield* modelResponseParsersFor(toolkit).decode(captured.encodedPart).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Model response part failed canonical decoding" }))),
-		retainedBytes: captured.retainedBytes
-	};
+const ownModelResponsePart = (part, toolkit, usage, limits, finished) => Effect.suspend(() => {
+	if (finished) return Effect.fail(ModelProtocolError.make({ message: "Model response emitted content after its finish part" }));
+	const primitive = usage.responsePartCount < limits.maxModelResponseParts ? capturePrimitiveTextPart(part, limits.maxModelResponseBytes - usage.responsePartBytes) : void 0;
+	if (primitive !== void 0) return Effect.mapBothEager(decodePrimitiveModelResponsePart(primitive.part), {
+		onFailure: () => ModelProtocolError.make({ message: "Model response part failed canonical decoding" }),
+		onSuccess: (ownedPart) => ({
+			ownedPart,
+			retainedBytes: primitive.retainedBytes
+		})
+	});
+	return Effect.flatMapEager(captureModelResponsePartGeneral(part, toolkit, usage, limits), (captured) => Effect.mapBothEager(modelResponseParsersFor(toolkit).decode(captured.encodedPart), {
+		onFailure: () => ModelProtocolError.make({ message: "Model response part failed canonical decoding" }),
+		onSuccess: (ownedPart) => ({
+			ownedPart,
+			retainedBytes: captured.retainedBytes
+		})
+	}));
 });
 const hasTool = (tools, name) => Object.hasOwn(tools, name);
 const startPart = (parts, id, description) => {
@@ -1121,25 +1137,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 +1186,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 +1223,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 +1370,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, {
@@ -1551,6 +1568,7 @@ const toolFailureMessage = (message) => {
 };
 const executePreparedToolCall = Effect.fnUntraced(function* (context, turnId, toolkit, prepared, trace, resultBounds, onWaiting) {
 	const call = prepared.call;
+	const toolCallId = prepared.toolCallId;
 	const observer = context.toolFailureObserver;
 	const telemetryToolCallId = isTelemetryToolCallId(call.id) ? call.id : void 0;
 	const executionClass = getToolExecutionClass(prepared.tool);
@@ -1571,7 +1589,6 @@ const executePreparedToolCall = Effect.fnUntraced(function* (context, turnId, to
 	let propagatedFailure;
 	const terminalTelemetry = (outcome, handling) => isolateToolDerivative(terminalToolTelemetry(telemetryDescriptor, outcome, outcome === "failure" ? failureMarker() : void 0, handling));
 	const started = Result.isFailure(prepared.validation) ? Effect.void : Effect.gen(function* () {
-		const toolCallId = yield* decodeToolCallId(call.id);
 		yield* Effect.logDebug("agent tool handler started").pipe(Effect.annotateLogs({
 			agentId: context.agentId,
 			runId: context.runId,
@@ -1597,7 +1614,6 @@ const executePreparedToolCall = Effect.fnUntraced(function* (context, turnId, to
 	}))));
 	const results = prepareWithinDeadline(context, Stream.runForEach(handlerResults, (result) => Effect.gen(function* () {
 		if (terminal || trace.finalToolResultIds.has(call.id)) return yield* ModelProtocolError.make({ message: `Tool Call ${call.id} produced more than one terminal result` });
-		const toolCallId = yield* decodeToolCallId(call.id);
 		const encodedResult = toolResultForJson(prepared.tool, result);
 		if (result.preliminary) {
 			const owned = yield* ownApplicationToolProgress(context, encodedResult);
@@ -1622,13 +1638,12 @@ const executePreparedToolCall = Effect.fnUntraced(function* (context, turnId, to
 		yield* checkpointExecution(context);
 		if (!terminal || terminalResult === void 0) return yield* ModelProtocolError.make({ message: `Tool Call ${call.id} completed without a terminal result` });
 		const result = terminalResult;
-		const toolCallId = yield* decodeToolCallId(call.id);
 		let toolSelection;
 		if (!result.isFailure && Context.get(prepared.tool.annotations, DiscoveryTool)) {
 			toolSelection = yield* validateSelection(result.result, context.definition, context.toolCatalog);
 			yield* exposureSnapshot(context.definition, toolSelection, context.toolCatalog, context.toolSchemaTransformer);
 		}
-		const encodedResult = boundEncodedToolResult(result.encodedResult, resultBounds);
+		const encodedResult = yield* boundEncodedToolResult(result.encodedResult, resultBounds);
 		const successResult = result.isFailure ? void 0 : yield* decodeEventJson(encodedResult, "Tool result");
 		trace.finalToolResultIds.add(call.id);
 		trace.applicationToolResults[prepared.declarationIndex] = {
@@ -1678,7 +1693,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 +1731,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 +1808,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 +1836,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,48 +1847,45 @@ 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",
-				discard: true
-			});
+		for (const group of groups) yield* Effect.forEach(group, (call) => permits.withPermit(Effect.acquireUseRelease(Effect.forkScoped(Effect.scoped(Effect.gen(function* () {
 			yield* checkpointExecution(context, durability);
-		}
-	}).pipe(Effect.provideService(RunEventSink, batchSink), Effect.provideService(Emitter, updateEmitter), Effect.provideService(SubagentDurability, batchSubagentDurability), Effect.ensuring(Effect.sync(() => {
+			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
+		});
+	}).pipe(Effect.updateContext((services) => services.pipe(Context.add(SubagentDurability, batchSubagentDurability), Context.add(Emitter, updateEmitter), Context.add(RunEventSink, batchSink))), Effect.ensuring(Effect.sync(() => {
 		updatesOpen = false;
 	})));
 	yield* guardBudgetEffect(handlers, options.budget);
@@ -1996,26 +2009,22 @@ const toolResultForJson = (tool, result) => {
 	if (!result.isFailure && result.encodedResult === void 0 && SchemaAST.isVoid(SchemaAST.toEncoded(tool.successSchema.ast))) return Schema.encodeSync(Schema.toCodecJson(Schema.Void))(void 0);
 	return result.encodedResult;
 };
+const decodeBoundedToolResult = Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown));
 /**
 * RUN-022: bound one application Tool result at the settle seam. The bounded
 * value is what official history, the settled record, and the success event
-* all carry, so every downstream surface agrees; a within-bounds result
-* passes through with its identity preserved.
+* all carry, so every downstream surface agrees on the measured representation.
 */
 const boundEncodedToolResult = (encodedResult, bounds) => {
 	let text;
 	try {
 		text = JSON.stringify(encodedResult);
 	} catch (cause) {
-		return unserializableToolResult(cause);
+		return Effect.succeed(unserializableToolResult(cause));
 	}
-	if (text === void 0) return unserializableToolResult("the encoded result is not a JSON value");
+	if (text === void 0) return Effect.succeed(unserializableToolResult("the encoded result is not a JSON value"));
 	const bounded = applyToolResultBounds(text, bounds);
-	try {
-		return Schema.decodeSync(Schema.fromJsonString(Schema.Unknown))(bounded);
-	} catch (cause) {
-		return unserializableToolResult(cause);
-	}
+	return decodeBoundedToolResult(bounded).pipe(Effect.orElseSucceed(unserializableToolResult));
 };
 const durableResultBounds = (bounds, options, turn) => ToolResultBounds.make({ maxBytes: Math.min(bounds.maxBytes, options.durability?.toolResultMaxBytes ?? bounds.maxBytes, options.resume?.turn === turn ? options.resume.toolResultMaxBytes ?? bounds.maxBytes : bounds.maxBytes) });
 const RUN_STATUS_WARNING = " · WARNING: approaching limits — converge and deliver your final result now.";
@@ -2086,13 +2095,13 @@ const consumeUsage = (agent, context, usage, toolCallCount, turn, options, respo
 	const reportedText = providerUsage.outputTokens.text ?? 0;
 	const reasoning = providerUsage.outputTokens.reasoning ?? 0;
 	const reportedInputTotal = providerUsage.inputTokens.total;
-	const reportedInputWithoutWrite = yield* decodeProviderUsageTotal(reportedUncached + cacheRead);
+	const reportedInputWithoutWrite = reportedUncached + cacheRead;
 	const disjointReportedUncached = reportedUncached - (reportedInputTotal !== void 0 && providerUsage.inputTokens.uncached !== void 0 && providerUsage.inputTokens.cacheWrite !== void 0 && cacheWrite <= reportedUncached && reportedInputWithoutWrite <= reportedInputTotal && cacheWrite > reportedInputTotal - reportedInputWithoutWrite ? cacheWrite : 0);
-	const reportedInputComponents = yield* decodeProviderUsageTotal(disjointReportedUncached + cacheRead + cacheWrite);
+	const reportedInputComponents = disjointReportedUncached + cacheRead + cacheWrite;
 	const allInputComponentsReported = providerUsage.inputTokens.uncached !== void 0 && providerUsage.inputTokens.cacheRead !== void 0 && providerUsage.inputTokens.cacheWrite !== void 0;
 	if (reportedInputTotal !== void 0 && (reportedInputTotal < reportedInputComponents || allInputComponentsReported && reportedInputTotal !== reportedInputComponents)) return yield* invalidProviderUsage();
 	const inputTokens = reportedInputTotal ?? reportedInputComponents;
-	const reportedOutputComponents = yield* decodeProviderUsageTotal(reportedText + reasoning);
+	const reportedOutputComponents = reportedText + reasoning;
 	const reportedOutputTotal = providerUsage.outputTokens.total;
 	const allOutputComponentsReported = providerUsage.outputTokens.text !== void 0 && providerUsage.outputTokens.reasoning !== void 0;
 	if (reportedOutputTotal !== void 0 && (reportedOutputTotal < reportedOutputComponents || allOutputComponentsReported && reportedOutputTotal !== reportedOutputComponents)) return yield* invalidProviderUsage();
@@ -2104,6 +2113,17 @@ const consumeUsage = (agent, context, usage, toolCallCount, turn, options, respo
 	const normalizedCacheWrite = cacheWrite + (providerUsage.inputTokens.uncached !== void 0 && providerUsage.inputTokens.cacheRead !== void 0 && providerUsage.inputTokens.cacheWrite === void 0 ? inputRemainder : 0);
 	const text = reportedText + (providerUsage.outputTokens.text === void 0 ? outputRemainder : 0);
 	const normalizedReasoning = reasoning + (providerUsage.outputTokens.text !== void 0 && providerUsage.outputTokens.reasoning === void 0 ? outputRemainder : 0);
+	const inputUsage = yield* InputTokenUsage.makeEffect({
+		total: inputTokens,
+		uncached,
+		cacheRead: normalizedCacheRead,
+		cacheWrite: normalizedCacheWrite
+	}).pipe(Effect.mapError(() => invalidProviderUsage()));
+	const outputUsage = yield* OutputTokenUsage.makeEffect({
+		total: outputTokens,
+		text,
+		reasoning: normalizedReasoning
+	}).pipe(Effect.mapError(() => invalidProviderUsage()));
 	const totalTokens = yield* decodeProviderUsageTotal(inputTokens + outputTokens);
 	const provider = yield* Model.ProviderName;
 	const model = yield* Model.ModelName;
@@ -2143,17 +2163,8 @@ const consumeUsage = (agent, context, usage, toolCallCount, turn, options, respo
 		pricingStatus,
 		...serviceTier === void 0 ? {} : { serviceTier },
 		...pricingVersion === void 0 ? {} : { pricingVersion },
-		inputTokens: InputTokenUsage.make({
-			total: inputTokens,
-			uncached,
-			cacheRead: normalizedCacheRead,
-			cacheWrite: normalizedCacheWrite
-		}),
-		outputTokens: OutputTokenUsage.make({
-			total: outputTokens,
-			text,
-			reasoning: normalizedReasoning
-		}),
+		inputTokens: inputUsage,
+		outputTokens: outputUsage,
 		costMicrousd
 	});
 	const modelCalls = yield* decodeProviderUsageTotal(context.modelCalls + 1);
@@ -2451,7 +2462,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 +2615,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);
@@ -2634,9 +2645,9 @@ const decodeProviderToolCallIdValue = Schema.decodeEffect(ProviderToolCallId);
 const decodeProviderResponsePartIdValue = Schema.decodeEffect(ProviderResponsePartId);
 const decodeJson = Schema.decodeUnknownEffect(Schema.Json);
 const decodeToolCallId = (id) => Effect.suspend(() => decodeToolCallIdValue(id).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: `Invalid Tool Call ID: ${cause.message}` }))));
-const decodeProviderToolCallId = (id) => Effect.suspend(() => decodeProviderToolCallIdValue(id).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Model supplied an invalid Tool Call ID; expected 1-128 ASCII letters, digits, dots, underscores, colons, or hyphens" }))));
-const decodeProviderResponsePartId = (id) => Effect.suspend(() => decodeProviderResponsePartIdValue(id).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Model supplied an invalid response part ID; expected 1-128 ASCII letters, digits, dots, underscores, colons, or hyphens" }))));
-const validateProviderPartIdentifiers = Effect.fnUntraced(function* (part) {
+const decodeProviderToolCallId = (id) => decodeProviderToolCallIdValue(id).pipe(Effect.mapErrorEager(() => ModelProtocolError.make({ message: "Model supplied an invalid Tool Call ID; expected 1-128 ASCII letters, digits, dots, underscores, colons, or hyphens" })));
+const decodeProviderResponsePartId = (id) => decodeProviderResponsePartIdValue(id).pipe(Effect.mapErrorEager(() => ModelProtocolError.make({ message: "Model supplied an invalid response part ID; expected 1-128 ASCII letters, digits, dots, underscores, colons, or hyphens" })));
+const validateProviderPartIdentifiers = Effect.fnUntracedEager(function* (part) {
 	switch (part.type) {
 		case "text-start":
 		case "text-delta":
@@ -2706,7 +2717,7 @@ const promptFromTurnParts = (trace) => {
 	if (!attachedProviderResults) messages.push(Prompt.makeMessage("assistant", { content: providerResults }));
 	return Prompt.fromMessages(messages);
 };
-const processModelPart = Effect.fnUntraced(function* (context, turnId, turn, tools, trace, part, retainedBytes, events) {
+const processModelPart = Effect.fnUntracedEager(function* (context, turnId, turn, tools, trace, part, retainedBytes, events) {
 	trace.responsePartCount++;
 	trace.responsePartBytes += retainedBytes;
 	if (part.type === "finish" && trace.usage === void 0) {
@@ -2782,7 +2793,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 +3041,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",
@@ -3330,7 +3341,7 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 		const exit = yield* consumeTurnUsage(0).pipe(Effect.exit);
 		if (Exit.isFailure(exit)) failedUsageCause = exit.cause;
 	});
-	const attempt = (basis) => Effect.flatten(outgoingModelPrompt(policy, context, prepareModelPrompt(Prompt.fromMessages([...basis.content, ...transientContext.content]), outputContract._tag === "rendered" ? outputContract.part : void 0, systemMessagesInHistory, staticInstructions), turn, priorToolCalls, systemMessagesInHistory).pipe(withCallModel, Effect.flatMap((providerPrompt) => Effect.gen(function* () {
+	const attempt = (basis) => Effect.flatten(outgoingModelPrompt(policy, context, prepareModelPrompt(Prompt.concat(basis, transientContext), outputContract._tag === "rendered" ? outputContract.part : void 0, systemMessagesInHistory, staticInstructions), turn, priorToolCalls, systemMessagesInHistory).pipe(withCallModel, Effect.flatMap((providerPrompt) => Effect.gen(function* () {
 		yield* checkpointExecution(context, options.durability);
 		const toolChoice = modelToolChoice();
 		let requestToolkit = modelToolkit;
@@ -3367,27 +3378,31 @@ const makeTurn = (agent, context, prompt, turn, priorToolCalls, options, restart
 			trace.usageConsumed = false;
 			provisionalText = !restartRequested && attempt?.threadId === context.threadId ? attempt.openModel(context.runId, turnId) : void 0;
 			activeProvisionalText = provisionalText;
-		})), Stream.runForEach((part) => Effect.gen(function* () {
-			const owned = yield* ownModelResponsePart(part, agent.definition.toolkit, trace, context.bufferLimits, trace.finished);
-			const events = context.publish === void 0 ? void 0 : [];
-			yield* processModelPart(context, turnId, turn, agent.definition.toolkit.tools, trace, owned.ownedPart, owned.retainedBytes, events);
-			if (provisionalText !== void 0) {
-				const part = owned.ownedPart;
-				if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end") provisionalText.offerUnsafe(part);
+		})), Stream.runForEachArray((parts) => Effect.gen(function* () {
+			for (const part of parts) {
+				const owned = yield* ownModelResponsePart(part, agent.definition.toolkit, trace, context.bufferLimits, trace.finished);
+				const events = context.publish === void 0 ? void 0 : [];
+				yield* processModelPart(context, turnId, turn, agent.definition.toolkit.tools, trace, owned.ownedPart, owned.retainedBytes, events);
+				if (provisionalText !== void 0) {
+					const part = owned.ownedPart;
+					if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end") provisionalText.offerUnsafe(part);
+				}
+				if (events !== void 0) yield* publishEvents(context, events);
 			}
-			if (events !== void 0) yield* publishEvents(context, events);
 		})), (effect) => prepareWithinDeadline(context, effect), Effect.onExit((exit) => {
 			if (Exit.isSuccess(exit)) return Effect.void;
 			provisionalText?.discard();
 			return retainFailedUsage();
 		}))));
 	}))));
-	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 attemptWithRetries = Effect.suspend(() => attempt(compactedOutgoing())).pipe((operation) => (policy.modelRetries ?? 0) === 0 ? operation : Effect.retry(operation, ($) => $(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 +3566,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 +3580,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;
@@ -3845,7 +3860,7 @@ const makeResumeTurn = (agent, context, prompt, resume, countedToolCalls, option
 			settledCalls.push({
 				id: call.id,
 				isFailure: true,
-				result: yield* decodeEventJson(boundEncodedToolResult(rejection.error, durableResultBounds(agent.definition.policy.toolResultBounds, options, turn)), "Rejected Tool result")
+				result: yield* decodeEventJson(yield* boundEncodedToolResult(rejection.error, durableResultBounds(agent.definition.policy.toolResultBounds, options, turn)), "Rejected Tool result")
 			});
 			recordedSettledIds.add(call.id);
 		}
@@ -4062,11 +4077,10 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 		const attemptDeadlineMillis = attemptStartedAtMillis + Duration.toMillis(agent.definition.policy.maxDuration);
 		const durationDeadlineMillis = options.durationDeadline === void 0 ? attemptDeadlineMillis : Math.min(attemptDeadlineMillis, DateTime.toEpochMillis(options.durationDeadline));
 		const startedAtMillis = options.runStartedAt === void 0 ? attemptStartedAtMillis : DateTime.toEpochMillis(options.runStartedAt);
-		const programmaticAuthorization = Layer.effect(ProgrammaticToolAuthorization, Effect.gen(function* () {
-			const services = yield* Effect.context();
+		const programmaticAuthorization = Effect.map(Effect.context(), (services) => {
 			const selected = options.toolAuthorization;
 			return ProgrammaticToolAuthorization.of({ authorize: (request) => selected === void 0 ? Effect.succeed({ _tag: "allowed" }) : provideHookServices(selected.authorize(request), services).pipe(Effect.catchCauseFilter(Cause.findError, (error, cause) => Effect.fail(new BrokerCallFailure(error, cause)))) });
-		}));
+		});
 		const interpreted = Effect.flatten(Effect.gen(function* () {
 			const resumed = options.resume === void 0 ? void 0 : {
 				batch: options.resume,
@@ -4081,7 +4095,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 = {
@@ -4257,8 +4271,10 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 					let request = pending;
 					while (request !== void 0) {
 						const output = yield* Effect.scoped(request.resume === void 0 ? makeTurn(agent, context, request.prompt, request.turn, request.toolCalls, options, request.restarting) : makeResumeTurn(agent, context, request.prompt, request.resume, request.toolCalls, options));
-						yield* checkpointExecution(context, options.durability);
-						if (output._tag !== "NextTurn") return output;
+						if (output._tag !== "NextTurn") {
+							yield* checkpointExecution(context, options.durability);
+							return output;
+						}
 						request = output;
 					}
 					return yield* ModelProtocolError.make({ message: "Agent execution ended without RunCompleted" });
@@ -4270,10 +4286,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 +4305,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 +4339,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));
@@ -4351,7 +4367,7 @@ function executeWithCompletion(agentValue, input, runOptions = {}, onCompleted,
 		const events = (model === void 0 ? finalized : Effect.gen(function* () {
 			const services = yield* beforeExecutionDeadline(Layer.build(Layer.fresh(model)), durationDeadlineMillis, durationFailure);
 			return yield* Effect.provide(finalized, services);
-		})).pipe(Effect.provide(ToolSpanTelemetry.layer.pipe(Layer.provideMerge(programmaticAuthorization))));
+		})).pipe(Effect.provideServiceEffect(ToolSpanTelemetry, ToolSpanTelemetry.make), Effect.provideServiceEffect(ProgrammaticToolAuthorization, programmaticAuthorization));
 		return Effect.scoped(events).pipe(Effect.flatMap((terminal) => Effect.gen(function* () {
 			if (onCompleted !== void 0) yield* onCompleted(terminal);
 			if (retained !== void 0) yield* retained.commit(terminal);
@@ -4470,13 +4486,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 +4623,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 +4757,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 +4835,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 +4907,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 +5216,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-DaDKMasp.mjs.map