maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.64.20260929

package/node_modules/@openai/agents-core/dist/run.mjs

@@ -7,7 +7,7 @@ import logger, { logModelAndToolActionDebug } from "./logger.mjs";
 import { getDefaultModelProvider } from "./providers.mjs";
 import { RunContext } from "./runContext.mjs";
 import { RunResult, StreamedRunResult } from "./result.mjs";
-import { RunState } from "./runState.mjs";
+import { assertPendingSessionCompactionTerminalAuthority, RunState, } from "./runState.mjs";
 import { getCurrentTrace, getCurrentTraceContext, resetCurrentSpan, setCurrentSpan, withNewSpanContext, withTrace, withTraceContext, } from "./tracing/context.mjs";
 import { includeTaskAndTurnSpans, mergeTracingConfig } from "./tracing/config.mjs";
 import { Usage } from "./usage.mjs";
@@ -18,16 +18,17 @@ import { StreamEventResponseCompleted } from "./types/protocol.mjs";
 import { SandboxRuntimeManager } from "./sandbox/runtime/index.mjs";
 import { ServerConversationTracker, applyCallModelInputFilter, getServerConversationOwner, } from "./runner/conversation.mjs";
 import { createGuardrailTracker, finalizeOutputGuardrails, } from "./runner/guardrails.mjs";
-import { adjustModelSettingsForNonGPT5RunnerModel, mergeModelSettings, maybeResetToolChoice, selectModel, } from "./runner/modelSettings.mjs";
+import { adjustModelSettingsForLegacyModel, mergeModelSettings, maybeResetToolChoice, selectModel, } from "./runner/modelSettings.mjs";
 import { getResponseWithRetry, getStreamedResponseWithRetry, validateModelTimeoutMs, } from "./runner/modelRetry.mjs";
 import { processModelResponseAsync } from "./runner/modelOutputs.mjs";
 import { addStepToRunResult, streamStepItemsToRunResult, isAbortError, } from "./runner/streaming.mjs";
-import { createSessionPersistenceTracker, captureSessionHistoryTransactionInputItems, markSessionHistoryTransactionInputPersisted, prepareSessionHistoryTransactionsForRun, releaseProvisionalSessionHistoryTransactionBinding, releaseUnusedSessionHistoryTransactionBinding, prepareInputItemsWithSession, saveStreamInputToSession, saveStreamResultToSession, saveToSession, } from "./runner/sessionPersistence.mjs";
+import { acquireResumedSessionWriteOperation, createSessionPersistenceTracker, getSessionCompactionState, bindSessionCompactionState, captureSessionHistoryTransactionInputItems, markSessionHistoryTransactionInputPersisted, prepareSessionHistoryTransactionsForRun, prepareResumedSessionWrite, reconcilePendingSessionWriteBeforeRun, releaseProvisionalSessionHistoryTransactionBinding, releaseUnusedSessionHistoryTransactionBinding, prepareInputItemsWithSession, saveStreamInputToSession, saveStreamResultToSession, saveToSession, } from "./runner/sessionPersistence.mjs";
 import { filterSuppressedToolCallItems, preflightModelResponseToolInvocations, preflightToolInvocations, resolveTurnAfterModelResponse, } from "./runner/turnResolution.mjs";
-import { assertResumedSessionOutputGuardrailSafety, captureCurrentResponseToolOutputGuardrailResultStart, hasBlockedOutputExecutionEffect, hasTerminalToolOutputSource, OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT, sanitizeBlockedTerminalToolOutput, shouldDeferInterruptedSessionItems, } from "./runner/blockedOutputPersistence.mjs";
+import { assertResumedSessionOutputGuardrailSafety, captureCurrentResponseToolOutputGuardrailResultStart, normalizeSerializedOutputGuardrailBlockedMessage, hasBlockedOutputExecutionEffect, hasPendingApprovedToolInputCompaction, hasPersistedToolOutput, hasTerminalToolOutputSource, sanitizeBlockedTerminalToolOutput, shouldDeferInterruptedSessionItems, } from "./runner/blockedOutputPersistence.mjs";
+import { createOutputGuardrailBlockedMessageResolver, OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT, } from "./runner/outputGuardrailBlockedMessage.mjs";
 import { prepareTurn } from "./runner/turnPreparation.mjs";
 import { commitPendingInput, hasUnpersistedRunInput, mapPendingInputAfterContextProcessing, selectPendingInputForAdmission, } from "./runner/pendingInput.mjs";
-import { prepareAgentArtifacts } from "./runner/modelPreparation.mjs";
+import { prepareAgentArtifacts, trackDeferredToolRecovery, } from "./runner/modelPreparation.mjs";
 import { applyTurnResult, assertAcceptedResponseContinuationAuthority, handleInterruptedOutcome, isAcceptedResponseCheckpoint, markAcceptedResponseProcessingStarted, markAcceptedResponseFinalizationStarted, resumeAcceptedModelResponse, resumeInterruptedTurn, } from "./runner/runLoop.mjs";
 import { applyTraceOverrides, ensureActiveAgentSpanForInterruptedResume, ensureTurnSpan, finishRunnerSpan, getRunnerSpanErrorDetails, getTracing, setRunnerSpanError, startRunnerInvocationSpans, recordRunnerSpanUsage, } from "./runner/tracing.mjs";
 import { getRunnerParentUsageRecorder, setRunStateUsageRecorder, } from "./runner/usageTracking.mjs";
