@openai/agents-core 0.3.7 → 0.3.8

package/dist/run.mjs

@@ -1,24 +1,32 @@
 import { Agent } from "./agent.mjs";
+import { RunAgentUpdatedStreamEvent, RunRawModelStreamEvent } from "./events.mjs";
+import { ModelBehaviorError, UserError } from "./errors.mjs";
 import { defineInputGuardrail, defineOutputGuardrail, } from "./guardrail.mjs";
+import { RunHooks } from "./lifecycle.mjs";
+import logger from "./logger.mjs";
 import { getDefaultModelProvider } from "./providers.mjs";
 import { RunContext } from "./runContext.mjs";
 import { RunResult, StreamedRunResult } from "./result.mjs";
-import { RunHooks } from "./lifecycle.mjs";
-import logger from "./logger.mjs";
-import { serializeTool, serializeHandoff } from "./utils/serialize.mjs";
-import { GuardrailExecutionError, InputGuardrailTripwireTriggered, MaxTurnsExceededError, ModelBehaviorError, OutputGuardrailTripwireTriggered, UserError, } from "./errors.mjs";
-import { addStepToRunResult, resolveInterruptedTurn, resolveTurnAfterModelResponse, maybeResetToolChoice, processModelResponse, streamStepItemsToRunResult, saveStreamInputToSession, saveStreamResultToSession, saveToSession, prepareInputItemsWithSession, } from "./runImplementation.mjs";
-import { resolveComputer, disposeResolvedComputers, } from "./tool.mjs";
-import { getOrCreateTrace, addErrorToCurrentSpan, resetCurrentSpan, setCurrentSpan, withNewSpanContext, withTrace, } from "./tracing/context.mjs";
-import { createAgentSpan, withGuardrailSpan } from "./tracing/index.mjs";
-import { Usage } from "./usage.mjs";
-import { RunAgentUpdatedStreamEvent, RunRawModelStreamEvent } from "./events.mjs";
 import { RunState } from "./runState.mjs";
-import { StreamEventResponseCompleted } from "./types/protocol.mjs";
+import { disposeResolvedComputers } from "./tool.mjs";
+import { getOrCreateTrace, resetCurrentSpan, setCurrentSpan, withNewSpanContext, withTrace, } from "./tracing/context.mjs";
+import { Usage } from "./usage.mjs";
 import { convertAgentOutputTypeToSerializable } from "./utils/tools.mjs";
