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

package/dist/{AgentRuntime-B6qZlD3f.mjs → AgentRuntime-DaDKMasp.mjs}

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