@@ -39,11 +40,6 @@ import { attachRunStateToError, invalidateAcceptedResponseReplayEvidence, prepar
 import { finalizeSandboxRuntime, isSandboxRuntimeAgent, prepareSandboxInterruptedTurnResume, } from "./runner/sandbox.mjs";
 import { buildAbortReconciliationInput, createStreamAbortReconciliationState, getAbortReconciliationPreviousResponseId, markAbortReconciliationComplete, recordStreamEventForAbortReconciliation, shouldReconcileStreamAbort, } from "./runner/streamReconciliation.mjs";
 import { getImplicitModelSettingsForResolvedModel, validateToolExecutionConfig, validateToolNameCollisionPolicy, } from "./runner/runConfig.mjs";
-function hasPersistedToolOutput(state) {
-    return state._generatedItems
-        .slice(0, state._currentTurnPersistedItemCount)
-        .some((item) => item.type === 'tool_call_output_item');
-}
 function hasRetainableBlockedOutputEffect(state) {
     return hasBlockedOutputExecutionEffect(state._generatedItems, state._currentTurnPersistedItemCount);
 }
@@ -77,6 +73,10 @@ function rollbackUnstartedTurn(state, snapshot) {
     state._currentTurnInProgress = snapshot.currentTurnInProgress;
     return true;
 }
+function recordModelFailureUsage(usage, state, recordUsage) {
+    state.usage.add(usage);
+    recordUsage(usage);
+}
 function assertPendingInputServerOwnership(state, conversationId, previousResponseId) {
     const serverManagesConversation = Boolean(conversationId || previousResponseId);
     if (state._pendingInput.length === 0 ||
@@ -130,6 +130,7 @@ export class Runner extends RunHooks {
             sessionInputCallback: config.sessionInputCallback,
             callModelInputFilter: config.callModelInputFilter,
             toolErrorFormatter: config.toolErrorFormatter,
+            outputGuardrailBlockedMessage: config.outputGuardrailBlockedMessage,
             reasoningItemIdPolicy: config.reasoningItemIdPolicy,
         };
         this.traceOverrides = {
@@ -178,6 +179,9 @@ export class Runner extends RunHooks {
         const callModelInputFilter = resolvedOptions.callModelInputFilter ?? this.config.callModelInputFilter;
         // Per-run callback can override runner-level tool error formatting defaults.
         const toolErrorFormatter = resolvedOptions.toolErrorFormatter ?? this.config.toolErrorFormatter;
+        const outputGuardrailBlockedMessage = resolvedOptions.outputGuardrailBlockedMessage === undefined
+            ? this.config.outputGuardrailBlockedMessage
+            : resolvedOptions.outputGuardrailBlockedMessage;
         const reasoningItemIdPolicy = resolvedOptions.reasoningItemIdPolicy ??
             (input instanceof RunState ? input._reasoningItemIdPolicy : undefined) ??
             this.config.reasoningItemIdPolicy;
@@ -205,6 +209,7 @@ export class Runner extends RunHooks {
             sessionInputCallback,
             callModelInputFilter,
             toolErrorFormatter,
+            outputGuardrailBlockedMessage,
             reasoningItemIdPolicy,
             toolExecution,
             toolNotFoundBehavior,
@@ -229,142 +234,184 @@ export class Runner extends RunHooks {
         // When the server tracks conversation history we defer to it for previous turns so local session
         // persistence can focus solely on the new delta being generated in this process.
         const session = effectiveOptions.session;
-        let provisionalSessionHistoryTransactionSessionId;
-        let provisionalSessionHistoryTransactionInputItems;
-        if (resumingFromState) {
-            const resumedState = input;
-            assertAcceptedResponseContinuationAuthority(resumedState, effectiveOptions.conversationId, effectiveOptions.previousResponseId);
-            const hadSessionBinding = resumedState._currentTurnSessionHistoryTransactionSessionId !==
-                undefined;
-            const portableInputItems = resumedState._currentTurnSessionHistoryTransactionInputItems;
-            assertResumedSessionOutputGuardrailSafety(resumedState, session, this.#agentHasOutputGuardrail(resumedState._currentAgent));
-            resumedState.setReasoningItemIdPolicy(reasoningItemIdPolicy);
-            await prepareSessionHistoryTransactionsForRun(session, resumedState, {
-                serverManagesConversation,
-            });
-            if (!hadSessionBinding) {
-                provisionalSessionHistoryTransactionSessionId =
-                    resumedState._currentTurnSessionHistoryTransactionSessionId;
-                provisionalSessionHistoryTransactionInputItems = portableInputItems;
+        const sessionCompaction = getSessionCompactionState(session, input instanceof RunState ? input : undefined);
+        const resumedState = resumingFromState
+            ? input
+            : undefined;
+        if (resumedState?._resumedSessionWriteInProgress) {
+            throw new UserError('The same RunState cannot resume or reconcile a Session write concurrently.');
+        }
+        const resumedStateRequiresInputCompaction = resumedState !== undefined &&
+            hasPendingApprovedToolInputCompaction(resumedState);
+        if (resumedStateRequiresInputCompaction) {
+            if (serverManagesConversation || session === undefined) {
+                throw new UserError('A pending Session compaction requires the same ordinary local Session to resume safely.');
             }
+            assertPendingSessionCompactionTerminalAuthority(resumedState);
         }
-        const sessionPersistence = createSessionPersistenceTracker({
-            session,
-            runContext,
-            hasCallModelInputFilter,
-            persistInput: saveStreamInputToSession,
-            resumingFromState,
-            resumedSessionInputItems: resumingFromState
-                ? input
-                    ._currentTurnSessionHistoryTransactionInputItems
-                : undefined,
-        });
-        let preparedInput = input;
-        if (!(preparedInput instanceof RunState)) {
-            const prepared = await prepareInputItemsWithSession(preparedInput, session, sessionInputCallback, {
-                // When the server tracks conversation state we only send the new turn inputs;
-                // previous messages are recovered via conversationId/previousResponseId.
-                includeHistoryInPreparedInput: !serverManagesConversation,
-                preserveDroppedNewItems: serverManagesConversation,
-                reasoningItemIdPolicy,
-            }, runContext);
-            if (serverManagesConversation && session) {
-                // When the server manages memory we only persist the new turn inputs locally so the
-                // conversation service stays the single source of truth for prior exchanges.
-                const sessionItems = prepared.sessionItems;
-                if (sessionItems && sessionItems.length > 0) {
-                    preparedInput = sessionItems;
+        const releaseResumedSessionWriteOperation = resumedState &&
+            (resumedState._pendingSessionWrite !== undefined ||
+                resumedState._currentTurnSessionWriteCompactedItemCount !== undefined ||
+                resumedStateRequiresInputCompaction ||
+                resumedState._currentStep?.type === 'next_step_interruption')
+            ? acquireResumedSessionWriteOperation(resumedState)
+            : undefined;
+        let releaseResumedSessionWriteOperationOnReturn = true;
+        try {
+            let provisionalSessionHistoryTransactionSessionId;
+            let provisionalSessionHistoryTransactionInputItems;
+            let pendingSessionWriteReconciled = false;
+            if (resumingFromState) {
+                assertAcceptedResponseContinuationAuthority(resumedState, effectiveOptions.conversationId, effectiveOptions.previousResponseId);
+                const hadSessionBinding = resumedState._currentTurnSessionHistoryTransactionSessionId !==
+                    undefined;
+                const portableInputItems = resumedState._currentTurnSessionHistoryTransactionInputItems;
+                assertResumedSessionOutputGuardrailSafety(resumedState, session, this.#agentHasOutputGuardrail(resumedState._currentAgent));
+                pendingSessionWriteReconciled =
+                    await reconcilePendingSessionWriteBeforeRun(session, resumedState, {
+                        serverManagesConversation,
+                        operationAlreadyOwned: releaseResumedSessionWriteOperation !== undefined,
+                    });
+                resumedState.setReasoningItemIdPolicy(reasoningItemIdPolicy);
+                await prepareSessionHistoryTransactionsForRun(session, resumedState, {
+                    serverManagesConversation,
+                });
+                if (!hadSessionBinding) {
+                    provisionalSessionHistoryTransactionSessionId =
+                        resumedState._currentTurnSessionHistoryTransactionSessionId;
+                    provisionalSessionHistoryTransactionInputItems = portableInputItems;
+                }
+            }
+            const sessionPersistence = createSessionPersistenceTracker({
+                session,
+                runContext,
+                compactionState: sessionCompaction,
+                hasCallModelInputFilter,
+                persistInput: saveStreamInputToSession,
+                resumingFromState,
+                resumedSessionInputItems: resumingFromState
+                    ? input
+                        ._currentTurnSessionHistoryTransactionInputItems
+                    : undefined,
+            });
+            let preparedInput = input;
+            if (!(preparedInput instanceof RunState)) {
+                const prepared = await prepareInputItemsWithSession(preparedInput, session, sessionInputCallback, {
+                    // When the server tracks conversation state we only send the new turn inputs;
+                    // previous messages are recovered via conversationId/previousResponseId.
+                    includeHistoryInPreparedInput: !serverManagesConversation,
+                    preserveDroppedNewItems: serverManagesConversation,
+                    reasoningItemIdPolicy,
+                }, runContext, sessionCompaction);
+                if (serverManagesConversation && session) {
+                    // When the server manages memory we only persist the new turn inputs locally so the
+                    // conversation service stays the single source of truth for prior exchanges.
+                    const sessionItems = prepared.sessionItems;
+                    if (sessionItems && sessionItems.length > 0) {
+                        preparedInput = sessionItems;
+                    }
+                    else {
+                        preparedInput = prepared.preparedInput;
+                    }
                 }
                 else {
                     preparedInput = prepared.preparedInput;
                 }
+                sessionPersistence?.setPreparedItems(prepared.sessionItems, prepared.preparedInput);
             }
-            else {
-                preparedInput = prepared.preparedInput;
-            }
-            sessionPersistence?.setPreparedItems(prepared.sessionItems, prepared.preparedInput);
-        }
-        // Streaming runs persist the input asynchronously, so track a one-shot helper
-        // that can be awaited from multiple branches without double-writing.
-        const ensureStreamInputPersisted = sessionPersistence?.buildPersistInputOnce(serverManagesConversation);
-        const executeRun = async (effectiveInvocationSpanParent = invocationSpanParent) => {
-            if (effectiveOptions.stream) {
-                const streamResult = await this.#runIndividualStream(agent, preparedInput, taskSpanName, effectiveOptions, ensureStreamInputPersisted, sessionPersistence?.setPreparedTurnItems, sessionPersistence?.recordTurnItems, sessionPersistence?.getItemsForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, {
+            // Streaming runs persist the input asynchronously, so track a one-shot helper
+            // that can be awaited from multiple branches without double-writing.
+            const ensureStreamInputPersisted = sessionPersistence?.buildPersistInputOnce(serverManagesConversation);
+            const executeRun = async (effectiveInvocationSpanParent = invocationSpanParent) => {
+                if (effectiveOptions.stream) {
+                    const streamResult = await this.#runIndividualStream(agent, preparedInput, taskSpanName, effectiveOptions, ensureStreamInputPersisted, sessionPersistence?.setPreparedTurnItems, sessionPersistence?.recordTurnItems, sessionPersistence?.getItemsForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, {
+                        sdkSessionId: async () => await session?.getSessionId(),
+                        inputOverride: () => session
+                            ? sessionPersistence?.getItemsForPersistence()
+                            : undefined,
+                    }, effectiveInvocationSpanParent, pendingSessionWriteReconciled, sessionCompaction);
+                    if (releaseResumedSessionWriteOperation) {
+                        releaseResumedSessionWriteOperationOnReturn = false;
+                        void streamResult.completed.then(releaseResumedSessionWriteOperation, releaseResumedSessionWriteOperation);
+                    }
+                    return streamResult;
+                }
+                const runResult = await this.#runIndividualNonStream(agent, preparedInput, effectiveOptions, taskSpanName, sessionPersistence?.setPreparedTurnItems, sessionPersistence?.recordTurnItems, sessionPersistence?.getItemsForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, {
                     sdkSessionId: async () => await session?.getSessionId(),
                     inputOverride: () => session
                         ? sessionPersistence?.getItemsForPersistence()
                         : undefined,
-                }, effectiveInvocationSpanParent);
-                return streamResult;
-            }
-            const runResult = await this.#runIndividualNonStream(agent, preparedInput, effectiveOptions, taskSpanName, sessionPersistence?.setPreparedTurnItems, sessionPersistence?.recordTurnItems, sessionPersistence?.getItemsForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, {
-                sdkSessionId: async () => await session?.getSessionId(),
-                inputOverride: () => session ? sessionPersistence?.getItemsForPersistence() : undefined,
-            }, effectiveInvocationSpanParent, session && sessionPersistence && !serverManagesConversation
-                ? async (result, persistenceOptions) => {
-                    await saveToSession(session, sessionPersistence.getItemsForPersistence(), result, persistenceOptions);
+                }, effectiveInvocationSpanParent, session && sessionPersistence && !serverManagesConversation
+                    ? async (result, persistenceOptions) => {
+                        await saveToSession(session, sessionPersistence.getItemsForPersistence(), result, persistenceOptions);
+                    }
+                    : undefined, pendingSessionWriteReconciled, sessionCompaction);
+                return runResult;
+            };
+            if (this.config.tracingDisabled) {
+                const disabledTrace = new NoopTrace();
+                if (preparedInput instanceof RunState) {
+                    preparedInput._currentAgentSpan?.end();
+                    preparedInput._trace = null;
+                    preparedInput.setCurrentAgentSpan(undefined);
                 }
-                : undefined);
-            return runResult;
-        };
-        if (this.config.tracingDisabled) {
-            const disabledTrace = new NoopTrace();
-            if (preparedInput instanceof RunState) {
-                preparedInput._currentAgentSpan?.end();
-                preparedInput._trace = null;
-                preparedInput.setCurrentAgentSpan(undefined);
-            }
-            return withTrace(disabledTrace, async () => {
-                try {
-                    const result = await executeRun(disabledTrace);
-                    const clearDisabledTraceState = () => {
-                        result.state._trace = null;
-                        result.state.setCurrentAgentSpan(undefined);
-                    };
-                    if (result instanceof StreamedRunResult) {
-                        void result.completed.then(clearDisabledTraceState, clearDisabledTraceState);
+                return await withTrace(disabledTrace, async () => {
+                    try {
+                        const result = await executeRun(disabledTrace);
+                        const clearDisabledTraceState = () => {
+                            result.state._trace = null;
+                            result.state.setCurrentAgentSpan(undefined);
+                        };
+                        if (result instanceof StreamedRunResult) {
+                            void result.completed.then(clearDisabledTraceState, clearDisabledTraceState);
+                        }
+                        else {
+                            clearDisabledTraceState();
+                        }
+                        return result;
                     }
-                    else {
-                        clearDisabledTraceState();
+                    catch (error) {
+                        if (error instanceof AgentsError && error.state) {
+                            error.state._trace = null;
+                            error.state.setCurrentAgentSpan(undefined);
+                        }
+                        throw error;
                     }
-                    return result;
-                }
-                catch (error) {
-                    if (error instanceof AgentsError && error.state) {
-                        error.state._trace = null;
-                        error.state.setCurrentAgentSpan(undefined);
+                });
+            }
+            if (preparedInput instanceof RunState && preparedInput._trace) {
+                const applied = applyTraceOverrides(preparedInput._trace, preparedInput._currentAgentSpan, traceOverrides);
+                preparedInput._trace = applied.trace;
+                preparedInput._currentAgentSpan = applied.currentSpan;
+                return await withTrace(preparedInput._trace, async () => {
+                    if (preparedInput._currentAgentSpan && !useTaskAndTurnSpans) {
+                        setCurrentSpan(preparedInput._currentAgentSpan);
                     }
-                    throw error;
-                }
-            });
-        }
-        if (preparedInput instanceof RunState && preparedInput._trace) {
-            const applied = applyTraceOverrides(preparedInput._trace, preparedInput._currentAgentSpan, traceOverrides);
-            preparedInput._trace = applied.trace;
-            preparedInput._currentAgentSpan = applied.currentSpan;
-            return withTrace(preparedInput._trace, async () => {
-                if (preparedInput._currentAgentSpan && !useTaskAndTurnSpans) {
-                    setCurrentSpan(preparedInput._currentAgentSpan);
+                    return executeRun();
+                });
+            }
+            const executeInInvocationTrace = async (effectiveInvocationSpanParent = invocationSpanParent) => {
+                if (preparedInput instanceof RunState && !preparedInput._trace) {
+                    preparedInput._trace = getCurrentTrace();
                 }
-                return executeRun();
+                return executeRun(effectiveInvocationSpanParent);
+            };
+            if (invocationTraceContext) {
+                return await withTraceContext(invocationTraceContext, executeInInvocationTrace);
+            }
+            return await withTrace(this.config.workflowName ?? 'Agent workflow', async (trace) => executeInInvocationTrace(trace), {
+                traceId: this.config.traceId,
+                groupId: this.config.groupId,
+                metadata: this.config.traceMetadata,
+                // Per-run tracing config overrides exporter defaults such as environment API key.
+                tracingApiKey: tracingConfig?.apiKey,
             });
         }
-        const executeInInvocationTrace = async (effectiveInvocationSpanParent = invocationSpanParent) => {
-            if (preparedInput instanceof RunState && !preparedInput._trace) {
-                preparedInput._trace = getCurrentTrace();
+        finally {
+            if (releaseResumedSessionWriteOperationOnReturn) {
+                releaseResumedSessionWriteOperation?.();
             }
-            return executeRun(effectiveInvocationSpanParent);
-        };
-        if (invocationTraceContext) {
-            return withTraceContext(invocationTraceContext, executeInInvocationTrace);
         }
-        return withTrace(this.config.workflowName ?? 'Agent workflow', async (trace) => executeInInvocationTrace(trace), {
-            traceId: this.config.traceId,
-            groupId: this.config.groupId,
-            metadata: this.config.traceMetadata,
-            // Per-run tracing config overrides exporter defaults such as environment API key.
-            tracingApiKey: tracingConfig?.apiKey,
-        });
     }
     // --------------------------------------------------------------
     //  Internals
@@ -447,7 +494,7 @@ export class Runner extends RunHooks {
     async #runIndividualNonStream(startingAgent, input, options, taskSpanName, sessionTurnInputUpdate, 
     // sessionInputUpdate lets the caller adjust queued session items after filters run so we
     // persist exactly what we send to the model (e.g., after redactions or truncation).
-    sessionInputUpdate, getSessionInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, invocationSpanParent, persistResult) {
+    sessionInputUpdate, getSessionInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, invocationSpanParent, persistResult, pendingSessionWriteReconciled = false, sessionCompaction) {
         return withNewSpanContext(async () => {
             // if we have a saved state we use that one, otherwise we create a new one
             const isResumedState = input instanceof RunState;
@@ -458,6 +505,7 @@ export class Runner extends RunHooks {
                     : new RunContext(options.context), input, startingAgent, options.maxTurns === undefined
                     ? DEFAULT_MAX_TURNS
                     : options.maxTurns);
+            bindSessionCompactionState(state, sessionCompaction);
             this.#validateModelTimeoutForAgent(state._currentAgent);
             if (isResumedState) {
                 state._agentToolInvocation = undefined;
@@ -507,6 +555,9 @@ export class Runner extends RunHooks {
                 state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
             }
             const toolErrorFormatter = options.toolErrorFormatter ?? this.config.toolErrorFormatter;
+            const outputGuardrailBlockedMessage = options.outputGuardrailBlockedMessage === undefined
+                ? this.config.outputGuardrailBlockedMessage
+                : options.outputGuardrailBlockedMessage;
             const useTaskAndTurnSpans = !this.config.tracingDisabled &&
                 includeTaskAndTurnSpans(options.tracing);
             const resumingInterruptedTurn = isResumedState && state._currentStep?.type === 'next_step_interruption';
@@ -553,9 +604,16 @@ export class Runner extends RunHooks {
             setRunStateUsageRecorder(state, recordUsage);
             let completedResult;
             let persistenceCheckpoint;
-            let approvedToolCheckpointCompacted = false;
-            let approvedToolCheckpointRequiresLocalInputCompaction = isResumedState && hasPersistedToolOutput(state);
+            const resumedStateHasPersistedToolOutput = isResumedState && hasPersistedToolOutput(state);
+            let approvedToolCheckpointCompacted = pendingSessionWriteReconciled ||
+                state._currentTurnSessionWriteCompactedItemCount ===
+                    state._currentTurnPersistedItemCount ||
+                (resumedStateHasPersistedToolOutput &&
+                    !hasPendingApprovedToolInputCompaction(state));
+            let approvedToolCheckpointRequiresLocalInputCompaction = resumedStateHasPersistedToolOutput;
             let approvedToolCheckpointModelResponseCount = state._modelResponses.length;
+            let approvedToolFinalSessionWritePreparation;
+            let deferredApprovedToolFinalSessionWritePreparation;
             let completedResultPersisted = false;
             const completeResult = (result) => {
                 completedResult = result;
@@ -579,7 +637,37 @@ export class Runner extends RunHooks {
                     ...compactionOptions,
                     ...overrideOptions,
                 };
-                await persistResult?.(result, persistenceOptions);
+                const finalSessionWritePreparation = approvedToolFinalSessionWritePreparation;
+                await persistResult?.(result, {
+                    ...persistenceOptions,
+                    resumedSessionWritePreparation: finalSessionWritePreparation ??
+                        persistenceOptions.resumedSessionWritePreparation,
+                });
+                if (finalSessionWritePreparation) {
+                    approvedToolFinalSessionWritePreparation = undefined;
+                    if (persistenceOptions.deferResumedSessionWrite !== true) {
+                        approvedToolCheckpointCompacted = true;
+                        approvedToolCheckpointModelResponseCount =
+                            result.rawResponses.length;
+                    }
+                }
+            };
+            const activateDeferredApprovedToolFinalSessionWrite = () => {
+                const preparation = deferredApprovedToolFinalSessionWritePreparation;
+                if (!preparation) {
+                    return;
+                }
+                if (state._pendingSessionHistoryTransaction !== undefined ||
+                    state._currentTurnDeferredSessionItemIndexes.size > 0 ||
+                    state._currentTurnBlockedSessionStartIndex !== undefined) {
+                    deferredApprovedToolFinalSessionWritePreparation = undefined;
+                    return;
+                }
+                if (!options.session || serverManagesConversation) {
+                    throw new UserError('Resumed Session write preparation has no ordinary Session owner.');
+                }
+                deferredApprovedToolFinalSessionWritePreparation = undefined;
+                approvedToolFinalSessionWritePreparation = preparation;
             };
             const recordNonStreamingError = (error) => {
                 if (state._currentAgentSpan) {
@@ -600,30 +688,64 @@ export class Runner extends RunHooks {
                     throw new ModelBehaviorError('Expected a final output step while finalizing the run.', state);
                 }
                 markAcceptedResponseFinalizationStarted(state);
-                await finalizeOutputGuardrails({
-                    state,
-                    runnerOutputGuardrails: this.outputGuardrailDefs,
-                    output: currentStep.output,
-                    redactedOutput: OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT,
-                    guardedTerminalToolOutput: hasTerminalToolOutputSource(state),
-                    signal: options.signal,
-                    sanitizeRejectedOutput: sanitizeBlockedTerminalToolOutput,
-                    persistBlockedOutput: persistResult
-                        ? async () => persistResult(new RunResult(state), {
-                            outputBlocked: true,
-                        })
-                        : undefined,
-                    persistUnblockedFailure: async () => {
-                        await persistNonStreamingResult(new RunResult(state));
-                        completedResultPersisted = true;
-                    },
-                    releaseBlockedOutputPersistence: releaseUnusedSessionHistoryTransactionBinding,
-                });
+                normalizeSerializedOutputGuardrailBlockedMessage(state);
+                const resolveBlockedMessage = createOutputGuardrailBlockedMessageResolver(outputGuardrailBlockedMessage, state);
+                const outputGuardrailResultStart = state._outputGuardrailResults.length;
+                let outputGuardrailBlocked = false;
+                try {
+                    await finalizeOutputGuardrails({
+                        state,
+                        runnerOutputGuardrails: this.outputGuardrailDefs,
+                        output: currentStep.output,
+                        redactedOutput: OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT,
+                        guardedTerminalToolOutput: hasTerminalToolOutputSource(state),
+                        signal: options.signal,
+                        sanitizeRejectedOutput: (...args) => sanitizeBlockedTerminalToolOutput(...args, resolveBlockedMessage, options.signal, () => {
+                            outputGuardrailBlocked = true;
+                        }),
+                        persistBlockedOutput: persistResult
+                            ? async () => persistResult(new RunResult(state), {
+                                outputBlocked: true,
+                            })
+                            : undefined,
+                        persistUnblockedFailure: async () => {
+                            activateDeferredApprovedToolFinalSessionWrite();
+                            await persistNonStreamingResult(new RunResult(state));
+                            completedResultPersisted = true;
+                        },
+                        onBlockedOutput: () => {
+                            outputGuardrailBlocked = true;
+                        },
+                        releaseBlockedOutputPersistence: releaseUnusedSessionHistoryTransactionBinding,
+                    });
+                }
+                catch (error) {
+                    if (!outputGuardrailBlocked &&
+                        (deferredApprovedToolFinalSessionWritePreparation !== undefined ||
+                            state._pendingSessionWrite !== undefined ||
+                            approvedToolCheckpointCompacted)) {
+                        state._outputGuardrailResults.splice(outputGuardrailResultStart);
+                        if (deferredApprovedToolFinalSessionWritePreparation !== undefined &&
+                            state._pendingSessionWrite === undefined) {
+                            try {
+                                activateDeferredApprovedToolFinalSessionWrite();
+                                await persistNonStreamingResult(new RunResult(state), { deferResumedSessionWrite: true });
+                            }
+                            catch (checkpointError) {
+                                if (state._pendingSessionWrite === undefined) {
+                                    throw checkpointError;
+                                }
+                            }
+                        }
+                    }
+                    throw error;
+                }
                 if (state._serializedCurrentStep === currentStep &&
                     hasRetainableBlockedOutputEffect(state)) {
                     releaseProvisionalSessionHistoryTransactionBinding(state, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems);
                     throw new UserError('Accepted final output cannot be resumed directly from serialized terminal state. Start a new run from persisted session history.');
                 }
+                activateDeferredApprovedToolFinalSessionWrite();
                 finishRunnerSpan(currentTurnSpan);
                 setRunStateTurnSpanParent(state, undefined);
                 currentTurnSpan = undefined;
@@ -634,6 +756,7 @@ export class Runner extends RunHooks {
                         : undefined);
                 }
                 catch (error) {
+                    state._outputGuardrailResults.splice(outputGuardrailResultStart);
                     commitDeferredRunErrorItemAfterPartialPersistence(state, preparedErrorOutput);
                     throw error;
                 }
@@ -678,34 +801,71 @@ export class Runner extends RunHooks {
                             currentTurnSpan = ensureTurnSpan(currentTurnSpan, state._currentTurn, state._currentAgent.name, state._currentAgentSpan);
                             setRunStateTurnSpanParent(state, currentTurnSpan.span);
                         }
-                        captureCurrentResponseToolOutputGuardrailResultStart(state, false);
-                        const interruptedOutcome = await resumeInterruptedTurn({
-                            state,
-                            runner: this,
-                            toolErrorFormatter,
-                            agentToolParentRunConfig,
-                            signal: options.signal,
-                            validateHandoffAgent: (handoffAgent) => {
-                                this.#validateModelTimeoutForAgent(handoffAgent);
-                            },
-                        });
-                        const approvedToolCheckpointDeferred = interruptedOutcome.approvedToolResumed &&
-                            interruptedOutcome.nextStep.type === 'next_step_final_output' &&
-                            this.#agentHasOutputGuardrail(state._currentAgent);
-                        if (interruptedOutcome.approvedToolResumed) {
-                            const approvedToolResult = new RunResult(state);
-                            approvedToolCheckpointRequiresLocalInputCompaction = true;
-                            if (persistResult &&
-                                interruptedOutcome.nextStep.type !== 'next_step_final_output' &&
-                                !this.#shouldDeferInterruptedSessionItems(state)) {
-                                await persistResult(approvedToolResult, {
-                                    compactionMode: 'input',
-                                });
-                                approvedToolCheckpointCompacted = true;
-                                approvedToolCheckpointModelResponseCount =
-                                    approvedToolResult.rawResponses.length;
+                        const { interruptedOutcome, approvedToolCheckpointDeferred } = await (async () => {
+                            let resumedSessionWritePreparation;
+                            captureCurrentResponseToolOutputGuardrailResultStart(state, false);
+                            const outcome = await resumeInterruptedTurn({
+                                state,
+                                runner: this,
+                                toolErrorFormatter,
+                                agentToolParentRunConfig,
+                                signal: options.signal,
+                                validateHandoffAgent: (handoffAgent) => {
+                                    this.#validateModelTimeoutForAgent(handoffAgent);
+                                },
+                                beforeResumedSideEffects: async () => {
+                                    if (persistResult &&
+                                        options.session &&
+                                        !serverManagesConversation) {
+                                        resumedSessionWritePreparation =
+                                            await prepareResumedSessionWrite(options.session, state);
+                                    }
+                                    return resumedSessionWritePreparation;
+                                },
+                            });
+                            const checkpointDeferred = outcome.resumedSideEffects &&
+                                outcome.nextStep.type === 'next_step_final_output' &&
+                                this.#agentHasOutputGuardrail(state._currentAgent);
+                            if (outcome.resumedSideEffects) {
+                                const approvedToolResult = new RunResult(state);
+                                approvedToolCheckpointRequiresLocalInputCompaction = true;
+                                if (persistResult &&
+                                    !this.#shouldDeferInterruptedSessionItems(state)) {
+                                    if (options.session &&
+                                        !serverManagesConversation &&
+                                        !resumedSessionWritePreparation) {
+                                        throw new UserError('Resumed Session write preparation is missing after approved tool execution.');
+                                    }
+                                    if (checkpointDeferred) {
+                                        deferredApprovedToolFinalSessionWritePreparation =
+                                            resumedSessionWritePreparation;
+                                    }
+                                    else if (outcome.nextStep.type === 'next_step_final_output') {
+                                        approvedToolFinalSessionWritePreparation =
+                                            resumedSessionWritePreparation;
+                                    }
+                                    if (outcome.nextStep.type !== 'next_step_final_output') {
+                                        await persistResult(approvedToolResult, {
+                                            compactionMode: 'input',
+                                            resumedSessionWritePreparation,
+                                        });
+                                        approvedToolCheckpointCompacted = true;
+                                        approvedToolCheckpointModelResponseCount =
+                                            approvedToolResult.rawResponses.length;
+                                    }
+                                    else {
+                                        approvedToolFinalSessionWritePreparation ??=
+                                            checkpointDeferred
+                                                ? undefined
+                                                : resumedSessionWritePreparation;
+                                    }
+                                }
                             }
-                        }
+                            return {
+                                interruptedOutcome: outcome,
+                                approvedToolCheckpointDeferred: checkpointDeferred,
+                            };
+                        })();
                         if (options.signal?.aborted && !approvedToolCheckpointDeferred) {
                             persistenceCheckpoint = new RunResult(state);
                         }
@@ -719,7 +879,8 @@ export class Runner extends RunHooks {
                                 continuingInterruptedTurn = value;
                             },
                         });
-                        if (!shouldContinue) {
+                        if (!shouldContinue ||
+                            interruptedOutcome.nextStep.type === 'next_step_handoff') {
                             finishRunnerSpan(currentTurnSpan);
                             setRunStateTurnSpanParent(state, undefined);
                             currentTurnSpan = undefined;
@@ -866,11 +1027,14 @@ export class Runner extends RunHooks {
                             }
                             serverInputMarked = true;
                         };
-                        const pendingModelResponse = getResponseWithRetry(preparedCall.model, modelRequest, serverConversationTracker
-                            ? {
-                                onPossiblyAcceptedRequestFailure: () => markServerInputAccepted(false),
-                            }
-                            : undefined);
+                        const pendingModelResponse = getResponseWithRetry(preparedCall.model, modelRequest, {
+                            onModelFailureUsage: (usage) => recordModelFailureUsage(usage, state, recordUsage),
+                            ...(serverConversationTracker
+                                ? {
+                                    onPossiblyAcceptedRequestFailure: () => markServerInputAccepted(false),
+                                }
+                                : {}),
+                        });
                         if (deferLocalPendingInputAdmission) {
                             const modelResponseOutcome = pendingModelResponse.then((response) => ({ status: 'fulfilled', response }), (error) => ({ status: 'rejected', error }));
                             try {
@@ -905,11 +1069,20 @@ export class Runner extends RunHooks {
                         if (serverConversationTracker) {
                             state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
                         }
-                        const processedResponse = await processModelResponseAsync(state._lastTurnResponse, state._currentAgent, preparedCall.tools, preparedCall.handoffs, state, [...preparedCall.turnInput, ...state._generatedItems], options.toolNotFoundBehavior, {
+                        const processedResponse = await processModelResponseAsync(state._lastTurnResponse, state._currentAgent, preparedCall.tools, preparedCall.handoffs, state, 
+                        // Loading authority retains the agent ownership lost in model input.
+                        [
+                            ...(Array.isArray(state._originalInput)
+                                ? state._originalInput
+                                : []),
+                            ...state._generatedItems,
+                        ], options.toolNotFoundBehavior, {
                             allowPromptSuppliedTools: preparedCall.allowPromptSuppliedTools,
                             beforeClientToolSearch: () => preflightModelResponseToolInvocations(state._currentAgent, state, state._lastTurnResponse, preparedCall.tools, preparedCall.handoffs),
                         });
+                        serverConversationTracker?.trackServerItems(state._lastTurnResponse, processedResponse.newItems);
                         state._lastProcessedResponse = processedResponse;
+                        trackDeferredToolRecovery(state, state._currentAgent, processedResponse);
                         const suppressedToolCalls = preflightToolInvocations(state._currentAgent, state, processedResponse);
                         await guardrailTracker.awaitCompletion();
                         markAcceptedResponseProcessingStarted(state);
@@ -989,13 +1162,15 @@ export class Runner extends RunHooks {
                 }
                 attachRunStateToError(err, state);
                 releaseUnusedSessionHistoryTransactionBinding(state);
-                const errorHandled = await prepareRunErrorFinalOutput({
-                    error: err,
-                    state,
-                    errorHandlers: options.errorHandlers,
-                    responseAccepted: isAcceptedResponseCheckpoint(state),
-                    attemptedErrors: attemptedRunErrorHandlers,
-                });
+                const errorHandled = state._pendingSessionWrite
+                    ? undefined
+                    : await prepareRunErrorFinalOutput({
+                        error: err,
+                        state,
+                        errorHandlers: options.errorHandlers,
+                        responseAccepted: isAcceptedResponseCheckpoint(state),
+                        attemptedErrors: attemptedRunErrorHandlers,
+                    });
                 if (errorHandled) {
                     try {
                         return await finalizeCurrentOutput(errorHandled);
@@ -1052,7 +1227,7 @@ export class Runner extends RunHooks {
     /**
      * @internal
      */
-    async #runStreamLoop(result, startingAgent, sandboxRuntime, options, isResumedState, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, taskSpan, invocationSpanParent) {
+    async #runStreamLoop(result, startingAgent, sandboxRuntime, options, isResumedState, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, taskSpan, invocationSpanParent, pendingSessionWriteReconciled = false) {
         const resolvedReasoningItemIdPolicy = options.reasoningItemIdPolicy ??
             (isResumedState ? result.state._reasoningItemIdPolicy : undefined) ??
             this.config.reasoningItemIdPolicy;
@@ -1098,6 +1273,9 @@ export class Runner extends RunHooks {
             result.state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
         }
         const toolErrorFormatter = options.toolErrorFormatter ?? this.config.toolErrorFormatter;
+        const outputGuardrailBlockedMessage = options.outputGuardrailBlockedMessage === undefined
+            ? this.config.outputGuardrailBlockedMessage
+            : options.outputGuardrailBlockedMessage;
         const agentToolParentRunConfig = this.#getAgentToolParentRunConfig(options);
         const useTaskAndTurnSpans = !this.config.tracingDisabled && includeTaskAndTurnSpans(options.tracing);
         // Tracks when we resume an approval interruption so the next run-again step stays in the same turn.
@@ -1105,9 +1283,16 @@ export class Runner extends RunHooks {
         let runError;
         const attemptedRunErrorHandlers = new WeakSet();
         let suppressStreamInputPersistence = false;
-        let approvedToolCheckpointCompacted = false;
-        let approvedToolCheckpointRequiresLocalInputCompaction = isResumedState && hasPersistedToolOutput(result.state);
+        const resumedStateHasPersistedToolOutput = isResumedState && hasPersistedToolOutput(result.state);
+        let approvedToolCheckpointCompacted = pendingSessionWriteReconciled ||
+            result.state._currentTurnSessionWriteCompactedItemCount ===
+                result.state._currentTurnPersistedItemCount ||
+            (resumedStateHasPersistedToolOutput &&
+                !hasPendingApprovedToolInputCompaction(result.state));
+        let approvedToolCheckpointRequiresLocalInputCompaction = resumedStateHasPersistedToolOutput;
         let approvedToolCheckpointModelResponseCount = result.rawResponses.length;
+        let approvedToolFinalSessionWritePreparation;
+        let deferredApprovedToolFinalSessionWritePreparation;
         let currentTurnSpan;
         let turnPendingModelRequest;
         let commitDeferredLocalPendingInput;
@@ -1136,13 +1321,42 @@ export class Runner extends RunHooks {
                 ...compactionOptions,
                 ...overrideOptions,
             };
+            const finalSessionWritePreparation = approvedToolFinalSessionWritePreparation;
             const sessionInputItems = streamInputPersisted
                 ? undefined
                 : getStreamInputForPersistence?.();
             // A remote session may commit addItems before rejecting, and compaction happens after the
             // append. Once the combined save starts, retrying the input is therefore unsafe.
             streamInputPersisted = true;
-            await saveStreamResultToSession(options.session, result, persistenceOptions, sessionInputItems);
+            await saveStreamResultToSession(options.session, result, {
+                ...persistenceOptions,
+                resumedSessionWritePreparation: finalSessionWritePreparation ??
+                    persistenceOptions.resumedSessionWritePreparation,
+            }, sessionInputItems);
+            if (finalSessionWritePreparation) {
+                approvedToolFinalSessionWritePreparation = undefined;
+                if (persistenceOptions.deferResumedSessionWrite !== true) {
+                    approvedToolCheckpointCompacted = true;
+                    approvedToolCheckpointModelResponseCount = result.rawResponses.length;
+                }
+            }
+        };
+        const activateDeferredApprovedToolFinalSessionWrite = () => {
+            const preparation = deferredApprovedToolFinalSessionWritePreparation;
+            if (!preparation) {
+                return;
+            }
+            if (result.state._pendingSessionHistoryTransaction !== undefined ||
+                result.state._currentTurnDeferredSessionItemIndexes.size > 0 ||
+                result.state._currentTurnBlockedSessionStartIndex !== undefined) {
+                deferredApprovedToolFinalSessionWritePreparation = undefined;
+                return;
+            }
+            if (!options.session || serverManagesConversation) {
+                throw new UserError('Resumed Session write preparation has no ordinary Session owner.');
+            }
+            deferredApprovedToolFinalSessionWritePreparation = undefined;
+            approvedToolFinalSessionWritePreparation = preparation;
         };
         const recordStreamingError = (error) => {
             if (result.state._currentAgentSpan) {
@@ -1164,29 +1378,67 @@ export class Runner extends RunHooks {
             }
             markAcceptedResponseFinalizationStarted(result.state);
             result._hideFinalOutput();
-            await finalizeOutputGuardrails({
-                state: result.state,
-                runnerOutputGuardrails: this.outputGuardrailDefs,
-                output: currentStep.output,
-                redactedOutput: OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT,
-                guardedTerminalToolOutput: hasTerminalToolOutputSource(result.state),
-                signal: options.signal,
-                sanitizeRejectedOutput: sanitizeBlockedTerminalToolOutput,
-                persistBlockedOutput: !serverManagesConversation
-                    ? async () => saveStreamResultWithCompactionOwnership({
-                        outputBlocked: true,
-                    })
-                    : undefined,
-                persistUnblockedFailure: !serverManagesConversation
-                    ? async () => saveStreamResultWithCompactionOwnership()
-                    : undefined,
-                releaseBlockedOutputPersistence: releaseUnusedSessionHistoryTransactionBinding,
-            });
+            normalizeSerializedOutputGuardrailBlockedMessage(result.state);
+            const resolveBlockedMessage = createOutputGuardrailBlockedMessageResolver(outputGuardrailBlockedMessage, result.state);
+            const outputGuardrailResultStart = result.state._outputGuardrailResults.length;
+            let outputGuardrailBlocked = false;
+            try {
+                await finalizeOutputGuardrails({
+                    state: result.state,
+                    runnerOutputGuardrails: this.outputGuardrailDefs,
+                    output: currentStep.output,
+                    redactedOutput: OUTPUT_GUARDRAIL_BLOCKED_TOOL_OUTPUT,
+                    guardedTerminalToolOutput: hasTerminalToolOutputSource(result.state),
+                    signal: options.signal,
+                    sanitizeRejectedOutput: (...args) => sanitizeBlockedTerminalToolOutput(...args, resolveBlockedMessage, options.signal, () => {
+                        outputGuardrailBlocked = true;
+                    }),
+                    persistBlockedOutput: !serverManagesConversation
+                        ? async () => saveStreamResultWithCompactionOwnership({
+                            outputBlocked: true,
+                        })
+                        : undefined,
+                    persistUnblockedFailure: !serverManagesConversation
+                        ? async () => {
+                            activateDeferredApprovedToolFinalSessionWrite();
+                            await saveStreamResultWithCompactionOwnership();
+                        }
+                        : undefined,
+                    onBlockedOutput: () => {
+                        outputGuardrailBlocked = true;
+                    },
+                    releaseBlockedOutputPersistence: releaseUnusedSessionHistoryTransactionBinding,
+                });
+            }
+            catch (error) {
+                if (!outputGuardrailBlocked &&
+                    (deferredApprovedToolFinalSessionWritePreparation !== undefined ||
+                        result.state._pendingSessionWrite !== undefined ||
+                        approvedToolCheckpointCompacted)) {
+                    result.state._outputGuardrailResults.splice(outputGuardrailResultStart);
+                    if (deferredApprovedToolFinalSessionWritePreparation !== undefined &&
+                        result.state._pendingSessionWrite === undefined) {
+                        try {
+                            activateDeferredApprovedToolFinalSessionWrite();
+                            await saveStreamResultWithCompactionOwnership({
+                                deferResumedSessionWrite: true,
+                            });
+                        }
+                        catch (checkpointError) {
+                            if (result.state._pendingSessionWrite === undefined) {
+                                throw checkpointError;
+                            }
+                        }
+                    }
+                }
+                throw error;
+            }
             if (result.state._serializedCurrentStep === currentStep &&
                 hasRetainableBlockedOutputEffect(result.state)) {
                 releaseProvisionalSessionHistoryTransactionBinding(result.state, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems);
                 throw new UserError('Accepted final output cannot be resumed directly from serialized terminal state. Start a new run from persisted session history.');
             }
+            activateDeferredApprovedToolFinalSessionWrite();
             finishRunnerSpan(currentTurnSpan);
             setRunStateTurnSpanParent(result.state, undefined);
             currentTurnSpan = undefined;
@@ -1199,6 +1451,7 @@ export class Runner extends RunHooks {
                         : undefined);
                 }
                 catch (error) {
+                    result.state._outputGuardrailResults.splice(outputGuardrailResultStart);
                     const itemCommitted = commitDeferredRunErrorItemAfterPartialPersistence(result.state, preparedErrorOutput);
                     if (itemCommitted && preparedErrorOutput?.deferredItem) {
                         streamStepItemsToRunResult(result, [
@@ -1269,34 +1522,63 @@ export class Runner extends RunHooks {
                         currentTurnSpan = ensureTurnSpan(currentTurnSpan, result.state._currentTurn, result.state._currentAgent.name, result.state._currentAgentSpan);
                         setRunStateTurnSpanParent(result.state, currentTurnSpan.span);
                     }
-                    captureCurrentResponseToolOutputGuardrailResultStart(result.state, false);
-                    const interruptedOutcome = await resumeInterruptedTurn({
-                        state: result.state,
-                        runner: this,
-                        toolErrorFormatter,
-                        agentToolParentRunConfig,
-                        signal: options.signal,
-                        validateHandoffAgent: (handoffAgent) => {
-                            this.#validateModelTimeoutForAgent(handoffAgent);
-                        },
-                        onStepItems: (turnResult) => {
-                            addStepToRunResult(result, turnResult);
-                        },
-                    });
-                    if (interruptedOutcome.approvedToolResumed) {
-                        approvedToolCheckpointRequiresLocalInputCompaction = true;
-                        if (interruptedOutcome.nextStep.type !== 'next_step_final_output' &&
-                            !serverManagesConversation &&
-                            options.session &&
-                            !this.#shouldDeferInterruptedSessionItems(result.state)) {
-                            await saveStreamResultToSession(options.session, result, {
-                                compactionMode: 'input',
-                            });
-                            approvedToolCheckpointCompacted = true;
-                            approvedToolCheckpointModelResponseCount =
-                                result.rawResponses.length;
+                    const interruptedOutcome = await (async () => {
+                        let resumedSessionWritePreparation;
+                        captureCurrentResponseToolOutputGuardrailResultStart(result.state, false);
+                        const outcome = await resumeInterruptedTurn({
+                            state: result.state,
+                            runner: this,
+                            toolErrorFormatter,
+                            agentToolParentRunConfig,
+                            signal: options.signal,
+                            validateHandoffAgent: (handoffAgent) => {
+                                this.#validateModelTimeoutForAgent(handoffAgent);
+                            },
+                            onStepItems: (turnResult) => {
+                                addStepToRunResult(result, turnResult);
+                            },
+                            onHandoff: (agent) => {
+                                result._addItem(new RunAgentUpdatedStreamEvent(agent));
+                            },
+                            beforeResumedSideEffects: async () => {
+                                if (options.session && !serverManagesConversation) {
+                                    resumedSessionWritePreparation =
+                                        await prepareResumedSessionWrite(options.session, result.state);
+                                }
+                                return resumedSessionWritePreparation;
+                            },
+                        });
+                        if (outcome.resumedSideEffects) {
+                            const checkpointDeferred = outcome.nextStep.type === 'next_step_final_output' &&
+                                this.#agentHasOutputGuardrail(result.state._currentAgent);
+                            approvedToolCheckpointRequiresLocalInputCompaction = true;
+                            if (!serverManagesConversation &&
+                                options.session &&
+                                !this.#shouldDeferInterruptedSessionItems(result.state)) {
+                                if (!resumedSessionWritePreparation) {
+                                    throw new UserError('Resumed Session write preparation is missing after approved tool execution.');
+                                }
+                                if (checkpointDeferred) {
+                                    deferredApprovedToolFinalSessionWritePreparation =
+                                        resumedSessionWritePreparation;
+                                }
+                                else if (outcome.nextStep.type === 'next_step_final_output') {
+                                    approvedToolFinalSessionWritePreparation =
+                                        resumedSessionWritePreparation;
+                                }
+                                else {
+                                    await saveStreamResultToSession(options.session, result, {
+                                        compactionMode: 'input',
+                                        resumedSessionWritePreparation,
+                                    });
+                                    approvedToolCheckpointCompacted = true;
+                                    approvedToolCheckpointModelResponseCount =
+                                        result.rawResponses.length;
+                                }
+                            }
                         }
-                    }
+                        return outcome;
+                    })();
                     // Don't reset counter here - resolveInterruptedTurn already adjusted it via rewind logic
                     // The counter will be reset when _currentTurn is incremented (starting a new turn)
                     const { shouldReturn, shouldContinue } = handleInterruptedOutcome({
@@ -1306,7 +1588,8 @@ export class Runner extends RunHooks {
                             continuingInterruptedTurn = value;
                         },
                     });
-                    if (!shouldContinue) {
+                    if (!shouldContinue ||
+                        interruptedOutcome.nextStep.type === 'next_step_handoff') {
                         finishRunnerSpan(currentTurnSpan);
                         setRunStateTurnSpanParent(result.state, undefined);
                         currentTurnSpan = undefined;
@@ -1488,6 +1771,8 @@ export class Runner extends RunHooks {
                                 handoffs: preparedCall.serializedHandoffs,
                                 outputType: convertAgentOutputTypeToSerializable(currentAgent.outputType),
                                 tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
+                            }, {
+                                onModelFailureUsage: (usage) => recordModelFailureUsage(usage, result.state, recordUsage),
                             });
                             markAbortReconciliationComplete(abortReconciliationState, reconciliationResponse);
                             result.state._context.usage.add(reconciliationResponse.usage);
@@ -1525,6 +1810,7 @@ export class Runner extends RunHooks {
                     sentInputToModel = true;
                     try {
                         for await (const event of getStreamedResponseWithRetry(preparedCall.model, modelRequest, {
+                            onModelFailureUsage: (usage) => recordModelFailureUsage(usage, result.state, recordUsage),
                             onModelTimeout: () => {
                                 timedOutModelCallFailed = true;
                             },
@@ -1626,11 +1912,20 @@ export class Runner extends RunHooks {
                         result.state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
                     }
                     result.state._modelResponses.push(result.state._lastTurnResponse);
-                    const processedResponse = await processModelResponseAsync(result.state._lastTurnResponse, currentAgent, preparedCall.tools, preparedCall.handoffs, result.state, [...preparedCall.turnInput, ...result.state._generatedItems], options.toolNotFoundBehavior, {
+                    const processedResponse = await processModelResponseAsync(result.state._lastTurnResponse, currentAgent, preparedCall.tools, preparedCall.handoffs, result.state, 
+                    // Loading authority retains the agent ownership lost in model input.
+                    [
+                        ...(Array.isArray(result.state._originalInput)
+                            ? result.state._originalInput
+                            : []),
+                        ...result.state._generatedItems,
+                    ], options.toolNotFoundBehavior, {
                         allowPromptSuppliedTools: preparedCall.allowPromptSuppliedTools,
                         beforeClientToolSearch: () => preflightModelResponseToolInvocations(currentAgent, result.state, result.state._lastTurnResponse, preparedCall.tools, preparedCall.handoffs),
                     });
+                    serverConversationTracker?.trackServerItems(result.state._lastTurnResponse, processedResponse.newItems);
                     result.state._lastProcessedResponse = processedResponse;
+                    trackDeferredToolRecovery(result.state, currentAgent, processedResponse);
                     const suppressedToolCalls = preflightToolInvocations(currentAgent, result.state, processedResponse);
                     const streamableItems = filterSuppressedToolCallItems(processedResponse.newItems, suppressedToolCalls);
                     // Record the items emitted directly from the model response so we do not
@@ -1716,14 +2011,16 @@ export class Runner extends RunHooks {
             releaseUnusedSessionHistoryTransactionBinding(result.state);
             suppressStreamInputPersistence =
                 error instanceof CompactionItemValidationError;
-            const errorHandled = await prepareRunErrorFinalOutput({
-                error,
-                state: result.state,
-                errorHandlers: options.errorHandlers,
-                streamResult: result,
-                responseAccepted: isAcceptedResponseCheckpoint(result.state),
-                attemptedErrors: attemptedRunErrorHandlers,
-            });
+            const errorHandled = result.state._pendingSessionWrite
+                ? undefined
+                : await prepareRunErrorFinalOutput({
+                    error,
+                    state: result.state,
+                    errorHandlers: options.errorHandlers,
+                    streamResult: result,
+                    responseAccepted: isAcceptedResponseCheckpoint(result.state),
+                    attemptedErrors: attemptedRunErrorHandlers,
+                });
             if (errorHandled) {
                 try {
                     await finalizeStreamOutput(errorHandled);
@@ -1782,7 +2079,7 @@ export class Runner extends RunHooks {
     /**
      * @internal
      */
-    async #runIndividualStream(agent, input, taskSpanName, options, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, invocationSpanParent) {
+    async #runIndividualStream(agent, input, taskSpanName, options, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, invocationSpanParent, pendingSessionWriteReconciled = false, sessionCompaction) {
         options = options ?? {};
         return withNewSpanContext(async () => {
             // Initialize or reuse existing state
@@ -1794,6 +2091,7 @@ export class Runner extends RunHooks {
                     : new RunContext(options.context), input, agent, options.maxTurns === undefined
                     ? DEFAULT_MAX_TURNS
                     : options.maxTurns);
+            bindSessionCompactionState(state, sessionCompaction);
             this.#validateModelTimeoutForAgent(state._currentAgent);
             if (isResumedState) {
                 state._agentToolInvocation = undefined;
@@ -1866,7 +2164,7 @@ export class Runner extends RunHooks {
             // Setup defaults
             result.maxTurns = state._maxTurns;
             // Continue the stream loop without blocking
-            const streamLoopPromise = this.#runStreamLoop(result, agent, sandboxRuntime, streamOptions, isResumedState, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, taskSpan, invocationSpanParent).then(() => {
+            const streamLoopPromise = this.#runStreamLoop(result, agent, sandboxRuntime, streamOptions, isResumedState, ensureStreamInputPersisted, sessionTurnInputUpdate, sessionInputUpdate, getStreamInputForPersistence, preserveTurnPersistenceOnResume, provisionalSessionHistoryTransactionSessionId, provisionalSessionHistoryTransactionInputItems, sandboxMemoryRunContext, taskSpan, invocationSpanParent, pendingSessionWriteReconciled).then(() => {
                 result._done();
             }, (err) => {
                 result._raiseError(err);
@@ -1898,7 +2196,11 @@ export class Runner extends RunHooks {
         const agentModelSettings = hasExplicitAgentModelSettings
             ? executionAgent.modelSettings
             : undefined;
-        const implicitModelSettings = hasExplicitAgentModelSettings
+        // Only adapters that honor prompt model selection can replace the default model.
+        const promptOwnsModel = model.supportsPromptModelSelection === true &&
+            executionAgent.prompt !== undefined &&
+            !explicitlyModelSet;
+        const implicitModelSettings = hasExplicitAgentModelSettings || promptOwnsModel
             ? undefined
             : getImplicitModelSettingsForResolvedModel(explicitlyModelSet, resolvedModelName);
         const modelRequestInternal = {
@@ -1910,7 +2212,7 @@ export class Runner extends RunHooks {
         };
         let modelSettings = mergeModelSettings(implicitModelSettings, this.config.modelSettings);
         modelSettings = mergeModelSettings(modelSettings, agentModelSettings);
-        modelSettings = adjustModelSettingsForNonGPT5RunnerModel(explicitlyModelSet, agentModelSettings ?? implicitModelSettings ?? {}, model, modelSettings, resolvedModelName);
+        modelSettings = adjustModelSettingsForLegacyModel(explicitlyModelSet, agentModelSettings ?? implicitModelSettings ?? {}, modelSettings, resolvedModelName);
         modelSettings = maybeResetToolChoice(state._currentAgent, state._toolUseTracker, modelSettings);
         validateModelTimeoutMs(modelSettings);
         state._lastModelSettings = modelSettings;