-import { gpt5ReasoningSettingsRequired, isGpt5Default } from "./defaultModel.mjs";
-import { encodeUint8ArrayToBase64 } from "./utils/base64.mjs";
-import { isArrayBufferView, isNodeBuffer, isSerializedBufferSnapshot, } from "./utils/smartString.mjs";
+import { DEFAULT_MAX_TURNS } from "./runner/constants.mjs";
+import { StreamEventResponseCompleted } from "./types/protocol.mjs";
+import { ServerConversationTracker, applyCallModelInputFilter, } from "./runner/conversation.mjs";
+import { createGuardrailTracker, runOutputGuardrails, } from "./runner/guardrails.mjs";
+import { adjustModelSettingsForNonGPT5RunnerModel, maybeResetToolChoice, selectModel, } from "./runner/modelSettings.mjs";
+import { processModelResponse } from "./runner/modelOutputs.mjs";
+import { addStepToRunResult, streamStepItemsToRunResult, isAbortError, } from "./runner/streaming.mjs";
+import { createSessionPersistenceTracker, prepareInputItemsWithSession, saveStreamInputToSession, saveStreamResultToSession, saveToSession, } from "./runner/sessionPersistence.mjs";
+import { resolveTurnAfterModelResponse } from "./runner/turnResolution.mjs";
+import { prepareTurn } from "./runner/turnPreparation.mjs";
+import { applyTurnResult, handleInterruptedOutcome, resumeInterruptedTurn, } from "./runner/runLoop.mjs";
+import { getTracing } from "./runner/tracing.mjs";
+export { getTracing } from "./runner/tracing.mjs";
+export { selectModel } from "./runner/modelSettings.mjs";
+export { getTurnInput } from "./runner/items.mjs";
 export async function run(agent, input, options) {
     const runner = getDefaultRunner();
     if (options?.stream) {
@@ -54,6 +62,7 @@ export class Runner extends RunHooks {
             traceId: config.traceId,
             groupId: config.groupId,
             traceMetadata: config.traceMetadata,
+            tracing: config.tracing,
             sessionInputCallback: config.sessionInputCallback,
             callModelInputFilter: config.callModelInputFilter,
         };
@@ -70,147 +79,34 @@ export class Runner extends RunHooks {
         // Likewise allow callers to override callModelInputFilter on individual runs.
         const callModelInputFilter = resolvedOptions.callModelInputFilter ?? this.config.callModelInputFilter;
         const hasCallModelInputFilter = Boolean(callModelInputFilter);
+        const tracingConfig = resolvedOptions.tracing ?? this.config.tracing;
         const effectiveOptions = {
             ...resolvedOptions,
             sessionInputCallback,
             callModelInputFilter,
         };
-        const serverManagesConversation = Boolean(effectiveOptions.conversationId) ||
-            Boolean(effectiveOptions.previousResponseId);
+        const resumingFromState = input instanceof RunState;
+        const preserveTurnPersistenceOnResume = resumingFromState &&
+            input._currentTurnInProgress === true;
+        const resumedConversationId = resumingFromState
+            ? input._conversationId
+            : undefined;
+        const resumedPreviousResponseId = resumingFromState
+            ? input._previousResponseId
+            : undefined;
+        const serverManagesConversation = Boolean(effectiveOptions.conversationId ?? resumedConversationId) ||
+            Boolean(effectiveOptions.previousResponseId ?? resumedPreviousResponseId);
         // 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;
-        const resumingFromState = input instanceof RunState;
-        let sessionInputOriginalSnapshot = session && resumingFromState ? [] : undefined;
-        let sessionInputFilteredSnapshot = undefined;
-        // Tracks remaining persistence slots per AgentInputItem key so resumed sessions only write each original occurrence once.
-        let sessionInputPendingWriteCounts = session && resumingFromState ? new Map() : undefined;
-        // Keeps track of which inputs should be written back to session memory. `sourceItems` reflects
-        // the original objects (so we can respect resume counts) while `filteredItems`, when present,
-        // contains the filtered/redacted clones that must be persisted for history.
-        // The helper reconciles the filtered copies produced by callModelInputFilter with their original
-        // counterparts so resume-from-state bookkeeping stays consistent and duplicate references only
-        // consume a single persistence slot.
-        const recordSessionItemsForPersistence = (sourceItems, filteredItems) => {
-            const pendingWriteCounts = sessionInputPendingWriteCounts;
-            if (filteredItems !== undefined) {
-                if (!pendingWriteCounts) {
-                    sessionInputFilteredSnapshot = filteredItems.map((item) => structuredClone(item));
-                    return;
-                }
-                const persistableItems = [];
-                const sourceOccurrenceCounts = new WeakMap();
-                // Track how many times each original object appears so duplicate references only consume one persistence slot.
-                for (const source of sourceItems) {
-                    if (!source || typeof source !== 'object') {
-                        continue;
-                    }
-                    const nextCount = (sourceOccurrenceCounts.get(source) ?? 0) + 1;
-                    sourceOccurrenceCounts.set(source, nextCount);
-                }
-                // Let filtered items without a one-to-one source match claim any remaining persistence count.
-                const consumeAnyPendingWriteSlot = () => {
-                    for (const [key, remaining] of pendingWriteCounts) {
-                        if (remaining > 0) {
-                            pendingWriteCounts.set(key, remaining - 1);
-                            return true;
-                        }
-                    }
-                    return false;
-                };
-                for (let i = 0; i < filteredItems.length; i++) {
-                    const filteredItem = filteredItems[i];
-                    if (!filteredItem) {
-                        continue;
-                    }
-                    let allocated = false;
-                    const source = sourceItems[i];
-                    if (source && typeof source === 'object') {
-                        const pendingOccurrences = (sourceOccurrenceCounts.get(source) ?? 0) - 1;
-                        sourceOccurrenceCounts.set(source, pendingOccurrences);
-                        if (pendingOccurrences > 0) {
-                            continue;
-                        }
-                        const sourceKey = getAgentInputItemKey(source);
-                        const remaining = pendingWriteCounts.get(sourceKey) ?? 0;
-                        if (remaining > 0) {
-                            pendingWriteCounts.set(sourceKey, remaining - 1);
-                            persistableItems.push(structuredClone(filteredItem));
-                            allocated = true;
-                            continue;
-                        }
-                    }
-                    const filteredKey = getAgentInputItemKey(filteredItem);
-                    const filteredRemaining = pendingWriteCounts.get(filteredKey) ?? 0;
-                    if (filteredRemaining > 0) {
-                        pendingWriteCounts.set(filteredKey, filteredRemaining - 1);
-                        persistableItems.push(structuredClone(filteredItem));
-                        allocated = true;
-                        continue;
-                    }
-                    if (!source && consumeAnyPendingWriteSlot()) {
-                        persistableItems.push(structuredClone(filteredItem));
-                        allocated = true;
-                    }
-                    if (!allocated &&
-                        !source &&
-                        sessionInputFilteredSnapshot === undefined) {
-                        // Preserve at least one copy so later persistence resolves even when no counters remain.
-                        persistableItems.push(structuredClone(filteredItem));
-                    }
-                }
-                if (persistableItems.length > 0 ||
-                    sessionInputFilteredSnapshot === undefined) {
-                    sessionInputFilteredSnapshot = persistableItems;
-                }
-                return;
-            }
-            const filtered = [];
-            if (!pendingWriteCounts) {
-                for (const item of sourceItems) {
-                    if (!item) {
-                        continue;
-                    }
-                    filtered.push(structuredClone(item));
-                }
-            }
-            else {
-                for (const item of sourceItems) {
-                    if (!item) {
-                        continue;
-                    }
-                    const key = getAgentInputItemKey(item);
-                    const remaining = pendingWriteCounts.get(key) ?? 0;
-                    if (remaining <= 0) {
-                        continue;
-                    }
-                    pendingWriteCounts.set(key, remaining - 1);
-                    filtered.push(structuredClone(item));
-                }
-            }
-            if (filtered.length > 0) {
-                sessionInputFilteredSnapshot = filtered;
-            }
-            else if (sessionInputFilteredSnapshot === undefined) {
-                sessionInputFilteredSnapshot = [];
-            }
-        };
-        // Determine which items should be committed to session memory for this turn.
-        // Filters take precedence because they reflect the exact payload delivered to the model.
-        const resolveSessionItemsForPersistence = () => {
-            if (sessionInputFilteredSnapshot !== undefined) {
-                return sessionInputFilteredSnapshot;
-            }
-            if (hasCallModelInputFilter) {
-                return undefined;
-            }
-            return sessionInputOriginalSnapshot;
-        };
+        const sessionPersistence = createSessionPersistenceTracker({
+            session,
+            hasCallModelInputFilter,
+            persistInput: saveStreamInputToSession,
+            resumingFromState,
+        });
         let preparedInput = input;
         if (!(preparedInput instanceof RunState)) {
-            if (session && Array.isArray(preparedInput) && !sessionInputCallback) {
-                throw new UserError('RunConfig.sessionInputCallback must be provided when using session history with list inputs.');
-            }
             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.
@@ -231,48 +127,21 @@ export class Runner extends RunHooks {
             else {
                 preparedInput = prepared.preparedInput;
             }
-            if (session) {
-                const items = prepared.sessionItems ?? [];
-                // Clone the items that will be persisted so later mutations (filters, hooks) cannot desync history.
-                sessionInputOriginalSnapshot = items.map((item) => structuredClone(item));
-                // Reset pending counts so each prepared item reserves exactly one write slot until filters resolve matches.
-                sessionInputPendingWriteCounts = new Map();
-                for (const item of items) {
-                    const key = getAgentInputItemKey(item);
-                    sessionInputPendingWriteCounts.set(key, (sessionInputPendingWriteCounts.get(key) ?? 0) + 1);
-                }
-            }
+            sessionPersistence?.setPreparedItems(prepared.sessionItems);
         }
         // Streaming runs persist the input asynchronously, so track a one-shot helper
         // that can be awaited from multiple branches without double-writing.
-        let ensureStreamInputPersisted;
-        // Sessions remain usable alongside server-managed conversations (e.g., OpenAIConversationsSession)
-        // so callers can reuse callbacks, resume-from-state logic, and other helpers without duplicating
-        // remote history, so persistence is gated on serverManagesConversation.
-        if (session && !serverManagesConversation) {
-            let persisted = false;
-            ensureStreamInputPersisted = async () => {
-                if (persisted) {
-                    return;
-                }
-                const itemsToPersist = resolveSessionItemsForPersistence();
-                if (!itemsToPersist || itemsToPersist.length === 0) {
-                    return;
-                }
-                persisted = true;
-                await saveStreamInputToSession(session, itemsToPersist);
-            };
-        }
+        const ensureStreamInputPersisted = sessionPersistence?.buildPersistInputOnce(serverManagesConversation);
         const executeRun = async () => {
             if (effectiveOptions.stream) {
-                const streamResult = await this.#runIndividualStream(agent, preparedInput, effectiveOptions, ensureStreamInputPersisted, recordSessionItemsForPersistence);
+                const streamResult = await this.#runIndividualStream(agent, preparedInput, effectiveOptions, ensureStreamInputPersisted, sessionPersistence?.recordTurnItems, preserveTurnPersistenceOnResume);
                 return streamResult;
             }
-            const runResult = await this.#runIndividualNonStream(agent, preparedInput, effectiveOptions, recordSessionItemsForPersistence);
+            const runResult = await this.#runIndividualNonStream(agent, preparedInput, effectiveOptions, sessionPersistence?.recordTurnItems, preserveTurnPersistenceOnResume);
             // See note above: allow sessions to run for callbacks/state but skip writes when the server
             // is the source of truth for transcript history.
-            if (session && !serverManagesConversation) {
-                await saveToSession(session, resolveSessionItemsForPersistence(), runResult);
+            if (sessionPersistence && !serverManagesConversation) {
+                await saveToSession(session, sessionPersistence.getItemsForPersistence(), runResult);
             }
             return runResult;
         };
@@ -289,6 +158,8 @@ export class Runner extends RunHooks {
             name: this.config.workflowName,
             groupId: this.config.groupId,
             metadata: this.config.traceMetadata,
+            // Per-run tracing config overrides exporter defaults such as environment API key.
+            tracingApiKey: tracingConfig?.apiKey,
         });
     }
     // --------------------------------------------------------------
@@ -296,23 +167,6 @@ export class Runner extends RunHooks {
     // --------------------------------------------------------------
     inputGuardrailDefs;
     outputGuardrailDefs;
-    #getInputGuardrailDefinitions(state) {
-        return this.inputGuardrailDefs.concat(state._currentAgent.inputGuardrails.map(defineInputGuardrail));
-    }
-    #splitInputGuardrails(state) {
-        const guardrails = this.#getInputGuardrailDefinitions(state);
-        const blocking = [];
-        const parallel = [];
-        for (const guardrail of guardrails) {
-            if (guardrail.runInParallel === false) {
-                blocking.push(guardrail);
-            }
-            else {
-                parallel.push(guardrail);
-            }
-        }
-        return { blocking, parallel };
-    }
     /**
      * @internal
      * Resolves the effective model once so both run loops obey the same precedence rules.
@@ -322,11 +176,12 @@ export class Runner extends RunHooks {
             agent.model !== Agent.DEFAULT_MODEL_PLACEHOLDER) ||
             (this.config.model !== undefined &&
                 this.config.model !== Agent.DEFAULT_MODEL_PLACEHOLDER);
-        let resolvedModel = selectModel(agent.model, this.config.model);
-        if (typeof resolvedModel === 'string') {
-            resolvedModel = await this.config.modelProvider.getModel(resolvedModel);
-        }
-        return { model: resolvedModel, explictlyModelSet };
+        const selectedModel = selectModel(agent.model, this.config.model);
+        const resolvedModelName = typeof selectedModel === 'string' ? selectedModel : undefined;
+        const resolvedModel = typeof selectedModel === 'string'
+            ? await this.config.modelProvider.getModel(selectedModel)
+            : selectedModel;
+        return { model: resolvedModel, explictlyModelSet, resolvedModelName };
     }
     /**
      * @internal
@@ -334,7 +189,7 @@ export class Runner extends RunHooks {
     async #runIndividualNonStream(startingAgent, input, options, 
     // 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) {
+    sessionInputUpdate, preserveTurnPersistenceOnResume) {
         return withNewSpanContext(async () => {
             // if we have a saved state we use that one, otherwise we create a new one
             const isResumedState = input instanceof RunState;
@@ -343,10 +198,17 @@ export class Runner extends RunHooks {
                 : new RunState(options.context instanceof RunContext
                     ? options.context
                     : new RunContext(options.context), input, startingAgent, options.maxTurns ?? DEFAULT_MAX_TURNS);
-            const serverConversationTracker = options.conversationId || options.previousResponseId
+            const resolvedConversationId = options.conversationId ??
+                (isResumedState ? state._conversationId : undefined);
+            const resolvedPreviousResponseId = options.previousResponseId ??
+                (isResumedState ? state._previousResponseId : undefined);
+            if (!isResumedState) {
+                state.setConversationContext(resolvedConversationId, resolvedPreviousResponseId);
+            }
+            const serverConversationTracker = resolvedConversationId || resolvedPreviousResponseId
                 ? new ServerConversationTracker({
-                    conversationId: options.conversationId,
-                    previousResponseId: options.previousResponseId,
+                    conversationId: resolvedConversationId,
+                    previousResponseId: resolvedPreviousResponseId,
                 })
                 : undefined;
             if (serverConversationTracker && isResumedState) {
@@ -355,7 +217,9 @@ export class Runner extends RunHooks {
                     generatedItems: state._generatedItems,
                     modelResponses: state._modelResponses,
                 });
+                state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
             }
+            // Tracks when we resume an approval interruption so the next run-again step stays in the same turn.
             let continuingInterruptedTurn = false;
             try {
                 while (true) {
@@ -368,66 +232,60 @@ export class Runner extends RunHooks {
                         if (!state._lastTurnResponse || !state._lastProcessedResponse) {
                             throw new UserError('No model response found in previous state', state);
                         }
-                        const turnResult = await resolveInterruptedTurn(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
-                        state._toolUseTracker.addToolUse(state._currentAgent, state._lastProcessedResponse.toolsUsed);
-                        state._originalInput = turnResult.originalInput;
-                        state._generatedItems = turnResult.generatedItems;
+                        const interruptedOutcome = await resumeInterruptedTurn({
+                            state,
+                            runner: this,
+                        });
                         // 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)
-                        if (turnResult.nextStep.type === 'next_step_interruption') {
+                        const { shouldReturn, shouldContinue } = handleInterruptedOutcome({
+                            state,
+                            outcome: interruptedOutcome,
+                            setContinuingInterruptedTurn: (value) => {
+                                continuingInterruptedTurn = value;
+                            },
+                        });
+                        if (shouldReturn) {
                             // we are still in an interruption, so we need to avoid an infinite loop
-                            state._currentStep = turnResult.nextStep;
                             return new RunResult(state);
                         }
-                        // If continuing from interruption with next_step_run_again, set step to undefined
-                        // so the loop treats it as a new step without incrementing the turn.
-                        // The counter has already been adjusted by resolveInterruptedTurn's rewind logic.
-                        if (turnResult.nextStep.type === 'next_step_run_again') {
-                            continuingInterruptedTurn = true;
-                            state._currentStep = undefined;
+                        if (shouldContinue) {
                             continue;
                         }
-                        continuingInterruptedTurn = false;
-                        state._currentStep = turnResult.nextStep;
                     }
                     if (state._currentStep.type === 'next_step_run_again') {
-                        const artifacts = await prepareAgentArtifacts(state);
-                        const isResumingFromInterruption = isResumedState && continuingInterruptedTurn;
+                        const wasContinuingInterruptedTurn = continuingInterruptedTurn;
                         continuingInterruptedTurn = false;
-                        // Do not advance the turn when resuming from an interruption; the next model call is
-                        // still part of the same logical turn.
-                        if (!isResumingFromInterruption) {
-                            state._currentTurn++;
-                            state._currentTurnPersistedItemCount = 0;
-                        }
-                        if (state._currentTurn > state._maxTurns) {
-                            state._currentAgentSpan?.setError({
-                                message: 'Max turns exceeded',
-                                data: { max_turns: state._maxTurns },
-                            });
-                            throw new MaxTurnsExceededError(`Max turns (${state._maxTurns}) exceeded`, state);
-                        }
-                        logger.debug(`Running agent ${state._currentAgent.name} (turn ${state._currentTurn})`);
-                        let parallelGuardrailPromise;
-                        // Only run input guardrails on the first turn of a new run.
-                        if (state._currentTurn === 1 && !isResumingFromInterruption) {
-                            const guardrails = this.#splitInputGuardrails(state);
-                            if (guardrails.blocking.length > 0) {
-                                await this.#runInputGuardrails(state, guardrails.blocking);
-                            }
-                            if (guardrails.parallel.length > 0) {
-                                parallelGuardrailPromise = this.#runInputGuardrails(state, guardrails.parallel);
-                                parallelGuardrailPromise.catch(() => { });
-                            }
-                        }
-                        const turnInput = serverConversationTracker
-                            ? serverConversationTracker.prepareInput(state._originalInput, state._generatedItems)
-                            : getTurnInput(state._originalInput, state._generatedItems);
-                        if (state._noActiveAgentRun) {
-                            state._currentAgent.emit('agent_start', state._context, state._currentAgent, turnInput);
-                            this.emit('agent_start', state._context, state._currentAgent, turnInput);
+                        const guardrailTracker = createGuardrailTracker();
+                        const previousTurn = state._currentTurn;
+                        const previousPersistedCount = state._currentTurnPersistedItemCount;
+                        const previousGeneratedCount = state._generatedItems.length;
+                        const { artifacts, turnInput, parallelGuardrailPromise } = await prepareTurn({
+                            state,
+                            input: state._originalInput,
+                            generatedItems: state._generatedItems,
+                            isResumedState,
+                            preserveTurnPersistenceOnResume,
+                            continuingInterruptedTurn: wasContinuingInterruptedTurn,
+                            serverConversationTracker,
+                            inputGuardrailDefs: this.inputGuardrailDefs,
+                            guardrailHandlers: {
+                                onParallelStart: guardrailTracker.markPending,
+                                onParallelError: guardrailTracker.setError,
+                            },
+                            emitAgentStart: (context, agent, inputItems) => {
+                                this.emit('agent_start', context, agent, inputItems);
+                            },
+                        });
+                        if (preserveTurnPersistenceOnResume &&
+                            state._currentTurn > previousTurn &&
+                            previousPersistedCount <= previousGeneratedCount) {
+                            // Preserve persisted offsets from a resumed run to avoid re-saving prior items.
+                            state._currentTurnPersistedItemCount = previousPersistedCount;
                         }
+                        guardrailTracker.setPromise(parallelGuardrailPromise);
                         const preparedCall = await this.#prepareModelCall(state, options, artifacts, turnInput, serverConversationTracker, sessionInputUpdate);
+                        guardrailTracker.throwIfError();
                         state._lastTurnResponse = await preparedCall.model.getResponse({
                             systemInstructions: preparedCall.modelInput.instructions,
                             prompt: preparedCall.prompt,
@@ -446,56 +304,71 @@ export class Runner extends RunHooks {
                             tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
                             signal: options.signal,
                         });
+                        if (serverConversationTracker) {
+                            serverConversationTracker.markInputAsSent(preparedCall.sourceItems, {
+                                filterApplied: preparedCall.filterApplied,
+                                allTurnItems: preparedCall.turnInput,
+                            });
+                        }
                         state._modelResponses.push(state._lastTurnResponse);
                         state._context.usage.add(state._lastTurnResponse.usage);
                         state._noActiveAgentRun = false;
                         // After each turn record the items echoed by the server so future requests only
                         // include the incremental inputs that have not yet been acknowledged.
                         serverConversationTracker?.trackServerItems(state._lastTurnResponse);
+                        if (serverConversationTracker) {
+                            state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
+                        }
                         const processedResponse = processModelResponse(state._lastTurnResponse, state._currentAgent, preparedCall.tools, preparedCall.handoffs);
                         state._lastProcessedResponse = processedResponse;
                         const turnResult = await resolveTurnAfterModelResponse(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
-                        state._toolUseTracker.addToolUse(state._currentAgent, state._lastProcessedResponse.toolsUsed);
-                        state._originalInput = turnResult.originalInput;
-                        state._generatedItems = turnResult.generatedItems;
-                        if (turnResult.nextStep.type === 'next_step_run_again') {
-                            state._currentTurnPersistedItemCount = 0;
-                        }
-                        state._currentStep = turnResult.nextStep;
-                        if (parallelGuardrailPromise) {
-                            await parallelGuardrailPromise;
-                        }
-                    }
-                    if (state._currentStep &&
-                        state._currentStep.type === 'next_step_final_output') {
-                        await this.#runOutputGuardrails(state, state._currentStep.output);
-                        this.emit('agent_end', state._context, state._currentAgent, state._currentStep.output);
-                        state._currentAgent.emit('agent_end', state._context, state._currentStep.output);
-                        return new RunResult(state);
-                    }
-                    else if (state._currentStep &&
-                        state._currentStep.type === 'next_step_handoff') {
-                        state._currentAgent = state._currentStep.newAgent;
-                        if (state._currentAgentSpan) {
-                            state._currentAgentSpan.end();
-                            resetCurrentSpan();
-                            state._currentAgentSpan = undefined;
-                        }
-                        state._noActiveAgentRun = true;
-                        // we've processed the handoff, so we need to run the loop again
-                        state._currentStep = { type: 'next_step_run_again' };
-                    }
-                    else if (state._currentStep &&
-                        state._currentStep.type === 'next_step_interruption') {
-                        // interrupted. Don't run any guardrails
-                        return new RunResult(state);
+                        applyTurnResult({
+                            state,
+                            turnResult,
+                            agent: state._currentAgent,
+                            toolsUsed: state._lastProcessedResponse?.toolsUsed ?? [],
+                            resetTurnPersistence: !isResumedState,
+                        });
+                        await guardrailTracker.awaitCompletion();
                     }
-                    else {
+                    const currentStep = state._currentStep;
+                    if (!currentStep) {
                         logger.debug('Running next loop');
+                        continue;
+                    }
+                    switch (currentStep.type) {
+                        case 'next_step_final_output':
+                            await runOutputGuardrails(state, this.outputGuardrailDefs, currentStep.output);
+                            state._currentTurnInProgress = false;
+                            this.emit('agent_end', state._context, state._currentAgent, currentStep.output);
+                            state._currentAgent.emit('agent_end', state._context, currentStep.output);
+                            return new RunResult(state);
+                        case 'next_step_handoff':
+                            state.setCurrentAgent(currentStep.newAgent);
+                            if (state._currentAgentSpan) {
+                                state._currentAgentSpan.end();
+                                resetCurrentSpan();
+                                state.setCurrentAgentSpan(undefined);
+                            }
+                            state._noActiveAgentRun = true;
+                            state._currentTurnInProgress = false;
+                            // We've processed the handoff, so we need to run the loop again.
+                            state._currentStep = { type: 'next_step_run_again' };
+                            break;
+                        case 'next_step_interruption':
+                            // Interrupted. Don't run any guardrails.
+                            return new RunResult(state);
+                        case 'next_step_run_again':
+                            state._currentTurnInProgress = false;
+                            logger.debug('Running next loop');
+                            break;
+                        default:
+                            logger.debug('Running next loop');
                     }
                 }
             }
             catch (err) {
+                state._currentTurnInProgress = false;
                 if (state._currentAgentSpan) {
                     state._currentAgentSpan.setError({
                         message: 'Error in agent run',
@@ -526,16 +399,22 @@ export class Runner extends RunHooks {
     /**
      * @internal
      */
-    async #runStreamLoop(result, options, isResumedState, ensureStreamInputPersisted, sessionInputUpdate) {
-        const serverManagesConversation = Boolean(options.conversationId) || Boolean(options.previousResponseId);
+    async #runStreamLoop(result, options, isResumedState, ensureStreamInputPersisted, sessionInputUpdate, preserveTurnPersistenceOnResume) {
+        const resolvedConversationId = options.conversationId ?? result.state._conversationId;
+        const resolvedPreviousResponseId = options.previousResponseId ?? result.state._previousResponseId;
+        const serverManagesConversation = Boolean(resolvedConversationId) || Boolean(resolvedPreviousResponseId);
         const serverConversationTracker = serverManagesConversation
             ? new ServerConversationTracker({
-                conversationId: options.conversationId,
-                previousResponseId: options.previousResponseId,
+                conversationId: resolvedConversationId,
+                previousResponseId: resolvedPreviousResponseId,
             })
             : undefined;
-        let handedInputToModel = false;
+        if (serverConversationTracker) {
+            result.state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
+        }
+        let sentInputToModel = false;
         let streamInputPersisted = false;
+        let guardrailTracker = createGuardrailTracker();
         const persistStreamInputIfNeeded = async () => {
             if (streamInputPersisted || !ensureStreamInputPersisted) {
                 return;
@@ -544,13 +423,27 @@ export class Runner extends RunHooks {
             await ensureStreamInputPersisted();
             streamInputPersisted = true;
         };
+        let parallelGuardrailPromise;
+        const awaitGuardrailsAndPersistInput = async () => {
+            await guardrailTracker.awaitCompletion();
+            if (guardrailTracker.failed) {
+                throw guardrailTracker.error;
+            }
+            if (sentInputToModel &&
+                !streamInputPersisted &&
+                !guardrailTracker.failed) {
+                await persistStreamInputIfNeeded();
+            }
+        };
         if (serverConversationTracker && isResumedState) {
             serverConversationTracker.primeFromState({
                 originalInput: result.state._originalInput,
                 generatedItems: result.state._generatedItems,
                 modelResponses: result.state._modelResponses,
             });
+            result.state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
         }
+        // Tracks when we resume an approval interruption so the next run-again step stays in the same turn.
         let continuingInterruptedTurn = false;
         try {
             while (true) {
@@ -564,119 +457,149 @@ export class Runner extends RunHooks {
                         !result.state._lastProcessedResponse) {
                         throw new UserError('No model response found in previous state', result.state);
                     }
-                    const turnResult = await resolveInterruptedTurn(result.state._currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
-                    addStepToRunResult(result, turnResult);
-                    result.state._toolUseTracker.addToolUse(result.state._currentAgent, result.state._lastProcessedResponse.toolsUsed);
-                    result.state._originalInput = turnResult.originalInput;
-                    result.state._generatedItems = turnResult.generatedItems;
+                    const interruptedOutcome = await resumeInterruptedTurn({
+                        state: result.state,
+                        runner: this,
+                        onStepItems: (turnResult) => {
+                            addStepToRunResult(result, turnResult);
+                        },
+                    });
                     // 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)
-                    if (turnResult.nextStep.type === 'next_step_interruption') {
+                    const { shouldReturn, shouldContinue } = handleInterruptedOutcome({
+                        state: result.state,
+                        outcome: interruptedOutcome,
+                        setContinuingInterruptedTurn: (value) => {
+                            continuingInterruptedTurn = value;
+                        },
+                    });
+                    if (shouldReturn) {
                         // we are still in an interruption, so we need to avoid an infinite loop
-                        result.state._currentStep = turnResult.nextStep;
                         return;
                     }
-                    // If continuing from interruption with next_step_run_again, set step to undefined
-                    // so the loop treats it as a new step without incrementing the turn.
-                    // The counter has already been adjusted by resolveInterruptedTurn's rewind logic.
-                    if (turnResult.nextStep.type === 'next_step_run_again') {
-                        continuingInterruptedTurn = true;
-                        result.state._currentStep = undefined;
+                    if (shouldContinue) {
                         continue;
                     }
-                    continuingInterruptedTurn = false;
-                    result.state._currentStep = turnResult.nextStep;
                 }
                 if (result.state._currentStep.type === 'next_step_run_again') {
-                    const artifacts = await prepareAgentArtifacts(result.state);
-                    const isResumingFromInterruption = isResumedState && continuingInterruptedTurn;
+                    parallelGuardrailPromise = undefined;
+                    guardrailTracker = createGuardrailTracker();
+                    const wasContinuingInterruptedTurn = continuingInterruptedTurn;
                     continuingInterruptedTurn = false;
-                    // Do not advance the turn when resuming from an interruption; the next model call is
-                    // still part of the same logical turn.
-                    if (!isResumingFromInterruption) {
-                        result.state._currentTurn++;
-                        result.state._currentTurnPersistedItemCount = 0;
-                    }
-                    if (result.state._currentTurn > result.state._maxTurns) {
-                        result.state._currentAgentSpan?.setError({
-                            message: 'Max turns exceeded',
-                            data: { max_turns: result.state._maxTurns },
+                    const previousTurn = result.state._currentTurn;
+                    const previousPersistedCount = result.state._currentTurnPersistedItemCount;
+                    const previousGeneratedCount = result.state._generatedItems.length;
+                    const preparedTurn = await prepareTurn({
+                        state: result.state,
+                        input: result.input,
+                        generatedItems: result.newItems,
+                        isResumedState,
+                        preserveTurnPersistenceOnResume,
+                        continuingInterruptedTurn: wasContinuingInterruptedTurn,
+                        serverConversationTracker,
+                        inputGuardrailDefs: this.inputGuardrailDefs,
+                        guardrailHandlers: {
+                            onParallelStart: () => {
+                                guardrailTracker.markPending();
+                            },
+                            onParallelError: (err) => {
+                                guardrailTracker.setError(err);
+                            },
+                        },
+                        emitAgentStart: (context, agent, inputItems) => {
+                            this.emit('agent_start', context, agent, inputItems);
+                        },
+                    });
+                    if (preserveTurnPersistenceOnResume &&
+                        result.state._currentTurn > previousTurn &&
+                        previousPersistedCount <= previousGeneratedCount) {
+                        // Preserve persisted offsets from a resumed run to avoid re-saving prior items.
+                        result.state._currentTurnPersistedItemCount =
+                            previousPersistedCount;
+                    }
+                    const { artifacts, turnInput } = preparedTurn;
+                    parallelGuardrailPromise = preparedTurn.parallelGuardrailPromise;
+                    guardrailTracker.setPromise(parallelGuardrailPromise);
+                    // If guardrails are still running, defer input persistence until they finish.
+                    const delayStreamInputPersistence = guardrailTracker.pending;
+                    const preparedCall = await this.#prepareModelCall(result.state, options, artifacts, turnInput, serverConversationTracker, sessionInputUpdate);
+                    guardrailTracker.throwIfError();
+                    let finalResponse = undefined;
+                    let inputMarked = false;
+                    const markInputOnce = () => {
+                        if (inputMarked || !serverConversationTracker) {
+                            return;
+                        }
+                        // We only mark inputs as sent after receiving the first stream event,
+                        // which is the earliest reliable confirmation that the server accepted
+                        // the request. If the stream fails before any events, leave inputs
+                        // unmarked so a retry can resend safely.
+                        // Record the exact input that was sent so the server tracker can advance safely.
+                        serverConversationTracker.markInputAsSent(preparedCall.sourceItems, {
+                            filterApplied: preparedCall.filterApplied,
+                            allTurnItems: preparedCall.turnInput,
                         });
-                        throw new MaxTurnsExceededError(`Max turns (${result.state._maxTurns}) exceeded`, result.state);
+                        inputMarked = true;
+                    };
+                    sentInputToModel = true;
+                    if (!delayStreamInputPersistence) {
+                        await persistStreamInputIfNeeded();
                     }
-                    logger.debug(`Running agent ${currentAgent.name} (turn ${result.state._currentTurn})`);
-                    let guardrailError;
-                    let parallelGuardrailPromise;
-                    // Only run input guardrails on the first turn of a new run.
-                    if (result.state._currentTurn === 1 && !isResumingFromInterruption) {
-                        const guardrails = this.#splitInputGuardrails(result.state);
-                        if (guardrails.blocking.length > 0) {
-                            await this.#runInputGuardrails(result.state, guardrails.blocking);
-                        }
-                        if (guardrails.parallel.length > 0) {
-                            const promise = this.#runInputGuardrails(result.state, guardrails.parallel);
-                            parallelGuardrailPromise = promise.catch((err) => {
-                                guardrailError = err;
-                                return [];
-                            });
+                    try {
+                        for await (const event of preparedCall.model.getStreamedResponse({
+                            systemInstructions: preparedCall.modelInput.instructions,
+                            prompt: preparedCall.prompt,
+                            // Streaming requests should also honor explicitly chosen models.
+                            ...(preparedCall.explictlyModelSet
+                                ? { overridePromptModel: true }
+                                : {}),
+                            input: preparedCall.modelInput.input,
+                            previousResponseId: preparedCall.previousResponseId,
+                            conversationId: preparedCall.conversationId,
+                            modelSettings: preparedCall.modelSettings,
+                            tools: preparedCall.serializedTools,
+                            toolsExplicitlyProvided: preparedCall.toolsExplicitlyProvided,
+                            handoffs: preparedCall.serializedHandoffs,
+                            outputType: convertAgentOutputTypeToSerializable(currentAgent.outputType),
+                            tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
+                            signal: options.signal,
+                        })) {
+                            guardrailTracker.throwIfError();
+                            markInputOnce();
+                            if (event.type === 'response_done') {
+                                const parsed = StreamEventResponseCompleted.parse(event);
+                                finalResponse = {
+                                    usage: new Usage(parsed.response.usage),
+                                    output: parsed.response.output,
+                                    responseId: parsed.response.id,
+                                };
+                                result.state._context.usage.add(finalResponse.usage);
+                            }
+                            if (result.cancelled) {
+                                // When the user's code exits a loop to consume the stream, we need to break
+                                // this loop to prevent internal false errors and unnecessary processing
+                                await awaitGuardrailsAndPersistInput();
+                                return;
+                            }
+                            result._addItem(new RunRawModelStreamEvent(event));
                         }
                     }
-                    const turnInput = serverConversationTracker
-                        ? serverConversationTracker.prepareInput(result.input, result.newItems)
-                        : getTurnInput(result.input, result.newItems);
-                    if (result.state._noActiveAgentRun) {
-                        currentAgent.emit('agent_start', result.state._context, currentAgent, turnInput);
-                        this.emit('agent_start', result.state._context, currentAgent, turnInput);
-                    }
-                    let finalResponse = undefined;
-                    const preparedCall = await this.#prepareModelCall(result.state, options, artifacts, turnInput, serverConversationTracker, sessionInputUpdate);
-                    if (guardrailError) {
-                        throw guardrailError;
-                    }
-                    handedInputToModel = true;
-                    await persistStreamInputIfNeeded();
-                    for await (const event of preparedCall.model.getStreamedResponse({
-                        systemInstructions: preparedCall.modelInput.instructions,
-                        prompt: preparedCall.prompt,
-                        // Streaming requests should also honor explicitly chosen models.
-                        ...(preparedCall.explictlyModelSet
-                            ? { overridePromptModel: true }
-                            : {}),
-                        input: preparedCall.modelInput.input,
-                        previousResponseId: preparedCall.previousResponseId,
-                        conversationId: preparedCall.conversationId,
-                        modelSettings: preparedCall.modelSettings,
-                        tools: preparedCall.serializedTools,
-                        toolsExplicitlyProvided: preparedCall.toolsExplicitlyProvided,
-                        handoffs: preparedCall.serializedHandoffs,
-                        outputType: convertAgentOutputTypeToSerializable(currentAgent.outputType),
-                        tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
-                        signal: options.signal,
-                    })) {
-                        if (guardrailError) {
-                            throw guardrailError;
-                        }
-                        if (event.type === 'response_done') {
-                            const parsed = StreamEventResponseCompleted.parse(event);
-                            finalResponse = {
-                                usage: new Usage(parsed.response.usage),
-                                output: parsed.response.output,
-                                responseId: parsed.response.id,
-                            };
-                            result.state._context.usage.add(finalResponse.usage);
-                        }
-                        if (result.cancelled) {
-                            // When the user's code exits a loop to consume the stream, we need to break
-                            // this loop to prevent internal false errors and unnecessary processing
+                    catch (error) {
+                        if (isAbortError(error)) {
+                            if (sentInputToModel) {
+                                markInputOnce();
+                            }
+                            await awaitGuardrailsAndPersistInput();
                             return;
                         }
-                        result._addItem(new RunRawModelStreamEvent(event));
+                        throw error;
                     }
-                    if (parallelGuardrailPromise) {
-                        await parallelGuardrailPromise;
-                        if (guardrailError) {
-                            throw guardrailError;
-                        }
+                    if (finalResponse) {
+                        markInputOnce();
+                    }
+                    await awaitGuardrailsAndPersistInput();
+                    if (result.cancelled) {
+                        return;
                     }
                     result.state._noActiveAgentRun = false;
                     if (!finalResponse) {
@@ -685,6 +608,9 @@ export class Runner extends RunHooks {
                     result.state._lastTurnResponse = finalResponse;
                     // Keep the tracker in sync with the streamed response so reconnections remain accurate.
                     serverConversationTracker?.trackServerItems(finalResponse);
+                    if (serverConversationTracker) {
+                        result.state.setConversationContext(serverConversationTracker.conversationId, serverConversationTracker.previousResponseId);
+                    }
                     result.state._modelResponses.push(result.state._lastTurnResponse);
                     const processedResponse = processModelResponse(result.state._lastTurnResponse, currentAgent, preparedCall.tools, preparedCall.handoffs);
                     result.state._lastProcessedResponse = processedResponse;
@@ -695,58 +621,69 @@ export class Runner extends RunHooks {
                         streamStepItemsToRunResult(result, processedResponse.newItems);
                     }
                     const turnResult = await resolveTurnAfterModelResponse(currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
-                    addStepToRunResult(result, turnResult, {
-                        skipItems: preToolItems,
+                    applyTurnResult({
+                        state: result.state,
+                        turnResult,
+                        agent: currentAgent,
+                        toolsUsed: processedResponse.toolsUsed,
+                        resetTurnPersistence: !isResumedState,
+                        onStepItems: (step) => {
+                            addStepToRunResult(result, step, { skipItems: preToolItems });
+                        },
                     });
-                    result.state._toolUseTracker.addToolUse(currentAgent, processedResponse.toolsUsed);
-                    result.state._originalInput = turnResult.originalInput;
-                    result.state._generatedItems = turnResult.generatedItems;
-                    if (turnResult.nextStep.type === 'next_step_run_again') {
-                        result.state._currentTurnPersistedItemCount = 0;
-                    }
-                    result.state._currentStep = turnResult.nextStep;
                 }
-                if (result.state._currentStep.type === 'next_step_final_output') {
-                    await this.#runOutputGuardrails(result.state, result.state._currentStep.output);
-                    await persistStreamInputIfNeeded();
-                    // Guardrails must succeed before persisting session memory to avoid storing blocked outputs.
-                    if (!serverManagesConversation) {
-                        await saveStreamResultToSession(options.session, result);
-                    }
-                    this.emit('agent_end', result.state._context, currentAgent, result.state._currentStep.output);
-                    currentAgent.emit('agent_end', result.state._context, result.state._currentStep.output);
-                    return;
-                }
-                else if (result.state._currentStep.type === 'next_step_interruption') {
-                    // we are done for now. Don't run any output guardrails
-                    await persistStreamInputIfNeeded();
-                    if (!serverManagesConversation) {
-                        await saveStreamResultToSession(options.session, result);
-                    }
-                    return;
-                }
-                else if (result.state._currentStep.type === 'next_step_handoff') {
-                    result.state._currentAgent = result.state._currentStep
-                        ?.newAgent;
-                    if (result.state._currentAgentSpan) {
-                        result.state._currentAgentSpan.end();
-                        resetCurrentSpan();
-                    }
-                    result.state._currentAgentSpan = undefined;
-                    result._addItem(new RunAgentUpdatedStreamEvent(result.state._currentAgent));
-                    result.state._noActiveAgentRun = true;
-                    // we've processed the handoff, so we need to run the loop again
-                    result.state._currentStep = {
-                        type: 'next_step_run_again',
-                    };
-                }
-                else {
-                    logger.debug('Running next loop');
+                const currentStep = result.state._currentStep;
+                switch (currentStep.type) {
+                    case 'next_step_final_output':
+                        await runOutputGuardrails(result.state, this.outputGuardrailDefs, currentStep.output);
+                        result.state._currentTurnInProgress = false;
+                        await persistStreamInputIfNeeded();
+                        // Guardrails must succeed before persisting session memory to avoid storing blocked outputs.
+                        if (!serverManagesConversation) {
+                            await saveStreamResultToSession(options.session, result);
+                        }
+                        this.emit('agent_end', result.state._context, currentAgent, currentStep.output);
+                        currentAgent.emit('agent_end', result.state._context, currentStep.output);
+                        return;
+                    case 'next_step_interruption':
+                        // We are done for now. Don't run any output guardrails.
+                        await persistStreamInputIfNeeded();
+                        if (!serverManagesConversation) {
+                            await saveStreamResultToSession(options.session, result);
+                        }
+                        return;
+                    case 'next_step_handoff':
+                        result.state.setCurrentAgent(currentStep.newAgent);
+                        if (result.state._currentAgentSpan) {
+                            result.state._currentAgentSpan.end();
+                            resetCurrentSpan();
+                        }
+                        result.state.setCurrentAgentSpan(undefined);
+                        result._addItem(new RunAgentUpdatedStreamEvent(result.state._currentAgent));
+                        result.state._noActiveAgentRun = true;
+                        result.state._currentTurnInProgress = false;
+                        // We've processed the handoff, so we need to run the loop again.
+                        result.state._currentStep = {
+                            type: 'next_step_run_again',
+                        };
+                        break;
+                    case 'next_step_run_again':
+                        result.state._currentTurnInProgress = false;
+                        logger.debug('Running next loop');
+                        break;
+                    default:
+                        logger.debug('Running next loop');
                 }
             }
         }
         catch (error) {
-            if (handedInputToModel && !streamInputPersisted) {
+            result.state._currentTurnInProgress = false;
+            if (guardrailTracker.pending) {
+                await guardrailTracker.awaitCompletion({ suppressErrors: true });
+            }
+            if (sentInputToModel &&
+                !streamInputPersisted &&
+                !guardrailTracker.failed) {
                 await persistStreamInputIfNeeded();
             }
             if (result.state._currentAgentSpan) {
@@ -758,6 +695,14 @@ export class Runner extends RunHooks {
             throw error;
         }
         finally {
+            if (guardrailTracker.pending) {
+                await guardrailTracker.awaitCompletion({ suppressErrors: true });
+            }
+            if (sentInputToModel &&
+                !streamInputPersisted &&
+                !guardrailTracker.failed) {
+                await persistStreamInputIfNeeded();
+            }
             if (result.state._currentStep?.type !== 'next_step_interruption') {
                 try {
                     await disposeResolvedComputers({ runContext: result.state._context });
@@ -777,7 +722,7 @@ export class Runner extends RunHooks {
     /**
      * @internal
      */
-    async #runIndividualStream(agent, input, options, ensureStreamInputPersisted, sessionInputUpdate) {
+    async #runIndividualStream(agent, input, options, ensureStreamInputPersisted, sessionInputUpdate, preserveTurnPersistenceOnResume) {
         options = options ?? {};
         return withNewSpanContext(async () => {
             // Initialize or reuse existing state
@@ -787,15 +732,26 @@ export class Runner extends RunHooks {
                 : new RunState(options.context instanceof RunContext
                     ? options.context
                     : new RunContext(options.context), input, agent, options.maxTurns ?? DEFAULT_MAX_TURNS);
+            const resolvedConversationId = options.conversationId ??
+                (isResumedState ? state._conversationId : undefined);
+            const resolvedPreviousResponseId = options.previousResponseId ??
+                (isResumedState ? state._previousResponseId : undefined);
+            if (!isResumedState) {
+                state.setConversationContext(resolvedConversationId, resolvedPreviousResponseId);
+            }
             // Initialize the streamed result with existing state
             const result = new StreamedRunResult({
                 signal: options.signal,
                 state,
             });
+            const streamOptions = {
+                ...options,
+                signal: result._getAbortSignal(),
+            };
             // Setup defaults
-            result.maxTurns = options.maxTurns ?? state._maxTurns;
+            result.maxTurns = streamOptions.maxTurns ?? state._maxTurns;
             // Continue the stream loop without blocking
-            const streamLoopPromise = this.#runStreamLoop(result, options, isResumedState, ensureStreamInputPersisted, sessionInputUpdate).then(() => {
+            const streamLoopPromise = this.#runStreamLoop(result, streamOptions, isResumedState, ensureStreamInputPersisted, sessionInputUpdate, preserveTurnPersistenceOnResume).then(() => {
                 result._done();
             }, (err) => {
                 result._raiseError(err);
@@ -805,108 +761,22 @@ export class Runner extends RunHooks {
             return result;
         });
     }
-    async #runInputGuardrails(state, guardrailsOverride) {
-        const guardrails = guardrailsOverride ?? this.#getInputGuardrailDefinitions(state);
-        if (guardrails.length > 0) {
-            const guardrailArgs = {
-                agent: state._currentAgent,
-                input: state._originalInput,
-                context: state._context,
-            };
-            try {
-                const results = await Promise.all(guardrails.map(async (guardrail) => {
-                    return withGuardrailSpan(async (span) => {
-                        const result = await guardrail.run(guardrailArgs);
-                        span.spanData.triggered = result.output.tripwireTriggered;
-                        return result;
-                    }, { data: { name: guardrail.name } }, state._currentAgentSpan);
-                }));
-                state._inputGuardrailResults.push(...results);
-                for (const result of results) {
-                    if (result.output.tripwireTriggered) {
-                        if (state._currentAgentSpan) {
-                            state._currentAgentSpan.setError({
-                                message: 'Guardrail tripwire triggered',
-                                data: { guardrail: result.guardrail.name },
-                            });
-                        }
-                        throw new InputGuardrailTripwireTriggered(`Input guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
-                    }
-                }
-                return results;
-            }
-            catch (e) {
-                if (e instanceof InputGuardrailTripwireTriggered) {
-                    throw e;
-                }
-                // roll back the current turn to enable reruns
-                state._currentTurn--;
-                throw new GuardrailExecutionError(`Input guardrail failed to complete: ${e}`, e, state);
-            }
-        }
-        return [];
-    }
-    async #runOutputGuardrails(state, output) {
-        const guardrails = this.outputGuardrailDefs.concat(state._currentAgent.outputGuardrails.map(defineOutputGuardrail));
-        if (guardrails.length > 0) {
-            const agentOutput = state._currentAgent.processFinalOutput(output);
-            const runOutput = getTurnInput([], state._generatedItems);
-            const guardrailArgs = {
-                agent: state._currentAgent,
-                agentOutput,
-                context: state._context,
-                details: {
-                    modelResponse: state._lastTurnResponse,
-                    output: runOutput,
-                },
-            };
-            try {
-                const results = await Promise.all(guardrails.map(async (guardrail) => {
-                    return withGuardrailSpan(async (span) => {
-                        const result = await guardrail.run(guardrailArgs);
-                        span.spanData.triggered = result.output.tripwireTriggered;
-                        return result;
-                    }, { data: { name: guardrail.name } }, state._currentAgentSpan);
-                }));
-                for (const result of results) {
-                    if (result.output.tripwireTriggered) {
-                        if (state._currentAgentSpan) {
-                            state._currentAgentSpan.setError({
-                                message: 'Guardrail tripwire triggered',
-                                data: { guardrail: result.guardrail.name },
-                            });
-                        }
-                        throw new OutputGuardrailTripwireTriggered(`Output guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
-                    }
-                }
-            }
-            catch (e) {
-                if (e instanceof OutputGuardrailTripwireTriggered) {
-                    throw e;
-                }
-                throw new GuardrailExecutionError(`Output guardrail failed to complete: ${e}`, e, state);
-            }
-        }
-    }
     /**
      * @internal
      * Applies call-level filters and merges session updates so the model request mirrors exactly
      * what we persisted for history.
      */
     async #prepareModelCall(state, options, artifacts, turnInput, serverConversationTracker, sessionInputUpdate) {
-        const { model, explictlyModelSet } = await this.#resolveModelForAgent(state._currentAgent);
+        const { model, explictlyModelSet, resolvedModelName } = await this.#resolveModelForAgent(state._currentAgent);
         let modelSettings = {
             ...this.config.modelSettings,
             ...state._currentAgent.modelSettings,
         };
-        modelSettings = adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, state._currentAgent.modelSettings, model, modelSettings);
+        modelSettings = adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, state._currentAgent.modelSettings, model, modelSettings, resolvedModelName);
         modelSettings = maybeResetToolChoice(state._currentAgent, state._toolUseTracker, modelSettings);
         const systemInstructions = await state._currentAgent.getSystemPrompt(state._context);
         const prompt = await state._currentAgent.getPrompt(state._context);
         const { modelInput, sourceItems, persistedItems, filterApplied } = await applyCallModelInputFilter(state._currentAgent, options.callModelInputFilter, state._context, turnInput, systemInstructions);
-        // Inform the tracker which exact original objects made it to the provider so future turns
-        // only send the delta that has not yet been acknowledged by the server.
-        serverConversationTracker?.markInputAsSent(sourceItems);
         // Provide filtered clones whenever filters run so session history mirrors the model payload.
         // Returning an empty array is intentional: it tells the session layer to persist "nothing"
         // instead of falling back to the unfiltered originals when the filter redacts everything.
@@ -923,461 +793,18 @@ export class Runner extends RunHooks {
             prompt,
             previousResponseId,
             conversationId,
-        };
-    }
-}
-/**
- * Constructs the model input array for the current turn by combining the original turn input with
- * any new run items (excluding tool approval placeholders). This helps ensure that repeated calls
- * to the Responses API only send newly generated content.
- *
- * See: https://platform.openai.com/docs/guides/conversation-state?api-mode=responses.
- */
-export function getTurnInput(originalInput, generatedItems) {
-    const rawItems = generatedItems
-        .filter((item) => item.type !== 'tool_approval_item') // don't include approval items to avoid double function calls
-        .map((item) => item.rawItem);
-    return [...toAgentInputList(originalInput), ...rawItems];
-}
-// --------------------------------------------------------------
-//  Internal helpers
-// --------------------------------------------------------------
-const DEFAULT_MAX_TURNS = 10;
-let _defaultRunner = undefined;
-function getDefaultRunner() {
-    if (_defaultRunner) {
-        return _defaultRunner;
-    }
-    _defaultRunner = new Runner();
-    return _defaultRunner;
-}
-/**
- * Resolves the effective model for the next turn by giving precedence to the agent-specific
- * configuration when present, otherwise falling back to the runner-level default.
- */
-export function selectModel(agentModel, runConfigModel) {
-    // When initializing an agent without model name, the model property is set to an empty string. So,
-    // * agentModel === Agent.DEFAULT_MODEL_PLACEHOLDER & runConfigModel exists, runConfigModel will be used
-    // * agentModel is set, the agentModel will be used over runConfigModel
-    if ((typeof agentModel === 'string' &&
-        agentModel !== Agent.DEFAULT_MODEL_PLACEHOLDER) ||
-        agentModel // any truthy value
-    ) {
-        return agentModel;
-    }
-    return runConfigModel ?? agentModel ?? Agent.DEFAULT_MODEL_PLACEHOLDER;
-}
-/**
- * Normalizes tracing configuration into the format expected by model providers.
- * Returns `false` to disable tracing, `true` to include full payload data, or
- * `'enabled_without_data'` to omit sensitive content while still emitting spans.
- */
-export function getTracing(tracingDisabled, traceIncludeSensitiveData) {
-    if (tracingDisabled) {
-        return false;
-    }
-    if (traceIncludeSensitiveData) {
-        return true;
-    }
-    return 'enabled_without_data';
-}
-/**
- * @internal
- */
-async function applyCallModelInputFilter(agent, callModelInputFilter, context, inputItems, systemInstructions) {
-    const cloneInputItems = (items, map) => items.map((item) => {
-        const cloned = structuredClone(item);
-        if (map && cloned && typeof cloned === 'object') {
-            map.set(cloned, item);
-        }
-        return cloned;
-    });
-    // Record the relationship between the cloned array passed to filters and the original inputs.
-    const cloneMap = new WeakMap();
-    const originalPool = buildAgentInputPool(inputItems);
-    const fallbackOriginals = [];
-    // Track any original object inputs so filtered replacements can still mark them as delivered.
-    for (const item of inputItems) {
-        if (item && typeof item === 'object') {
-            fallbackOriginals.push(item);
-        }
-    }
-    const removeFromFallback = (candidate) => {
-        if (!candidate || typeof candidate !== 'object') {
-            return;
-        }
-        const index = fallbackOriginals.findIndex((original) => original === candidate);
-        if (index !== -1) {
-            fallbackOriginals.splice(index, 1);
-        }
-    };
-    const takeFallbackOriginal = () => {
-        const next = fallbackOriginals.shift();
-        if (next) {
-            removeAgentInputFromPool(originalPool, next);
-        }
-        return next;
-    };
-    // Always create a deep copy so downstream mutations inside filters cannot affect
-    // the cached turn state.
-    const clonedBaseInput = cloneInputItems(inputItems, cloneMap);
-    const base = {
-        input: clonedBaseInput,
-        instructions: systemInstructions,
-    };
-    if (!callModelInputFilter) {
-        return {
-            modelInput: base,
-            sourceItems: [...inputItems],
-            persistedItems: [],
-            filterApplied: false,
-        };
-    }
-    try {
-        const result = await callModelInputFilter({
-            modelData: base,
-            agent,
-            context: context.context,
-        });
-        if (!result || !Array.isArray(result.input)) {
-            throw new UserError('callModelInputFilter must return a ModelInputData object with an input array.');
-        }
-        // Preserve a pointer to the original object backing each filtered clone so downstream
-        // trackers can keep their bookkeeping consistent even after redaction.
-        const sourceItems = result.input.map((item) => {
-            if (!item || typeof item !== 'object') {
-                return undefined;
-            }
-            const original = cloneMap.get(item);
-            if (original) {
-                removeFromFallback(original);
-                removeAgentInputFromPool(originalPool, original);
-                return original;
-            }
-            const key = getAgentInputItemKey(item);
-            const matchedByContent = takeAgentInputFromPool(originalPool, key);
-            if (matchedByContent) {
-                removeFromFallback(matchedByContent);
-                return matchedByContent;
-            }
-            const fallback = takeFallbackOriginal();
-            if (fallback) {
-                return fallback;
-            }
-            return undefined;
-        });
-        const clonedFilteredInput = cloneInputItems(result.input);
-        return {
-            modelInput: {
-                input: clonedFilteredInput,
-                instructions: typeof result.instructions === 'undefined'
-                    ? systemInstructions
-                    : result.instructions,
-            },
             sourceItems,
-            persistedItems: clonedFilteredInput.map((item) => structuredClone(item)),
-            filterApplied: true,
+            filterApplied,
+            turnInput,
         };
     }
-    catch (error) {
-        addErrorToCurrentSpan({
-            message: 'Error in callModelInputFilter',
-            data: { error: String(error) },
-        });
-        throw error;
-    }
-}
-// Tracks which items have already been sent to or received from the Responses API when the caller
-// supplies `conversationId`/`previousResponseId`. This ensures we only send the delta each turn.
-class ServerConversationTracker {
-    // Conversation ID:
-    // - https://platform.openai.com/docs/guides/conversation-state?api-mode=responses#using-the-conversations-api
-    // - https://platform.openai.com/docs/api-reference/conversations/create
-    conversationId;
-    // Previous Response ID:
-    // https://platform.openai.com/docs/guides/conversation-state?api-mode=responses#passing-context-from-the-previous-response
-    previousResponseId;
-    // Using this flag because WeakSet does not provide a way to check its size
-    sentInitialInput = false;
-    // The items already sent to the model; using WeakSet for memory efficiency
-    sentItems = new WeakSet();
-    // The items received from the server; using WeakSet for memory efficiency
-    serverItems = new WeakSet();
-    // Track initial input items that have not yet been sent so they can be retried on later turns.
-    remainingInitialInput = null;
-    constructor({ conversationId, previousResponseId, }) {
-        this.conversationId = conversationId ?? undefined;
-        this.previousResponseId = previousResponseId ?? undefined;
-    }
-    /**
-     * Pre-populates tracker caches from an existing RunState when resuming server-managed runs.
-     */
-    primeFromState({ originalInput, generatedItems, modelResponses, }) {
-        if (this.sentInitialInput) {
-            return;
-        }
-        for (const item of toAgentInputList(originalInput)) {
-            if (item && typeof item === 'object') {
-                this.sentItems.add(item);
-            }
-        }
-        this.sentInitialInput = true;
-        this.remainingInitialInput = null;
-        const latestResponse = modelResponses[modelResponses.length - 1];
-        for (const response of modelResponses) {
-            for (const item of response.output) {
-                if (item && typeof item === 'object') {
-                    this.serverItems.add(item);
-                }
-            }
-        }
-        if (!this.conversationId && latestResponse?.responseId) {
-            this.previousResponseId = latestResponse.responseId;
-        }
-        for (const item of generatedItems) {
-            const rawItem = item.rawItem;
-            if (!rawItem || typeof rawItem !== 'object') {
-                continue;
-            }
-            if (this.serverItems.has(rawItem)) {
-                this.sentItems.add(rawItem);
-            }
-        }
-    }
-    /**
-     * Records the raw items returned by the server so future delta calculations skip them.
-     * Also captures the latest response identifier to chain follow-up calls when possible.
-     */
-    trackServerItems(modelResponse) {
-        if (!modelResponse) {
-            return;
-        }
-        for (const item of modelResponse.output) {
-            if (item && typeof item === 'object') {
-                this.serverItems.add(item);
-            }
-        }
-        if (!this.conversationId && modelResponse.responseId) {
-            this.previousResponseId = modelResponse.responseId;
-        }
-    }
-    /**
-     * Returns the minimum set of items that still need to be delivered to the server for the
-     * current turn. This includes the original turn inputs (until acknowledged) plus any
-     * newly generated items that have not yet been echoed back by the API.
-     */
-    prepareInput(originalInput, generatedItems) {
-        const inputItems = [];
-        if (!this.sentInitialInput) {
-            const initialItems = toAgentInputList(originalInput);
-            // Preserve the full initial payload so a filter can drop items without losing their originals.
-            inputItems.push(...initialItems);
-            this.remainingInitialInput = initialItems.filter((item) => Boolean(item) && typeof item === 'object');
-            this.sentInitialInput = true;
-        }
-        else if (this.remainingInitialInput &&
-            this.remainingInitialInput.length > 0) {
-            // Re-queue prior initial items until the tracker confirms they were delivered to the API.
-            inputItems.push(...this.remainingInitialInput);
-        }
-        for (const item of generatedItems) {
-            if (item.type === 'tool_approval_item') {
-                continue;
-            }
-            const rawItem = item.rawItem;
-            if (!rawItem || typeof rawItem !== 'object') {
-                continue;
-            }
-            if (this.sentItems.has(rawItem) || this.serverItems.has(rawItem)) {
-                continue;
-            }
-            inputItems.push(rawItem);
-        }
-        return inputItems;
-    }
-    /**
-     * Marks the provided originals as delivered so future turns do not resend them and any
-     * pending initial inputs can be dropped once the server acknowledges receipt.
-     */
-    markInputAsSent(items) {
-        if (!items.length) {
-            return;
-        }
-        const delivered = new Set();
-        for (const item of items) {
-            if (!item || typeof item !== 'object' || delivered.has(item)) {
-                continue;
-            }
-            // Some inputs may be repeated in the filtered list; only mark unique originals once.
-            delivered.add(item);
-            this.sentItems.add(item);
-        }
-        if (!this.remainingInitialInput ||
-            this.remainingInitialInput.length === 0) {
-            return;
-        }
-        this.remainingInitialInput = this.remainingInitialInput.filter((item) => !delivered.has(item));
-        if (this.remainingInitialInput.length === 0) {
-            this.remainingInitialInput = null;
-        }
-    }
-}
-/**
- * When the default model is a GPT-5 variant, agents may carry GPT-5-specific providerData
- * (e.g., reasoning effort, text verbosity). If a run resolves to a non-GPT-5 model and the
- * agent relied on the default model (i.e., no explicit model set), these GPT-5-only settings
- * are incompatible and should be stripped to avoid runtime errors.
- */
-function adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, agentModelSettings, runnerModel, modelSettings) {
-    if (
-    // gpt-5 is enabled for the default model for agents
-    isGpt5Default() &&
-        // explicitly set model for the agent
-        explictlyModelSet &&
-        // this runner uses a non-gpt-5 model
-        (typeof runnerModel !== 'string' ||
-            !gpt5ReasoningSettingsRequired(runnerModel)) &&
-        (agentModelSettings.providerData?.reasoning ||
-            agentModelSettings.providerData?.text?.verbosity ||
-            agentModelSettings.providerData?.reasoning_effort)) {
-        const copiedModelSettings = { ...modelSettings };
-        // the incompatible parameters should be removed to avoid runtime errors
-        delete copiedModelSettings.providerData?.reasoning;
-        delete copiedModelSettings.providerData?.text?.verbosity;
-        delete copiedModelSettings.providerData?.reasoning_effort;
-        if (copiedModelSettings.reasoning) {
-            delete copiedModelSettings.reasoning.effort;
-            delete copiedModelSettings.reasoning.summary;
-        }
-        if (copiedModelSettings.text) {
-            delete copiedModelSettings.text.verbosity;
-        }
-        return copiedModelSettings;
-    }
-    return modelSettings;
-}
-/**
- * @internal
- * Collects tools/handoffs early so we can annotate spans before model execution begins.
- */
-async function prepareAgentArtifacts(state) {
-    const handoffs = await state._currentAgent.getEnabledHandoffs(state._context);
-    const tools = await state._currentAgent.getAllTools(state._context);
-    const computerTools = tools.filter((tool) => tool.type === 'computer');
-    if (computerTools.length > 0) {
-        await Promise.all(computerTools.map(async (tool) => {
-            await resolveComputer({ tool, runContext: state._context });
-        }));
-    }
-    if (!state._currentAgentSpan) {
-        const handoffNames = handoffs.map((h) => h.agentName);
-        state._currentAgentSpan = createAgentSpan({
-            data: {
-                name: state._currentAgent.name,
-                handoffs: handoffNames,
-                tools: tools.map((t) => t.name),
-                output_type: state._currentAgent.outputSchemaName,
-            },
-        });
-        state._currentAgentSpan.start();
-        setCurrentSpan(state._currentAgentSpan);
-    }
-    else {
-        state._currentAgentSpan.spanData.tools = tools.map((t) => t.name);
-    }
-    return {
-        handoffs,
-        tools,
-        serializedHandoffs: handoffs.map((handoff) => serializeHandoff(handoff)),
-        serializedTools: tools.map((tool) => serializeTool(tool)),
-        toolsExplicitlyProvided: state._currentAgent.hasExplicitToolConfig(),
-    };
-}
-function getAgentInputItemKey(item) {
-    // Deep serialization keeps binary inputs comparable after filters clone them.
-    return JSON.stringify(item, agentInputSerializationReplacer);
-}
-function buildAgentInputPool(items) {
-    // Track every original object so filters can safely return cloned copies.
-    const pool = new Map();
-    for (const item of items) {
-        const key = getAgentInputItemKey(item);
-        const existing = pool.get(key);
-        if (existing) {
-            existing.push(item);
-        }
-        else {
-            pool.set(key, [item]);
-        }
-    }
-    return pool;
-}
-function takeAgentInputFromPool(pool, key) {
-    // Prefer reusing the earliest untouched original to keep ordering stable.
-    const candidates = pool.get(key);
-    if (!candidates || candidates.length === 0) {
-        return undefined;
-    }
-    const [first] = candidates;
-    candidates.shift();
-    if (candidates.length === 0) {
-        pool.delete(key);
-    }
-    return first;
-}
-function removeAgentInputFromPool(pool, item) {
-    // Remove exactly the matched instance so duplicate payloads remain available.
-    const key = getAgentInputItemKey(item);
-    const candidates = pool.get(key);
-    if (!candidates || candidates.length === 0) {
-        return;
-    }
-    const index = candidates.findIndex((candidate) => candidate === item);
-    if (index === -1) {
-        return;
-    }
-    candidates.splice(index, 1);
-    if (candidates.length === 0) {
-        pool.delete(key);
-    }
-}
-function agentInputSerializationReplacer(_key, value) {
-    // Mirror runImplementation serialization so buffer snapshots round-trip.
-    if (value instanceof ArrayBuffer) {
-        return {
-            __type: 'ArrayBuffer',
-            data: encodeUint8ArrayToBase64(new Uint8Array(value)),
-        };
-    }
-    if (isArrayBufferView(value)) {
-        const view = value;
-        return {
-            __type: view.constructor.name,
-            data: encodeUint8ArrayToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength)),
-        };
-    }
-    if (isNodeBuffer(value)) {
-        const view = value;
-        return {
-            __type: 'Buffer',
-            data: encodeUint8ArrayToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength)),
-        };
-    }
-    if (isSerializedBufferSnapshot(value)) {
-        return {
-            __type: 'Buffer',
-            data: encodeUint8ArrayToBase64(Uint8Array.from(value.data)),
-        };
-    }
-    return value;
-}
-// Normalizes user-provided input into the structure the model expects. Strings become user messages,
-// arrays are kept as-is so downstream loops can treat both scenarios uniformly.
-function toAgentInputList(originalInput) {
-    // Allow callers to pass plain strings while preserving original item order.
-    if (typeof originalInput === 'string') {
-        return [{ type: 'message', role: 'user', content: originalInput }];
-    }
-    return [...originalInput];
 }
+// internal helpers and constants
+let defaultRunner;
+const getDefaultRunner = () => {
+    if (!defaultRunner) {
+        defaultRunner = new Runner();
+    }
+    return defaultRunner;
+};
 //# sourceMappingURL=run.mjs.map