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

package/src/engine/internal/agent-runtime.ts

@@ -763,8 +763,8 @@ const acceptTurnCommit = <E, R>(
       Effect.andThen(() => durability?.commitTurn(commit) ?? Effect.succeed("committed" as const)),
     );
 
-    return accepted.pipe(
-      Effect.flatMap((receipt) => {
+    return Effect.onExitPrimitive(
+      Effect.flatMap(accepted, (receipt) => {
         if (receipt === "deferred")
           return commit._tag === "Response" && commit.defer === true
             ? Effect.void
@@ -774,21 +774,19 @@ const acceptTurnCommit = <E, R>(
                 }),
               );
 
-        return Effect.sync(() => {
-          if (commit._tag !== "Partial") {
-            if (commit.response !== undefined) {
-              context.pendingCommitInputs.splice(0, trace.commitInputCount ?? 0);
-              trace.responseCommitted = true;
-            }
-            if (commit._tag === "Settled") trace.resultsCommitted = true;
+        if (commit._tag !== "Partial") {
+          if (commit.response !== undefined) {
+            context.pendingCommitInputs.splice(0, trace.commitInputCount ?? 0);
+            trace.responseCommitted = true;
           }
-        });
+          if (commit._tag === "Settled") trace.resultsCommitted = true;
+        }
+
+        return Effect.void;
       }),
-      Effect.onExit((exit) =>
-        Effect.sync(() => {
-          if (Exit.isFailure(exit)) trace.commitFailed = true;
-        }),
-      ),
+      (exit) => {
+        if (Exit.isFailure(exit)) trace.commitFailed = true;
+      },
     );
   });
 
@@ -1190,53 +1188,67 @@ const captureModelResponsePartGeneral = Effect.fnUntraced(function* <
   return { encodedPart: ownedEncoded, retainedBytes };
 });
 
-const captureModelResponsePart = <Tools extends Record<string, Tool.Any>>(
-  part: unknown,
-  toolkit: Toolkit.Toolkit<Tools>,
-  usage: ModelResponseBufferUsage,
-  limits: EffectiveRunBufferLimits,
-): ReturnType<typeof captureModelResponsePartGeneral> =>
-  Effect.suspend((): ReturnType<typeof captureModelResponsePartGeneral> => {
-    const primitive =
-      usage.responsePartCount < limits.maxModelResponseParts
-        ? capturePrimitiveTextPart(part, limits.maxModelResponseBytes - usage.responsePartBytes)
-        : undefined;
-
-    return primitive === undefined
-      ? captureModelResponsePartGeneral(part, toolkit, usage, limits)
-      : Effect.succeed(primitive);
-  });
-
 interface OwnedModelResponsePart {
   readonly ownedPart: Response.AnyPart;
   readonly retainedBytes: number;
 }
 
