@qduc/term2 0.11.0 → 0.12.0

package/dist/services/agent-runtime/application-run-loop.js

@@ -0,0 +1,1236 @@
+import { z } from 'zod';
+import { createContinuationHandle, unwrapContinuationHandle, } from '../../contracts/continuation-handle.js';
+import { createAgentStream } from '../agent-stream.js';
+import { isZodToolParameterSchema } from '../../tools/types.js';
+import { normalizeToolParameters } from '../../lib/tool-invoke.js';
+import { isCancellationError, isHarnessInvariantError } from '../../lib/harness-invariant-error.js';
+import { ApprovalLedger } from './tool-invocation-context.js';
+import { addTokenUsage, normalizeUsage } from '../../utils/ai/token-usage.js';
+import { computeModelCost } from '../../services/cost/model-cost.js';
+import { getCatalogPricingVersion, getModelPricing } from '../../services/cost/pricing.js';
+import { GenerationDeadline, GenerationGuard, GenerationGuardError, } from './generation-guard.js';
+/**
+ * Raised when a run exceeds its `maxTurns` budget. The loop owns turn counting
+ * — the SDK-era `callModelInputFilter` hook is deliberately not reintroduced.
+ */
+export class MaxTurnsExceededError extends Error {
+    maxTurns;
+    constructor(maxTurns) {
+        super(`Max turns (${maxTurns}) exceeded`);
+        this.name = 'MaxTurnsExceededError';
+        this.maxTurns = maxTurns;
+    }
+}
+class EventQueue {
+    #items = [];
+    #waiters = [];
+    #closed = false;
+    #failure;
+    push(item) {
+        const waiter = this.#waiters.shift();
+        if (waiter)
+            waiter.resolve({ done: false, value: item });
+        else
+            this.#items.push(item);
+    }
+    close(error) {
+        this.#closed = true;
+        this.#failure = error;
+        for (const waiter of this.#waiters.splice(0)) {
+            if (error)
+                waiter.reject(error);
+            else
+                waiter.resolve({ done: true, value: undefined });
+        }
+    }
+    next() {
+        const item = this.#items.shift();
+        if (item !== undefined)
+            return Promise.resolve({ done: false, value: item });
+        if (this.#closed) {
+            if (this.#failure)
+                return Promise.reject(this.#failure);
+            return Promise.resolve({ done: true, value: undefined });
+        }
+        return new Promise((resolve, reject) => this.#waiters.push({ resolve, reject }));
+    }
+}
+/**
+ * Small provider-neutral agent loop. It owns model-turn sequencing and tool
+ * execution; providers only implement `StreamedModelTurn`.
+ */
+export class ApplicationRunLoop {
+    #deps;
+    #contextCompactionSessionState;
+    #activeAbortController = null;
+    #runInFlight = false;
+    /**
+     * Set when a segment ends holding approvals, meaning the turn is pausing
+     * rather than finishing. Injections offered during the pause wait here for
+     * the continuation segment instead of being refused for want of a run.
+     */
+    #turnPaused = false;
+    /**
+     * Set while a caller that owns turn boundaries has a turn open, from before
+     * its first request is built until after its last one settles.
+     *
+     * `#runInFlight` and `#turnPaused` only ever describe a *segment*, so between
+     * them they leave every gap in a turn where no run exists yet: the startup
+     * before the first request (provider model discovery, hooks, input
+     * preparation) and the backoff before a retry restarts the stream. A turn is
+     * steerable across those gaps, and only the caller that opened the turn knows
+     * they belong to it.
+     */
+    #turnOpen = false;
+    #pendingSteers = [];
+    constructor(deps) {
+        this.#deps = deps;
+        this.#contextCompactionSessionState = deps.contextCompactionSessionState ?? { disabled: false };
+    }
+    /**
+     * Declare a turn open, making it steerable before its first run exists.
+     *
+     * Anything still waiting belongs to a turn that never closed, and can never
+     * be admitted now.
+     */
+    openTurn() {
+        this.#releasePendingSteers({ reason: 'superseded_by_new_turn' });
+        this.#turnOpen = true;
+        this.#turnPaused = false;
+    }
+    /**
+     * Declare the turn over. Whatever is still waiting had no boundary left, so
+     * it is handed back for the caller to send as its own turn.
+     */
+    closeTurn() {
+        this.#turnOpen = false;
+        this.#turnPaused = false;
+        this.#releasePendingSteers({ reason: 'turn_closed' });
+    }
+    abort() {
+        this.abortSegment();
+        // An aborted turn will not resume, so nothing may keep waiting on it.
+        this.#turnOpen = false;
+        this.#turnPaused = false;
+        this.#releasePendingSteers({ reason: 'aborted' });
+    }
+    /**
+     * Stop the segment currently streaming without judging the turn's fate.
+     *
+     * Resuming a paused turn goes through here, so waiting injections survive;
+     * only `abort`, which means the turn itself is over, discards them.
+     */
+    abortSegment() {
+        this.#activeAbortController?.abort();
+        this.#activeAbortController = null;
+    }
+    /**
+     * Hand the running turn a user message to send with its next model request.
+     *
+     * The loop admits it at a request boundary — after the tool results of the
+     * current round are in history and before the next request is built — so the
+     * model reads it in sequence without the turn being interrupted. Nothing is
+     * cancelled, and a tool already running is untouched.
+     *
+     * The wait spans the whole turn, not just the segment it was offered to: a
+     * turn that pauses for an approval resumes as a new segment, and the message
+     * is admitted at that segment's first boundary. A caller that declares its
+     * turn boundaries with `openTurn`/`closeTurn` extends the wait further still,
+     * to the gaps where no segment exists at all — before the first request, and
+     * across a retry that restarts the stream.
+     *
+     * Resolves `'admitted'` once the message has been admitted, `'released'`
+     * when the turn ends first (or none is running) — it offered no further
+     * request boundary, so the caller must send the message as its own turn
+     * instead — and `'retracted'` when `retractSteer` pulled it out first.
+     *
+     * `options.id` correlates this steer with `retractSteer`/`editSteer`. A
+     * steer offered without an id can never be retracted or edited in place —
+     * only released or admitted.
+     */
+    steer(items, options) {
+        if (items.length === 0)
+            return Promise.resolve('released');
+        if (!this.#turnOpen && !this.#runInFlight && !this.#turnPaused)
+            return Promise.resolve('released');
+        return new Promise((resolve) => {
+            this.#pendingSteers.push({ id: options?.id, items, resolve });
+        });
+    }
+    /**
+     * Drop a still-waiting steer before it reaches a request boundary. Returns
+     * `false` when the id is unknown, including when it was already admitted.
+     *
+     * Invariant: this and `#admitPendingSteers` are both synchronous, and the
+     * latter drains `#pendingSteers` in a single pass — so the two can never
+     * interleave. A retraction is decided in the same tick against whatever is
+     * currently in `#pendingSteers`; once an item has been admitted it is no
+     * longer in that array for this method to find. No locking is needed to
+     * close the race between "the user retracts" and "the turn admits".
+     */
+    retractSteer(id) {
+        const index = this.#pendingSteers.findIndex((steer) => steer.id === id);
+        if (index < 0)
+            return false;
+        const [steer] = this.#pendingSteers.splice(index, 1);
+        steer.resolve('retracted');
+        return true;
+    }
+    /**
+     * Replace a waiting steer's items in place, keeping its position (and thus
+     * its priority relative to other pending steers) and its id. Returns
+     * `false` when the id is unknown, including when it was already admitted —
+     * same synchronicity invariant as `retractSteer`.
+     */
+    editSteer(id, items) {
+        const index = this.#pendingSteers.findIndex((steer) => steer.id === id);
+        if (index < 0)
+            return false;
+        this.#pendingSteers[index] = { ...this.#pendingSteers[index], items };
+        return true;
+    }
+    /** Settle every steer this run did not admit so callers stop waiting on it. */
+    #releasePendingSteers(reason = {}) {
+        const pending = this.#pendingSteers;
+        this.#pendingSteers = [];
+        if (pending.length > 0) {
+            this.#deps.logDiagnostic?.('Steer released at run end', { released: pending.length, ...reason });
+        }
+        for (const steer of pending)
+            steer.resolve('released');
+    }
+    /**
+     * Append waiting steers to the turn as ordinary user messages.
+     *
+     * They enter history and model input exactly as a user turn does — never
+     * folded into a tool result — so the provider sees the user speaking after
+     * the tool results of the round that was in flight when they typed.
+     */
+    #admitPendingSteers(state, stream, queue) {
+        if (this.#pendingSteers.length === 0)
+            return;
+        const admitted = this.#pendingSteers;
+        this.#pendingSteers = [];
+        this.#deps.logDiagnostic?.('Steer admitted at request boundary', {
+            admitted: admitted.length,
+            turnCount: state.turnCount,
+        });
+        for (const steer of admitted) {
+            for (const item of steer.items) {
+                state.history.push(item);
+                state.input.push(...normalizeApplicationInput([item]));
+                outputPush(stream, queue, { type: 'item', item });
+            }
+            steer.resolve('admitted');
+        }
+    }
+    startStream(agent, input, options = {}) {
+        // Without a declared turn scope, a fresh stream is the only evidence this
+        // loop gets that a new turn has begun: anything still waiting belonged to
+        // the previous one and must not leak into work the user did not aim it at.
+        // With one, this call may equally be the same turn restarting after a
+        // retry, which the loop cannot tell apart — so `openTurn`/`closeTurn` own
+        // the decision instead.
+        this.#turnPaused = false;
+        if (!this.#turnOpen)
+            this.#releasePendingSteers({ reason: 'superseded_by_new_turn' });
+        const state = {
+            agent,
+            input: normalizeInput(input),
+            history: normalizeHistory(input),
+            // A response ID is usable only after its provider origin is recorded.
+            // This also makes old callers that omit providerId fail closed.
+            responseId: options.providerId && options.supportsConversationChaining === true
+                ? options.previousResponseId ?? undefined
+                : undefined,
+            pendingApprovals: [],
+            supportsConversationChaining: options.supportsConversationChaining === true,
+            currentProviderId: options.providerId,
+            responseProviderId: options.providerId && options.supportsConversationChaining === true && options.previousResponseId
+                ? options.providerId
+                : undefined,
+            requestPreparation: options.requestPreparation,
+            sessionId: options.sessionId,
+            turnId: options.turnId,
+            hookScope: options.hookScope,
+            context: options.context,
+            approvals: options.approvals ?? new ApprovalLedger(),
+            turnCount: 0,
+            maxTurns: options.maxTurns,
+        };
+        state.approve = (interruption) => {
+            state.approvalDecision = 'approved';
+            state.approvalDecisionCallId = getInterruptionCallId(interruption);
+        };
+        state.reject = (interruption, approvalOptions) => {
+            state.approvalDecision = 'rejected';
+            state.approvalDecisionCallId = getInterruptionCallId(interruption);
+            state.approvalMessage = approvalOptions?.message;
+        };
+        return this.#run(state, options);
+    }
+    continueRunStream(handle, options = {}) {
+        const state = unwrapContinuationHandle(handle);
+        if (!state || typeof state !== 'object' || !('agent' in state) || !('input' in state)) {
+            throw new Error('Invalid application continuation state');
+        }
+        // Handles created before the ledger existed cannot resume meaningfully;
+        // give them a fresh ledger rather than crashing on `approvals` access.
+        if (!state.approvals)
+            state.approvals = new ApprovalLedger();
+        // A continuation handle from before approval batching carried only the
+        // current pending item. Normalize it into the queue used by current runs.
+        if (!state.pendingApprovals)
+            state.pendingApprovals = state.pendingApproval ? [state.pendingApproval] : [];
+        if (!state.pendingApproval && state.pendingApprovals.length > 0) {
+            state.pendingApproval = state.pendingApprovals[0];
+        }
+        // Handles created before cost accounting existed have no record list.
+        if (!state.costRecords)
+            state.costRecords = [];
+        // Response IDs are provider-owned. A handle from before provenance was
+        // recorded, a missing providerId, or a provider switch must never forward
+        // its opaque ID. In particular, do not use previousResponseId as a
+        // compatibility fallback here: its origin cannot be proven.
+        const previousProviderId = state.currentProviderId;
+        const sameProvider = typeof previousProviderId === 'string' &&
+            typeof options.providerId === 'string' &&
+            previousProviderId === options.providerId;
+        if (!sameProvider || options.supportsConversationChaining !== true) {
+            state.responseId = undefined;
+            state.responseProviderId = undefined;
+        }
+        else if (options.previousResponseId) {
+            // A same-provider caller may supply a refreshed continuity anchor (for
+            // example after persisted-session recovery). Its origin is now proven
+            // by the provider identity carried in this continuation state.
+            state.responseId = options.previousResponseId;
+            state.responseProviderId = options.providerId;
+        }
+        state.currentProviderId = options.providerId;
+        // The turn budget belongs to the run, so a resumed run keeps spending the
+        // same one rather than starting over after every approval pause.
+        if (typeof state.turnCount !== 'number')
+            state.turnCount = 0;
+        if (state.maxTurns === undefined)
+            state.maxTurns = options.maxTurns;
+        if (typeof state.supportsConversationChaining !== 'boolean') {
+            state.supportsConversationChaining = options.supportsConversationChaining === true;
+        }
+        else {
+            // AgentClient supplies the current provider capability on every resume.
+            state.supportsConversationChaining = options.supportsConversationChaining === true;
+        }
+        // A continuation receives a fresh immutable snapshot from the session;
+        // refresh the preparation closure when supplied, while preserving the
+        // root closure for callers that do not provide one again.
+        if (options.requestPreparation)
+            state.requestPreparation = options.requestPreparation;
+        if (options.sessionId !== undefined)
+            state.sessionId = options.sessionId;
+        if (options.turnId !== undefined)
+            state.turnId = options.turnId;
+        if (options.hookScope !== undefined)
+            state.hookScope = options.hookScope;
+        return this.#run(state, options);
+    }
+    #run(state, options) {
+        const queue = new EventQueue();
+        this.abortSegment();
+        const controller = new AbortController();
+        this.#activeAbortController = controller;
+        this.#runInFlight = true;
+        // This segment is running, so the turn is no longer paused between them.
+        this.#turnPaused = false;
+        if (options.signal) {
+            if (options.signal.aborted)
+                controller.abort();
+            else
+                options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
+        const effectiveOptions = { ...options, signal: controller.signal };
+        const toolContext = {
+            context: state.context,
+            approvals: state.approvals,
+            signal: effectiveOptions.signal,
+            // A getter, not a snapshot: the context object outlives every turn, and
+            // tools read it while deciding whether to warn about the turn budget.
+            get turn() {
+                return { count: state.turnCount, max: state.maxTurns };
+            },
+        };
+        const output = [];
+        const stream = createAgentStream({
+            [Symbol.asyncIterator]: () => ({ next: () => queue.next() }),
+            completed: Promise.resolve(undefined),
+            history: state.history,
+            newItems: output,
+            output,
+            finalOutput: undefined,
+            lastResponseId: state.responseId ?? null,
+            interruptions: [],
+            state: createContinuationHandle(state),
+            rawResponses: [],
+            get runUsage() {
+                return state.usage;
+            },
+            get runCostRecords() {
+                return state.costRecords ?? [];
+            },
+        });
+        let exitError;
+        stream.completed = this.#execute(state, stream, queue, effectiveOptions, toolContext, controller)
+            .catch((error) => {
+            exitError = error;
+            stream.cancelled = error instanceof Error && error.name === 'AbortError';
+            queue.close(error);
+            throw error;
+        })
+            .finally(() => {
+            if (this.#activeAbortController === controller)
+                this.#activeAbortController = null;
+            this.#runInFlight = false;
+            // A segment that ends holding approvals has paused the turn, not ended
+            // it: the caller resumes through continueRunStream, which offers
+            // another request boundary. Injections wait for it. Only a segment
+            // that ends with nothing outstanding has truly finished the turn, and
+            // then anything still waiting has to be sent as its own turn instead.
+            const pendingApprovals = state.pendingApprovals?.length ?? 0;
+            const cancelled = stream.cancelled === true;
+            this.#turnPaused = pendingApprovals > 0 && !cancelled && exitError === undefined;
+            if (this.#turnPaused)
+                return;
+            // A declared turn outlives its segments — this one may be about to be
+            // retried, or resumed past a post-execute gate. Its owner says when it
+            // is over.
+            if (this.#turnOpen)
+                return;
+            this.#releasePendingSteers({
+                pendingApprovals,
+                cancelled,
+                error: exitError instanceof Error ? exitError.name : exitError ? String(exitError) : undefined,
+                turnCount: state.turnCount,
+            });
+        });
+        return stream;
+    }
+    async #execute(state, stream, queue, options, toolContext, requestAbortController) {
+        while (true) {
+            if (options.signal?.aborted)
+                throw Object.assign(new Error('Operation aborted'), { name: 'AbortError' });
+            state.pendingApprovals ??= state.pendingApproval ? [state.pendingApproval] : [];
+            if (state.pendingApprovals.length > 0 && state.approvalDecision) {
+                const selectedIndex = state.approvalDecisionCallId
+                    ? state.pendingApprovals.findIndex((pending) => getInterruptionCallId(pending.interruption) === state.approvalDecisionCallId)
+                    : -1;
+                if (state.approvalDecisionCallId && selectedIndex < 0) {
+                    throw new Error(`Approval decision references unknown pending tool call: ${state.approvalDecisionCallId}`);
+                }
+                const pendingIndex = selectedIndex >= 0 ? selectedIndex : 0;
+                const pending = state.pendingApprovals[pendingIndex];
+                const approved = state.approvalDecision === 'approved';
+                if (approved) {
+                    state.approvals.approveTool({ toolName: pending.toolName, callId: pending.callId });
+                }
+                else {
+                    state.approvals.rejectTool({ toolName: pending.toolName, callId: pending.callId }, { message: state.approvalMessage });
+                }
+                const rawResult = approved
+                    ? await this.#invokeTool(pending.definition, pending.params, toolContext, pending.callId, state)
+                    : state.approvalMessage ?? 'rejected';
+                const result = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult);
+                const resultItem = {
+                    type: 'function_call_result',
+                    callId: pending.callId,
+                    name: pending.toolName,
+                    output: result,
+                };
+                state.history.push(resultItem);
+                state.input.push({ type: 'tool_result', id: pending.callId, output: result });
+                outputPush(stream, queue, { type: 'item', item: resultItem });
+                state.pendingApprovals.splice(pendingIndex, 1);
+                state.pendingApproval = state.pendingApprovals[0];
+                state.approvalDecision = undefined;
+                state.approvalDecisionCallId = undefined;
+                state.approvalMessage = undefined;
+                stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+                if (state.pendingApprovals.length > 0)
+                    return finish(stream, state, queue);
+                // Nothing is outstanding, so this segment is terminal — see
+                // `stopAfterApprovalResolution`. Stopping here rather than at the
+                // request boundary below is what keeps the just-recorded tool result
+                // in the committed history.
+                if (options.stopAfterApprovalResolution)
+                    return finish(stream, state, queue);
+            }
+            // The request boundary: every tool result of the previous round is in
+            // history, and the next request has not been built. A user message
+            // admitted here reaches the model in sequence, mid-turn.
+            this.#admitPendingSteers(state, stream, queue);
+            state.turnCount += 1;
+            if (state.maxTurns !== undefined && state.turnCount > state.maxTurns) {
+                throw new MaxTurnsExceededError(state.maxTurns);
+            }
+            const model = await this.#deps.resolveModel(state.agent.model);
+            let sawToolCall = false;
+            let completion;
+            let pendingNativeReasoning;
+            // Stable run-local request id, allocated immediately before dispatch so a
+            // cost record can be settled exactly once (success or failure).
+            const requestId = this.#nextRequestId(state);
+            const request = {
+                instructions: state.agent.instructions,
+                ...(state.supportsConversationChaining &&
+                    state.responseId &&
+                    state.responseProviderId !== undefined &&
+                    state.responseProviderId === state.currentProviderId
+                    ? { previousResponseId: state.responseId }
+                    : {}),
+                input: state.input,
+                tools: toModelTools(state.agent.tools),
+                applicationTools: state.agent.tools,
+                ...(state.agent.modelSettings?.temperature !== undefined
+                    ? { temperature: state.agent.modelSettings.temperature }
+                    : {}),
+                ...(state.agent.modelSettings?.reasoning ? { reasoning: state.agent.modelSettings.reasoning } : {}),
+                ...(state.agent.modelSettings?.maxTokens !== undefined
+                    ? { maxTokens: state.agent.modelSettings.maxTokens }
+                    : {}),
+                ...(state.agent.outputType !== undefined ? { outputType: state.agent.outputType } : {}),
+                ...(state.agent.modelSettings?.codex ? { codex: state.agent.modelSettings.codex } : {}),
+                ...(state.agent.modelSettings?.providerData
+                    ? {
+                        providerOptions: this.#contextCompactionSessionState.disabled
+                            ? Object.fromEntries(Object.entries(state.agent.modelSettings.providerData).filter(([key]) => key !== 'contextCompaction'))
+                            : state.agent.modelSettings.providerData,
+                    }
+                    : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+            };
+            const generationGuard = new GenerationGuard({
+                maxOutputCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                maxTextCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                maxReasoningCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                maxToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                maxCumulativeToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                requestDeadlineMs: state.agent.modelSettings?.maxModelRequestDurationMs,
+                ...options.generationGuard,
+            });
+            const consume = async () => {
+                const deadline = new GenerationDeadline(generationGuard.requestDeadlineMs, () => requestAbortController.abort());
+                let iterator;
+                let iteratorFinished = false;
+                try {
+                    iterator = model.stream(request)[Symbol.asyncIterator]();
+                    while (true) {
+                        const next = await deadline.wait(iterator.next());
+                        if (next.done) {
+                            iteratorFinished = true;
+                            return;
+                        }
+                        const event = next.value;
+                        if (event.type === 'completion') {
+                            generationGuard.observeCompletion(event.output);
+                            completion = event;
+                            continue;
+                        }
+                        if (event.type === 'text_delta') {
+                            generationGuard.observeText(event.text);
+                            outputPush(stream, queue, { type: 'text_delta', text: event.text });
+                            continue;
+                        }
+                        if (event.type === 'codex_rate_limits') {
+                            outputPush(stream, queue, { type: 'codex_rate_limits', rateLimits: event.rateLimits });
+                            continue;
+                        }
+                        if (event.type === 'reasoning_delta') {
+                            generationGuard.observeReasoning(event.text);
+                            pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, event);
+                            outputPush(stream, queue, { type: 'reasoning_delta', text: event.text });
+                            continue;
+                        }
+                        if (event.type === 'tool_call_streaming_delta') {
+                            generationGuard.observeToolArgumentProgress(event.argumentCharCount);
+                            outputPush(stream, queue, event);
+                            continue;
+                        }
+                        if (event.type === 'context_compaction_started' || event.type === 'context_compaction_completed') {
+                            outputPush(stream, queue, event);
+                            continue;
+                        }
+                        if (event.type === 'tool_call') {
+                            generationGuard.observeToolCall(event.arguments);
+                            pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+                            sawToolCall = true;
+                            await this.#handleToolCall(state, stream, queue, event, toolContext);
+                        }
+                    }
+                }
+                finally {
+                    deadline.dispose();
+                    if (iterator && !iteratorFinished)
+                        void iterator.return?.().catch(() => undefined);
+                }
+            };
+            const dispatch = async () => {
+                state.requestPreparation?.prepare(request);
+                await consume();
+            };
+            try {
+                if (state.requestPreparation)
+                    await state.requestPreparation.run(dispatch);
+                else
+                    await dispatch();
+            }
+            catch (error) {
+                if (error instanceof GenerationGuardError)
+                    requestAbortController.abort();
+                // Dispatch began, but no terminal completion was accepted. Record an
+                // unpriced marker so the summary stays honest (partial) rather than
+                // appearing exact. Observational only: the error still propagates.
+                const cancelled = error instanceof Error && error.name === 'AbortError';
+                this.#appendCostRecord(state, {
+                    requestId,
+                    provider: state.currentProviderId,
+                    model: state.agent.model,
+                    tier: resolveServiceTier(request),
+                    outcome: cancelled ? 'cancelled' : 'failed',
+                });
+                throw error;
+            }
+            if (!completion)
+                throw new Error('Application model turn ended without completion');
+            // Commit the authoritative terminal state before handling terminal-only
+            // tool calls. Approval may pause immediately after this point, and the
+            // continuation must still carry the response that produced the calls.
+            // Response IDs are provider-chain state, not generic run metadata. Keep
+            // them out of continuation handles for providers that do not support
+            // chaining, while still exposing the completed provider response on the
+            // current stream for diagnostics.
+            if (state.supportsConversationChaining && state.currentProviderId !== undefined) {
+                state.responseId = completion.responseId;
+                state.responseProviderId = state.currentProviderId;
+            }
+            else {
+                state.responseId = undefined;
+                state.responseProviderId = undefined;
+            }
+            let normalizedCompletionUsage;
+            if (completion.usage !== undefined) {
+                normalizedCompletionUsage = normalizeModelUsage(completion.usage);
+                if (normalizedCompletionUsage) {
+                    const accumulated = addTokenUsage(normalizeModelUsage(state.usage), normalizedCompletionUsage);
+                    state.usage = {
+                        ...(accumulated.prompt_tokens !== undefined ? { inputTokens: accumulated.prompt_tokens } : {}),
+                        ...(accumulated.completion_tokens !== undefined ? { outputTokens: accumulated.completion_tokens } : {}),
+                        // `total_tokens` is the billable normalized total, including cache
+                        // creation tokens. Keep it alongside the application aliases so the
+                        // authoritative run accumulator never reconstructs a smaller total.
+                        ...(accumulated.total_tokens !== undefined ? { totalTokens: accumulated.total_tokens } : {}),
+                        ...(accumulated.cache_read_tokens !== undefined
+                            ? { cachedInputTokens: accumulated.cache_read_tokens }
+                            : {}),
+                        ...(accumulated.cache_creation_tokens !== undefined
+                            ? { cacheWriteTokens: accumulated.cache_creation_tokens }
+                            : {}),
+                    };
+                }
+                else {
+                    // Providers may carry a future/opaque usage shape. Preserve the old
+                    // pass-through behavior when normalization cannot recognize it.
+                    state.usage = completion.usage;
+                }
+            }
+            else {
+                normalizedCompletionUsage = undefined;
+            }
+            // Attribute cost while the dispatched request's identity is still known.
+            this.#appendCostRecord(state, {
+                requestId,
+                provider: state.currentProviderId,
+                model: state.agent.model,
+                tier: resolveServiceTier(request),
+                outcome: 'completed',
+                usage: normalizedCompletionUsage,
+                providerUsd: completion.costUsd,
+            });
+            stream.lastResponseId = completion.responseId;
+            stream.rawResponses?.push(completion);
+            // Some provider adapters report function calls only in the terminal
+            // completion rather than as separate stream events. Their reasoning may
+            // likewise be terminal-only, so associate it before replaying calls.
+            if (!sawToolCall) {
+                for (const item of completion.output) {
+                    if (item.type === 'reasoning')
+                        pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, item);
+                }
+                for (const item of completion.output) {
+                    if (item.type !== 'tool_call')
+                        continue;
+                    pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+                    sawToolCall = true;
+                    await this.#handleToolCall(state, stream, queue, item, toolContext);
+                }
+            }
+            // A native reasoning item belongs to the completed assistant turn even
+            // when no tool call follows it. Commit it before assistant text so both
+            // stateless continuation and persisted canonical history retain the
+            // provider-specific metadata exactly once.
+            pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+            // Provider-native completion items (notably OpenAI compaction items)
+            // must stay in the live provider history. The session layer later
+            // applies compaction's replacement rule; keeping the item here also
+            // makes it available to an in-flight tool continuation before that
+            // terminal history commit occurs.
+            for (const item of completion.output) {
+                if (item.type !== 'provider_opaque')
+                    continue;
+                const historyItem = {
+                    ...item.item,
+                    providerOpaque: { provider: item.provider },
+                };
+                state.history.push(historyItem);
+                state.input.push(item);
+                outputPush(stream, queue, { type: 'item', item });
+            }
+            const assistantText = completion.output
+                .filter((item) => item.type === 'message')
+                .flatMap((item) => item.content)
+                .map((part) => part.text)
+                .join('');
+            if (assistantText) {
+                stream.finalOutput = assistantText;
+                const item = {
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text: assistantText }],
+                };
+                state.history.push(item);
+                outputPush(stream, queue, { type: 'item', item });
+                state.input.push({ type: 'message', role: 'assistant', content: [{ type: 'text', text: assistantText }] });
+            }
+            if (state.pendingApprovals.length > 0) {
+                stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+                return finish(stream, state, queue);
+            }
+            if (!sawToolCall)
+                return finish(stream, state, queue);
+        }
+    }
+    async #handleToolCall(state, stream, queue, event, toolContext) {
+        const definition = state.agent.tools.find((tool) => tool.name === event.name);
+        const args = parseArguments(event.arguments);
+        const callItem = {
+            type: 'function_call',
+            callId: event.id,
+            name: event.name,
+            arguments: event.arguments,
+        };
+        state.history.push(callItem);
+        state.input.push({ type: 'tool_call', id: event.id, name: event.name, arguments: event.arguments });
+        outputPush(stream, queue, { type: 'item', item: callItem });
+        if (!definition) {
+            const output = `Unknown tool: ${event.name}`;
+            const resultItem = {
+                type: 'function_call_result',
+                callId: event.id,
+                name: event.name,
+                output,
+            };
+            state.history.push(resultItem);
+            state.input.push({ type: 'tool_result', id: event.id, output });
+            outputPush(stream, queue, { type: 'item', item: resultItem });
+            return;
+        }
+        // Keep the raw-model invocation contract: normalization repairs the
+        // accepted object shape but intentionally does not Zod-parse it, which
+        // would apply schema defaults before execute. web_fetch relies on its
+        // executor fallbacks on the strict JSON-schema path.
+        const params = normalizeToolParameters(args, definition.parameters);
+        // Consult this run's ledger before prompting: a decision already taken
+        // (in the parent run and replayed in, or earlier in this run) must not
+        // prompt again. This is what makes approval replay observable.
+        const alreadyDecided = state.approvals.isToolApproved({ toolName: event.name, callId: event.id });
+        if (alreadyDecided === false) {
+            const message = state.approvals.getRejectionMessage(event.name, event.id) ?? 'Tool execution was not approved.';
+            const resultItem = {
+                type: 'function_call_result',
+                callId: event.id,
+                name: event.name,
+                output: message,
+            };
+            state.history.push(resultItem);
+            state.input.push({ type: 'tool_result', id: event.id, output: message });
+            outputPush(stream, queue, { type: 'item', item: resultItem });
+            return;
+        }
+        if (alreadyDecided === true) {
+            const result = await this.#invokeTool(definition, params, toolContext, event.id, state);
+            const output = typeof result === 'string' ? result : JSON.stringify(result);
+            const resultItem = {
+                type: 'function_call_result',
+                callId: event.id,
+                name: event.name,
+                output,
+            };
+            state.history.push(resultItem);
+            state.input.push({ type: 'tool_result', id: event.id, output });
+            outputPush(stream, queue, { type: 'item', item: resultItem });
+            return;
+        }
+        if (await definition.needsApproval(params, toolContext)) {
+            const pending = {
+                callId: event.id,
+                toolName: event.name,
+                argumentsText: event.arguments,
+                interruption: {
+                    type: 'tool_approval_item',
+                    rawItem: { type: 'function_call', callId: event.id, name: event.name, arguments: event.arguments },
+                    callId: event.id,
+                    name: event.name,
+                    arguments: event.arguments,
+                },
+                definition,
+                params,
+            };
+            state.pendingApprovals ??= [];
+            if (!state.pendingApproval)
+                state.pendingApproval = pending;
+            state.pendingApprovals.push(pending);
+            stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+            return;
+        }
+        const result = await this.#invokeTool(definition, params, toolContext, event.id, state);
+        const output = typeof result === 'string' ? result : JSON.stringify(result);
+        const resultItem = {
+            type: 'function_call_result',
+            callId: event.id,
+            name: event.name,
+            output,
+        };
+        state.history.push(resultItem);
+        state.input.push({ type: 'tool_result', id: event.id, output });
+        outputPush(stream, queue, { type: 'item', item: resultItem });
+    }
+    /**
+     * A tool that throws must not take the run down with it.
+     *
+     * Most tools already report failure by returning `Error: ...` as their
+     * output, which the model reads and acts on. The handful that throw got the
+     * opposite treatment for no principled reason: the exception escaped to
+     * `#execute`, closed the event queue, and ended the turn — so the model never
+     * saw a recoverable problem like a path that does not exist, and the caller
+     * lost the whole turn. Worse, `#handleToolCall` pushes the `function_call`
+     * into history before executing, so an escape leaves a call with no matching
+     * result.
+     *
+     * Errors are therefore normalized into tool output, with two exceptions that
+     * must still propagate: cancellation (the run is ending on purpose) and
+     * `HarnessInvariantError` (a bug here, which the model cannot act on).
+     */
+    async #invokeTool(definition, params, toolContext, callId, state) {
+        const startedAt = Date.now();
+        const attempt = state
+            ? ((state.toolAttempts ??= new Map()).set(callId, (state.toolAttempts.get(callId) ?? 0) + 1),
+                state.toolAttempts.get(callId))
+            : 1;
+        const lifecycleContext = {
+            ...(state?.sessionId ? { sessionId: state.sessionId } : {}),
+            ...(state?.turnId ? { turnId: state.turnId } : {}),
+            toolCallId: callId,
+            toolName: definition.name,
+            normalizedArguments: params,
+            attempt,
+            scope: state?.hookScope ?? 'root',
+        };
+        await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.before(lifecycleContext));
+        try {
+            const result = await definition.execute(params, toolContext, { toolCall: { callId } });
+            await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.after(lifecycleContext, result, Date.now() - startedAt));
+            return result;
+        }
+        catch (error) {
+            if (isCancellationError(error) || isHarnessInvariantError(error) || error instanceof MaxTurnsExceededError) {
+                await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, false));
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            // Feeding the same failure back forever is its own failure mode: some
+            // errors no argument can fix. Repeat the identical result once, then say
+            // so plainly rather than inviting a third identical attempt.
+            const repeated = state ? countRepeatedFailure(state, definition.name, params, message) : 1;
+            if (repeated > MAX_IDENTICAL_TOOL_FAILURES) {
+                const result = `Error: ${message}\n\nThis exact call has now failed ${repeated} times with the same error. Do not call ${definition.name} with these arguments again — either change your approach or report the problem to the user.`;
+                await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, true));
+                return result;
+            }
+            const result = `Error: ${message}`;
+            await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, true));
+            return result;
+        }
+    }
+    #nextRequestId(state) {
+        state.costRequestSeq = (state.costRequestSeq ?? 0) + 1;
+        return `req-${state.turnCount}-${state.costRequestSeq}`;
+    }
+    #appendCostRecord(state, input) {
+        const record = computeModelCost({
+            requestId: input.requestId,
+            provider: input.provider ?? 'unknown',
+            model: input.model,
+            serviceTier: input.tier,
+            outcome: input.outcome,
+            usage: input.usage,
+            providerUsd: input.providerUsd,
+            getPrice: (provider, model, tier) => getModelPricing(provider, model, tier),
+            pricingVersion: getCatalogPricingVersion(),
+        });
+        state.costRecords = [...(state.costRecords ?? []), record];
+    }
+    async #notifyToolLifecycle(operation) {
+        if (!operation)
+            return;
+        try {
+            await operation();
+        }
+        catch {
+            // Lifecycle observers are passive. A broken observer must not alter tool
+            // execution or turn recovery semantics.
+        }
+    }
+}
+/**
+ * How many times an identical failing call is fed back before the loop stops
+ * inviting retries. One repeat is worth allowing: a transient failure resolves,
+ * and a model given the error often corrects on its second attempt.
+ */
+const MAX_IDENTICAL_TOOL_FAILURES = 2;
+function countRepeatedFailure(state, toolName, params, message) {
+    let key;
+    try {
+        key = JSON.stringify([toolName, params, message]);
+    }
+    catch {
+        // Unserializable params cannot be compared for identity; treat every such
+        // failure as distinct rather than collapsing unrelated calls together.
+        return 1;
+    }
+    state.toolFailureCounts ??= new Map();
+    const count = (state.toolFailureCounts.get(key) ?? 0) + 1;
+    state.toolFailureCounts.set(key, count);
+    return count;
+}
+function outputPush(stream, queue, item) {
+    stream.output.push(item);
+    if (stream.newItems !== stream.output)
+        stream.newItems.push(item);
+    queue.push(item);
+}
+function finish(stream, state, queue) {
+    stream.history = state.history;
+    if (state.supportsConversationChaining &&
+        state.responseId &&
+        state.responseProviderId !== undefined &&
+        state.responseProviderId === state.currentProviderId) {
+        stream.lastResponseId = state.responseId;
+    }
+    else {
+        stream.lastResponseId = null;
+    }
+    queue.close();
+    return { usage: state.usage, output: stream.output, costRecords: state.costRecords ?? [] };
+}
+/**
+ * Only replay native reasoning when the provider explicitly supplies the
+ * Chat-Completions continuation field. Generic reasoning remains display-only
+ * so providers with different native formats are not given a foreign field.
+ */
+function appendNativeReasoning(current, event) {
+    const nativeReasoning = event.providerMetadata?.reasoning_content;
+    if (typeof nativeReasoning === 'string') {
+        const text = current?.text === nativeReasoning
+            ? current.text
+            : current?.text && nativeReasoning.startsWith(current.text)
+                ? nativeReasoning
+                : `${current?.text ?? ''}${nativeReasoning}`;
+        return {
+            ...(event.id ? { id: event.id } : current?.id ? { id: current.id } : {}),
+            text,
+            providerMetadata: { ...event.providerMetadata, reasoning_content: text },
+        };
+    }
+    // Responses providers return encrypted reasoning only on their terminal
+    // output. Their metadata is namespaced, so retain it without turning it into
+    // the Chat-Completions-only reasoning_content convention.
+    if (asRecord(event.providerMetadata?.codex) || asRecord(event.providerMetadata?.openai)) {
+        return {
+            ...(event.id ? { id: event.id } : current?.id ? { id: current.id } : {}),
+            text: event.text,
+            providerMetadata: event.providerMetadata,
+        };
+    }
+    return current;
+}
+function commitPendingNativeReasoning(state, stream, queue, pending) {
+    if (!pending)
+        return undefined;
+    const reasoningInput = {
+        type: 'reasoning',
+        ...(pending.id ? { id: pending.id } : {}),
+        text: pending.text,
+        providerMetadata: pending.providerMetadata,
+    };
+    const reasoningHistory = {
+        type: 'reasoning',
+        ...(pending.id ? { id: pending.id } : {}),
+        content: [{ type: 'reasoning_text', text: pending.text }],
+        providerData: pending.providerMetadata,
+    };
+    state.input.push(reasoningInput);
+    state.history.push(reasoningHistory);
+    outputPush(stream, queue, { type: 'item', item: reasoningHistory });
+    return undefined;
+}
+/**
+ * Resolve the effective billing service tier from the dispatched request. The
+ * default service tier is standard; only a flex/batch request that was actually
+ * dispatched resolves to its tier, and anything unrecognized fails closed.
+ */
+function resolveServiceTier(request) {
+    const options = request.providerOptions;
+    const raw = options?.service_tier ?? options?.serviceTier;
+    if (raw === 'flex' || raw === 'batch' || raw === 'standard')
+        return raw;
+    return raw === undefined ? 'standard' : 'unknown';
+}
+function normalizeModelUsage(usage) {
+    if (!usage || typeof usage !== 'object')
+        return undefined;
+    const rawUsage = usage;
+    return normalizeUsage({
+        ...rawUsage,
+        cacheReadTokens: rawUsage.cachedInputTokens ?? rawUsage.cacheReadTokens,
+        cacheCreationTokens: rawUsage.cacheWriteTokens ?? rawUsage.cacheCreationTokens,
+    });
+}
+function parseArguments(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function getInterruptionCallId(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const callId = value.callId;
+    return typeof callId === 'string' ? callId : undefined;
+}
+function toModelTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: isJsonSchema(tool.parameters) ? tool.parameters : z.toJSONSchema(tool.parameters),
+    }));
+}
+function isJsonSchema(value) {
+    return typeof value === 'object' && value !== null && !isZodToolParameterSchema(value);
+}
+/**
+ * The canonical application projection used for both model requests and
+ * continuation-prefix comparisons. Keep this at the application boundary so
+ * callers never need to inspect opaque continuation state.
+ */
+export function normalizeApplicationInput(input) {
+    if (typeof input === 'string')
+        return [{ type: 'message', role: 'user', content: [{ type: 'text', text: input }] }];
+    const items = (Array.isArray(input) ? input : [input]);
+    return items.flatMap((item) => normalizeInputItem(item));
+}
+function normalizeInput(input) {
+    return normalizeApplicationInput(input);
+}
+function normalizeHistory(input) {
+    if (typeof input === 'string')
+        return [{ type: 'message', role: 'user', content: input }];
+    return Array.isArray(input) ? [...input] : [input];
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function unsupportedInput(description) {
+    throw new Error(`Unsupported restored input ${description}`);
+}
+function normalizeTextPart(value, description) {
+    if (typeof value === 'string')
+        return { type: 'text', text: value };
+    const record = asRecord(value);
+    if (!record ||
+        !['text', 'input_text', 'output_text'].includes(String(record.type)) ||
+        typeof record.text !== 'string') {
+        unsupportedInput(description);
+    }
+    return { type: 'text', text: record.text };
+}
+function normalizeMessageImage(record) {
+    const image = record.image ?? record.image_url;
+    const detail = typeof record.detail === 'string' ? record.detail : undefined;
+    if (image === undefined)
+        return { type: 'image', ...(detail ? { detail } : {}) };
+    if (typeof image === 'string')
+        return { type: 'image', image, ...(detail ? { detail } : {}) };
+    const reference = asRecord(image);
+    if (typeof reference?.id === 'string')
+        return { type: 'image', image: { id: reference.id }, ...(detail ? { detail } : {}) };
+    unsupportedInput('message image reference');
+}
+function normalizeMessagePart(value) {
+    const record = asRecord(value);
+    if (record?.type === 'image' || record?.type === 'input_image')
+        return normalizeMessageImage(record);
+    return normalizeTextPart(value, record?.type ? `message content: ${record.type}` : 'message content');
+}
+function normalizeMessageContent(value) {
+    if (value === undefined || value === null)
+        return [{ type: 'text', text: '' }];
+    return (Array.isArray(value) ? value : [value]).map((part) => normalizeMessagePart(part));
+}
+function isTextMessagePart(part) {
+    return part.type === 'text';
+}
+function normalizeToolImagePart(record) {
+    const rawImage = record.image ?? record.image_url;
+    const detail = typeof record.detail === 'string' ? record.detail : undefined;
+    if (rawImage === undefined)
+        return { type: 'image', ...(detail ? { detail } : {}) };
+    if (typeof rawImage === 'string')
+        return { type: 'image', image: rawImage, ...(detail ? { detail } : {}) };
+    const image = asRecord(rawImage);
+    if (!image)
+        unsupportedInput('tool image reference');
+    const normalized = typeof image.id === 'string'
+        ? { id: image.id }
+        : typeof image.url === 'string'
+            ? { url: image.url }
+            : typeof image.fileId === 'string'
+                ? { fileId: image.fileId }
+                : (typeof image.data === 'string' || image.data instanceof Uint8Array) && typeof image.mediaType === 'string'
+                    ? { data: image.data, mediaType: image.mediaType }
+                    : undefined;
+    if (!normalized)
+        unsupportedInput('tool image reference');
+    return { type: 'image', image: normalized, ...(detail ? { detail } : {}) };
+}
+function normalizeToolFilePart(record) {
+    const rawFile = record.file ?? record.file_id ?? record.file_url;
+    const outerFilename = typeof record.filename === 'string' ? record.filename : undefined;
+    if (typeof rawFile === 'string')
+        return { type: 'file', file: rawFile };
+    const file = asRecord(rawFile);
+    if (!file)
+        unsupportedInput('tool file reference');
+    if (typeof file.id === 'string')
+        return { type: 'file', file: { id: file.id, ...(outerFilename ? { filename: outerFilename } : {}) } };
+    if (typeof file.url === 'string')
+        return { type: 'file', file: { url: file.url, ...(outerFilename ? { filename: outerFilename } : {}) } };
+    const filename = outerFilename ?? (typeof file.filename === 'string' ? file.filename : undefined);
+    if ((typeof file.data === 'string' || file.data instanceof Uint8Array) &&
+        typeof file.mediaType === 'string' &&
+        filename !== undefined) {
+        return { type: 'file', file: { data: file.data, mediaType: file.mediaType, filename } };
+    }
+    unsupportedInput('tool file reference');
+}
+function normalizeToolResultPart(value) {
+    const record = asRecord(value);
+    if (record?.type === 'image' || record?.type === 'input_image')
+        return normalizeToolImagePart(record);
+    if (record?.type === 'file' || record?.type === 'input_file')
+        return normalizeToolFilePart(record);
+    return normalizeTextPart(value, record?.type ? `tool result part: ${record.type}` : 'tool result part');
+}
+function normalizeToolResultOutput(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    if (!Array.isArray(value))
+        unsupportedInput('tool result output');
+    return value.map(normalizeToolResultPart);
+}
+function normalizeReasoningText(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    const parts = Array.isArray(value) ? value : [value];
+    return parts
+        .map((part) => {
+        const record = asRecord(part);
+        if (!record ||
+            !['reasoning_text', 'text', 'summary_text'].includes(String(record.type)) ||
+            typeof record.text !== 'string') {
+            return unsupportedInput('reasoning content part');
+        }
+        return record.text;
+    })
+        .join('');
+}
+/** True when the adapter marked this item as provider-native and opaque. */
+function isProviderOpaque(item) {
+    const marker = item.providerOpaque;
+    return typeof marker?.provider === 'string' && marker.provider.length > 0;
+}
+function normalizeInputItem(item) {
+    if (isProviderOpaque(item)) {
+        const { providerOpaque: _marker, ...providerItem } = item;
+        return [{ type: 'provider_opaque', provider: item.providerOpaque.provider, item: providerItem }];
+    }
+    if (item.type === 'function_call') {
+        return [
+            {
+                type: 'tool_call',
+                id: String(item.callId ?? item.call_id ?? ''),
+                name: String(item.name ?? ''),
+                arguments: String(item.arguments ?? '{}'),
+            },
+        ];
+    }
+    if (item.type === 'function_call_result' || item.type === 'function_call_output') {
+        return [
+            {
+                type: 'tool_result',
+                id: String(item.callId ?? item.call_id ?? item.tool_call_id ?? ''),
+                output: normalizeToolResultOutput(item.output),
+            },
+        ];
+    }
+    if (item.type === 'reasoning') {
+        const providerMetadata = item.providerData;
+        return [
+            {
+                type: 'reasoning',
+                ...(typeof item.id === 'string' ? { id: item.id } : {}),
+                text: normalizeReasoningText(item.content ?? item.output ?? ''),
+                ...(providerMetadata ? { providerMetadata } : {}),
+            },
+        ];
+    }
+    if (item.type !== undefined && item.type !== 'message')
+        unsupportedInput(`item type: ${String(item.type)}`);
+    const role = item.role === undefined
+        ? 'user'
+        : item.role === 'assistant' || item.role === 'system' || item.role === 'user'
+            ? item.role
+            : unsupportedInput(`message role: ${String(item.role)}`);
+    const content = normalizeMessageContent(item.content);
+    if (role === 'system') {
+        const textContent = content.filter(isTextMessagePart);
+        if (textContent.length !== content.length)
+            unsupportedInput('system message content');
+        return [{ type: 'message', role, content: textContent }];
+    }
+    return [{ type: 'message', role, content }];
+}
+//# sourceMappingURL=application-run-loop.js.map