effect-agent 0.1.0-beta.85 → 0.1.0-beta.86

package/dist/AgentRuntime-BLyETCPo.mjs

@@ -0,0 +1,4562 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "./utf8-DchGZRBd.mjs";
+import { applyToolResultBounds, unserializableToolResult } from "./core/ToolResult.mjs";
+import { ReceiptId, RunId, SubmissionId, ThreadId, ToolCallId } from "./core/Identifiers.mjs";
+import { IdempotencyKey } from "./core/Receipt.mjs";
+import { Emitter, Update, UpdateError } from "./core/AgentUpdates.mjs";
+import { AgentApprovalDenied, AgentApprovalPending, AgentInputError, AgentOutputError, AgentPolicyError, AgentRunDispositionError, AgentToolAuthorizationDenied, ContextBudgetError, ContextOverflowError, ModelProtocolError } from "./core/AgentError.mjs";
+import { IdGenerator as IdGenerator$1 } from "./core/IdGenerator.mjs";
+import { DelegationDepth, SubagentParentLink, getToolExecutionKind, isSubagentToolAllowed } from "./core/SubagentContract.mjs";
+import { a as PinnedTool, c as ToolNames, i as Limits, l as ToolNamespace, n as DiscoveryTool, o as Selection, r as IncludesCatalogDocumentation, s as Snapshot, t as AdditionalToolCatalog } from "./ToolExposure-C93U1sPu.mjs";
+import { InputTokenUsage, ModelCallUsage, ModelResponseIdentity, OutputTokenUsage, RunTotals, RunUsageReport, emptyRunTotals, sumRunTotals, unknownRunTotals } from "./core/Usage.mjs";
+import { AgentUpdateEmitted, ApprovalRequested, BudgetWarning, CompactionPerformed, 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 { FrameworkMessage } from "./core/Worker.mjs";
+import { t as MessagingHost } from "./MessagingHost-CWi_PP3g.mjs";
+import { SubagentHost } from "./engine/SubagentHost.mjs";
+import { ThreadHistory, ThreadHistoryError } from "./engine/ThreadHistory.mjs";
+import { n as RunToolVisibility, t as CurrentToolCatalog } from "./ToolExposure-9uF_Yo0T.mjs";
+import { n as isTextOutput, r as outputSchemaContract, t as insertOutputContract } from "./output-contract-BC7tjlGw.mjs";
+import { _ as initialCompactionState, b as boundedCanonicalJsonSnapshot, d as collectCoveredMessages, f as contextWindowId, g as evaluateMessageTokenEstimates, h as estimatePromptTokens, s as buildCompactedView, v as isContextOverflowMessage, x as boundedJsonSnapshot } from "./compaction-C2OTceKw.mjs";
+import { ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext } from "./engine/ContextWindow.mjs";
+import { DurableStep, DurableStepError, getToolExecutionClass } from "./engine/DurableStep.mjs";
+import { CompactionDecision, CompactionError, ContextCompactor } from "./engine/ContextCompactor.mjs";
+import { RunEventSink, RunEventSinkClosedError } from "./engine/RunEventSink.mjs";
+import { AgentUpdateAcceptance, CurrentToolFailureObserver, ModelUsageAccounting, RunContextPreparation, RunResumeUsageSchema, RunToolAuthorization, RunToolScheduling, RunTurnResumeSettledCallSchema } from "./engine/RunOptions.mjs";
+import { ToolBroker, ToolBrokerConfigurationError, ToolBrokerUnavailableError } from "./engine/ToolBroker.mjs";
+import { AiError, LanguageModel, Model, Prompt, Response, Tool, Toolkit } from "effect/unstable/ai";
+import { Cause, Channel, Clock, Context, DateTime, Duration, Effect, Equal, ErrorReporter, Exit, Fiber, Layer, Metric, Option, PubSub, Queue, Redacted, Result, Schema, Scope, Semaphore, Stream, Tracer } from "effect";
+//#region src/engine/internal/bounded-value.ts
+const DEFAULT_MAX_DEPTH = 128;
+const OBJECT_OVERHEAD_BYTES = 32;
+const PROPERTY_OVERHEAD_BYTES = 8;
+const dateTimeUtcPrototype = Object.getPrototypeOf(DateTime.makeUnsafe(0));
+const redactedPrototype = Object.getPrototypeOf(Redacted.make(void 0));
+const intrinsicViewPrototypes = /* @__PURE__ */ new Set([
+	DataView.prototype,
+	Int8Array.prototype,
+	Uint8Array.prototype,
+	Uint8ClampedArray.prototype,
+	Int16Array.prototype,
+	Uint16Array.prototype,
+	Int32Array.prototype,
+	Uint32Array.prototype,
+	Float32Array.prototype,
+	Float64Array.prototype,
+	BigInt64Array.prototype,
+	BigUint64Array.prototype
+]);
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer")?.get;
+const typedArrayLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length")?.get;
+const dataViewBufferGetter = Object.getOwnPropertyDescriptor(DataView.prototype, "buffer")?.get;
+const urlConstructor = Reflect.get(globalThis, "URL");
+const urlPrototypeDescriptor = typeof urlConstructor === "function" ? Object.getOwnPropertyDescriptor(urlConstructor, "prototype") : void 0;
+const urlHrefGetter = urlPrototypeDescriptor !== void 0 && "value" in urlPrototypeDescriptor && urlPrototypeDescriptor.value !== null && typeof urlPrototypeDescriptor.value === "object" ? Object.getOwnPropertyDescriptor(urlPrototypeDescriptor.value, "href")?.get : void 0;
+const urlPrototype = urlPrototypeDescriptor !== void 0 && "value" in urlPrototypeDescriptor && urlPrototypeDescriptor.value !== null && typeof urlPrototypeDescriptor.value === "object" ? urlPrototypeDescriptor.value : void 0;
+const intrinsicArrayBufferByteLength = (value) => {
+	if (arrayBufferByteLengthGetter === void 0) return void 0;
+	try {
+		const byteLength = Reflect.apply(arrayBufferByteLengthGetter, value, []);
+		return Number.isSafeInteger(byteLength) && byteLength >= 0 ? byteLength : void 0;
+	} catch {
+		return;
+	}
+};
+const intrinsicViewBackingByteLength = (value) => {
+	const getters = [typedArrayBufferGetter, dataViewBufferGetter];
+	for (const getter of getters) {
+		if (getter === void 0) continue;
+		try {
+			const buffer = Reflect.apply(getter, value, []);
+			if (buffer !== null && typeof buffer === "object") return intrinsicArrayBufferByteLength(buffer);
+		} catch {}
+	}
+};
+const intrinsicTypedArrayLength = (value) => {
+	if (typedArrayLengthGetter === void 0) return void 0;
+	try {
+		const length = Reflect.apply(typedArrayLengthGetter, value, []);
+		return Number.isSafeInteger(length) && length >= 0 ? length : void 0;
+	} catch {
+		return;
+	}
+};
+const intrinsicUrlByteLength = (value) => {
+	if (urlHrefGetter === void 0) return void 0;
+	try {
+		const href = Reflect.apply(urlHrefGetter, value, []);
+		return typeof href === "string" ? utf8ByteLength(href) + 2 : void 0;
+	} catch {
+		return;
+	}
+};
+const inspectPrototype = (prototype, isArray, knownSafePrototypes) => {
+	if (prototype === null) return true;
+	if (isArray) return prototype === Array.prototype;
+	return prototype === Object.prototype || prototype === dateTimeUtcPrototype || knownSafePrototypes.has(prototype);
+};
+const isCanonicalArrayIndex = (key) => {
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key;
+};
+/**
+* Conservatively measure one retained, engine-owned JavaScript value without invoking getters,
+* coercion, or `toJSON`. `undefined` means the value exceeded the allowance or its shape could not
+* be measured without executing an accessor.
+*
+* This is a memory-retention guard, not an untrusted wire boundary. Callers must first canonicalize
+* provider values into owned data because JavaScript offers no portable, trap-free Proxy test.
+* Object and property overheads deliberately make the estimate larger than the visible primitive
+* payload for ordinary response values.
+*/
+const boundedValueFootprint = (root, maxBytes, knownSafePrototypes = /* @__PURE__ */ new Set(), maxDepth = DEFAULT_MAX_DEPTH) => {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 0 || !Number.isSafeInteger(maxDepth) || maxDepth < 0) return;
+	let total = 0;
+	const ancestors = /* @__PURE__ */ new WeakSet();
+	const add = (bytes) => {
+		if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > maxBytes - total) return false;
+		total += bytes;
+		return true;
+	};
+	const canMaterializeIndexedKeys = (count) => {
+		if (!Number.isSafeInteger(count) || count < 0) return false;
+		if (count === 0) return true;
+		const largestKeyBytes = utf8ByteLength(String(count - 1));
+		const temporaryBytesPerKey = PROPERTY_OVERHEAD_BYTES + largestKeyBytes;
+		return count <= Math.floor((maxBytes - total) / temporaryBytesPerKey);
+	};
+	const visit = (value, depth) => {
+		if (depth > maxDepth) return false;
+		if (value === null) return add(4);
+		switch (typeof value) {
+			case "string": return add(utf8ByteLength(value) + 2);
+			case "boolean": return add(4);
+			case "number": return add(16);
+			case "bigint":
+			case "symbol": return false;
+			case "undefined": return add(16);
+			case "function": return false;
+			case "object": {
+				if (ancestors.has(value) || !add(OBJECT_OVERHEAD_BYTES)) return false;
+				const prototype = Object.getPrototypeOf(value);
+				let skipIndexedProperties = false;
+				let indexedPropertyCount = 0;
+				let supportedSpecialObject = false;
+				if (ArrayBuffer.isView(value)) {
+					if (!intrinsicViewPrototypes.has(prototype)) return false;
+					const byteLength = intrinsicViewBackingByteLength(value);
+					if (byteLength === void 0 || !add(byteLength)) return false;
+					if (prototype !== DataView.prototype) {
+						const length = intrinsicTypedArrayLength(value);
+						if (length === void 0) return false;
+						indexedPropertyCount = length;
+					}
+					skipIndexedProperties = true;
+					supportedSpecialObject = true;
+				}
+				if (!supportedSpecialObject) {
+					const bufferByteLength = intrinsicArrayBufferByteLength(value);
+					if (bufferByteLength !== void 0) {
+						if (prototype !== ArrayBuffer.prototype) return false;
+						if (!add(bufferByteLength)) return false;
+						supportedSpecialObject = true;
+					}
+				}
+				if (!supportedSpecialObject) {
+					const urlByteLength = intrinsicUrlByteLength(value);
+					if (urlByteLength !== void 0) {
+						if (prototype !== urlPrototype) return false;
+						if (!add(urlByteLength)) return false;
+						supportedSpecialObject = true;
+					}
+				}
+				let redactedValue;
+				let isRedacted = false;
+				if (prototype === redactedPrototype) {
+					const labelDescriptor = Object.getOwnPropertyDescriptor(value, "label");
+					if (labelDescriptor !== void 0 && !("value" in labelDescriptor)) return false;
+					try {
+						redactedValue = Redacted.value(value);
+						isRedacted = true;
+					} catch {
+						return false;
+					}
+				}
+				const isArray = Array.isArray(value);
+				if (!supportedSpecialObject && !isRedacted && !inspectPrototype(prototype, isArray, knownSafePrototypes)) return false;
+				if (isArray) {
+					const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+					if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || !add(lengthDescriptor.value)) return false;
+					indexedPropertyCount = lengthDescriptor.value;
+				}
+				if (!canMaterializeIndexedKeys(indexedPropertyCount)) return false;
+				ancestors.add(value);
+				try {
+					if (isRedacted && !visit(redactedValue, depth + 1)) return false;
+					for (const key of Reflect.ownKeys(value)) {
+						if (key === "length" && isArray) continue;
+						if (typeof key === "symbol") return false;
+						if (skipIndexedProperties && isCanonicalArrayIndex(key)) continue;
+						if (!add(PROPERTY_OVERHEAD_BYTES)) return false;
+						if (!add(utf8ByteLength(key))) return false;
+						const descriptor = Object.getOwnPropertyDescriptor(value, key);
+						if (descriptor === void 0) return false;
+						if ("value" in descriptor) {
+							if (!visit(descriptor.value, depth + 1)) return false;
+						} else return false;
+					}
+					return true;
+				} finally {
+					ancestors.delete(value);
+				}
+			}
+		}
+		return false;
+	};
+	try {
+		return visit(root, 0) ? total : void 0;
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/engine/internal/primitive-delta.ts
+const keys = [
+	"~effect/ai/Content/Part",
+	"type",
+	"id",
+	"delta",
+	"metadata"
+];
+const decode = Schema.decodeUnknownOption(Schema.toType(Schema.Union([Response.TextDeltaPart, Response.ReasoningDeltaPart])));
+const overhead = (type) => ({
+	source: boundedValueFootprint(Response.makePart(type, {
+		id: "",
+		delta: ""
+	}), Number.MAX_SAFE_INTEGER),
+	encoded: boundedValueFootprint({
+		type,
+		id: "",
+		delta: "",
+		metadata: {}
+	}, Number.MAX_SAFE_INTEGER)
+});
+const overheads = {
+	"text-delta": overhead("text-delta"),
+	"reasoning-delta": overhead("reasoning-delta")
+};
+/**
+* Copy the common primitive delta into owned data before 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.
+* Unlike a generic footprint shortcut, this cannot retain an exotic backing buffer.
+*/
+const ownPrimitiveDelta = (part, maxBytes) => {
+	try {
+		if (part === null || typeof part !== "object") return void 0;
+		if (Array.isArray(part) || ArrayBuffer.isView(part)) return void 0;
+		const prototype = Object.getPrototypeOf(part);
+		if (prototype !== Object.prototype && prototype !== null) return void 0;
+		if (Reflect.ownKeys(part).length !== keys.length) return void 0;
+		const snapshot = {};
+		for (const key of keys) {
+			const descriptor = Object.getOwnPropertyDescriptor(part, key);
+			if (descriptor === void 0 || !("value" in descriptor)) return void 0;
+			snapshot[key] = descriptor.value;
+		}
+		const { type, id, delta, metadata } = snapshot;
+		if (type !== "text-delta" && type !== "reasoning-delta") return void 0;
+		if (typeof id !== "string" || typeof delta !== "string") return void 0;
+		if (metadata === null || typeof metadata !== "object") return void 0;
+		if (Array.isArray(metadata) || ArrayBuffer.isView(metadata)) return void 0;
+		const metadataPrototype = Object.getPrototypeOf(metadata);
+		if (metadataPrototype !== Object.prototype && metadataPrototype !== null) return void 0;
+		if (Reflect.ownKeys(metadata).length !== 0) return void 0;
+		const fixed = overheads[type];
+		if (fixed.source === void 0 || fixed.encoded === void 0) return void 0;
+		const bytes = utf8ByteLength(id) + utf8ByteLength(delta);
+		if (bytes + fixed.source > maxBytes || bytes + fixed.encoded > maxBytes) return void 0;
+		snapshot.metadata = {};
+		const validated = decode(snapshot);
+		if (Option.isNone(validated)) return void 0;
+		return {
+			ownedPart: validated.value,
+			retainedBytes: bytes + fixed.encoded
+		};
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/engine/internal/tool-derivative.ts
+/** @internal Only the explicitly installed trusted observer sees this live value. */
+const deliverToolFailure = (observer, observation) => isolateToolDerivative(Effect.suspend(() => observer.observe(observation)));
+/**
+* Report failures of derivative work without consuming external interruption. Reporter defects
+* are isolated too. Neither observer delivery nor telemetry owns the authoritative Tool outcome.
+*/
+const reportDerivativeCause = (cause) => {
+	const reportableReasons = [];
+	const interruptionReasons = [];
+	for (const reason of cause.reasons) if (Cause.isInterruptReason(reason)) interruptionReasons.push(reason);
+	else reportableReasons.push(reason);
+	const reportExit = reportableReasons.length === 0 ? Effect.succeed(Exit.succeed(void 0)) : Effect.exit(ErrorReporter.report(Cause.fromReasons(reportableReasons)));
+	return Effect.flatMap(reportExit, (exit) => {
+		if (Exit.isFailure(exit)) {
+			for (const reason of exit.cause.reasons) if (Cause.isInterruptReason(reason)) interruptionReasons.push(reason);
+		}
+		return interruptionReasons.length === 0 ? Effect.void : Effect.failCause(Cause.fromReasons(interruptionReasons));
+	});
+};
+/** @internal Isolate reporting defects independently of Logger/Tracer configuration. */
+const isolateToolDerivative = (effect) => effect.pipe(Effect.catchCause(reportDerivativeCause));
+/**
+* @internal Emit one authoritative value, then run derivative work from either the next pull or
+* structured finalization on early close. Telemetry and application observation share this one
+* owner. A started action is never retried after interruption.
+*/
+const emitThenAfter = (event, after) => Stream.unwrap(Effect.sync(() => {
+	let firstPull = true;
+	let afterPhase = "unarmed";
+	const runAfter = Effect.suspend(() => {
+		if (afterPhase !== "pending") return Effect.void;
+		afterPhase = "running";
+		return after.pipe(Effect.onExit(() => Effect.sync(() => {
+			afterPhase = "completed";
+		})));
+	});
+	const pull = Effect.suspend(() => {
+		if (firstPull) return Effect.map(event, (value) => {
+			firstPull = false;
+			afterPhase = "pending";
+			return [value];
+		});
+		return Effect.andThen(runAfter, Cause.done());
+	});
+	return Stream.fromPull(Effect.succeed(pull)).pipe(Stream.ensuring(Effect.exit(Effect.interruptible(runAfter)).pipe(Effect.flatMap((exit) => {
+		if (Exit.isSuccess(exit)) return Effect.void;
+		return reportDerivativeCause(exit.cause);
+	}))));
+}));
+//#endregion
+//#region src/engine/internal/tool-exposure.ts
+const invalid = (message) => ModelProtocolError.make({ message });
+const decodeSelection = (value) => Schema.decodeUnknownEffect(Selection)(value).pipe(Effect.mapError(() => invalid("Invalid Tool exposure selection")));
+const decodeSnapshot = (value) => Schema.decodeUnknownEffect(Snapshot)(value).pipe(Effect.mapError(() => invalid("Invalid recorded Tool exposure snapshot")), Effect.map((snapshot) => Object.freeze(Snapshot.make({
+	exposedToolNames: Object.freeze([...snapshot.exposedToolNames]),
+	...snapshot.selection === void 0 ? {} : { selection: Object.freeze(Selection.make({ toolNames: Object.freeze([...snapshot.selection.toolNames]) })) }
+}))));
+const eligibleCatalog = Effect.fn("ToolExposure.eligibleCatalog")(function* (definition, request, grant, depth) {
+	const visibility = yield* RunToolVisibility;
+	const entries = [];
+	for (const tool of Object.values(definition.toolkit.tools)) {
+		if (Context.get(tool.annotations, DiscoveryTool) && (getToolExecutionKind(tool.annotations) !== "ordinary" || getToolExecutionClass(tool) !== "readonly")) return yield* invalid("Discovery requires ordinary readonly Tools");
+		const namespace = Context.get(tool.annotations, ToolNamespace);
+		entries.push({
+			kind: "native",
+			tool,
+			nativeToolName: tool.name,
+			...namespace === void 0 ? {} : { namespace }
+		});
+		for (const extra of Context.get(tool.annotations, AdditionalToolCatalog)) entries.push({
+			kind: "code-mode",
+			...extra,
+			nativeToolName: tool.name
+		});
+	}
+	const names = [...new Set(entries.map((entry) => entry.tool.name))];
+	const visible = visibility === void 0 ? names : yield* visibility.visible({
+		...request,
+		toolNames: names
+	});
+	const checked = visibility === void 0 ? visible : yield* Schema.decodeEffect(ToolNames)(visible).pipe(Effect.mapError(() => invalid("Host Tool visibility returned invalid names")));
+	if (checked.some((name) => !names.includes(name))) return yield* invalid("Host Tool visibility returned an unregistered name");
+	const allowed = new Set(checked);
+	const permits = (tool) => allowed.has(tool.name) && isSubagentToolAllowed(grant, depth, tool.name, tool.annotations);
+	for (const outer of Object.values(definition.toolkit.tools)) if (permits(outer) && Context.get(outer.annotations, IncludesCatalogDocumentation) && Context.get(outer.annotations, AdditionalToolCatalog).some((entry) => !permits(entry.tool))) return yield* invalid("A Tool description includes hidden catalogue declarations; configure includeDeclarations: false");
+	return Object.freeze(entries.filter((entry) => {
+		const outer = definition.toolkit.tools[entry.nativeToolName];
+		return outer !== void 0 && permits(outer) && permits(entry.tool);
+	}).map((entry) => Object.freeze(entry)));
+});
+const validateSelection = Effect.fn("ToolExposure.validateSelection")(function* (value, definition, entries, requireEligible = true) {
+	const selection = yield* decodeSelection(value);
+	const eligible = new Set(entries.filter((entry) => entry.kind === "native").map((entry) => entry.nativeToolName));
+	if (selection.toolNames.some((name) => !Object.hasOwn(definition.toolkit.tools, name) || requireEligible && !eligible.has(name))) return yield* invalid("Tool selection names a Tool outside the eligible registered toolkit");
+	return Selection.make({ toolNames: Object.freeze([...selection.toolNames]) });
+});
+const exposureSnapshot = Effect.fn("ToolExposure.exposureSnapshot")(function* (definition, selection, entries, transformer, only) {
+	const native = entries.filter((entry) => entry.kind === "native").map((entry) => entry.tool);
+	const progressive = definition.toolExposure !== void 0 || selection !== void 0;
+	const mandatory = Object.values(definition.toolkit.tools).filter((tool) => Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, ContextRolloverTool) || definition.completion?.required === true && definition.completion.tool === tool.name);
+	if (progressive && mandatory.some((tool) => !native.some((candidate) => candidate.name === tool.name))) return yield* invalid("A mandatory Tool is excluded by host visibility or the inherited grant");
+	const pinned = native.filter((tool) => Context.get(tool.annotations, PinnedTool) || mandatory.includes(tool));
+	if (selection !== void 0) yield* validateSelection(selection, definition, entries, false);
+	const selected = selection === void 0 ? void 0 : new Set(selection.toolNames);
+	const names = native.filter((tool) => selected === void 0 || selected.has(tool.name) || pinned.includes(tool)).map((tool) => tool.name).filter((name) => only === void 0 || only.includes(name));
+	if (progressive) {
+		const limits = yield* Schema.decodeEffect(Limits)({
+			maxTools: definition.toolExposure?.maxTools ?? 64,
+			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) ? {
+					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")
+		})) > limits.maxSchemaBytes) return yield* invalid("Tool exposure exceeds the configured schema byte bound");
+	}
+	return yield* decodeSnapshot({
+		exposedToolNames: names,
+		...selection === void 0 ? {} : { selection }
+	});
+});
+//#endregion
+//#region src/engine/internal/tool-telemetry.ts
+/**
+* @internal Payload-free control signal used only to close the canonical Tool span with a failed
+* Exit. It is removed immediately outside that span and never enters the public error channel.
+*/
+var ToolSpanFailure = class ToolSpanFailure extends AiError.AiError.extend("@effect-agent/engine/ToolSpanFailure")({}) {
+	name = "ToolCallFailed";
+	/** Schema-safe factory retaining the generated constructor required by Effect Schema. */
+	static marker() {
+		return ToolSpanFailure.make({
+			module: "effect-agent",
+			method: "execute_tool",
+			reason: AiError.UnknownError.make({ description: "Tool execution reached a failed terminal state" })
+		});
+	}
+};
+const TOOL_SPAN_FAILURE_MARKER_ATTRIBUTE = "@effect-agent/engine/ToolSpanFailureMarker";
+const terminalOutcomeTokens = /* @__PURE__ */ new WeakMap();
+/** @internal Annotate one completed attempt and hand its existing marker to the isolated span. */
+const annotateToolSpanTerminalOutcome = (outcome, failureMarker, failureHandling, failureMode) => {
+	const token = {};
+	terminalOutcomeTokens.set(token, {
+		outcome,
+		failureMarker,
+		failureHandling,
+		failureMode
+	});
+	return Effect.annotateCurrentSpan({
+		"effect_agent.tool.outcome": outcome,
+		[TOOL_SPAN_FAILURE_MARKER_ATTRIBUTE]: token
+	});
+};
+const stripToolSpanFailures = (cause, marker) => {
+	if (!cause.reasons.some((reason) => Cause.isFailReason(reason) && reason.error === marker)) return {
+		found: false,
+		residual: cause
+	};
+	const reasons = cause.reasons.filter((reason) => {
+		if (Cause.isFailReason(reason) && reason.error === marker) return false;
+		return true;
+	});
+	return {
+		found: true,
+		residual: Cause.fromReasons(reasons)
+	};
+};
+/** @internal Remove only the private marker and restore the saved Cause plus every residual. */
+const restoreToolSpanFailureCause = (cause, marker, original) => {
+	const { found, residual } = stripToolSpanFailures(cause, marker);
+	return {
+		found,
+		restored: original === void 0 ? residual : Cause.combine(original, residual)
+	};
+};
+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 {
+	name = "ToolSpanLifecycleFailure";
+	constructor() {
+		super("Tool span lifecycle failed");
+	}
+};
+/**
+* @internal Guard one host span so synchronous exporter defects cannot alter Tool execution.
+* The wrapper retains the span contract for Effect while forwarding every measurement to the host.
+*/
+var IsolatedToolSpan = class {
+	_tag = "Span";
+	name;
+	spanId;
+	traceId;
+	parent;
+	annotations;
+	attributes = /* @__PURE__ */ new Map();
+	links;
+	sampled;
+	kind;
+	status;
+	#delegate;
+	#recordDefect;
+	#terminalOutcome;
+	#terminalFailure;
+	#terminalFailureHandling;
+	#terminalFailureMode;
+	constructor(delegate, options, recordDefect) {
+		this.#delegate = delegate;
+		this.#recordDefect = recordDefect;
+		this.name = options.name;
+		this.spanId = delegate.spanId;
+		this.traceId = delegate.traceId;
+		this.parent = options.parent;
+		this.annotations = options.annotations;
+		this.links = [...options.links];
+		this.sampled = delegate.sampled;
+		this.kind = options.kind;
+		this.status = {
+			_tag: "Started",
+			startTime: options.startTime
+		};
+	}
+	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;
+		this.status = {
+			_tag: "Ended",
+			startTime: this.status.startTime,
+			endTime,
+			exit: exportedExit
+		};
+		if (this.#terminalOutcome !== void 0) {
+			this.attributes.set("effect_agent.tool.outcome", this.#terminalOutcome);
+			try {
+				this.#delegate.attribute("effect_agent.tool.outcome", this.#terminalOutcome);
+			} catch (defect) {
+				this.#recordDefect(defect);
+			}
+		}
+		for (const [key, value] of [["effect_agent.tool.failure_mode", this.#terminalFailureMode], ["effect_agent.tool.failure_handling", this.#terminalFailureHandling]]) if (value !== void 0) {
+			this.attributes.set(key, value);
+			try {
+				this.#delegate.attribute(key, value);
+			} catch (defect) {
+				this.#recordDefect(defect);
+			}
+		} else if (key === "effect_agent.tool.failure_handling") this.attributes.delete(key);
+		try {
+			this.#delegate.end(endTime, exportedExit);
+		} catch (defect) {
+			this.#recordDefect(defect);
+		}
+	}
+	attribute(key, value) {
+		if (key === TOOL_SPAN_FAILURE_MARKER_ATTRIBUTE) {
+			if (typeof value === "object" && value !== null) {
+				const terminal = terminalOutcomeTokens.get(value);
+				if (terminal !== void 0) {
+					this.#terminalOutcome = terminal.outcome;
+					this.#terminalFailure = terminal.failureMarker;
+					this.#terminalFailureHandling = terminal.failureHandling;
+					this.#terminalFailureMode = terminal.failureMode;
+				}
+			}
+			return;
+		}
+		if (key === "effect_agent.tool.failure_handling") return;
+		this.attributes.set(key, value);
+		try {
+			this.#delegate.attribute(key, value);
+		} catch (defect) {
+			this.#recordDefect(defect);
+		}
+	}
+	event(name, startTime, attributes) {
+		try {
+			this.#delegate.event(name, startTime, attributes);
+		} catch (defect) {
+			this.#recordDefect(defect);
+		}
+	}
+	addLinks(links) {
+		this.links.push(...links);
+		try {
+			this.#delegate.addLinks(links);
+		} catch (defect) {
+			this.#recordDefect(defect);
+		}
+	}
+};
+/**
+* @internal Isolate the complete canonical span lifecycle. A creation defect receives a local,
+* non-exported span so the handler still runs; delegate method/finalization defects are retained
+* as bounded reporter diagnostics and never enter the handler stream Cause.
+*/
+const makeIsolatedToolTracer = (delegate) => {
+	const defects = [];
+	const recordDefect = (defect) => {
+		if (defects.length < MAX_REPORTED_SPAN_LIFECYCLE_DEFECTS) defects.push(defect);
+	};
+	let delegateContext;
+	try {
+		delegateContext = delegate.context?.bind(delegate);
+	} catch (defect) {
+		recordDefect(defect);
+		delegateContext = void 0;
+	}
+	const context = delegateContext === void 0 ? void 0 : (primitive, fiber) => {
+		let evaluation = { _tag: "Pending" };
+		const currentEvaluation = () => evaluation;
+		const evaluate = (currentFiber) => {
+			switch (evaluation._tag) {
+				case "Succeeded": return evaluation.value;
+				case "Failed": throw evaluation.error;
+				case "Pending": try {
+					const value = primitive["~effect/Effect/evaluate"](currentFiber);
+					evaluation = {
+						_tag: "Succeeded",
+						value
+					};
+					return value;
+				} catch (error) {
+					evaluation = {
+						_tag: "Failed",
+						error
+					};
+					throw error;
+				}
+			}
+		};
+		const guardedPrimitive = { ["~effect/Effect/evaluate"]: evaluate };
+		try {
+			delegateContext(guardedPrimitive, fiber);
+		} catch (defect) {
+			const observed = currentEvaluation();
+			switch (observed._tag) {
+				case "Failed": throw observed.error;
+				case "Succeeded":
+					recordDefect(defect);
+					return observed.value;
+				case "Pending":
+					recordDefect(defect);
+					return evaluate(fiber);
+			}
+		}
+		const observed = currentEvaluation();
+		switch (observed._tag) {
+			case "Failed": throw observed.error;
+			case "Succeeded": return observed.value;
+			case "Pending": return evaluate(fiber);
+		}
+	};
+	return {
+		tracer: Tracer.make({
+			context,
+			span(options) {
+				let delegateSpan;
+				try {
+					delegateSpan = delegate.span(options);
+				} catch (defect) {
+					recordDefect(defect);
+					return new Tracer.NativeSpan(options);
+				}
+				try {
+					return new IsolatedToolSpan(delegateSpan, options, recordDefect);
+				} catch (defect) {
+					recordDefect(defect);
+					try {
+						delegateSpan.end(options.startTime, Exit.fail(new ToolSpanLifecycleFailure()));
+					} catch (closeDefect) {
+						recordDefect(closeDefect);
+					}
+					return new Tracer.NativeSpan(options);
+				}
+			}
+		}),
+		reportLifecycleDefects: Effect.suspend(() => {
+			const pending = defects.splice(0);
+			return Effect.forEach(pending, (defect) => isolateToolDerivative(ErrorReporter.report(Cause.die(defect))), { discard: true });
+		})
+	};
+};
+/**
+* @internal Engine-owned span-lifecycle policy. The AgentRuntime composition boundary builds this
+* capability from the host's ambient Tracer; Tool execution consumes it without selecting,
+* 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({
+		isolateEffectSpanLifecycle: (effect) => Effect.suspend(() => {
+			const isolated = makeIsolatedToolTracer(delegate);
+			return effect.pipe(Effect.provideService(Tracer.Tracer, isolated.tracer), Effect.ensuring(isolated.reportLifecycleDefects));
+		}),
+		isolateToolkitHandle: (effect) => Effect.currentSpan.pipe(Effect.option, Effect.flatMap((parentOption) => {
+			if (Option.isNone(parentOption)) return effect;
+			const parent = parentOption.value;
+			const local = new Tracer.NativeSpan({
+				name: "AgentRuntime.toolkit.handle",
+				parent: Option.some(parent),
+				annotations: Context.add(Context.empty(), Tracer.DisablePropagation, true),
+				links: [],
+				startTime: 0n,
+				kind: "internal",
+				sampled: parent.sampled
+			});
+			return effect.pipe(Effect.withParentSpan(local), Effect.onExit((exit) => Effect.sync(() => {
+				local.end(0n, exit);
+			})));
+		})),
+		isolateSpanLifecycle: (stream) => Stream.unwrap(Effect.sync(() => {
+			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
+const DIAGNOSTIC_MESSAGE_LIMIT = 4096;
+const DIAGNOSTIC_TAG_LIMIT = 128;
+const boundedDiagnostic = (value, maxCharacters) => value.length <= maxCharacters ? value : value.slice(0, maxCharacters);
+const ownStringDiagnostic = (input, key, maxCharacters) => {
+	if (input === null || typeof input !== "object" && typeof input !== "function") return;
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(input, key);
+		return descriptor !== void 0 && "value" in descriptor && typeof descriptor.value === "string" ? boundedDiagnostic(descriptor.value, maxCharacters) : void 0;
+	} catch {
+		return;
+	}
+};
+/** Total, bounded projection for opaque failures. It never invokes arbitrary coercion hooks. */
+const errorMessage = (error) => {
+	const message = ownStringDiagnostic(error, "message", DIAGNOSTIC_MESSAGE_LIMIT);
+	if (message !== void 0) return message;
+	return typeof error === "string" ? boundedDiagnostic(error, DIAGNOSTIC_MESSAGE_LIMIT) : "Unknown error";
+};
+/** Total, bounded tag projection for opaque failures. */
+const errorTag = (error) => ownStringDiagnostic(error, "_tag", DIAGNOSTIC_TAG_LIMIT) ?? "UnknownError";
+//#endregion
+//#region src/engine/internal/agent-runtime.ts
+/** Schema factory for the terminal value produced by reducing a completed agent event stream. */
+const AgentResultSchema = (output) => Schema.Struct({
+	output,
+	threadId: ThreadId,
+	runId: RunId,
+	turns: Schema.Int.check(Schema.isGreaterThan(0)),
+	finishReason: Schema.Literals([
+		"completed",
+		"model-stop",
+		"budget-exhausted"
+	]),
+	/** Dimension that bound when the Run settled budget-exhausted (RUN-025; the grant-flow marker). */
+	exhausted: Schema.optionalKey(Schema.Literals([
+		"tokens",
+		"tool-calls",
+		"turns"
+	])),
+	/** Schema-encoded application disposition declared for an ordinary completed Run. */
+	runDisposition: Schema.optionalKey(Schema.Json),
+	/** Cumulative spend for the Run, as reported on its terminal event. */
+	usage: Schema.optionalKey(RunTotals),
+	/** Disjoint usage of attached descendants, including nested and failed children. */
+	delegatedUsage: Schema.optionalKey(RunTotals)
+}).check(Schema.makeFilter((result) => !("runDisposition" in result) || result.runDisposition === void 0 || !("finishReason" in result) || result.finishReason !== "budget-exhausted", { expected: "runDisposition only when finishReason is not budget-exhausted" }));
+/** Direct usage only: budget counters never absorb descendant consumption. */
+const runTotalsOf = (context) => RunTotals.make({
+	modelCalls: context.modelCalls,
+	inputTokens: context.inputTokens,
+	outputTokens: context.outputTokens,
+	costMicrousd: context.costMicrousd,
+	usageStatus: context.usageStatus,
+	pricingStatus: context.pricingStatus,
+	unobservedModelCalls: context.unobservedModelCalls
+});
+const usageReportOf = Effect.fn("AgentRuntime.usageReport")(function* (context) {
+	const contributions = [];
+	for (const read of context.childUsage.values()) {
+		const report = yield* read;
+		contributions.push(report.usage, report.delegatedUsage);
+	}
+	const delegatedUsage = yield* sumRunTotals(contributions).pipe(Effect.catchTag("UsageAggregationError", () => Effect.succeed(unknownRunTotals())));
+	return RunUsageReport.make({
+		usage: runTotalsOf(context),
+		delegatedUsage
+	});
+});
+const noteIncompleteUsage = Effect.fn("AgentRuntime.noteIncompleteUsage")(function* (context, turn) {
+	const accounting = yield* ModelUsageAccounting;
+	context.unobservedModelCalls += 1;
+	context.usageStatus = context.usageStatus === "unknown" || context.modelCalls === 0 ? "unknown" : "partial";
+	context.pricingStatus = context.pricingStatus === "unknown" || context.modelCalls === 0 ? "unknown" : "partial";
+	yield* accounting.noteIncompleteUsage(turn);
+});
+const runCounter = Metric.counter("effect_agent_runs_total", { description: "Agent runs started; no content or high-cardinality identifiers are recorded." });
+const modelCounter = Metric.counter("effect_agent_model_calls_total", { description: "Agent model calls started; no content or high-cardinality identifiers are recorded." });
+const toolCounter = Metric.counter("effect_agent_tool_calls_total", { description: "Agent tool handlers started; no content or high-cardinality identifiers are recorded." });
+const MAX_STAGED_PROVIDER_EVENTS = 256;
+const MAX_STAGED_PROVIDER_BYTES = 1048576;
+const DEFAULT_RUN_BUFFER_LIMITS = {
+	maxModelResponseParts: 16384,
+	maxModelResponseBytes: 8388608,
+	maxRunEvents: 65536,
+	maxToolProgressBytes: 8388608,
+	maxSubagentEventsPerBatch: 1024
+};
+const tighteningBufferLimit = (configured, ceiling, minimum) => configured === void 0 || !Number.isFinite(configured) ? ceiling : Math.min(ceiling, Math.max(minimum, Math.floor(configured)));
+const effectiveRunBufferLimits = (configured) => ({
+	maxModelResponseParts: tighteningBufferLimit(configured?.maxModelResponseParts, DEFAULT_RUN_BUFFER_LIMITS.maxModelResponseParts, 1),
+	maxModelResponseBytes: tighteningBufferLimit(configured?.maxModelResponseBytes, DEFAULT_RUN_BUFFER_LIMITS.maxModelResponseBytes, 1),
+	maxRunEvents: tighteningBufferLimit(configured?.maxRunEvents, DEFAULT_RUN_BUFFER_LIMITS.maxRunEvents, 2),
+	maxToolProgressBytes: tighteningBufferLimit(configured?.maxToolProgressBytes, DEFAULT_RUN_BUFFER_LIMITS.maxToolProgressBytes, 1),
+	maxSubagentEventsPerBatch: tighteningBufferLimit(configured?.maxSubagentEventsPerBatch, DEFAULT_RUN_BUFFER_LIMITS.maxSubagentEventsPerBatch, 1)
+});
+const structuredCloneFunction = Reflect.get(globalThis, "structuredClone");
+const knownSafeModelResponsePrototypes = /* @__PURE__ */ new Set([Response.Usage.prototype]);
+const schemaClassPrototype = (schema) => {
+	if (typeof schema !== "function" || !Schema.isSchema(schema)) return void 0;
+	const descriptor = Object.getOwnPropertyDescriptor(schema, "prototype");
+	return descriptor !== void 0 && "value" in descriptor && descriptor.value !== null && typeof descriptor.value === "object" ? descriptor.value : void 0;
+};
+/**
+* Build the bounded preflight view for a decoded Tool payload whose root is an
+* application-selected Schema class. The class instance is deliberately omitted:
+* its complete canonical encoding is measured before cloning, and it is never
+* retained in the Turn trace. Every other response field remains in the preflight.
+*/
+const schemaClassToolPartPreflight = (part, toolkit) => {
+	try {
+		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;
+		};
+		const type = read("type");
+		if (type !== "tool-call" && type !== "tool-result") return void 0;
+		const name = read("name");
+		if (typeof name !== "string" || !hasTool(toolkit.tools, name)) return void 0;
+		const tool = toolkit.tools[name];
+		const payload = read(type === "tool-call" ? "params" : "result");
+		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;
+		const preflight = {};
+		const retainedKeys = type === "tool-call" ? [
+			"type",
+			"id",
+			"name",
+			"providerExecuted",
+			"metadata"
+		] : [
+			"type",
+			"id",
+			"name",
+			"isFailure",
+			"providerExecuted",
+			"preliminary",
+			"metadata",
+			"encodedResult"
+		];
+		for (const key of retainedKeys) preflight[key] = read(key);
+		return preflight;
+	} catch {
+		return;
+	}
+};
+const inspectModelResponsePartCapacity = (usage, part, limits, knownSafePrototypes = knownSafeModelResponsePrototypes) => Effect.suspend(() => {
+	const bytes = boundedValueFootprint(part, limits.maxModelResponseBytes - usage.responsePartBytes, knownSafePrototypes);
+	return bytes === void 0 ? Effect.fail(ModelProtocolError.make({ message: `Model response exceeded the ${limits.maxModelResponseBytes}-byte retained response limit` })) : Effect.succeed(bytes);
+});
+/**
+* `disableToolCallResolution` keeps model Tool Call parameters in their
+* encoded wire form. Build the response ownership codec from those encoded
+* parameter Schemas; the engine decodes and canonically re-encodes each call
+* against the Definition-owned Schema before it enters history or executes.
+*/
+const encodedToolParameterToolkit = (toolkit) => Toolkit.make(...Object.values(toolkit.tools).map((tool) => tool.setParameters(Schema.toEncoded(tool.parametersSchema))));
+const makeModelResponseCodec = (toolkit) => Schema.toCodecJson(Response.StreamPart(encodedToolParameterToolkit(toolkit)));
+const modelResponseCodecs = /* @__PURE__ */ new WeakMap();
+const modelResponseCodecFor = (toolkit) => {
+	const cached = modelResponseCodecs.get(toolkit);
+	if (cached !== void 0) return cached;
+	const codec = makeModelResponseCodec(toolkit);
+	modelResponseCodecs.set(toolkit, codec);
+	return codec;
+};
+const ownModelResponsePartGeneral = Effect.fn("AgentRuntime.ownModelResponsePart")(function* (part, toolkit, usage, limits) {
+	if (usage.responsePartCount >= limits.maxModelResponseParts) return yield* ModelProtocolError.make({ message: `Model response exceeded the ${limits.maxModelResponseParts}-part response limit` });
+	if (boundedValueFootprint(part, limits.maxModelResponseBytes - usage.responsePartBytes, knownSafeModelResponsePrototypes) === void 0) {
+		const preflight = schemaClassToolPartPreflight(part, toolkit);
+		yield* inspectModelResponsePartCapacity(usage, preflight ?? part, limits);
+	}
+	const codec = modelResponseCodecFor(toolkit);
+	const encodingFailure = ModelProtocolError.make({ message: "Model response part failed canonical encoding" });
+	const encoded = yield* Schema.encodeUnknownEffect(codec)(part).pipe(Effect.mapError(() => encodingFailure));
+	const retainedBytes = yield* inspectModelResponsePartCapacity(usage, encoded, limits);
+	const ownedEncoded = 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" })
+	});
+	const decodingFailure = ModelProtocolError.make({ message: "Model response part failed canonical decoding" });
+	return {
+		ownedPart: yield* Schema.decodeUnknownEffect(codec)(ownedEncoded).pipe(Effect.mapError(() => decodingFailure)),
+		retainedBytes
+	};
+});
+const ownModelResponsePart = (part, toolkit, usage, limits) => Effect.suspend(() => {
+	const primitive = usage.responsePartCount < limits.maxModelResponseParts ? ownPrimitiveDelta(part, limits.maxModelResponseBytes - usage.responsePartBytes) : void 0;
+	return primitive === void 0 ? ownModelResponsePartGeneral(part, toolkit, usage, limits) : Effect.succeed(primitive);
+});
+const consumeModelResponsePart = (usage, retainedBytes, limits) => Effect.suspend(() => {
+	if (usage.responsePartCount >= limits.maxModelResponseParts || !Number.isSafeInteger(retainedBytes) || retainedBytes < 0 || retainedBytes > limits.maxModelResponseBytes - usage.responsePartBytes) return Effect.fail(ModelProtocolError.make({ message: usage.responsePartCount >= limits.maxModelResponseParts ? `Model response exceeded the ${limits.maxModelResponseParts}-part response limit` : `Model response exceeded the ${limits.maxModelResponseBytes}-byte retained response limit` }));
+	return Effect.sync(() => {
+		usage.responsePartCount += 1;
+		usage.responsePartBytes += retainedBytes;
+	});
+});
+const withSemaphorePermit = (semaphore, stream) => Stream.scoped(Stream.fromEffect(Effect.acquireRelease(semaphore.take(1), (permits) => semaphore.release(permits).pipe(Effect.asVoid))).pipe(Stream.flatMap(() => stream)));
+const hasTool = (tools, name) => Object.hasOwn(tools, name);
+const startPart = (parts, id, description) => {
+	if (parts.has(id)) return Effect.fail(ModelProtocolError.make({ message: `Model response repeated ${description} start for ${id}` }));
+	parts.set(id, "open");
+	return Effect.void;
+};
+const continuePart = (parts, id, description) => parts.get(id) === "open" ? Effect.void : Effect.fail(ModelProtocolError.make({ message: `Model response emitted ${description} for inactive part ${id}` }));
+const endPart = (parts, id, description) => continuePart(parts, id, `${description} end`).pipe(Effect.tap(() => Effect.sync(() => parts.set(id, "closed"))));
+const firstOpenPart = (trace) => {
+	for (const [id, state] of trace.textParts) if (state === "open") return `text part ${id}`;
+	for (const [id, state] of trace.reasoningParts) if (state === "open") return `reasoning part ${id}`;
+	for (const [id, part] of trace.toolParameterParts) if (part.state === "open") return `Tool parameter part ${id}`;
+};
+/** Canonically encode already-decoded Tool Call parameters for history and execution. */
+const encodeToolCallParameters = (tool, toolName, decodedParams) => {
+	return Schema.encodeUnknownEffect(tool.parametersSchema)(decodedParams).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: `Invalid parameters for Tool ${toolName}: ${cause.message}` })));
+};
+/**
+* Decode canonically recorded Tool parameters for policy and authorization.
+* The private assertion restores the correlation lost by dynamic record
+* lookup only around a successful Schema decode.
+*/
+const decodeToolCallParameters = (tool, toolName, encodedParams, boundary = "execution") => {
+	return Schema.decodeUnknownEffect(tool.parametersSchema)(encodedParams).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: `Recorded parameters for Tool ${toolName} failed validation${boundary === "resume" ? " on resume" : ""}: ${cause.message}` })));
+};
+/**
+* Decode canonical parameters for approval while retaining their encoded
+* form for the native `Toolkit.handle` boundary.
+*/
+const prepareToolCall = (toolkit, call, declarationIndex) => {
+	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 decodeToolCallId(call.id).pipe(Effect.flatMap((toolCallId) => decodeToolCallParameters(tool, call.name, call.params).pipe(Effect.map((decodedParams) => ({
+		call,
+		name,
+		toolCallId,
+		decodedParams,
+		tool,
+		declarationIndex
+	})))));
+};
+/**
+* Re-validate one canonically recorded Tool Call's encoded parameters through
+* the owning parameter Schema before a resumed batch may execute anything.
+* Declarations were validated when they entered the log (RUN-004), but a
+* resumed Attempt re-validates on read (STORE-006); a decode failure is a
+* strict no-start boundary. The same private assertion contract as
+* `encodeToolCallParameters` applies: correlation lost by dynamic record
+* lookup is restored only around a successful Schema decode.
+*/
+/**
+* Effective Run bounds (RUN-021): per-Run allowances tighten the Agent
+* Policy's Turn and Tool Call ceilings but can never widen them — the
+* effective limit is `min(policy bound, max(1, floor(allowance)))`. The
+* `onExhaustion` resolution (RUN-018/RUN-019) keys off these effective
+* limits, which is how an orchestrator grants a delegated child a budget
+* extension by re-invoking with a larger allowance below the Definition's
+* ceiling.
+*/
+const CurrentSubagentAuthority = Context.Reference("@effect-agent/engine/internal/CurrentSubagentAuthority", { defaultValue: () => void 0 });
+const boundedAllowance = (policyBound, allowance) => allowance === void 0 || !Number.isFinite(allowance) ? policyBound : Math.min(policyBound, Math.max(1, Math.floor(allowance)));
+const effectiveRunBounds = (policy, options) => ({
+	maxTurns: boundedAllowance(policy.maxTurns, options.turnAllowance),
+	maxToolCalls: boundedAllowance(policy.maxToolCalls, options.toolCallAllowance)
+});
+const decodeResumedSettledCall = Effect.fn("AgentRuntime.decodeResumedSettledCall")((input, maxResultBytes, providerCallIds) => Effect.gen(function* () {
+	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 result = boundedCanonicalJsonSnapshot(raw.result, typeof raw.id === "string" && providerCallIds.has(raw.id) ? MAX_STAGED_PROVIDER_BYTES : maxResultBytes);
+	if (result === void 0) return yield* ModelProtocolError.make({ message: "Turn resume settled Tool result is not bounded canonical JSON" });
+	return yield* Schema.decodeUnknownEffect(RunTurnResumeSettledCallSchema)({
+		...raw,
+		result: result.value
+	}).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Turn resume contains an invalid settled Tool Call" })));
+}));
+const snapshotResumedSettledCalls = Effect.fn("AgentRuntime.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 decodeResumeUsage = Effect.fn("AgentRuntime.decodeResumeUsage")((input) => Effect.gen(function* () {
+	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"
+				].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" })
+	});
+	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.fn("AgentRuntime.makeToolFailedEvent")(function* (context, turnId, call, error, failureHandling, budgetRejected) {
+	const toolCallId = yield* decodeToolCallId(call.id);
+	const tools = context.definition.toolkit.tools;
+	return ToolCallFailed.make({
+		...yield* eventBase(context),
+		turnId,
+		toolCallId,
+		toolName: call.name,
+		errorTag: errorTag(error),
+		message: errorMessage(error),
+		providerExecuted: false,
+		failureHandling,
+		...Object.hasOwn(tools, call.name) ? { failureMode: tools[call.name].failureMode } : {},
+		...budgetRejected === void 0 ? {} : { budgetRejected }
+	});
+});
+/**
+* Settle a rejected Tool batch without starting any handler: every open
+* application call receives the encoded failure as its model-visible result.
+* Only budget rejections (RUN-018) are exempt from repeated-failure folding;
+* correctable model declarations count as ordinary failed calls. Emit one
+* `ToolCallFailed` per call with no `ToolCallStarted` (the
+* approval-denied precedent). The caller hands the trace to
+* `toolBatchContinuation`, so the synthetic results advance history through
+* the ordinary tool message and — under a durable coordinator that never saw
+* a response commit for this Turn — settle canonically via the single-batch
+* Turn commit.
+*/
+const settleRejectedBatch = Effect.fn("AgentRuntime.settleRejectedBatch")(function* (context, turnId, trace, error, alreadySettled) {
+	const budgetRejected = error._tag === "AgentPolicyError" ? true : void 0;
+	const encodedResult = {
+		_tag: error._tag,
+		...error._tag === "AgentPolicyError" ? { limit: error.limit } : {},
+		message: error.message
+	};
+	const events = [];
+	for (const [index, call] of trace.applicationToolCalls.entries()) {
+		if (alreadySettled?.has(call.id) === true) continue;
+		trace.finalToolResultIds.add(call.id);
+		trace.applicationToolResults[index] = {
+			id: call.id,
+			name: call.name,
+			encodedResult,
+			isFailure: true,
+			...budgetRejected === void 0 ? {} : { budgetRejected }
+		};
+		events.push(yield* makeToolFailedEvent(context, turnId, call, error, "returned-to-model", budgetRejected));
+	}
+	return events;
+});
+const stampSubagentEvent = Effect.fn("AgentRuntime.stampSubagentEvent")(function* (context, turnId, payload) {
+	if (payload._tag === "AgentUpdateEmitted") return AgentUpdateEmitted.make({
+		...yield* eventBase(context),
+		turnId,
+		update: payload.update
+	});
+	const shared = {
+		...yield* eventBase(context),
+		turnId,
+		toolCallId: payload.toolCallId,
+		delegationId: payload.delegationId,
+		childThreadId: payload.childThreadId,
+		childRunId: payload.childRunId,
+		targetAgentId: payload.targetAgentId,
+		depth: payload.depth
+	};
+	const report = "usage" in payload ? {
+		...payload.usage === void 0 ? {} : { usage: payload.usage },
+		...payload.delegatedUsage === void 0 ? {} : { delegatedUsage: payload.delegatedUsage }
+	} : {};
+	switch (payload._tag) {
+		case "SubagentRequested": return SubagentRequested.make(shared);
+		case "SubagentStarted": return SubagentStarted.make(shared);
+		case "SubagentProgress": return SubagentProgress.make({
+			...shared,
+			summary: payload.summary
+		});
+		case "SubagentCompleted": return SubagentCompleted.make({
+			...shared,
+			turns: payload.turns,
+			finishReason: payload.finishReason,
+			...payload.exhausted !== void 0 ? { exhausted: payload.exhausted } : {},
+			...report
+		});
+		case "SubagentFailed": return SubagentFailed.make({
+			...shared,
+			...report,
+			errorTag: payload.errorTag,
+			message: payload.message
+		});
+		case "SubagentInterrupted": return SubagentInterrupted.make({
+			...shared,
+			...report,
+			reason: payload.reason
+		});
+		case "SubagentJoined": return SubagentJoined.make({
+			...shared,
+			...report
+		});
+	}
+});
+const approvalDecision = (context, turnId, prepared, options) => Effect.gen(function* () {
+	const approval = prepared.tool.needsApproval;
+	if (approval === void 0 || approval === false) return { required: false };
+	if (!(typeof approval === "function" ? yield* Effect.suspend(() => {
+		const result = approval(prepared.decodedParams, {
+			toolCallId: prepared.call.id,
+			messages: context.history.content
+		});
+		return Effect.isEffect(result) ? result : Effect.succeed(result);
+	}) : approval)) return { required: false };
+	const request = Response.makePart("tool-approval-request", {
+		approvalId: `${context.runId}:${prepared.call.id}`,
+		toolCallId: prepared.call.id
+	});
+	if (options.approval === void 0) return {
+		required: true,
+		request,
+		decision: {
+			_tag: "unresolved",
+			reason: "No approval decision hook is available"
+		}
+	};
+	const toolCallId = yield* decodeToolCallId(prepared.call.id);
+	return {
+		required: true,
+		request,
+		decision: yield* options.approval.request({
+			request,
+			threadId: context.threadId,
+			runId: context.runId,
+			turnId,
+			toolCallId,
+			toolName: prepared.call.name,
+			parameters: prepared.decodedParams
+		})
+	};
+});
+/**
+* Resolve every native Effect AI approval before the handler scheduler starts.
+* Concatenating this preflight stream ahead of handler streams makes denied or
+* unresolved batches a strict no-start boundary.
+*/
+const preflightApproval = (context, turnId, prepared, options) => Stream.unwrap(approvalDecision(context, turnId, prepared, options).pipe(Effect.flatMap((approval) => {
+	if (!approval.required) return Effect.succeed(Stream.empty);
+	return Effect.gen(function* () {
+		const toolCallId = yield* decodeToolCallId(prepared.call.id);
+		const requested = ApprovalRequested.make({
+			...yield* eventBase(context),
+			turnId,
+			toolCallId,
+			toolName: prepared.call.name
+		});
+		switch (approval.decision._tag) {
+			case "approved": return Stream.succeed(requested);
+			case "denied": {
+				const denied = AgentApprovalDenied.make({
+					toolCallId: prepared.call.id,
+					toolName: prepared.call.name,
+					message: approval.decision.reason ?? "Tool approval was denied"
+				});
+				const failed = ToolCallFailed.make({
+					...yield* eventBase(context),
+					turnId,
+					toolCallId,
+					toolName: prepared.call.name,
+					errorTag: denied._tag,
+					message: denied.message,
+					providerExecuted: false,
+					failureMode: prepared.tool.failureMode,
+					failureHandling: "propagated"
+				});
+				return Stream.fromIterable([requested, failed]).pipe(Stream.concat(Stream.fail(denied)));
+			}
+			case "unresolved": {
+				const pending = AgentApprovalPending.make({
+					approvalId: approval.request.approvalId,
+					toolCallId: prepared.call.id,
+					toolName: prepared.call.name,
+					message: approval.decision.reason ?? "Tool approval remains unresolved"
+				});
+				return Stream.succeed(requested).pipe(Stream.concat(Stream.fail(pending)));
+			}
+		}
+	});
+})));
+/**
+* Recheck host-owned Tool authority after approval and before durable preparation or scheduling.
+* Every call in the executable batch is authorized in declaration order before ANY Handler may
+* start, so a later denial leaves this Attempt's complete batch at zero application side effects.
+*/
+const preflightToolAuthorization = (context, turnId, turn, call, options, annotations) => {
+	const authorization = isSubagentToolAllowed(options.subagentGrant, options.delegationDepth ?? options.parentLink?.depth ?? 0, call.toolName, annotations) ? options.toolAuthorization : { authorize: () => Effect.succeed({
+		_tag: "denied",
+		reason: "Tool exceeds the inherited subagent grant"
+	}) };
+	if (authorization === void 0) return Stream.empty;
+	return Stream.unwrap(authorization.authorize({
+		threadId: context.threadId,
+		runId: context.runId,
+		turnId,
+		turn,
+		input: context.input,
+		call
+	}).pipe(Effect.map((decision) => {
+		if (decision._tag === "allowed") return Stream.empty;
+		const denied = AgentToolAuthorizationDenied.make({
+			toolCallId: call.toolCallId,
+			toolName: call.toolName,
+			message: decision.reason
+		});
+		return Stream.fromEffect(Effect.map(eventBase(context), (base) => ToolCallFailed.make({
+			...base,
+			turnId,
+			toolCallId: call.toolCallId,
+			toolName: call.toolName,
+			errorTag: denied._tag,
+			message: denied.message,
+			providerExecuted: false,
+			failureMode: context.definition.toolkit.tools[call.toolName].failureMode,
+			failureHandling: "propagated"
+		}))).pipe(Stream.concat(Stream.fail(denied)));
+	})));
+};
+const ProviderResponsePartId = Schema.String.check(Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/));
+const ProviderToolCallId = ToolCallId.check(Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/));
+const isTelemetryToolCallId = Schema.is(ProviderToolCallId);
+/** One bounded identity surface shared by canonical Tool spans and terminal logs. */
+const toolTelemetryAttributes = (descriptor) => ({
+	"gen_ai.operation.name": "execute_tool",
+	"gen_ai.tool.name": descriptor.toolName,
+	"gen_ai.tool.type": "function",
+	...descriptor.toolCallId === void 0 ? {} : {
+		"gen_ai.tool.call.id": descriptor.toolCallId,
+		toolCallId: descriptor.toolCallId
+	},
+	"gen_ai.agent.name": descriptor.context.agentId,
+	"gen_ai.conversation.id": descriptor.context.threadId,
+	"effect_agent.tool.execution_class": descriptor.executionClass,
+	"effect_agent.tool.invocation_kind": descriptor.invocationKind,
+	"effect_agent.tool.failure_mode": descriptor.failureMode,
+	...descriptor.parentToolCallId === void 0 ? {} : {
+		"effect_agent.tool.parent_call.id": descriptor.parentToolCallId,
+		parentToolCallId: descriptor.parentToolCallId
+	},
+	...descriptor.sequenceIndex === void 0 ? {} : {
+		"effect_agent.tool.sequence_index": descriptor.sequenceIndex,
+		sequenceIndex: descriptor.sequenceIndex
+	},
+	agentId: descriptor.context.agentId,
+	threadId: descriptor.context.threadId,
+	runId: descriptor.context.runId,
+	turnId: descriptor.turnId,
+	toolName: descriptor.toolName
+});
+/** Canonical content-free terminal signal for any application Tool handler attempt. */
+const terminalToolTelemetry = (descriptor, outcome, failureMarker, failureHandling) => annotateToolSpanTerminalOutcome(outcome, failureMarker, failureHandling, descriptor.failureMode).pipe(Effect.andThen((outcome === "success" ? Effect.logInfo("agent tool execution completed") : Effect.logWarning("agent tool execution failed")).pipe(Effect.annotateLogs({
+	...toolTelemetryAttributes(descriptor),
+	"effect_agent.tool.outcome": outcome,
+	...failureHandling === void 0 ? {} : { "effect_agent.tool.failure_handling": failureHandling },
+	toolExecutionClass: descriptor.executionClass,
+	toolOutcome: outcome
+}))));
+/** Bound only the observer's diagnostic; broker/public diagnostic policy is a separate contract. */
+const toolFailureMessage = (message) => {
+	let bytes = 0;
+	let end = 0;
+	for (const character of message) {
+		const size = utf8ByteLength(character);
+		if (bytes + size > 4096) break;
+		bytes += size;
+		end += character.length;
+	}
+	return message.slice(0, end);
+};
+const executePreparedToolCall = (context, turnId, toolkit, prepared, trace, resultBounds, onWaiting) => {
+	const call = prepared.call;
+	const observer = context.toolFailureObserver;
+	const telemetryToolCallId = isTelemetryToolCallId(call.id) ? call.id : void 0;
+	const executionClass = getToolExecutionClass(prepared.tool);
+	const telemetryDescriptor = {
+		context,
+		turnId,
+		toolCallId: telemetryToolCallId,
+		toolName: call.name,
+		executionClass,
+		invocationKind: "model",
+		failureMode: prepared.tool.failureMode
+	};
+	const toolSpanFailure = ToolSpanFailure.marker();
+	let terminal = false;
+	let terminalResultCommitted = false;
+	let terminalOutcome;
+	let terminalResult;
+	let propagatedFailure;
+	let failureObservation;
+	const terminalTelemetry = (outcome, failureHandling) => terminalToolTelemetry(telemetryDescriptor, outcome, outcome === "failure" ? toolSpanFailure : void 0, failureHandling);
+	const isolatedTerminalTelemetry = (outcome, failureHandling) => isolateToolDerivative(terminalTelemetry(outcome, failureHandling));
+	/**
+	* The authoritative event reaches the downstream Run stream before derivative work starts.
+	* Telemetry and observation share one owner across the next-pull/early-close race, under this
+	* call's batch permit. A returned failure still fails a normal second pull with the span marker.
+	*/
+	const terminalEventThenAfter = (event, outcome, failSpan, failureHandling) => {
+		const telemetry = isolatedTerminalTelemetry(outcome, failureHandling);
+		const after = observer === void 0 ? telemetry : telemetry.pipe(Effect.andThen(Effect.suspend(() => failureObservation === void 0 ? Effect.void : deliverToolFailure(observer, failureObservation))));
+		return emitThenAfter(event, after.pipe(Effect.andThen(failSpan ? Effect.fail(toolSpanFailure) : Effect.void)));
+	};
+	const started = Stream.fromEffect(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,
+			turnId,
+			...telemetryToolCallId === void 0 ? {} : { toolCallId: telemetryToolCallId },
+			toolName: call.name
+		}));
+		yield* Metric.update(toolCounter, 1);
+		return ToolCallStarted.make({
+			...yield* eventBase(context),
+			turnId,
+			toolCallId,
+			toolName: call.name
+		});
+	}).pipe(Effect.withLogSpan("AgentRuntime.tool")));
+	const handle = toolkit.handle;
+	const results = Stream.unwrap(Effect.flatMap(ToolSpanTelemetry, ({ isolateToolkitHandle }) => isolateToolkitHandle(handle.call(toolkit, prepared.name, call.params, call.id)))).pipe(Stream.mapEffect((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);
+		if (result.preliminary) {
+			const owned = yield* ownApplicationToolProgress(context, result.encodedResult);
+			return ToolProgress.make({
+				...yield* eventBase(context),
+				turnId,
+				toolCallId,
+				toolName: call.name,
+				result: owned,
+				providerExecuted: false
+			});
+		}
+		terminal = true;
+		terminalOutcome = result.isFailure ? "failure" : "success";
+		terminalResult = {
+			encodedResult: result.encodedResult,
+			isFailure: result.isFailure,
+			result: result.result
+		};
+	})), Stream.filter((event) => event !== void 0));
+	const commitTerminalResult = Effect.suspend(() => {
+		if (!terminal || terminalOutcome === void 0 || terminalResult === void 0) return Effect.fail(ModelProtocolError.make({ message: `Tool Call ${call.id} completed without a terminal result` }));
+		const result = terminalResult;
+		return Effect.gen(function* () {
+			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 event = result.isFailure ? ToolCallFailed.make({
+				...yield* eventBase(context),
+				turnId,
+				toolCallId,
+				toolName: call.name,
+				errorTag: errorTag(result.result),
+				message: errorMessage(result.result),
+				providerExecuted: false,
+				failureMode: prepared.tool.failureMode,
+				failureHandling: "returned-to-model"
+			}) : ToolCallSucceeded.make({
+				...yield* eventBase(context),
+				turnId,
+				toolCallId,
+				toolName: call.name,
+				result: yield* decodeEventJson(encodedResult, "Tool result"),
+				...toolSelection === void 0 ? {} : { toolSelection },
+				providerExecuted: false
+			});
+			trace.finalToolResultIds.add(call.id);
+			trace.applicationToolResults[prepared.declarationIndex] = {
+				...toolSelection === void 0 ? {} : { toolSelection },
+				id: call.id,
+				name: call.name,
+				encodedResult,
+				isFailure: result.isFailure
+			};
+			terminalResultCommitted = true;
+			if (observer !== void 0 && event._tag === "ToolCallFailed") failureObservation = {
+				_tag: "ModelToolFailure",
+				kind: "declared-failure",
+				agentId: context.agentId,
+				threadId: context.threadId,
+				runId: context.runId,
+				turnId,
+				toolCallId,
+				toolName: call.name,
+				executionClass,
+				tag: event.errorTag
+			};
+			return event;
+		});
+	});
+	const finalizeTerminalResult = Stream.unwrap(Effect.sync(() => terminalEventThenAfter(commitTerminalResult, terminalOutcome ?? "failure", terminalOutcome === "failure", terminalOutcome === "failure" ? "returned-to-model" : void 0)));
+	const failTerminalResult = (cause) => {
+		terminal = true;
+		terminalOutcome = "failure";
+		terminalResult = void 0;
+		propagatedFailure = cause;
+		return terminalEventThenAfter(makeToolFailedEvent(context, turnId, call, Cause.squash(cause), "propagated").pipe(Effect.tap(() => Effect.sync(() => {
+			trace.finalToolResultIds.add(call.id);
+			terminalResultCommitted = true;
+		}))), "failure", true, "propagated");
+	};
+	const measured = started.pipe(Stream.concat(results), Stream.concat(finalizeTerminalResult), Stream.catchCause((cause) => {
+		const { found: hasToolSpanFailure, residual: toolCause } = stripToolSpanFailures(cause, toolSpanFailure);
+		if (hasToolSpanFailure) return Stream.failCause(cause);
+		if (terminalResultCommitted) return Stream.failCause(toolCause);
+		if (toolCause.reasons.length > 0 && toolCause.reasons.every(Cause.isInterruptReason)) return Stream.failCause(toolCause);
+		const waiting = waitingFromCause(toolCause);
+		if (waiting !== void 0) {
+			if (terminal || trace.finalToolResultIds.has(call.id)) return failTerminalResult(Cause.fail(ModelProtocolError.make({ message: `Tool Call ${call.id} raised the waiting signal after its terminal result` })));
+			onWaiting(waiting);
+			return Stream.empty;
+		}
+		return failTerminalResult(toolCause);
+	}), Stream.withSpan(`execute_tool ${call.name}`, {
+		kind: "internal",
+		attributes: toolTelemetryAttributes(telemetryDescriptor)
+	}));
+	return Stream.unwrap(Effect.map(ToolSpanTelemetry, ({ isolateSpanLifecycle }) => isolateSpanLifecycle(measured))).pipe(Stream.catchCause((cause) => {
+		const { found, restored } = restoreToolSpanFailureCause(cause, toolSpanFailure, propagatedFailure);
+		if (!found) return Stream.failCause(restored);
+		return restored.reasons.length === 0 ? Stream.empty : Stream.failCause(restored);
+	}));
+};
+/**
+* Execute a wholly preflighted native Toolkit batch under one finite engine
+* semaphore.
+*
+* The engine provides this batch's `RunEventSink` locally to the handler
+* streams, bound to the batch's Turn. Sink emissions are drained into the
+* batch stream and stamped through `eventBase`; the batch settles (including
+* by failure) only after every already-emitted Subagent event has surfaced.
+* The public exclusion of engine-provided services happens once at the Run
+* boundary in `stream`, so this signature keeps the naked handler services.
+*/
+const executeToolBatch = (context, turnId, turn, toolkit, calls, trace, concurrency, options, brokerAccounting, resultBounds, settledCallIds) => Stream.unwrap(Effect.gen(function* () {
+	const exposed = context.toolExposure?.exposedToolNames;
+	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* Effect.forEach(calls, (call, declarationIndex) => prepareToolCall(toolkit, call, declarationIndex));
+	if (prepared.some((call) => Context.get(call.tool.annotations, ContextRolloverTool)) && trace.toolCalls.size !== 1) return yield* ModelProtocolError.make({ message: "A context rollover Tool must be the only Tool Call in its batch" });
+	const semaphore = yield* Semaphore.make(concurrency);
+	const approvalPreflight = prepared.reduce((stream, call) => stream.pipe(Stream.concat(preflightApproval(context, turnId, call, options))), Stream.empty);
+	const descriptors = trace.applicationCallDescriptors;
+	const durability = options.durability;
+	const hookServices = yield* Effect.context();
+	const executable = settledCallIds === void 0 ? prepared : prepared.filter((call) => !settledCallIds.has(call.call.id));
+	const authorizationPreflight = (settledCallIds === void 0 ? descriptors : descriptors.filter((call) => !settledCallIds.has(call.toolCallId))).reduce((stream, call) => stream.pipe(Stream.concat(preflightToolAuthorization(context, turnId, turn, call, options, toolkit.tools[call.toolName]?.annotations ?? Context.empty()))), Stream.empty);
+	const preparation = durability === void 0 ? Stream.empty : Stream.fromEffect(Effect.suspend(() => {
+		const preparedDescriptors = descriptors.filter((call) => call.executionClass !== "readonly" || call.executionKind !== "ordinary");
+		return preparedDescriptors.length === 0 ? Effect.void : durability.prepareToolCalls(preparedDescriptors);
+	})).pipe(Stream.drain);
+	const stepServiceFor = (call) => durability === void 0 ? passthroughDurableStep() : makeDurableStepService(call.toolCallId, durability.step, hookServices);
+	const subagentHook = options.subagent;
+	const batchSubagentDurability = subagentHook === void 0 ? ephemeralSubagentDurability : makeSubagentDurabilityService(subagentHook, hookServices);
+	const waitingByDeclaration = /* @__PURE__ */ new Map();
+	const scheduling = options.scheduling ?? (yield* RunToolScheduling);
+	const groups = [];
+	let parallel = [];
+	for (const call of executable) if (scheduling.toolRequiresSequential?.(call.name) === true) {
+		if (parallel.length > 0) {
+			groups.push(parallel);
+			parallel = [];
+		}
+		groups.push([call]);
+	} else parallel.push(call);
+	if (parallel.length > 0) groups.push(parallel);
+	const handlers = groups.reduce((stream, group) => {
+		const channels = group.map((call) => withSemaphorePermit(semaphore, Stream.unwrap(Effect.gen(function* () {
+			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: options.durability?.reservePolicyUsage,
+				hookServices
+			});
+			return executePreparedToolCall(context, turnId, toolkit, call, trace, resultBounds, (waiting) => {
+				waitingByDeclaration.set(call.declarationIndex, waiting);
+			}).pipe(Stream.provideService(DurableStep, stepServiceFor(call)), Stream.provideService(SubagentHost, subagentHost(source)), Stream.provideService(MessagingHost, messagingHost(source)), Stream.provideService(ToolBroker, broker.service), Stream.provideService(CurrentToolCatalog, { entries: context.toolCatalog }), Stream.ensuring(Effect.sync(() => broker.close())));
+		}))).channel);
+		const next = Stream.fromChannel(Channel.mergeAll(Channel.fromIterable(channels), { concurrency }));
+		return stream.pipe(Stream.concat(next));
+	}, Stream.empty);
+	const sinkQueue = yield* Queue.bounded(context.bufferLimits.maxSubagentEventsPerBatch);
+	const batchSink = { emit: (payload) => ![
+		"SubagentRequested",
+		"SubagentStarted",
+		"SubagentProgress",
+		"SubagentCompleted",
+		"SubagentFailed",
+		"SubagentInterrupted",
+		"SubagentJoined"
+	].includes(payload._tag) ? Effect.fail(new RunEventSinkClosedError({ message: "Unsupported Tool event payload" })) : Queue.offer(sinkQueue, payload).pipe(Effect.flatMap((accepted) => accepted ? Effect.sync(() => {
+		if (context.liveChildren.has(payload.childRunId)) return;
+		if ("usage" in payload && payload.usage !== void 0) context.childUsage.set(payload.childRunId, Effect.succeed(RunUsageReport.make({
+			usage: payload.usage,
+			delegatedUsage: payload.delegatedUsage ?? unknownRunTotals()
+		})));
+		else if (payload._tag === "SubagentStarted" && !context.childUsage.has(payload.childRunId)) context.childUsage.set(payload.childRunId, Effect.succeed(RunUsageReport.make({
+			usage: unknownRunTotals(),
+			delegatedUsage: unknownRunTotals()
+		})));
+	}) : Effect.fail(RunEventSinkClosedError.make({ message: `Subagent event ${payload._tag} was emitted after its Tool batch settled` })))) };
+	const updateAcceptance = yield* AgentUpdateAcceptance;
+	let updatesOpen = true;
+	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" })));
+		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" });
+			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" });
+		const snapshot = boundedCanonicalJsonSnapshot(value, bytes);
+		if (snapshot === void 0) return yield* new UpdateError({ reason: "validation" });
+		const accepted = yield* updateAcceptance.accept(Object.freeze(Update.make({
+			schemaVersion: 1,
+			agentId: context.agentId,
+			threadId: context.threadId,
+			runId: context.runId,
+			updateId,
+			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 update = Object.freeze(Update.make({
+			...validated,
+			value: snapshot.value
+		}));
+		context.updates.set(request.updateId, update);
+		context.updateBytes += bytes;
+		if (!(yield* Queue.offer(sinkQueue, {
+			_tag: "AgentUpdateEmitted",
+			update
+		}))) return yield* new UpdateError({ reason: "unavailable" });
+		return update;
+	})) };
+	let settledCause;
+	const settling = handlers.pipe(Stream.provideService(RunEventSink, batchSink), Stream.provideService(Emitter, updateEmitter), Stream.provideService(SubagentDurability, batchSubagentDurability), Stream.catchCause((cause) => {
+		settledCause = cause;
+		return Stream.empty;
+	}), Stream.ensuring(Effect.sync(() => {
+		updatesOpen = false;
+	}).pipe(Effect.andThen(Queue.end(sinkQueue)))));
+	const sinkEvents = Stream.fromQueue(sinkQueue).pipe(Stream.mapEffect((payload) => stampSubagentEvent(context, turnId, payload)));
+	const settled = Stream.merge(settling, sinkEvents).pipe(Stream.concat(Stream.fromEffect(Effect.suspend(() => {
+		if (settledCause !== void 0) return Effect.failCause(settledCause);
+		const waiting = [...waitingByDeclaration.entries()].sort(([left], [right]) => left - right).map(([, signal]) => signal);
+		const [first, ...rest] = waiting;
+		if (first === void 0) return Effect.void;
+		const child = (signal) => ({
+			toolCallId: signal.toolCallId,
+			childThreadId: signal.childThreadId,
+			childSubmissionId: signal.childSubmissionId,
+			childRunId: signal.childRunId
+		});
+		return Effect.fail(AgentChildPending.make({
+			children: [child(first), ...rest.map(child)],
+			message: `${waiting.length} durable delegation ${waiting.length === 1 ? "call is" : "calls are"} waiting on attached children; the Run suspended without settling`
+		}));
+	})).pipe(Stream.drain)));
+	return approvalPreflight.pipe(Stream.concat(authorizationPreflight), Stream.concat(preparation), Stream.concat(settled));
+}));
+const schedulingConcurrency = Effect.fn("AgentRuntime.schedulingConcurrency")(function* (configured, explicit) {
+	const override = (explicit ?? (yield* RunToolScheduling)).runOverride;
+	if (override === void 0) return configured;
+	if (override.mode === "sequential") return 1;
+	if (!Number.isInteger(override.concurrency) || override.concurrency <= 0) return yield* AgentPolicyError.make({
+		limit: "usage",
+		message: "Run Tool concurrency override must be a positive integer"
+	});
+	return Math.min(configured, override.concurrency);
+});
+/**
+* One terminal outcome per declared Tool Call of the completed Turn, in
+* declaration order. Provider-executed results are read from the response
+* parts; application results from the settled batch.
+*/
+const turnToolFailures = (trace) => {
+	const outcomes = [];
+	for (const [id, call] of trace.toolCalls) {
+		if (call.providerExecuted) {
+			for (const part of trace.parts) if (part.type === "tool-result" && part.id === id && part.preliminary !== true) {
+				outcomes.push(part.isFailure);
+				break;
+			}
+			continue;
+		}
+		const result = trace.applicationToolResults.find((candidate) => candidate?.id === id);
+		if (result !== void 0 && result.budgetRejected !== true) outcomes.push(result.isFailure);
+	}
+	return outcomes;
+};
+/**
+* Fold the completed Turn's terminal Tool outcomes into the Run's
+* consecutive-failure counter in declaration order, then enforce the
+* repeated-failure Stop Policy before the next model request. A terminal
+* success resets the counter; a `repeatedFailureLimit` of `0` disables the
+* bound.
+*/
+const applyRepeatedFailurePolicy = (context, trace, repeatedFailureLimit) => Effect.suspend(() => {
+	for (const isFailure of turnToolFailures(trace)) context.consecutiveToolFailures = isFailure ? context.consecutiveToolFailures + 1 : 0;
+	if (repeatedFailureLimit > 0 && context.consecutiveToolFailures >= repeatedFailureLimit) return Effect.fail(AgentPolicyError.make({
+		limit: "repeated-failures",
+		message: `Agent reached its ${repeatedFailureLimit} consecutive Tool Call failure limit`
+	}));
+	return Effect.void;
+});
+const inputsToPrompt = (inputs) => Effect.try({
+	try: () => Prompt.fromMessages(inputs.flatMap((input) => Prompt.make(input).content)),
+	catch: (cause) => AgentInputError.make({ message: `Unable to materialize queued Run input: ${errorMessage(cause)}` })
+});
+/** Validate live reference context before it reaches budgeting or provider I/O. */
+const transientInputToPrompt = (input) => Effect.try({
+	try: () => Prompt.make(input),
+	catch: (cause) => AgentInputError.make({ message: `Unable to materialize transient Run context: ${errorMessage(cause)}` })
+}).pipe(Effect.flatMap((prompt) => Schema.decodeEffect(Prompt.Prompt)({ content: prompt.content }).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to materialize transient Run context: ${errorMessage(cause)}` })))));
+const advanceHistory = (context, history, options) => Effect.gen(function* () {
+	context.history = history;
+	if (options.onHistory !== void 0) yield* options.onHistory(history);
+});
+const drainInputs = (context, options) => Effect.gen(function* () {
+	if (options.input === void 0) return [];
+	const commands = yield* options.input.drain(options.commandDrainPolicy ?? "one");
+	const steering = [];
+	for (const command of commands) if (command.kind === "steering") steering.push(command.input);
+	else context.pendingFollowUps.push(command.input);
+	return steering;
+});
+const takeFollowUps = (context, policy) => {
+	if (context.pendingFollowUps.length === 0) return [];
+	if (policy === "one") {
+		const input = context.pendingFollowUps.shift();
+		return input === void 0 ? [] : [input];
+	}
+	return context.pendingFollowUps.splice(0, context.pendingFollowUps.length);
+};
+const appendInputs = (context, source, inputs, options) => Effect.gen(function* () {
+	if (inputs.length === 0) return source;
+	const additions = yield* inputsToPrompt(inputs);
+	const history = Prompt.fromMessages([...source.content, ...additions.content]);
+	yield* advanceHistory(context, history, options);
+	return history;
+});
+/**
+* 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.
+*/
+const boundEncodedToolResult = (encodedResult, bounds) => {
+	let text;
+	try {
+		text = JSON.stringify(encodedResult);
+	} catch (cause) {
+		return unserializableToolResult(cause);
+	}
+	if (text === void 0) return 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);
+	}
+};
+const RUN_STATUS_WARNING = " · WARNING: approaching limits — converge and deliver your final result now.";
+/** Fraction checks use `consumed * 5 >= limit * 4` so the 80% threshold stays integer-exact. */
+const nearingLimit = (consumed, limit) => consumed * 5 >= limit * 4;
+/**
+* RUN-024: render the derived run-status message appended to each outgoing
+* model request. The format is pinned here — tests target this function.
+*/
+const formatRunStatus = (view) => {
+	const researchBudget = view.tokenBudget === void 0 ? void 0 : Math.max(0, view.tokenBudget - (view.completionReserveTokens ?? 0));
+	const remainingResearch = researchBudget === void 0 ? void 0 : Math.max(0, researchBudget - view.tokensConsumed);
+	const warn = nearingLimit(view.turn, view.maxTurns) || nearingLimit(view.toolCallsUsed, view.maxToolCalls) || researchBudget !== void 0 && (nearingLimit(view.tokensConsumed, researchBudget) || view.lastInputTokens > 0 && (remainingResearch ?? 0) <= view.lastInputTokens) || nearingLimit(view.elapsedSeconds, view.maxDurationSeconds);
+	const reserveStatus = view.tokenBudget === void 0 ? "" : ` · research-remaining ${remainingResearch} · completion-reserve ${view.completionReserveTokens ?? 0}`;
+	return `<run-status>turn ${view.turn}/${view.maxTurns} · tool-calls ${view.toolCallsUsed}/${view.maxToolCalls} · tokens ${view.tokensConsumed}/${view.tokenBudget ?? "unbounded"}${reserveStatus} · last-context ${view.lastInputTokens} · elapsed ${view.elapsedSeconds}s/${view.maxDurationSeconds}s${warn ? RUN_STATUS_WARNING : ""}</run-status>`;
+};
+/**
+* The run-status message is derived per request and appended only to the
+* OUTGOING prompt: official history and durable commits never carry it, so it
+* can never accumulate or replay.
+*/
+const outgoingModelPrompt = (policy, context, prepared, turn, declaredToolCalls) => Effect.gen(function* () {
+	if (policy.runStatus !== "appended") return prepared;
+	const now = yield* Clock.currentTimeMillis;
+	const status = formatRunStatus({
+		turn,
+		maxTurns: policy.maxTurns,
+		toolCallsUsed: declaredToolCalls + context.programmaticToolCalls,
+		maxToolCalls: policy.maxToolCalls,
+		tokensConsumed: context.inputTokens + context.outputTokens,
+		tokenBudget: policy.tokenBudget,
+		completionReserveTokens: policy.completionReserveTokens,
+		lastInputTokens: context.lastInputTokens,
+		elapsedSeconds: Math.max(0, Math.floor((now - context.startedAtMillis) / 1e3)),
+		maxDurationSeconds: Math.floor(Duration.toMillis(policy.maxDuration) / 1e3)
+	});
+	return Prompt.fromMessages([...prepared.content, Prompt.makeMessage("user", { content: [Prompt.makePart("text", { text: status })] })]);
+});
+const ProviderUsage = Schema.Struct({
+	inputTokens: Schema.Struct({
+		uncached: Schema.optional(Schema.Natural),
+		total: Schema.optional(Schema.Natural),
+		cacheRead: Schema.optional(Schema.Natural),
+		cacheWrite: Schema.optional(Schema.Natural)
+	}),
+	outputTokens: Schema.Struct({
+		total: Schema.optional(Schema.Natural),
+		text: Schema.optional(Schema.Natural),
+		reasoning: Schema.optional(Schema.Natural)
+	})
+});
+const invalidProviderUsage = () => ModelProtocolError.make({ message: "Model response usage fields and derived totals must be non-negative safe integers" });
+const decodeProviderUsageTotal = (value) => Schema.decodeEffect(Schema.Natural)(value).pipe(Effect.mapError(() => invalidProviderUsage()));
+const consumeUsage = (agent, context, usage, toolCallCount, turn, options, response = {}) => Effect.gen(function* () {
+	if (usage === void 0) return yield* AgentPolicyError.make({
+		limit: "usage",
+		message: "A completed model response did not report usage"
+	});
+	const providerUsage = yield* Schema.decodeEffect(ProviderUsage)(usage).pipe(Effect.mapError(() => invalidProviderUsage()));
+	const reportedUncached = providerUsage.inputTokens.uncached ?? 0;
+	const cacheRead = providerUsage.inputTokens.cacheRead ?? 0;
+	const cacheWrite = providerUsage.inputTokens.cacheWrite ?? 0;
+	const reportedText = providerUsage.outputTokens.text ?? 0;
+	const reasoning = providerUsage.outputTokens.reasoning ?? 0;
+	const reportedInputTotal = providerUsage.inputTokens.total;
+	const reportedInputWithoutWrite = yield* decodeProviderUsageTotal(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 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 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();
+	const outputTokens = reportedOutputTotal ?? reportedOutputComponents;
+	const inputRemainder = inputTokens - reportedInputComponents;
+	const outputRemainder = outputTokens - reportedOutputComponents;
+	const uncached = disjointReportedUncached + (providerUsage.inputTokens.uncached === void 0 ? inputRemainder : 0);
+	const normalizedCacheRead = cacheRead + (providerUsage.inputTokens.uncached !== void 0 && providerUsage.inputTokens.cacheRead === void 0 ? inputRemainder : 0);
+	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 totalTokens = yield* decodeProviderUsageTotal(inputTokens + outputTokens);
+	const provider = yield* Model.ProviderName;
+	const model = yield* Model.ModelName;
+	const estimate = options.estimateCostMicrousd === void 0 ? 0 : yield* options.estimateCostMicrousd(usage, {
+		provider,
+		model,
+		usage,
+		...response
+	});
+	const costMicrousd = typeof estimate === "number" ? estimate : estimate.costMicrousd;
+	if (!Number.isSafeInteger(costMicrousd) || costMicrousd < 0) return yield* AgentPolicyError.make({
+		limit: "cost",
+		message: "Model cost estimation must produce a non-negative integer number of microdollars"
+	});
+	const serviceTier = typeof estimate === "number" ? void 0 : estimate.serviceTier;
+	const pricingVersion = typeof estimate === "number" ? void 0 : estimate.pricingVersion;
+	const pricingStatus = options.estimateCostMicrousd === void 0 ? "unknown" : typeof estimate === "number" ? "estimated" : estimate.pricingStatus ?? "estimated";
+	const validPricingIdentity = (value) => value === void 0 || value.length > 0 && value.length <= 256;
+	if (!validPricingIdentity(serviceTier) || !validPricingIdentity(pricingVersion)) return yield* AgentPolicyError.make({
+		limit: "cost",
+		message: "Model cost estimation returned an invalid service tier or pricing version"
+	});
+	const modelUsage = ModelCallUsage.make({
+		provider,
+		model,
+		...response.response === void 0 ? {} : { response: ModelResponseIdentity.make(response.response) },
+		purpose: response.purpose ?? "turn",
+		usageStatus: Object.values(providerUsage.inputTokens).every((value) => value === void 0) && Object.values(providerUsage.outputTokens).every((value) => value === void 0) ? "unknown" : [
+			providerUsage.inputTokens.uncached,
+			providerUsage.inputTokens.cacheRead,
+			providerUsage.inputTokens.cacheWrite,
+			providerUsage.outputTokens.text,
+			providerUsage.outputTokens.reasoning
+		].every((value) => value !== void 0) ? "complete" : "partial",
+		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
+		}),
+		costMicrousd
+	});
+	const modelCalls = yield* decodeProviderUsageTotal(context.modelCalls + 1);
+	const cumulativeInputTokens = yield* decodeProviderUsageTotal(context.inputTokens + inputTokens);
+	const cumulativeOutputTokens = yield* decodeProviderUsageTotal(context.outputTokens + outputTokens);
+	const cumulativeCostMicrousd = context.costMicrousd + costMicrousd;
+	if (!Number.isSafeInteger(cumulativeCostMicrousd)) return yield* AgentPolicyError.make({
+		limit: "cost",
+		message: "Cumulative model cost exceeds safe-integer accounting capacity"
+	});
+	const firstObserved = context.modelCalls === 0 && context.unobservedModelCalls === 0;
+	const combineStatus = (prior, next) => firstObserved && prior === "complete" ? next : prior === next ? prior : "partial";
+	context.usageStatus = combineStatus(context.usageStatus, modelUsage.usageStatus ?? "unknown");
+	context.pricingStatus = combineStatus(context.pricingStatus, pricingStatus === "estimated" ? "complete" : "unknown");
+	context.modelCalls = modelCalls;
+	context.inputTokens = cumulativeInputTokens;
+	context.outputTokens = cumulativeOutputTokens;
+	context.lastInputTokens = inputTokens;
+	context.lastOutputTokens = outputTokens;
+	context.costMicrousd = cumulativeCostMicrousd;
+	context.lastCostMicrousd = costMicrousd;
+	if (options.durability !== void 0) yield* options.durability.noteTurnUsage({
+		turn,
+		usage: modelUsage
+	});
+	const policy = agent.definition.policy;
+	const consumedTokens = context.inputTokens + context.outputTokens;
+	const tokenBudget = policy.tokenBudget;
+	let breach;
+	if (!context.finalizing && !context.tokenExhausted && tokenBudget !== void 0 && consumedTokens > tokenBudget) {
+		breach = AgentPolicyError.make({
+			limit: "tokens",
+			message: `Agent exceeded its ${tokenBudget} token budget`
+		});
+		if (policy.onExhaustion === "fail") return yield* breach;
+		context.tokenExhausted = true;
+		context.exhaustedDimension ??= "tokens";
+	}
+	const costBudget = policy.costBudgetMicrousd;
+	if (costBudget !== void 0) {
+		if (options.estimateCostMicrousd === void 0) return yield* AgentPolicyError.make({
+			limit: "cost",
+			message: "Agent cost budget requires a model cost estimator"
+		});
+		if (pricingStatus === "unknown") return yield* AgentPolicyError.make({
+			limit: "cost",
+			message: "Agent cost budget requires a known model cost estimate"
+		});
+		if (context.costMicrousd > costBudget) return yield* AgentPolicyError.make({
+			limit: "cost",
+			message: `Agent exceeded its ${costBudget} microdollar cost budget`
+		});
+	}
+	if (options.budget !== void 0) {
+		const delta = {
+			modelCalls: 1,
+			inputTokens,
+			outputTokens,
+			totalTokens,
+			toolCalls: toolCallCount,
+			costMicrousd,
+			usage,
+			modelUsage
+		};
+		yield* options.budget.consume(delta);
+	}
+	const warnings = [];
+	if (tokenBudget !== void 0 && !context.warnedLimits.has("tokens") && nearingLimit(consumedTokens, tokenBudget)) {
+		context.warnedLimits.add("tokens");
+		warnings.push(BudgetWarning.make({
+			...yield* eventBase(context),
+			limit: "tokens",
+			consumed: consumedTokens,
+			limitValue: tokenBudget
+		}));
+	}
+	return {
+		breach,
+		warnings,
+		modelUsage
+	};
+});
+const eventBaseFor = Effect.fnUntraced(function* (context, terminal) {
+	const ceiling = terminal ? context.bufferLimits.maxRunEvents : context.bufferLimits.maxRunEvents - 1;
+	if (context.sequence >= ceiling) return yield* ModelProtocolError.make({ message: `Run exceeded the ${context.bufferLimits.maxRunEvents}-event buffer limit` });
+	const timestamp = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
+	const sequence = context.sequence;
+	context.sequence += 1;
+	return {
+		eventVersion: 1,
+		runId: context.runId,
+		threadId: context.threadId,
+		agentId: context.agentId,
+		sequence,
+		timestamp
+	};
+});
+const eventBase = (context) => eventBaseFor(context, false);
+/** The ordinary event budget always reserves one slot for this typed terminal projection. */
+const terminalEventBase = (context) => eventBaseFor(context, true);
+const toolProgressLimitError = (context) => ModelProtocolError.make({ message: `Run exceeded the ${context.bufferLimits.maxToolProgressBytes}-byte Tool progress limit or received invalid progress JSON` });
+const admitToolProgress = (context, snapshot) => Effect.suspend(() => {
+	if (snapshot.bytes > context.bufferLimits.maxToolProgressBytes - context.toolProgressBytes) return Effect.fail(toolProgressLimitError(context));
+	context.toolProgressBytes += snapshot.bytes;
+	return Effect.succeed(snapshot.value);
+});
+const ownApplicationToolProgress = (context, result) => Effect.suspend(() => {
+	const snapshot = boundedCanonicalJsonSnapshot(result, context.bufferLimits.maxToolProgressBytes - context.toolProgressBytes);
+	return snapshot === void 0 ? Effect.fail(toolProgressLimitError(context)) : admitToolProgress(context, snapshot);
+});
+const snapshotStagedProviderEvent = (trace, payload) => Effect.suspend(() => {
+	if (trace.providerResultPayloads.length + (trace.turnCompletion === void 0 ? 0 : 1) >= MAX_STAGED_PROVIDER_EVENTS) return Effect.fail(ModelProtocolError.make({ message: `Model response exceeded the ${MAX_STAGED_PROVIDER_EVENTS}-event staged provider event limit` }));
+	const snapshot = boundedJsonSnapshot(payload, MAX_STAGED_PROVIDER_BYTES - trace.providerStagedPayloadBytes);
+	if (snapshot === void 0) return Effect.fail(ModelProtocolError.make({ message: `Model response exceeded the ${MAX_STAGED_PROVIDER_BYTES}-byte staged provider event limit` }));
+	return Effect.succeed(snapshot);
+});
+const stageProviderResultPayload = (trace, payload) => Effect.gen(function* () {
+	const snapshot = yield* snapshotStagedProviderEvent(trace, payload);
+	const snapshotObject = snapshot.value;
+	if (snapshotObject === null || typeof snapshotObject !== "object" || Array.isArray(snapshotObject) || Object.getPrototypeOf(snapshotObject) !== null) return yield* ModelProtocolError.make({ message: "Provider Tool result could not be normalized as JSON" });
+	const resultDescriptor = Object.getOwnPropertyDescriptor(snapshotObject, "result");
+	const normalizedResult = resultDescriptor !== void 0 && "value" in resultDescriptor ? Schema.decodeUnknownOption(Schema.Json)(resultDescriptor.value) : Option.none();
+	if (payload._tag !== "ToolCallFailed" && Option.isNone(normalizedResult)) return yield* ModelProtocolError.make({ message: "Provider Tool result could not be normalized as JSON" });
+	const normalized = payload._tag === "ToolCallFailed" ? Object.freeze({ ...payload }) : Object.freeze({
+		...payload,
+		result: Option.getOrThrow(normalizedResult)
+	});
+	trace.providerResultPayloads.push(normalized);
+	trace.providerStagedPayloadBytes += snapshot.bytes;
+});
+const ProviderToolResultSnapshot = Schema.Struct({
+	result: Schema.Json,
+	metadata: Schema.Record(Schema.String, Schema.Json)
+});
+const snapshotProviderToolResultPart = Effect.fnUntraced(function* (trace, part) {
+	const snapshot = boundedJsonSnapshot({
+		result: part.encodedResult,
+		metadata: part.metadata
+	}, MAX_STAGED_PROVIDER_BYTES - trace.providerStagedPayloadBytes);
+	if (snapshot === void 0) return yield* ModelProtocolError.make({ message: `Model response exceeded the ${MAX_STAGED_PROVIDER_BYTES}-byte staged provider event limit` });
+	const normalized = yield* Schema.decodeUnknownEffect(ProviderToolResultSnapshot)(snapshot.value).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Provider Tool result could not be normalized as JSON" })));
+	trace.providerStagedPayloadBytes += snapshot.bytes;
+	return normalized;
+});
+const stampProviderResultEvent = (context, turnId, payload) => Effect.gen(function* () {
+	if (payload._tag === "ToolProgress") {
+		const text = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Json))(payload.result).pipe(Effect.mapError(() => toolProgressLimitError(context)));
+		yield* admitToolProgress(context, {
+			value: payload.result,
+			bytes: utf8ByteLength(text)
+		});
+	}
+	const base = yield* eventBase(context);
+	switch (payload._tag) {
+		case "ToolProgress": return ToolProgress.make({
+			...base,
+			turnId,
+			...payload
+		});
+		case "ToolCallSucceeded": return ToolCallSucceeded.make({
+			...base,
+			turnId,
+			...payload
+		});
+		case "ToolCallFailed": return ToolCallFailed.make({
+			...base,
+			turnId,
+			...payload,
+			failureHandling: "returned-to-model"
+		});
+	}
+});
+/**
+* RUN-026: deterministic estimate of the NEXT model call's live context.
+* Anchored on the last provider-reported call when the view has only grown
+* since then; a fresh Run or a just-compacted view falls back to the full
+* chars/4 estimate.
+*/
+const estimateContextTokens = Effect.fn("AgentRuntime.estimateContextTokens")(function* (messages, messageTokenEstimator) {
+	const compactor = yield* ContextCompactor;
+	const estimate = messageTokenEstimator === void 0 ? Option.some(compactor.estimate(messages)) : evaluateMessageTokenEstimates(messageTokenEstimator, (estimate) => estimatePromptTokens(messages, estimate));
+	if (Option.isNone(estimate)) return yield* CompactionError.make({ message: "Message token estimator returned an invalid token count" });
+	return yield* Schema.decodeEffect(Schema.Natural)(estimate.value).pipe(Effect.mapError((cause) => CompactionError.make({
+		message: "Compactor returned an invalid token estimate",
+		cause
+	})));
+});
+const nextContextEstimate = Effect.fn("AgentRuntime.nextContextEstimate")(function* (context, view) {
+	const state = context.compaction;
+	if (context.lastInputTokens > 0 && state.lastViewLength >= 0 && state.lastViewLength <= view.length) return context.lastInputTokens + context.lastOutputTokens + (yield* estimateContextTokens(view.slice(state.lastViewLength)));
+	return yield* estimateContextTokens(view);
+});
+const snapshotCompactionMessages = Effect.fnUntraced(function* (messages) {
+	return yield* Effect.try({
+		try: () => messages.map((message) => Schema.decodeUnknownSync(Schema.Json)(JSON.parse(JSON.stringify(Schema.encodeSync(Prompt.Message)(message))))),
+		catch: (cause) => CompactionError.make({
+			message: "Could not snapshot prepared compaction history",
+			cause
+		})
+	});
+});
+/** Text a provider overflow classification matches against (message + reason). */
+const overflowText = (error) => `${error.message} ${error.reason.message}`;
+/**
+* Consume the installed strategy under engine-owned bounds. Validate each decision, commit it,
+* then update the disposable view. Summary model calls retain the Run's response-buffer and
+* budget guards; default summaries also obey the captured Model's input allowance. Pricing
+* reads the selected Model's identity inside the same provision scope.
+*/
+const compactContext = (agent, context, source, turn, options, resolvedModelInputLimit, messageTokenEstimator, targetTokens, trigger, modelCallAllowed = true, requested) => Effect.gen(function* () {
+	const state = context.compaction;
+	const events = [];
+	const messages = source.content;
+	const allowance = context.compactionTurn;
+	const preparedSource = context.preparedCompactionSource;
+	const preparedSnapshot = preparedSource === void 0 ? void 0 : yield* snapshotCompactionMessages(messages);
+	if (preparedSource !== void 0 && preparedSnapshot !== void 0) {
+		let start = -1;
+		let end = 0;
+		let mapped = true;
+		const positions = [];
+		const originalPositions = preparedSource.protectedReferences.map((message) => messages.indexOf(message));
+		const originalMapping = preparedSource.protectedReferences.every((message, position) => {
+			const index = originalPositions[position];
+			return index !== void 0 && index >= 0 && index > (originalPositions[position - 1] ?? -1) && messages.lastIndexOf(message) === index && Equal.equals(preparedSnapshot[index], preparedSource.protectedMessages[position]);
+		});
+		for (let position = 0; !originalMapping && position < preparedSource.protectedMessages.length; position += 1) {
+			const protectedMessage = preparedSource.protectedMessages[position];
+			const index = preparedSnapshot.findIndex((message, index) => index >= end && Equal.equals(message, protectedMessage));
+			if (index < 0) {
+				mapped = false;
+				break;
+			}
+			if (start < 0) start = index;
+			end = index + 1;
+			positions.push(index);
+		}
+		let reverseEnd = preparedSnapshot.length;
+		for (let position = preparedSource.protectedMessages.length - 1; !originalMapping && mapped && position >= 0; position -= 1) {
+			const protectedMessage = preparedSource.protectedMessages[position];
+			const index = preparedSnapshot.findLastIndex((message, index) => index < reverseEnd && Equal.equals(message, protectedMessage));
+			if (index !== positions[position]) mapped = false;
+			reverseEnd = index;
+		}
+		if (originalMapping) {
+			mapped = true;
+			start = originalPositions[0] ?? -1;
+			end = (originalPositions.at(-1) ?? -1) + 1;
+		}
+		if (!mapped) return yield* CompactionError.make({ message: "Prepared context cannot map the protected instructions and input for compaction" });
+		state.protectedStart = mapped ? start : -1;
+		state.protectedEnd = mapped ? end : -1;
+		state.protectSystemMessages = true;
+	}
+	const resolvedRequest = requested === void 0 ? void 0 : {
+		...requested,
+		through: requested.through ?? Math.max(0, state.protectedStart)
+	};
+	if (requested !== void 0 && requested.through === void 0 && resolvedRequest !== void 0 && (resolvedRequest.through <= (state.replacement?.through ?? 0) || collectCoveredMessages(messages, state, resolvedRequest.through).length === 0)) return { events };
+	if (allowance.turn !== turn) {
+		allowance.turn = turn;
+		allowance.summaryCalls = 0;
+		allowance.applied.clear();
+	}
+	if (allowance.applied.has("summarize") || allowance.applied.has("rollover")) return yield* CompactionError.make({ message: "Compaction already replaced this Turn's context" });
+	const before = yield* estimateContextTokens(buildCompactedView(messages, state), messageTokenEstimator);
+	const summarize = (summarizerPrompt, model) => {
+		const generate = Effect.gen(function* () {
+			if (allowance.summaryCalls++ > 0 || !modelCallAllowed) return yield* CompactionError.make({ message: "Compaction exceeded its summary-call allowance" });
+			if (model === void 0 && resolvedModelInputLimit !== void 0 && (yield* estimateContextTokens(summarizerPrompt.content, messageTokenEstimator)) > resolvedModelInputLimit) return yield* CompactionError.make({ message: "Compaction summary request exceeds the resolved model input limit" });
+			const pieces = [];
+			const responseUsage = {
+				responsePartCount: 0,
+				responsePartBytes: 0
+			};
+			let summaryUsage;
+			let summaryResponse;
+			let summaryFinishMetadata;
+			let summaryFinished = false;
+			let summaryFailure;
+			const textParts = /* @__PURE__ */ new Map();
+			const reasoningParts = /* @__PURE__ */ new Map();
+			const summaryExit = yield* guardBudgetStream(LanguageModel.streamText({ prompt: summarizerPrompt }), options.budget).pipe(Stream.runForEach((part) => Effect.gen(function* () {
+				const owned = yield* ownModelResponsePart(part, Toolkit.empty, responseUsage, context.bufferLimits);
+				yield* consumeModelResponsePart(responseUsage, owned.retainedBytes, context.bufferLimits);
+				const ownedPart = owned.ownedPart;
+				if (ownedPart.type === "text-delta") pieces.push(ownedPart.delta);
+				else if (ownedPart.type === "finish") {
+					if (summaryUsage === void 0) {
+						summaryUsage = ownedPart.usage;
+						summaryFinishMetadata = ownedPart.metadata;
+					}
+				} else if (ownedPart.type === "response-metadata") summaryResponse = yield* responseIdentity(ownedPart, summaryResponse);
+				yield* Effect.gen(function* () {
+					if (summaryFinished) return yield* ModelProtocolError.make({ message: "Compaction response emitted content after its finish part" });
+					switch (ownedPart.type) {
+						case "text-start": return yield* startPart(textParts, ownedPart.id, "compaction text");
+						case "text-delta": return yield* continuePart(textParts, ownedPart.id, "compaction text delta");
+						case "text-end": return yield* endPart(textParts, ownedPart.id, "compaction text");
+						case "reasoning-start": return yield* startPart(reasoningParts, ownedPart.id, "compaction reasoning");
+						case "reasoning-delta": return yield* continuePart(reasoningParts, ownedPart.id, "compaction reasoning delta");
+						case "reasoning-end": return yield* endPart(reasoningParts, ownedPart.id, "compaction reasoning");
+						case "finish":
+							summaryFinished = true;
+							if (ownedPart.reason !== "stop" || [...textParts.values(), ...reasoningParts.values()].includes("open")) return yield* ModelProtocolError.make({ message: "Compaction response did not finish with complete text and a stop reason" });
+							return;
+						case "tool-params-start":
+						case "tool-params-delta":
+						case "tool-params-end":
+						case "tool-approval-request":
+						case "error": return yield* ModelProtocolError.make({ message: `Compaction response contained an unusable ${ownedPart.type} part` });
+						case "file":
+						case "response-metadata":
+						case "source": return;
+					}
+				}).pipe(Effect.catch((error) => Effect.sync(() => {
+					summaryFailure ??= error;
+				})));
+			})), Effect.exit);
+			if (summaryUsage === void 0) {
+				yield* noteIncompleteUsage(context, turn);
+				if (Exit.isFailure(summaryExit)) return yield* Effect.failCause(summaryExit.cause);
+				if (!summaryFinished) return yield* ModelProtocolError.make({ message: "Compaction response ended without a finish part" });
+			}
+			const wasFinalizing = context.finalizing;
+			const priorSummaryModelCalls = context.modelCalls;
+			context.finalizing = true;
+			const consumedExit = yield* consumeUsage(agent, context, summaryUsage, 0, turn, options, {
+				response: summaryResponse,
+				finishMetadata: summaryFinishMetadata,
+				purpose: "summary"
+			}).pipe(Effect.tapCause(() => summaryUsage !== void 0 && context.modelCalls === priorSummaryModelCalls ? noteIncompleteUsage(context, turn) : Effect.void), Effect.ensuring(Effect.sync(() => {
+				context.finalizing = wasFinalizing;
+			})), Effect.exit);
+			if (Exit.isFailure(summaryExit)) return yield* Effect.failCause(summaryExit.cause);
+			if (Exit.isFailure(consumedExit)) return yield* Effect.failCause(consumedExit.cause);
+			events.push(...consumedExit.value.warnings);
+			if (!summaryFinished) return yield* ModelProtocolError.make({ message: "Compaction response ended without a finish part" });
+			const summary = pieces.join("").trim();
+			if (summaryFailure !== void 0) return yield* summaryFailure;
+			if (summary.length === 0) return yield* ModelProtocolError.make({ message: "Compaction response requires non-whitespace text and a valid finish part" });
+			return summary;
+		});
+		return model === void 0 ? generate : Effect.provide(generate, model);
+	};
+	const applied = allowance.applied;
+	yield* (yield* ContextCompactor).compact({
+		source,
+		state: Object.freeze({
+			...state,
+			replacement: state.replacement === void 0 ? void 0 : Object.freeze({ ...state.replacement })
+		}),
+		policy: agent.definition.policy.compaction,
+		targetTokens,
+		threadId: context.threadId,
+		runId: context.runId,
+		turn,
+		trigger,
+		modelCallAllowed,
+		...messageTokenEstimator === void 0 ? {} : { estimateMessageTokens: messageTokenEstimator },
+		...resolvedRequest === void 0 ? {} : { requested: resolvedRequest },
+		summarize
+	}).pipe(Stream.runForEach((candidate) => Effect.gen(function* () {
+		const decision = yield* Schema.decodeEffect(CompactionDecision)(candidate).pipe(Effect.mapError((cause) => CompactionError.make({
+			message: "Invalid compaction decision",
+			cause
+		})));
+		if (applied.has(decision.kind) || applied.has("summarize") || applied.has("rollover")) return yield* CompactionError.make({ message: "Compaction exceeded its decision allowance" });
+		const next = {
+			...state,
+			lastViewLength: -1
+		};
+		if (resolvedRequest !== void 0 && (decision.kind !== "rollover" || decision.through !== resolvedRequest.through)) return yield* CompactionError.make({ message: "Requested rollover must cover exactly its selected source boundary" });
+		if (decision.kind === "rollover") {
+			if (decision.through <= (state.replacement?.through ?? 0) || decision.through > messages.length || messages[decision.through]?.role === "tool" || collectCoveredMessages(messages, state, decision.through).length === 0) return yield* CompactionError.make({ message: "Rollover must advance coverage without splitting Tool pairs or discarding protected input" });
+			next.replacement = {
+				kind: "rollover",
+				through: decision.through,
+				windowId: contextWindowId(context.runId, turn),
+				...decision.handoff === void 0 ? {} : { handoff: decision.handoff }
+			};
+		} else if (decision.kind === "summarize") {
+			if (utf8ByteLength(decision.summary) > context.bufferLimits.maxModelResponseBytes) return yield* CompactionError.make({ message: "Compaction summary exceeded the response-buffer limit" });
+			if (decision.through <= (state.replacement?.through ?? 0) || decision.through >= messages.length || messages[decision.through]?.role === "tool" || collectCoveredMessages(messages, state, decision.through).length === 0) return yield* CompactionError.make({ message: "Compaction must advance coverage without splitting Tool pairs or removing the recent tail" });
+			next.replacement = {
+				kind: "summarize",
+				through: decision.through,
+				summary: decision.summary
+			};
+		} else {
+			const newestTool = messages.findLastIndex((message) => message.role === "tool");
+			if (decision.through <= state.clearedThrough || decision.through > newestTool) return yield* CompactionError.make({ message: "Compaction must advance pruning while retaining the newest Tool result" });
+			next.clearedThrough = decision.through;
+		}
+		const after = yield* estimateContextTokens(buildCompactedView(messages, next), messageTokenEstimator);
+		if (decision.kind === "rollover" && trigger !== "requested" && after >= before) return yield* CompactionError.make({ message: "Automatic rollover did not reduce context" });
+		const commit = {
+			turn,
+			source,
+			through: decision.through,
+			kind: decision.kind,
+			...decision.kind === "summarize" ? { summary: decision.summary } : {},
+			...decision.kind === "rollover" && decision.handoff !== void 0 ? { handoff: decision.handoff } : {},
+			tokensBeforeEstimate: before,
+			tokensAfterEstimate: after
+		};
+		if (options.durability !== void 0) yield* options.durability.commitCompaction(commit);
+		Object.assign(state, next);
+		if (next.replacement?.kind === "rollover") context.windowId = next.replacement.windowId;
+		if (preparedSource !== void 0 && preparedSnapshot !== void 0) preparedSource.prefix = preparedSnapshot.slice(0, Math.max(next.clearedThrough, next.replacement?.through ?? 0));
+		applied.add(decision.kind);
+		events.push(CompactionPerformed.make({
+			...yield* eventBase(context),
+			turn,
+			kind: decision.kind,
+			tokensBeforeEstimate: before,
+			tokensAfterEstimate: after
+		}));
+	})));
+	if (requested !== void 0 && !applied.has("rollover")) return yield* CompactionError.make({ message: "Compaction strategy did not honor the requested rollover" });
+	return { events };
+});
+const decodeInput = Effect.fn("AgentRuntime.decodeInput")((agent, input) => Schema.decodeUnknownEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: cause.message }))));
+const evaluateInstructions = Effect.fn("AgentRuntime.evaluateInstructions")((instructions, input) => Effect.suspend(() => {
+	const result = typeof instructions === "function" ? instructions(input) : instructions;
+	return Effect.isEffect(result) ? result : Effect.succeed(result);
+}));
+const encodeInput = Effect.fn("AgentRuntime.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 = Effect.fn("AgentRuntime.renderInputPrompt")((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)}` })
+}) : Effect.suspend(() => {
+	const result = inputPrompt(decodedInput);
+	return Effect.isEffect(result) ? result : Effect.succeed(result);
+}));
+function renderInputPrompt(inputPrompt, decodedInput, encodedInput) {
+	return renderInputPromptEffect(inputPrompt, decodedInput, encodedInput);
+}
+const makeInitialPrompt = Effect.fn("AgentRuntime.makeInitialPrompt")((instructions, inputPrompt, history) => Effect.try({
+	try: () => {
+		const instructionPrompt = typeof instructions === "string" ? Prompt.fromMessages([Prompt.makeMessage("system", { content: instructions })]) : Prompt.make(instructions);
+		return Prompt.fromMessages([
+			...history.content,
+			...instructionPrompt.content,
+			...Prompt.make(inputPrompt).content
+		]);
+	},
+	catch: (cause) => AgentInputError.make({ message: `Unable to materialize Agent input: ${errorMessage(cause)}` })
+}));
+const decodeToolCallId = Effect.fn((id) => Schema.decodeEffect(ToolCallId)(id).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: `Invalid Tool Call ID: ${cause.message}` }))));
+const decodeProviderToolCallId = Effect.fn((id) => Schema.decodeEffect(ProviderToolCallId)(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 = Effect.fn((id) => Schema.decodeEffect(ProviderResponsePartId)(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) {
+	switch (part.type) {
+		case "text-start":
+		case "text-delta":
+		case "text-end":
+		case "reasoning-start":
+		case "reasoning-delta":
+		case "reasoning-end":
+		case "source":
+			yield* decodeProviderResponsePartId(part.id);
+			return;
+		case "response-metadata":
+			if (part.id !== void 0) yield* decodeProviderResponsePartId(part.id);
+			return;
+		case "tool-params-start":
+		case "tool-params-delta":
+		case "tool-params-end":
+		case "tool-call":
+		case "tool-result":
+			yield* decodeProviderToolCallId(part.id);
+			return;
+		case "tool-approval-request":
+			yield* decodeProviderResponsePartId(part.approvalId);
+			yield* decodeProviderToolCallId(part.toolCallId);
+			return;
+		case "error":
+		case "file":
+		case "finish":
+		case "reasoning":
+		case "text": return;
+	}
+});
+const responseIdentity = (part, previous) => Schema.decodeEffect(ModelResponseIdentity)({
+	...previous,
+	...part.id === void 0 ? {} : { id: part.id },
+	...part.modelId === void 0 ? {} : { model: part.modelId }
+}).pipe(Effect.mapError(() => ModelProtocolError.make({ message: "Invalid provider response identity" })), Effect.filterOrFail(() => !(previous?.id !== void 0 && part.id !== void 0 && previous.id !== part.id || previous?.model !== void 0 && part.modelId !== void 0 && previous.model !== part.modelId), () => ModelProtocolError.make({ message: "Provider response identity changed within one call" })));
+const decodeEventJson = Effect.fn("AgentRuntime.decodeEventJson")((value, label) => Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((cause) => ModelProtocolError.make({ message: `${label} is not JSON: ${cause.message}` }))));
+/**
+* Preserves provider-executed results as assistant content while application
+* handler results remain Tool messages for the next model request.
+*/
+const promptFromTurnParts = (trace) => {
+	if (trace.replayedResponse !== void 0) return trace.replayedResponse;
+	const responsePrompt = Prompt.fromResponseParts(trace.parts.filter((part) => !(part.type === "tool-result" && part.providerExecuted)));
+	const providerResults = trace.parts.flatMap((part) => part.type === "tool-result" && part.providerExecuted && !part.preliminary ? [Prompt.makePart("tool-result", {
+		id: part.id,
+		name: part.name,
+		isFailure: part.isFailure,
+		result: part.encodedResult,
+		providerExecuted: true
+	})] : []);
+	if (providerResults.length === 0) return responsePrompt;
+	const messages = [];
+	let attachedProviderResults = false;
+	for (const message of responsePrompt.content) {
+		if (message.role === "assistant") {
+			messages.push(Prompt.makeMessage("assistant", {
+				content: [...message.content, ...providerResults],
+				options: message.options
+			}));
+			attachedProviderResults = true;
+			continue;
+		}
+		if (message.role === "tool") continue;
+		messages.push(message);
+	}
+	if (!attachedProviderResults) messages.push(Prompt.makeMessage("assistant", { content: providerResults }));
+	return Prompt.fromMessages(messages);
+};
+const eventsForPart = Effect.fnUntraced(function* (context, turnId, turn, tools, trace, part, retainedBytes) {
+	yield* consumeModelResponsePart(trace, retainedBytes, context.bufferLimits);
+	if (part.type === "finish" && trace.usage === void 0) {
+		trace.usage = part.usage;
+		trace.finishMetadata = part.metadata;
+	}
+	if (trace.finished) return yield* ModelProtocolError.make({ message: "Model response emitted content after its finish part" });
+	yield* validateProviderPartIdentifiers(part);
+	if (part.type === "response-metadata") trace.response = yield* responseIdentity(part, trace.response);
+	if (part.type !== "tool-call" && part.type !== "tool-result") trace.parts.push(part);
+	switch (part.type) {
+		case "text-start":
+			yield* startPart(trace.textParts, part.id, "text");
+			return [];
+		case "text-delta":
+			yield* continuePart(trace.textParts, part.id, "text delta");
+			trace.text.push(part.delta);
+			return [TextDelta.make({
+				...yield* eventBase(context),
+				turnId,
+				text: part.delta
+			})];
+		case "text-end":
+			yield* endPart(trace.textParts, part.id, "text");
+			return [];
+		case "reasoning-start":
+			yield* startPart(trace.reasoningParts, part.id, "reasoning");
+			return [];
+		case "reasoning-delta":
+			yield* continuePart(trace.reasoningParts, part.id, "reasoning delta");
+			return [ReasoningDelta.make({
+				...yield* eventBase(context),
+				turnId,
+				text: part.delta
+			})];
+		case "reasoning-end":
+			yield* endPart(trace.reasoningParts, part.id, "reasoning");
+			return [];
+		case "tool-params-start":
+			if (trace.toolParameterParts.has(part.id)) return yield* ModelProtocolError.make({ message: `Model response repeated Tool parameter start for ${part.id}` });
+			trace.toolParameterParts.set(part.id, {
+				name: part.name,
+				providerExecuted: part.providerExecuted,
+				state: "open"
+			});
+			return [];
+		case "tool-params-delta":
+			if (trace.toolParameterParts.get(part.id)?.state !== "open") return yield* ModelProtocolError.make({ message: `Model response emitted Tool parameter delta for inactive part ${part.id}` });
+			return [];
+		case "tool-params-end": {
+			const parameterPart = trace.toolParameterParts.get(part.id);
+			if (parameterPart?.state !== "open") return yield* ModelProtocolError.make({ message: `Model response emitted Tool parameter end for inactive part ${part.id}` });
+			parameterPart.state = "closed";
+			return [];
+		}
+		case "tool-call": {
+			if (!hasTool(tools, part.name)) return yield* ModelProtocolError.make({ message: `Model requested unknown Tool ${part.name}` });
+			if (trace.toolCalls.has(part.id)) return yield* ModelProtocolError.make({ message: `Model response repeated Tool Call ID ${part.id}` });
+			const parameterPart = trace.toolParameterParts.get(part.id);
+			if (parameterPart?.state === "open") return yield* ModelProtocolError.make({ message: `Model response declared Tool Call ${part.id} before its parameters completed` });
+			if (parameterPart !== void 0 && (parameterPart.name !== part.name || parameterPart.providerExecuted !== part.providerExecuted)) return yield* ModelProtocolError.make({ message: `Completed Tool parameters did not match Tool Call ${part.id}` });
+			const toolCallId = yield* decodeToolCallId(part.id);
+			const tool = tools[part.name];
+			const decodedParameters = yield* decodeToolCallParameters(tool, part.name, part.params);
+			const encodedParameters = yield* encodeToolCallParameters(tool, part.name, decodedParameters);
+			const parameters = yield* decodeEventJson(encodedParameters, "Tool parameters");
+			const canonicalCall = Response.makePart("tool-call", {
+				id: part.id,
+				name: part.name,
+				params: parameters,
+				providerExecuted: part.providerExecuted,
+				metadata: part.metadata
+			});
+			trace.parts.push(canonicalCall);
+			trace.toolCalls.set(part.id, {
+				name: part.name,
+				providerExecuted: part.providerExecuted
+			});
+			if (!part.providerExecuted) {
+				trace.applicationToolCalls.push(canonicalCall);
+				trace.applicationCallDescriptors.push({
+					toolCallId,
+					toolName: part.name,
+					parameters,
+					executionClass: getToolExecutionClass(tool),
+					executionKind: getToolExecutionKind(tool.annotations)
+				});
+			}
+			return [ToolCallDeclared.make({
+				...yield* eventBase(context),
+				turnId,
+				toolCallId,
+				toolName: part.name,
+				parameters,
+				providerExecuted: part.providerExecuted
+			})];
+		}
+		case "tool-result": {
+			const declaredCall = trace.toolCalls.get(part.id);
+			if (declaredCall === void 0) return yield* ModelProtocolError.make({ message: `Model response returned an unrequested Tool result ${part.id}` });
+			if (declaredCall.name !== part.name) return yield* ModelProtocolError.make({ message: `Tool result name did not match Tool Call ${part.id}: expected ${declaredCall.name}, received ${part.name}` });
+			if (declaredCall.providerExecuted !== part.providerExecuted) return yield* ModelProtocolError.make({ message: `Tool result execution boundary did not match Tool Call ${part.id}` });
+			if (!part.providerExecuted) return yield* ModelProtocolError.make({ message: `Model response included an application Tool result before engine execution for ${part.id}` });
+			const toolCallId = yield* decodeToolCallId(part.id);
+			const normalized = yield* snapshotProviderToolResultPart(trace, part);
+			const result = normalized.result;
+			if (part.preliminary === true) {
+				yield* stageProviderResultPayload(trace, {
+					_tag: "ToolProgress",
+					toolCallId,
+					toolName: part.name,
+					result,
+					providerExecuted: true
+				});
+				trace.parts.push(Response.toolResultPart({
+					id: part.id,
+					name: part.name,
+					isFailure: part.isFailure,
+					result,
+					encodedResult: result,
+					providerExecuted: true,
+					preliminary: true,
+					metadata: normalized.metadata
+				}));
+				return [];
+			}
+			if (trace.finalToolResultIds.has(part.id)) return yield* ModelProtocolError.make({ message: `Tool Call ${part.id} produced more than one terminal result` });
+			if (part.isFailure) yield* stageProviderResultPayload(trace, {
+				_tag: "ToolCallFailed",
+				toolCallId,
+				toolName: part.name,
+				errorTag: errorTag(result),
+				message: errorMessage(result),
+				providerExecuted: true
+			});
+			else yield* stageProviderResultPayload(trace, {
+				_tag: "ToolCallSucceeded",
+				toolCallId,
+				toolName: part.name,
+				result,
+				providerExecuted: true
+			});
+			trace.finalToolResultIds.add(part.id);
+			trace.parts.push(Response.toolResultPart({
+				id: part.id,
+				name: part.name,
+				isFailure: part.isFailure,
+				result,
+				encodedResult: result,
+				providerExecuted: true,
+				preliminary: false,
+				metadata: normalized.metadata
+			}));
+			return [];
+		}
+		case "finish": {
+			const openPart = firstOpenPart(trace);
+			if (openPart !== void 0) return yield* ModelProtocolError.make({ message: `Model response finished before completing ${openPart}` });
+			trace.finished = true;
+			trace.finishReason = part.reason;
+			trace.usage = part.usage;
+			if (Array.from(trace.toolCalls.values()).some(({ providerExecuted }) => providerExecuted)) {
+				const turnCompletion = { finishReason: part.reason };
+				const snapshot = yield* snapshotStagedProviderEvent(trace, {
+					_tag: "TurnCompleted",
+					...turnCompletion
+				});
+				trace.turnCompletion = turnCompletion;
+				trace.providerStagedPayloadBytes += snapshot.bytes;
+				return [];
+			}
+			return [TurnCompleted.make({
+				...yield* eventBase(context),
+				turnId,
+				turn,
+				finishReason: part.reason
+			})];
+		}
+		case "error": return yield* ModelProtocolError.make({ message: `Model response failed: ${errorMessage(part.error)}` });
+		case "file":
+		case "reasoning":
+		case "response-metadata":
+		case "source":
+		case "text":
+		case "tool-approval-request": return [];
+	}
+});
+const decodeFinalOutput = Effect.fn("AgentRuntime.decodeFinalOutput")(function* (agent, text) {
+	const eventJson = isTextOutput(agent.definition.output) ? text : yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Json))(text).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Agent output is not valid JSON: ${cause.message}` })));
+	const candidateOutput = eventJson;
+	return {
+		encoded: eventJson,
+		decoded: yield* Schema.decodeUnknownEffect(agent.definition.output)(candidateOutput).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: cause.message })))
+	};
+});
+const encodeOutputCandidate = Effect.fn("AgentRuntime.encodeOutputCandidate")(function* (agent, candidate) {
+	const encoded = yield* Schema.encodeUnknownEffect(agent.definition.output)(candidate).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Completion Tool output failed Schema encoding: ${cause.message}` })));
+	const decoded = yield* Schema.decodeUnknownEffect(agent.definition.output)(encoded).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Completion Tool output failed canonical decoding: ${cause.message}` })));
+	return {
+		encoded: yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Completion Tool output did not encode as durable JSON: ${cause.message}` }))),
+		decoded
+	};
+});
+const projectToolResult = Effect.fn("AgentRuntime.projectToolResult")(function* (agent, declaration, parameters, result) {
+	const tool = agent.definition.toolkit.tools[declaration.tool];
+	if (tool === void 0) return yield* ModelProtocolError.make({ message: `Agent completion declaration references unknown Tool ${declaration.tool}` });
+	const decodedParameters = yield* Schema.decodeUnknownEffect(tool.parametersSchema)(parameters).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Completion Tool parameters failed canonical decoding: ${cause.message}` })));
+	const decodedResult = yield* Schema.decodeUnknownEffect(tool.successSchema)(result).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: `Completion Tool result failed canonical decoding: ${cause.message}` })));
+	return yield* Effect.try({
+		try: () => declaration.project({
+			parameters: decodedParameters,
+			result: decodedResult
+		}),
+		catch: (cause) => AgentOutputError.make({ message: `Completion Tool projector failed: ${cause instanceof Error ? cause.message : String(cause)}` })
+	});
+});
+const projectCompletionOutput = Effect.fn("AgentRuntime.projectCompletionOutput")(function* (agent, declaration, parameters, result) {
+	return yield* encodeOutputCandidate(agent, yield* projectToolResult(agent, declaration, parameters, result));
+});
+/** Reconstruct optional action completion identically for live execution and canonical recovery. */
+const projectCompletionFromToolOutput = Effect.fn("AgentRuntime.projectCompletionFromToolOutput")(function* (agent, declaration, parameters, result) {
+	const projected = yield* projectToolResult(agent, declaration, parameters, result);
+	if (!Option.isOption(projected)) return yield* AgentOutputError.make({ message: "Action completion projector did not return an Option" });
+	if (Option.isNone(projected)) return Option.none();
+	return Option.some(yield* encodeOutputCandidate(agent, projected.value));
+});
+const encodeRunDispositionCandidate = Effect.fn("AgentRuntime.encodeRunDisposition")(function* (declaration, output) {
+	const selected = yield* Effect.try({
+		try: () => declaration.fromOutput(output),
+		catch: (cause) => AgentRunDispositionError.make({
+			cause,
+			message: "Run disposition selector failed"
+		})
+	});
+	if (selected === void 0) return void 0;
+	const encoded = yield* Schema.encodeUnknownEffect(declaration.schema)(selected).pipe(Effect.mapError((cause) => AgentRunDispositionError.make({
+		cause,
+		message: "Run disposition failed Schema encoding"
+	})));
+	return yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError((cause) => AgentRunDispositionError.make({
+		cause,
+		message: "Run disposition did not encode as durable JSON"
+	})));
+});
+function encodeRunDisposition(agent, output) {
+	const declaration = agent.definition.runDisposition;
+	return declaration === void 0 ? Effect.void : encodeRunDispositionCandidate(declaration, output);
+}
+const decodeRunDispositionCandidate = Effect.fn("AgentRuntime.decodeRunDisposition")(function* (declaration, encoded) {
+	return yield* Schema.decodeEffect(declaration.schema)(encoded).pipe(Effect.mapError((cause) => AgentRunDispositionError.make({
+		cause,
+		message: cause.message
+	})));
+});
+function decodeRunDisposition(agent, encoded) {
+	const declaration = agent.definition.runDisposition;
+	return declaration === void 0 ? Effect.fail(ModelProtocolError.make({ message: "RunCompleted declared a run disposition without a definition-owned Schema" })) : decodeRunDispositionCandidate(declaration, encoded);
+}
+const nextTurn = (prompt, turn, toolCalls) => Stream.succeed({
+	_tag: "NextTurn",
+	prompt,
+	turn,
+	toolCalls
+});
+const makeTurn = (agent, context, prompt, turn, priorToolCalls, options) => Stream.unwrap(Effect.gen(function* () {
+	const policy = agent.definition.policy;
+	const bounds = effectiveRunBounds(policy, options);
+	if (options.beforeTurn !== void 0) yield* options.beforeTurn();
+	if ((yield* Clock.currentTimeMillis) >= context.durationDeadlineMillis) return failRunEventStream(durationLimitError(agent.definition.policy));
+	if (policy.onExhaustion === "fail" && turn > bounds.maxTurns) return failRunEventStream(AgentPolicyError.make({
+		limit: "turns",
+		message: `Agent exceeded its ${bounds.maxTurns} Turn limit`
+	}));
+	if (context.finalizationUsed) return failRunEventStream(AgentPolicyError.make({
+		limit: turn > bounds.maxTurns ? "turns" : priorToolCalls + context.programmaticToolCalls > bounds.maxToolCalls ? "tool-calls" : "tokens",
+		message: "Agent already used its one grace finalization"
+	}));
+	const turnId = yield* (yield* IdGenerator$1).nextTurnId;
+	const outputContract = outputSchemaContract(agent.definition);
+	const outputContractMessage = outputContract._tag === "rendered" ? outputContract.message : void 0;
+	const contextRequest = {
+		threadId: context.threadId,
+		runId: context.runId,
+		turnId,
+		turn,
+		source: prompt,
+		...outputContractMessage === void 0 ? {} : { outputContract: outputContractMessage }
+	};
+	const modelContext = options.context === void 0 ? { prompt } : yield* options.context.prepare(contextRequest);
+	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",
+		cause
+	})));
+	const contextTokenLimit = callContext === void 0 ? policy.contextTokenLimit : Math.max(0, Math.min(policy.contextTokenLimit ?? Infinity, callContext.maxInputTokens ?? Infinity, callContext.contextCapacity - callContext.outputReserveTokens) - callContext.uncountedOverheadTokens);
+	context.windowContextTokenLimit = contextTokenLimit;
+	const toolSchemaTransformer = modelContext.modelCall?.toolSchemaTransformer;
+	const messageTokenEstimator = modelContext.modelCall?.estimateMessageTokens;
+	const visibility = yield* RunToolVisibility;
+	const catalog = yield* eligibleCatalog(agent.definition, {
+		threadId: context.threadId,
+		runId: context.runId,
+		turn,
+		input: context.input
+	}, options.subagentGrant, options.delegationDepth ?? options.parentLink?.depth ?? 0);
+	if (modelContext.toolSelection !== void 0) context.toolSelection = yield* validateSelection(modelContext.toolSelection, agent.definition, catalog);
+	let snapshot = agent.definition.toolExposure === void 0 && context.toolSelection === void 0 && visibility === void 0 ? void 0 : yield* exposureSnapshot(agent.definition, context.toolSelection, catalog, toolSchemaTransformer);
+	const selectionSnapshot = snapshot;
+	context.toolSchemaTransformer = toolSchemaTransformer;
+	context.toolCatalog = catalog;
+	context.toolExposure = snapshot;
+	const modelToolkit = Toolkit.make(...snapshot === void 0 ? catalog.filter((entry) => entry.kind === "native").map((entry) => entry.tool) : catalog.filter((entry) => entry.kind === "native" && snapshot?.exposedToolNames.includes(entry.nativeToolName)).map((entry) => entry.tool));
+	if (options.durability !== void 0 && snapshot !== void 0) {
+		if (options.durability.noteToolExposure === void 0 && context.toolSelection !== void 0) return yield* ModelProtocolError.make({ message: "Durable Tool exposure requires a request snapshot staging hook" });
+	}
+	const estimateCallTokens = (messages) => estimateContextTokens(messages, messageTokenEstimator);
+	const modelServices = modelContext.modelCall === void 0 ? void 0 : yield* Layer.build(Layer.fresh(modelContext.modelCall.model));
+	const withCallModel = (operation) => modelServices === void 0 ? operation : Effect.provide(operation, modelServices);
+	const priorCompactionPrefix = context.preparedCompactionSource?.prefix;
+	if (priorCompactionPrefix !== void 0 && priorCompactionPrefix.length > 0) {
+		const preparedPrefix = yield* snapshotCompactionMessages(modelContext.prompt.content.slice(0, priorCompactionPrefix.length));
+		if (!Equal.equals(preparedPrefix, priorCompactionPrefix)) return yield* CompactionError.make({ message: "Prepared context changed a prefix already covered by compaction" });
+	}
+	const trace = {
+		responsePartCount: 0,
+		responsePartBytes: 0,
+		parts: [],
+		text: [],
+		textParts: /* @__PURE__ */ new Map(),
+		reasoningParts: /* @__PURE__ */ new Map(),
+		toolParameterParts: /* @__PURE__ */ new Map(),
+		toolCalls: /* @__PURE__ */ new Map(),
+		finalToolResultIds: /* @__PURE__ */ new Set(),
+		providerResultPayloads: [],
+		providerStagedPayloadBytes: 0,
+		turnCompletion: void 0,
+		applicationToolCalls: [],
+		applicationCallDescriptors: [],
+		applicationToolResults: [],
+		finished: false,
+		finishReason: void 0,
+		usage: void 0
+	};
+	const started = Stream.fromEffect(Effect.gen(function* () {
+		yield* Metric.update(modelCounter, 1);
+		yield* Effect.logDebug("agent model call started").pipe(Effect.annotateLogs({
+			agentId: context.agentId,
+			runId: context.runId,
+			turnId
+		}));
+		return [TurnStarted.make({
+			...yield* eventBase(context),
+			turnId,
+			turn
+		}), ModelStarted.make({
+			...yield* eventBase(context),
+			turnId,
+			turn
+		})];
+	}).pipe(Effect.withLogSpan("AgentRuntime.model"))).pipe(Stream.flatMap(Stream.fromIterable));
+	let finalAnswerOnly = policy.onExhaustion !== "fail" && (turn > bounds.maxTurns || priorToolCalls + context.programmaticToolCalls > bounds.maxToolCalls || context.tokenExhausted);
+	const modelToolChoice = () => {
+		return finalAnswerOnly || agent.definition.completion?.required === true && policy.onExhaustion === "fail" && turn === bounds.maxTurns ? agent.definition.completion === void 0 || agent.definition.completion.required !== true && !catalog.some((entry) => entry.kind === "native" && entry.nativeToolName === agent.definition.completion?.tool) ? "none" : agent.definition.completion.required === true ? { tool: agent.definition.completion.tool } : {
+			mode: "auto",
+			oneOf: [agent.definition.completion.tool]
+		} : agent.definition.completion?.required === true ? "required" : void 0;
+	};
+	if (finalAnswerOnly && context.exhaustedDimension === void 0) context.exhaustedDimension = turn > bounds.maxTurns ? "turns" : priorToolCalls + context.programmaticToolCalls > bounds.maxToolCalls ? "tool-calls" : "tokens";
+	if (outputContract._tag === "unrenderable" && turn === 1) yield* Effect.logWarning("Agent output schema cannot render to JSON Schema; the model-visible final output contract is omitted").pipe(Effect.annotateLogs({
+		agentId: context.agentId,
+		runId: context.runId,
+		reason: outputContract.reason
+	}));
+	const admissionRequired = contextTokenLimit !== void 0 || !context.finalizing && !finalAnswerOnly && policy.tokenBudget !== void 0;
+	const outputContractTokens = !admissionRequired || outputContractMessage === void 0 ? 0 : yield* estimateCallTokens([Prompt.makeMessage("system", { content: outputContractMessage })]);
+	const canonicalDecoration = !admissionRequired ? Prompt.empty : yield* outgoingModelPrompt(policy, context, Prompt.empty, turn, priorToolCalls);
+	const estimateToolSchemaTokens = Effect.suspend(() => {
+		const choice = modelToolChoice();
+		const tools = typeof choice === "object" && "oneOf" in choice ? catalog.filter((entry) => entry.kind === "native" && choice.oneOf.includes(entry.nativeToolName)).map((entry) => entry.tool) : Object.values(modelToolkit.tools);
+		return callContext === void 0 || tools.length === 0 ? Effect.succeed(0) : Effect.try({
+			try: () => JSON.stringify(tools.map((tool) => Tool.isProviderDefined(tool) ? {
+				type: tool.providerName,
+				args: tool.args
+			} : {
+				name: tool.name,
+				description: Tool.getDescription(tool),
+				parameters: Tool.getJsonSchema(tool, { transformer: toolSchemaTransformer })
+			})),
+			catch: (cause) => CompactionError.make({
+				message: "Could not estimate native Tool schemas",
+				cause
+			})
+		}).pipe(Effect.flatMap((content) => estimateCallTokens([Prompt.makeMessage("system", { content })])));
+	});
+	let toolSchemaTokens = yield* estimateToolSchemaTokens;
+	const canonicalDecorationPromptTokens = !admissionRequired ? 0 : outputContractTokens + (yield* estimateCallTokens(canonicalDecoration.content));
+	const canonicalDecorationTokens = () => toolSchemaTokens + canonicalDecorationPromptTokens;
+	const estimateSourceContext = (view) => options.context === void 0 && options.transientContext === void 0 ? nextContextEstimate(context, view) : estimateCallTokens(view);
+	let prepared = buildCompactedView(modelContext.prompt.content, context.compaction);
+	let sourceTokens;
+	const preparedSourceTokens = Effect.suspend(() => sourceTokens === void 0 ? estimateSourceContext(prepared).pipe(Effect.tap((tokens) => Effect.sync(() => {
+		sourceTokens = tokens;
+	}))) : Effect.succeed(sourceTokens));
+	const refreshPrepared = () => {
+		prepared = buildCompactedView(modelContext.prompt.content, context.compaction);
+		sourceTokens = void 0;
+	};
+	let preEvents = [];
+	if (modelContext.rollover !== void 0) {
+		if (context.pendingContextToolCallId !== void 0) return yield* CompactionError.make({ message: "Host and Tool rollover requests cannot share a Turn" });
+		const requested = yield* Schema.decodeEffect(ContextRolloverSelection)(modelContext.rollover).pipe(Effect.mapError((cause) => CompactionError.make({
+			message: "Invalid host context rollover",
+			cause
+		})));
+		const outcome = yield* compactContext(agent, context, modelContext.prompt, turn, options, callContext === void 0 ? void 0 : contextTokenLimit, messageTokenEstimator, contextTokenLimit === void 0 ? void 0 : Math.max(0, contextTokenLimit - canonicalDecorationTokens()), "requested", false, requested).pipe(withCallModel);
+		if (outcome.events.some((event) => event._tag === "CompactionPerformed")) context.compaction.lastCompactionTurn = turn;
+		preEvents = outcome.events;
+		refreshPrepared();
+	}
+	const lastToolIndex = context.pendingContextToolCallId === void 0 ? -1 : modelContext.prompt.content.findLastIndex((message) => message.role === "tool" && message.content.some((part) => part.type === "tool-result" && part.id === context.pendingContextToolCallId));
+	if (context.pendingContextToolCallId !== void 0 && lastToolIndex < 0) return yield* CompactionError.make({ message: "Prepared context omitted the pending context Tool result" });
+	const lastTool = modelContext.prompt.content[lastToolIndex];
+	if (context.pendingContextToolCallId !== void 0 && (lastTool?.role !== "tool" || lastTool.content.length !== 1)) return yield* CompactionError.make({ message: "Prepared context changed the pending context Tool batch" });
+	if (lastTool?.role === "tool" && lastTool.content.length === 1) {
+		const result = lastTool.content[0];
+		if (result?.type === "tool-result" && !result.isFailure && result.providerExecuted !== true && result.id === context.pendingContextToolCallId && hasTool(agent.definition.toolkit.tools, result.name) && Context.get(agent.definition.toolkit.tools[result.name].annotations, ContextRolloverTool)) {
+			const request = yield* Schema.decodeUnknownEffect(ContextRolloverRequest, { onExcessProperty: "error" })(result.result).pipe(Effect.mapError((cause) => CompactionError.make({
+				message: "Invalid context rollover Tool result",
+				cause
+			})));
+			const outcome = yield* compactContext(agent, context, modelContext.prompt, turn, options, callContext === void 0 ? void 0 : contextTokenLimit, messageTokenEstimator, contextTokenLimit === void 0 ? void 0 : Math.max(0, contextTokenLimit - canonicalDecorationTokens()), "requested", false, {
+				...request,
+				through: lastToolIndex + 1
+			}).pipe(withCallModel);
+			context.compaction.lastCompactionTurn = turn;
+			preEvents = outcome.events;
+			refreshPrepared();
+		}
+	}
+	context.pendingContextToolCallId = void 0;
+	if (!context.finalizing && admissionRequired) {
+		const consumedTokens = context.inputTokens + context.outputTokens;
+		const tokenCallTarget = policy.tokenBudget === void 0 || finalAnswerOnly ? void 0 : Math.max(0, policy.tokenBudget - consumedTokens - policy.completionReserveTokens);
+		const contextCallTarget = contextTokenLimit;
+		const fullTarget = tokenCallTarget === void 0 ? contextCallTarget : contextCallTarget === void 0 ? tokenCallTarget : Math.min(tokenCallTarget, contextCallTarget);
+		const sourceTarget = fullTarget === void 0 ? void 0 : Math.max(0, fullTarget - canonicalDecorationTokens());
+		const estimate = (yield* preparedSourceTokens) + canonicalDecorationTokens();
+		const contextPressure = contextCallTarget !== void 0 && estimate > contextCallTarget;
+		const tokenPressure = tokenCallTarget !== void 0 && estimate > tokenCallTarget;
+		if ((contextPressure || tokenPressure) && sourceTarget !== void 0 && sourceTarget > 0 && context.compaction.lastCompactionTurn !== turn) {
+			context.compaction.lastCompactionTurn = turn;
+			const outcome = yield* compactContext(agent, context, modelContext.prompt, turn, options, callContext === void 0 ? void 0 : contextTokenLimit, messageTokenEstimator, sourceTarget, "pressure", !tokenPressure).pipe(withCallModel);
+			preEvents = [...preEvents, ...outcome.events];
+			if (outcome.events.some((event) => event._tag === "CompactionPerformed")) refreshPrepared();
+		}
+		if (context.tokenExhausted) {
+			finalAnswerOnly = true;
+			toolSchemaTokens = yield* estimateToolSchemaTokens;
+		}
+		const preparedTokenCallTarget = policy.tokenBudget === void 0 || finalAnswerOnly ? void 0 : Math.max(0, policy.tokenBudget - (context.inputTokens + context.outputTokens) - policy.completionReserveTokens);
+		let preparedEstimate = (yield* preparedSourceTokens) + canonicalDecorationTokens();
+		if ((callContext !== void 0 || contextCallTarget === void 0 || preparedEstimate <= contextCallTarget) && preparedTokenCallTarget !== void 0 && preparedEstimate > preparedTokenCallTarget) {
+			const error = AgentPolicyError.make({
+				limit: "tokens",
+				message: `The next research call would consume this Run's ${policy.completionReserveTokens} token completion reserve`
+			});
+			if (policy.onExhaustion === "fail") return yield* error;
+			context.tokenExhausted = true;
+			context.exhaustedDimension ??= "tokens";
+			finalAnswerOnly = true;
+			toolSchemaTokens = yield* estimateToolSchemaTokens;
+			preparedEstimate = (yield* preparedSourceTokens) + canonicalDecorationTokens();
+		}
+		if (contextCallTarget !== void 0 && preparedEstimate > contextCallTarget) return yield* ContextBudgetError.make({
+			message: `Compaction could not fit the next model prompt inside the ${contextCallTarget} token context target`,
+			estimatedTokens: preparedEstimate,
+			targetTokens: contextCallTarget,
+			completionReserveTokens: policy.completionReserveTokens
+		});
+	}
+	const transientContext = options.transientContext === void 0 ? Prompt.empty : yield* options.transientContext.load(contextRequest).pipe(Effect.flatMap(transientInputToPrompt));
+	const derivedPrompt = options.transientContext === void 0 ? canonicalDecoration : yield* outgoingModelPrompt(policy, context, transientContext, turn, priorToolCalls);
+	const derivedPromptContentTokens = !admissionRequired ? 0 : options.transientContext === void 0 ? canonicalDecorationPromptTokens : outputContractTokens + (yield* estimateCallTokens(derivedPrompt.content));
+	const derivedPromptTokens = () => toolSchemaTokens + derivedPromptContentTokens;
+	if (!context.finalizing && admissionRequired && options.transientContext !== void 0) {
+		const tokenCallTarget = policy.tokenBudget === void 0 || finalAnswerOnly ? void 0 : Math.max(0, policy.tokenBudget - (context.inputTokens + context.outputTokens) - policy.completionReserveTokens);
+		const fullTarget = tokenCallTarget === void 0 ? contextTokenLimit : contextTokenLimit === void 0 ? tokenCallTarget : Math.min(tokenCallTarget, contextTokenLimit);
+		const sourceTarget = fullTarget === void 0 ? void 0 : Math.max(0, fullTarget - derivedPromptTokens());
+		let preparedEstimate = (yield* preparedSourceTokens) + derivedPromptTokens();
+		const contextPressure = contextTokenLimit !== void 0 && preparedEstimate > contextTokenLimit;
+		const tokenPressure = tokenCallTarget !== void 0 && preparedEstimate > tokenCallTarget;
+		const currentCompactionAllowance = context.compactionTurn.turn === turn;
+		const summarizedThisTurn = currentCompactionAllowance && (context.compactionTurn.applied.has("summarize") || context.compactionTurn.applied.has("rollover"));
+		const prunedThisTurn = currentCompactionAllowance && context.compactionTurn.applied.has("clear-tool-results");
+		const canCompact = !summarizedThisTurn && (!prunedThisTurn || !tokenPressure && policy.compaction.mode !== "prune");
+		if ((contextPressure || tokenPressure) && sourceTarget !== void 0 && sourceTarget > 0 && canCompact) {
+			context.compaction.lastCompactionTurn = turn;
+			const outcome = yield* compactContext(agent, context, modelContext.prompt, turn, options, callContext === void 0 ? void 0 : contextTokenLimit, messageTokenEstimator, sourceTarget, "pressure", !tokenPressure).pipe(withCallModel);
+			preEvents = [...preEvents, ...outcome.events];
+			if (outcome.events.some((event) => event._tag === "CompactionPerformed")) refreshPrepared();
+			preparedEstimate = (yield* preparedSourceTokens) + derivedPromptTokens();
+		}
+		if (context.tokenExhausted) {
+			finalAnswerOnly = true;
+			toolSchemaTokens = yield* estimateToolSchemaTokens;
+		}
+		const preparedTokenCallTarget = policy.tokenBudget === void 0 || finalAnswerOnly ? void 0 : Math.max(0, policy.tokenBudget - (context.inputTokens + context.outputTokens) - policy.completionReserveTokens);
+		if ((callContext !== void 0 || contextTokenLimit === void 0 || preparedEstimate <= contextTokenLimit) && preparedTokenCallTarget !== void 0 && preparedEstimate > preparedTokenCallTarget) {
+			const error = AgentPolicyError.make({
+				limit: "tokens",
+				message: `The next research call would consume this Run's ${policy.completionReserveTokens} token completion reserve`
+			});
+			if (policy.onExhaustion === "fail") return yield* error;
+			context.tokenExhausted = true;
+			context.exhaustedDimension ??= "tokens";
+			finalAnswerOnly = true;
+			toolSchemaTokens = yield* estimateToolSchemaTokens;
+		}
+		preparedEstimate = (yield* preparedSourceTokens) + derivedPromptTokens();
+		if (contextTokenLimit !== void 0 && preparedEstimate > contextTokenLimit) return yield* ContextBudgetError.make({
+			message: `Transient context could not fit the next model prompt inside the ${contextTokenLimit} token context target`,
+			estimatedTokens: preparedEstimate,
+			targetTokens: contextTokenLimit,
+			completionReserveTokens: policy.completionReserveTokens
+		});
+	}
+	if (finalAnswerOnly) yield* context.policyReservations.withPermit(Effect.gen(function* () {
+		context.finalizationUsed = true;
+		if (options.durability?.reservePolicyUsage !== void 0) yield* options.durability.reservePolicyUsage({
+			programmaticToolCalls: context.programmaticToolCalls,
+			finalizationUsed: true
+		});
+	}));
+	/** The model-visible view of the Turn basis under current compaction state. */
+	const compactedOutgoing = () => {
+		context.compaction.lastViewLength = prepared.length;
+		return Prompt.fromMessages(prepared);
+	};
+	const consumeTurnUsage = (toolCallCount) => Effect.suspend(() => {
+		trace.usageConsumed = true;
+		const priorModelCalls = context.modelCalls;
+		return consumeUsage(agent, context, trace.usage, toolCallCount, turn, options, {
+			response: trace.response,
+			finishMetadata: trace.finishMetadata,
+			purpose: "turn"
+		}).pipe(withCallModel, Effect.tapCause(() => context.modelCalls === priorModelCalls ? noteIncompleteUsage(context, turn) : Effect.void));
+	});
+	const retainFailedUsage = Effect.fn("AgentRuntime.retainFailedUsage")(function* () {
+		if (trace.usageConsumed) return;
+		trace.usageConsumed = true;
+		if (trace.usage === void 0) return yield* noteIncompleteUsage(context, turn);
+		yield* consumeTurnUsage(0).pipe(Effect.exit);
+	});
+	const attempt = (basis) => Stream.unwrap(outgoingModelPrompt(policy, context, Prompt.fromMessages([...basis.content, ...transientContext.content]), turn, priorToolCalls).pipe(Effect.flatMap((outgoing) => Effect.gen(function* () {
+		const toolChoice = modelToolChoice();
+		let requestToolkit = modelToolkit;
+		snapshot = selectionSnapshot;
+		if (selectionSnapshot !== void 0 && typeof toolChoice === "object" && "oneOf" in toolChoice) {
+			const finalSelection = yield* validateSelection({ toolNames: toolChoice.oneOf }, agent.definition, catalog);
+			const selected = yield* exposureSnapshot(agent.definition, finalSelection, catalog, toolSchemaTransformer, toolChoice.oneOf);
+			requestToolkit = Toolkit.make(...catalog.filter((entry) => entry.kind === "native" && selected.exposedToolNames.includes(entry.nativeToolName)).map((entry) => entry.tool));
+			snapshot = Object.freeze(Snapshot.make({
+				...selectionSnapshot,
+				exposedToolNames: selected.exposedToolNames
+			}));
+		}
+		context.toolExposure = snapshot;
+		const providerPrompt = outputContract._tag !== "rendered" ? outgoing : insertOutputContract(outgoing, outputContract.part);
+		return yield* estimateCallTokens(providerPrompt.content).pipe(Effect.map((tokens) => tokens + toolSchemaTokens), Effect.tap((estimatedTokens) => contextTokenLimit !== void 0 && (options.context !== void 0 || options.transientContext !== void 0) && estimatedTokens > contextTokenLimit ? ContextBudgetError.make({
+			message: `Prepared context could not fit the next model prompt inside the ${contextTokenLimit} token context target`,
+			estimatedTokens,
+			targetTokens: contextTokenLimit,
+			completionReserveTokens: policy.completionReserveTokens
+		}) : Effect.void), Effect.tap((tokens) => Effect.sync(() => {
+			context.windowTokens = tokens;
+		})), Effect.tap(() => snapshot === void 0 || options.durability?.noteToolExposure === void 0 ? Effect.void : options.durability.noteToolExposure(turn, snapshot)), Effect.as(guardBudgetStream(LanguageModel.streamText({
+			prompt: providerPrompt,
+			toolkit: requestToolkit,
+			disableToolCallResolution: true,
+			...toolChoice === void 0 ? {} : { toolChoice }
+		}), options.budget).pipe(Stream.onStart(Effect.sync(() => {
+			trace.usageConsumed = false;
+		})), Stream.mapEffect((part) => ownModelResponsePart(part, agent.definition.toolkit, trace, context.bufferLimits).pipe(Effect.flatMap((owned) => eventsForPart(context, turnId, turn, agent.definition.toolkit.tools, trace, owned.ownedPart, owned.retainedBytes)))), Stream.flatMap(Stream.fromIterable), Stream.tapCause(() => retainFailedUsage()))));
+	}))));
+	const response = attempt(compactedOutgoing()).pipe(Stream.catch((error) => {
+		if (!(error instanceof AiError.AiError) || !isContextOverflowMessage(overflowText(error))) return Stream.fail(error);
+		const message = overflowText(error);
+		if (trace.parts.length > 0 || contextTokenLimit === void 0) return Stream.fail(ContextOverflowError.make({
+			message,
+			retried: false
+		}));
+		if (context.compaction.overflowRetryTurn === turn) return Stream.fail(ContextOverflowError.make({
+			message,
+			retried: true
+		}));
+		context.compaction.overflowRetryTurn = turn;
+		context.compaction.lastCompactionTurn = turn;
+		return Stream.unwrap(Effect.gen(function* () {
+			const outcome = yield* compactContext(agent, context, modelContext.prompt, turn, options, callContext === void 0 ? void 0 : contextTokenLimit, messageTokenEstimator, Math.max(0, contextTokenLimit - derivedPromptTokens()), "overflow").pipe(withCallModel).pipe(Effect.mapError((inner) => inner instanceof AiError.AiError && isContextOverflowMessage(overflowText(inner)) ? ContextOverflowError.make({
+				message: overflowText(inner),
+				retried: true
+			}) : inner));
+			if (outcome.events.some((event) => event._tag === "CompactionPerformed")) refreshPrepared();
+			const retryEstimate = (yield* preparedSourceTokens) + derivedPromptTokens();
+			if (retryEstimate > contextTokenLimit) return yield* ContextBudgetError.make({
+				message: `Overflow compaction could not fit the retry inside the ${contextTokenLimit} token context target`,
+				estimatedTokens: retryEstimate,
+				targetTokens: contextTokenLimit,
+				completionReserveTokens: policy.completionReserveTokens
+			});
+			const retried = attempt(compactedOutgoing()).pipe(Stream.catch((again) => again instanceof AiError.AiError && isContextOverflowMessage(overflowText(again)) ? Stream.fail(ContextOverflowError.make({
+				message: overflowText(again),
+				retried: true
+			})) : Stream.fail(again)));
+			return Stream.fromIterable(outcome.events).pipe(Stream.concat(retried));
+		}));
+	}), Stream.withSpan("AgentRuntime.model", { attributes: {
+		agentId: context.agentId,
+		runId: context.runId,
+		turnId
+	} }));
+	const continuation = Stream.unwrap(Effect.sync(() => {
+		if (!trace.finished) return failRunEventStream(ModelProtocolError.make({ message: "Model response ended without a finish part" }));
+		const hasProviderCalls = Array.from(trace.toolCalls.values()).some(({ providerExecuted }) => providerExecuted);
+		const turnCompletion = trace.turnCompletion;
+		if (hasProviderCalls && turnCompletion === void 0) return failRunEventStream(ModelProtocolError.make({ message: "Model response omitted staged Turn completion" }));
+		const completionTool = agent.definition.completion?.tool;
+		const declaresCompletion = completionTool !== void 0 && trace.applicationToolCalls.some((call) => call.name === completionTool);
+		const declaresActionCompletion = trace.applicationToolCalls.some((call) => agent.definition.completionFromTools?.some((declaration) => declaration.tool === call.name));
+		if (trace.applicationToolCalls.some((call) => hasTool(agent.definition.toolkit.tools, call.name) && Context.get(agent.definition.toolkit.tools[call.name].annotations, ContextRolloverTool)) && (trace.toolCalls.size !== 1 || declaresCompletion || declaresActionCompletion)) return failRunEventStream(ModelProtocolError.make({ message: "A context rollover Tool must be the only Tool Call and cannot complete the Run" }));
+		const completionBatchError = (declaresCompletion || declaresActionCompletion) && trace.applicationToolCalls.length !== 1 ? ModelProtocolError.make({ message: declaresCompletion ? `Completion Tool ${completionTool} must be the only application Tool Call in its batch` : "An action completion Tool must be the only application Tool Call in its batch" }) : void 0;
+		if (completionBatchError !== void 0 && finalAnswerOnly) return failRunEventStream(completionBatchError);
+		const completionBatch = declaresCompletion && trace.applicationToolCalls.length === 1;
+		if (finalAnswerOnly && trace.toolCalls.size > 0 && (hasProviderCalls || !completionBatch)) return failRunEventStream(ModelProtocolError.make({ message: completionTool === void 0 ? `Model declared ${trace.toolCalls.size} Tool Call(s) under toolChoice "none" after budget exhaustion` : `Model declared ${trace.toolCalls.size} non-completion Tool Call(s) after budget exhaustion` }));
+		const providerOnly = trace.toolCalls.size > 0 && Array.from(trace.toolCalls.values()).every(({ providerExecuted }) => providerExecuted);
+		const missingProviderResult = Array.from(trace.toolCalls.entries()).find(([id, call]) => call.providerExecuted && !trace.finalToolResultIds.has(id));
+		if (missingProviderResult !== void 0) return failRunEventStream(ModelProtocolError.make({ message: `Provider-executed Tool Call ${missingProviderResult[0]} completed without a terminal result` }));
+		const toolCalls = priorToolCalls + trace.toolCalls.size;
+		const overToolBudget = toolCalls + context.programmaticToolCalls > bounds.maxToolCalls;
+		if (overToolBudget && policy.onExhaustion === "fail") return failRunEventStream(AgentPolicyError.make({
+			limit: "tool-calls",
+			message: `Agent exceeded its ${bounds.maxToolCalls} Tool Call limit`
+		}));
+		if (agent.definition.completion?.required === true && trace.toolCalls.size === 0) return failRunEventStream(ModelProtocolError.make({ message: `Model stopped without required completion Tool ${agent.definition.completion.tool}` }));
+		const stagedResponse = Stream.fromIterable(trace.providerResultPayloads).pipe(Stream.mapEffect((payload) => stampProviderResultEvent(context, turnId, payload)), Stream.concat(turnCompletion === void 0 ? Stream.empty : Stream.fromEffect(Effect.map(eventBase(context), (base) => TurnCompleted.make({
+			...base,
+			turnId,
+			turn,
+			finishReason: turnCompletion.finishReason
+		})))));
+		/** Official history advanced through this Turn's response, plus any Tool message. */
+		const historyWithResponse = (...additions) => Prompt.fromMessages([
+			...prompt.content,
+			...promptFromTurnParts(trace).content,
+			...additions
+		]);
+		const afterValidatedResponse = (next) => stagedResponse.pipe(Stream.concat(Stream.unwrap(Effect.gen(function* () {
+			const consumed = yield* consumeTurnUsage(trace.toolCalls.size);
+			const pre = [...consumed.warnings];
+			if (!context.warnedLimits.has("tool-calls") && nearingLimit(toolCalls + context.programmaticToolCalls, bounds.maxToolCalls)) {
+				context.warnedLimits.add("tool-calls");
+				pre.push(BudgetWarning.make({
+					...yield* eventBase(context),
+					limit: "tool-calls",
+					consumed: toolCalls + context.programmaticToolCalls,
+					limitValue: bounds.maxToolCalls
+				}));
+			}
+			if (!context.warnedLimits.has("turns") && nearingLimit(turn, bounds.maxTurns)) {
+				context.warnedLimits.add("turns");
+				pre.push(BudgetWarning.make({
+					...yield* eventBase(context),
+					limit: "turns",
+					consumed: turn,
+					limitValue: bounds.maxTurns
+				}));
+			}
+			const emitThen = (nextStream) => pre.length === 0 ? nextStream : Stream.fromIterable(pre).pipe(Stream.concat(nextStream));
+			if (consumed.breach !== void 0) {
+				if (agent.definition.completion?.required !== true && trace.applicationToolCalls.length === 0 && trace.finishReason === "stop") {
+					const output = yield* decodeFinalOutput(agent, trace.text.join("")).pipe(Effect.map(Option.some), Effect.catch(() => Effect.succeed(Option.none())));
+					if (Option.isSome(output)) {
+						yield* advanceHistory(context, historyWithResponse(), options);
+						const completionUsage = yield* usageReportOf(context);
+						return emitThen(Stream.fromEffect(Effect.map(eventBase(context), (base) => RunCompleted.make({
+							...base,
+							output: output.value.encoded,
+							turns: turn,
+							finishReason: "budget-exhausted",
+							exhausted: "tokens",
+							...completionUsage
+						}))));
+					}
+				}
+				if (trace.applicationToolCalls.length > 0 && !completionBatch) {
+					const rejection = yield* settleRejectedBatch(context, turnId, trace, AgentPolicyError.make({
+						limit: "tokens",
+						message: `Token budget exhausted: this Run's ${policy.tokenBudget ?? 0} token budget was reached, so this call was rejected without executing. Do not request more tools; produce your final answer now from the information you already have.`
+					}));
+					return emitThen(Stream.fromIterable(rejection).pipe(Stream.concat(toolBatchContinuation(agent, context, trace, prompt, turn, toolCalls, options))));
+				}
+			}
+			return emitThen(yield* next);
+		}))));
+		/**
+		* Advance official history for a Turn that always continues, drain
+		* 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* () {
+			yield* advanceHistory(context, history, options);
+			const steering = yield* drainInputs(context, options);
+			const nextPrompt = yield* appendInputs(context, history, steering, options);
+			return nextTurn(nextPrompt, turn + 1, toolCalls);
+		});
+		/**
+		* The otherwise-stop seam: advance official history, drain steering,
+		* fall back to buffered follow-ups, then either start the next Turn
+		* 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* () {
+			yield* advanceHistory(context, history, options);
+			const steering = yield* drainInputs(context, options);
+			const queued = steering.length > 0 ? steering : takeFollowUps(context, options.commandDrainPolicy ?? "one");
+			if (queued.length > 0) {
+				if (policy.onExhaustion === "fail" ? turn >= bounds.maxTurns : turn > bounds.maxTurns) return failRunEventStream(AgentPolicyError.make({
+					limit: "turns",
+					message: `Agent exceeded its ${bounds.maxTurns} Turn limit`
+				}));
+				yield* applyRepeatedFailurePolicy(context, trace, agent.definition.policy.repeatedFailureLimit);
+				const nextPrompt = yield* appendInputs(context, history, queued, options);
+				return nextTurn(nextPrompt, turn + 1, toolCalls);
+			}
+			const output = yield* decodeFinalOutput(agent, trace.text.join(""));
+			const declaration = agent.definition.runDisposition;
+			const runDisposition = finalAnswerOnly || declaration === void 0 ? void 0 : yield* encodeRunDisposition(agent, output.decoded);
+			const completionUsage = yield* usageReportOf(context);
+			return Stream.fromEffect(Effect.map(eventBase(context), (base) => RunCompleted.make({
+				...base,
+				output: output.encoded,
+				...runDisposition === void 0 ? {} : { runDisposition },
+				turns: turn,
+				finishReason: finalAnswerOnly ? "budget-exhausted" : "model-stop",
+				...finalAnswerOnly && context.exhaustedDimension !== void 0 ? { exhausted: context.exhaustedDimension } : {},
+				...completionUsage
+			})));
+		});
+		if (providerOnly && trace.finishReason === "stop") {
+			if (agent.definition.completion?.required === true) {
+				if (policy.onExhaustion === "fail" ? turn >= bounds.maxTurns : turn > bounds.maxTurns) return failRunEventStream(AgentPolicyError.make({
+					limit: "turns",
+					message: `Agent exceeded its ${bounds.maxTurns} Turn limit`
+				}));
+			}
+			return afterValidatedResponse(agent.definition.completion?.required === true ? continueTurn(historyWithResponse()) : settleOrFollowUp(historyWithResponse()));
+		}
+		if (trace.toolCalls.size > 0) {
+			if (trace.finishReason !== "tool-calls") return failRunEventStream(ModelProtocolError.make({ message: `Model declared Tool Calls with incompatible finish reason ${trace.finishReason}` }));
+			if (turn > bounds.maxTurns && !(turn === bounds.maxTurns + 1 && finalAnswerOnly && completionBatch) || policy.onExhaustion === "fail" && turn === bounds.maxTurns && !completionBatch) return failRunEventStream(AgentPolicyError.make({
+				limit: "turns",
+				message: `Agent exceeded its ${bounds.maxTurns} Turn limit`
+			}));
+			const batchRejection = overToolBudget && trace.applicationToolCalls.length > 0 && !(completionBatch && policy.onExhaustion === "final-answer") ? AgentPolicyError.make({
+				limit: "tool-calls",
+				message: `Tool Call budget exhausted: this Run's ${bounds.maxToolCalls} Tool Call limit was reached, so this call was rejected without executing. Do not request more tools; produce your final answer now from the information you already have.`
+			}) : completionBatchError === void 0 ? void 0 : ModelProtocolError.make({ message: `${completionBatchError.message}. ` + (hasProviderCalls ? "The application batch was rejected before execution; none of its application tools ran. Completed provider results are retained. " : "The entire batch was rejected before execution; none of its tools ran. ") + "Request any needed ordinary tools first, wait for their results, then call a completion tool alone." });
+			if (batchRejection !== void 0) return afterValidatedResponse(Effect.gen(function* () {
+				const rejection = yield* settleRejectedBatch(context, turnId, trace, batchRejection);
+				return Stream.fromIterable(rejection).pipe(Stream.concat(toolBatchContinuation(agent, context, trace, prompt, turn, toolCalls, options)));
+			}));
+			if (trace.applicationToolCalls.length === 0) return afterValidatedResponse(Effect.gen(function* () {
+				const history = historyWithResponse();
+				yield* advanceHistory(context, history, options);
+				yield* applyRepeatedFailurePolicy(context, trace, agent.definition.policy.repeatedFailureLimit);
+				const steering = yield* drainInputs(context, options);
+				const nextPrompt = yield* appendInputs(context, history, steering, options);
+				return nextTurn(nextPrompt, turn + 1, toolCalls);
+			}));
+			return afterValidatedResponse(Effect.gen(function* () {
+				const toolkit = yield* agent.definition.toolkit;
+				const concurrency = yield* schedulingConcurrency(agent.definition.policy.toolConcurrency, options.scheduling);
+				if (options.durability !== void 0) yield* options.durability.commitResponse({
+					turn,
+					turnId,
+					responseMessages: promptFromTurnParts(trace),
+					calls: trace.applicationCallDescriptors,
+					toolExposure: snapshot
+				});
+				return guardBudgetStream(executeToolBatch(context, turnId, turn, toolkit, trace.applicationToolCalls, trace, concurrency, options, {
+					maxToolCalls: bounds.maxToolCalls,
+					declaredToolCalls: toolCalls
+				}, agent.definition.policy.toolResultBounds), options.budget).pipe(Stream.concat(toolBatchContinuation(agent, context, trace, prompt, turn, toolCalls, options)));
+			}));
+		}
+		if (trace.finishReason !== "stop") return failRunEventStream(ModelProtocolError.make({ message: `Model stopped without a final answer (${trace.finishReason})` }));
+		return afterValidatedResponse(settleOrFollowUp(historyWithResponse()));
+	}));
+	const events = Stream.fromIterable(preEvents).pipe(Stream.concat(started), Stream.concat(response), Stream.concat(continuation.pipe(Stream.tapCause(() => retainFailedUsage()))));
+	return modelServices === void 0 ? events : Stream.provideContext(events, modelServices);
+}));
+/**
+* Settle a completed application Tool batch and continue the Run: verify one
+* final result per declared call, fold outcomes into the repeated-failure
+* Stop Policy, advance official history with the Tool message in declaration
+* order, drain steering at the safe seam, and start the next Turn. Shared by
+* the ordinary model-declared path (`makeTurn`) and the durable batch-resume
+* path (`makeResumeTurn`).
+*/
+const toolBatchContinuation = (agent, context, trace, prompt, turn, toolCalls, options) => Stream.unwrap(Effect.gen(function* () {
+	if (trace.finalToolResultIds.size !== trace.toolCalls.size) return failRunEventStream(ModelProtocolError.make({ message: "A Tool Call turn completed without one final result per Tool Call" }));
+	const orderedResults = [];
+	for (const call of trace.applicationToolCalls) {
+		const result = trace.applicationToolResults.find((candidate) => candidate?.id === call.id);
+		if (result === void 0) return failRunEventStream(ModelProtocolError.make({ message: "Tool batch did not settle completely" }));
+		orderedResults.push(result);
+	}
+	for (const result of orderedResults) if (!result.isFailure && result.toolSelection !== void 0) context.toolSelection = result.toolSelection;
+	const toolMessage = Prompt.makeMessage("tool", { content: orderedResults.map((result) => Prompt.makePart("tool-result", {
+		id: result.id,
+		name: result.name,
+		result: result.encodedResult,
+		isFailure: result.isFailure,
+		providerExecuted: false
+	})) });
+	const history = Prompt.fromMessages([
+		...prompt.content,
+		...promptFromTurnParts(trace).content,
+		toolMessage
+	]);
+	yield* advanceHistory(context, history, options);
+	yield* applyRepeatedFailurePolicy(context, trace, agent.definition.policy.repeatedFailureLimit);
+	const rolloverResult = orderedResults.length === 1 ? orderedResults[0] : void 0;
+	if (rolloverResult !== void 0 && !rolloverResult.isFailure && hasTool(agent.definition.toolkit.tools, rolloverResult.name) && Context.get(agent.definition.toolkit.tools[rolloverResult.name].annotations, ContextRolloverTool)) context.pendingContextToolCallId = rolloverResult.id;
+	const completion = agent.definition.completion;
+	const successfulResult = trace.applicationToolCalls.length === 1 && orderedResults.length === 1 && orderedResults[0]?.isFailure === false ? orderedResults[0] : void 0;
+	const actionCompletion = agent.definition.completionFromTools?.find((declaration) => declaration.tool === successfulResult?.name);
+	let selectedOutput = Option.none();
+	if (successfulResult !== void 0 && (successfulResult.name === completion?.tool || actionCompletion !== void 0)) {
+		const call = trace.applicationCallDescriptors[0];
+		if (call === void 0) return failRunEventStream(ModelProtocolError.make({ message: "Completion Tool has no canonical call descriptor" }));
+		if (actionCompletion !== void 0) selectedOutput = yield* projectCompletionFromToolOutput(agent, actionCompletion, call.parameters, successfulResult.encodedResult);
+		else if (completion !== void 0) selectedOutput = Option.some(yield* projectCompletionOutput(agent, completion, call.parameters, successfulResult.encodedResult));
+	}
+	if (Option.isSome(selectedOutput)) {
+		const output = selectedOutput.value;
+		const bounds = effectiveRunBounds(agent.definition.policy, options);
+		const exhausted = context.tokenExhausted ? "tokens" : turn > bounds.maxTurns ? "turns" : toolCalls + context.programmaticToolCalls > bounds.maxToolCalls ? "tool-calls" : context.exhaustedDimension;
+		if (exhausted !== void 0 && context.exhaustedDimension === void 0) context.exhaustedDimension = exhausted;
+		const declaration = agent.definition.runDisposition;
+		const runDisposition = exhausted !== void 0 || declaration === void 0 ? void 0 : yield* encodeRunDisposition(agent, output.decoded);
+		const completionUsage = yield* usageReportOf(context);
+		return Stream.fromEffect(Effect.map(eventBase(context), (base) => RunCompleted.make({
+			...base,
+			output: output.encoded,
+			...runDisposition === void 0 ? {} : { runDisposition },
+			turns: turn,
+			finishReason: exhausted === void 0 ? "completed" : "budget-exhausted",
+			...exhausted === void 0 ? {} : { exhausted },
+			...completionUsage
+		})));
+	}
+	const steering = yield* drainInputs(context, options);
+	const nextPrompt = yield* appendInputs(context, history, steering, options);
+	return nextTurn(nextPrompt, turn + 1, toolCalls);
+}));
+/**
+* Resume one canonically declared Tool batch without re-invoking the model
+* (the durable batch-resume seam consumed via `RunOptions.resume`).
+*
+* The declared calls are re-validated through their Tool parameter Schemas
+* before anything executes; a decode failure is a strict no-start boundary
+* (RUN-004/STORE-006). The resumed Turn's response messages are rebuilt in
+* canonical encoded form so official history matches the recorded response.
+* Calls listed in `settled` are injected as final results without starting
+* their handlers — recorded Tool outcomes never rerun — while approval
+* preflight and durable preparation still cover the complete declared batch.
+* No model request is made and no usage is consumed for the resumed Turn.
+*/
+const makeResumeTurn = (agent, context, prompt, resume, countedToolCalls, options) => Stream.unwrap(Effect.gen(function* () {
+	const tools = agent.definition.toolkit.tools;
+	const turn = resume.turn;
+	const turnId = resume.turnId;
+	const visibility = yield* RunToolVisibility;
+	if (resume.toolExposure === void 0 && (agent.definition.toolExposure !== void 0 || context.toolSelection !== void 0 || visibility !== void 0)) return yield* ModelProtocolError.make({ message: "Resumed progressive Turn is missing its original Tool exposure" });
+	context.toolCatalog = yield* eligibleCatalog(agent.definition, {
+		threadId: context.threadId,
+		runId: context.runId,
+		turn,
+		input: context.input
+	}, options.subagentGrant, options.delegationDepth ?? options.parentLink?.depth ?? 0);
+	context.toolExposure = resume.toolExposure === void 0 ? void 0 : yield* decodeSnapshot(resume.toolExposure);
+	const originalExposure = context.toolExposure;
+	if (originalExposure !== void 0) {
+		yield* validateSelection({ toolNames: originalExposure.exposedToolNames }, agent.definition, context.toolCatalog, false);
+		if (originalExposure.selection !== void 0) yield* validateSelection(originalExposure.selection, agent.definition, context.toolCatalog, false);
+		if (resume.calls.some((call) => !originalExposure.exposedToolNames.includes(call.name))) return yield* ModelProtocolError.make({ message: "Resumed Tool call was not exposed in its original model request" });
+		context.toolSelection = originalExposure.selection;
+	}
+	if (!Number.isInteger(turn) || turn <= 0) return failRunEventStream(ModelProtocolError.make({ message: "Turn resume requires a positive integer turn number" }));
+	if (resume.calls.length === 0) return failRunEventStream(ModelProtocolError.make({ message: "Turn resume requires at least one declared Tool Call" }));
+	const trace = {
+		replayedResponse: resume.responseMessages,
+		responsePartCount: 0,
+		responsePartBytes: 0,
+		parts: [],
+		text: [],
+		textParts: /* @__PURE__ */ new Map(),
+		reasoningParts: /* @__PURE__ */ new Map(),
+		toolParameterParts: /* @__PURE__ */ new Map(),
+		toolCalls: /* @__PURE__ */ new Map(),
+		finalToolResultIds: /* @__PURE__ */ new Set(),
+		providerResultPayloads: [],
+		providerStagedPayloadBytes: 0,
+		turnCompletion: void 0,
+		applicationToolCalls: [],
+		applicationCallDescriptors: [],
+		applicationToolResults: [],
+		finished: true,
+		finishReason: "tool-calls",
+		usage: void 0
+	};
+	const declarationByCallId = /* @__PURE__ */ new Map();
+	for (const call of resume.calls) {
+		if (!hasTool(tools, call.name)) return failRunEventStream(ModelProtocolError.make({ message: `Turn resume declared unknown Tool ${call.name}` }));
+		if (trace.toolCalls.has(call.id)) return failRunEventStream(ModelProtocolError.make({ message: `Turn resume repeated Tool Call ID ${call.id}` }));
+		const tool = tools[call.name];
+		const toolCallId = yield* decodeToolCallId(call.id);
+		yield* decodeToolCallParameters(tool, call.name, call.params, "resume");
+		const parameters = yield* decodeEventJson(call.params, "Tool parameters");
+		const providerExecuted = call.providerExecuted === true;
+		declarationByCallId.set(call.id, {
+			index: trace.applicationToolCalls.length,
+			name: call.name,
+			providerExecuted
+		});
+		trace.parts.push(Response.makePart("tool-call", {
+			id: call.id,
+			name: call.name,
+			params: parameters,
+			providerExecuted
+		}));
+		trace.toolCalls.set(call.id, {
+			name: call.name,
+			providerExecuted
+		});
+		if (providerExecuted) continue;
+		trace.applicationToolCalls.push(Response.makePart("tool-call", {
+			id: call.id,
+			name: call.name,
+			params: parameters,
+			providerExecuted: false
+		}));
+		trace.applicationCallDescriptors.push({
+			toolCallId,
+			toolName: call.name,
+			parameters,
+			executionClass: getToolExecutionClass(tool),
+			executionKind: getToolExecutionKind(tool.annotations)
+		});
+	}
+	const completionTool = agent.definition.completion?.tool;
+	const actionCompletionCall = trace.applicationToolCalls.find((call) => agent.definition.completionFromTools?.some((declaration) => declaration.tool === call.name));
+	if ((actionCompletionCall !== void 0 || completionTool !== void 0 && trace.applicationToolCalls.some((call) => call.name === completionTool)) && trace.applicationToolCalls.length !== 1) return failRunEventStream(ModelProtocolError.make({ message: "A completion Tool must be the only application Tool Call in its batch" }));
+	const completionBatch = completionTool !== void 0 && trace.applicationToolCalls.length === 1 && trace.applicationToolCalls[0]?.name === completionTool;
+	if (completionBatch && completionTool !== void 0 && Context.get(tools[completionTool].annotations, ContextRolloverTool) || actionCompletionCall !== void 0 && Context.get(tools[actionCompletionCall.name].annotations, ContextRolloverTool)) return failRunEventStream(ModelProtocolError.make({ message: "A context rollover Tool cannot complete the Run" }));
+	if (context.finalizationUsed && (!completionBatch || trace.toolCalls.size !== 1)) return failRunEventStream(ModelProtocolError.make({ message: "A resumed grace finalization may only execute the completion Tool" }));
+	const settledIds = /* @__PURE__ */ new Set();
+	const providerCallIds = new Set([...declarationByCallId].filter(([, call]) => call.providerExecuted).map(([id]) => id));
+	const settledInputs = yield* snapshotResumedSettledCalls(resume, declarationByCallId.size);
+	for (const settledInput of settledInputs) {
+		const settledCall = yield* decodeResumedSettledCall(settledInput, agent.definition.policy.toolResultBounds.maxBytes, providerCallIds);
+		const declared = declarationByCallId.get(settledCall.id);
+		if (declared === void 0) return failRunEventStream(ModelProtocolError.make({ message: `Turn resume settled an undeclared Tool Call ${settledCall.id}` }));
+		if (settledIds.has(settledCall.id)) return failRunEventStream(ModelProtocolError.make({ message: `Turn resume settled Tool Call ${settledCall.id} more than once` }));
+		settledIds.add(settledCall.id);
+		trace.finalToolResultIds.add(settledCall.id);
+		if (declared.providerExecuted) {
+			trace.parts.push(Response.makePart("tool-result", {
+				id: settledCall.id,
+				name: declared.name,
+				result: settledCall.result,
+				encodedResult: settledCall.result,
+				isFailure: settledCall.isFailure,
+				providerExecuted: true,
+				preliminary: false
+			}));
+			continue;
+		}
+		trace.applicationToolResults[declared.index] = {
+			...settledCall.toolSelection === void 0 ? {} : { toolSelection: yield* validateSelection(settledCall.toolSelection, agent.definition, context.toolCatalog, false) },
+			id: settledCall.id,
+			name: declared.name,
+			encodedResult: settledCall.result,
+			isFailure: settledCall.isFailure,
+			...settledCall.budgetRejected === void 0 ? {} : { budgetRejected: settledCall.budgetRejected }
+		};
+	}
+	const policy = agent.definition.policy;
+	const bounds = effectiveRunBounds(policy, options);
+	const toolCalls = countedToolCalls;
+	for (const [id, call] of declarationByCallId) if (call.providerExecuted && !settledIds.has(id)) return failRunEventStream(ModelProtocolError.make({ message: `Turn resume lacks the canonical provider result for ${id}` }));
+	const overToolBudget = toolCalls + context.programmaticToolCalls > bounds.maxToolCalls;
+	if (overToolBudget && policy.onExhaustion === "fail") return failRunEventStream(AgentPolicyError.make({
+		limit: "tool-calls",
+		message: `Agent exceeded its ${bounds.maxToolCalls} Tool Call limit`
+	}));
+	if (turn > bounds.maxTurns && !(policy.onExhaustion === "final-answer" && turn === bounds.maxTurns + 1 && context.finalizationUsed && completionBatch) || policy.onExhaustion === "fail" && turn === bounds.maxTurns && !completionBatch) return failRunEventStream(AgentPolicyError.make({
+		limit: "turns",
+		message: `Agent exceeded its ${bounds.maxTurns} Turn limit`
+	}));
+	const toolkit = yield* agent.definition.toolkit;
+	const concurrency = yield* schedulingConcurrency(agent.definition.policy.toolConcurrency, options.scheduling);
+	const leading = resume.leadingMessages;
+	const resumedPrompt = leading === void 0 || leading.content.length === 0 ? prompt : Prompt.fromMessages([...prompt.content, ...leading.content]);
+	if (resumedPrompt !== prompt) yield* advanceHistory(context, resumedPrompt, options);
+	const started = Stream.fromEffect(Effect.gen(function* () {
+		yield* Effect.logDebug("agent resumed a declared Tool batch").pipe(Effect.annotateLogs({
+			agentId: context.agentId,
+			runId: context.runId,
+			turnId
+		}));
+		return [TurnStarted.make({
+			...yield* eventBase(context),
+			turnId,
+			turn
+		}), TurnCompleted.make({
+			...yield* eventBase(context),
+			turnId,
+			turn,
+			finishReason: "tool-calls"
+		})];
+	}).pipe(Effect.withLogSpan("AgentRuntime.resume"))).pipe(Stream.flatMap(Stream.fromIterable));
+	const continueAfterBatch = () => toolBatchContinuation(agent, context, trace, resumedPrompt, turn, toolCalls, options);
+	if (overToolBudget && !(completionBatch && policy.onExhaustion === "final-answer")) {
+		const rejection = yield* settleRejectedBatch(context, turnId, trace, AgentPolicyError.make({
+			limit: "tool-calls",
+			message: `Tool Call budget exhausted: this Run's ${bounds.maxToolCalls} Tool Call limit was reached, so this call was rejected without executing. Do not request more tools; produce your final answer now from the information you already have.`
+		}), settledIds);
+		return started.pipe(Stream.concat(Stream.fromIterable(rejection)), Stream.concat(continueAfterBatch()));
+	}
+	const toolResults = guardBudgetStream(executeToolBatch(context, turnId, turn, toolkit, trace.applicationToolCalls, trace, concurrency, options, {
+		maxToolCalls: bounds.maxToolCalls,
+		declaredToolCalls: toolCalls
+	}, agent.definition.policy.toolResultBounds, settledIds), options.budget);
+	return started.pipe(Stream.concat(toolResults), Stream.concat(continueAfterBatch()));
+}));
+const failRunEventStream = (error) => Stream.fail(error);
+const durationLimitError = (policy) => AgentPolicyError.make({
+	limit: "duration",
+	message: `Agent exceeded its ${Duration.format(policy.maxDuration)} duration limit`
+});
+const enforceDurationDeadline = (execution, durationDeadlineMillis, durationLimit) => Stream.unwrap(Effect.gen(function* () {
+	const remaining = durationDeadlineMillis - (yield* Clock.currentTimeMillis);
+	if (remaining <= 0) return Stream.fail(durationLimit);
+	return execution.pipe(Stream.interruptWhen(Effect.sleep(remaining).pipe(Effect.andThen(Effect.fail(durationLimit)))));
+}));
+const guardBudgetStream = (stream, budget) => budget === void 0 ? stream : Stream.transformPull(stream, (pull) => Effect.succeed(budget.guard(pull)));
+function streamWithCompletion(agentValue, input, runOptions = {}, onCompleted, onUsage) {
+	const agent = { definition: "definition" in agentValue ? agentValue.definition : agentValue };
+	const model = "definition" in agentValue ? agentValue.model : void 0;
+	return Stream.unwrap(Effect.gen(function* () {
+		const history = yield* ThreadHistory;
+		const preparation = yield* Effect.serviceOption(RunContextPreparation).pipe(Effect.map(Option.getOrElse(() => RunContextPreparation.of({}))));
+		const authorization = yield* Effect.serviceOption(RunToolAuthorization).pipe(Effect.map(Option.getOrUndefined));
+		const visibility = yield* RunToolVisibility;
+		const ids = yield* IdGenerator$1;
+		const threadId = runOptions.threadId ?? (yield* ids.nextThreadId);
+		const runId = runOptions.runId ?? (yield* ids.nextRunId);
+		const retained = history.retention === "incremental" && runOptions.durability !== void 0 ? void 0 : yield* history.open({
+			threadId,
+			runId
+		});
+		if (history.retention === "on-success" && (runOptions.history !== void 0 || runOptions.onHistory !== void 0 || runOptions.input !== void 0 || runOptions.durability !== void 0 || runOptions.subagent !== void 0 || runOptions.resume !== void 0 || runOptions.resumeUsage !== void 0)) return yield* ThreadHistoryError.make({
+			threadId,
+			reason: "incompatible",
+			message: "Provided history cannot share ownership with explicit history, input queues, or durable recovery hooks"
+		});
+		const initialHistory = runOptions.history ?? retained?.prompt;
+		if (retained !== void 0 && runOptions.history !== void 0) yield* retained.stageHistory(runOptions.history);
+		const options = {
+			...runOptions,
+			context: runOptions.context ?? preparation.hook,
+			transientContext: runOptions.transientContext ?? preparation.transientContext,
+			toolAuthorization: runOptions.toolAuthorization ?? authorization,
+			threadId,
+			runId,
+			...retained === void 0 ? {} : {
+				history: initialHistory,
+				onHistory: (next) => retained.stageHistory(next).pipe(Effect.andThen(() => runOptions.onHistory?.(next) ?? Effect.void))
+			}
+		};
+		const programmaticAuthorization = Layer.effect(ProgrammaticToolAuthorization, Effect.gen(function* () {
+			const services = yield* Effect.context();
+			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 = Stream.unwrap(Effect.gen(function* () {
+			const resumed = options.resume === void 0 ? void 0 : {
+				batch: options.resume,
+				usage: yield* decodeResumeUsage(options.resumeUsage)
+			};
+			const resumeUsage = resumed?.usage ?? (options.resumeUsage === void 0 ? void 0 : yield* decodeResumeUsage(options.resumeUsage));
+			if (resumed !== void 0 && (resumed.usage.committedTurns !== resumed.batch.turn || resumed.usage.toolCalls < resumed.batch.calls.length || resumed.usage.consecutiveToolFailures > resumed.usage.toolCalls - resumed.batch.calls.length)) return yield* ModelProtocolError.make({ message: "Run resume accounting conflicts with the pending Turn and declared Tool Calls" });
+			const attemptStartedAtMillis = yield* Clock.currentTimeMillis;
+			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 compactor = yield* Effect.serviceOption(ContextCompactor).pipe(Effect.flatMap(Option.match({
+				onSome: Effect.succeed,
+				onNone: () => Effect.provide(ContextCompactor, ContextCompactor.layer)
+			})));
+			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 context = {
+				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" }))),
+				updates: /* @__PURE__ */ new Map(),
+				updateBytes: 0,
+				updatePermits: yield* Semaphore.make(1),
+				definition: agent.definition,
+				toolSelection: initialToolSelection === void 0 ? void 0 : yield* decodeSelection(initialToolSelection),
+				toolCatalog: [],
+				toolExposure: void 0,
+				toolSchemaTransformer: void 0,
+				agentId: agent.definition.id,
+				threadId,
+				runId,
+				toolFailureObserver: yield* CurrentToolFailureObserver,
+				input: void 0,
+				pendingFollowUps: [],
+				startedAtMillis,
+				durationDeadlineMillis,
+				history: options.history ?? Prompt.empty,
+				modelCalls: resumeUsage?.modelCalls ?? 0,
+				usageStatus: resumeUsage?.usageStatus ?? (resumeUsage === void 0 ? "complete" : "unknown"),
+				pricingStatus: resumeUsage?.pricingStatus ?? (resumeUsage === void 0 ? "complete" : "unknown"),
+				unobservedModelCalls: resumeUsage?.unobservedModelCalls ?? 0,
+				childUsage: new Map((resumeUsage?.children ?? []).map((child) => [child.runId, Effect.succeed(child.report)])),
+				liveChildren: /* @__PURE__ */ new Set(),
+				consecutiveToolFailures: resumeUsage?.consecutiveToolFailures ?? 0,
+				inputTokens: resumeUsage?.inputTokens ?? 0,
+				outputTokens: resumeUsage?.outputTokens ?? 0,
+				lastInputTokens: resumeUsage?.lastInputTokens ?? 0,
+				lastOutputTokens: resumeUsage?.lastOutputTokens ?? 0,
+				costMicrousd: resumeUsage?.costMicrousd ?? 0,
+				lastCostMicrousd: 0,
+				warnedLimits: /* @__PURE__ */ new Set(),
+				finalizing: false,
+				tokenExhausted: false,
+				exhaustedDimension: void 0,
+				compaction: initialCompactionState(),
+				preparedCompactionSource: void 0,
+				compactionTurn: {
+					turn: 0,
+					summaryCalls: 0,
+					applied: /* @__PURE__ */ new Set()
+				},
+				windowId: options.initialContextWindowId ?? contextWindowId(runId, 0),
+				windowTokens: resumeUsage?.lastInputTokens ?? 0,
+				windowContextTokenLimit: agent.definition.policy.contextTokenLimit,
+				pendingContextToolCallId: options.pendingContextToolCallId,
+				bufferLimits: effectiveRunBufferLimits(options.bufferLimits),
+				sequence: 0,
+				toolProgressBytes: 0,
+				programmaticToolCalls: resumeUsage?.programmaticToolCalls ?? 0,
+				finalizationUsed: resumeUsage?.finalizationUsed ?? false,
+				policyReservations: yield* Semaphore.make(1)
+			};
+			onUsage?.(usageReportOf(context));
+			if (resumeUsage !== void 0) {
+				const bounds = effectiveRunBounds(agent.definition.policy, options);
+				if (context.finalizationUsed) context.exhaustedDimension = resumeUsage.committedTurns > bounds.maxTurns ? "turns" : resumeUsage.toolCalls + context.programmaticToolCalls > bounds.maxToolCalls ? "tool-calls" : "tokens";
+				if (agent.definition.policy.onExhaustion === "fail" && resumeUsage.toolCalls + context.programmaticToolCalls > bounds.maxToolCalls) return failRunEventStream(AgentPolicyError.make({
+					limit: "tool-calls",
+					message: `Agent exceeded its ${bounds.maxToolCalls} Tool Call limit`
+				}));
+				const failureLimit = agent.definition.policy.repeatedFailureLimit;
+				if (failureLimit > 0 && context.consecutiveToolFailures >= failureLimit) return failRunEventStream(AgentPolicyError.make({
+					limit: "repeated-failures",
+					message: `Agent reached its ${failureLimit} consecutive Tool Call failure limit`
+				}));
+				const seededCostBudget = agent.definition.policy.costBudgetMicrousd;
+				if (seededCostBudget !== void 0 && context.costMicrousd > seededCostBudget) return failRunEventStream(AgentPolicyError.make({
+					limit: "cost",
+					message: `Agent exceeded its ${seededCostBudget} microdollar cost budget`
+				}));
+				const seededBudget = agent.definition.policy.tokenBudget;
+				if (seededBudget !== void 0 && context.inputTokens + context.outputTokens > seededBudget) {
+					if (agent.definition.policy.onExhaustion === "fail") return failRunEventStream(AgentPolicyError.make({
+						limit: "tokens",
+						message: `Agent exceeded its ${seededBudget} token budget`
+					}));
+					context.tokenExhausted = true;
+					context.exhaustedDimension ??= "tokens";
+				}
+			}
+			if (options.input?.start !== void 0) yield* options.input.start();
+			const started = Stream.fromEffect(Effect.gen(function* () {
+				yield* Metric.update(runCounter, 1);
+				yield* Effect.logDebug("agent run started").pipe(Effect.annotateLogs({
+					agentId: context.agentId,
+					runId: context.runId
+				}));
+				return yield* eventBase(context).pipe(Effect.map((base) => RunStarted.make(base)));
+			}).pipe(Effect.withLogSpan("AgentRuntime.run")));
+			const execution = Stream.unwrap(Effect.gen(function* () {
+				const decodedInput = yield* decodeInput(agent, input);
+				const instructions = yield* evaluateInstructions(agent.definition.instructions, decodedInput);
+				const encodedInput = yield* encodeInput(agent, decodedInput);
+				context.input = encodedInput;
+				if (retained !== void 0) yield* retained.stageInput(encodedInput);
+				const inputPrompt = options.frameworkMessage === void 0 ? yield* renderInputPrompt(agent.definition.inputPrompt, decodedInput, encodedInput) : yield* Schema.encodeEffect(Schema.fromJsonString(FrameworkMessage))(options.frameworkMessage).pipe(Effect.mapError(() => AgentInputError.make({ message: "Invalid worker message" })));
+				const priorHistoryLength = context.history.content.length;
+				const prompt = yield* makeInitialPrompt(instructions, inputPrompt, context.history);
+				if (options.context === void 0) {
+					context.compaction.protectedStart = priorHistoryLength;
+					context.compaction.protectedEnd = prompt.content.length;
+				} else context.preparedCompactionSource = {
+					protectedReferences: options.protectedContext?.content ?? prompt.content.slice(priorHistoryLength),
+					protectedMessages: yield* snapshotCompactionMessages(options.protectedContext?.content ?? prompt.content.slice(priorHistoryLength)),
+					prefix: []
+				};
+				yield* advanceHistory(context, prompt, options);
+				let pending;
+				if (resumed !== void 0) pending = {
+					prompt,
+					turn: resumed.batch.turn,
+					toolCalls: resumed.usage.toolCalls,
+					resume: resumed.batch
+				};
+				else {
+					const steering = yield* drainInputs(context, options);
+					pending = {
+						prompt: yield* appendInputs(context, prompt, steering, options),
+						turn: (resumeUsage?.committedTurns ?? 0) + 1,
+						toolCalls: resumeUsage?.toolCalls ?? 0
+					};
+				}
+				return Stream.fromEffectRepeat(Effect.suspend(() => {
+					const current = pending;
+					pending = void 0;
+					return current === void 0 ? Cause.done() : Effect.succeed(current);
+				})).pipe(Stream.flatMap((request) => request.resume === void 0 ? makeTurn(agent, context, request.prompt, request.turn, request.toolCalls, options) : makeResumeTurn(agent, context, request.prompt, request.resume, request.toolCalls, options)), Stream.filterMapEffect((output) => Effect.sync(() => {
+					if (output._tag === "NextTurn") {
+						pending = output;
+						return Result.fail(void 0);
+					}
+					return Result.succeed(output);
+				})));
+			}));
+			const durationLimit = durationLimitError(agent.definition.policy);
+			const deadline = enforceDurationDeadline(execution, durationDeadlineMillis, durationLimit);
+			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" })));
+				yield* (yield* Emitter).emit({
+					target: agent.definition,
+					updateId,
+					value
+				});
+			}) });
+			const engineToolServices = Context.make(AgentSpawner, makeAgentSpawner({
+				agentId: context.agentId,
+				threadId: context.threadId,
+				runId: context.runId
+			}, options.delegationDepth ?? options.parentLink?.depth ?? 0, history, preparation, agent.definition.policy, options.subagentGrant, options.subagentBudget, options.subagentBudgetScope, (childRunId, read) => {
+				context.liveChildren.add(childRunId);
+				context.childUsage.set(childRunId, read);
+			})).pipe(Context.add(ContextWindow, { status: Effect.sync(() => {
+				const estimatedTokens = Math.min(Number.MAX_SAFE_INTEGER, context.windowTokens + context.lastOutputTokens);
+				const contextTokenLimit = context.windowContextTokenLimit ?? null;
+				return ContextWindowStatus.make({
+					threadId: context.threadId,
+					runId: context.runId,
+					windowId: context.windowId,
+					estimatedTokens,
+					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 : {
+				grant: options.subagentGrant,
+				depth: options.delegationDepth ?? options.parentLink?.depth ?? 0
+			}), Context.add(ToolBroker, closedToolBroker));
+			return started.pipe(Stream.concat(deadline), Stream.catch((error) => {
+				return Stream.fromEffect(Effect.gen(function* () {
+					if (error instanceof AgentApprovalPending || error instanceof AgentChildPending) return RunSuspended.make({
+						...yield* terminalEventBase(context),
+						reason: error.message,
+						...yield* usageReportOf(context)
+					});
+					return RunFailed.make({
+						...yield* terminalEventBase(context),
+						...yield* usageReportOf(context),
+						errorTag: errorTag(error),
+						message: errorMessage(error)
+					});
+				})).pipe(Stream.concat(Stream.fail(error)));
+			}), Stream.withSpan("AgentRuntime.run", { attributes: {
+				agentId: context.agentId,
+				runId: context.runId
+			} }), Stream.provide(engineToolServices), Stream.provideService(ContextCompactor, compactor));
+		}));
+		const finalized = options.input?.end === void 0 ? interpreted : interpreted.pipe(Stream.ensuring(options.input.end()));
+		const events = (model === void 0 ? finalized : finalized.pipe(Stream.provide(model, { local: true }))).pipe(Stream.provide(ToolSpanTelemetry.layer), Stream.provide(programmaticAuthorization));
+		if (retained === void 0 && onCompleted === void 0) return events;
+		let completed;
+		return events.pipe(Stream.filter((event) => {
+			if (event._tag !== "RunCompleted") return true;
+			completed = event;
+			return false;
+		}), Stream.scoped, Stream.concat(Stream.unwrap(Effect.gen(function* () {
+			const terminal = completed;
+			if (terminal === void 0) return yield* ModelProtocolError.make({ message: "Agent stream ended without RunCompleted" });
+			return Stream.fromEffect(Effect.gen(function* () {
+				if (onCompleted !== void 0) yield* onCompleted(terminal);
+				if (retained !== void 0) yield* retained.commit(terminal);
+				return terminal;
+			})).pipe(Stream.catch((error) => Stream.make(RunFailed.make({
+				eventVersion: terminal.eventVersion,
+				threadId: terminal.threadId,
+				runId: terminal.runId,
+				agentId: terminal.agentId,
+				usage: terminal.usage,
+				delegatedUsage: terminal.delegatedUsage,
+				sequence: terminal.sequence,
+				timestamp: terminal.timestamp,
+				errorTag: errorTag(error),
+				message: errorMessage(error)
+			})).pipe(Stream.concat(Stream.fail(error)))));
+		}))));
+	}));
+}
+/** Validate the terminal result before the stream commits history and publishes completion. */
+const reduceRunEvents = (agent, events) => Effect.gen(function* () {
+	let result;
+	yield* Stream.runDrain(events((completed) => Effect.gen(function* () {
+		const candidateOutput = completed.output;
+		const output = yield* Schema.decodeUnknownEffect(agent.definition.output)(candidateOutput).pipe(Effect.mapError((cause) => AgentOutputError.make({ message: cause.message })));
+		const declaration = agent.definition.runDisposition;
+		const runDisposition = completed.runDisposition === void 0 ? void 0 : completed.finishReason === "budget-exhausted" ? yield* ModelProtocolError.make({ message: "A budget-exhausted RunCompleted event cannot declare a run disposition" }) : declaration === void 0 ? yield* ModelProtocolError.make({ message: "RunCompleted declared a run disposition without a definition-owned Schema" }) : yield* decodeRunDisposition(agent, completed.runDisposition);
+		result = {
+			output,
+			threadId: completed.threadId,
+			runId: completed.runId,
+			turns: completed.turns,
+			finishReason: completed.finishReason,
+			...completed.exhausted !== void 0 ? { exhausted: completed.exhausted } : {},
+			...runDisposition === void 0 ? {} : { runDisposition: completed.runDisposition },
+			...completed.usage === void 0 ? {} : { usage: completed.usage },
+			...completed.delegatedUsage === void 0 ? {} : { delegatedUsage: completed.delegatedUsage }
+		};
+	})));
+	if (result === void 0) return yield* ModelProtocolError.make({ message: "Agent stream ended without RunCompleted" });
+	return result;
+});
+/**
+* Complete execution and close run-owned resources before returning the decoded result.
+* Caller-contributed requirements, including Scope, remain visible; services supplied by
+* application Layers retain their application's lifetime.
+*/
+const runProgram = Effect.fn("AgentRuntime.run")(function* (agent, events) {
+	return yield* reduceRunEvents(agent, events);
+});
+const startProgram = Effect.fn("AgentRuntime.start")(function* (agent, events, options) {
+	yield* Scope.Scope;
+	const bufferLimits = Object.freeze(effectiveRunBufferLimits(options.bufferLimits));
+	const executionOptionDescriptors = {
+		...Object.getOwnPropertyDescriptors(options),
+		bufferLimits: {
+			configurable: false,
+			enumerable: true,
+			value: bufferLimits,
+			writable: false
+		}
+	};
+	const executionOptions = Object.create(Object.getPrototypeOf(options), executionOptionDescriptors);
+	const captured = [];
+	const observationCapacity = bufferLimits.maxRunEvents + 1;
+	const pubsub = yield* PubSub.dropping({
+		capacity: observationCapacity,
+		replay: observationCapacity
+	});
+	yield* Effect.addFinalizer(() => PubSub.shutdown(pubsub));
+	let readUsage = Effect.succeed(RunUsageReport.make({
+		usage: emptyRunTotals(),
+		delegatedUsage: emptyRunTotals()
+	}));
+	const fiber = yield* reduceRunEvents(agent, (onCompleted) => events(executionOptions, onCompleted, (read) => {
+		readUsage = read;
+	}).pipe(Stream.tap((event) => Effect.suspend(() => {
+		captured.push(event);
+		return PubSub.publish(pubsub, [event]);
+	})))).pipe(Effect.onExit(() => Effect.suspend(() => readUsage).pipe(Effect.flatMap((report) => Effect.sync(() => {
+		readUsage = Effect.succeed(report);
+	})))), Effect.ensuring(PubSub.publish(pubsub, Exit.void))).pipe(Effect.forkScoped);
+	return {
+		await: Fiber.join(fiber),
+		events: Fiber.await(fiber).pipe(Effect.andThen(Effect.sync(() => captured.slice()))),
+		observe: Stream.fromPubSubTake(pubsub),
+		usageReport: Effect.suspend(() => readUsage)
+	};
+});
+/** Decode external input before instructions or model execution. */
+const streamUnknown = (agent, input, options) => streamWithCompletion(agent, input, options).pipe(Stream.provide(Layer.mergeAll(ModelUsageAccounting.layerEphemeral, AgentUpdateAcceptance.layerEphemeral)));
+/**
+* Host interpreter entry point with Attempt-local usage accounting and update acceptance in R.
+* Durable coordinators provide these services alongside their recovery hooks;
+* ordinary callers use streamUnknown's explicit ephemeral composition.
+*/
+const streamWithUsageAccountingUnknown = (agent, input, options) => streamWithCompletion(agent, input, options);
+/** 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 };
+	return runProgram(program, (onCompleted) => streamWithCompletion(agent, input, options, onCompleted).pipe(Stream.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 };
+	return startProgram(program, (executionOptions, onCompleted, onUsage) => streamWithCompletion(agent, input, executionOptions, onCompleted, onUsage).pipe(Stream.provide(Layer.mergeAll(ModelUsageAccounting.layerEphemeral, AgentUpdateAcceptance.layerEphemeral))), options);
+}
+/** Accept schema-encoded input, retaining runtime validation. Use startUnknown for external data. */
+const start = (agent, input, options) => startUnknown(agent, input, options);
+/**
+* Fail-closed Run-level `RunEventSink` default. Each Tool batch shadows it
+* with a live sink; any emission outside an active Tool batch fails with the
+* same typed error as emitting after a batch settled.
+*/
+const closedRunEventSink = { emit: (payload) => Effect.fail(RunEventSinkClosedError.make({ message: `Subagent event ${payload._tag} was emitted outside an active Tool batch` })) };
+/**
+* Fail-closed Run-level `DurableStep` default. Every executable Tool Call
+* shadows it with a live per-call service; a Step executed outside an active
+* Tool Call fails typed instead of silently running unrecorded.
+*/
+const closedDurableStep = { do: (name) => Effect.fail(DurableStepError.make({
+	stepName: name,
+	reason: "no-active-tool-call",
+	message: "Durable Step was executed outside an active Tool Call"
+})) };
+/**
+* Fail-closed Run-level `ToolBroker` default. Every executable Tool Call
+* shadows it with a live per-call service bound to that call's identity and
+* held permit; opening a pass outside an active Tool Call fails typed.
+*/
+const closedToolBroker = { openPass: () => Effect.fail(ToolBrokerUnavailableError.make({ message: "The programmatic Tool broker was used outside an active Tool Call" })) };
+const programmaticOutcomeError = (index, tag, message) => ({
+	_tag: "ProgrammaticCallError",
+	index,
+	errorTag: tag,
+	message
+});
+/** A call's typed failure captured as a value so defects stay defects. */
+var BrokerCallFailure = class {
+	error;
+	cause;
+	constructor(error, cause) {
+		this.error = error;
+		this.cause = cause;
+	}
+};
+/** Run-owned authorization with typed override failures preserved for broker projection. */
+var ProgrammaticToolAuthorization = class extends Context.Service()("@effect-agent/engine/internal/ProgrammaticToolAuthorization") {};
+/**
+* Measure one started programmatic handler with the same canonical span semantics as a
+* model-declared handler. A private marker gives value-level failures a failed exported status;
+* the marker is removed before the broker outcome returns, while an original Effect Cause is
+* restored unchanged outside the span.
+*/
+const stripProgrammaticToolSpanFailure = (cause, marker) => {
+	let found = false;
+	const residual = [];
+	for (const reason of cause.reasons) if (Cause.isFailReason(reason)) {
+		if (reason.error === marker) found = true;
+		else residual.push(Cause.makeDieReason(reason.error));
+	} else residual.push(reason);
+	return {
+		found,
+		residual: Cause.fromReasons(residual)
+	};
+};
+const measureProgrammaticToolCall = (telemetry, descriptor, effect) => Effect.suspend(() => {
+	const marker = ToolSpanFailure.marker();
+	let terminalResult;
+	let propagatedFailure;
+	const measured = Effect.exit(effect).pipe(Effect.flatMap((exit) => {
+		if (Exit.isFailure(exit)) {
+			if (exit.cause.reasons.length > 0 && exit.cause.reasons.every(Cause.isInterruptReason)) return Effect.failCause(exit.cause);
+			propagatedFailure = exit.cause;
+			return isolateToolDerivative(terminalToolTelemetry(descriptor, "failure", marker, "propagated")).pipe(Effect.andThen(Effect.fail(marker)));
+		}
+		terminalResult = exit.value;
+		const outcome = exit.value._tag === "ProgrammaticCallSuccess" ? "success" : "failure";
+		return isolateToolDerivative(terminalToolTelemetry(descriptor, outcome, outcome === "failure" ? marker : void 0, outcome === "failure" ? "returned-to-caller" : void 0)).pipe(Effect.andThen(outcome === "failure" ? Effect.fail(marker) : Effect.succeed(exit.value)));
+	}), Effect.withSpan(`execute_tool ${descriptor.toolName}`, {
+		kind: "internal",
+		attributes: toolTelemetryAttributes(descriptor)
+	}));
+	return telemetry.isolateEffectSpanLifecycle(measured).pipe(Effect.catchCause((cause) => {
+		const { found, residual } = stripProgrammaticToolSpanFailure(cause, marker);
+		const restored = propagatedFailure === void 0 ? residual : Cause.combine(propagatedFailure, residual);
+		if (!found) return Effect.failCause(restored);
+		if (restored.reasons.length > 0) return Effect.failCause(restored);
+		return terminalResult === void 0 ? Effect.die("Programmatic Tool telemetry completed without a terminal result") : Effect.succeed(terminalResult);
+	}));
+});
+const brokerSerializeJson = (value) => {
+	try {
+		const text = JSON.stringify(value);
+		return text === void 0 ? void 0 : {
+			text,
+			bytes: utf8ByteLength(text)
+		};
+	} catch {
+		return;
+	}
+};
+const emptyProgrammaticUsage = Response.Usage.make({
+	inputTokens: {},
+	outputTokens: {}
+});
+/** Hostile values can throw from trap getters mid-decode; stay fail-closed. */
+const brokerDecodeJson = (value) => {
+	try {
+		return Schema.decodeUnknownOption(Schema.Json)(value);
+	} catch {
+		return Option.none();
+	}
+};
+/**
+* Live per-outer-call `ToolBroker` (runtime spec §12.1; RUN-016, RUN-017).
+* The pass executes under the outer Tool Call's already-held scheduling
+* permit — invocations run in caller-owned structured fibers and acquire a finite
+* per-pass Semaphore, never the outer batch permit again. Execution indices are
+* allocated in invocation order before preflight, with gaps for rejected calls,
+* and every started call consumes the Run's Tool-call budgets before its
+* handler is invoked. Inner calls produce no Run events and no Canonical
+* Records. Trusted applications may explicitly observe non-propagating failures (RUN-036).
+*/
+const makeToolBrokerService = Effect.fnUntraced(function* (binding) {
+	const toolSpanTelemetry = yield* ToolSpanTelemetry;
+	const authorization = yield* ProgrammaticToolAuthorization;
+	const lifecycle = { closed: false };
+	const observer = binding.context.toolFailureObserver;
+	const preflightObserver = observer === void 0 ? void 0 : {
+		observer,
+		permits: Semaphore.makeUnsafe(1)
+	};
+	return {
+		service: { openPass: (toolkit, passOptions) => Effect.gen(function* () {
+			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 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);
+			const records = [];
+			const preflightFailure = (input, kind, tag, message, cause) => {
+				const outcome = programmaticOutcomeError(void 0, tag, message);
+				if (preflightObserver === void 0) return Effect.succeed(outcome);
+				return deliverToolFailure(preflightObserver.observer, {
+					_tag: "ProgrammaticPreflightFailure",
+					agentId: binding.context.agentId,
+					threadId: binding.context.threadId,
+					runId: binding.context.runId,
+					turnId: binding.turnId,
+					parentToolCallId: binding.outerToolCallId,
+					toolName: input.toolName,
+					...hasTool(toolkit.tools, input.toolName) ? { executionClass: getToolExecutionClass(toolkit.tools[input.toolName]) } : {},
+					kind,
+					tag,
+					message: toolFailureMessage(message),
+					...cause === void 0 ? {} : { cause }
+				}).pipe(preflightObserver.permits.withPermits(1), Effect.as(outcome));
+			};
+			const body = (input, sequenceIndex) => Effect.gen(function* () {
+				if (!hasTool(toolkit.tools, input.toolName)) return yield* preflightFailure(input, "infrastructure", "ProgrammaticToolUnknownError", `Tool ${input.toolName} is not part of this pass's allowlisted Toolkit`);
+				const tool = toolkit.tools[input.toolName];
+				if (Object.values(binding.context.definition.toolkit.tools).some((outer) => Context.get(outer.annotations, AdditionalToolCatalog).some((entry) => entry.tool.name === input.toolName)) && !binding.context.toolCatalog.some((entry) => entry.kind === "code-mode" && entry.tool.name === input.toolName)) return yield* preflightFailure(input, "infrastructure", "ProgrammaticToolAuthorizationDenied", "Tool is excluded by the current host visibility policy");
+				if (!isSubagentToolAllowed(inheritedAuthority?.grant, inheritedAuthority?.depth ?? 0, input.toolName, tool.annotations)) return yield* preflightFailure(input, "infrastructure", "ProgrammaticToolAuthorizationDenied", "Tool exceeds the inherited subagent grant");
+				if (Context.get(tool.annotations, ContextRolloverTool)) return yield* preflightFailure(input, "infrastructure", "ProgrammaticContextRolloverUnsupportedError", "Context rollover requires a direct, singleton model Tool Call");
+				const approval = tool.needsApproval;
+				if (approval !== void 0 && approval !== false) return yield* preflightFailure(input, "infrastructure", "ProgrammaticApprovalUnsupportedError", `Tool ${input.toolName} requires approval; approval-requiring Tools never start programmatically in the ephemeral slice`);
+				const invalidParameters = yield* Schema.decodeUnknownEffect(tool.parametersSchema)(input.encodedArguments).pipe(Effect.map(() => void 0), Effect.catchCauseFilter(Cause.findError, (error, cause) => preflightFailure(input, "protocol", "ModelProtocolError", `Invalid parameters for Tool ${input.toolName}: ${error.message}`, cause)));
+				if (invalidParameters !== void 0) return invalidParameters;
+				const handleId = ToolCallId.make(`${binding.outerToolCallId}#${sequenceIndex}`);
+				const denied = yield* authorization.authorize({
+					threadId: binding.context.threadId,
+					runId: binding.context.runId,
+					turnId: binding.turnId,
+					turn: binding.turn,
+					input: binding.context.input,
+					programmatic: {
+						parentToolCallId: binding.outerToolCallId,
+						sequenceIndex
+					},
+					call: {
+						toolCallId: handleId,
+						toolName: input.toolName,
+						parameters: input.encodedArguments,
+						executionClass: getToolExecutionClass(tool),
+						executionKind: getToolExecutionKind(tool.annotations)
+					}
+				}).pipe(Effect.flatMap((decision) => decision._tag === "allowed" ? Effect.succeed(void 0) : preflightFailure(input, "infrastructure", "ProgrammaticToolAuthorizationDenied", decision.reason)), Effect.catch((failure) => preflightFailure(input, "infrastructure", errorTag(failure.error), errorMessage(failure.error), failure.cause)));
+				if (denied !== void 0) return denied;
+				const rejected = yield* binding.context.policyReservations.withPermit(Effect.gen(function* () {
+					if (binding.declaredToolCalls + binding.context.programmaticToolCalls + 1 > binding.maxToolCalls) return yield* preflightFailure(input, "infrastructure", "AgentPolicyError", `Agent exceeded its ${binding.maxToolCalls} Tool Call limit`);
+					if (binding.budget !== void 0) {
+						const exhausted = yield* provideHookServices(binding.budget.consume({
+							modelCalls: 0,
+							inputTokens: 0,
+							outputTokens: 0,
+							totalTokens: 0,
+							toolCalls: 1,
+							costMicrousd: 0,
+							usage: emptyProgrammaticUsage
+						}), binding.hookServices).pipe(Effect.map(() => void 0), Effect.catchCauseFilter(Cause.findError, (error, cause) => Effect.succeed({
+							error,
+							cause
+						})));
+						if (exhausted !== void 0) return yield* preflightFailure(input, "infrastructure", errorTag(exhausted.error), errorMessage(exhausted.error), exhausted.cause);
+					}
+					binding.context.programmaticToolCalls += 1;
+					if (binding.reservePolicyUsage !== void 0) return yield* provideHookServices(binding.reservePolicyUsage({
+						programmaticToolCalls: binding.context.programmaticToolCalls,
+						finalizationUsed: binding.context.finalizationUsed
+					}), binding.hookServices).pipe(Effect.as(void 0), Effect.catchCauseFilter(Cause.findError, (error, cause) => preflightFailure(input, "infrastructure", errorTag(error), errorMessage(error), cause)));
+				}));
+				if (rejected !== void 0) return rejected;
+				const index = sequenceIndex;
+				records[sequenceIndex] = {
+					sequenceIndex,
+					toolName: input.toolName,
+					status: "uncertain"
+				};
+				const executionClass = getToolExecutionClass(tool);
+				let failureObservation;
+				const startedFailure = (kind, tag, message) => {
+					const outcome = programmaticOutcomeError(index, tag, message);
+					if (observer === void 0) return Effect.succeed(outcome);
+					failureObservation = {
+						_tag: "ProgrammaticToolFailure",
+						agentId: binding.context.agentId,
+						threadId: binding.context.threadId,
+						runId: binding.context.runId,
+						turnId: binding.turnId,
+						toolCallId: handleId,
+						parentToolCallId: binding.outerToolCallId,
+						sequenceIndex: index,
+						toolName: input.toolName,
+						executionClass,
+						kind,
+						tag,
+						message: toolFailureMessage(message)
+					};
+					return Effect.succeed(outcome);
+				};
+				const telemetryDescriptor = {
+					context: binding.context,
+					turnId: binding.turnId,
+					toolCallId: handleId,
+					toolName: input.toolName,
+					executionClass,
+					invocationKind: "programmatic",
+					failureMode: tool.failureMode,
+					parentToolCallId: binding.outerToolCallId,
+					sequenceIndex: index
+				};
+				const recorded = measureProgrammaticToolCall(toolSpanTelemetry, telemetryDescriptor, Effect.gen(function* () {
+					yield* Effect.logDebug("agent programmatic tool handler started").pipe(Effect.annotateLogs({
+						agentId: binding.context.agentId,
+						runId: binding.context.runId,
+						turnId: binding.turnId,
+						toolCallId: handleId,
+						parentToolCallId: binding.outerToolCallId,
+						toolName: input.toolName,
+						sequenceIndex: index
+					}));
+					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(() => {
+						if (terminal !== void 0) {
+							resultAfterTerminal = true;
+							return;
+						}
+						if (!result.preliminary) terminal = {
+							encodedResult: result.encodedResult,
+							isFailure: result.isFailure,
+							tag: observer === void 0 || !result.isFailure ? void 0 : errorTag(result.result)
+						};
+					})), Effect.map(() => void 0), Effect.catchCauseFilter(Cause.findError, (error, cause) => Effect.succeed(new BrokerCallFailure(error, cause))));
+					if (handlerFailed instanceof BrokerCallFailure) {
+						const tag = errorTag(handlerFailed.error);
+						if (observer !== void 0) failureObservation = {
+							_tag: "ProgrammaticToolFailure",
+							agentId: binding.context.agentId,
+							threadId: binding.context.threadId,
+							runId: binding.context.runId,
+							turnId: binding.turnId,
+							toolCallId: handleId,
+							parentToolCallId: binding.outerToolCallId,
+							sequenceIndex: index,
+							toolName: input.toolName,
+							executionClass,
+							kind: "handler-error",
+							tag,
+							cause: handlerFailed.cause
+						};
+						return programmaticOutcomeError(index, tag, errorMessage(handlerFailed.error));
+					}
+					if (resultAfterTerminal) return yield* startedFailure("protocol", "ModelProtocolError", `Tool Call ${handleId} produced more than one terminal result`);
+					if (terminal === void 0) return yield* startedFailure("protocol", "ModelProtocolError", `Tool Call ${handleId} completed without a terminal result`);
+					if (terminal.isFailure) {
+						if (observer !== void 0) failureObservation = {
+							_tag: "ProgrammaticToolFailure",
+							agentId: binding.context.agentId,
+							threadId: binding.context.threadId,
+							runId: binding.context.runId,
+							turnId: binding.turnId,
+							toolCallId: handleId,
+							parentToolCallId: binding.outerToolCallId,
+							sequenceIndex: index,
+							toolName: input.toolName,
+							executionClass,
+							kind: "declared-failure",
+							tag: terminal.tag ?? "UnknownError"
+						};
+						return {
+							_tag: "ProgrammaticCallFailure",
+							index,
+							encodedResult: terminal.encodedResult
+						};
+					}
+					if (Option.isNone(brokerDecodeJson(terminal.encodedResult))) return yield* startedFailure("protocol", "ModelProtocolError", `Tool ${input.toolName} produced a success encoding outside JSON`);
+					let encodedResult = terminal.encodedResult;
+					if (passOptions.redactResult !== void 0) {
+						const redacted = brokerDecodeJson(yield* passOptions.redactResult(encodedResult));
+						if (Option.isNone(redacted)) return yield* startedFailure("protocol", "ModelProtocolError", `The redacted result for Tool ${input.toolName} is outside the JSON surface`);
+						encodedResult = redacted.value;
+					}
+					const snapshot = brokerSerializeJson(encodedResult);
+					if (snapshot === void 0 || snapshot.bytes > passOptions.maxResultBytes) return yield* startedFailure("infrastructure", "ProgrammaticResultLimitError", `Tool ${input.toolName} result of ${snapshot?.bytes ?? "unencodable"} bytes exceeds the ${passOptions.maxResultBytes}-byte broker bound`);
+					const owned = Schema.decodeOption(Schema.fromJsonString(Schema.Json))(snapshot.text);
+					if (Option.isNone(owned)) return yield* startedFailure("protocol", "ModelProtocolError", `Tool ${input.toolName} produced a success encoding outside JSON`);
+					return {
+						_tag: "ProgrammaticCallSuccess",
+						index,
+						encodedResult: owned.value
+					};
+				})).pipe(Effect.tap((outcome) => Effect.sync(() => {
+					records[sequenceIndex] = {
+						sequenceIndex,
+						toolName: input.toolName,
+						status: outcome._tag === "ProgrammaticCallSuccess" ? "succeeded" : outcome._tag === "ProgrammaticCallFailure" ? "failed" : "uncertain",
+						...outcome._tag === "ProgrammaticCallError" ? { errorTag: outcome.errorTag } : {}
+					};
+				})));
+				return yield* observer === void 0 ? recorded : recorded.pipe(Effect.tap(() => failureObservation === void 0 ? Effect.void : deliverToolFailure(observer, failureObservation)));
+			}).pipe(Effect.provideContext(handlerServices));
+			return {
+				snapshot: Effect.sync(() => records.map((record) => ({ ...record }))),
+				invoke: (input) => Effect.suspend(() => {
+					const sequenceIndex = records.length;
+					records.push({
+						sequenceIndex,
+						toolName: input.toolName,
+						status: "not-started"
+					});
+					return permits.withPermit(Effect.suspend(() => lifecycle.closed ? preflightFailure(input, "infrastructure", "ToolBrokerUnavailableError", "The outer Tool Call for this pass has already settled") : body(input, sequenceIndex))).pipe(Effect.tap((outcome) => Effect.sync(() => {
+						if (outcome._tag === "ProgrammaticCallError" && outcome.index === void 0) records[sequenceIndex] = {
+							sequenceIndex,
+							toolName: input.toolName,
+							status: "not-started",
+							errorTag: outcome.errorTag
+						};
+					})));
+				})
+			};
+		}) },
+		close: () => {
+			lifecycle.closed = true;
+		}
+	};
+});
+/**
+* Ephemeral pass-through `DurableStep` provided when `RunOptions.durability`
+* is absent: each Step body executes exactly once in-process and nothing is
+* recorded. Durable Tools stay runnable on the ephemeral runtime with honest
+* (weaker) semantics — the durable claim attaches to the runtime, not the
+* Tool. Duplicate Step names remain the same typed identity conflict as under
+* the durable service so authoring bugs fail identically on both runtimes.
+*/
+const passthroughDurableStep = () => {
+	const usedNames = /* @__PURE__ */ new Set();
+	return { do: (name, _output, execute) => Effect.suspend(() => {
+		if (usedNames.has(name)) return Effect.fail(DurableStepError.make({
+			stepName: name,
+			reason: "duplicate-step-name",
+			message: "Durable Step name was reused within one Tool Call"
+		}));
+		usedNames.add(name);
+		return execute;
+	}) };
+};
+/**
+* Durable `DurableStep` service bound to one Tool Call over the coordinator's
+* `RunStepHook`.
+*
+* Semantics per durability §11: a committed result decodes through the
+* declared output Schema and returns without executing the body
+* (exactly-once-recorded); otherwise the body runs (at-least-once-executed —
+* a crash mid-body re-executes on the next Attempt and duplicate external
+* effects stay observable), the success is encoded through the Schema, and
+* only then committed. Failures are never recorded: a failing body fails the
+* Step call into the handler's error channel and re-entry re-executes it.
+* Step names must be deterministic and unique within one Tool Call; reuse is
+* a typed identity conflict because the second call would silently replay the
+* first call's recorded result. Hook failures and codec conflicts surface as
+* `DurableStepError` without widening the handler's error channel.
+*/
+/**
+* Provide a captured hook Context to a hook effect. TypeScript cannot reduce
+* the deferred conditional `Exclude<HookRequirements, HookRequirements>` on
+* an unresolved generic, so this private assertion pins the identity that
+* providing `Context<R>` to an `Effect<_, _, R>` leaves no requirements; it
+* never bypasses validation.
+*/
+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* () {
+		if (usedNames.has(name)) return yield* DurableStepError.make({
+			toolCallId,
+			stepName: name,
+			reason: "duplicate-step-name",
+			message: "Durable Step name was reused within one Tool Call"
+		});
+		usedNames.add(name);
+		const key = {
+			toolCallId,
+			stepName: name
+		};
+		const recorded = yield* provideHookServices(hook.lookup(key), hookServices).pipe(Effect.mapError((cause) => DurableStepError.make({
+			toolCallId,
+			stepName: name,
+			reason: "lookup-failed",
+			message: "Durable Step lookup failed",
+			cause
+		})));
+		if (Option.isSome(recorded)) return yield* Schema.decodeUnknownEffect(output)(recorded.value.encodedOutput).pipe(Effect.mapError(() => DurableStepError.make({
+			toolCallId,
+			stepName: name,
+			reason: "recorded-result-invalid",
+			message: "Recorded Durable Step result failed the declared output Schema"
+		})));
+		const value = yield* execute;
+		const encodedOutput = yield* Schema.encodeEffect(output)(value).pipe(Effect.mapError(() => DurableStepError.make({
+			toolCallId,
+			stepName: name,
+			reason: "output-encoding-failed",
+			message: "Durable Step output failed the declared output Schema"
+		})));
+		yield* provideHookServices(hook.commit(key, encodedOutput), hookServices).pipe(Effect.mapError((cause) => DurableStepError.make({
+			toolCallId,
+			stepName: name,
+			reason: "commit-failed",
+			message: "Durable Step commit failed",
+			cause
+		})));
+		return value;
+	}) };
+};
+/**
+* Typed engine-owned suspension signal raised by a delegation Tool handler
+* through the per-batch `SubagentDurability` service when its durable child
+* is established but not settled (S2 plan §2). It is NOT a Tool failure: the
+* batch executor treats the raising call as "stays open" — no terminal
+* result, no `ToolCallFailed`, no batch failure policy, no sibling
+* interruption — and terminates the Run with `AgentChildPending` after every
+* non-waiting sibling handler settled.
+*/
+var ToolCallWaiting = class extends Schema.TaggedError()("ToolCallWaiting", {
+	toolCallId: ToolCallId,
+	childThreadId: ThreadId,
+	childSubmissionId: SubmissionId,
+	childRunId: RunId,
+	receiptId: ReceiptId,
+	message: Schema.String
+}) {};
+/**
+* The Run suspended `waitingForChild`: at least one durable delegation call
+* of the last Tool batch is waiting on its attached child.
+* Mirrors `AgentApprovalPending`: the engine emits
+* `RunSuspended` and then fails the Run stream with this error; the durable
+* coordinator catches it and ends the Attempt's ownership period without
+* settling. `children` is listed in declaration order, deterministically.
+*/
+var AgentChildPending = class extends Schema.TaggedError()("AgentChildPending", {
+	children: Schema.NonEmptyArray(Schema.Struct({
+		toolCallId: ToolCallId,
+		childThreadId: ThreadId,
+		childSubmissionId: SubmissionId,
+		childRunId: RunId
+	})),
+	message: Schema.String
+}) {};
+/**
+* Typed failure of the engine-provided `SubagentDurability` operations.
+* `hook-failed` wraps a coordinator hook failure without leaking the hook's
+* error type into handler signatures (the `DurableStepError` precedent);
+* `no-active-tool-batch` is the fail-closed Run-level default — establishment
+* outside an active Tool batch never silently degrades to ephemeral spawning.
+*/
+var SubagentDurabilityError = class extends Schema.TaggedError()("SubagentDurabilityError", {
+	operation: Schema.Literals([
+		"establish",
+		"join",
+		"waiting"
+	]),
+	reason: Schema.Literals(["hook-failed", "no-active-tool-batch"]),
+	message: Schema.String.check(Schema.isMaxLength(4096)),
+	toolCallId: Schema.optionalKey(ToolCallId),
+	/** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/**
+* Engine-owned durable-Subagent seam provided locally to every Tool batch,
+* constructed from `RunOptions.subagent` when present and the explicit
+* ephemeral-mode default when absent. Like the other engine-provided Tool
+* services it is excluded from the runtime's public requirements and MUST NOT
+* be satisfied from an application Layer; handlers resolve it per call (the
+* S1 innermost re-provide pattern) so a Layer built inside another Run's
+* batch never captures a stale mode.
+*/
+var SubagentDurability = class extends Context.Service()("@effect-agent/engine/SubagentDurability") {};
+/** The one explicit ephemeral-mode value: absence of a durable coordinator is stated, not inferred. */
+const ephemeralSubagentDurability = { mode: "ephemeral" };
+const closedSubagentDurabilityFailure = (operation, toolCallId) => SubagentDurabilityError.make({
+	operation,
+	reason: "no-active-tool-batch",
+	message: `Durable Subagent ${operation} was invoked outside an active Tool batch`,
+	...toolCallId === void 0 ? {} : { toolCallId }
+});
+/**
+* Fail-closed Run-level `SubagentDurability` default. Each Tool batch shadows
+* it with its live per-batch service; resolving the seam outside an active
+* Tool batch fails typed instead of silently spawning an ephemeral child
+* under a durable coordinator.
+*/
+const closedSubagentDurability = {
+	mode: "durable",
+	establish: (request) => Effect.fail(closedSubagentDurabilityFailure("establish", request.toolCallId)),
+	join: (request) => Effect.fail(closedSubagentDurabilityFailure("join", request.toolCallId)),
+	waiting: (toolCallId) => Effect.fail(closedSubagentDurabilityFailure("waiting", toolCallId))
+};
+/**
+* Durable `SubagentDurability` service bound to one Tool batch over the
+* coordinator's `RunSubagentHook`. Hook failures surface as typed
+* `SubagentDurabilityError` values without widening handler error channels
+* (the coordinator keeps its own halt side channel, exactly like the Step
+* hook); `waiting` constructs the engine-owned `ToolCallWaiting` signal so a
+* handler can never counterfeit a foreign child identity shape.
+*/
+const makeSubagentDurabilityService = (hook, hookServices) => ({
+	mode: "durable",
+	establish: (request) => provideHookServices(hook.establish(request), hookServices).pipe(Effect.mapError((cause) => SubagentDurabilityError.make({
+		operation: "establish",
+		reason: "hook-failed",
+		toolCallId: request.toolCallId,
+		message: "Durable child establishment failed",
+		cause
+	}))),
+	join: (request) => provideHookServices(hook.join(request), hookServices).pipe(Effect.mapError((cause) => SubagentDurabilityError.make({
+		operation: "join",
+		reason: "hook-failed",
+		toolCallId: request.toolCallId,
+		message: "Durable child join failed",
+		cause
+	}))),
+	waiting: (toolCallId, child) => Effect.fail(ToolCallWaiting.make({
+		toolCallId,
+		childThreadId: child.childThreadId,
+		childSubmissionId: child.childSubmissionId,
+		childRunId: child.childRunId,
+		receiptId: child.receiptId,
+		message: `Tool Call ${toolCallId} is waiting on durable attached child ${child.childSubmissionId}`
+	}))
+});
+/**
+* Extract the waiting suspension signal from a handler cause. It normally
+* travels as a typed failure through the native `Toolkit.handle` error
+* channel; the squash fallback also recognizes it inside a defect so a
+* wrapped signal still suspends instead of manufacturing a Tool failure.
+*/
+const waitingFromCause = (cause) => {
+	const failure = Cause.findErrorOption(cause);
+	if (Option.isSome(failure) && failure.value instanceof ToolCallWaiting) return failure.value;
+	const squashed = Cause.squash(cause);
+	return squashed instanceof ToolCallWaiting ? squashed : void 0;
+};
+/**
+* Run one child Agent Binding through the same interpreter as a top-level
+* Run.
+*
+* The spawner allocates a fresh child `ThreadId` and `RunId` through
+* `IdGenerator` (guaranteeing a fresh child Thread per invocation, with
+* no Thread reuse), constructs the immutable Parent Link at
+* `depth + 1`, and starts the child eagerly with `AgentRuntime.start` inside
+* the caller-provided Scope, so parent interruption always reaches the child
+* and its finalizers. Preflight policy (including S1's normative
+* subtree reservation and inherited-grant checks) belongs to the delegation capability and runs
+* before `spawn` is called. Children inherit the parent Run's provided history and context
+* services; delegation handlers do not select separate host policies.
+*/
+const spawnWithParent = (parent, depth, history, preparation, onChild) => Effect.fn("AgentSpawner.spawn")(function* (binding, input, delegation, options) {
+	const ids = yield* IdGenerator$1;
+	const threadId = yield* ids.nextThreadId;
+	const runId = yield* ids.nextRunId;
+	const childDepth = yield* Schema.decodeEffect(DelegationDepth)(depth + 1).pipe(Effect.orDie);
+	const parentLink = SubagentParentLink.make({
+		delegationId: delegation.delegationId,
+		parentAgentId: parent.agentId,
+		parentThreadId: parent.threadId,
+		parentRunId: parent.runId,
+		parentToolCallId: delegation.parentToolCallId,
+		depth: childDepth
+	});
+	const child = yield* startUnknown(binding, input, {
+		...options,
+		threadId,
+		runId,
+		parentLink
+	}).pipe(Effect.provide(Context.make(ThreadHistory, history).pipe(Context.add(RunContextPreparation, preparation))));
+	onChild(runId, child.usageReport);
+	return {
+		...child,
+		threadId,
+		runId,
+		parentLink
+	};
+});
+/**
+* Engine-owned service contract through which a declared delegation Tool
+* runs an Attached Child on the same interpreter.
+*
+* The engine provides this service locally to every Run, bound to the Run's
+* immutable identity and delegation depth; it is never satisfied from an
+* application Layer, is excluded from the runtime's public requirements, and
+* exposes neither the engine's mutable Run state nor any root Layer Context.
+*/
+var AgentSpawner = class extends Context.Service()("@effect-agent/engine/AgentSpawner") {};
+const makeAgentSpawner = (parent, depth, history, preparation, policy, grant, budget, budgetScope, onChild = () => {}) => ({
+	...grant === void 0 ? {} : { grant },
+	...budget === void 0 ? {} : { budget },
+	...budgetScope === void 0 ? {} : { budgetScope },
+	policy,
+	depth,
+	parent,
+	spawn: spawnWithParent(parent, depth, history, preparation, onChild)
+});
+/** Bound applied to the rendered defect message of `withTerminalDefectEvent` (SEC-013). */
+const DEFECT_MESSAGE_LIMIT = 2048;
+/**
+* Opt-in boundary combinator (P7 §7(h), decision point 8): the engine keeps defects as
+* defects — `RunFailed` covers EXPECTED failures only, and a defect still fails the event
+* stream with its full Cause (AGENTS.md: errors are never silently widened, and a defect is
+* never converted into a typed failure by default). A host boundary that forwards Run Events
+* to a UI or transport can wrap the stream with this helper to append ONE bounded terminal
+* `RunFailed { errorTag: "Defect" }` event before the original cause is rethrown, so a viewer
+* always observes a terminal event even when the Run dies.
+*
+* Event contract:
+*
+* - typed failures and interruptions pass through untouched — the engine already emitted
+*   their terminal event, so nothing is duplicated;
+* - a cause carrying a defect first emits `RunFailed` with `errorTag: "Defect"` and a
+*   bounded string rendering of the defect (never the raw value; hosts owning stricter
+*   redaction apply it downstream), then RETHROWS the original cause unchanged;
+* - identity fields come from the last event already streamed (`sequence` advances by one);
+*   a defect BEFORE the first event has no Run identity to attribute, so it is rethrown
+*   without an event — the helper never fabricates identities.
+*/
+const withTerminalDefectEvent = (events) => Stream.suspend(() => {
+	let last;
+	return events.pipe(Stream.tap((event) => Effect.sync(() => {
+		last = event;
+	})), Stream.catchCause((cause) => {
+		const base = last;
+		if (base === void 0 || !Cause.hasDies(cause) || Cause.hasInterruptsOnly(cause)) return Stream.failCause(cause);
+		return Stream.fromEffect(Effect.gen(function* () {
+			const timestamp = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
+			return RunFailed.make({
+				eventVersion: 1,
+				runId: base.runId,
+				threadId: base.threadId,
+				agentId: base.agentId,
+				sequence: base.sequence + 1,
+				timestamp,
+				errorTag: "Defect",
+				message: errorMessage(Cause.squash(cause)).slice(0, DEFECT_MESSAGE_LIMIT)
+			});
+		})).pipe(Stream.concat(Stream.failCause(cause)));
+	}));
+});
+//#endregion
+//#region src/engine/AgentRuntime.ts
+var AgentRuntime_exports = /* @__PURE__ */ __exportAll({
+	AgentChildPending: () => AgentChildPending,
+	AgentResultSchema: () => AgentResultSchema,
+	AgentSpawner: () => AgentSpawner,
+	SubagentDurability: () => SubagentDurability,
+	SubagentDurabilityError: () => SubagentDurabilityError,
+	ToolCallWaiting: () => ToolCallWaiting,
+	decodeFinalOutput: () => decodeFinalOutput,
+	encodeRunDisposition: () => encodeRunDisposition,
+	projectCompletionFromToolOutput: () => projectCompletionFromToolOutput,
+	projectCompletionOutput: () => projectCompletionOutput,
+	renderInputPrompt: () => renderInputPrompt,
+	run: () => run,
+	runUnknown: () => runUnknown,
+	start: () => start,
+	startUnknown: () => startUnknown,
+	stream: () => stream,
+	streamUnknown: () => streamUnknown,
+	streamWithUsageAccountingUnknown: () => streamWithUsageAccountingUnknown,
+	withTerminalDefectEvent: () => withTerminalDefectEvent
+});
+//#endregion
+export { stream as _, SubagentDurability as a, withTerminalDefectEvent as b, decodeFinalOutput as c, projectCompletionOutput as d, renderInputPrompt as f, startUnknown as g, start as h, AgentSpawner as i, encodeRunDisposition as l, runUnknown as m, AgentChildPending as n, SubagentDurabilityError as o, run as p, AgentResultSchema as r, ToolCallWaiting as s, AgentRuntime_exports as t, projectCompletionFromToolOutput as u, streamUnknown as v, streamWithUsageAccountingUnknown as y };
+
+//# sourceMappingURL=AgentRuntime-BLyETCPo.mjs.map