+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* <Tools extends Record<string, Tool.Any>>(
+const ownModelResponsePart = <Tools extends Record<string, Tool.Any>>(
   part: unknown,
   toolkit: Toolkit.Toolkit<Tools>,
   usage: ModelResponseBufferUsage,
   limits: EffectiveRunBufferLimits,
   finished: boolean,
-): Effect.fn.Return<OwnedModelResponsePart, ModelProtocolError> {
-  if (finished) {
-    return yield* ModelProtocolError.make({
-      message: "Model response emitted content after its finish part",
-    });
-  }
-  const captured = yield* captureModelResponsePart(part, toolkit, usage, limits);
+): Effect.Effect<OwnedModelResponsePart, ModelProtocolError> =>
+  Effect.suspend((): Effect.Effect<OwnedModelResponsePart, ModelProtocolError> => {
+    if (finished) {
+      return Effect.fail(
+        ModelProtocolError.make({
+          message: "Model response emitted content after its finish part",
+        }),
+      );
+    }
 
-  const ownedPart = yield* modelResponseParsersFor(toolkit)
-    .decode(captured.encodedPart)
-    .pipe(
-      Effect.mapError(() =>
-        ModelProtocolError.make({ message: "Model response part failed canonical decoding" }),
-      ),
-    );
+    const primitive =
+      usage.responsePartCount < limits.maxModelResponseParts
+        ? capturePrimitiveTextPart(part, limits.maxModelResponseBytes - usage.responsePartBytes)
+        : undefined;
 
-  return { ownedPart, retainedBytes: captured.retainedBytes };
-});
+    // Complete primitive snapshots need validation, but no defaults or transformation.
+    // Schema.toType retains every constraint from the native Response part schemas.
+    if (primitive !== undefined) {
+      return Effect.mapBothEager(decodePrimitiveModelResponsePart(primitive.part), {
+        onFailure: () =>
+          ModelProtocolError.make({ message: "Model response part failed canonical decoding" }),
+        onSuccess: (ownedPart) => ({ ownedPart, retainedBytes: primitive.retainedBytes }),
+      });
+    }
+
+    // Pending application codecs keep normal Effect execution in this same consumer fiber.
+    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 }),
+        }),
+    );
+  });
 
 type PartLifecycle = "open" | "closed";
 
