veryfront 0.1.1289-rc.25708 → 0.1.1289-rc.25721

package/esm/src/agent/runtime/index.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import * as dntShim from "../../../_dnt.shims.js";
 import { MAX_RUNTIME_PROVIDER_STREAM_RETRIES } from "./provider-stream-retry-policy.js";
 import { introduceToolCallOccurrence, runWithToolCallOccurrenceDispatch, } from "../../runtime/tool-call-occurrence.js";
@@ -47,7 +99,7 @@ import { convertToTextGenerationRuntimeRequestMessages } from "./text-generation
 import { attachProviderMetadata, isProviderReplayDelivered, markProviderReplayDelivered, readAttachedProviderMetadata, } from "./provider-metadata.js";
 import { isRuntimeProviderSchemaHiddenTool } from "./local-tool.js";
 import { convertToolsToRuntimeTools } from "./model-tool-converter.js";
-import { bindRuntimeRemoteToolSourcesToCredentialOwner, constrainRuntimeRemoteToolSources, getRuntimeRemoteToolSources, getRuntimeUnavailableOptionalRemoteTools, } from "./mcp-server-tool-sources.js";
+import { bindRuntimeRemoteToolSourcesToCredentialOwner, constrainRuntimeRemoteToolSources, createRuntimeMcpSourceCleanup, getRuntimeRemoteToolSources, getRuntimeUnavailableOptionalRemoteTools, } from "./mcp-server-tool-sources.js";
 import { runWithRuntimeRemoteToolSources } from "./remote-tool-source-context.js";
 import { hasRuntimeObservationCapability, } from "../../runtime/runtime-observation-carrier.js";
 import { announceStreamedToolCallInput, createRuntimeStreamSource, createStreamState, processStream, resolveRelayableExecutionFailure, resolveRuntimeExecutionErrorEvent, withRuntimeProviderStreamErrorProvenance, } from "./chat-stream-handler.js";
@@ -1274,10 +1326,10 @@ function executeFrameworkToolSearch(input) {
                 ...result,
                 contract,
                 nextStep: isAvailable
-                    ? "This tool is already available. Call it with this input schema."
+                    ? "This tool is already available. Call it with this input schema. The output schema is the declared result contract, or null when absent."
                     : result.loadedCount > 0
-                        ? "This tool is loaded for the next step. Call it with this input schema."
-                        : "This is the exact input schema, but the tool could not be loaded within the current tool limit.",
+                        ? "This tool is loaded for the next step. Call it with this input schema. The output schema is the declared result contract, or null when absent."
+                        : "These are the exact declared schemas, but the tool could not be loaded within the current tool limit.",
             },
             checkpoint: checkpoint(),
         };