@@ -2166,6 +2178,7 @@ const executePreparedToolCall = Effect.fnUntraced(function* <
     | AiError.AiError
     | Tool.HandlerError<ToolUnion<Tools>>;
   const call = prepared.call;
+  const toolCallId = prepared.toolCallId;
   const observer = context.toolFailureObserver;
   const telemetryToolCallId = isTelemetryToolCallId(call.id) ? call.id : undefined;
   const executionClass = getToolExecutionClass(prepared.tool);
@@ -2205,8 +2218,6 @@ const executePreparedToolCall = Effect.fnUntraced(function* <
   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,
@@ -2265,7 +2276,6 @@ const executePreparedToolCall = Effect.fnUntraced(function* <
           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) {
@@ -2302,7 +2312,6 @@ const executePreparedToolCall = Effect.fnUntraced(function* <
         message: `Tool Call ${call.id} completed without a terminal result`,
       });
     const result = terminalResult;
-    const toolCallId = yield* decodeToolCallId(call.id);
     let toolSelection: Selection | undefined;
 
     if (!result.isFailure && Context.get(prepared.tool.annotations, DiscoveryTool)) {
@@ -2318,7 +2327,7 @@ const executePreparedToolCall = Effect.fnUntraced(function* <
         context.toolSchemaTransformer,
       );
     }
-    const encodedResult = boundEncodedToolResult(result.encodedResult, resultBounds);
+    const encodedResult = yield* boundEncodedToolResult(result.encodedResult, resultBounds);
 
     // The ordinary JSON boundary remains required; only the public Class projection is optional.
     const successResult = result.isFailure
@@ -2882,12 +2891,26 @@ const executeToolBatch = Effect.fnUntraced(function* <
           ),
         { concurrency: group.length === 1 ? 1 : "unbounded", discard: true },
       );
-      yield* checkpointExecution(context, durability);
+      // Each following call checks before dispatch; the batch owner checks again
+      // after the final group, its cleanup, and the optional budget guard.
     }
   }).pipe(
-    Effect.provideService(RunEventSink, batchSink),
-    Effect.provideService(Emitter, updateEmitter),
-    Effect.provideService(SubagentDurability, batchSubagentDurability),
+    Effect.updateContext(
+      (
+        services: Context.Context<
+          | HookRequirements
+          | ToolSpanTelemetry
+          | ProgrammaticToolAuthorization
+          | Scope.Scope
+          | Tool.HandlerServices<ToolUnion<Tools>>
+        >,
+      ) =>
+        services.pipe(
+          Context.add(SubagentDurability, batchSubagentDurability),
+          Context.add(Emitter, updateEmitter),
+          Context.add(RunEventSink, batchSink),
+        ),
+    ),
     Effect.ensuring(
       Effect.sync(() => {
         updatesOpen = false;
@@ -3144,13 +3167,17 @@ const toolResultForJson = (tool: Tool.Any, result: Tool.HandlerResult<Tool.Any>)
   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: unknown, bounds: ToolResultBounds): unknown => {
+const boundEncodedToolResult = (
+  encodedResult: unknown,
+  bounds: ToolResultBounds,
+): Effect.Effect<unknown> => {
   let text: string | undefined;
 
   try {
@@ -3158,10 +3185,10 @@ const boundEncodedToolResult = (encodedResult: unknown, bounds: ToolResultBounds
   } catch (cause) {
     // Fail closed (runtime spec §9): an unserializable result is unbounded by
     // construction, so the sentinel replaces it before history or records.
-    return unserializableToolResult(cause);
+    return Effect.succeed(unserializableToolResult(cause));
   }
   if (text === undefined) {
-    return unserializableToolResult("the encoded result is not a JSON value");
+    return Effect.succeed(unserializableToolResult("the encoded result is not a JSON value"));
   }
   const bounded = applyToolResultBounds(text, bounds);
 
@@ -3169,12 +3196,8 @@ const boundEncodedToolResult = (encodedResult: unknown, bounds: ToolResultBounds
   // truncated and unmodified cases: returning the original object would let a
   // stateful `toJSON` pass the byte check small and expand or throw on later
   // canonical serialization, carrying unchecked state past the boundary.
-  try {
-    return Schema.decodeSync(Schema.fromJsonString(Schema.Unknown))(bounded);
-  } catch (cause) {
-    // Defensive only: `applyToolResultBounds` always emits valid JSON.
-    return unserializableToolResult(cause);
-  }
+  // Stay in the caller's Effect; a synchronous decoder would start another runtime fiber.
+  return decodeBoundedToolResult(bounded).pipe(Effect.orElseSucceed(unserializableToolResult));
 };
 
 const durableResultBounds = <E, R>(
@@ -3363,7 +3386,7 @@ const consumeUsage = <AgentValue extends Agent.Any, HookError, HookRequirements>
     // them separately. Separate that overlap before constructing the canonical,
     // additive input components, but retain the raw provider usage for pricing.
     const reportedInputTotal = providerUsage.inputTokens.total;
-    const reportedInputWithoutWrite = yield* decodeProviderUsageTotal(reportedUncached + cacheRead);
+    const reportedInputWithoutWrite = reportedUncached + cacheRead;
 
     const cacheWriteOverlapsUncached =
       reportedInputTotal !== undefined &&
@@ -3376,9 +3399,7 @@ const consumeUsage = <AgentValue extends Agent.Any, HookError, HookRequirements>
     const disjointReportedUncached =
       reportedUncached - (cacheWriteOverlapsUncached ? cacheWrite : 0);
 
-    const reportedInputComponents = yield* decodeProviderUsageTotal(
-      disjointReportedUncached + cacheRead + cacheWrite,
-    );
+    const reportedInputComponents = disjointReportedUncached + cacheRead + cacheWrite;
 
     const allInputComponentsReported =
       providerUsage.inputTokens.uncached !== undefined &&
@@ -3393,7 +3414,7 @@ const consumeUsage = <AgentValue extends Agent.Any, HookError, HookRequirements>
       return yield* invalidProviderUsage();
     }
     const inputTokens = reportedInputTotal ?? reportedInputComponents;
-    const reportedOutputComponents = yield* decodeProviderUsageTotal(reportedText + reasoning);
+    const reportedOutputComponents = reportedText + reasoning;
     const reportedOutputTotal = providerUsage.outputTokens.total;
 
     const allOutputComponentsReported =
@@ -3444,6 +3465,20 @@ const consumeUsage = <AgentValue extends Agent.Any, HookError, HookRequirements>
         ? outputRemainder
         : 0);
 
+    // Validate the complete additive components before pricing or staging usage.
+    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;
@@ -3511,17 +3546,8 @@ const consumeUsage = <AgentValue extends Agent.Any, HookError, HookRequirements>
       pricingStatus,
       ...(serviceTier === undefined ? {} : { serviceTier }),
       ...(pricingVersion === undefined ? {} : { pricingVersion }),
-      inputTokens: InputTokenUsage.make({
-        total: inputTokens,
-        uncached,
-        cacheRead: normalizedCacheRead,
-        cacheWrite: normalizedCacheWrite,
-      }),
-      outputTokens: OutputTokenUsage.make({
-        total: outputTokens,
-        text,
-        reasoning: normalizedReasoning,
-      }),
+      inputTokens: inputUsage,
+      outputTokens: outputUsage,
       costMicrousd,
     });
 
@@ -4605,30 +4631,26 @@ const decodeToolCallId = (id: string) =>
   );
 
 const decodeProviderToolCallId = (id: string) =>
-  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",
-        }),
-      ),
+  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: string) =>
-  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",
-        }),
-      ),
+  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.fnUntraced(function* (part: Response.AnyPart) {
+const validateProviderPartIdentifiers = Effect.fnUntracedEager(function* (part: Response.AnyPart) {
   switch (part.type) {
     case "text-start":
     case "text-delta":
@@ -4761,10 +4783,10 @@ const promptFromTurnParts = (trace: TurnTrace): Prompt.Prompt => {
   return Prompt.fromMessages(messages);
 };
 
-// `Effect.fnUntraced`: this dispatcher runs for every streamed Response Part,
-// so a named span here would emit one span per TextDelta/ReasoningDelta. The
-// enclosing model request keeps its `AgentRuntime.model` stream span.
-const processModelPart = Effect.fnUntraced(function* <Tools extends Record<string, Tool.Any>>(
+// Yield the returned Effect immediately and exactly once from the executing stream
+// consumer: construction runs the synchronous prefix, mutating trace counters and maps.
+// Application codecs and events still suspend. The enclosing model request owns the span.
+const processModelPart = Effect.fnUntracedEager(function* <Tools extends Record<string, Tool.Any>>(
   context: RunContext,
   turnId: TurnId,
   turn: number,
@@ -6385,7 +6407,7 @@ const makeTurn = <
             policy,
             context,
             prepareModelPrompt(
-              Prompt.fromMessages([...basis.content, ...transientContext.content]),
+              Prompt.concat(basis, transientContext),
               outputContract._tag === "rendered" ? outputContract.part : undefined,
               systemMessagesInHistory,
               staticInstructions,
@@ -6519,40 +6541,42 @@ const makeTurn = <
                           activeProvisionalText = provisionalText;
                         }),
                       ),
-                      Stream.runForEach((part) =>
+                      Stream.runForEachArray((parts) =>
                         Effect.gen(function* () {
-                          const owned = yield* ownModelResponsePart(
-                            part,
-                            agent.definition.toolkit,
-                            trace,
-                            context.bufferLimits,
-                            trace.finished,
-                          );
-
-                          const events = context.publish === undefined ? undefined : [];
-
-                          yield* processModelPart(
-                            context,
-                            turnId,
-                            turn,
-                            agent.definition.toolkit.tools,
-                            trace,
-                            owned.ownedPart,
-                            owned.retainedBytes,
-                            events,
-                          );
-                          if (provisionalText !== undefined) {
-                            const part = owned.ownedPart;
-
-                            if (
-                              part.type === "text-start" ||
-                              part.type === "text-delta" ||
-                              part.type === "text-end"
-                            )
-                              provisionalText.offerUnsafe(part);
+                          for (const part of parts) {
+                            const owned = yield* ownModelResponsePart(
+                              part,
+                              agent.definition.toolkit,
+                              trace,
+                              context.bufferLimits,
+                              trace.finished,
+                            );
+
+                            const events = context.publish === undefined ? undefined : [];
+
+                            yield* processModelPart(
+                              context,
+                              turnId,
+                              turn,
+                              agent.definition.toolkit.tools,
+                              trace,
+                              owned.ownedPart,
+                              owned.retainedBytes,
+                              events,
+                            );
+                            if (provisionalText !== undefined) {
+                              const part = owned.ownedPart;
+
+                              if (
+                                part.type === "text-start" ||
+                                part.type === "text-delta" ||
+                                part.type === "text-end"
+                              )
+                                provisionalText.offerUnsafe(part);
+                            }
+                            // Publish before accepting the next part. Backpressure stays interruptible.
+                            if (events !== undefined) yield* publishEvents(context, events);
                           }
-                          // Publish before accepting the next part. Backpressure stays interruptible.
-                          if (events !== undefined) yield* publishEvents(context, events);
                         }),
                       ),
                       <Value, Error, Requirements>(
@@ -6575,64 +6599,67 @@ const makeTurn = <
       // Retry the closed native provider operation. Admitted content makes the response
       // ineligible for retry; canonical acceptance belongs to the continuation below.
       const attemptWithRetries = Effect.suspend(() => attempt(compactedOutgoing())).pipe(
-        Effect.retry(($) =>
-          $(Schedule.exponential(MODEL_RETRY_BASE)).pipe(
-            Schedule.upTo({ times: policy.modelRetries ?? 0 }),
-            Schedule.while(({ input: error }) => {
-              const lastPart = trace.parts.at(-1);
-              const providerError: unknown = error;
-
-              return (
-                canRepeatModelCall &&
-                !hasStreamedContent(trace) &&
-                ((lastPart?.type === "error" && isTransientErrorPayload(lastPart.error)) ||
-                  (AiError.isAiError(providerError) && providerError.isRetryable))
-              );
-            }),
-            Schedule.modifyDelay(({ input: error, duration }) =>
-              Effect.gen(function* () {
-                const backoff = Duration.min(duration, MODEL_RETRY_MAX_DELAY);
-                const providerError: unknown = error;
+        (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: unknown = error;
+
+                    return (
+                      canRepeatModelCall &&
+                      !hasStreamedContent(trace) &&
+                      ((lastPart?.type === "error" && isTransientErrorPayload(lastPart.error)) ||
+                        (AiError.isAiError(providerError) && providerError.isRetryable))
+                    );
+                  }),
+                  Schedule.modifyDelay(({ input: error, duration }) =>
+                    Effect.gen(function* () {
+                      const backoff = Duration.min(duration, MODEL_RETRY_MAX_DELAY);
+                      const providerError: unknown = error;
 
-                const retryAfter = AiError.isAiError(providerError)
-                  ? providerError.retryAfter
-                  : undefined;
+                      const retryAfter = AiError.isAiError(providerError)
+                        ? providerError.retryAfter
+                        : undefined;
 
-                const requested =
-                  retryAfter === undefined ? backoff : Duration.max(backoff, retryAfter);
+                      const requested =
+                        retryAfter === undefined ? backoff : Duration.max(backoff, retryAfter);
 
-                // Expiration is rejected by the next native attempt. Capping only this delay
-                // keeps failed-attempt accounting and canonical hooks outside interruption timers.
-                const remaining = Math.max(
-                  0,
-                  context.durationDeadlineMillis - (yield* Clock.currentTimeMillis),
-                );
+                      // Expiration is rejected by the next native attempt. Capping only this delay
+                      // keeps failed-attempt accounting and canonical hooks outside interruption timers.
+                      const remaining = Math.max(
+                        0,
+                        context.durationDeadlineMillis - (yield* Clock.currentTimeMillis),
+                      );
 
-                return Duration.min(requested, Duration.millis(remaining));
-              }),
-            ),
-            Schedule.tap(({ input: error, attempt: retry, duration }) =>
-              Effect.gen(function* () {
-                trace.parts.length = 0;
-                trace.responsePartCount = 0;
-                trace.responsePartBytes = 0;
-                // The failed attempt's usage was already retained on exit.
-                trace.usage = undefined;
-                delete trace.response;
-                delete trace.finishMetadata;
-                yield* Effect.logWarning("agent model call retrying").pipe(
-                  Effect.annotateLogs({
-                    runId: context.runId,
-                    turnId,
-                    retry,
-                    delayMillis: Duration.toMillis(duration),
-                    error: errorMessage(error),
-                  }),
-                );
-              }),
-            ),
-          ),
-        ),
+                      return Duration.min(requested, Duration.millis(remaining));
+                    }),
+                  ),
+                  Schedule.tap(({ input: error, attempt: retry, duration }) =>
+                    Effect.gen(function* () {
+                      trace.parts.length = 0;
+                      trace.responsePartCount = 0;
+                      trace.responsePartBytes = 0;
+                      // The failed attempt's usage was already retained on exit.
+                      trace.usage = undefined;
+                      delete trace.response;
+                      delete trace.finishMetadata;
+                      yield* Effect.logWarning("agent model call retrying").pipe(
+                        Effect.annotateLogs({
+                          runId: context.runId,
+                          turnId,
+                          retry,
+                          delayMillis: Duration.toMillis(duration),
+                          error: errorMessage(error),
+                        }),
+                      );
+                    }),
+                  ),
+                ),
+              ),
       );
 
       // RUN-027: one summarize-and-retry for a classified provider context
@@ -7934,7 +7961,7 @@ const makeResumeTurn = <
             id: call.id,
             isFailure: true,
             result: yield* decodeEventJson(
-              boundEncodedToolResult(
+              yield* boundEncodedToolResult(
                 rejection.error,
                 durableResultBounds(agent.definition.policy.toolResultBounds, options, turn),
               ),
@@ -8578,10 +8605,9 @@ function executeWithCompletion<
 
       // Normalize the selected host policy at the Run boundary. Inner calls project typed
       // override failures into broker outcomes; native calls retain their original E channel.
-      const programmaticAuthorization = Layer.effect(
-        ProgrammaticToolAuthorization,
-        Effect.gen(function* () {
-          const services = yield* Effect.context<HookRequirements>();
+      const programmaticAuthorization = Effect.map(
+        Effect.context<HookRequirements>(),
+        (services) => {
           const selected = options.toolAuthorization;
 
           return ProgrammaticToolAuthorization.of({
@@ -8594,7 +8620,7 @@ function executeWithCompletion<
                     ),
                   ),
           });
-        }),
+        },
       );
 
       const interpreted = Effect.flatten(
@@ -9006,8 +9032,13 @@ function executeWithCompletion<
                         ),
                   );
 
-                  yield* checkpointExecution(context, options.durability);
-                  if (output._tag !== "NextTurn") return output;
+                  if (output._tag !== "NextTurn") {
+                    yield* checkpointExecution(context, options.durability);
+
+                    return output;
+                  }
+                  // Both Turn entry points check before any hook or dispatch. The
+                  // preceding Scope has closed, so that check also sees finalizer failures.
                   request = output;
                 }
 
@@ -9254,7 +9285,8 @@ function executeWithCompletion<
       const events = modeled.pipe(
         // The engine composition boundary owns span-lifecycle isolation while preserving the host's
         // ambient Tracer/Logger configuration. Individual Tool executions consume this capability.
-        Effect.provide(ToolSpanTelemetry.layer.pipe(Layer.provideMerge(programmaticAuthorization))),
+        Effect.provideServiceEffect(ToolSpanTelemetry, ToolSpanTelemetry.make),
+        Effect.provideServiceEffect(ProgrammaticToolAuthorization, programmaticAuthorization),
       );
 
       // Closing execution first joins every owned child and finalizer before validation,