@@ -3244,869 +3296,882 @@ export class AgentRuntime {
     async #executeAgentLoop(// NOSONAR: Existing loop shape; this patch only adds authority cleanup.
     systemPrompt, messages, validateProviderRequest, persistMessage, prepareTerminalDispatch, toolContextBase, runtimeContext, runRuntimeContext, supportsToolCalling, providerReplayCheckpointEmission, modelString, resolvedModel, headers, providerOptions, reasoning, maxOutputTokensOverride, temperatureModelString, toolReplacements, abortSignal, outputSchema) {
         return withSpan("agent.execution_loop", async (loopSpan) => {
-            const { maxAgentSteps } = getPlatformCapabilities();
-            const maxSteps = this.computeMaxSteps(maxAgentSteps);
-            const effectiveModel = resolveRuntimeModel(modelString || this.config.model);
-            const languageModel = resolvedModel ?? resolveModel(effectiveModel);
-            const toolCalls = [];
-            const currentMessages = mapPrivateArray(messages, (message) => message);
-            applyProviderReplayCheckpointsToMessages(currentMessages, getRuntimeProviderReplayCheckpoints(this.config), { activeProvider: resolveActiveProviderReplayProvider(languageModel) });
-            const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
-            if (!supportsToolCalling && this.config.tools) {
-                warnUnsupportedToolCalling(this.id, effectiveModel);
-            }
-            // Request-scoped skill policy (not class-level mutable state)
-            const skillState = AgentLoopSkillState.hydrate(currentMessages, runtimeContext);
-            const hasToolReplacements = toolReplacements !== undefined;
-            const initialToolExposureCheckpoint = hasToolReplacements
-                ? undefined
-                : getRuntimeToolExposureCheckpoint(this.config);
-            const toolExposureState = createToolExposureState();
-            const persistToolExposureCheckpoint = hasToolReplacements
-                ? undefined
-                : getRuntimeToolExposureCheckpointPersister(this.config);
-            const requireToolExposureCheckpointPersistence = hasToolReplacements
-                ? false
-                : isRuntimeToolExposureCheckpointPersistenceRequired(this.config);
-            const runtimeToolsConfig = hasToolReplacements ? toolReplacements : this.config.tools;
-            const frameworkLocalTools = hasToolReplacements
-                ? undefined
-                : createRuntimeFrameworkLocalTools(this.config);
-            const toolLoadingResolution = resolveRuntimeToolLoading(this.config);
-            const runConfig = {
-                ...this.config,
-                __vfToolLoadingMode: hasToolReplacements ? "eager" : toolLoadingResolution.mode,
-            };
-            if (ObjectGetPrototypeOf(this.config) === null)
-                ObjectSetPrototypeOf(runConfig, null);
-            const runtimeStepConfig = hasToolReplacements
-                ? {
-                    ...runConfig,
-                    tools: runtimeToolsConfig,
-                    skills: undefined,
-                    bootstrapTools: undefined,
-                    optionalBootstrapTools: undefined,
-                    providerTools: undefined,
-                    mcpServers: undefined,
-                    sandbox: undefined,
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const { maxAgentSteps } = getPlatformCapabilities();
+                const maxSteps = this.computeMaxSteps(maxAgentSteps);
+                const effectiveModel = resolveRuntimeModel(modelString || this.config.model);
+                const languageModel = resolvedModel ?? resolveModel(effectiveModel);
+                const toolCalls = [];
+                const currentMessages = mapPrivateArray(messages, (message) => message);
+                applyProviderReplayCheckpointsToMessages(currentMessages, getRuntimeProviderReplayCheckpoints(this.config), { activeProvider: resolveActiveProviderReplayProvider(languageModel) });
+                const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+                if (!supportsToolCalling && this.config.tools) {
+                    warnUnsupportedToolCalling(this.id, effectiveModel);
                 }
-                : runConfig;
-            if (ObjectGetPrototypeOf(this.config) === null)
-                ObjectSetPrototypeOf(runtimeStepConfig, null);
-            const runtimeStepToolLoading = resolveRuntimeToolLoading(runtimeStepConfig);
-            const allowedRemoteToolNames = hasToolReplacements
-                ? undefined
-                : getRuntimeAllowedRemoteTools(this.config);
-            const forwardedRemoteToolDefinitions = hasToolReplacements
-                ? undefined
-                : getRuntimeForwardedIntegrationToolDefs(this.config);
-            const remoteToolSources = hasToolReplacements
-                ? undefined
-                : getRuntimeRemoteToolSources(this.config, undefined, this.id);
-            const unavailableOptionalRemoteTools = hasToolReplacements
-                ? { names: [], prefixes: [] }
-                : getRuntimeUnavailableOptionalRemoteTools(this.config, remoteToolSources);
-            const sourceIntegrationPolicy = hasToolReplacements
-                ? undefined
-                : getRuntimeSourceIntegrationPolicy(this.config);
-            const configuredProviderTools = hasToolReplacements
-                ? []
-                : getRuntimeProviderTools(this.config);
-            const toolResultContext = createActiveToolResultContext({
-                config: this.config,
-                hasToolReplacements,
-                supportsToolCalling,
-            });
-            const providerTools = sourceIntegrationPolicy
-                ? applySourceIntegrationPolicy(configuredProviderTools, sourceIntegrationPolicy)
-                : configuredProviderTools;
-            let currentSystemPrompt = systemPrompt;
-            let currentRuntimeContext = runtimeContext;
-            let agentWriteFinalResponseToolGuardEnabled = false;
-            let recoveredEmptyResponse = false;
-            let maxStepsParsedOutput;
-            // A submitted form continues a turn whose startup already ran, and the
-            // post-form skill policy forbids loading or switching skill bodies.
-            // Replacements suppress startup unless they retain the configured loader.
-            let startupSkillLoaded = (hasToolReplacements && replacementsRetainingSkillLoader.get(toolReplacements) !== true) ||
-                this.config.bootstrapSkill === undefined || skillState.hasSubmittedFormInput;
-            for (let step = 0; step < maxSteps; step++) {
-                throwIfAborted(abortSignal);
-                this.status = "thinking";
-                addSpanEvent(loopSpan, "step_start", { step });
-                const stepRuntimeContext = skillState.hasSubmittedFormInput
-                    ? markSubmittedFormInputRuntimeContext(currentRuntimeContext)
-                    : currentRuntimeContext;
-                const preparedStep = await prepareAgentRuntimeStep({
-                    agentId: this.id,
-                    activeSkillId: hasToolReplacements ? undefined : skillState.activeSkillId,
-                    activeSkillToolAvailability: hasToolReplacements
-                        ? undefined
-                        : skillState.activeSkillToolAvailability,
-                    allowedRemoteToolNames,
-                    config: runtimeStepConfig,
-                    effectiveModel,
-                    ...resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
-                    reservedToolSlots: getToolResultReaderReservedSlots(toolResultContext),
-                    excludedToolNames: agentWriteFinalResponseToolGuardEnabled &&
-                        runtimeStepToolLoading.mode === "eager"
-                        ? AGENT_WRITE_FINAL_RESPONSE_EXCLUDED_TOOL_NAMES
-                        : undefined,
-                    forwardedRemoteToolDefinitions,
-                    getAvailableTools,
-                    unavailableOptionalRemoteToolNames: unavailableOptionalRemoteTools.names,
-                    unavailableOptionalRemoteToolPrefixes: unavailableOptionalRemoteTools.prefixes,
+                // Request-scoped skill policy (not class-level mutable state)
+                const skillState = AgentLoopSkillState.hydrate(currentMessages, runtimeContext);
+                const hasToolReplacements = toolReplacements !== undefined;
+                const initialToolExposureCheckpoint = hasToolReplacements
+                    ? undefined
+                    : getRuntimeToolExposureCheckpoint(this.config);
+                const toolExposureState = createToolExposureState();
+                const persistToolExposureCheckpoint = hasToolReplacements
+                    ? undefined
+                    : getRuntimeToolExposureCheckpointPersister(this.config);
+                const requireToolExposureCheckpointPersistence = hasToolReplacements
+                    ? false
+                    : isRuntimeToolExposureCheckpointPersistenceRequired(this.config);
+                const runtimeToolsConfig = hasToolReplacements ? toolReplacements : this.config.tools;
+                const frameworkLocalTools = hasToolReplacements
+                    ? undefined
+                    : createRuntimeFrameworkLocalTools(this.config);
+                const toolLoadingResolution = resolveRuntimeToolLoading(this.config);
+                const runConfig = {
+                    ...this.config,
+                    __vfToolLoadingMode: hasToolReplacements ? "eager" : toolLoadingResolution.mode,
+                };
+                if (ObjectGetPrototypeOf(this.config) === null)
+                    ObjectSetPrototypeOf(runConfig, null);
+                const runtimeStepConfig = hasToolReplacements
+                    ? {
+                        ...runConfig,
+                        tools: runtimeToolsConfig,
+                        skills: undefined,
+                        bootstrapTools: undefined,
+                        optionalBootstrapTools: undefined,
+                        providerTools: undefined,
+                        mcpServers: undefined,
+                        sandbox: undefined,
+                    }
+                    : runConfig;
+                if (ObjectGetPrototypeOf(this.config) === null)
+                    ObjectSetPrototypeOf(runtimeStepConfig, null);
+                const runtimeStepToolLoading = resolveRuntimeToolLoading(runtimeStepConfig);
+                const allowedRemoteToolNames = hasToolReplacements
+                    ? undefined
+                    : getRuntimeAllowedRemoteTools(this.config);
+                const forwardedRemoteToolDefinitions = hasToolReplacements
+                    ? undefined
+                    : getRuntimeForwardedIntegrationToolDefs(this.config);
+                const remoteToolSources = hasToolReplacements
+                    ? undefined
+                    : getRuntimeRemoteToolSources(this.config, undefined, this.id);
+                const _remoteMcpCleanup = __addDisposableResource(env_1, createRuntimeMcpSourceCleanup(remoteToolSources), true);
+                const unavailableOptionalRemoteTools = hasToolReplacements
+                    ? { names: [], prefixes: [] }
+                    : getRuntimeUnavailableOptionalRemoteTools(this.config, remoteToolSources);
+                const sourceIntegrationPolicy = hasToolReplacements
+                    ? undefined
+                    : getRuntimeSourceIntegrationPolicy(this.config);
+                const configuredProviderTools = hasToolReplacements
+                    ? []
+                    : getRuntimeProviderTools(this.config);
+                const toolResultContext = createActiveToolResultContext({
+                    config: this.config,
+                    hasToolReplacements,
                     supportsToolCalling,
-                    includeStartupAuthorizedTools: !startupSkillLoaded,
-                    messages: currentMessages,
-                    mode: "generate",
-                    modelRuntime: languageModel,
-                    providerOptionKey: resolveModelProviderOptionKey(effectiveModel, languageModel),
-                    // The authorization catalog is independent of whether the model can
-                    // call tools; only the model-visible provider tools are withheld.
-                    authorizedProviderToolNames: providerTools,
-                    providerToolNames: supportsToolCalling && !agentWriteFinalResponseToolGuardEnabled
-                        ? providerTools
-                        : [],
-                    remoteToolSources,
-                    sourceIntegrationPolicy,
-                    resolveRuntimeState: this.resolveRuntimeState.bind(this),
-                    runtimeContext: stepRuntimeContext,
-                    step,
-                    systemPrompt: currentSystemPrompt,
-                    toolContextBase: { ...toolContextBase, abortSignal },
-                    strictConfiguredToolsOnly: hasToolReplacements,
-                    frameworkLocalTools,
-                    toolExposureState,
-                    toolExposureCheckpoint: step === 0 ? initialToolExposureCheckpoint : undefined,
                 });
-                throwIfAborted(abortSignal);
-                currentSystemPrompt = preparedStep.systemPrompt;
-                currentRuntimeContext = preparedStep.runtimeContext;
-                const toolContext = preparedStep.toolContext;
-                // Keep this snapshot fixed while calls from the same provider response execute.
-                const providerObservedSkillBodies = getProviderObservedSkillBodies(currentMessages);
-                let effectiveToolExposurePlan = agentWriteFinalResponseToolGuardEnabled
-                    ? applyAgentWriteFinalResponseGuard(preparedStep.toolExposurePlan, {
-                        reloadable: runtimeStepToolLoading.mode === "deferred",
-                    })
-                    : preparedStep.toolExposurePlan;
-                if (!startupSkillLoaded) {
-                    await executeStartupSkill({
+                const providerTools = sourceIntegrationPolicy
+                    ? applySourceIntegrationPolicy(configuredProviderTools, sourceIntegrationPolicy)
+                    : configuredProviderTools;
+                let currentSystemPrompt = systemPrompt;
+                let currentRuntimeContext = runtimeContext;
+                let agentWriteFinalResponseToolGuardEnabled = false;
+                let recoveredEmptyResponse = false;
+                let maxStepsParsedOutput;
+                // A submitted form continues a turn whose startup already ran, and the
+                // post-form skill policy forbids loading or switching skill bodies.
+                // Replacements suppress startup unless they retain the configured loader.
+                let startupSkillLoaded = (hasToolReplacements && replacementsRetainingSkillLoader.get(toolReplacements) !== true) ||
+                    this.config.bootstrapSkill === undefined || skillState.hasSubmittedFormInput;
+                for (let step = 0; step < maxSteps; step++) {
+                    throwIfAborted(abortSignal);
+                    this.status = "thinking";
+                    addSpanEvent(loopSpan, "step_start", { step });
+                    const stepRuntimeContext = skillState.hasSubmittedFormInput
+                        ? markSubmittedFormInputRuntimeContext(currentRuntimeContext)
+                        : currentRuntimeContext;
+                    const preparedStep = await prepareAgentRuntimeStep({
                         agentId: this.id,
-                        skillId: this.config.bootstrapSkill,
-                        authorized: preparedStep.startupAuthorizedTools,
+                        activeSkillId: hasToolReplacements ? undefined : skillState.activeSkillId,
+                        activeSkillToolAvailability: hasToolReplacements
+                            ? undefined
+                            : skillState.activeSkillToolAvailability,
+                        allowedRemoteToolNames,
+                        config: runtimeStepConfig,
+                        effectiveModel,
+                        ...resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
+                        reservedToolSlots: getToolResultReaderReservedSlots(toolResultContext),
+                        excludedToolNames: agentWriteFinalResponseToolGuardEnabled &&
+                            runtimeStepToolLoading.mode === "eager"
+                            ? AGENT_WRITE_FINAL_RESPONSE_EXCLUDED_TOOL_NAMES
+                            : undefined,
+                        forwardedRemoteToolDefinitions,
+                        getAvailableTools,
+                        unavailableOptionalRemoteToolNames: unavailableOptionalRemoteTools.names,
+                        unavailableOptionalRemoteToolPrefixes: unavailableOptionalRemoteTools.prefixes,
+                        supportsToolCalling,
+                        includeStartupAuthorizedTools: !startupSkillLoaded,
                         messages: currentMessages,
-                        persistMessage,
-                        skillState,
-                        toolCalls,
-                        resolveLoader: (name) => resolveConfiguredTool(runtimeToolsConfig, name, { agentId: this.id }),
-                        execute: async (toolName, toolCallId, args, admittedTurn) => {
-                            const context = applicationExecutionContext(toolContext);
-                            const result = await traceConfiguredToolExecution({
-                                mode: "generate",
-                                agentId: this.id,
-                                toolName,
-                                toolCallId,
-                                args,
-                                admittedTurn,
-                                owner: currentMessages,
-                                prepareTerminalDispatch,
-                                toolsConfig: runtimeToolsConfig,
-                                context,
-                                allowedRemoteToolNames,
-                                remoteToolSources,
-                                sourceIntegrationPolicy,
-                                frameworkLocalTools,
-                            });
-                            await this.notifyToolResult({
-                                mode: "generate",
-                                toolName,
-                                toolCallId,
-                                input: args,
-                                result,
-                                context,
-                            });
-                            return result;
-                        },
+                        mode: "generate",
+                        modelRuntime: languageModel,
+                        providerOptionKey: resolveModelProviderOptionKey(effectiveModel, languageModel),
+                        // The authorization catalog is independent of whether the model can
+                        // call tools; only the model-visible provider tools are withheld.
+                        authorizedProviderToolNames: providerTools,
+                        providerToolNames: supportsToolCalling && !agentWriteFinalResponseToolGuardEnabled
+                            ? providerTools
+                            : [],
+                        remoteToolSources,
+                        sourceIntegrationPolicy,
+                        resolveRuntimeState: this.resolveRuntimeState.bind(this),
+                        runtimeContext: stepRuntimeContext,
+                        step,
+                        systemPrompt: currentSystemPrompt,
+                        toolContextBase: { ...toolContextBase, abortSignal },
+                        strictConfiguredToolsOnly: hasToolReplacements,
+                        frameworkLocalTools,
+                        toolExposureState,
+                        toolExposureCheckpoint: step === 0 ? initialToolExposureCheckpoint : undefined,
                     });
-                    startupSkillLoaded = true;
-                    // Refresh the active skill policy without consuming a model step.
-                    step--;
-                    continue;
-                }
-                assertToolResultReaderNameAvailable({
-                    plan: effectiveToolExposurePlan,
-                    context: toolResultContext,
-                });
-                const baseSystemPrompt = currentSystemPrompt;
-                const assembleRequest = (messages, plan = effectiveToolExposurePlan) => assembleRuntimeStepRequest({
-                    messages,
-                    plan,
-                    toolResultContext,
-                    supportsToolCalling,
-                    agentWriteFinalResponseToolGuardEnabled,
-                    providerTools,
-                    model: effectiveModel,
-                    languageModel,
-                    toolSchemaOptions: resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
-                    baseSystemPrompt,
-                    integrationToolDiscovery: preparedStep.integrationToolDiscovery,
-                    runRuntimeContext,
-                    bootstrapToolNames: preparedStep.configuredBootstrapToolNames,
-                });
-                const requestedOutputTokens = this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride);
-                // An invalid thinking budget is left for the provider path to reject.
-                const additionalOutputTokens = resolveAdditiveReasoningOutputTokens(languageModel, {
-                    reasoning,
-                    providerOptions,
-                }) ?? 0;
-                const fittedRequest = await fitRuntimeStepRequestToServedBudget({
-                    sourceMessages: currentMessages,
-                    modelMessages: toolResultContext
-                        ? createModelToolResultContextMessages(currentMessages, toolResultContext)
-                        : currentMessages,
-                    plan: effectiveToolExposurePlan,
-                    assembleRequest,
-                    toolResultContext,
-                    supportsToolCalling,
-                    deferredToolLoading: runtimeStepToolLoading.mode === "deferred",
-                    languageModel,
-                    model: effectiveModel,
-                    reasoning,
-                    providerOptions,
-                    responseFormat: outputSchema?.responseFormat,
-                    requestedOutputTokens,
-                    explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
-                    additionalOutputTokens,
-                    toolExposureState,
-                    persistToolExposureCheckpoint,
-                    requireToolExposureCheckpointPersistence,
-                    turnAdmission: validateProviderRequest,
-                });
-                const modelMessages = fittedRequest.modelMessages;
-                effectiveToolExposurePlan = fittedRequest.plan;
-                if (this.#persistRecoveryBoundary) {
-                    await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
                     throwIfAborted(abortSignal);
-                }
-                const request = assembleRequest(modelMessages);
-                currentSystemPrompt = request.systemPrompt;
-                const { tools, runtimeTools, providerSystemPrompt, providerMessages } = request;
-                setSpanAttributes(loopSpan, {
-                    "tool.loading.mode": runtimeStepToolLoading.mode,
-                    "tool.loading.provenance": toolLoadingResolution.provenance,
-                    "tool.catalog.authorized_count": preparedStep.toolExposurePlan.authorized.length,
-                    "tool.catalog.visible_count": tools.length,
-                    "tool.catalog.deferred_count": effectiveToolExposurePlan.deferred.length,
-                    "tool.loading.path": "framework-fallback",
-                });
-                const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel, providerOptions);
-                const response = await withSpan("agent.generate_text", async (span) => {
-                    setSpanAttributes(span, {
-                        "model.id": effectiveModel,
-                        "messages.count": currentMessages.length,
+                    currentSystemPrompt = preparedStep.systemPrompt;
+                    currentRuntimeContext = preparedStep.runtimeContext;
+                    const toolContext = preparedStep.toolContext;
+                    // Keep this snapshot fixed while calls from the same provider response execute.
+                    const providerObservedSkillBodies = getProviderObservedSkillBodies(currentMessages);
+                    let effectiveToolExposurePlan = agentWriteFinalResponseToolGuardEnabled
+                        ? applyAgentWriteFinalResponseGuard(preparedStep.toolExposurePlan, {
+                            reloadable: runtimeStepToolLoading.mode === "deferred",
+                        })
+                        : preparedStep.toolExposurePlan;
+                    if (!startupSkillLoaded) {
+                        await executeStartupSkill({
+                            agentId: this.id,
+                            skillId: this.config.bootstrapSkill,
+                            authorized: preparedStep.startupAuthorizedTools,
+                            messages: currentMessages,
+                            persistMessage,
+                            skillState,
+                            toolCalls,
+                            resolveLoader: (name) => resolveConfiguredTool(runtimeToolsConfig, name, { agentId: this.id }),
+                            execute: async (toolName, toolCallId, args, admittedTurn) => {
+                                const context = applicationExecutionContext(toolContext);
+                                const result = await traceConfiguredToolExecution({
+                                    mode: "generate",
+                                    agentId: this.id,
+                                    toolName,
+                                    toolCallId,
+                                    args,
+                                    admittedTurn,
+                                    owner: currentMessages,
+                                    prepareTerminalDispatch,
+                                    toolsConfig: runtimeToolsConfig,
+                                    context,
+                                    allowedRemoteToolNames,
+                                    remoteToolSources,
+                                    sourceIntegrationPolicy,
+                                    frameworkLocalTools,
+                                });
+                                await this.notifyToolResult({
+                                    mode: "generate",
+                                    toolName,
+                                    toolCallId,
+                                    input: args,
+                                    result,
+                                    context,
+                                });
+                                return result;
+                            },
+                        });
+                        startupSkillLoaded = true;
+                        // Refresh the active skill policy without consuming a model step.
+                        step--;
+                        continue;
+                    }
+                    assertToolResultReaderNameAvailable({
+                        plan: effectiveToolExposurePlan,
+                        context: toolResultContext,
+                    });
+                    const baseSystemPrompt = currentSystemPrompt;
+                    const assembleRequest = (messages, plan = effectiveToolExposurePlan) => assembleRuntimeStepRequest({
+                        messages,
+                        plan,
+                        toolResultContext,
+                        supportsToolCalling,
+                        agentWriteFinalResponseToolGuardEnabled,
+                        providerTools,
+                        model: effectiveModel,
+                        languageModel,
+                        toolSchemaOptions: resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
+                        baseSystemPrompt,
+                        integrationToolDiscovery: preparedStep.integrationToolDiscovery,
+                        runRuntimeContext,
+                        bootstrapToolNames: preparedStep.configuredBootstrapToolNames,
                     });
-                    // Reject an over-budget request before the turn is accepted, so a
-                    // rejected input is rolled back instead of committed to memory.
-                    const { maxOutputTokens } = enforceProviderRequestBudget({
-                        model: languageModel,
-                        ...(reasoning === undefined ? {} : { reasoning }),
-                        ...(providerOptions === undefined ? {} : { providerOptions }),
-                        system: providerSystemPrompt,
-                        messages: providerMessages,
-                        tools: runtimeTools,
+                    const requestedOutputTokens = this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride);
+                    // An invalid thinking budget is left for the provider path to reject.
+                    const additionalOutputTokens = resolveAdditiveReasoningOutputTokens(languageModel, {
+                        reasoning,
+                        providerOptions,
+                    }) ?? 0;
+                    const fittedRequest = await fitRuntimeStepRequestToServedBudget({
+                        sourceMessages: currentMessages,
+                        modelMessages: toolResultContext
+                            ? createModelToolResultContextMessages(currentMessages, toolResultContext)
+                            : currentMessages,
+                        plan: effectiveToolExposurePlan,
+                        assembleRequest,
+                        toolResultContext,
+                        supportsToolCalling,
+                        deferredToolLoading: runtimeStepToolLoading.mode === "deferred",
+                        languageModel,
+                        model: effectiveModel,
+                        reasoning,
+                        providerOptions,
                         responseFormat: outputSchema?.responseFormat,
-                        limit: fittedRequest.servedLimit,
                         requestedOutputTokens,
                         explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
                         additionalOutputTokens,
+                        toolExposureState,
+                        persistToolExposureCheckpoint,
+                        requireToolExposureCheckpointPersistence,
+                        turnAdmission: validateProviderRequest,
                     });
-                    await validateProviderRequest(providerSystemPrompt, modelMessages, { beforeAcceptance: fittedRequest.commitToolExposure });
-                    const result = await generateText({
-                        model: languageModel,
-                        system: providerSystemPrompt,
-                        messages: providerMessages,
-                        tools: runtimeTools,
-                        experimental_repairToolCall: repairToolCall,
-                        maxOutputTokens,
-                        ...(temperature === undefined ? {} : { temperature }),
-                        ...(this.config.parallelToolCalls === undefined
-                            ? {}
-                            : { parallelToolCalls: this.config.parallelToolCalls }),
-                        ...(headers ? { headers } : {}),
-                        ...(providerOptions ? { providerOptions } : {}),
-                        ...(reasoning ? { reasoning } : {}),
-                        ...(outputSchema ? { responseFormat: outputSchema.responseFormat } : {}),
-                        abortSignal,
-                    });
-                    setSpanAttributes(span, buildRuntimeUsageTraceAttributes(result.usage));
-                    return result;
-                });
-                throwIfAborted(abortSignal);
-                // Accumulate usage
-                if (response.usage) {
-                    const input = response.usage.inputTokens ?? 0;
-                    const output = response.usage.outputTokens ?? 0;
-                    accumulateUsage(totalUsage, {
-                        promptTokens: input,
-                        completionTokens: output,
-                        totalTokens: response.usage.totalTokens ?? input + output,
-                        cachedInputTokens: response.usage.cachedInputTokens ??
-                            response.usage.cacheReadInputTokens,
-                        cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
-                        cacheCreation1hInputTokens: response.usage.cacheCreation1hInputTokens,
-                        cacheReadInputTokens: response.usage.cacheReadInputTokens,
-                        reasoningTokens: response.usage.reasoningTokens,
-                        billableInputTokens: response.usage.billableInputTokens,
-                        billableOutputTokens: response.usage.billableOutputTokens,
-                        costUsd: response.usage.costUsd,
-                        providerInputCostUsd: response.usage.providerInputCostUsd,
-                        providerOutputCostUsd: response.usage.providerOutputCostUsd,
-                        providerCostUsd: response.usage.providerCostUsd,
-                        veryfrontInputChargeUsd: response.usage.veryfrontInputChargeUsd,
-                        veryfrontOutputChargeUsd: response.usage.veryfrontOutputChargeUsd,
-                        veryfrontChargeUsd: response.usage.veryfrontChargeUsd,
-                        veryfrontBilledUsd: response.usage.veryfrontBilledUsd,
-                        costCredits: response.usage.costCredits,
-                        costSource: response.usage.costSource,
-                        billingMode: response.usage.billingMode,
-                        usageCaptureStatus: response.usage.usageCaptureStatus,
+                    const modelMessages = fittedRequest.modelMessages;
+                    effectiveToolExposurePlan = fittedRequest.plan;
+                    if (this.#persistRecoveryBoundary) {
+                        await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
+                        throwIfAborted(abortSignal);
+                    }
+                    const request = assembleRequest(modelMessages);
+                    currentSystemPrompt = request.systemPrompt;
+                    const { tools, runtimeTools, providerSystemPrompt, providerMessages } = request;
+                    setSpanAttributes(loopSpan, {
+                        "tool.loading.mode": runtimeStepToolLoading.mode,
+                        "tool.loading.provenance": toolLoadingResolution.provenance,
+                        "tool.catalog.authorized_count": preparedStep.toolExposurePlan.authorized.length,
+                        "tool.catalog.visible_count": tools.length,
+                        "tool.catalog.deferred_count": effectiveToolExposurePlan.deferred.length,
+                        "tool.loading.path": "framework-fallback",
                     });
-                    setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
-                }
-                const generatedToolResults = collectGeneratedToolResults(response.toolResults);
-                const generatedInvokeAgentBatch = providerReplayCheckpointEmission.complete
-                    ? collectGeneratedParallelInvokeAgentToolCalls(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, effectiveToolExposurePlan, {
-                        activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
-                        toolsConfig: runtimeToolsConfig,
-                        agentId: this.id,
-                        hasToolReplacements,
-                    })
-                    : undefined;
-                const generatedSkillDelegationOrder = generatedInvokeAgentBatch && !hasToolReplacements
-                    ? generatedSameTurnSkillDelegationOrder(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames)
-                    : undefined;
-                let generatedBatchCompletionDeferred = generatedSkillDelegationOrder === "prefix";
-                const assistantMessage = buildGeneratedAssistantMessage(response, {
-                    id: `msg_${Date.now()}_${step}`,
-                    timestamp: Date.now(),
-                });
-                const admittedTurn = snapshotAdmittedToolTurn(assistantMessage, currentMessages.length);
-                let generatedTurnAdmissionObserved = false;
-                let generatedTurnFinishObserved = false;
-                const observeGeneratedProviderTurnAdmissionOnce = async () => {
-                    if (generatedTurnAdmissionObserved)
-                        return;
-                    await observeGeneratedAgentTurn(assistantMessage.id, {
-                        ...response,
-                        finishReason: undefined,
-                        usage: undefined,
+                    const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel, providerOptions);
+                    const response = await withSpan("agent.generate_text", async (span) => {
+                        setSpanAttributes(span, {
+                            "model.id": effectiveModel,
+                            "messages.count": currentMessages.length,
+                        });
+                        // Reject an over-budget request before the turn is accepted, so a
+                        // rejected input is rolled back instead of committed to memory.
+                        const { maxOutputTokens } = enforceProviderRequestBudget({
+                            model: languageModel,
+                            ...(reasoning === undefined ? {} : { reasoning }),
+                            ...(providerOptions === undefined ? {} : { providerOptions }),
+                            system: providerSystemPrompt,
+                            messages: providerMessages,
+                            tools: runtimeTools,
+                            responseFormat: outputSchema?.responseFormat,
+                            limit: fittedRequest.servedLimit,
+                            requestedOutputTokens,
+                            explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
+                            additionalOutputTokens,
+                        });
+                        await validateProviderRequest(providerSystemPrompt, modelMessages, { beforeAcceptance: fittedRequest.commitToolExposure });
+                        const result = await generateText({
+                            model: languageModel,
+                            system: providerSystemPrompt,
+                            messages: providerMessages,
+                            tools: runtimeTools,
+                            experimental_repairToolCall: repairToolCall,
+                            maxOutputTokens,
+                            ...(temperature === undefined ? {} : { temperature }),
+                            ...(this.config.parallelToolCalls === undefined
+                                ? {}
+                                : { parallelToolCalls: this.config.parallelToolCalls }),
+                            ...(headers ? { headers } : {}),
+                            ...(providerOptions ? { providerOptions } : {}),
+                            ...(reasoning ? { reasoning } : {}),
+                            ...(outputSchema ? { responseFormat: outputSchema.responseFormat } : {}),
+                            abortSignal,
+                        });
+                        setSpanAttributes(span, buildRuntimeUsageTraceAttributes(result.usage));
+                        return result;
                     });
-                    generatedTurnAdmissionObserved = true;
-                };
-                const observeGeneratedProviderTurnFinishOnce = async (turn) => {
-                    if (generatedTurnFinishObserved)
-                        return;
-                    if (!generatedTurnAdmissionObserved) {
-                        await observeGeneratedAgentTurn(assistantMessage.id, withOutputSchemaObservationObject(turn));
-                        generatedTurnAdmissionObserved = true;
-                    }
-                    else {
-                        const structured = readStructuredAgentOutput(turn);
-                        await observeGeneratedAgentTurnFinish({
-                            finishReason: turn.finishReason,
-                            usage: turn.usage,
-                            ...(structured ? createOutputSchemaObservationFields(structured.data) : {}),
+                    throwIfAborted(abortSignal);
+                    // Accumulate usage
+                    if (response.usage) {
+                        const input = response.usage.inputTokens ?? 0;
+                        const output = response.usage.outputTokens ?? 0;
+                        accumulateUsage(totalUsage, {
+                            promptTokens: input,
+                            completionTokens: output,
+                            totalTokens: response.usage.totalTokens ?? input + output,
+                            cachedInputTokens: response.usage.cachedInputTokens ??
+                                response.usage.cacheReadInputTokens,
+                            cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
+                            cacheCreation1hInputTokens: response.usage.cacheCreation1hInputTokens,
+                            cacheReadInputTokens: response.usage.cacheReadInputTokens,
+                            reasoningTokens: response.usage.reasoningTokens,
+                            billableInputTokens: response.usage.billableInputTokens,
+                            billableOutputTokens: response.usage.billableOutputTokens,
+                            costUsd: response.usage.costUsd,
+                            providerInputCostUsd: response.usage.providerInputCostUsd,
+                            providerOutputCostUsd: response.usage.providerOutputCostUsd,
+                            providerCostUsd: response.usage.providerCostUsd,
+                            veryfrontInputChargeUsd: response.usage.veryfrontInputChargeUsd,
+                            veryfrontOutputChargeUsd: response.usage.veryfrontOutputChargeUsd,
+                            veryfrontChargeUsd: response.usage.veryfrontChargeUsd,
+                            veryfrontBilledUsd: response.usage.veryfrontBilledUsd,
+                            costCredits: response.usage.costCredits,
+                            costSource: response.usage.costSource,
+                            billingMode: response.usage.billingMode,
+                            usageCaptureStatus: response.usage.usageCaptureStatus,
                         });
+                        setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
                     }
-                    generatedTurnFinishObserved = true;
-                };
-                let generatedProviderReplayCheckpointPersisted = false;
-                const persistGeneratedProviderReplayCheckpoint = async () => {
-                    if (generatedProviderReplayCheckpointPersisted)
-                        return;
-                    await persistProviderReplayCheckpointAfterTurn({
-                        emission: providerReplayCheckpointEmission,
-                        providerMetadata: readAttachedProviderMetadata(assistantMessage),
-                        invokeAgentToolCalls: generatedSkillDelegationOrder === "interleaved"
-                            ? undefined
-                            : generatedInvokeAgentBatch,
-                        deferCompletion: generatedBatchCompletionDeferred,
-                    });
-                    generatedProviderReplayCheckpointPersisted = true;
-                };
-                pushPrivateArray(currentMessages, assistantMessage);
-                try {
-                    await persistMessage(assistantMessage);
-                }
-                catch (error) {
-                    await observeGeneratedProviderTurnFinishOnce(response);
-                    throw error;
-                }
-                const persistGeneratedToolResult = async (generatedToolResult) => {
-                    const executionAuthority = resolveToolExecutionAuthority({
-                        toolName: generatedToolResult.toolName,
-                        plan: effectiveToolExposurePlan,
+                    const generatedToolResults = collectGeneratedToolResults(response.toolResults);
+                    const generatedInvokeAgentBatch = providerReplayCheckpointEmission.complete
+                        ? collectGeneratedParallelInvokeAgentToolCalls(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, effectiveToolExposurePlan, {
+                            activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
+                            toolsConfig: runtimeToolsConfig,
+                            agentId: this.id,
+                            hasToolReplacements,
+                        })
+                        : undefined;
+                    const generatedSkillDelegationOrder = generatedInvokeAgentBatch && !hasToolReplacements
+                        ? generatedSameTurnSkillDelegationOrder(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames)
+                        : undefined;
+                    let generatedBatchCompletionDeferred = generatedSkillDelegationOrder === "prefix";
+                    const assistantMessage = buildGeneratedAssistantMessage(response, {
+                        id: `msg_${Date.now()}_${step}`,
+                        timestamp: Date.now(),
                     });
-                    const toolResultMessage = createPolicyAwareToolResultMessage(generatedToolResult.toolCallId, generatedToolResult.toolName, generatedToolResult.isError === true
-                        ? { error: stringifyToolError(generatedToolResult.result) }
-                        : generatedToolResult.result, executionAuthority?.toolDefinition, generatedToolResult.providerExecuted === true);
-                    pushPrivateArray(currentMessages, toolResultMessage);
-                    await persistMessage(toolResultMessage);
-                    throwIfAborted(abortSignal);
-                };
-                const rejectUnpairedRequestScopedGeneratedToolResult = async (generatedToolResult) => {
-                    if (!hasToolReplacements) {
-                        return false;
-                    }
-                    const error = `Tool "${generatedToolResult.toolName}" is not available in request-scoped replacement tools`;
-                    const toolCall = {
-                        id: generatedToolResult.toolCallId,
-                        name: generatedToolResult.toolName,
-                        args: {},
-                        status: "error",
-                        error,
+                    const admittedTurn = snapshotAdmittedToolTurn(assistantMessage, currentMessages.length);
+                    let generatedTurnAdmissionObserved = false;
+                    let generatedTurnFinishObserved = false;
+                    const observeGeneratedProviderTurnAdmissionOnce = async () => {
+                        if (generatedTurnAdmissionObserved)
+                            return;
+                        await observeGeneratedAgentTurn(assistantMessage.id, {
+                            ...response,
+                            finishReason: undefined,
+                            usage: undefined,
+                        });
+                        generatedTurnAdmissionObserved = true;
                     };
-                    pushPrivateArray(toolCalls, toolCall);
-                    const errorMessage = createToolErrorMessage(generatedToolResult.toolCallId, generatedToolResult.toolName, error);
-                    pushPrivateArray(currentMessages, errorMessage);
-                    await persistMessage(errorMessage);
-                    return true;
-                };
-                if (!response.toolCalls?.length) {
-                    try {
-                        for (const generatedToolResult of generatedToolResults.values()) {
-                            if (await rejectUnpairedRequestScopedGeneratedToolResult(generatedToolResult)) {
-                                continue;
-                            }
-                            await persistGeneratedToolResult(generatedToolResult);
+                    const observeGeneratedProviderTurnFinishOnce = async (turn) => {
+                        if (generatedTurnFinishObserved)
+                            return;
+                        if (!generatedTurnAdmissionObserved) {
+                            await observeGeneratedAgentTurn(assistantMessage.id, withOutputSchemaObservationObject(turn));
+                            generatedTurnAdmissionObserved = true;
                         }
+                        else {
+                            const structured = readStructuredAgentOutput(turn);
+                            await observeGeneratedAgentTurnFinish({
+                                finishReason: turn.finishReason,
+                                usage: turn.usage,
+                                ...(structured ? createOutputSchemaObservationFields(structured.data) : {}),
+                            });
+                        }
+                        generatedTurnFinishObserved = true;
+                    };
+                    let generatedProviderReplayCheckpointPersisted = false;
+                    const persistGeneratedProviderReplayCheckpoint = async () => {
+                        if (generatedProviderReplayCheckpointPersisted)
+                            return;
+                        await persistProviderReplayCheckpointAfterTurn({
+                            emission: providerReplayCheckpointEmission,
+                            providerMetadata: readAttachedProviderMetadata(assistantMessage),
+                            invokeAgentToolCalls: generatedSkillDelegationOrder === "interleaved"
+                                ? undefined
+                                : generatedInvokeAgentBatch,
+                            deferCompletion: generatedBatchCompletionDeferred,
+                        });
+                        generatedProviderReplayCheckpointPersisted = true;
+                    };
+                    pushPrivateArray(currentMessages, assistantMessage);
+                    try {
+                        await persistMessage(assistantMessage);
                     }
                     catch (error) {
                         await observeGeneratedProviderTurnFinishOnce(response);
-                        await persistGeneratedProviderReplayCheckpoint();
                         throw error;
                     }
-                    const stoppedEmptyAfterCompletedTool = response.finishReason === "stop" &&
-                        !hasSubstantiveAssistantText(response.text) &&
-                        generatedToolResults.size === 0 &&
-                        somePrivateArray(toolCalls, (toolCall) => toolCall.status === "completed");
-                    if (stoppedEmptyAfterCompletedTool) {
-                        await observeGeneratedProviderTurnFinishOnce(response);
-                        await persistGeneratedProviderReplayCheckpoint();
+                    const persistGeneratedToolResult = async (generatedToolResult) => {
+                        const executionAuthority = resolveToolExecutionAuthority({
+                            toolName: generatedToolResult.toolName,
+                            plan: effectiveToolExposurePlan,
+                        });
+                        const toolResultMessage = createPolicyAwareToolResultMessage(generatedToolResult.toolCallId, generatedToolResult.toolName, generatedToolResult.isError === true
+                            ? { error: stringifyToolError(generatedToolResult.result) }
+                            : generatedToolResult.result, executionAuthority?.toolDefinition, generatedToolResult.providerExecuted === true);
+                        pushPrivateArray(currentMessages, toolResultMessage);
+                        await persistMessage(toolResultMessage);
                         throwIfAborted(abortSignal);
-                        if (recoveredEmptyResponse || step + 1 >= maxSteps) {
-                            throw new RuntimeEmptyResponseError();
+                    };
+                    const rejectUnpairedRequestScopedGeneratedToolResult = async (generatedToolResult) => {
+                        if (!hasToolReplacements) {
+                            return false;
                         }
-                        recoveredEmptyResponse = true;
-                        pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
-                            id: `runtime_empty_response_${Date.now()}_${step}`,
-                            role: "user",
-                            parts: [{
-                                    type: "text",
-                                    text: EMPTY_RESPONSE_RECOVERY_PROMPT,
-                                }],
-                            timestamp: Date.now(),
-                        }));
-                        continue;
-                    }
-                    this.status = "completed";
-                    addSpanEvent(loopSpan, "loop_complete");
-                    setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
-                    let parsedObject;
-                    if (outputSchema) {
+                        const error = `Tool "${generatedToolResult.toolName}" is not available in request-scoped replacement tools`;
+                        const toolCall = {
+                            id: generatedToolResult.toolCallId,
+                            name: generatedToolResult.toolName,
+                            args: {},
+                            status: "error",
+                            error,
+                        };
+                        pushPrivateArray(toolCalls, toolCall);
+                        const errorMessage = createToolErrorMessage(generatedToolResult.toolCallId, generatedToolResult.toolName, error);
+                        pushPrivateArray(currentMessages, errorMessage);
+                        await persistMessage(errorMessage);
+                        return true;
+                    };
+                    if (!response.toolCalls?.length) {
                         try {
-                            parsedObject = await outputSchema.parseOutput(response.text);
+                            for (const generatedToolResult of generatedToolResults.values()) {
+                                if (await rejectUnpairedRequestScopedGeneratedToolResult(generatedToolResult)) {
+                                    continue;
+                                }
+                                await persistGeneratedToolResult(generatedToolResult);
+                            }
                         }
                         catch (error) {
-                            await observeGeneratedAgentOutputSchemaRejection(assistantMessage.id, response);
+                            await observeGeneratedProviderTurnFinishOnce(response);
                             await persistGeneratedProviderReplayCheckpoint();
                             throw error;
                         }
-                    }
-                    await observeGeneratedProviderTurnFinishOnce({
-                        ...response,
-                        ...(outputSchema ? { data: parsedObject, object: parsedObject } : {}),
-                    });
-                    await persistGeneratedProviderReplayCheckpoint();
-                    throwIfAborted(abortSignal);
-                    return attachOutputSchemaParser({
-                        text: response.text,
-                        ...(outputSchema ? { data: parsedObject, object: parsedObject } : {}),
-                        messages: currentMessages,
-                        toolCalls,
-                        status: this.status,
-                        usage: totalUsage,
-                        metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, response.finishReason ? { finishReason: response.finishReason } : undefined),
-                    }, outputSchema);
-                }
-                const isFinalMaxStepsToolTurn = step + 1 >= maxSteps;
-                try {
-                    if (isFinalMaxStepsToolTurn) {
-                        await observeGeneratedProviderTurnAdmissionOnce();
-                    }
-                    else {
-                        await observeGeneratedProviderTurnFinishOnce(response);
-                    }
-                    await persistGeneratedProviderReplayCheckpoint();
-                    throwIfAborted(abortSignal);
-                    this.status = "tool_execution";
-                    addSpanEvent(loopSpan, "tool_execution_start", { count: response.toolCalls.length });
-                    for (let toolCallIndex = 0; toolCallIndex < response.toolCalls.length; toolCallIndex++) {
-                        if (!ObjectHasOwn(response.toolCalls, toolCallIndex))
+                        const stoppedEmptyAfterCompletedTool = response.finishReason === "stop" &&
+                            !hasSubstantiveAssistantText(response.text) &&
+                            generatedToolResults.size === 0 &&
+                            somePrivateArray(toolCalls, (toolCall) => toolCall.status === "completed");
+                        if (stoppedEmptyAfterCompletedTool) {
+                            await observeGeneratedProviderTurnFinishOnce(response);
+                            await persistGeneratedProviderReplayCheckpoint();
+                            throwIfAborted(abortSignal);
+                            if (recoveredEmptyResponse || step + 1 >= maxSteps) {
+                                throw new RuntimeEmptyResponseError();
+                            }
+                            recoveredEmptyResponse = true;
+                            pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
+                                id: `runtime_empty_response_${Date.now()}_${step}`,
+                                role: "user",
+                                parts: [{
+                                        type: "text",
+                                        text: EMPTY_RESPONSE_RECOVERY_PROMPT,
+                                    }],
+                                timestamp: Date.now(),
+                            }));
                             continue;
-                        const tc = response.toolCalls[toolCallIndex];
+                        }
+                        this.status = "completed";
+                        addSpanEvent(loopSpan, "loop_complete");
+                        setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
+                        let parsedObject;
+                        if (outputSchema) {
+                            try {
+                                parsedObject = await outputSchema.parseOutput(response.text);
+                            }
+                            catch (error) {
+                                await observeGeneratedAgentOutputSchemaRejection(assistantMessage.id, response);
+                                await persistGeneratedProviderReplayCheckpoint();
+                                throw error;
+                            }
+                        }
+                        await observeGeneratedProviderTurnFinishOnce({
+                            ...response,
+                            ...(outputSchema ? { data: parsedObject, object: parsedObject } : {}),
+                        });
+                        await persistGeneratedProviderReplayCheckpoint();
                         throwIfAborted(abortSignal);
-                        const toolCall = {
-                            id: tc.toolCallId,
-                            name: tc.toolName,
-                            args: tc.input,
-                            status: "pending",
-                        };
-                        const generatedToolResult = generatedToolResults.get(tc.toolCallId);
-                        if (generatedBatchCompletionDeferred && generatedToolResult === undefined &&
-                            IntrinsicReflectApply(IntrinsicSetHas, providerReplayCheckpointEmission.invokeAgentToolNames, [tc.toolName])) {
-                            await completeDeferredProviderReplayCheckpointTurn(providerReplayCheckpointEmission, collectGeneratedParallelInvokeAgentToolCalls(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, effectiveToolExposurePlan, {
-                                activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
-                                toolsConfig: runtimeToolsConfig,
-                                agentId: this.id,
-                                hasToolReplacements,
-                            }));
-                            generatedBatchCompletionDeferred = false;
+                        return attachOutputSchemaParser({
+                            text: response.text,
+                            ...(outputSchema ? { data: parsedObject, object: parsedObject } : {}),
+                            messages: currentMessages,
+                            toolCalls,
+                            status: this.status,
+                            usage: totalUsage,
+                            metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, response.finishReason ? { finishReason: response.finishReason } : undefined),
+                        }, outputSchema);
+                    }
+                    const isFinalMaxStepsToolTurn = step + 1 >= maxSteps;
+                    try {
+                        if (isFinalMaxStepsToolTurn) {
+                            await observeGeneratedProviderTurnAdmissionOnce();
                         }
-                        await withSpan("agent.tool_execute", async (toolSpan) => {
-                            const inputSizeBytes = estimateSerializedSizeBytes(tc.input);
-                            setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
-                                "tool.name": tc.toolName,
-                                "tool.call.id": tc.toolCallId,
-                                "tool.id": tc.toolCallId,
-                                "tool.status": "executing",
-                                "tool.input.size_bytes": inputSizeBytes,
-                                "gen_ai.operation.name": "execute_tool",
-                                "gen_ai.tool.name": tc.toolName,
-                                "gen_ai.tool.type": "function",
-                                "gen_ai.tool.call.id": tc.toolCallId,
-                            }));
-                            const executionAuthority = resolveToolExecutionAuthority({
-                                toolName: tc.toolName,
-                                plan: effectiveToolExposurePlan,
-                            });
-                            if (generatedToolResult === undefined &&
-                                shouldHandleToolResultRead({
+                        else {
+                            await observeGeneratedProviderTurnFinishOnce(response);
+                        }
+                        await persistGeneratedProviderReplayCheckpoint();
+                        throwIfAborted(abortSignal);
+                        this.status = "tool_execution";
+                        addSpanEvent(loopSpan, "tool_execution_start", { count: response.toolCalls.length });
+                        for (let toolCallIndex = 0; toolCallIndex < response.toolCalls.length; toolCallIndex++) {
+                            if (!ObjectHasOwn(response.toolCalls, toolCallIndex))
+                                continue;
+                            const tc = response.toolCalls[toolCallIndex];
+                            throwIfAborted(abortSignal);
+                            const toolCall = {
+                                id: tc.toolCallId,
+                                name: tc.toolName,
+                                args: tc.input,
+                                status: "pending",
+                            };
+                            const generatedToolResult = generatedToolResults.get(tc.toolCallId);
+                            if (generatedBatchCompletionDeferred && generatedToolResult === undefined &&
+                                IntrinsicReflectApply(IntrinsicSetHas, providerReplayCheckpointEmission.invokeAgentToolNames, [tc.toolName])) {
+                                await completeDeferredProviderReplayCheckpointTurn(providerReplayCheckpointEmission, collectGeneratedParallelInvokeAgentToolCalls(response.toolCalls, generatedToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, effectiveToolExposurePlan, {
+                                    activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
+                                    toolsConfig: runtimeToolsConfig,
+                                    agentId: this.id,
+                                    hasToolReplacements,
+                                }));
+                                generatedBatchCompletionDeferred = false;
+                            }
+                            await withSpan("agent.tool_execute", async (toolSpan) => {
+                                const inputSizeBytes = estimateSerializedSizeBytes(tc.input);
+                                setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
+                                    "tool.name": tc.toolName,
+                                    "tool.call.id": tc.toolCallId,
+                                    "tool.id": tc.toolCallId,
+                                    "tool.status": "executing",
+                                    "tool.input.size_bytes": inputSizeBytes,
+                                    "gen_ai.operation.name": "execute_tool",
+                                    "gen_ai.tool.name": tc.toolName,
+                                    "gen_ai.tool.type": "function",
+                                    "gen_ai.tool.call.id": tc.toolCallId,
+                                }));
+                                const executionAuthority = resolveToolExecutionAuthority({
                                     toolName: tc.toolName,
                                     plan: effectiveToolExposurePlan,
-                                    context: toolResultContext,
-                                })) {
-                                try {
-                                    if (toolResultContext === undefined) {
-                                        throw new ReferenceError("Tool result context is not available");
+                                });
+                                if (generatedToolResult === undefined &&
+                                    shouldHandleToolResultRead({
+                                        toolName: tc.toolName,
+                                        plan: effectiveToolExposurePlan,
+                                        context: toolResultContext,
+                                    })) {
+                                    try {
+                                        if (toolResultContext === undefined) {
+                                            throw new ReferenceError("Tool result context is not available");
+                                        }
+                                        const result = readToolResultContext(toolResultContext, toolCall.args);
+                                        toolCall.status = "completed";
+                                        toolCall.result = result;
+                                        setSpanAttributes(toolSpan, {
+                                            "tool.status": "completed",
+                                            "tool.output.size_bytes": estimateSerializedSizeBytes(result),
+                                        });
+                                        const toolResultMessage = createToolResultMessage(tc.toolCallId, tc.toolName, result);
+                                        pushPrivateArray(currentMessages, toolResultMessage);
+                                        await persistMessage(toolResultMessage);
                                     }
-                                    const result = readToolResultContext(toolResultContext, toolCall.args);
-                                    toolCall.status = "completed";
-                                    toolCall.result = result;
-                                    setSpanAttributes(toolSpan, {
-                                        "tool.status": "completed",
-                                        "tool.output.size_bytes": estimateSerializedSizeBytes(result),
-                                    });
-                                    const toolResultMessage = createToolResultMessage(tc.toolCallId, tc.toolName, result);
-                                    pushPrivateArray(currentMessages, toolResultMessage);
-                                    await persistMessage(toolResultMessage);
+                                    catch (error) {
+                                        toolCall.status = "error";
+                                        toolCall.error = error instanceof Error ? error.message : String(error);
+                                        const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
+                                        pushPrivateArray(currentMessages, errorMessage);
+                                        await persistMessage(errorMessage);
+                                    }
+                                    pushPrivateArray(toolCalls, toolCall);
+                                    return;
                                 }
-                                catch (error) {
+                                if (generatedToolResult === undefined &&
+                                    shouldBlockToolResultReadName({
+                                        toolName: tc.toolName,
+                                        context: toolResultContext,
+                                    })) {
                                     toolCall.status = "error";
-                                    toolCall.error = error instanceof Error ? error.message : String(error);
+                                    toolCall.error = toolResultReaderUnavailableError();
                                     const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
                                     pushPrivateArray(currentMessages, errorMessage);
                                     await persistMessage(errorMessage);
+                                    pushPrivateArray(toolCalls, toolCall);
+                                    return;
                                 }
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            if (generatedToolResult === undefined &&
-                                shouldBlockToolResultReadName({
-                                    toolName: tc.toolName,
-                                    context: toolResultContext,
-                                })) {
-                                toolCall.status = "error";
-                                toolCall.error = toolResultReaderUnavailableError();
-                                const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
-                                pushPrivateArray(currentMessages, errorMessage);
-                                await persistMessage(errorMessage);
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            if (!hasToolReplacements &&
-                                generatedToolResult === undefined &&
-                                executionAuthority === undefined) {
-                                toolCall.status = "error";
-                                toolCall.error = toolNotVisibleError(tc.toolName);
-                                setSpanAttributes(toolSpan, {
-                                    "tool.status": "blocked",
-                                    error: true,
-                                    "error.type": "ToolExposureBlocked",
-                                });
-                                const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
-                                pushPrivateArray(currentMessages, errorMessage);
-                                await persistMessage(errorMessage);
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            if (generatedToolResult === undefined &&
-                                isFrameworkToolSearch(tc.toolName, effectiveToolExposurePlan)) {
-                                let checkpoint;
-                                try {
-                                    const search = executeFrameworkToolSearch({
-                                        args: toolCall.args,
-                                        plan: effectiveToolExposurePlan,
-                                        state: toolExposureState,
+                                if (!hasToolReplacements &&
+                                    generatedToolResult === undefined &&
+                                    executionAuthority === undefined) {
+                                    toolCall.status = "error";
+                                    toolCall.error = toolNotVisibleError(tc.toolName);
+                                    setSpanAttributes(toolSpan, {
+                                        "tool.status": "blocked",
+                                        error: true,
+                                        "error.type": "ToolExposureBlocked",
                                     });
-                                    if (didReloadProjectAgentWriteTool(search.result)) {
-                                        agentWriteFinalResponseToolGuardEnabled = false;
+                                    const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
+                                    pushPrivateArray(currentMessages, errorMessage);
+                                    await persistMessage(errorMessage);
+                                    pushPrivateArray(toolCalls, toolCall);
+                                    return;
+                                }
+                                if (generatedToolResult === undefined &&
+                                    isFrameworkToolSearch(tc.toolName, effectiveToolExposurePlan)) {
+                                    let checkpoint;
+                                    try {
+                                        const search = executeFrameworkToolSearch({
+                                            args: toolCall.args,
+                                            plan: effectiveToolExposurePlan,
+                                            state: toolExposureState,
+                                        });
+                                        if (didReloadProjectAgentWriteTool(search.result)) {
+                                            agentWriteFinalResponseToolGuardEnabled = false;
+                                        }
+                                        toolCall.status = "completed";
+                                        toolCall.result = search.result;
+                                        setSpanAttributes(toolSpan, {
+                                            "tool.status": "completed",
+                                            "tool.search.result_count": search.result.resultCount,
+                                            "tool.search.loaded_count": search.result.loadedCount,
+                                            "tool.search.miss": search.result.miss,
+                                        });
+                                        const toolResultMessage = createToolResultMessage(tc.toolCallId, tc.toolName, search.result);
+                                        pushPrivateArray(currentMessages, toolResultMessage);
+                                        await persistMessage(toolResultMessage);
+                                        checkpoint = search.checkpoint;
                                     }
-                                    toolCall.status = "completed";
-                                    toolCall.result = search.result;
-                                    setSpanAttributes(toolSpan, {
-                                        "tool.status": "completed",
-                                        "tool.search.result_count": search.result.resultCount,
-                                        "tool.search.loaded_count": search.result.loadedCount,
-                                        "tool.search.miss": search.result.miss,
+                                    catch (error) {
+                                        toolCall.status = "error";
+                                        toolCall.error = error instanceof Error ? error.message : String(error);
+                                        const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
+                                        pushPrivateArray(currentMessages, errorMessage);
+                                        await persistMessage(errorMessage);
+                                        pushPrivateArray(toolCalls, toolCall);
+                                        return;
+                                    }
+                                    await persistToolExposureCheckpointBeforeContinuation({
+                                        checkpoint,
+                                        persist: persistToolExposureCheckpoint,
+                                        required: requireToolExposureCheckpointPersistence,
                                     });
-                                    const toolResultMessage = createToolResultMessage(tc.toolCallId, tc.toolName, search.result);
-                                    pushPrivateArray(currentMessages, toolResultMessage);
-                                    await persistMessage(toolResultMessage);
-                                    checkpoint = search.checkpoint;
+                                    pushPrivateArray(toolCalls, toolCall);
+                                    return;
                                 }
-                                catch (error) {
+                                // Provider-executed tools (web_search/web_fetch) return results without skill-state
+                                // transitions. Unlike locally-executed paths, load_skill and form_input are client-side
+                                // function tools that the runtime executes itself, so they never appear in
+                                // response.toolResults. This branch mirrors the streaming loop's providerExecuted===true
+                                // path, not the locally-executed ones. If provider-executed tools expand beyond web_*,
+                                // the transitions (skillState.applySuccessfulResult, markFormInputSubmitted) would apply.
+                                if (generatedToolResult && !hasToolReplacements) {
+                                    if (generatedToolResult.providerExecuted === true) {
+                                        await traceProviderExecutedTool({
+                                            mode: "generate",
+                                            agentId: this.id,
+                                            toolName: tc.toolName,
+                                            toolCallId: tc.toolCallId,
+                                            context: {
+                                                toolCallId: tc.toolCallId,
+                                                ...toolContext,
+                                                agentId: this.id,
+                                            },
+                                            args: tc.input,
+                                            result: generatedToolResult.result,
+                                            isError: generatedToolResult.isError === true,
+                                        });
+                                    }
+                                    await persistGeneratedToolResult(generatedToolResult);
+                                    toolCall.status = generatedToolResult.isError === true ? "error" : "completed";
+                                    toolCall.result = generatedToolResult.result;
+                                    toolCall.error = generatedToolResult.isError === true
+                                        ? stringifyToolError(generatedToolResult.result)
+                                        : undefined;
+                                    if (toolCall.error !== undefined) {
+                                        setOtelActiveSpanErrorStatus(new NativeError(`Tool "${tc.toolName}" failed`));
+                                    }
+                                    if (generatedToolResult.isError !== true &&
+                                        shouldHideProjectToolAfterAgentWriteSuccess(tc.toolName)) {
+                                        agentWriteFinalResponseToolGuardEnabled = true;
+                                    }
+                                    setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
+                                        "tool.status": generatedToolResult.isError === true ? "failed" : "completed",
+                                        "tool.provider_executed": generatedToolResult.providerExecuted === true,
+                                        "tool.output.size_bytes": estimateSerializedSizeBytes(generatedToolResult.result),
+                                        ...(toolCall.error
+                                            ? {
+                                                error: true,
+                                                "error.type": "ProviderExecutedToolError",
+                                            }
+                                            : {}),
+                                    }));
+                                    pushPrivateArray(toolCalls, toolCall);
+                                    return;
+                                }
+                                const policyCheck = enforceSkillPolicy(tc.toolName, {
+                                    activeSkillId: skillState.activeSkillId,
+                                    hasSubmittedFormInput: skillState.hasSubmittedFormInput,
+                                    skillToolAvailability: skillState.activeSkillToolAvailability,
+                                    toolInput: tc.input,
+                                    toolDefinition: executionAuthority?.toolDefinition,
+                                });
+                                if (!policyCheck.allowed) {
                                     toolCall.status = "error";
-                                    toolCall.error = error instanceof Error ? error.message : String(error);
-                                    const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
+                                    toolCall.error = policyCheck.error;
+                                    setSpanAttributes(toolSpan, {
+                                        "tool.status": "blocked",
+                                        error: true,
+                                        "error.type": "ToolPolicyBlocked",
+                                    });
+                                    const errorMessage = {
+                                        id: `tool_error_${tc.toolCallId}`,
+                                        role: "tool",
+                                        parts: [{
+                                                type: "tool-result",
+                                                toolCallId: tc.toolCallId,
+                                                toolName: tc.toolName,
+                                                result: { error: policyCheck.error },
+                                            }],
+                                        timestamp: Date.now(),
+                                    };
                                     pushPrivateArray(currentMessages, errorMessage);
                                     await persistMessage(errorMessage);
                                     pushPrivateArray(toolCalls, toolCall);
                                     return;
                                 }
-                                await persistToolExposureCheckpointBeforeContinuation({
-                                    checkpoint,
-                                    persist: persistToolExposureCheckpoint,
-                                    required: requireToolExposureCheckpointPersistence,
-                                });
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            // Provider-executed tools (web_search/web_fetch) return results without skill-state
-                            // transitions. Unlike locally-executed paths, load_skill and form_input are client-side
-                            // function tools that the runtime executes itself, so they never appear in
-                            // response.toolResults. This branch mirrors the streaming loop's providerExecuted===true
-                            // path, not the locally-executed ones. If provider-executed tools expand beyond web_*,
-                            // the transitions (skillState.applySuccessfulResult, markFormInputSubmitted) would apply.
-                            if (generatedToolResult && !hasToolReplacements) {
-                                if (generatedToolResult.providerExecuted === true) {
-                                    await traceProviderExecutedTool({
+                                try {
+                                    toolCall.status = "executing";
+                                    const startTime = Date.now();
+                                    const cacheCtx = tryGetCacheKeyContext();
+                                    toolCall.args = applySkillDelegationOverridesToToolInput(tc.toolName, toolCall.args, hasToolReplacements ? undefined : skillState.activeSkillDelegationOverrides, hasToolReplacements
+                                        ? undefined
+                                        : resolveConfiguredTool(runtimeToolsConfig, tc.toolName, {
+                                            agentId: this.id,
+                                        }) ??
+                                            undefined);
+                                    const executionContext = applicationExecutionContext(toolContext, providerObservedSkillBodies);
+                                    executionContext.projectId = cacheCtx?.projectId ?? toolContext?.projectId;
+                                    throwIfAborted(abortSignal);
+                                    const result = await traceConfiguredToolExecution({
                                         mode: "generate",
                                         agentId: this.id,
                                         toolName: tc.toolName,
                                         toolCallId: tc.toolCallId,
-                                        context: {
-                                            toolCallId: tc.toolCallId,
-                                            ...toolContext,
-                                            agentId: this.id,
-                                        },
-                                        args: tc.input,
-                                        result: generatedToolResult.result,
-                                        isError: generatedToolResult.isError === true,
+                                        args: toolCall.args,
+                                        admittedTurn,
+                                        owner: currentMessages,
+                                        prepareTerminalDispatch,
+                                        toolsConfig: runtimeToolsConfig,
+                                        context: executionContext,
+                                        allowedRemoteToolNames,
+                                        remoteToolSources,
+                                        sourceIntegrationPolicy,
+                                        strictConfiguredToolsOnly: hasToolReplacements,
+                                        frameworkLocalTools,
                                     });
-                                }
-                                await persistGeneratedToolResult(generatedToolResult);
-                                toolCall.status = generatedToolResult.isError === true ? "error" : "completed";
-                                toolCall.result = generatedToolResult.result;
-                                toolCall.error = generatedToolResult.isError === true
-                                    ? stringifyToolError(generatedToolResult.result)
-                                    : undefined;
-                                if (toolCall.error !== undefined) {
-                                    setOtelActiveSpanErrorStatus(new NativeError(`Tool "${tc.toolName}" failed`));
-                                }
-                                if (generatedToolResult.isError !== true &&
-                                    shouldHideProjectToolAfterAgentWriteSuccess(tc.toolName)) {
-                                    agentWriteFinalResponseToolGuardEnabled = true;
-                                }
-                                setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
-                                    "tool.status": generatedToolResult.isError === true ? "failed" : "completed",
-                                    "tool.provider_executed": generatedToolResult.providerExecuted === true,
-                                    "tool.output.size_bytes": estimateSerializedSizeBytes(generatedToolResult.result),
-                                    ...(toolCall.error
-                                        ? {
+                                    await this.notifyToolResult({
+                                        mode: "generate",
+                                        toolName: tc.toolName,
+                                        toolCallId: tc.toolCallId,
+                                        input: toolCall.args,
+                                        result,
+                                        context: executionContext,
+                                    });
+                                    const resultError = getToolResultError(result);
+                                    if (resultError !== undefined) {
+                                        setOtelActiveSpanErrorStatus(new NativeError(`Tool "${tc.toolName}" failed`));
+                                    }
+                                    toolCall.status = resultError === undefined ? "completed" : "error";
+                                    toolCall.result = result;
+                                    toolCall.error = resultError;
+                                    toolCall.executionTime = Date.now() - startTime;
+                                    setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
+                                        "tool.status": resultError === undefined ? "completed" : "failed",
+                                        "tool.provider_executed": false,
+                                        "tool.output.size_bytes": estimateSerializedSizeBytes(result),
+                                        ...(resultError === undefined ? {} : {
                                             error: true,
-                                            "error.type": "ProviderExecutedToolError",
+                                            "error.type": "ToolResultError",
+                                        }),
+                                    }));
+                                    if (resultError === undefined) {
+                                        if (shouldHideProjectToolAfterAgentWriteSuccess(tc.toolName)) {
+                                            agentWriteFinalResponseToolGuardEnabled = true;
                                         }
-                                        : {}),
-                                }));
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            const policyCheck = enforceSkillPolicy(tc.toolName, {
-                                activeSkillId: skillState.activeSkillId,
-                                hasSubmittedFormInput: skillState.hasSubmittedFormInput,
-                                skillToolAvailability: skillState.activeSkillToolAvailability,
-                                toolInput: tc.input,
-                                toolDefinition: executionAuthority?.toolDefinition,
-                            });
-                            if (!policyCheck.allowed) {
-                                toolCall.status = "error";
-                                toolCall.error = policyCheck.error;
-                                setSpanAttributes(toolSpan, {
-                                    "tool.status": "blocked",
-                                    error: true,
-                                    "error.type": "ToolPolicyBlocked",
-                                });
-                                const errorMessage = {
-                                    id: `tool_error_${tc.toolCallId}`,
-                                    role: "tool",
-                                    parts: [{
-                                            type: "tool-result",
-                                            toolCallId: tc.toolCallId,
-                                            toolName: tc.toolName,
-                                            result: { error: policyCheck.error },
-                                        }],
-                                    timestamp: Date.now(),
-                                };
-                                pushPrivateArray(currentMessages, errorMessage);
-                                await persistMessage(errorMessage);
-                                pushPrivateArray(toolCalls, toolCall);
-                                return;
-                            }
-                            try {
-                                toolCall.status = "executing";
-                                const startTime = Date.now();
-                                const cacheCtx = tryGetCacheKeyContext();
-                                toolCall.args = applySkillDelegationOverridesToToolInput(tc.toolName, toolCall.args, hasToolReplacements ? undefined : skillState.activeSkillDelegationOverrides, hasToolReplacements
-                                    ? undefined
-                                    : resolveConfiguredTool(runtimeToolsConfig, tc.toolName, {
-                                        agentId: this.id,
-                                    }) ??
-                                        undefined);
-                                const executionContext = applicationExecutionContext(toolContext, providerObservedSkillBodies);
-                                executionContext.projectId = cacheCtx?.projectId ?? toolContext?.projectId;
-                                throwIfAborted(abortSignal);
-                                const result = await traceConfiguredToolExecution({
-                                    mode: "generate",
-                                    agentId: this.id,
-                                    toolName: tc.toolName,
-                                    toolCallId: tc.toolCallId,
-                                    args: toolCall.args,
-                                    admittedTurn,
-                                    owner: currentMessages,
-                                    prepareTerminalDispatch,
-                                    toolsConfig: runtimeToolsConfig,
-                                    context: executionContext,
-                                    allowedRemoteToolNames,
-                                    remoteToolSources,
-                                    sourceIntegrationPolicy,
-                                    strictConfiguredToolsOnly: hasToolReplacements,
-                                    frameworkLocalTools,
-                                });
-                                await this.notifyToolResult({
-                                    mode: "generate",
-                                    toolName: tc.toolName,
-                                    toolCallId: tc.toolCallId,
-                                    input: toolCall.args,
-                                    result,
-                                    context: executionContext,
-                                });
-                                const resultError = getToolResultError(result);
-                                if (resultError !== undefined) {
-                                    setOtelActiveSpanErrorStatus(new NativeError(`Tool "${tc.toolName}" failed`));
+                                        // Track skill policy only from successful framework-owned load_skill results.
+                                        if (isLoadSkillToolName(tc.toolName) &&
+                                            hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition)) {
+                                            skillState.applySuccessfulResult(result);
+                                        }
+                                        const submittedFormInput = isSubmittedFormInputExecutionResult(tc.toolName, result, executionAuthority?.toolDefinition);
+                                        skillState.markFormInputSubmitted(submittedFormInput);
+                                        if (submittedFormInput) {
+                                            currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
+                                        }
+                                    }
+                                    const toolResultMessage = createPolicyAwareToolResultMessage(tc.toolCallId, tc.toolName, result, executionAuthority?.toolDefinition, false, true);
+                                    pushPrivateArray(currentMessages, toolResultMessage);
+                                    await persistMessage(toolResultMessage);
                                 }
-                                toolCall.status = resultError === undefined ? "completed" : "error";
-                                toolCall.result = result;
-                                toolCall.error = resultError;
-                                toolCall.executionTime = Date.now() - startTime;
-                                setSpanAttributes(toolSpan, compactRuntimeTraceAttributes({
-                                    "tool.status": resultError === undefined ? "completed" : "failed",
-                                    "tool.provider_executed": false,
-                                    "tool.output.size_bytes": estimateSerializedSizeBytes(result),
-                                    ...(resultError === undefined ? {} : {
+                                catch (error) {
+                                    await this.recordTerminalToolResult(error, toolCall, persistMessage, currentMessages, toolCalls, totalUsage);
+                                    throwIfAborted(abortSignal);
+                                    toolCall.status = "error";
+                                    toolCall.error = error instanceof Error ? error.message : String(error);
+                                    setSpanAttributes(toolSpan, {
+                                        "tool.status": "failed",
                                         error: true,
-                                        "error.type": "ToolResultError",
-                                    }),
-                                }));
-                                if (resultError === undefined) {
-                                    if (shouldHideProjectToolAfterAgentWriteSuccess(tc.toolName)) {
-                                        agentWriteFinalResponseToolGuardEnabled = true;
-                                    }
-                                    // Track skill policy only from successful framework-owned load_skill results.
-                                    if (isLoadSkillToolName(tc.toolName) &&
-                                        hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition)) {
-                                        skillState.applySuccessfulResult(result);
-                                    }
-                                    const submittedFormInput = isSubmittedFormInputExecutionResult(tc.toolName, result, executionAuthority?.toolDefinition);
-                                    skillState.markFormInputSubmitted(submittedFormInput);
-                                    if (submittedFormInput) {
-                                        currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
-                                    }
+                                        "error.type": telemetryErrorType(error),
+                                    });
+                                    const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
+                                    pushPrivateArray(currentMessages, errorMessage);
+                                    await persistMessage(errorMessage);
                                 }
-                                const toolResultMessage = createPolicyAwareToolResultMessage(tc.toolCallId, tc.toolName, result, executionAuthority?.toolDefinition, false, true);
-                                pushPrivateArray(currentMessages, toolResultMessage);
-                                await persistMessage(toolResultMessage);
-                            }
-                            catch (error) {
-                                await this.recordTerminalToolResult(error, toolCall, persistMessage, currentMessages, toolCalls, totalUsage);
-                                throwIfAborted(abortSignal);
-                                toolCall.status = "error";
-                                toolCall.error = error instanceof Error ? error.message : String(error);
-                                setSpanAttributes(toolSpan, {
-                                    "tool.status": "failed",
-                                    error: true,
-                                    "error.type": telemetryErrorType(error),
-                                });
-                                const errorMessage = createToolErrorMessage(tc.toolCallId, tc.toolName, toolCall.error);
-                                pushPrivateArray(currentMessages, errorMessage);
-                                await persistMessage(errorMessage);
-                            }
-                            pushPrivateArray(toolCalls, toolCall);
-                        });
-                        throwIfAborted(abortSignal);
+                                pushPrivateArray(toolCalls, toolCall);
+                            });
+                            throwIfAborted(abortSignal);
+                        }
                     }
-                }
-                catch (error) {
-                    if (generatedTurnAdmissionObserved) {
-                        await observeGeneratedProviderTurnFinishOnce(response);
+                    catch (error) {
+                        if (generatedTurnAdmissionObserved) {
+                            await observeGeneratedProviderTurnFinishOnce(response);
+                        }
+                        throw error;
+                    }
+                    if (isFinalMaxStepsToolTurn) {
+                        maxStepsParsedOutput = await tryParseMaxStepsOutput(response.text, outputSchema);
+                        await observeGeneratedProviderTurnFinishOnce({
+                            ...response,
+                            ...(maxStepsParsedOutput.parsed
+                                ? { data: maxStepsParsedOutput.object, object: maxStepsParsedOutput.object }
+                                : {}),
+                        });
                     }
-                    throw error;
                 }
-                if (isFinalMaxStepsToolTurn) {
-                    maxStepsParsedOutput = await tryParseMaxStepsOutput(response.text, outputSchema);
-                    await observeGeneratedProviderTurnFinishOnce({
-                        ...response,
-                        ...(maxStepsParsedOutput.parsed
-                            ? { data: maxStepsParsedOutput.object, object: maxStepsParsedOutput.object }
+                throwIfAborted(abortSignal);
+                this.status = "completed";
+                addSpanEvent(loopSpan, "max_steps_reached", { maxSteps });
+                setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
+                // The last message on this exit is a tool result, so the response text
+                // and the structured-output candidate come from the final assistant turn.
+                const finalText = getFinalAssistantText(currentMessages);
+                const parsedOutput = maxStepsParsedOutput ??
+                    await tryParseMaxStepsOutput(finalText, outputSchema);
+                return attachOutputSchemaParser({
+                    text: finalText,
+                    ...(parsedOutput.parsed ? { data: parsedOutput.object, object: parsedOutput.object } : {}),
+                    messages: currentMessages,
+                    toolCalls,
+                    status: this.status,
+                    usage: totalUsage,
+                    metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, {
+                        warning: `Max steps (${maxSteps}) reached`,
+                        ...(!parsedOutput.parsed && parsedOutput.outputSchemaError !== undefined
+                            ? { outputSchemaError: parsedOutput.outputSchemaError }
                             : {}),
-                    });
-                }
+                    }),
+                }, withCachedMaxStepsOutputParse(outputSchema, parsedOutput, finalText));
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
             }
-            throwIfAborted(abortSignal);
-            this.status = "completed";
-            addSpanEvent(loopSpan, "max_steps_reached", { maxSteps });
-            setSpanAttributes(loopSpan, buildRuntimeUsageTraceAttributes(totalUsage));
-            // The last message on this exit is a tool result, so the response text
-            // and the structured-output candidate come from the final assistant turn.
-            const finalText = getFinalAssistantText(currentMessages);
-            const parsedOutput = maxStepsParsedOutput ??
-                await tryParseMaxStepsOutput(finalText, outputSchema);
-            return attachOutputSchemaParser({
-                text: finalText,
-                ...(parsedOutput.parsed ? { data: parsedOutput.object, object: parsedOutput.object } : {}),
-                messages: currentMessages,
-                toolCalls,
-                status: this.status,
-                usage: totalUsage,
-                metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, {
-                    warning: `Max steps (${maxSteps}) reached`,
-                    ...(!parsedOutput.parsed && parsedOutput.outputSchemaError !== undefined
-                        ? { outputSchemaError: parsedOutput.outputSchemaError }
-                        : {}),
-                }),
-            }, withCachedMaxStepsOutputParse(outputSchema, parsedOutput, finalText));
         });
     }
     /**
@@ -4116,1516 +4181,1529 @@ export class AgentRuntime {
      */
     async #executeAgentLoopStreaming(// NOSONAR: Existing loop shape; this patch only adds authority cleanup.
     systemPrompt, messages, validateProviderRequest, persistMessage, prepareTerminalDispatch, controller, encoder, callbacks, textPartId, toolContextBase, runtimeContext, runRuntimeContext, runtimeObservationsEnabled, supportsToolCalling, providerReplayCheckpointEmission, modelString, resolvedModel, headers, providerOptions, reasoning, maxOutputTokensOverride, abortSignal, temperatureModelString, outputSchema) {
-        const { maxAgentSteps } = getPlatformCapabilities();
-        const maxSteps = this.computeMaxSteps(maxAgentSteps);
-        const effectiveModel = resolveRuntimeModel(modelString || this.config.model);
-        const languageModel = resolvedModel ?? resolveModel(effectiveModel);
-        const continuation = this.#recoveryContinuation ?? await this.#manualPause?.load();
-        const checkpoint = continuation == null ? undefined : parseAgentPauseCheckpoint(continuation);
-        if (checkpoint?.providerMetadata) {
-            mapPrivateArray(checkpoint.messages, (message) => {
-                const saved = filterPrivateArray(checkpoint.providerMetadata, (entry) => entry.messageId === message.id)[0];
-                if (saved) {
-                    attachProviderMetadata(message, saved.metadata);
-                }
-            });
-        }
-        const toolCalls = checkpoint?.toolCalls ?? [];
-        const currentMessages = mapPrivateArray(checkpoint?.messages ?? messages, (message) => message);
-        const runtimeGeneratedMessageIds = createPrivateSet(checkpoint?.runtimeGeneratedMessageIds ?? []);
-        mapPrivateArray(currentMessages, (message) => {
-            if (runtimeGeneratedMessageIds.has(message.id))
-                markRuntimeGeneratedUserMessage(message);
-            return message;
-        });
-        // JSON checkpoints drop in-memory trust markers; restore only the runtime-recorded results.
-        restoreTrustedSkillLoadResultsFromPauseCheckpoint(currentMessages, checkpoint?.trustedSkillLoadResultIds, checkpoint?.trustedSkillLoadResultRefs);
-        applyProviderReplayCheckpointsToMessages(currentMessages, getRuntimeProviderReplayCheckpoints(this.config), { activeProvider: resolveActiveProviderReplayProvider(languageModel) });
-        const totalUsage = checkpoint?.usage ??
-            { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
-        if (!supportsToolCalling && this.config.tools) {
-            warnUnsupportedToolCalling(this.id, effectiveModel);
-        }
-        // Request-scoped skill policy (not class-level mutable state)
-        const skillState = AgentLoopSkillState.hydrate(currentMessages, runtimeContext);
-        if (checkpoint) {
-            skillState.activeSkillDelegationOverrides = checkpoint.activeSkillDelegationOverrides;
-            skillState.markFormInputSubmitted(checkpoint.hasSubmittedFormInput === true);
-        }
-        let finalFinishReason = checkpoint?.finishReason;
-        let latestAssistantText = checkpoint?.latestAssistantText ?? "";
-        let completedWithinStepBudget = checkpoint?.completed ?? false;
-        const initialToolExposureCheckpoint = checkpoint?.toolExposureCheckpoint ??
-            getRuntimeToolExposureCheckpoint(this.config);
-        let pauseToolExposureAuthorized;
-        const toolExposureState = createToolExposureState();
-        const persistToolExposureCheckpoint = getRuntimeToolExposureCheckpointPersister(this.config);
-        const requireToolExposureCheckpointPersistence = isRuntimeToolExposureCheckpointPersistenceRequired(this.config);
-        const toolLoadingResolution = resolveRuntimeToolLoading(this.config);
-        const runtimeStepConfig = {
-            ...this.config,
-            __vfToolLoadingMode: toolLoadingResolution.mode,
-        };
-        if (ObjectGetPrototypeOf(this.config) === null)
-            ObjectSetPrototypeOf(runtimeStepConfig, null);
-        const allowedRemoteToolNames = getRuntimeAllowedRemoteTools(this.config);
-        const forwardedRemoteToolDefinitions = getRuntimeForwardedIntegrationToolDefs(this.config);
-        const remoteToolSources = getRuntimeRemoteToolSources(this.config, undefined, this.id);
-        const unavailableOptionalRemoteTools = getRuntimeUnavailableOptionalRemoteTools(this.config, remoteToolSources);
-        const sourceIntegrationPolicy = getRuntimeSourceIntegrationPolicy(this.config);
-        const frameworkLocalTools = createRuntimeFrameworkLocalTools(this.config);
-        const configuredProviderTools = getRuntimeProviderTools(this.config);
-        const toolResultContext = createActiveToolResultContext({
-            config: this.config,
-            supportsToolCalling,
-        });
-        const providerTools = sourceIntegrationPolicy
-            ? applySourceIntegrationPolicy(configuredProviderTools, sourceIntegrationPolicy)
-            : configuredProviderTools;
-        let currentSystemPrompt = systemPrompt;
-        let currentRuntimeContext = runtimeContext;
-        let agentWriteFinalResponseToolGuardEnabled = checkpoint?.agentWriteFinalResponseToolGuardEnabled ?? false;
-        let recoveredEmptyResponse = checkpoint?.recoveredEmptyResponse ?? false;
-        // One retry gives the model a chance to reconstruct a transport-truncated
-        // batch without allowing a repeatedly broken provider stream to loop.
-        let recoveredInterruptedLocalToolBatch = checkpoint?.recoveredInterruptedLocalToolBatch ??
-            false;
-        let interruptedLocalToolBatchRecoveryStep = checkpoint?.interruptedLocalToolBatchRecoveryStep;
-        let interruptedLocalToolBatchRecoveryText = checkpoint?.interruptedLocalToolBatchRecoveryText;
-        let resumeToolCallExecuted = checkpoint?.resumeToolCallExecuted ?? false;
-        // A pause can precede startup preparation; checkpoint existence is not completion.
-        let startupSkillLoaded = checkpoint?.startupSkillLoaded === true ||
-            this.config.bootstrapSkill === undefined || skillState.hasSubmittedFormInput;
-        const captureRecoveryContinuation = (nextStep) => parseAgentPauseCheckpoint({
-            version: 1,
-            nextStep,
-            messages: currentMessages,
-            toolCalls,
-            usage: totalUsage,
-            latestAssistantText,
-            completed: completedWithinStepBudget,
-            ...(finalFinishReason ? { finishReason: finalFinishReason } : {}),
-            recoveredEmptyResponse,
-            startupSkillLoaded,
-            recoveredInterruptedLocalToolBatch,
-            hasSubmittedFormInput: skillState.hasSubmittedFormInput,
-            activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
-            // Omitted when empty so checkpoints without trusted loads keep the prior shape.
-            ...(() => {
-                const ids = getTrustedSkillLoadResultIds(currentMessages);
-                if (hasAmbiguousTrustedSkillLoadResultIds(currentMessages)) {
-                    return { trustedSkillLoadResultRefs: getTrustedSkillLoadResultRefs(currentMessages) };
-                }
-                return ids.length > 0 ? { trustedSkillLoadResultIds: ids } : {};
-            })(),
-            resumeToolCallExecuted,
-            agentWriteFinalResponseToolGuardEnabled,
-            interruptedLocalToolBatchRecoveryStep,
-            interruptedLocalToolBatchRecoveryText,
-            providerMetadata: mapPrivateArray(filterPrivateArray(currentMessages, (message) => readAttachedProviderMetadata(message) !== undefined), (message) => ({
-                messageId: message.id,
-                metadata: readAttachedProviderMetadata(message),
-            })),
-            runtimeGeneratedMessageIds: mapPrivateArray(filterPrivateArray(currentMessages, isRuntimeGeneratedUserMessage), (message) => message.id),
-            toolExposureCheckpoint: pauseToolExposureAuthorized
-                ? createToolExposureCheckpoint(pauseToolExposureAuthorized, toolExposureState)
-                : initialToolExposureCheckpoint,
-        });
-        const pauseAtBoundary = async (nextStep) => {
-            if (this.#persistRecoveryBoundary) {
-                const runtimeContinuation = captureRecoveryContinuation(nextStep);
-                await this.#persistRecoveryBoundary({
-                    ...createRecoveryBoundary(currentMessages, runtimeContinuation.toolExposureCheckpoint ?? { version: 2, loadedToolNames: [] }),
-                    runtimeContinuation,
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { maxAgentSteps } = getPlatformCapabilities();
+            const maxSteps = this.computeMaxSteps(maxAgentSteps);
+            const effectiveModel = resolveRuntimeModel(modelString || this.config.model);
+            const languageModel = resolvedModel ?? resolveModel(effectiveModel);
+            const continuation = this.#recoveryContinuation ?? await this.#manualPause?.load();
+            const checkpoint = continuation == null ? undefined : parseAgentPauseCheckpoint(continuation);
+            if (checkpoint?.providerMetadata) {
+                mapPrivateArray(checkpoint.messages, (message) => {
+                    const saved = filterPrivateArray(checkpoint.providerMetadata, (entry) => entry.messageId === message.id)[0];
+                    if (saved) {
+                        attachProviderMetadata(message, saved.metadata);
+                    }
                 });
             }
-            if (!this.#manualPause)
-                return;
-            if (this.#manualPause.requested && !(await this.#manualPause.requested()))
-                return;
-            let saved;
-            try {
-                saved = captureRecoveryContinuation(nextStep);
-            }
-            catch {
-                if (this.#manualPause.release && !(await this.#manualPause.release()))
-                    return;
-                logger.warn("Agent is held at a safe boundary because its pause continuation cannot be saved");
-                throw agentManualPauseBoundary();
-            }
-            let acknowledged = false;
-            await validateProviderRequest(withAgentRunRuntimeContext(systemPrompt, runRuntimeContext), currentMessages, {
-                beforeAcceptance: async () => {
-                    acknowledged = await this.#manualPause.acknowledge(saved);
-                    return acknowledged;
-                },
+            const toolCalls = checkpoint?.toolCalls ?? [];
+            const currentMessages = mapPrivateArray(checkpoint?.messages ?? messages, (message) => message);
+            const runtimeGeneratedMessageIds = createPrivateSet(checkpoint?.runtimeGeneratedMessageIds ?? []);
+            mapPrivateArray(currentMessages, (message) => {
+                if (runtimeGeneratedMessageIds.has(message.id))
+                    markRuntimeGeneratedUserMessage(message);
+                return message;
             });
-            if (acknowledged)
-                throw agentManualPauseBoundary();
-        };
-        if (this.#manualPause) {
-            await validateProviderRequest(withAgentRunRuntimeContext(systemPrompt, runRuntimeContext), currentMessages, { deferAcceptance: true });
+            // JSON checkpoints drop in-memory trust markers; restore only the runtime-recorded results.
+            restoreTrustedSkillLoadResultsFromPauseCheckpoint(currentMessages, checkpoint?.trustedSkillLoadResultIds, checkpoint?.trustedSkillLoadResultRefs);
+            applyProviderReplayCheckpointsToMessages(currentMessages, getRuntimeProviderReplayCheckpoints(this.config), { activeProvider: resolveActiveProviderReplayProvider(languageModel) });
+            const totalUsage = checkpoint?.usage ??
+                { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+            if (!supportsToolCalling && this.config.tools) {
+                warnUnsupportedToolCalling(this.id, effectiveModel);
+            }
+            // Request-scoped skill policy (not class-level mutable state)
+            const skillState = AgentLoopSkillState.hydrate(currentMessages, runtimeContext);
             if (checkpoint) {
-                const persistedIds = createPrivateSet(mapPrivateArray(messages, (message) => message.id));
-                for (let index = 0; index < currentMessages.length; index++) {
-                    const message = currentMessages[index];
-                    if (persistedIds.has(message.id))
-                        continue;
-                    await persistMessage(message);
-                    persistedIds.add(message.id);
-                }
+                skillState.activeSkillDelegationOverrides = checkpoint.activeSkillDelegationOverrides;
+                skillState.markFormInputSubmitted(checkpoint.hasSubmittedFormInput === true);
             }
-        }
-        await pauseAtBoundary(checkpoint?.nextStep ?? 0);
-        for (let step = checkpoint?.nextStep ?? 0; !completedWithinStepBudget && step < maxSteps; step++) {
-            throwIfAborted(abortSignal);
-            const currentStepToolResults = createPrivateMap();
-            const stepRuntimeContext = skillState.hasSubmittedFormInput
-                ? markSubmittedFormInputRuntimeContext(currentRuntimeContext)
-                : currentRuntimeContext;
-            const preparedStep = await prepareAgentRuntimeStep({
-                agentId: this.id,
-                activeSkillId: skillState.activeSkillId,
-                activeSkillToolAvailability: skillState.activeSkillToolAvailability,
-                allowedRemoteToolNames,
-                config: runtimeStepConfig,
-                effectiveModel,
-                ...resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
-                reservedToolSlots: getToolResultReaderReservedSlots(toolResultContext),
-                excludedToolNames: agentWriteFinalResponseToolGuardEnabled &&
-                    toolLoadingResolution.mode === "eager"
-                    ? AGENT_WRITE_FINAL_RESPONSE_EXCLUDED_TOOL_NAMES
-                    : undefined,
-                forwardedRemoteToolDefinitions,
-                getAvailableTools,
-                unavailableOptionalRemoteToolNames: unavailableOptionalRemoteTools.names,
-                unavailableOptionalRemoteToolPrefixes: unavailableOptionalRemoteTools.prefixes,
+            let finalFinishReason = checkpoint?.finishReason;
+            let latestAssistantText = checkpoint?.latestAssistantText ?? "";
+            let completedWithinStepBudget = checkpoint?.completed ?? false;
+            const initialToolExposureCheckpoint = checkpoint?.toolExposureCheckpoint ??
+                getRuntimeToolExposureCheckpoint(this.config);
+            let pauseToolExposureAuthorized;
+            const toolExposureState = createToolExposureState();
+            const persistToolExposureCheckpoint = getRuntimeToolExposureCheckpointPersister(this.config);
+            const requireToolExposureCheckpointPersistence = isRuntimeToolExposureCheckpointPersistenceRequired(this.config);
+            const toolLoadingResolution = resolveRuntimeToolLoading(this.config);
+            const runtimeStepConfig = {
+                ...this.config,
+                __vfToolLoadingMode: toolLoadingResolution.mode,
+            };
+            if (ObjectGetPrototypeOf(this.config) === null)
+                ObjectSetPrototypeOf(runtimeStepConfig, null);
+            const allowedRemoteToolNames = getRuntimeAllowedRemoteTools(this.config);
+            const forwardedRemoteToolDefinitions = getRuntimeForwardedIntegrationToolDefs(this.config);
+            const remoteToolSources = getRuntimeRemoteToolSources(this.config, undefined, this.id);
+            const _remoteMcpCleanup = __addDisposableResource(env_2, createRuntimeMcpSourceCleanup(remoteToolSources), true);
+            const unavailableOptionalRemoteTools = getRuntimeUnavailableOptionalRemoteTools(this.config, remoteToolSources);
+            const sourceIntegrationPolicy = getRuntimeSourceIntegrationPolicy(this.config);
+            const frameworkLocalTools = createRuntimeFrameworkLocalTools(this.config);
+            const configuredProviderTools = getRuntimeProviderTools(this.config);
+            const toolResultContext = createActiveToolResultContext({
+                config: this.config,
                 supportsToolCalling,
-                includeStartupAuthorizedTools: !startupSkillLoaded,
+            });
+            const providerTools = sourceIntegrationPolicy
+                ? applySourceIntegrationPolicy(configuredProviderTools, sourceIntegrationPolicy)
+                : configuredProviderTools;
+            let currentSystemPrompt = systemPrompt;
+            let currentRuntimeContext = runtimeContext;
+            let agentWriteFinalResponseToolGuardEnabled = checkpoint?.agentWriteFinalResponseToolGuardEnabled ?? false;
+            let recoveredEmptyResponse = checkpoint?.recoveredEmptyResponse ?? false;
+            // One retry gives the model a chance to reconstruct a transport-truncated
+            // batch without allowing a repeatedly broken provider stream to loop.
+            let recoveredInterruptedLocalToolBatch = checkpoint?.recoveredInterruptedLocalToolBatch ??
+                false;
+            let interruptedLocalToolBatchRecoveryStep = checkpoint?.interruptedLocalToolBatchRecoveryStep;
+            let interruptedLocalToolBatchRecoveryText = checkpoint?.interruptedLocalToolBatchRecoveryText;
+            let resumeToolCallExecuted = checkpoint?.resumeToolCallExecuted ?? false;
+            // A pause can precede startup preparation; checkpoint existence is not completion.
+            let startupSkillLoaded = checkpoint?.startupSkillLoaded === true ||
+                this.config.bootstrapSkill === undefined || skillState.hasSubmittedFormInput;
+            const captureRecoveryContinuation = (nextStep) => parseAgentPauseCheckpoint({
+                version: 1,
+                nextStep,
                 messages: currentMessages,
-                mode: "stream",
-                modelRuntime: languageModel,
-                providerOptionKey: resolveModelProviderOptionKey(effectiveModel, languageModel),
-                authorizedProviderToolNames: providerTools,
-                providerToolNames: supportsToolCalling && !agentWriteFinalResponseToolGuardEnabled
-                    ? providerTools
-                    : [],
-                remoteToolSources,
-                sourceIntegrationPolicy,
-                resolveRuntimeState: this.resolveRuntimeState.bind(this),
-                runtimeContext: stepRuntimeContext,
-                step,
-                systemPrompt: currentSystemPrompt,
-                toolContextBase,
-                frameworkLocalTools,
-                toolExposureState,
-                toolExposureCheckpoint: step === (checkpoint?.nextStep ?? 0)
-                    ? initialToolExposureCheckpoint
-                    : undefined,
+                toolCalls,
+                usage: totalUsage,
+                latestAssistantText,
+                completed: completedWithinStepBudget,
+                ...(finalFinishReason ? { finishReason: finalFinishReason } : {}),
+                recoveredEmptyResponse,
+                startupSkillLoaded,
+                recoveredInterruptedLocalToolBatch,
+                hasSubmittedFormInput: skillState.hasSubmittedFormInput,
+                activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
+                // Omitted when empty so checkpoints without trusted loads keep the prior shape.
+                ...(() => {
+                    const ids = getTrustedSkillLoadResultIds(currentMessages);
+                    if (hasAmbiguousTrustedSkillLoadResultIds(currentMessages)) {
+                        return { trustedSkillLoadResultRefs: getTrustedSkillLoadResultRefs(currentMessages) };
+                    }
+                    return ids.length > 0 ? { trustedSkillLoadResultIds: ids } : {};
+                })(),
+                resumeToolCallExecuted,
+                agentWriteFinalResponseToolGuardEnabled,
+                interruptedLocalToolBatchRecoveryStep,
+                interruptedLocalToolBatchRecoveryText,
+                providerMetadata: mapPrivateArray(filterPrivateArray(currentMessages, (message) => readAttachedProviderMetadata(message) !== undefined), (message) => ({
+                    messageId: message.id,
+                    metadata: readAttachedProviderMetadata(message),
+                })),
+                runtimeGeneratedMessageIds: mapPrivateArray(filterPrivateArray(currentMessages, isRuntimeGeneratedUserMessage), (message) => message.id),
+                toolExposureCheckpoint: pauseToolExposureAuthorized
+                    ? createToolExposureCheckpoint(pauseToolExposureAuthorized, toolExposureState)
+                    : initialToolExposureCheckpoint,
             });
-            pauseToolExposureAuthorized = preparedStep.toolExposurePlan.authorized;
-            currentSystemPrompt = preparedStep.systemPrompt;
-            currentRuntimeContext = preparedStep.runtimeContext;
-            const toolContext = preparedStep.toolContext;
-            let effectiveToolExposurePlan = agentWriteFinalResponseToolGuardEnabled
-                ? applyAgentWriteFinalResponseGuard(preparedStep.toolExposurePlan, {
-                    reloadable: toolLoadingResolution.mode === "deferred",
-                })
-                : preparedStep.toolExposurePlan;
-            if (!startupSkillLoaded) {
-                await executeStartupSkill({
+            const pauseAtBoundary = async (nextStep) => {
+                if (this.#persistRecoveryBoundary) {
+                    const runtimeContinuation = captureRecoveryContinuation(nextStep);
+                    await this.#persistRecoveryBoundary({
+                        ...createRecoveryBoundary(currentMessages, runtimeContinuation.toolExposureCheckpoint ?? { version: 2, loadedToolNames: [] }),
+                        runtimeContinuation,
+                    });
+                }
+                if (!this.#manualPause)
+                    return;
+                if (this.#manualPause.requested && !(await this.#manualPause.requested()))
+                    return;
+                let saved;
+                try {
+                    saved = captureRecoveryContinuation(nextStep);
+                }
+                catch {
+                    if (this.#manualPause.release && !(await this.#manualPause.release()))
+                        return;
+                    logger.warn("Agent is held at a safe boundary because its pause continuation cannot be saved");
+                    throw agentManualPauseBoundary();
+                }
+                let acknowledged = false;
+                await validateProviderRequest(withAgentRunRuntimeContext(systemPrompt, runRuntimeContext), currentMessages, {
+                    beforeAcceptance: async () => {
+                        acknowledged = await this.#manualPause.acknowledge(saved);
+                        return acknowledged;
+                    },
+                });
+                if (acknowledged)
+                    throw agentManualPauseBoundary();
+            };
+            if (this.#manualPause) {
+                await validateProviderRequest(withAgentRunRuntimeContext(systemPrompt, runRuntimeContext), currentMessages, { deferAcceptance: true });
+                if (checkpoint) {
+                    const persistedIds = createPrivateSet(mapPrivateArray(messages, (message) => message.id));
+                    for (let index = 0; index < currentMessages.length; index++) {
+                        const message = currentMessages[index];
+                        if (persistedIds.has(message.id))
+                            continue;
+                        await persistMessage(message);
+                        persistedIds.add(message.id);
+                    }
+                }
+            }
+            await pauseAtBoundary(checkpoint?.nextStep ?? 0);
+            for (let step = checkpoint?.nextStep ?? 0; !completedWithinStepBudget && step < maxSteps; step++) {
+                throwIfAborted(abortSignal);
+                const currentStepToolResults = createPrivateMap();
+                const stepRuntimeContext = skillState.hasSubmittedFormInput
+                    ? markSubmittedFormInputRuntimeContext(currentRuntimeContext)
+                    : currentRuntimeContext;
+                const preparedStep = await prepareAgentRuntimeStep({
                     agentId: this.id,
-                    skillId: this.config.bootstrapSkill,
-                    authorized: preparedStep.startupAuthorizedTools,
+                    activeSkillId: skillState.activeSkillId,
+                    activeSkillToolAvailability: skillState.activeSkillToolAvailability,
+                    allowedRemoteToolNames,
+                    config: runtimeStepConfig,
+                    effectiveModel,
+                    ...resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
+                    reservedToolSlots: getToolResultReaderReservedSlots(toolResultContext),
+                    excludedToolNames: agentWriteFinalResponseToolGuardEnabled &&
+                        toolLoadingResolution.mode === "eager"
+                        ? AGENT_WRITE_FINAL_RESPONSE_EXCLUDED_TOOL_NAMES
+                        : undefined,
+                    forwardedRemoteToolDefinitions,
+                    getAvailableTools,
+                    unavailableOptionalRemoteToolNames: unavailableOptionalRemoteTools.names,
+                    unavailableOptionalRemoteToolPrefixes: unavailableOptionalRemoteTools.prefixes,
+                    supportsToolCalling,
+                    includeStartupAuthorizedTools: !startupSkillLoaded,
                     messages: currentMessages,
-                    persistMessage,
-                    skillState,
-                    toolCalls,
-                    onToolCall: callbacks?.onToolCall,
-                    ...(this.#persistRecoveryBoundary
+                    mode: "stream",
+                    modelRuntime: languageModel,
+                    providerOptionKey: resolveModelProviderOptionKey(effectiveModel, languageModel),
+                    authorizedProviderToolNames: providerTools,
+                    providerToolNames: supportsToolCalling && !agentWriteFinalResponseToolGuardEnabled
+                        ? providerTools
+                        : [],
+                    remoteToolSources,
+                    sourceIntegrationPolicy,
+                    resolveRuntimeState: this.resolveRuntimeState.bind(this),
+                    runtimeContext: stepRuntimeContext,
+                    step,
+                    systemPrompt: currentSystemPrompt,
+                    toolContextBase,
+                    frameworkLocalTools,
+                    toolExposureState,
+                    toolExposureCheckpoint: step === (checkpoint?.nextStep ?? 0)
+                        ? initialToolExposureCheckpoint
+                        : undefined,
+                });
+                pauseToolExposureAuthorized = preparedStep.toolExposurePlan.authorized;
+                currentSystemPrompt = preparedStep.systemPrompt;
+                currentRuntimeContext = preparedStep.runtimeContext;
+                const toolContext = preparedStep.toolContext;
+                let effectiveToolExposurePlan = agentWriteFinalResponseToolGuardEnabled
+                    ? applyAgentWriteFinalResponseGuard(preparedStep.toolExposurePlan, {
+                        reloadable: toolLoadingResolution.mode === "deferred",
+                    })
+                    : preparedStep.toolExposurePlan;
+                if (!startupSkillLoaded) {
+                    await executeStartupSkill({
+                        agentId: this.id,
+                        skillId: this.config.bootstrapSkill,
+                        authorized: preparedStep.startupAuthorizedTools,
+                        messages: currentMessages,
+                        persistMessage,
+                        skillState,
+                        toolCalls,
+                        onToolCall: callbacks?.onToolCall,
+                        ...(this.#persistRecoveryBoundary
+                            ? {
+                                recoveryStart: async (call) => {
+                                    const occurrenceId = introduceToolCallOccurrence(call);
+                                    if (!occurrenceId) {
+                                        throw new Error("Managed startup skill lacks original occurrence scope");
+                                    }
+                                    sendSSE(controller, encoder, {
+                                        type: "tool-input-start",
+                                        toolCallId: call.id,
+                                        toolName: call.name,
+                                        privateToolCallOccurrenceId: occurrenceId,
+                                    });
+                                    sendSSE(controller, encoder, {
+                                        type: "tool-input-available",
+                                        toolCallId: call.id,
+                                        toolName: call.name,
+                                        input: call.args,
+                                    });
+                                    await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
+                                },
+                                recoveryResult: async (call) => {
+                                    sendSSE(controller, encoder, call.error === undefined
+                                        ? { type: "tool-output-available", toolCallId: call.id, output: call.result }
+                                        : { type: "tool-output-error", toolCallId: call.id, errorText: call.error });
+                                    if (call.status === "completed")
+                                        startupSkillLoaded = true;
+                                    const runtimeContinuation = captureRecoveryContinuation(step);
+                                    await this.#persistRecoveryBoundary({
+                                        ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
+                                        runtimeContinuation,
+                                    });
+                                },
+                            }
+                            : {}),
+                        resolveLoader: (name) => resolveConfiguredTool(this.config.tools, name, { agentId: this.id }),
+                        execute: async (toolName, toolCallId, args, admittedTurn) => {
+                            const context = applicationExecutionContext(toolContext);
+                            const result = await traceConfiguredToolExecution({
+                                mode: "stream",
+                                agentId: this.id,
+                                toolName,
+                                toolCallId,
+                                args,
+                                admittedTurn,
+                                owner: currentMessages,
+                                prepareTerminalDispatch,
+                                toolsConfig: this.config.tools,
+                                context,
+                                allowedRemoteToolNames,
+                                remoteToolSources,
+                                sourceIntegrationPolicy,
+                                frameworkLocalTools,
+                            });
+                            await this.notifyToolResult({
+                                mode: "stream",
+                                toolName,
+                                toolCallId,
+                                input: args,
+                                result,
+                                context,
+                            });
+                            return result;
+                        },
+                    });
+                    startupSkillLoaded = true;
+                    // A pause requested while the loader ran must hold before the first
+                    // provider call; the checkpoint records the completed startup load.
+                    await pauseAtBoundary(step);
+                    // Refresh the active skill policy without consuming a model step.
+                    step--;
+                    continue;
+                }
+                const runtimeObservationStepId = runtimeObservationsEnabled ? dntShim.crypto.randomUUID() : undefined;
+                const runtimeObservationMessageSpanId = runtimeObservationStepId !== undefined
+                    ? dntShim.crypto.randomUUID()
+                    : undefined;
+                sendSSE(controller, encoder, {
+                    type: "step-start",
+                    ...(runtimeObservationStepId
                         ? {
-                            recoveryStart: async (call) => {
-                                const occurrenceId = introduceToolCallOccurrence(call);
-                                if (!occurrenceId) {
-                                    throw new Error("Managed startup skill lacks original occurrence scope");
-                                }
-                                sendSSE(controller, encoder, {
-                                    type: "tool-input-start",
-                                    toolCallId: call.id,
-                                    toolName: call.name,
-                                    privateToolCallOccurrenceId: occurrenceId,
-                                });
-                                sendSSE(controller, encoder, {
-                                    type: "tool-input-available",
-                                    toolCallId: call.id,
-                                    toolName: call.name,
-                                    input: call.args,
-                                });
-                                await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
-                            },
-                            recoveryResult: async (call) => {
-                                sendSSE(controller, encoder, call.error === undefined
-                                    ? { type: "tool-output-available", toolCallId: call.id, output: call.result }
-                                    : { type: "tool-output-error", toolCallId: call.id, errorText: call.error });
-                                if (call.status === "completed")
-                                    startupSkillLoaded = true;
-                                const runtimeContinuation = captureRecoveryContinuation(step);
-                                await this.#persistRecoveryBoundary({
-                                    ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
-                                    runtimeContinuation,
-                                });
+                            privateRuntimeObservation: {
+                                version: 1,
+                                kind: "step_started",
+                                stepId: runtimeObservationStepId,
                             },
                         }
                         : {}),
-                    resolveLoader: (name) => resolveConfiguredTool(this.config.tools, name, { agentId: this.id }),
-                    execute: async (toolName, toolCallId, args, admittedTurn) => {
-                        const context = applicationExecutionContext(toolContext);
-                        const result = await traceConfiguredToolExecution({
+                });
+                assertToolResultReaderNameAvailable({
+                    plan: effectiveToolExposurePlan,
+                    context: toolResultContext,
+                });
+                if (!resumeToolCallExecuted && this.#resumeToolCall) {
+                    const resumeToolCall = this.#resumeToolCall;
+                    resumeToolCallExecuted = true;
+                    const inputText = privateJsonStringify(resumeToolCall.input);
+                    const streamedCall = {
+                        id: resumeToolCall.id,
+                        name: resumeToolCall.name,
+                        arguments: inputText,
+                        inputDeltas: [inputText],
+                        inputAvailable: true,
+                    };
+                    announceStreamedToolCallInput(controller, encoder, streamedCall, (name) => isDynamicTool(name, this.config.tools));
+                    sendSSE(controller, encoder, {
+                        type: "tool-input-available",
+                        toolCallId: resumeToolCall.id,
+                        toolName: resumeToolCall.name,
+                        input: resumeToolCall.input,
+                        ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
+                    });
+                    const assistantToolCallMessage = {
+                        id: generateMessageId(),
+                        role: "assistant",
+                        parts: [{
+                                type: `tool-${resumeToolCall.name}`,
+                                toolCallId: resumeToolCall.id,
+                                toolName: resumeToolCall.name,
+                                args: resumeToolCall.input,
+                            }],
+                    };
+                    let admittedTurn = snapshotAdmittedToolTurn(assistantToolCallMessage, currentMessages.length);
+                    for (let index = currentMessages.length - 1; index >= 0; index--) {
+                        const message = currentMessages[index];
+                        if (message.role !== "assistant")
+                            continue;
+                        const candidate = snapshotAdmittedToolTurn(message, index);
+                        if (somePrivateArray(candidate.calls, (call) => call.toolCallId === resumeToolCall.id && call.toolName === resumeToolCall.name &&
+                            providerValuesEqual(call.input, resumeToolCall.input, new IntrinsicWeakMap())))
+                            admittedTurn = candidate;
+                        // A newer assistant envelope is a turn boundary, never inferred replay provenance.
+                        break;
+                    }
+                    if (admittedTurn.start === currentMessages.length) {
+                        pushPrivateArray(currentMessages, assistantToolCallMessage);
+                        await persistMessage(assistantToolCallMessage);
+                    }
+                    if (this.#persistRecoveryBoundary) {
+                        await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
+                        throwIfAborted(abortSignal);
+                    }
+                    const toolCall = {
+                        id: resumeToolCall.id,
+                        name: resumeToolCall.name,
+                        args: resumeToolCall.input,
+                        status: "executing",
+                    };
+                    const executionContext = applicationExecutionContext(toolContext, 
+                    // Partial results from the parked assistant turn were not yet provider-observed.
+                    getProviderObservedSkillBodies(slicePrivateArray(currentMessages, 0, admittedTurn.start)));
+                    let resumeAdmissionRejection;
+                    try {
+                        // The trusted parked call was already exposed in the prior segment.
+                        // Recheck current authorization without requiring its lost step visibility.
+                        const resumeExecutionAuthority = resolveToolExecutionAuthority({
+                            toolName: resumeToolCall.name,
+                            plan: {
+                                ...effectiveToolExposurePlan,
+                                visible: effectiveToolExposurePlan.authorized,
+                            },
+                        });
+                        if (resumeExecutionAuthority === undefined) {
+                            throw new Error(toolNotVisibleError(resumeToolCall.name));
+                        }
+                        const policyCheck = enforceSkillPolicy(resumeToolCall.name, {
+                            activeSkillId: skillState.activeSkillId,
+                            hasSubmittedFormInput: skillState.hasSubmittedFormInput,
+                            skillToolAvailability: skillState.activeSkillToolAvailability,
+                            toolInput: toolCall.args,
+                            toolDefinition: resumeExecutionAuthority.toolDefinition,
+                        });
+                        if (!policyCheck.allowed)
+                            throw new Error(policyCheck.error);
+                        toolCall.args = applySkillDelegationOverridesToToolInput(resumeToolCall.name, toolCall.args, skillState.activeSkillDelegationOverrides, resolveConfiguredTool(this.config.tools, resumeToolCall.name, { agentId: this.id }) ??
+                            undefined);
+                        // Resuming a trusted parked tool is a real dispatch even before the
+                        // next provider request. Validate before its effect, then retain that
+                        // accepted history if later provider preparation fails.
+                        try {
+                            await validateProviderRequest(withAgentRunRuntimeContext(currentSystemPrompt, runRuntimeContext), currentMessages);
+                        }
+                        catch (error) {
+                            resumeAdmissionRejection = { error };
+                            throw error;
+                        }
+                        callbacks?.onToolCall?.(toolCall);
+                        const startTime = Date.now();
+                        const result = await runWithToolCallOccurrenceDispatch(streamedCall, () => traceConfiguredToolExecution({
                             mode: "stream",
                             agentId: this.id,
-                            toolName,
-                            toolCallId,
-                            args,
+                            toolName: resumeToolCall.name,
+                            toolCallId: resumeToolCall.id,
+                            args: toolCall.args,
                             admittedTurn,
                             owner: currentMessages,
                             prepareTerminalDispatch,
                             toolsConfig: this.config.tools,
-                            context,
+                            context: executionContext,
                             allowedRemoteToolNames,
                             remoteToolSources,
                             sourceIntegrationPolicy,
                             frameworkLocalTools,
-                        });
+                        }));
+                        throwIfAborted(abortSignal);
                         await this.notifyToolResult({
                             mode: "stream",
-                            toolName,
-                            toolCallId,
-                            input: args,
+                            toolName: resumeToolCall.name,
+                            toolCallId: resumeToolCall.id,
+                            input: toolCall.args,
                             result,
-                            context,
+                            context: executionContext,
                         });
-                        return result;
-                    },
-                });
-                startupSkillLoaded = true;
-                // A pause requested while the loader ran must hold before the first
-                // provider call; the checkpoint records the completed startup load.
-                await pauseAtBoundary(step);
-                // Refresh the active skill policy without consuming a model step.
-                step--;
-                continue;
-            }
-            const runtimeObservationStepId = runtimeObservationsEnabled ? dntShim.crypto.randomUUID() : undefined;
-            const runtimeObservationMessageSpanId = runtimeObservationStepId !== undefined
-                ? dntShim.crypto.randomUUID()
-                : undefined;
-            sendSSE(controller, encoder, {
-                type: "step-start",
-                ...(runtimeObservationStepId
-                    ? {
-                        privateRuntimeObservation: {
-                            version: 1,
-                            kind: "step_started",
-                            stepId: runtimeObservationStepId,
-                        },
+                        const resultError = getToolResultError(result);
+                        toolCall.status = resultError === undefined ? "completed" : "error";
+                        toolCall.result = result;
+                        toolCall.error = resultError;
+                        toolCall.executionTime = Date.now() - startTime;
+                        pushPrivateArray(toolCalls, toolCall);
+                        if (resultError === undefined) {
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-available",
+                                toolCallId: resumeToolCall.id,
+                                output: result,
+                                ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
+                            });
+                        }
+                        else {
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-error",
+                                toolCallId: resumeToolCall.id,
+                                errorText: resultError,
+                                ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
+                            });
+                        }
+                        const toolResultMessage = createPolicyAwareToolResultMessage(resumeToolCall.id, resumeToolCall.name, result, resumeExecutionAuthority.toolDefinition, false, true);
+                        pushPrivateArray(currentMessages, toolResultMessage);
+                        await persistMessage(toolResultMessage);
                     }
-                    : {}),
-            });
-            assertToolResultReaderNameAvailable({
-                plan: effectiveToolExposurePlan,
-                context: toolResultContext,
-            });
-            if (!resumeToolCallExecuted && this.#resumeToolCall) {
-                const resumeToolCall = this.#resumeToolCall;
-                resumeToolCallExecuted = true;
-                const inputText = privateJsonStringify(resumeToolCall.input);
-                const streamedCall = {
-                    id: resumeToolCall.id,
-                    name: resumeToolCall.name,
-                    arguments: inputText,
-                    inputDeltas: [inputText],
-                    inputAvailable: true,
-                };
-                announceStreamedToolCallInput(controller, encoder, streamedCall, (name) => isDynamicTool(name, this.config.tools));
-                sendSSE(controller, encoder, {
-                    type: "tool-input-available",
-                    toolCallId: resumeToolCall.id,
-                    toolName: resumeToolCall.name,
-                    input: resumeToolCall.input,
-                    ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
-                });
-                const assistantToolCallMessage = {
-                    id: generateMessageId(),
-                    role: "assistant",
-                    parts: [{
-                            type: `tool-${resumeToolCall.name}`,
-                            toolCallId: resumeToolCall.id,
-                            toolName: resumeToolCall.name,
-                            args: resumeToolCall.input,
-                        }],
-                };
-                let admittedTurn = snapshotAdmittedToolTurn(assistantToolCallMessage, currentMessages.length);
-                for (let index = currentMessages.length - 1; index >= 0; index--) {
-                    const message = currentMessages[index];
-                    if (message.role !== "assistant")
-                        continue;
-                    const candidate = snapshotAdmittedToolTurn(message, index);
-                    if (somePrivateArray(candidate.calls, (call) => call.toolCallId === resumeToolCall.id && call.toolName === resumeToolCall.name &&
-                        providerValuesEqual(call.input, resumeToolCall.input, new IntrinsicWeakMap())))
-                        admittedTurn = candidate;
-                    // A newer assistant envelope is a turn boundary, never inferred replay provenance.
-                    break;
-                }
-                if (admittedTurn.start === currentMessages.length) {
-                    pushPrivateArray(currentMessages, assistantToolCallMessage);
-                    await persistMessage(assistantToolCallMessage);
+                    catch (error) {
+                        // A turn admission rejection belongs to the request, not the tool:
+                        // surface it as the request error instead of a tool-output-error.
+                        if (resumeAdmissionRejection?.error === error)
+                            throw error;
+                        await this.recordTerminalToolResult(error, toolCall, persistMessage, currentMessages, toolCalls, totalUsage, { controller, encoder });
+                        throwIfAborted(abortSignal);
+                        await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
+                    }
+                    if (this.#persistRecoveryBoundary)
+                        await pauseAtBoundary(step);
                 }
+                // Include the parked result delivered to this request, but exclude new same-step results.
+                const providerObservedSkillBodies = getProviderObservedSkillBodies(currentMessages);
+                const baseSystemPrompt = currentSystemPrompt;
+                const assembleRequest = (messages, plan = effectiveToolExposurePlan) => assembleRuntimeStepRequest({
+                    messages,
+                    plan,
+                    toolResultContext,
+                    supportsToolCalling,
+                    agentWriteFinalResponseToolGuardEnabled,
+                    providerTools,
+                    model: effectiveModel,
+                    languageModel,
+                    toolSchemaOptions: resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
+                    baseSystemPrompt,
+                    integrationToolDiscovery: preparedStep.integrationToolDiscovery,
+                    runRuntimeContext,
+                    bootstrapToolNames: preparedStep.configuredBootstrapToolNames,
+                });
+                const requestedOutputTokens = this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride);
+                // An invalid thinking budget is left for the provider path to reject.
+                const additionalOutputTokens = resolveAdditiveReasoningOutputTokens(languageModel, {
+                    reasoning,
+                    providerOptions,
+                }) ?? 0;
+                const fittedRequest = await fitRuntimeStepRequestToServedBudget({
+                    sourceMessages: currentMessages,
+                    modelMessages: toolResultContext
+                        ? createModelToolResultContextMessages(currentMessages, toolResultContext)
+                        : currentMessages,
+                    plan: effectiveToolExposurePlan,
+                    assembleRequest,
+                    toolResultContext,
+                    supportsToolCalling,
+                    deferredToolLoading: toolLoadingResolution.mode === "deferred",
+                    languageModel,
+                    model: effectiveModel,
+                    reasoning,
+                    providerOptions,
+                    responseFormat: outputSchema?.responseFormat,
+                    requestedOutputTokens,
+                    explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
+                    additionalOutputTokens,
+                    toolExposureState,
+                    persistToolExposureCheckpoint,
+                    requireToolExposureCheckpointPersistence,
+                    turnAdmission: validateProviderRequest,
+                });
+                const modelMessages = fittedRequest.modelMessages;
+                effectiveToolExposurePlan = fittedRequest.plan;
                 if (this.#persistRecoveryBoundary) {
                     await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
                     throwIfAborted(abortSignal);
                 }
-                const toolCall = {
-                    id: resumeToolCall.id,
-                    name: resumeToolCall.name,
-                    args: resumeToolCall.input,
-                    status: "executing",
+                const request = assembleRequest(modelMessages);
+                currentSystemPrompt = request.systemPrompt;
+                const { tools, runtimeTools, providerSystemPrompt, providerMessages } = request;
+                setOtelActiveSpanAttributes({
+                    "tool.loading.mode": resolveRuntimeToolLoading(runtimeStepConfig).mode,
+                    "tool.loading.provenance": toolLoadingResolution.provenance,
+                    "tool.catalog.authorized_count": preparedStep.toolExposurePlan.authorized.length,
+                    "tool.catalog.visible_count": tools.length,
+                    "tool.catalog.deferred_count": effectiveToolExposurePlan.deferred.length,
+                    "tool.loading.path": "framework-fallback",
+                });
+                const runtimeToolNames = Object.keys(runtimeTools ?? {}).sort(compareStrings);
+                const acceptedRuntimeToolNames = collectAcceptedRuntimeToolNames(runtimeTools, effectiveToolExposurePlan);
+                const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel, providerOptions);
+                const genAiProviderName = resolveRuntimeGenAiProviderName(effectiveModel);
+                // Reject an over-budget request before the turn is accepted, so a
+                // rejected input is rolled back instead of committed to memory.
+                const { maxOutputTokens } = enforceProviderRequestBudget({
+                    model: languageModel,
+                    ...(reasoning === undefined ? {} : { reasoning }),
+                    ...(providerOptions === undefined ? {} : { providerOptions }),
+                    system: providerSystemPrompt,
+                    messages: providerMessages,
+                    tools: runtimeTools,
+                    responseFormat: outputSchema?.responseFormat,
+                    limit: fittedRequest.servedLimit,
+                    requestedOutputTokens,
+                    explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
+                    additionalOutputTokens,
+                });
+                await validateProviderRequest(providerSystemPrompt, modelMessages, { beforeAcceptance: fittedRequest.commitToolExposure });
+                const streamLifecycleMode = resolveStreamLifecycleModeFromEnv();
+                const streamModel = withRuntimeProviderStreamErrorProvenance(languageModel);
+                const streamSource = createRuntimeStreamSource((streamSignal) => streamTextForObservedAgentRuntime({
+                    model: streamModel,
+                    system: providerSystemPrompt,
+                    messages: providerMessages,
+                    tools: runtimeTools,
+                    experimental_repairToolCall: repairToolCall,
+                    maxOutputTokens,
+                    ...(temperature === undefined ? {} : { temperature }),
+                    ...(this.config.parallelToolCalls === undefined
+                        ? {}
+                        : { parallelToolCalls: this.config.parallelToolCalls }),
+                    ...(headers ? { headers } : {}),
+                    ...(providerOptions ? { providerOptions } : {}),
+                    ...(reasoning ? { reasoning } : {}),
+                    ...(outputSchema ? { responseFormat: outputSchema.responseFormat } : {}),
+                    abortSignal: streamSignal,
+                }));
+                let state = createStreamState();
+                // Hold a possible replay only while it remains a prefix of the text the
+                // client already received. Once it diverges, resume live delivery.
+                const deferInterruptedRecoveryOutput = step === interruptedLocalToolBatchRecoveryStep &&
+                    interruptedLocalToolBatchRecoveryText !== undefined;
+                const deferredRecoveryOutput = deferInterruptedRecoveryOutput ? [] : undefined;
+                const previousRecoveryText = interruptedLocalToolBatchRecoveryText ?? "";
+                let deferredRecoverySseText = "";
+                let deferredRecoveryCallbackText = "";
+                let releasedDeferredRecoveryOutput = false;
+                let releasedRecoveryReplacementTextPartId;
+                let suppressedRecoveryReplayTextLength = 0;
+                const stepTextPartId = textPartId === undefined || step === 0
+                    ? textPartId
+                    : `${textPartId}:step:${step}`;
+                const replacementRecoveryTextPartId = stepTextPartId === undefined
+                    ? `recovery:step:${step}`
+                    : `${stepTextPartId}:recovery`;
+                const remainingRecoveryReplayText = () => privateTextSlice(previousRecoveryText, suppressedRecoveryReplayTextLength);
+                const flushDeferredRecoveryOutput = (interruptedRecoveryPrefixLength, repeatsInterruptedRecoveryText, useReplacementTextPartId) => {
+                    if (deferredRecoveryOutput === undefined)
+                        return;
+                    let remainingSsePrefixLength = interruptedRecoveryPrefixLength;
+                    let remainingCallbackPrefixLength = interruptedRecoveryPrefixLength;
+                    for (let outputIndex = 0; outputIndex < deferredRecoveryOutput.length; outputIndex++) {
+                        if (!ObjectHasOwn(deferredRecoveryOutput, outputIndex))
+                            continue;
+                        const output = deferredRecoveryOutput[outputIndex];
+                        if (repeatsInterruptedRecoveryText &&
+                            (output.kind === "callback" || output.isTextEvent)) {
+                            continue;
+                        }
+                        if (output.kind === "callback") {
+                            const stripped = stripLeadingText(output.chunk, remainingCallbackPrefixLength);
+                            remainingCallbackPrefixLength = stripped.remainingPrefixLength;
+                            if (stripped.text.length > 0) {
+                                callbacks?.onChunk?.(stripped.text);
+                            }
+                        }
+                        else {
+                            const textChunk = useReplacementTextPartId && output.isTextEvent
+                                ? rewriteRecoveryTextSseChunkId(output.chunk, replacementRecoveryTextPartId, encoder)
+                                : output.chunk;
+                            const stripped = output.isTextEvent
+                                ? stripTextDeltaPrefixFromSseChunk(textChunk, remainingSsePrefixLength, encoder)
+                                : { chunk: textChunk, remainingPrefixLength: remainingSsePrefixLength };
+                            remainingSsePrefixLength = stripped.remainingPrefixLength;
+                            if (stripped.chunk !== undefined) {
+                                enqueuePrivateStream(controller, stripped.chunk);
+                            }
+                        }
+                    }
+                    deferredRecoveryOutput.length = 0;
                 };
-                const executionContext = applicationExecutionContext(toolContext, 
-                // Partial results from the parked assistant turn were not yet provider-observed.
-                getProviderObservedSkillBodies(slicePrivateArray(currentMessages, 0, admittedTurn.start)));
-                let resumeAdmissionRejection;
-                try {
-                    // The trusted parked call was already exposed in the prior segment.
-                    // Recheck current authorization without requiring its lost step visibility.
-                    const resumeExecutionAuthority = resolveToolExecutionAuthority({
-                        toolName: resumeToolCall.name,
-                        plan: {
-                            ...effectiveToolExposurePlan,
-                            visible: effectiveToolExposurePlan.authorized,
-                        },
-                    });
-                    if (resumeExecutionAuthority === undefined) {
-                        throw new Error(toolNotVisibleError(resumeToolCall.name));
+                const releaseDeferredRecoveryOutputAfterDivergence = () => {
+                    if (deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput)
+                        return;
+                    const expectedReplayText = remainingRecoveryReplayText();
+                    const sseDiverged = !privateTextStartsWith(expectedReplayText, deferredRecoverySseText);
+                    const callbackDiverged = callbacks?.onChunk === undefined ||
+                        !privateTextStartsWith(expectedReplayText, deferredRecoveryCallbackText);
+                    if (!sseDiverged || !callbackDiverged)
+                        return;
+                    const observedRecoveryText = callbacks?.onChunk === undefined
+                        ? deferredRecoverySseText
+                        : deferredRecoveryCallbackText;
+                    const extendsPreviousRecoveryText = privateTextStartsWith(observedRecoveryText, expectedReplayText);
+                    flushDeferredRecoveryOutput(extendsPreviousRecoveryText ? expectedReplayText.length : 0, false, !extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength === 0);
+                    if (extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength > 0) {
+                        suppressedRecoveryReplayTextLength += expectedReplayText.length;
                     }
-                    const policyCheck = enforceSkillPolicy(resumeToolCall.name, {
-                        activeSkillId: skillState.activeSkillId,
-                        hasSubmittedFormInput: skillState.hasSubmittedFormInput,
-                        skillToolAvailability: skillState.activeSkillToolAvailability,
-                        toolInput: toolCall.args,
-                        toolDefinition: resumeExecutionAuthority.toolDefinition,
-                    });
-                    if (!policyCheck.allowed)
-                        throw new Error(policyCheck.error);
-                    toolCall.args = applySkillDelegationOverridesToToolInput(resumeToolCall.name, toolCall.args, skillState.activeSkillDelegationOverrides, resolveConfiguredTool(this.config.tools, resumeToolCall.name, { agentId: this.id }) ??
-                        undefined);
-                    // Resuming a trusted parked tool is a real dispatch even before the
-                    // next provider request. Validate before its effect, then retain that
-                    // accepted history if later provider preparation fails.
-                    try {
-                        await validateProviderRequest(withAgentRunRuntimeContext(currentSystemPrompt, runRuntimeContext), currentMessages);
+                    if (!extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength === 0) {
+                        releasedRecoveryReplacementTextPartId = replacementRecoveryTextPartId;
                     }
-                    catch (error) {
-                        resumeAdmissionRejection = { error };
-                        throw error;
+                    releasedDeferredRecoveryOutput = true;
+                };
+                const releaseDeferredRecoveryOutputAfterExactReplay = (isTextEvent) => {
+                    if (isTextEvent || deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput ||
+                        deferredRecoverySseText !== remainingRecoveryReplayText() ||
+                        (callbacks?.onChunk !== undefined &&
+                            deferredRecoveryCallbackText !== remainingRecoveryReplayText())) {
+                        return;
                     }
-                    callbacks?.onToolCall?.(toolCall);
-                    const startTime = Date.now();
-                    const result = await runWithToolCallOccurrenceDispatch(streamedCall, () => traceConfiguredToolExecution({
-                        mode: "stream",
-                        agentId: this.id,
-                        toolName: resumeToolCall.name,
-                        toolCallId: resumeToolCall.id,
-                        args: toolCall.args,
-                        admittedTurn,
-                        owner: currentMessages,
-                        prepareTerminalDispatch,
-                        toolsConfig: this.config.tools,
-                        context: executionContext,
-                        allowedRemoteToolNames,
-                        remoteToolSources,
-                        sourceIntegrationPolicy,
-                        frameworkLocalTools,
-                    }));
-                    throwIfAborted(abortSignal);
-                    await this.notifyToolResult({
-                        mode: "stream",
-                        toolName: resumeToolCall.name,
-                        toolCallId: resumeToolCall.id,
-                        input: toolCall.args,
-                        result,
-                        context: executionContext,
-                    });
-                    const resultError = getToolResultError(result);
-                    toolCall.status = resultError === undefined ? "completed" : "error";
-                    toolCall.result = result;
-                    toolCall.error = resultError;
-                    toolCall.executionTime = Date.now() - startTime;
-                    pushPrivateArray(toolCalls, toolCall);
-                    if (resultError === undefined) {
-                        sendSSE(controller, encoder, {
-                            type: "tool-output-available",
-                            toolCallId: resumeToolCall.id,
-                            output: result,
-                            ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
-                        });
+                    flushDeferredRecoveryOutput(remainingRecoveryReplayText().length, false, false);
+                    releasedDeferredRecoveryOutput = true;
+                };
+                const releaseDeferredRecoveryNonTextOutput = (isTextEvent) => {
+                    if (isTextEvent || deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput) {
+                        return;
                     }
-                    else {
-                        sendSSE(controller, encoder, {
-                            type: "tool-output-error",
-                            toolCallId: resumeToolCall.id,
-                            errorText: resultError,
-                            ...(isDynamicTool(resumeToolCall.name, this.config.tools) ? { dynamic: true } : {}),
-                        });
+                    const retainedOutput = filterPrivateArray(deferredRecoveryOutput, (output) => output.kind === "callback" || output.isTextEvent);
+                    for (let outputIndex = 0; outputIndex < deferredRecoveryOutput.length; outputIndex++) {
+                        if (!ObjectHasOwn(deferredRecoveryOutput, outputIndex))
+                            continue;
+                        const output = deferredRecoveryOutput[outputIndex];
+                        if (output.kind === "sse" && !output.isTextEvent) {
+                            enqueuePrivateStream(controller, output.chunk);
+                        }
                     }
-                    const toolResultMessage = createPolicyAwareToolResultMessage(resumeToolCall.id, resumeToolCall.name, result, resumeExecutionAuthority.toolDefinition, false, true);
-                    pushPrivateArray(currentMessages, toolResultMessage);
-                    await persistMessage(toolResultMessage);
-                }
-                catch (error) {
-                    // A turn admission rejection belongs to the request, not the tool:
-                    // surface it as the request error instead of a tool-output-error.
-                    if (resumeAdmissionRejection?.error === error)
-                        throw error;
-                    await this.recordTerminalToolResult(error, toolCall, persistMessage, currentMessages, toolCalls, totalUsage, { controller, encoder });
-                    throwIfAborted(abortSignal);
-                    await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
-                }
-                if (this.#persistRecoveryBoundary)
-                    await pauseAtBoundary(step);
-            }
-            // Include the parked result delivered to this request, but exclude new same-step results.
-            const providerObservedSkillBodies = getProviderObservedSkillBodies(currentMessages);
-            const baseSystemPrompt = currentSystemPrompt;
-            const assembleRequest = (messages, plan = effectiveToolExposurePlan) => assembleRuntimeStepRequest({
-                messages,
-                plan,
-                toolResultContext,
-                supportsToolCalling,
-                agentWriteFinalResponseToolGuardEnabled,
-                providerTools,
-                model: effectiveModel,
-                languageModel,
-                toolSchemaOptions: resolveStepToolSchemaOptions(this.config, languageModel, effectiveModel),
-                baseSystemPrompt,
-                integrationToolDiscovery: preparedStep.integrationToolDiscovery,
-                runRuntimeContext,
-                bootstrapToolNames: preparedStep.configuredBootstrapToolNames,
-            });
-            const requestedOutputTokens = this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride);
-            // An invalid thinking budget is left for the provider path to reject.
-            const additionalOutputTokens = resolveAdditiveReasoningOutputTokens(languageModel, {
-                reasoning,
-                providerOptions,
-            }) ?? 0;
-            const fittedRequest = await fitRuntimeStepRequestToServedBudget({
-                sourceMessages: currentMessages,
-                modelMessages: toolResultContext
-                    ? createModelToolResultContextMessages(currentMessages, toolResultContext)
-                    : currentMessages,
-                plan: effectiveToolExposurePlan,
-                assembleRequest,
-                toolResultContext,
-                supportsToolCalling,
-                deferredToolLoading: toolLoadingResolution.mode === "deferred",
-                languageModel,
-                model: effectiveModel,
-                reasoning,
-                providerOptions,
-                responseFormat: outputSchema?.responseFormat,
-                requestedOutputTokens,
-                explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
-                additionalOutputTokens,
-                toolExposureState,
-                persistToolExposureCheckpoint,
-                requireToolExposureCheckpointPersistence,
-                turnAdmission: validateProviderRequest,
-            });
-            const modelMessages = fittedRequest.modelMessages;
-            effectiveToolExposurePlan = fittedRequest.plan;
-            if (this.#persistRecoveryBoundary) {
-                await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
-                throwIfAborted(abortSignal);
-            }
-            const request = assembleRequest(modelMessages);
-            currentSystemPrompt = request.systemPrompt;
-            const { tools, runtimeTools, providerSystemPrompt, providerMessages } = request;
-            setOtelActiveSpanAttributes({
-                "tool.loading.mode": resolveRuntimeToolLoading(runtimeStepConfig).mode,
-                "tool.loading.provenance": toolLoadingResolution.provenance,
-                "tool.catalog.authorized_count": preparedStep.toolExposurePlan.authorized.length,
-                "tool.catalog.visible_count": tools.length,
-                "tool.catalog.deferred_count": effectiveToolExposurePlan.deferred.length,
-                "tool.loading.path": "framework-fallback",
-            });
-            const runtimeToolNames = Object.keys(runtimeTools ?? {}).sort(compareStrings);
-            const acceptedRuntimeToolNames = collectAcceptedRuntimeToolNames(runtimeTools, effectiveToolExposurePlan);
-            const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel, providerOptions);
-            const genAiProviderName = resolveRuntimeGenAiProviderName(effectiveModel);
-            // Reject an over-budget request before the turn is accepted, so a
-            // rejected input is rolled back instead of committed to memory.
-            const { maxOutputTokens } = enforceProviderRequestBudget({
-                model: languageModel,
-                ...(reasoning === undefined ? {} : { reasoning }),
-                ...(providerOptions === undefined ? {} : { providerOptions }),
-                system: providerSystemPrompt,
-                messages: providerMessages,
-                tools: runtimeTools,
-                responseFormat: outputSchema?.responseFormat,
-                limit: fittedRequest.servedLimit,
-                requestedOutputTokens,
-                explicitOutputTokens: isMaxOutputTokensOverride(maxOutputTokensOverride),
-                additionalOutputTokens,
-            });
-            await validateProviderRequest(providerSystemPrompt, modelMessages, { beforeAcceptance: fittedRequest.commitToolExposure });
-            const streamLifecycleMode = resolveStreamLifecycleModeFromEnv();
-            const streamModel = withRuntimeProviderStreamErrorProvenance(languageModel);
-            const streamSource = createRuntimeStreamSource((streamSignal) => streamTextForObservedAgentRuntime({
-                model: streamModel,
-                system: providerSystemPrompt,
-                messages: providerMessages,
-                tools: runtimeTools,
-                experimental_repairToolCall: repairToolCall,
-                maxOutputTokens,
-                ...(temperature === undefined ? {} : { temperature }),
-                ...(this.config.parallelToolCalls === undefined
-                    ? {}
-                    : { parallelToolCalls: this.config.parallelToolCalls }),
-                ...(headers ? { headers } : {}),
-                ...(providerOptions ? { providerOptions } : {}),
-                ...(reasoning ? { reasoning } : {}),
-                ...(outputSchema ? { responseFormat: outputSchema.responseFormat } : {}),
-                abortSignal: streamSignal,
-            }));
-            let state = createStreamState();
-            // Hold a possible replay only while it remains a prefix of the text the
-            // client already received. Once it diverges, resume live delivery.
-            const deferInterruptedRecoveryOutput = step === interruptedLocalToolBatchRecoveryStep &&
-                interruptedLocalToolBatchRecoveryText !== undefined;
-            const deferredRecoveryOutput = deferInterruptedRecoveryOutput ? [] : undefined;
-            const previousRecoveryText = interruptedLocalToolBatchRecoveryText ?? "";
-            let deferredRecoverySseText = "";
-            let deferredRecoveryCallbackText = "";
-            let releasedDeferredRecoveryOutput = false;
-            let releasedRecoveryReplacementTextPartId;
-            let suppressedRecoveryReplayTextLength = 0;
-            const stepTextPartId = textPartId === undefined || step === 0
-                ? textPartId
-                : `${textPartId}:step:${step}`;
-            const replacementRecoveryTextPartId = stepTextPartId === undefined
-                ? `recovery:step:${step}`
-                : `${stepTextPartId}:recovery`;
-            const remainingRecoveryReplayText = () => privateTextSlice(previousRecoveryText, suppressedRecoveryReplayTextLength);
-            const flushDeferredRecoveryOutput = (interruptedRecoveryPrefixLength, repeatsInterruptedRecoveryText, useReplacementTextPartId) => {
-                if (deferredRecoveryOutput === undefined)
-                    return;
-                let remainingSsePrefixLength = interruptedRecoveryPrefixLength;
-                let remainingCallbackPrefixLength = interruptedRecoveryPrefixLength;
-                for (let outputIndex = 0; outputIndex < deferredRecoveryOutput.length; outputIndex++) {
-                    if (!ObjectHasOwn(deferredRecoveryOutput, outputIndex))
-                        continue;
-                    const output = deferredRecoveryOutput[outputIndex];
-                    if (repeatsInterruptedRecoveryText &&
-                        (output.kind === "callback" || output.isTextEvent)) {
-                        continue;
+                    deferredRecoveryOutput.length = 0;
+                    appendPrivateArray(deferredRecoveryOutput, retainedOutput);
+                };
+                const reconcileDeferredRecoveryTextSegment = (isTextEndEvent) => {
+                    if (!isTextEndEvent || deferredRecoveryOutput === undefined ||
+                        releasedDeferredRecoveryOutput ||
+                        !privateTextStartsWith(remainingRecoveryReplayText(), deferredRecoverySseText) ||
+                        (callbacks?.onChunk !== undefined &&
+                            !privateTextStartsWith(remainingRecoveryReplayText(), deferredRecoveryCallbackText))) {
+                        return;
                     }
-                    if (output.kind === "callback") {
-                        const stripped = stripLeadingText(output.chunk, remainingCallbackPrefixLength);
-                        remainingCallbackPrefixLength = stripped.remainingPrefixLength;
-                        if (stripped.text.length > 0) {
-                            callbacks?.onChunk?.(stripped.text);
-                        }
+                    // A tool or reasoning event closes the current text segment. If that
+                    // segment only replayed a prefix the client already received, discard
+                    // it now and treat later text as a distinct segment. Otherwise retained
+                    // prefix events could be released after the boundary when later text
+                    // diverges, duplicating and reordering the replay.
+                    suppressedRecoveryReplayTextLength += deferredRecoverySseText.length;
+                    deferredRecoveryOutput.length = 0;
+                    deferredRecoverySseText = "";
+                    deferredRecoveryCallbackText = "";
+                };
+                let sawProviderStreamEvent = false;
+                const enqueueStepChunk = (chunk) => {
+                    sawProviderStreamEvent = true;
+                    enqueuePrivateStream(controller, chunk);
+                };
+                const stepController = deferredRecoveryOutput === undefined
+                    ? {
+                        enqueue: enqueueStepChunk,
+                    }
+                    : {
+                        enqueue(chunk) {
+                            sawProviderStreamEvent = true;
+                            if (releasedDeferredRecoveryOutput) {
+                                enqueuePrivateStream(controller, releasedRecoveryReplacementTextPartId !== undefined
+                                    ? rewriteRecoveryTextSseChunkId(chunk, releasedRecoveryReplacementTextPartId, encoder)
+                                    : chunk);
+                                return;
+                            }
+                            deferredRecoverySseText += textDeltaFromSseChunk(chunk) ?? "";
+                            const isTextEvent = isTextSseChunk(chunk);
+                            pushPrivateArray(deferredRecoveryOutput, {
+                                kind: "sse",
+                                chunk,
+                                isTextEvent,
+                            });
+                            releaseDeferredRecoveryOutputAfterDivergence();
+                            releaseDeferredRecoveryOutputAfterExactReplay(isTextEvent);
+                            releaseDeferredRecoveryNonTextOutput(isTextEvent);
+                            reconcileDeferredRecoveryTextSegment(isTextEndSseChunk(chunk));
+                        },
+                    };
+                bindRuntimeStreamForwardingController(stepController, controller);
+                let providerStreamRetryAttempts = 0;
+                let sawProviderStreamUsage = false;
+                while (true) {
+                    try {
+                        await processStream(streamSource, state, stepController, encoder, stepTextPartId, {
+                            onChunk: deferredRecoveryOutput === undefined ? callbacks?.onChunk : (chunk) => {
+                                if (releasedDeferredRecoveryOutput) {
+                                    callbacks?.onChunk?.(chunk);
+                                    return;
+                                }
+                                deferredRecoveryCallbackText += chunk;
+                                if (callbacks?.onChunk !== undefined) {
+                                    pushPrivateArray(deferredRecoveryOutput, { kind: "callback", chunk });
+                                }
+                                releaseDeferredRecoveryOutputAfterDivergence();
+                            },
+                            ...(runtimeObservationStepId !== undefined &&
+                                runtimeObservationMessageSpanId !== undefined
+                                ? {
+                                    runtimeObservationStepId,
+                                    runtimeObservationMessageSpanId,
+                                }
+                                : {}),
+                            onUsage: (usage) => {
+                                sawProviderStreamUsage = true;
+                                accumulateUsage(totalUsage, usage);
+                                // Snapshot, not the live object: a later step must not mutate a total
+                                // a caller has already recorded on a span.
+                                callbacks?.onUsage?.({ ...totalUsage });
+                            },
+                            streamRequiresFinish: languageModel.runtimeCapabilities?.streamRequiresFinish === true,
+                            requireProviderFinish: languageModel.runtimeCapabilities?.toolCallStreamRequiresFinish === true,
+                            providerExecutedToolNames: getProviderExecutedToolNames(runtimeTools),
+                            availableToolNames: acceptedRuntimeToolNames,
+                            dynamicToolNames: runtimeToolNames.filter((name) => isDynamicTool(name, this.config.tools)),
+                            streamLifecycleMode,
+                            ...(this.#modelStreamTimeouts
+                                ? { streamLifecyclePolicy: { ...this.#modelStreamTimeouts } }
+                                : {}),
+                            traceSpanName: `chat ${effectiveModel}`,
+                            traceAttributes: {
+                                ...(genAiProviderName ? { "gen_ai.provider.name": genAiProviderName } : {}),
+                                "gen_ai.request.model": effectiveModel,
+                                "gen_ai.response.model": effectiveModel,
+                                "gen_ai.request.max_tokens": maxOutputTokens,
+                                "gen_ai.output.type": "text",
+                                ...(temperature === undefined ? {} : { "gen_ai.request.temperature": temperature }),
+                            },
+                        }, abortSignal);
+                        break;
                     }
-                    else {
-                        const textChunk = useReplacementTextPartId && output.isTextEvent
-                            ? rewriteRecoveryTextSseChunkId(output.chunk, replacementRecoveryTextPartId, encoder)
-                            : output.chunk;
-                        const stripped = output.isTextEvent
-                            ? stripTextDeltaPrefixFromSseChunk(textChunk, remainingSsePrefixLength, encoder)
-                            : { chunk: textChunk, remainingPrefixLength: remainingSsePrefixLength };
-                        remainingSsePrefixLength = stripped.remainingPrefixLength;
-                        if (stripped.chunk !== undefined) {
-                            enqueuePrivateStream(controller, stripped.chunk);
+                    catch (error) {
+                        if (!shouldRetryRuntimeProviderStreamFailure({
+                            error,
+                            state,
+                            attempts: providerStreamRetryAttempts,
+                            abortSignal,
+                            hasUsageProgress: sawProviderStreamUsage,
+                            hasEmittedStreamEvent: sawProviderStreamEvent,
+                        })) {
+                            throw error;
                         }
+                        providerStreamRetryAttempts += 1;
+                        state = createStreamState();
                     }
                 }
-                deferredRecoveryOutput.length = 0;
-            };
-            const releaseDeferredRecoveryOutputAfterDivergence = () => {
-                if (deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput)
-                    return;
-                const expectedReplayText = remainingRecoveryReplayText();
-                const sseDiverged = !privateTextStartsWith(expectedReplayText, deferredRecoverySseText);
-                const callbackDiverged = callbacks?.onChunk === undefined ||
-                    !privateTextStartsWith(expectedReplayText, deferredRecoveryCallbackText);
-                if (!sseDiverged || !callbackDiverged)
-                    return;
-                const observedRecoveryText = callbacks?.onChunk === undefined
-                    ? deferredRecoverySseText
-                    : deferredRecoveryCallbackText;
-                const extendsPreviousRecoveryText = privateTextStartsWith(observedRecoveryText, expectedReplayText);
-                flushDeferredRecoveryOutput(extendsPreviousRecoveryText ? expectedReplayText.length : 0, false, !extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength === 0);
-                if (extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength > 0) {
-                    suppressedRecoveryReplayTextLength += expectedReplayText.length;
-                }
-                if (!extendsPreviousRecoveryText && suppressedRecoveryReplayTextLength === 0) {
-                    releasedRecoveryReplacementTextPartId = replacementRecoveryTextPartId;
+                throwIfAborted(abortSignal);
+                const interruptedRecoveryPrefixLength = deferredRecoveryOutput === undefined
+                    ? 0
+                    : privateTextStartsWith(state.accumulatedText, previousRecoveryText)
+                        ? previousRecoveryText.length
+                        : privateTextStartsWith(previousRecoveryText, state.accumulatedText)
+                            ? state.accumulatedText.length
+                            : 0;
+                const recoveryPresentationPrefixLength = suppressedRecoveryReplayTextLength > 0
+                    ? suppressedRecoveryReplayTextLength
+                    : interruptedRecoveryPrefixLength;
+                const recoveryPresentationText = privateTextSlice(state.accumulatedText, recoveryPresentationPrefixLength);
+                const repeatsInterruptedRecoveryText = interruptedRecoveryPrefixLength > 0 &&
+                    recoveryPresentationText.length === 0;
+                if (deferredRecoveryOutput !== undefined && !releasedDeferredRecoveryOutput) {
+                    flushDeferredRecoveryOutput(interruptedRecoveryPrefixLength, repeatsInterruptedRecoveryText, previousRecoveryText.length > 0 && interruptedRecoveryPrefixLength === 0 &&
+                        !repeatsInterruptedRecoveryText && state.accumulatedText.length > 0);
                 }
-                releasedDeferredRecoveryOutput = true;
-            };
-            const releaseDeferredRecoveryOutputAfterExactReplay = (isTextEvent) => {
-                if (isTextEvent || deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput ||
-                    deferredRecoverySseText !== remainingRecoveryReplayText() ||
-                    (callbacks?.onChunk !== undefined &&
-                        deferredRecoveryCallbackText !== remainingRecoveryReplayText())) {
-                    return;
+                finalFinishReason = state.finishReason ?? finalFinishReason;
+                const streamedToolCalls = [];
+                for (const toolCall of state.toolCalls.values()) {
+                    pushPrivateArray(streamedToolCalls, toolCall);
                 }
-                flushDeferredRecoveryOutput(remainingRecoveryReplayText().length, false, false);
-                releasedDeferredRecoveryOutput = true;
-            };
-            const releaseDeferredRecoveryNonTextOutput = (isTextEvent) => {
-                if (isTextEvent || deferredRecoveryOutput === undefined || releasedDeferredRecoveryOutput) {
-                    return;
+                const finalToolResults = collectFinalStreamToolResults(state);
+                // Recovery replays the whole step, so it also re-emits this step's
+                // reasoning — duplicating it in the live stream and in history, with a
+                // signature that no longer matches the replayed content. Reasoning that
+                // was persisted is reasoning the client already saw, so fail closed.
+                // This is a stopgap: reasoning is default-on across the hosted catalog,
+                // which makes recovery inert on most hosted paths. See #3736 for the
+                // reconciliation protocol that would let it run again.
+                const persistedReasoningParts = filterPrivateArray(state.reasoningParts, isPersistedReasoningPart);
+                const hasExposedReasoning = persistedReasoningParts.length > 0;
+                const canRecoverInterruptedLocalToolBatch = !recoveredInterruptedLocalToolBatch &&
+                    step + 1 < maxSteps &&
+                    !hasExposedReasoning;
+                const shouldContinue = shouldContinueAfterStreamStep(state, {
+                    recoverInterruptedToolCalls: canRecoverInterruptedLocalToolBatch,
+                });
+                const stoppedEmptyAfterCompletedTool = state.finishReason === "stop" &&
+                    !hasSubstantiveAssistantText(state.accumulatedText) &&
+                    state.toolCalls.size === 0 &&
+                    finalToolResults.size === 0 &&
+                    (state.suppressedToolCalls?.length ?? 0) === 0 &&
+                    somePrivateArray(toolCalls, (toolCall) => toolCall.status === "completed");
+                const shouldRecoverInterruptedLocalToolBatch = canRecoverInterruptedLocalToolBatch &&
+                    shouldContinue &&
+                    somePrivateArray(streamedToolCalls, isInterruptedClientToolCall);
+                const exhaustedStepBudgetDuringInterruptedLocalToolRecovery = !recoveredInterruptedLocalToolBatch &&
+                    step + 1 >= maxSteps &&
+                    !hasExposedReasoning &&
+                    somePrivateArray(streamedToolCalls, isInterruptedClientToolCall) &&
+                    shouldContinueAfterStreamStep(state, { recoverInterruptedToolCalls: true });
+                // Exactly `shouldRecoverInterruptedLocalToolBatch` with the reasoning
+                // gate lifted: the batch this step would have replayed had it not
+                // already exposed reasoning. Re-asking is what separates "recovery was
+                // declined" from "this step merely carried reasoning";
+                // `shouldContinueAfterStreamStep` only reads state, so asking twice has
+                // no side effects, and the cheap conditions short-circuit ahead of it.
+                const declinedRecoveryForExposedReasoning = hasExposedReasoning &&
+                    !recoveredInterruptedLocalToolBatch &&
+                    step + 1 < maxSteps &&
+                    somePrivateArray(streamedToolCalls, isInterruptedClientToolCall) &&
+                    shouldContinueAfterStreamStep(state, { recoverInterruptedToolCalls: true });
+                if (declinedRecoveryForExposedReasoning) {
+                    logger.warn("Declined interrupted local tool batch recovery after exposed reasoning", {
+                        step,
+                        toolName: filterPrivateArray(streamedToolCalls, isInterruptedClientToolCall)[0]?.name,
+                        reasoningPartCount: persistedReasoningParts.length,
+                    });
                 }
-                const retainedOutput = filterPrivateArray(deferredRecoveryOutput, (output) => output.kind === "callback" || output.isTextEvent);
-                for (let outputIndex = 0; outputIndex < deferredRecoveryOutput.length; outputIndex++) {
-                    if (!ObjectHasOwn(deferredRecoveryOutput, outputIndex))
+                const assistantMessage = buildStreamedAssistantMessage({
+                    ...state,
+                    accumulatedText: recoveryPresentationText,
+                }, {
+                    id: `msg_${Date.now()}_${step}`,
+                    timestamp: Date.now(),
+                }, {
+                    preserveRecoverablePlaceholderToolCalls: shouldRecoverInterruptedLocalToolBatch ||
+                        !shouldContinue,
+                });
+                attachProviderMetadata(assistantMessage, await reconcileSuppressedProviderMetadata(languageModel, state.providerMetadata, state.suppressedToolCalls, state.toolCalls.size > 0, abortSignal));
+                for (const tc of state.toolCalls.values()) {
+                    const materialized = materializeStreamedToolCall(tc);
+                    if (materialized.kind === "incomplete" && isRecoverablePlaceholderToolCall(tc)) {
+                        // Provisional empty-object placeholder that never finalized. The
+                        // model never committed arguments. Preserve it when recovery or
+                        // terminalization records a matching tool result; otherwise the
+                        // assistant message builder can omit it beside final text. Surface no
+                        // input warning or error for the provisional fragment.
                         continue;
-                    const output = deferredRecoveryOutput[outputIndex];
-                    if (output.kind === "sse" && !output.isTextEvent) {
-                        enqueuePrivateStream(controller, output.chunk);
+                    }
+                    if (materialized.kind === "incomplete") {
+                        // Stream terminated before the provider emitted the finalizing
+                        // `tool-call` event for this block. The model never committed this
+                        // tool use. Surface the failure via SSE so the live client can
+                        // react, and leave the partial fragment under `inputText` in the
+                        // persisted part above so the history is replayable and transparent.
+                        logger.warn("Streamed tool call terminated before tool-call event", {
+                            toolCallId: tc.id,
+                            toolName: tc.name,
+                            partialArgumentsLength: materialized.partialArgumentsLength,
+                            partialArgumentsPreview: materialized.partialArgumentsPreview,
+                        });
+                        if (tc.inputAnnounced === true) {
+                            const dynamicIncomplete = isDynamicTool(tc.name, this.config.tools);
+                            sendSSE(controller, encoder, {
+                                type: "tool-input-error",
+                                toolCallId: tc.id,
+                                errorText: `Stream terminated before tool-call event fired for "${tc.name}". ` +
+                                    `Received ${materialized.partialArgumentsLength} chars of partial tool-input deltas.`,
+                                ...(dynamicIncomplete ? { dynamic: true } : {}),
+                            });
+                        }
+                    }
+                    else if (materialized.kind === "parse-error") {
+                        logger.warn("Failed to parse streamed tool arguments", {
+                            toolCallId: tc.id,
+                            error: materialized.parseError,
+                        });
                     }
                 }
-                deferredRecoveryOutput.length = 0;
-                appendPrivateArray(deferredRecoveryOutput, retainedOutput);
-            };
-            const reconcileDeferredRecoveryTextSegment = (isTextEndEvent) => {
-                if (!isTextEndEvent || deferredRecoveryOutput === undefined ||
-                    releasedDeferredRecoveryOutput ||
-                    !privateTextStartsWith(remainingRecoveryReplayText(), deferredRecoverySseText) ||
-                    (callbacks?.onChunk !== undefined &&
-                        !privateTextStartsWith(remainingRecoveryReplayText(), deferredRecoveryCallbackText))) {
-                    return;
+                const stepAssistantText = getTextFromParts(assistantMessage.parts);
+                if (step === interruptedLocalToolBatchRecoveryStep &&
+                    suppressedRecoveryReplayTextLength > 0) {
+                    latestAssistantText = `${previousRecoveryText}${recoveryPresentationText}`;
                 }
-                // A tool or reasoning event closes the current text segment. If that
-                // segment only replayed a prefix the client already received, discard
-                // it now and treat later text as a distinct segment. Otherwise retained
-                // prefix events could be released after the boundary when later text
-                // diverges, duplicating and reordering the replay.
-                suppressedRecoveryReplayTextLength += deferredRecoverySseText.length;
-                deferredRecoveryOutput.length = 0;
-                deferredRecoverySseText = "";
-                deferredRecoveryCallbackText = "";
-            };
-            let sawProviderStreamEvent = false;
-            const enqueueStepChunk = (chunk) => {
-                sawProviderStreamEvent = true;
-                enqueuePrivateStream(controller, chunk);
-            };
-            const stepController = deferredRecoveryOutput === undefined
-                ? {
-                    enqueue: enqueueStepChunk,
+                else if (step === interruptedLocalToolBatchRecoveryStep && interruptedRecoveryPrefixLength > 0) {
+                    latestAssistantText = privateTextStartsWith(previousRecoveryText, state.accumulatedText)
+                        ? previousRecoveryText
+                        : state.accumulatedText;
                 }
-                : {
-                    enqueue(chunk) {
-                        sawProviderStreamEvent = true;
-                        if (releasedDeferredRecoveryOutput) {
-                            enqueuePrivateStream(controller, releasedRecoveryReplacementTextPartId !== undefined
-                                ? rewriteRecoveryTextSseChunkId(chunk, releasedRecoveryReplacementTextPartId, encoder)
-                                : chunk);
-                            return;
+                else if (hasSubstantiveAssistantText(stepAssistantText) ||
+                    step !== interruptedLocalToolBatchRecoveryStep) {
+                    latestAssistantText = stepAssistantText;
+                }
+                const streamedInvokeAgentBatch = providerReplayCheckpointEmission.complete
+                    ? collectStreamedParallelInvokeAgentToolCalls(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, shouldContinue, effectiveToolExposurePlan, {
+                        activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
+                        toolsConfig: this.config.tools,
+                        agentId: this.id,
+                        hasToolReplacements: false,
+                    })
+                    : undefined;
+                const streamedSkillDelegationOrder = streamedInvokeAgentBatch
+                    ? streamedSameTurnSkillDelegationOrder(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames)
+                    : undefined;
+                let streamedBatchCompletionDeferred = streamedSkillDelegationOrder === "prefix";
+                const admittedTurn = snapshotAdmittedToolTurn(assistantMessage, currentMessages.length);
+                pushPrivateArray(currentMessages, assistantMessage);
+                await persistMessage(assistantMessage);
+                await persistProviderReplayCheckpointAfterTurn({
+                    emission: providerReplayCheckpointEmission,
+                    providerMetadata: readAttachedProviderMetadata(assistantMessage),
+                    invokeAgentToolCalls: streamedSkillDelegationOrder === "interleaved"
+                        ? undefined
+                        : streamedInvokeAgentBatch,
+                    deferCompletion: streamedBatchCompletionDeferred,
+                });
+                if (this.#persistRecoveryBoundary) {
+                    // Recovery snapshots require an authenticated admission for every local
+                    // call in this turn, including calls interrupted before input finalized.
+                    // Announce them before waiting for persistence so both retry and terminal
+                    // paths can acknowledge the matching error without an admission cycle.
+                    for (const toolCall of streamedToolCalls) {
+                        if (toolCall.providerExecuted !== true && isStreamedToolCallIncomplete(toolCall) &&
+                            !finalToolResults.has(toolCall.id)) {
+                            announceStreamedToolCallInput(controller, encoder, toolCall, (name) => isDynamicTool(name, this.config.tools));
                         }
-                        deferredRecoverySseText += textDeltaFromSseChunk(chunk) ?? "";
-                        const isTextEvent = isTextSseChunk(chunk);
-                        pushPrivateArray(deferredRecoveryOutput, {
-                            kind: "sse",
-                            chunk,
-                            isTextEvent,
-                        });
-                        releaseDeferredRecoveryOutputAfterDivergence();
-                        releaseDeferredRecoveryOutputAfterExactReplay(isTextEvent);
-                        releaseDeferredRecoveryNonTextOutput(isTextEvent);
-                        reconcileDeferredRecoveryTextSegment(isTextEndSseChunk(chunk));
-                    },
-                };
-            bindRuntimeStreamForwardingController(stepController, controller);
-            let providerStreamRetryAttempts = 0;
-            let sawProviderStreamUsage = false;
-            while (true) {
-                try {
-                    await processStream(streamSource, state, stepController, encoder, stepTextPartId, {
-                        onChunk: deferredRecoveryOutput === undefined ? callbacks?.onChunk : (chunk) => {
-                            if (releasedDeferredRecoveryOutput) {
-                                callbacks?.onChunk?.(chunk);
-                                return;
-                            }
-                            deferredRecoveryCallbackText += chunk;
-                            if (callbacks?.onChunk !== undefined) {
-                                pushPrivateArray(deferredRecoveryOutput, { kind: "callback", chunk });
-                            }
-                            releaseDeferredRecoveryOutputAfterDivergence();
-                        },
-                        ...(runtimeObservationStepId !== undefined &&
-                            runtimeObservationMessageSpanId !== undefined
+                    }
+                    await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
+                }
+                if (stoppedEmptyAfterCompletedTool) {
+                    sendSSE(controller, encoder, {
+                        type: "step-end",
+                        ...(runtimeObservationStepId
                             ? {
-                                runtimeObservationStepId,
-                                runtimeObservationMessageSpanId,
+                                privateRuntimeObservation: {
+                                    version: 1,
+                                    kind: "step_ended",
+                                    stepId: runtimeObservationStepId,
+                                },
                             }
                             : {}),
-                        onUsage: (usage) => {
-                            sawProviderStreamUsage = true;
-                            accumulateUsage(totalUsage, usage);
-                            // Snapshot, not the live object: a later step must not mutate a total
-                            // a caller has already recorded on a span.
-                            callbacks?.onUsage?.({ ...totalUsage });
-                        },
-                        streamRequiresFinish: languageModel.runtimeCapabilities?.streamRequiresFinish === true,
-                        requireProviderFinish: languageModel.runtimeCapabilities?.toolCallStreamRequiresFinish === true,
-                        providerExecutedToolNames: getProviderExecutedToolNames(runtimeTools),
-                        availableToolNames: acceptedRuntimeToolNames,
-                        dynamicToolNames: runtimeToolNames.filter((name) => isDynamicTool(name, this.config.tools)),
-                        streamLifecycleMode,
-                        ...(this.#modelStreamTimeouts
-                            ? { streamLifecyclePolicy: { ...this.#modelStreamTimeouts } }
-                            : {}),
-                        traceSpanName: `chat ${effectiveModel}`,
-                        traceAttributes: {
-                            ...(genAiProviderName ? { "gen_ai.provider.name": genAiProviderName } : {}),
-                            "gen_ai.request.model": effectiveModel,
-                            "gen_ai.response.model": effectiveModel,
-                            "gen_ai.request.max_tokens": maxOutputTokens,
-                            "gen_ai.output.type": "text",
-                            ...(temperature === undefined ? {} : { "gen_ai.request.temperature": temperature }),
-                        },
-                    }, abortSignal);
-                    break;
-                }
-                catch (error) {
-                    if (!shouldRetryRuntimeProviderStreamFailure({
-                        error,
-                        state,
-                        attempts: providerStreamRetryAttempts,
-                        abortSignal,
-                        hasUsageProgress: sawProviderStreamUsage,
-                        hasEmittedStreamEvent: sawProviderStreamEvent,
-                    })) {
-                        throw error;
+                    });
+                    if (recoveredEmptyResponse || step + 1 >= maxSteps) {
+                        throw new RuntimeEmptyResponseError();
                     }
-                    providerStreamRetryAttempts += 1;
-                    state = createStreamState();
-                }
-            }
-            throwIfAborted(abortSignal);
-            const interruptedRecoveryPrefixLength = deferredRecoveryOutput === undefined
-                ? 0
-                : privateTextStartsWith(state.accumulatedText, previousRecoveryText)
-                    ? previousRecoveryText.length
-                    : privateTextStartsWith(previousRecoveryText, state.accumulatedText)
-                        ? state.accumulatedText.length
-                        : 0;
-            const recoveryPresentationPrefixLength = suppressedRecoveryReplayTextLength > 0
-                ? suppressedRecoveryReplayTextLength
-                : interruptedRecoveryPrefixLength;
-            const recoveryPresentationText = privateTextSlice(state.accumulatedText, recoveryPresentationPrefixLength);
-            const repeatsInterruptedRecoveryText = interruptedRecoveryPrefixLength > 0 &&
-                recoveryPresentationText.length === 0;
-            if (deferredRecoveryOutput !== undefined && !releasedDeferredRecoveryOutput) {
-                flushDeferredRecoveryOutput(interruptedRecoveryPrefixLength, repeatsInterruptedRecoveryText, previousRecoveryText.length > 0 && interruptedRecoveryPrefixLength === 0 &&
-                    !repeatsInterruptedRecoveryText && state.accumulatedText.length > 0);
-            }
-            finalFinishReason = state.finishReason ?? finalFinishReason;
-            const streamedToolCalls = [];
-            for (const toolCall of state.toolCalls.values()) {
-                pushPrivateArray(streamedToolCalls, toolCall);
-            }
-            const finalToolResults = collectFinalStreamToolResults(state);
-            // Recovery replays the whole step, so it also re-emits this step's
-            // reasoning — duplicating it in the live stream and in history, with a
-            // signature that no longer matches the replayed content. Reasoning that
-            // was persisted is reasoning the client already saw, so fail closed.
-            // This is a stopgap: reasoning is default-on across the hosted catalog,
-            // which makes recovery inert on most hosted paths. See #3736 for the
-            // reconciliation protocol that would let it run again.
-            const persistedReasoningParts = filterPrivateArray(state.reasoningParts, isPersistedReasoningPart);
-            const hasExposedReasoning = persistedReasoningParts.length > 0;
-            const canRecoverInterruptedLocalToolBatch = !recoveredInterruptedLocalToolBatch &&
-                step + 1 < maxSteps &&
-                !hasExposedReasoning;
-            const shouldContinue = shouldContinueAfterStreamStep(state, {
-                recoverInterruptedToolCalls: canRecoverInterruptedLocalToolBatch,
-            });
-            const stoppedEmptyAfterCompletedTool = state.finishReason === "stop" &&
-                !hasSubstantiveAssistantText(state.accumulatedText) &&
-                state.toolCalls.size === 0 &&
-                finalToolResults.size === 0 &&
-                (state.suppressedToolCalls?.length ?? 0) === 0 &&
-                somePrivateArray(toolCalls, (toolCall) => toolCall.status === "completed");
-            const shouldRecoverInterruptedLocalToolBatch = canRecoverInterruptedLocalToolBatch &&
-                shouldContinue &&
-                somePrivateArray(streamedToolCalls, isInterruptedClientToolCall);
-            const exhaustedStepBudgetDuringInterruptedLocalToolRecovery = !recoveredInterruptedLocalToolBatch &&
-                step + 1 >= maxSteps &&
-                !hasExposedReasoning &&
-                somePrivateArray(streamedToolCalls, isInterruptedClientToolCall) &&
-                shouldContinueAfterStreamStep(state, { recoverInterruptedToolCalls: true });
-            // Exactly `shouldRecoverInterruptedLocalToolBatch` with the reasoning
-            // gate lifted: the batch this step would have replayed had it not
-            // already exposed reasoning. Re-asking is what separates "recovery was
-            // declined" from "this step merely carried reasoning";
-            // `shouldContinueAfterStreamStep` only reads state, so asking twice has
-            // no side effects, and the cheap conditions short-circuit ahead of it.
-            const declinedRecoveryForExposedReasoning = hasExposedReasoning &&
-                !recoveredInterruptedLocalToolBatch &&
-                step + 1 < maxSteps &&
-                somePrivateArray(streamedToolCalls, isInterruptedClientToolCall) &&
-                shouldContinueAfterStreamStep(state, { recoverInterruptedToolCalls: true });
-            if (declinedRecoveryForExposedReasoning) {
-                logger.warn("Declined interrupted local tool batch recovery after exposed reasoning", {
-                    step,
-                    toolName: filterPrivateArray(streamedToolCalls, isInterruptedClientToolCall)[0]?.name,
-                    reasoningPartCount: persistedReasoningParts.length,
-                });
-            }
-            const assistantMessage = buildStreamedAssistantMessage({
-                ...state,
-                accumulatedText: recoveryPresentationText,
-            }, {
-                id: `msg_${Date.now()}_${step}`,
-                timestamp: Date.now(),
-            }, {
-                preserveRecoverablePlaceholderToolCalls: shouldRecoverInterruptedLocalToolBatch ||
-                    !shouldContinue,
-            });
-            attachProviderMetadata(assistantMessage, await reconcileSuppressedProviderMetadata(languageModel, state.providerMetadata, state.suppressedToolCalls, state.toolCalls.size > 0, abortSignal));
-            for (const tc of state.toolCalls.values()) {
-                const materialized = materializeStreamedToolCall(tc);
-                if (materialized.kind === "incomplete" && isRecoverablePlaceholderToolCall(tc)) {
-                    // Provisional empty-object placeholder that never finalized. The
-                    // model never committed arguments. Preserve it when recovery or
-                    // terminalization records a matching tool result; otherwise the
-                    // assistant message builder can omit it beside final text. Surface no
-                    // input warning or error for the provisional fragment.
+                    recoveredEmptyResponse = true;
+                    pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
+                        id: `runtime_empty_response_${Date.now()}_${step}`,
+                        role: "user",
+                        parts: [{
+                                type: "text",
+                                text: EMPTY_RESPONSE_RECOVERY_PROMPT,
+                            }],
+                        timestamp: Date.now(),
+                    }));
+                    await pauseAtBoundary(step + 1);
+                    this.status = "thinking";
                     continue;
                 }
-                if (materialized.kind === "incomplete") {
-                    // Stream terminated before the provider emitted the finalizing
-                    // `tool-call` event for this block. The model never committed this
-                    // tool use. Surface the failure via SSE so the live client can
-                    // react, and leave the partial fragment under `inputText` in the
-                    // persisted part above so the history is replayable and transparent.
-                    logger.warn("Streamed tool call terminated before tool-call event", {
-                        toolCallId: tc.id,
-                        toolName: tc.name,
-                        partialArgumentsLength: materialized.partialArgumentsLength,
-                        partialArgumentsPreview: materialized.partialArgumentsPreview,
-                    });
-                    if (tc.inputAnnounced === true) {
-                        const dynamicIncomplete = isDynamicTool(tc.name, this.config.tools);
-                        sendSSE(controller, encoder, {
-                            type: "tool-input-error",
-                            toolCallId: tc.id,
-                            errorText: `Stream terminated before tool-call event fired for "${tc.name}". ` +
-                                `Received ${materialized.partialArgumentsLength} chars of partial tool-input deltas.`,
-                            ...(dynamicIncomplete ? { dynamic: true } : {}),
-                        });
+                const persistToolResult = async (toolResult) => {
+                    if (currentStepToolResults.has(toolResult.toolCallId)) {
+                        return;
                     }
-                }
-                else if (materialized.kind === "parse-error") {
-                    logger.warn("Failed to parse streamed tool arguments", {
-                        toolCallId: tc.id,
-                        error: materialized.parseError,
+                    const executionAuthority = resolveToolExecutionAuthority({
+                        toolName: toolResult.toolName,
+                        plan: effectiveToolExposurePlan,
                     });
-                }
-            }
-            const stepAssistantText = getTextFromParts(assistantMessage.parts);
-            if (step === interruptedLocalToolBatchRecoveryStep &&
-                suppressedRecoveryReplayTextLength > 0) {
-                latestAssistantText = `${previousRecoveryText}${recoveryPresentationText}`;
-            }
-            else if (step === interruptedLocalToolBatchRecoveryStep && interruptedRecoveryPrefixLength > 0) {
-                latestAssistantText = privateTextStartsWith(previousRecoveryText, state.accumulatedText)
-                    ? previousRecoveryText
-                    : state.accumulatedText;
-            }
-            else if (hasSubstantiveAssistantText(stepAssistantText) ||
-                step !== interruptedLocalToolBatchRecoveryStep) {
-                latestAssistantText = stepAssistantText;
-            }
-            const streamedInvokeAgentBatch = providerReplayCheckpointEmission.complete
-                ? collectStreamedParallelInvokeAgentToolCalls(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, shouldContinue, effectiveToolExposurePlan, {
-                    activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
-                    toolsConfig: this.config.tools,
-                    agentId: this.id,
-                    hasToolReplacements: false,
-                })
-                : undefined;
-            const streamedSkillDelegationOrder = streamedInvokeAgentBatch
-                ? streamedSameTurnSkillDelegationOrder(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames)
-                : undefined;
-            let streamedBatchCompletionDeferred = streamedSkillDelegationOrder === "prefix";
-            const admittedTurn = snapshotAdmittedToolTurn(assistantMessage, currentMessages.length);
-            pushPrivateArray(currentMessages, assistantMessage);
-            await persistMessage(assistantMessage);
-            await persistProviderReplayCheckpointAfterTurn({
-                emission: providerReplayCheckpointEmission,
-                providerMetadata: readAttachedProviderMetadata(assistantMessage),
-                invokeAgentToolCalls: streamedSkillDelegationOrder === "interleaved"
-                    ? undefined
-                    : streamedInvokeAgentBatch,
-                deferCompletion: streamedBatchCompletionDeferred,
-            });
-            if (this.#persistRecoveryBoundary) {
-                // Recovery snapshots require an authenticated admission for every local
-                // call in this turn, including calls interrupted before input finalized.
-                // Announce them before waiting for persistence so both retry and terminal
-                // paths can acknowledge the matching error without an admission cycle.
-                for (const toolCall of streamedToolCalls) {
-                    if (toolCall.providerExecuted !== true && isStreamedToolCallIncomplete(toolCall) &&
-                        !finalToolResults.has(toolCall.id)) {
+                    const toolResultMessage = createPolicyAwareToolResultMessage(toolResult.toolCallId, toolResult.toolName, toolResult.error === undefined
+                        ? toolResult.output
+                        : { error: stringifyToolError(toolResult.error) }, executionAuthority?.toolDefinition, toolResult.providerExecuted === true);
+                    pushPrivateArray(currentMessages, toolResultMessage);
+                    await persistMessage(toolResultMessage);
+                    currentStepToolResults.set(toolResult.toolCallId, toolResultMessage.parts[0]);
+                };
+                const recordIncompleteLocalToolError = async (toolCall, options = {}) => {
+                    if (toolCall.providerExecuted === true ||
+                        !isStreamedToolCallIncomplete(toolCall) ||
+                        finalToolResults.has(toolCall.id)) {
+                        return false;
+                    }
+                    if (options.announceInput === true) {
+                        // An interrupted call never reached `tool-input-end`, so its
+                        // `tool-input-start` is still buffered and `inputAnnounced` is false
+                        // — which would suppress the `tool-output-error` below. Every
+                        // terminal path passes `announceInput`, because on all of them the
+                        // run stops here and the client would otherwise be left with
+                        // whatever preceded the truncation and then nothing at all. Which
+                        // path declined recovery — exposed reasoning, a spent step budget, a
+                        // second interruption, an exposed sibling — is invisible to the
+                        // user, so it must not decide whether the failure renders (#3737).
+                        //
+                        // The name is safe to publish here. `tool-call` is what can supersede
+                        // a name, and it also sets `inputAvailable`, which fails the guard
+                        // above — so reaching this line means no such event arrived and the
+                        // buffered name is the only one this call will ever have. It is the
+                        // same name recorded below and in the persisted assistant message,
+                        // so the card matches a reload. Announcing is idempotent, so a call
+                        // surfaced upstream is not reported twice.
                         announceStreamedToolCallInput(controller, encoder, toolCall, (name) => isDynamicTool(name, this.config.tools));
                     }
-                }
-                await this.#persistRecoveryBoundary(createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)));
-            }
-            if (stoppedEmptyAfterCompletedTool) {
-                sendSSE(controller, encoder, {
-                    type: "step-end",
-                    ...(runtimeObservationStepId
-                        ? {
-                            privateRuntimeObservation: {
-                                version: 1,
-                                kind: "step_ended",
-                                stepId: runtimeObservationStepId,
-                            },
-                        }
-                        : {}),
-                });
-                if (recoveredEmptyResponse || step + 1 >= maxSteps) {
-                    throw new RuntimeEmptyResponseError();
-                }
-                recoveredEmptyResponse = true;
-                pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
-                    id: `runtime_empty_response_${Date.now()}_${step}`,
-                    role: "user",
-                    parts: [{
-                            type: "text",
-                            text: EMPTY_RESPONSE_RECOVERY_PROMPT,
-                        }],
-                    timestamp: Date.now(),
-                }));
-                await pauseAtBoundary(step + 1);
-                this.status = "thinking";
-                continue;
-            }
-            const persistToolResult = async (toolResult) => {
-                if (currentStepToolResults.has(toolResult.toolCallId)) {
-                    return;
-                }
-                const executionAuthority = resolveToolExecutionAuthority({
-                    toolName: toolResult.toolName,
-                    plan: effectiveToolExposurePlan,
-                });
-                const toolResultMessage = createPolicyAwareToolResultMessage(toolResult.toolCallId, toolResult.toolName, toolResult.error === undefined
-                    ? toolResult.output
-                    : { error: stringifyToolError(toolResult.error) }, executionAuthority?.toolDefinition, toolResult.providerExecuted === true);
-                pushPrivateArray(currentMessages, toolResultMessage);
-                await persistMessage(toolResultMessage);
-                currentStepToolResults.set(toolResult.toolCallId, toolResultMessage.parts[0]);
-            };
-            const recordIncompleteLocalToolError = async (toolCall, options = {}) => {
-                if (toolCall.providerExecuted === true ||
-                    !isStreamedToolCallIncomplete(toolCall) ||
-                    finalToolResults.has(toolCall.id)) {
-                    return false;
-                }
-                if (options.announceInput === true) {
-                    // An interrupted call never reached `tool-input-end`, so its
-                    // `tool-input-start` is still buffered and `inputAnnounced` is false
-                    // — which would suppress the `tool-output-error` below. Every
-                    // terminal path passes `announceInput`, because on all of them the
-                    // run stops here and the client would otherwise be left with
-                    // whatever preceded the truncation and then nothing at all. Which
-                    // path declined recovery — exposed reasoning, a spent step budget, a
-                    // second interruption, an exposed sibling — is invisible to the
-                    // user, so it must not decide whether the failure renders (#3737).
-                    //
-                    // The name is safe to publish here. `tool-call` is what can supersede
-                    // a name, and it also sets `inputAvailable`, which fails the guard
-                    // above — so reaching this line means no such event arrived and the
-                    // buffered name is the only one this call will ever have. It is the
-                    // same name recorded below and in the persisted assistant message,
-                    // so the card matches a reload. Announcing is idempotent, so a call
-                    // surfaced upstream is not reported twice.
-                    announceStreamedToolCallInput(controller, encoder, toolCall, (name) => isDynamicTool(name, this.config.tools));
-                }
-                const incompleteToolCall = {
-                    id: toolCall.id,
-                    name: toolCall.name,
-                    args: {},
-                    ...(toolCall.arguments.length > 0 ? { inputText: toolCall.arguments } : {}),
-                    status: "pending",
+                    const incompleteToolCall = {
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        args: {},
+                        ...(toolCall.arguments.length > 0 ? { inputText: toolCall.arguments } : {}),
+                        status: "pending",
+                    };
+                    await this.recordToolError(persistMessage, incompleteToolCall, `Stream terminated before tool-call event fired for "${toolCall.name}". ` +
+                        `Received ${toolCall.arguments.length} chars of partial tool-input deltas.`, { controller, encoder }, currentMessages, toolCalls, {
+                        emitSse: toolCall.inputAnnounced === true,
+                        includeInResponse: options.includeInResponse,
+                    });
+                    return true;
                 };
-                await this.recordToolError(persistMessage, incompleteToolCall, `Stream terminated before tool-call event fired for "${toolCall.name}". ` +
-                    `Received ${toolCall.arguments.length} chars of partial tool-input deltas.`, { controller, encoder }, currentMessages, toolCalls, {
-                    emitSse: toolCall.inputAnnounced === true,
-                    includeInResponse: options.includeInResponse,
-                });
-                return true;
-            };
-            if (!shouldContinue) {
-                for (const toolResult of finalToolResults.values()) {
-                    await persistToolResult(toolResult);
-                }
-                for (let toolCallIndex = 0; toolCallIndex < streamedToolCalls.length; toolCallIndex++) {
-                    // A rejected batch must close committed local calls too, without running
-                    // side effects or inventing a result for a provider-owned sibling.
-                    if (!ObjectHasOwn(streamedToolCalls, toolCallIndex))
-                        continue;
-                    const toolCall = streamedToolCalls[toolCallIndex];
-                    if (toolCall.providerExecuted !== true && toolCall.inputAvailable === true &&
-                        !finalToolResults.has(toolCall.id) && !currentStepToolResults.has(toolCall.id)) {
-                        const capturedInput = captureStreamedToolCallInput(toolCall);
-                        await this.recordToolError(persistMessage, {
-                            id: toolCall.id,
-                            name: toolCall.name,
-                            args: capturedInput.args,
-                            ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
-                            status: "pending",
-                        }, "Tool execution skipped because the model turn ended before local execution could continue.", { controller, encoder }, currentMessages, toolCalls);
-                        continue;
+                if (!shouldContinue) {
+                    for (const toolResult of finalToolResults.values()) {
+                        await persistToolResult(toolResult);
                     }
-                    // Terminal. Every incomplete local call recorded here is also
-                    // terminalized into history, so announce unconditionally and let the
-                    // wire carry the same failure. `recordIncompleteLocalToolError`
-                    // guards on `providerExecuted`, completeness and a final result, so
-                    // only genuinely truncated local calls are announced, and
-                    // `announceStreamedToolCallInput` is idempotent for any already
-                    // surfaced upstream.
-                    await recordIncompleteLocalToolError(toolCall, { announceInput: true });
-                }
-                sendSSE(controller, encoder, {
-                    type: "step-end",
-                    ...(runtimeObservationStepId
-                        ? {
-                            privateRuntimeObservation: {
-                                version: 1,
-                                kind: "step_ended",
-                                stepId: runtimeObservationStepId,
-                            },
+                    for (let toolCallIndex = 0; toolCallIndex < streamedToolCalls.length; toolCallIndex++) {
+                        // A rejected batch must close committed local calls too, without running
+                        // side effects or inventing a result for a provider-owned sibling.
+                        if (!ObjectHasOwn(streamedToolCalls, toolCallIndex))
+                            continue;
+                        const toolCall = streamedToolCalls[toolCallIndex];
+                        if (toolCall.providerExecuted !== true && toolCall.inputAvailable === true &&
+                            !finalToolResults.has(toolCall.id) && !currentStepToolResults.has(toolCall.id)) {
+                            const capturedInput = captureStreamedToolCallInput(toolCall);
+                            await this.recordToolError(persistMessage, {
+                                id: toolCall.id,
+                                name: toolCall.name,
+                                args: capturedInput.args,
+                                ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
+                                status: "pending",
+                            }, "Tool execution skipped because the model turn ended before local execution could continue.", { controller, encoder }, currentMessages, toolCalls);
+                            continue;
                         }
-                        : {}),
-                });
-                completedWithinStepBudget = !exhaustedStepBudgetDuringInterruptedLocalToolRecovery;
-                if (completedWithinStepBudget && this.#persistRecoveryBoundary) {
-                    const runtimeContinuation = captureRecoveryContinuation(step + 1);
-                    await this.#persistRecoveryBoundary({
-                        ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
-                        runtimeContinuation,
+                        // Terminal. Every incomplete local call recorded here is also
+                        // terminalized into history, so announce unconditionally and let the
+                        // wire carry the same failure. `recordIncompleteLocalToolError`
+                        // guards on `providerExecuted`, completeness and a final result, so
+                        // only genuinely truncated local calls are announced, and
+                        // `announceStreamedToolCallInput` is idempotent for any already
+                        // surfaced upstream.
+                        await recordIncompleteLocalToolError(toolCall, { announceInput: true });
+                    }
+                    sendSSE(controller, encoder, {
+                        type: "step-end",
+                        ...(runtimeObservationStepId
+                            ? {
+                                privateRuntimeObservation: {
+                                    version: 1,
+                                    kind: "step_ended",
+                                    stepId: runtimeObservationStepId,
+                                },
+                            }
+                            : {}),
                     });
+                    completedWithinStepBudget = !exhaustedStepBudgetDuringInterruptedLocalToolRecovery;
+                    if (completedWithinStepBudget && this.#persistRecoveryBoundary) {
+                        const runtimeContinuation = captureRecoveryContinuation(step + 1);
+                        await this.#persistRecoveryBoundary({
+                            ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
+                            runtimeContinuation,
+                        });
+                    }
+                    if (!completedWithinStepBudget)
+                        await pauseAtBoundary(step + 1);
+                    break;
                 }
-                if (!completedWithinStepBudget)
-                    await pauseAtBoundary(step + 1);
-                break;
-            }
-            this.status = "tool_execution";
-            if (shouldRecoverInterruptedLocalToolBatch) {
-                // Treat parallel local calls as one batch. Executing the finalized
-                // prefix here could apply only part of the model's intended mutation.
-                recoveredInterruptedLocalToolBatch = true;
-                interruptedLocalToolBatchRecoveryStep = step + 1;
-                interruptedLocalToolBatchRecoveryText = hasSubstantiveAssistantText(stepAssistantText)
-                    ? stepAssistantText
-                    : undefined;
-            }
-            for (let toolCallIndex = 0; toolCallIndex < streamedToolCalls.length; toolCallIndex++) {
-                if (!ObjectHasOwn(streamedToolCalls, toolCallIndex))
-                    continue;
-                const tc = streamedToolCalls[toolCallIndex];
-                throwIfAborted(abortSignal);
-                if (shouldRecoverInterruptedLocalToolBatch && tc.providerExecuted !== true) {
-                    if (await recordIncompleteLocalToolError(tc, { includeInResponse: false })) {
+                this.status = "tool_execution";
+                if (shouldRecoverInterruptedLocalToolBatch) {
+                    // Treat parallel local calls as one batch. Executing the finalized
+                    // prefix here could apply only part of the model's intended mutation.
+                    recoveredInterruptedLocalToolBatch = true;
+                    interruptedLocalToolBatchRecoveryStep = step + 1;
+                    interruptedLocalToolBatchRecoveryText = hasSubstantiveAssistantText(stepAssistantText)
+                        ? stepAssistantText
+                        : undefined;
+                }
+                for (let toolCallIndex = 0; toolCallIndex < streamedToolCalls.length; toolCallIndex++) {
+                    if (!ObjectHasOwn(streamedToolCalls, toolCallIndex))
+                        continue;
+                    const tc = streamedToolCalls[toolCallIndex];
+                    throwIfAborted(abortSignal);
+                    if (shouldRecoverInterruptedLocalToolBatch && tc.providerExecuted !== true) {
+                        if (await recordIncompleteLocalToolError(tc, { includeInResponse: false })) {
+                            continue;
+                        }
+                        const capturedInput = captureStreamedToolCallInput(tc);
+                        const interruptedBatchToolCall = {
+                            id: tc.id,
+                            name: tc.name,
+                            args: capturedInput.args,
+                            ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
+                            status: "pending",
+                        };
+                        await this.recordToolError(persistMessage, interruptedBatchToolCall, "Tool execution skipped because another tool call in the same model step " +
+                            "was interrupted before its input completed.", { controller, encoder }, currentMessages, toolCalls);
+                        continue;
+                    }
+                    if (isRecoverablePlaceholderToolCall(tc)) {
+                        // Provisional empty-object placeholder that never finalized. If the
+                        // bounded recovery path was unavailable, do not execute or surface
+                        // it as a committed call.
+                        continue;
+                    }
+                    if (await recordIncompleteLocalToolError(tc)) {
+                        // Stream ended before the provider finalized this tool call. We
+                        // cannot execute it, so record a distinct stream-termination error
+                        // (not a tool-argument parse error) so the parent step and any
+                        // upstream orchestrator (e.g. the child-fork watchdog) see a
+                        // completed step with a clearly-labelled failure and can recover.
                         continue;
                     }
                     const capturedInput = captureStreamedToolCallInput(tc);
-                    const interruptedBatchToolCall = {
+                    const toolCall = {
                         id: tc.id,
                         name: tc.name,
                         args: capturedInput.args,
                         ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
                         status: "pending",
                     };
-                    await this.recordToolError(persistMessage, interruptedBatchToolCall, "Tool execution skipped because another tool call in the same model step " +
-                        "was interrupted before its input completed.", { controller, encoder }, currentMessages, toolCalls);
-                    continue;
-                }
-                if (isRecoverablePlaceholderToolCall(tc)) {
-                    // Provisional empty-object placeholder that never finalized. If the
-                    // bounded recovery path was unavailable, do not execute or surface
-                    // it as a committed call.
-                    continue;
-                }
-                if (await recordIncompleteLocalToolError(tc)) {
-                    // Stream ended before the provider finalized this tool call. We
-                    // cannot execute it, so record a distinct stream-termination error
-                    // (not a tool-argument parse error) so the parent step and any
-                    // upstream orchestrator (e.g. the child-fork watchdog) see a
-                    // completed step with a clearly-labelled failure and can recover.
-                    continue;
-                }
-                const capturedInput = captureStreamedToolCallInput(tc);
-                const toolCall = {
-                    id: tc.id,
-                    name: tc.name,
-                    args: capturedInput.args,
-                    ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
-                    status: "pending",
-                };
-                const matchingResult = finalToolResults.get(tc.id);
-                const persistedResult = currentStepToolResults.get(tc.id);
-                const executionAuthority = resolveToolExecutionAuthority({
-                    toolName: tc.name,
-                    plan: effectiveToolExposurePlan,
-                });
-                if (streamedBatchCompletionDeferred && tc.providerExecuted !== true && !matchingResult &&
-                    !persistedResult &&
-                    IntrinsicReflectApply(IntrinsicSetHas, providerReplayCheckpointEmission.invokeAgentToolNames, [tc.name])) {
-                    await completeDeferredProviderReplayCheckpointTurn(providerReplayCheckpointEmission, collectStreamedParallelInvokeAgentToolCalls(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, shouldContinue, effectiveToolExposurePlan, {
-                        activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
-                        toolsConfig: this.config.tools,
-                        agentId: this.id,
-                        hasToolReplacements: false,
-                    }));
-                    streamedBatchCompletionDeferred = false;
-                }
-                if (matchingResult) {
-                    await persistToolResult(matchingResult);
-                    const trustedPlatformPolicyResult = (() => {
-                        const part = currentStepToolResults.get(tc.id);
-                        return part !== undefined && hasTrustedPlatformPolicyToolResultPart(part);
-                    })();
-                    toolCall.status = matchingResult.error === undefined ? "completed" : "error";
-                    toolCall.result = matchingResult.output;
-                    toolCall.error = matchingResult.error === undefined
-                        ? undefined
-                        : stringifyToolError(matchingResult.error);
-                    pushPrivateArray(toolCalls, toolCall);
-                    if (matchingResult.error === undefined) {
-                        if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
-                            agentWriteFinalResponseToolGuardEnabled = true;
-                        }
-                        if (isLoadSkillToolName(tc.name) &&
-                            hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition) &&
-                            trustedPlatformPolicyResult) {
-                            skillState.applySuccessfulResult(matchingResult.output);
-                        }
-                        const submittedFormInput = trustedPlatformPolicyResult &&
-                            isSubmittedFormInputExecutionResult(tc.name, matchingResult.output, executionAuthority?.toolDefinition);
-                        skillState.markFormInputSubmitted(submittedFormInput);
-                        if (submittedFormInput) {
-                            currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
-                        }
+                    const matchingResult = finalToolResults.get(tc.id);
+                    const persistedResult = currentStepToolResults.get(tc.id);
+                    const executionAuthority = resolveToolExecutionAuthority({
+                        toolName: tc.name,
+                        plan: effectiveToolExposurePlan,
+                    });
+                    if (streamedBatchCompletionDeferred && tc.providerExecuted !== true && !matchingResult &&
+                        !persistedResult &&
+                        IntrinsicReflectApply(IntrinsicSetHas, providerReplayCheckpointEmission.invokeAgentToolNames, [tc.name])) {
+                        await completeDeferredProviderReplayCheckpointTurn(providerReplayCheckpointEmission, collectStreamedParallelInvokeAgentToolCalls(streamedToolCalls, finalToolResults, providerReplayCheckpointEmission.invokeAgentToolNames, shouldContinue, effectiveToolExposurePlan, {
+                            activeSkillDelegationOverrides: skillState.activeSkillDelegationOverrides,
+                            toolsConfig: this.config.tools,
+                            agentId: this.id,
+                            hasToolReplacements: false,
+                        }));
+                        streamedBatchCompletionDeferred = false;
                     }
-                    continue;
-                }
-                if (persistedResult) {
-                    const trustedPlatformPolicyResult = hasTrustedPlatformPolicyToolResultPart(persistedResult);
-                    const persistedError = getToolResultError(persistedResult.result);
-                    toolCall.status = persistedError === undefined ? "completed" : "error";
-                    toolCall.result = persistedResult.result;
-                    toolCall.error = persistedError;
-                    pushPrivateArray(toolCalls, toolCall);
-                    if (persistedError === undefined) {
-                        if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
-                            agentWriteFinalResponseToolGuardEnabled = true;
-                        }
-                        if (isLoadSkillToolName(tc.name) &&
-                            hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition) &&
-                            trustedPlatformPolicyResult) {
-                            skillState.applySuccessfulResult(persistedResult.result);
+                    if (matchingResult) {
+                        await persistToolResult(matchingResult);
+                        const trustedPlatformPolicyResult = (() => {
+                            const part = currentStepToolResults.get(tc.id);
+                            return part !== undefined && hasTrustedPlatformPolicyToolResultPart(part);
+                        })();
+                        toolCall.status = matchingResult.error === undefined ? "completed" : "error";
+                        toolCall.result = matchingResult.output;
+                        toolCall.error = matchingResult.error === undefined
+                            ? undefined
+                            : stringifyToolError(matchingResult.error);
+                        pushPrivateArray(toolCalls, toolCall);
+                        if (matchingResult.error === undefined) {
+                            if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
+                                agentWriteFinalResponseToolGuardEnabled = true;
+                            }
+                            if (isLoadSkillToolName(tc.name) &&
+                                hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition) &&
+                                trustedPlatformPolicyResult) {
+                                skillState.applySuccessfulResult(matchingResult.output);
+                            }
+                            const submittedFormInput = trustedPlatformPolicyResult &&
+                                isSubmittedFormInputExecutionResult(tc.name, matchingResult.output, executionAuthority?.toolDefinition);
+                            skillState.markFormInputSubmitted(submittedFormInput);
+                            if (submittedFormInput) {
+                                currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
+                            }
                         }
-                        const submittedFormInput = trustedPlatformPolicyResult &&
-                            isSubmittedFormInputExecutionResult(tc.name, persistedResult.result, executionAuthority?.toolDefinition);
-                        skillState.markFormInputSubmitted(submittedFormInput);
-                        if (submittedFormInput) {
-                            currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
+                        continue;
+                    }
+                    if (persistedResult) {
+                        const trustedPlatformPolicyResult = hasTrustedPlatformPolicyToolResultPart(persistedResult);
+                        const persistedError = getToolResultError(persistedResult.result);
+                        toolCall.status = persistedError === undefined ? "completed" : "error";
+                        toolCall.result = persistedResult.result;
+                        toolCall.error = persistedError;
+                        pushPrivateArray(toolCalls, toolCall);
+                        if (persistedError === undefined) {
+                            if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
+                                agentWriteFinalResponseToolGuardEnabled = true;
+                            }
+                            if (isLoadSkillToolName(tc.name) &&
+                                hasTrustedPlatformPolicyToolDefinition(executionAuthority?.toolDefinition) &&
+                                trustedPlatformPolicyResult) {
+                                skillState.applySuccessfulResult(persistedResult.result);
+                            }
+                            const submittedFormInput = trustedPlatformPolicyResult &&
+                                isSubmittedFormInputExecutionResult(tc.name, persistedResult.result, executionAuthority?.toolDefinition);
+                            skillState.markFormInputSubmitted(submittedFormInput);
+                            if (submittedFormInput) {
+                                currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
+                            }
                         }
+                        continue;
                     }
-                    continue;
-                }
-                if (tc.providerExecuted === true) {
-                    await traceProviderExecutedTool({
-                        mode: "stream",
-                        agentId: this.id,
-                        toolName: tc.name,
-                        toolCallId: tc.id,
-                        context: {
-                            toolCallId: tc.id,
-                            ...toolContext,
+                    if (tc.providerExecuted === true) {
+                        await traceProviderExecutedTool({
+                            mode: "stream",
                             agentId: this.id,
-                        },
-                        args: toolCall.args,
-                    });
-                    toolCall.status = "completed";
-                    pushPrivateArray(toolCalls, toolCall);
-                    continue;
-                }
-                if (capturedInput.parseError) {
-                    logger.warn("Invalid streamed tool arguments", {
-                        toolCallId: tc.id,
-                        error: capturedInput.parseError,
-                    });
-                    const dynamic = isDynamicTool(tc.name, this.config.tools);
-                    sendSSE(controller, encoder, {
-                        type: "tool-input-error",
-                        toolCallId: tc.id,
-                        errorText: `Invalid tool arguments: ${capturedInput.parseError}`,
-                        ...(dynamic ? { dynamic: true } : {}),
-                    });
-                    await this.recordToolError(persistMessage, toolCall, `Invalid tool arguments: ${capturedInput.parseError}`, { controller, encoder }, currentMessages, toolCalls);
-                    continue;
-                }
-                if (isFrameworkToolSearch(tc.name, effectiveToolExposurePlan)) {
-                    let checkpoint;
-                    try {
-                        callbacks?.onToolCall?.(toolCall);
-                        const search = executeFrameworkToolSearch({
+                            toolName: tc.name,
+                            toolCallId: tc.id,
+                            context: {
+                                toolCallId: tc.id,
+                                ...toolContext,
+                                agentId: this.id,
+                            },
                             args: toolCall.args,
-                            plan: effectiveToolExposurePlan,
-                            state: toolExposureState,
                         });
-                        if (didReloadProjectAgentWriteTool(search.result)) {
-                            agentWriteFinalResponseToolGuardEnabled = false;
-                        }
                         toolCall.status = "completed";
-                        toolCall.result = search.result;
                         pushPrivateArray(toolCalls, toolCall);
-                        setOtelActiveSpanAttributes({
-                            "tool.search.result_count": search.result.resultCount,
-                            "tool.search.loaded_count": search.result.loadedCount,
-                            "tool.search.miss": search.result.miss,
+                        continue;
+                    }
+                    if (capturedInput.parseError) {
+                        logger.warn("Invalid streamed tool arguments", {
+                            toolCallId: tc.id,
+                            error: capturedInput.parseError,
                         });
+                        const dynamic = isDynamicTool(tc.name, this.config.tools);
                         sendSSE(controller, encoder, {
-                            type: "tool-output-available",
-                            toolCallId: toolCall.id,
-                            output: search.result,
+                            type: "tool-input-error",
+                            toolCallId: tc.id,
+                            errorText: `Invalid tool arguments: ${capturedInput.parseError}`,
+                            ...(dynamic ? { dynamic: true } : {}),
                         });
-                        const toolResultMessage = createToolResultMessage(tc.id, tc.name, search.result);
-                        pushPrivateArray(currentMessages, toolResultMessage);
-                        await persistMessage(toolResultMessage);
-                        checkpoint = search.checkpoint;
-                        currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
+                        await this.recordToolError(persistMessage, toolCall, `Invalid tool arguments: ${capturedInput.parseError}`, { controller, encoder }, currentMessages, toolCalls);
+                        continue;
                     }
-                    catch (error) {
-                        await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
+                    if (isFrameworkToolSearch(tc.name, effectiveToolExposurePlan)) {
+                        let checkpoint;
+                        try {
+                            callbacks?.onToolCall?.(toolCall);
+                            const search = executeFrameworkToolSearch({
+                                args: toolCall.args,
+                                plan: effectiveToolExposurePlan,
+                                state: toolExposureState,
+                            });
+                            if (didReloadProjectAgentWriteTool(search.result)) {
+                                agentWriteFinalResponseToolGuardEnabled = false;
+                            }
+                            toolCall.status = "completed";
+                            toolCall.result = search.result;
+                            pushPrivateArray(toolCalls, toolCall);
+                            setOtelActiveSpanAttributes({
+                                "tool.search.result_count": search.result.resultCount,
+                                "tool.search.loaded_count": search.result.loadedCount,
+                                "tool.search.miss": search.result.miss,
+                            });
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-available",
+                                toolCallId: toolCall.id,
+                                output: search.result,
+                            });
+                            const toolResultMessage = createToolResultMessage(tc.id, tc.name, search.result);
+                            pushPrivateArray(currentMessages, toolResultMessage);
+                            await persistMessage(toolResultMessage);
+                            checkpoint = search.checkpoint;
+                            currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
+                        }
+                        catch (error) {
+                            await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
+                            continue;
+                        }
+                        await persistToolExposureCheckpointBeforeContinuation({
+                            checkpoint,
+                            persist: persistToolExposureCheckpoint,
+                            required: requireToolExposureCheckpointPersistence,
+                        });
+                        continue;
+                    }
+                    if (shouldHandleToolResultRead({
+                        toolName: tc.name,
+                        plan: effectiveToolExposurePlan,
+                        context: toolResultContext,
+                    })) {
+                        try {
+                            callbacks?.onToolCall?.(toolCall);
+                            if (toolResultContext === undefined) {
+                                throw new ReferenceError("Tool result context is not available");
+                            }
+                            const result = readToolResultContext(toolResultContext, toolCall.args);
+                            toolCall.status = "completed";
+                            toolCall.result = result;
+                            pushPrivateArray(toolCalls, toolCall);
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-available",
+                                toolCallId: toolCall.id,
+                                output: result,
+                            });
+                            const toolResultMessage = createPolicyAwareToolResultMessage(tc.id, tc.name, result, executionAuthority?.toolDefinition);
+                            pushPrivateArray(currentMessages, toolResultMessage);
+                            await persistMessage(toolResultMessage);
+                            currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
+                        }
+                        catch (error) {
+                            await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
+                        }
+                        continue;
+                    }
+                    if (shouldBlockToolResultReadName({
+                        toolName: tc.name,
+                        context: toolResultContext,
+                    })) {
+                        await this.recordToolError(persistMessage, toolCall, toolResultReaderUnavailableError(), { controller, encoder }, currentMessages, toolCalls);
+                        continue;
+                    }
+                    if (executionAuthority === undefined) {
+                        await this.recordToolError(persistMessage, toolCall, toolNotVisibleError(tc.name), { controller, encoder }, currentMessages, toolCalls);
                         continue;
                     }
-                    await persistToolExposureCheckpointBeforeContinuation({
-                        checkpoint,
-                        persist: persistToolExposureCheckpoint,
-                        required: requireToolExposureCheckpointPersistence,
+                    const policyCheck = enforceSkillPolicy(tc.name, {
+                        activeSkillId: skillState.activeSkillId,
+                        hasSubmittedFormInput: skillState.hasSubmittedFormInput,
+                        skillToolAvailability: skillState.activeSkillToolAvailability,
+                        toolInput: toolCall.args,
+                        toolDefinition: executionAuthority.toolDefinition,
                     });
-                    continue;
-                }
-                if (shouldHandleToolResultRead({
-                    toolName: tc.name,
-                    plan: effectiveToolExposurePlan,
-                    context: toolResultContext,
-                })) {
+                    if (!policyCheck.allowed) {
+                        await this.recordToolError(persistMessage, toolCall, policyCheck.error, { controller, encoder }, currentMessages, toolCalls);
+                        continue;
+                    }
                     try {
+                        toolCall.status = "executing";
+                        const startTime = Date.now();
+                        toolCall.args = applySkillDelegationOverridesToToolInput(tc.name, toolCall.args, skillState.activeSkillDelegationOverrides, resolveConfiguredTool(this.config.tools, tc.name, { agentId: this.id }) ?? undefined);
                         callbacks?.onToolCall?.(toolCall);
-                        if (toolResultContext === undefined) {
-                            throw new ReferenceError("Tool result context is not available");
-                        }
-                        const result = readToolResultContext(toolResultContext, toolCall.args);
-                        toolCall.status = "completed";
+                        const executionContext = applicationExecutionContext(toolContext, providerObservedSkillBodies);
+                        const result = await runWithToolCallOccurrenceDispatch(tc, () => traceConfiguredToolExecution({
+                            mode: "stream",
+                            agentId: this.id,
+                            toolName: tc.name,
+                            toolCallId: tc.id,
+                            args: toolCall.args,
+                            admittedTurn,
+                            owner: currentMessages,
+                            prepareTerminalDispatch,
+                            toolsConfig: this.config.tools,
+                            context: executionContext,
+                            allowedRemoteToolNames,
+                            remoteToolSources,
+                            sourceIntegrationPolicy,
+                            frameworkLocalTools,
+                        }));
+                        throwIfAborted(abortSignal);
+                        await this.notifyToolResult({
+                            mode: "stream",
+                            toolName: tc.name,
+                            toolCallId: tc.id,
+                            input: toolCall.args,
+                            result,
+                            context: executionContext,
+                        });
+                        const resultError = getToolResultError(result);
+                        toolCall.status = resultError === undefined ? "completed" : "error";
                         toolCall.result = result;
+                        toolCall.error = resultError;
+                        toolCall.executionTime = Date.now() - startTime;
                         pushPrivateArray(toolCalls, toolCall);
-                        sendSSE(controller, encoder, {
-                            type: "tool-output-available",
-                            toolCallId: toolCall.id,
-                            output: result,
-                        });
-                        const toolResultMessage = createPolicyAwareToolResultMessage(tc.id, tc.name, result, executionAuthority?.toolDefinition);
-                        pushPrivateArray(currentMessages, toolResultMessage);
-                        await persistMessage(toolResultMessage);
-                        currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
+                        if (resultError === undefined) {
+                            // Track skill policy from successful load_skill results
+                            if (isLoadSkillToolName(tc.name) &&
+                                hasTrustedPlatformPolicyToolDefinition(executionAuthority.toolDefinition)) {
+                                skillState.applySuccessfulResult(result);
+                            }
+                            const submittedFormInput = isSubmittedFormInputExecutionResult(tc.name, result, executionAuthority.toolDefinition);
+                            skillState.markFormInputSubmitted(submittedFormInput);
+                            if (submittedFormInput) {
+                                currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
+                            }
+                            if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
+                                agentWriteFinalResponseToolGuardEnabled = true;
+                            }
+                        }
+                        const dynamic = isDynamicTool(tc.name, this.config.tools);
+                        if (resultError === undefined) {
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-available",
+                                toolCallId: toolCall.id,
+                                output: result,
+                                ...(dynamic ? { dynamic: true } : {}),
+                            });
+                        }
+                        else {
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-error",
+                                toolCallId: toolCall.id,
+                                errorText: resultError,
+                                ...(dynamic ? { dynamic: true } : {}),
+                            });
+                        }
+                        const toolResultMessage = createPolicyAwareToolResultMessage(tc.id, tc.name, result, executionAuthority.toolDefinition, false, true);
+                        if (!currentStepToolResults.has(tc.id)) {
+                            pushPrivateArray(currentMessages, toolResultMessage);
+                            await persistMessage(toolResultMessage);
+                            currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
+                        }
                     }
                     catch (error) {
-                        await this.recordToolError(persistMessage, toolCall, error instanceof Error ? error.message : String(error), { controller, encoder }, currentMessages, toolCalls);
+                        await this.recordToolError(persistMessage, toolCall, undefined, { controller, encoder }, currentMessages, toolCalls, { terminal: { error, usage: totalUsage, abortSignal } });
                     }
-                    continue;
-                }
-                if (shouldBlockToolResultReadName({
-                    toolName: tc.name,
-                    context: toolResultContext,
-                })) {
-                    await this.recordToolError(persistMessage, toolCall, toolResultReaderUnavailableError(), { controller, encoder }, currentMessages, toolCalls);
-                    continue;
                 }
-                if (executionAuthority === undefined) {
-                    await this.recordToolError(persistMessage, toolCall, toolNotVisibleError(tc.name), { controller, encoder }, currentMessages, toolCalls);
-                    continue;
-                }
-                const policyCheck = enforceSkillPolicy(tc.name, {
-                    activeSkillId: skillState.activeSkillId,
-                    hasSubmittedFormInput: skillState.hasSubmittedFormInput,
-                    skillToolAvailability: skillState.activeSkillToolAvailability,
-                    toolInput: toolCall.args,
-                    toolDefinition: executionAuthority.toolDefinition,
-                });
-                if (!policyCheck.allowed) {
-                    await this.recordToolError(persistMessage, toolCall, policyCheck.error, { controller, encoder }, currentMessages, toolCalls);
-                    continue;
+                for (const toolResult of finalToolResults.values()) {
+                    await persistToolResult(toolResult);
                 }
-                try {
-                    toolCall.status = "executing";
-                    const startTime = Date.now();
-                    toolCall.args = applySkillDelegationOverridesToToolInput(tc.name, toolCall.args, skillState.activeSkillDelegationOverrides, resolveConfiguredTool(this.config.tools, tc.name, { agentId: this.id }) ?? undefined);
-                    callbacks?.onToolCall?.(toolCall);
-                    const executionContext = applicationExecutionContext(toolContext, providerObservedSkillBodies);
-                    const result = await runWithToolCallOccurrenceDispatch(tc, () => traceConfiguredToolExecution({
-                        mode: "stream",
-                        agentId: this.id,
-                        toolName: tc.name,
-                        toolCallId: tc.id,
-                        args: toolCall.args,
-                        admittedTurn,
-                        owner: currentMessages,
-                        prepareTerminalDispatch,
-                        toolsConfig: this.config.tools,
-                        context: executionContext,
-                        allowedRemoteToolNames,
-                        remoteToolSources,
-                        sourceIntegrationPolicy,
-                        frameworkLocalTools,
+                if (state.suppressedToolCalls.length > 0) {
+                    const unavailableNames = [
+                        ...new Set(state.suppressedToolCalls.map((toolCall) => toolCall.name)),
+                    ];
+                    pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
+                        id: `runtime_note_${Date.now()}_${step}`,
+                        role: "user",
+                        parts: [{
+                                type: "text",
+                                text: `Runtime recovery: ignored unavailable tool call(s): ${unavailableNames.join(", ")}. Continue using only currently available tools: ${runtimeToolNames.join(", ")}.`,
+                            }],
+                        timestamp: Date.now(),
                     }));
-                    throwIfAborted(abortSignal);
-                    await this.notifyToolResult({
-                        mode: "stream",
-                        toolName: tc.name,
-                        toolCallId: tc.id,
-                        input: toolCall.args,
-                        result,
-                        context: executionContext,
-                    });
-                    const resultError = getToolResultError(result);
-                    toolCall.status = resultError === undefined ? "completed" : "error";
-                    toolCall.result = result;
-                    toolCall.error = resultError;
-                    toolCall.executionTime = Date.now() - startTime;
-                    pushPrivateArray(toolCalls, toolCall);
-                    if (resultError === undefined) {
-                        // Track skill policy from successful load_skill results
-                        if (isLoadSkillToolName(tc.name) &&
-                            hasTrustedPlatformPolicyToolDefinition(executionAuthority.toolDefinition)) {
-                            skillState.applySuccessfulResult(result);
-                        }
-                        const submittedFormInput = isSubmittedFormInputExecutionResult(tc.name, result, executionAuthority.toolDefinition);
-                        skillState.markFormInputSubmitted(submittedFormInput);
-                        if (submittedFormInput) {
-                            currentRuntimeContext = markSubmittedFormInputRuntimeContext(currentRuntimeContext);
-                        }
-                        if (shouldHideProjectToolAfterAgentWriteSuccess(tc.name)) {
-                            agentWriteFinalResponseToolGuardEnabled = true;
-                        }
-                    }
-                    const dynamic = isDynamicTool(tc.name, this.config.tools);
-                    if (resultError === undefined) {
-                        sendSSE(controller, encoder, {
-                            type: "tool-output-available",
-                            toolCallId: toolCall.id,
-                            output: result,
-                            ...(dynamic ? { dynamic: true } : {}),
-                        });
-                    }
-                    else {
-                        sendSSE(controller, encoder, {
-                            type: "tool-output-error",
-                            toolCallId: toolCall.id,
-                            errorText: resultError,
-                            ...(dynamic ? { dynamic: true } : {}),
-                        });
-                    }
-                    const toolResultMessage = createPolicyAwareToolResultMessage(tc.id, tc.name, result, executionAuthority.toolDefinition, false, true);
-                    if (!currentStepToolResults.has(tc.id)) {
-                        pushPrivateArray(currentMessages, toolResultMessage);
-                        await persistMessage(toolResultMessage);
-                        currentStepToolResults.set(tc.id, toolResultMessage.parts[0]);
-                    }
                 }
-                catch (error) {
-                    await this.recordToolError(persistMessage, toolCall, undefined, { controller, encoder }, currentMessages, toolCalls, { terminal: { error, usage: totalUsage, abortSignal } });
+                if (this.#persistRecoveryBoundary) {
+                    const runtimeContinuation = captureRecoveryContinuation(step + 1);
+                    await this.#persistRecoveryBoundary({
+                        ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
+                        runtimeContinuation,
+                    });
                 }
-            }
-            for (const toolResult of finalToolResults.values()) {
-                await persistToolResult(toolResult);
-            }
-            if (state.suppressedToolCalls.length > 0) {
-                const unavailableNames = [
-                    ...new Set(state.suppressedToolCalls.map((toolCall) => toolCall.name)),
-                ];
-                pushPrivateArray(currentMessages, markRuntimeGeneratedUserMessage({
-                    id: `runtime_note_${Date.now()}_${step}`,
-                    role: "user",
-                    parts: [{
-                            type: "text",
-                            text: `Runtime recovery: ignored unavailable tool call(s): ${unavailableNames.join(", ")}. Continue using only currently available tools: ${runtimeToolNames.join(", ")}.`,
-                        }],
-                    timestamp: Date.now(),
-                }));
-            }
-            if (this.#persistRecoveryBoundary) {
-                const runtimeContinuation = captureRecoveryContinuation(step + 1);
-                await this.#persistRecoveryBoundary({
-                    ...createRecoveryBoundary(currentMessages, createToolExposureCheckpoint(effectiveToolExposurePlan.authorized, toolExposureState)),
-                    runtimeContinuation,
+                throwIfAborted(abortSignal);
+                sendSSE(controller, encoder, {
+                    type: "step-end",
+                    ...(runtimeObservationStepId
+                        ? {
+                            privateRuntimeObservation: {
+                                version: 1,
+                                kind: "step_ended",
+                                stepId: runtimeObservationStepId,
+                            },
+                        }
+                        : {}),
                 });
+                await pauseAtBoundary(step + 1);
+                this.status = "thinking";
+            }
+            if (!completedWithinStepBudget) {
+                // Step-budget exhaustion mirrors the generate loop's max-steps exit: the
+                // partial result is still returned, so the structured-output parse is
+                // best effort and a failure is surfaced in metadata instead of thrown.
+                const parsedOutput = await tryParseMaxStepsOutput(latestAssistantText, outputSchema);
+                return attachOutputSchemaParser({
+                    text: latestAssistantText,
+                    ...(parsedOutput.parsed ? { data: parsedOutput.object, object: parsedOutput.object } : {}),
+                    messages: currentMessages,
+                    toolCalls,
+                    status: "completed",
+                    usage: totalUsage,
+                    metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, {
+                        warning: `Max steps (${maxSteps}) reached`,
+                        ...(finalFinishReason ? { finishReason: finalFinishReason } : {}),
+                        ...(!parsedOutput.parsed && parsedOutput.outputSchemaError !== undefined
+                            ? { outputSchemaError: parsedOutput.outputSchemaError }
+                            : {}),
+                    }),
+                }, outputSchema);
             }
-            throwIfAborted(abortSignal);
-            sendSSE(controller, encoder, {
-                type: "step-end",
-                ...(runtimeObservationStepId
-                    ? {
-                        privateRuntimeObservation: {
-                            version: 1,
-                            kind: "step_ended",
-                            stepId: runtimeObservationStepId,
-                        },
-                    }
-                    : {}),
-            });
-            await pauseAtBoundary(step + 1);
-            this.status = "thinking";
-        }
-        if (!completedWithinStepBudget) {
-            // Step-budget exhaustion mirrors the generate loop's max-steps exit: the
-            // partial result is still returned, so the structured-output parse is
-            // best effort and a failure is surfaced in metadata instead of thrown.
-            const parsedOutput = await tryParseMaxStepsOutput(latestAssistantText, outputSchema);
             return attachOutputSchemaParser({
                 text: latestAssistantText,
-                ...(parsedOutput.parsed ? { data: parsedOutput.object, object: parsedOutput.object } : {}),
+                ...(outputSchema ? await parseStructuredOutput(outputSchema, latestAssistantText) : {}),
                 messages: currentMessages,
                 toolCalls,
                 status: "completed",
                 usage: totalUsage,
-                metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, {
-                    warning: `Max steps (${maxSteps}) reached`,
-                    ...(finalFinishReason ? { finishReason: finalFinishReason } : {}),
-                    ...(!parsedOutput.parsed && parsedOutput.outputSchemaError !== undefined
-                        ? { outputSchemaError: parsedOutput.outputSchemaError }
-                        : {}),
-                }),
+                metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, finalFinishReason ? { finishReason: finalFinishReason } : undefined),
             }, outputSchema);
         }
-        return attachOutputSchemaParser({
-            text: latestAssistantText,
-            ...(outputSchema ? await parseStructuredOutput(outputSchema, latestAssistantText) : {}),
-            messages: currentMessages,
-            toolCalls,
-            status: "completed",
-            usage: totalUsage,
-            metadata: withAgentRunRuntimeContextMetadata(runRuntimeContext, finalFinishReason ? { finishReason: finalFinishReason } : undefined),
-        }, outputSchema);
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
     }
     /**
      * Record a tool error and send SSE event.