@openclaw/ai 2026.9.1-beta.1 → 2026.9.2

package/dist/{openai-responses-shared-DJThc6jW.mjs → openai-responses-shared-Bmma_3Qc.mjs}

@@ -1,19 +1,20 @@
 import { c as normalizeLowercaseStringOrEmpty, d as normalizeOptionalString, o as isRecord, t as truncateUtf16Safe } from "./utf16-slice-qz3nsy87.mjs";
-import { i as clampThinkingLevel, r as calculateCost } from "./sanitize-unicode-DCkltN94.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, n as getAiTransportHost } from "./host-D51fmkH6.mjs";
-import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
-import { t as asFiniteNumber } from "./number-coercion-H9qHik3g.mjs";
-import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary } from "./simple-options-CFj7x3J4.mjs";
-import { c as transformTransportMessages } from "./tool-schema-json-projection-qvTEs5Am.mjs";
-import { d as redactSensitiveText, u as redactIdentifier } from "./transport-utils-LJ1_rbi-.mjs";
-import { _ as transportAbortError, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, m as parseTerminalToolCallArguments, y as withProviderResponseHook } from "./transport-stream-shared-ljShVIZB.mjs";
+import { i as clampThinkingLevel, r as calculateCost } from "./sanitize-unicode-D6xUvZaS.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, n as getAiTransportHost } from "./host-CEvLw30U.mjs";
+import { i as stableStringify } from "./provider-error-9TraxGvt.mjs";
+import { r as asFiniteNumber } from "./base64-CEFBpSkN.mjs";
+import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName } from "./simple-options-BjHCCh4v.mjs";
+import { c as transformTransportMessages } from "./tool-schema-json-projection-mJhXDcyz.mjs";
+import { d as redactSensitiveText, p as sha256Hex, u as redactIdentifier } from "./transport-utils-7il795_9.mjs";
+import { _ as transportAbortError, c as finalizeTransportStream, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, m as parseTerminalToolCallArguments, o as failTransportStream, y as withProviderResponseHook } from "./transport-stream-shared-CZqMhfIw.mjs";
 import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { C as createOpenAIProviderAcceptanceHook, E as log, S as createModelStreamCooperativeScheduler, a as resolveOpenAIProjectedToolsStrictToolFlag, r as normalizeOpenAIStrictToolParameters, t as findOpenAIStrictToolProjectionDiagnostics, v as projectOpenAITools } from "./openai-tool-schema-ho-hIkQf.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-C01bQ5a3.mjs";
-import { S as supportsOpenAITemperature, a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, x as supportsOpenAIReasoningEffort, y as resolveOpenAIReasoningEffortForModel } from "./openai-responses-contracts-QUY12X0B.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-BuSUaAk5.mjs";
+import { C as createOpenAIProviderAcceptanceHook, E as log, S as createModelStreamCooperativeScheduler, a as resolveOpenAIProjectedToolsStrictToolFlag, r as normalizeOpenAIStrictToolParameters, t as findOpenAIStrictToolProjectionDiagnostics, v as projectOpenAITools } from "./openai-tool-schema-_pTAJqKF.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-BaMbI1hr.mjs";
+import { D as resolveOpenAIModelReasoningEfforts, O as resolveOpenAIReasoningEffortForModel, b as RESPONSE_FAILED_NO_DETAILS_MESSAGE, g as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, h as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, j as supportsOpenAITemperature, m as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, n as isOpenAIResponsesCompactionOutput, p as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-BMVHFOtq.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/ai/src/transports/model-transport-debug.ts
 /**
@@ -67,19 +68,8 @@ function resolveReplayableResponsesMessageId(params) {
 //#region packages/ai/src/transports/openai-responses-compaction-replay.ts
 const OPENAI_RESPONSES_COMPACTION_SUPPRESSION_TYPE = "openai-responses-compaction-suppression";
 const OPENAI_RESPONSES_COMPACTION_SUPPRESSION_DATA = "rejected";
-function hashOptionalReplayContextValue(value) {
-	const normalized = value?.trim();
-	return normalized ? shortHash(normalized) : void 0;
-}
 function buildOpenAIResponsesReplayContext(model, options) {
-	return {
-		provider: model.provider,
-		api: model.api,
-		model: model.id,
-		baseUrlHash: hashOptionalReplayContextValue(model.baseUrl),
-		sessionHash: hashOptionalReplayContextValue(options?.sessionId),
-		authProfileHash: hashOptionalReplayContextValue(options?.authProfileId)
-	};
+	return buildProviderReplayContext(model, options);
 }
 function isOpenAIResponsesReplayContext(value) {
 	if (!isRecord(value)) return false;
@@ -94,10 +84,7 @@ function isOpenAIResponsesCompactionState(state) {
 function readOpenAIResponsesCompactionReplayState(value) {
 	return isRecord(value) && isOpenAIResponsesReplayContext(value) && isOpenAIResponsesCompactionState(value) ? value : void 0;
 }
-function openAIResponsesReplayContextMatches(state, context) {
-	return state.provider === context.provider && state.api === context.api && state.model === context.model && state.baseUrlHash === context.baseUrlHash && state.sessionHash === context.sessionHash && state.authProfileHash === context.authProfileHash;
-}
-function captureOpenAIResponsesCompaction(output, item, boundary, model, captureMetadata) {
+function captureOpenAIResponsesCompaction(output, item, boundary, model, captureMetadata, compactedOutput) {
 	const metadata = captureMetadata ?? buildOpenAIResponsesReasoningReplayMetadata(model);
 	if (!item.encrypted_content) return;
 	if (!metadata?.baseUrlHash) {
@@ -106,19 +93,28 @@ function captureOpenAIResponsesCompaction(output, item, boundary, model, capture
 	}
 	const currentReplay = readOpenAIResponsesCompactionReplayState(output.providerReplay);
 	if (typeof boundary === "number" && currentReplay?.type === "openai-responses-compaction" && (currentReplay.replayIndex ?? -1) > boundary) return;
-	output.providerReplay = {
+	if (compactedOutput && !isOpenAIResponsesCompactionOutput(compactedOutput, model)) throw new Error("Responses compact endpoint checkpoint is invalid");
+	const replay = {
 		v: 1,
-		type: boundary === "retained-users" ? OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE : OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE,
+		...boundary === "retained-users" ? { type: OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE } : {
+			type: OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE,
+			replayIndex: boundary
+		},
 		...item.id ? { id: item.id } : {},
 		data: item.encrypted_content,
-		...typeof boundary === "number" ? { replayIndex: boundary } : {},
 		provider: metadata.provider,
 		api: metadata.api,
 		model: metadata.model,
 		baseUrlHash: metadata.baseUrlHash,
 		...metadata.sessionHash ? { sessionHash: metadata.sessionHash } : {},
-		...metadata.authProfileHash ? { authProfileHash: metadata.authProfileHash } : {}
+		...metadata.authProfileHash ? { authProfileHash: metadata.authProfileHash } : {},
+		...compactedOutput ? { compactedWindow: {
+			state: "ready",
+			output: JSON.stringify(compactedOutput)
+		} } : {}
 	};
+	if (compactedOutput && !readOpenAIResponsesCompactionWindow(replay, model)) throw new Error("Responses compact endpoint checkpoint is invalid or exceeds 16 MiB");
+	output.providerReplay = replay;
 }
 function suppressOpenAIResponsesCompaction(output, model, options, rejectedCheckpoint) {
 	const context = buildOpenAIResponsesReplayContext(model, options);
@@ -159,14 +155,29 @@ function resolveNewestOpenAIResponsesCompactionReplay(messages, model, options)
 		if (message?.role !== "assistant") continue;
 		const replay = readOpenAIResponsesCompactionReplayState(message.providerReplay);
 		if (replay?.type === OPENAI_RESPONSES_COMPACTION_SUPPRESSION_TYPE) {
-			if (openAIResponsesReplayContextMatches(replay, context)) return;
+			if (providerReplayContextMatches(replay, context)) return;
 			continue;
 		}
 		if (replay?.type !== "openai-responses-compaction" && replay?.type !== "openai-responses-retained-compaction") {
 			if (message.providerReplay?.type === "openai-responses-compaction" || message.providerReplay?.type === "openai-responses-retained-compaction") return;
 			continue;
 		}
-		if (!openAIResponsesReplayContextMatches(replay, context)) return;
+		if (!providerReplayContextMatches(replay, context)) return;
+		if (replay.compactedWindow !== void 0 || replay.type === "openai-responses-retained-compaction") {
+			const output = readOpenAIResponsesCompactionWindow(replay, model);
+			const item = output?.at(-1);
+			if (!output || item?.type !== "compaction") return {
+				owner: message,
+				mode: "refresh-required"
+			};
+			return {
+				owner: message,
+				mode: "complete-window",
+				output,
+				item,
+				replayIndex: replay.type === "openai-responses-retained-compaction" ? message.content.length : replay.replayIndex ?? 0
+			};
+		}
 		return {
 			owner: message,
 			item: {
@@ -174,13 +185,17 @@ function resolveNewestOpenAIResponsesCompactionReplay(messages, model, options)
 				...isSafeResponsesReplayItemId(replay.id) ? { id: replay.id } : {},
 				encrypted_content: replay.data
 			},
-			...replay.type === "openai-responses-retained-compaction" ? { mode: "retained-users" } : {
-				mode: "compacted-prefix",
-				replayIndex: replay.replayIndex ?? 0
-			}
+			mode: "compacted-prefix",
+			replayIndex: replay.replayIndex ?? 0
 		};
 	}
 }
+var CompactionReplayRefreshRequiredError = class extends Error {
+	constructor() {
+		super("Provider compaction checkpoint needs rebuilding. Run /compact to rebuild from saved conversation history.");
+		this.name = "CompactionReplayRefreshRequiredError";
+	}
+};
 function buildOpenAIResponsesCompactionReplayPlan(messages, model, options) {
 	if (options?.mode === "full-history") return {
 		messages,
@@ -191,22 +206,14 @@ function buildOpenAIResponsesCompactionReplayPlan(messages, model, options) {
 		messages,
 		preserveUnframedToolResults: false
 	};
+	if (compaction.mode === "refresh-required") throw new CompactionReplayRefreshRequiredError();
 	const ownerIndex = messages.indexOf(compaction.owner);
-	const collectRetainedUserMessages = (prefix) => {
-		const previous = resolveNewestOpenAIResponsesCompactionReplay(prefix, model, options);
-		if (!previous) return prefix.filter((message) => message.role === "user");
-		const previousOwnerIndex = prefix.indexOf(previous.owner);
-		const laterUsers = prefix.slice(previousOwnerIndex + 1).filter((message) => message.role === "user");
-		return previous.mode === "retained-users" ? [...collectRetainedUserMessages(prefix.slice(0, previousOwnerIndex)), ...laterUsers] : laterUsers;
-	};
-	const retainedMessages = compaction.mode === "retained-users" ? collectRetainedUserMessages(messages.slice(0, ownerIndex)) : void 0;
 	return {
 		messages: [{
 			...compaction.owner,
-			content: compaction.mode === "retained-users" ? [] : compaction.owner.content.slice(compaction.replayIndex)
+			content: compaction.owner.content.slice(compaction.replayIndex)
 		}, ...messages.slice(ownerIndex + 1)],
-		...retainedMessages?.length ? { retainedMessages } : {},
-		compaction: compaction.item,
+		...compaction.mode === "complete-window" ? { compactedWindow: compaction.output } : { compaction: compaction.item },
 		preserveUnframedToolResults: true
 	};
 }
@@ -218,6 +225,63 @@ function buildOpenAIResponsesReasoningReplayMetadata(model, options) {
 	};
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-input-replay.ts
+function recordResponsesInputReplay(message, replay) {
+	if (replay) Object.assign(message, { openclawResponsesInputReplay: replay });
+}
+function readResponsesInputReplay(message) {
+	const replay = "openclawResponsesInputReplay" in message ? message.openclawResponsesInputReplay : void 0;
+	if (isRecord(replay) && typeof replay.afterResponseId === "string" && Array.isArray(replay.before) && replay.before.every((item) => typeof item === "string") && Array.isArray(replay.after) && replay.after.every((item) => typeof item === "string")) return {
+		afterResponseId: replay.afterResponseId,
+		before: replay.before,
+		after: replay.after
+	};
+}
+function responsesInputFingerprint(item) {
+	if (isRecord(item) && (item.type === "function_call_output" || item.type === "custom_tool_call_output") && typeof item.call_id === "string") return sha256Hex(stableStringify({
+		type: item.type,
+		call_id: item.call_id
+	}));
+	return sha256Hex(stableStringify(item));
+}
+/** Reconstruct delivery order without rewriting durable local completion events. */
+function createResponsesInputReplay(model) {
+	const starts = /* @__PURE__ */ new Map();
+	const ends = /* @__PURE__ */ new Map();
+	const fingerprints = /* @__PURE__ */ new Map();
+	const fingerprint = (item) => {
+		const value = fingerprints.get(item) ?? responsesInputFingerprint(item);
+		fingerprints.set(item, value);
+		return value;
+	};
+	return (input, output, message) => {
+		const key = message.turnId || message.responseId;
+		const start = (key ? starts.get(key) : void 0) ?? output[0];
+		if (key && start) starts.set(key, start);
+		input.push(...output);
+		let end = input.at(-1);
+		const replay = readResponsesInputReplay(message);
+		const parent = replay ? ends.get(replay.afterResponseId) : void 0;
+		if (replay && parent && message.provider === model.provider && message.api === model.api && message.model === model.id) {
+			const take = (keys) => {
+				const moved = [];
+				for (const inputKey of keys.toReversed()) {
+					const boundary = input.indexOf(parent);
+					const index = input.findLastIndex((item, position) => position > boundary && fingerprint(item) === inputKey);
+					if (index > boundary) moved.unshift(...input.splice(index, 1));
+				}
+				return moved;
+			};
+			const before = take(replay.before);
+			const after = take(replay.after);
+			input.splice(start ? input.indexOf(start) : input.length, 0, ...before);
+			end = input.at(-1);
+			input.push(...after);
+		}
+		if (message.responseId && end) ends.set(message.responseId, end);
+	};
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-replay-messages-internal.ts
 function stripEncryptedReasoningContentFields(value) {
 	if (!value || typeof value !== "object") return {
@@ -287,7 +351,7 @@ function prepareOpenAIResponsesReasoningItemForReplay(item, context, blockMetada
 	const { [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: rawMetadata, ...rest } = record;
 	if (!("encrypted_content" in rest)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
 	const metadata = blockMetadata !== void 0 ? blockMetadata ?? void 0 : isOpenAIResponsesReasoningReplayMetadata(rawMetadata) ? rawMetadata : void 0;
-	if (blockMetadata === void 0 && !hasRawMetadata && options?.preserveUnattributedEncryptedContent === true || metadata && openAIResponsesReplayContextMatches(metadata, context)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
+	if (blockMetadata === void 0 && !hasRawMetadata && options?.preserveUnattributedEncryptedContent === true || metadata && providerReplayContextMatches(metadata, context)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
 	return normalizeOpenAIResponsesReasoningReplayItem(stripEncryptedReasoningContentFields(rest).value);
 }
 function normalizeResponsesReplayItemId(id, prefix) {
@@ -302,6 +366,41 @@ function encodeTextSignatureV1(id, phase) {
 		...phase ? { phase } : {}
 	});
 }
+function orderResponsesAsyncToolResults(source) {
+	const turnKey = (message) => {
+		const id = message.turnId || message.responseId;
+		return id ? `${message.provider}:${message.api}:${message.model}:${id}` : void 0;
+	};
+	const lastAssistant = /* @__PURE__ */ new Map();
+	for (const [index, message] of source.entries()) if (message.role === "assistant") {
+		const key = turnKey(message);
+		if (key) lastAssistant.set(key, index);
+	}
+	const owners = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const ordered = [];
+	for (const [index, message] of source.entries()) {
+		if (message.role === "assistant") {
+			const key = turnKey(message);
+			if (key) {
+				for (const block of message.content) if (block.type === "toolCall" && block.async) owners.set(block.id, key);
+			}
+		}
+		const owner = message.role === "toolResult" ? owners.get(message.toolCallId) : void 0;
+		const lastIndex = owner ? lastAssistant.get(owner) : void 0;
+		if (lastIndex !== void 0 && lastIndex > index) {
+			const results = pending.get(lastIndex) ?? [];
+			results.push(message);
+			pending.set(lastIndex, results);
+		} else ordered.push(message);
+		const results = pending.get(index);
+		if (results) {
+			ordered.push(...results);
+			pending.delete(index);
+		}
+	}
+	return ordered;
+}
 function parseOpenAIResponsesTextSignature(signature) {
 	if (!signature) return;
 	if (signature.startsWith("{")) try {
@@ -397,40 +496,52 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 		normalizeSameModelToolCallIds: shouldNormalizeSameModelToolCallIds,
 		preserveUnframedToolResults: replayPlan.preserveUnframedToolResults
 	});
-	const transformedMessages = transformMessages(replayPlan.messages);
-	const transformedRetainedMessages = replayPlan.retainedMessages ? transformMessages(replayPlan.retainedMessages) : [];
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && (providerStyle ? model.compat?.supportsDeveloperRole !== false : options?.supportsDeveloperRole !== false) ? "developer" : "system", [{
+	const transformedMessages = orderResponsesAsyncToolResults(transformMessages(replayPlan.messages));
+	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && model.compat?.supportsDeveloperRole !== false ? "developer" : "system", [{
 		type: "input_text",
 		text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
 	}]));
-	const replayMessages = replayPlan.compaction ? [
-		...transformedRetainedMessages,
-		replayPlan.compaction,
-		...transformedMessages
-	] : transformedMessages;
+	if (replayPlan.compactedWindow) messages.push(...replayPlan.compactedWindow);
+	let replayMessages = replayPlan.compaction ? [replayPlan.compaction, ...transformedMessages] : transformedMessages;
+	const isCarrier = (message) => "role" in message && message.role === "user" && message.runtimeContextCarrier === true;
+	if (replayMessages.some(isCarrier)) {
+		const anchored = [];
+		let insertionIndex = replayPlan.compactedWindow ? 0 : void 0;
+		for (const message of replayMessages) {
+			if (isCarrier(message) && insertionIndex !== void 0) {
+				anchored.splice(insertionIndex++, 0, message);
+				continue;
+			}
+			anchored.push(message);
+			if (!isCarrier(message) && ("role" in message ? message.role === "user" : message.type === "compaction")) insertionIndex = anchored.length;
+		}
+		replayMessages = anchored;
+	}
 	let msgIndex = 0;
+	const appendAssistant = createResponsesInputReplay(model);
 	for (const msg of replayMessages) {
 		if (!("role" in msg)) {
 			messages.push(msg);
 			continue;
 		}
-		if (msg.role === "user") if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
-			type: "input_text",
-			text: sanitizeTransportPayloadText(msg.content)
-		}]));
-		else {
-			const content = msg.content.map((item) => item.type === "text" ? {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
 				type: "input_text",
-				text: sanitizeTransportPayloadText(item.text)
-			} : {
-				type: "input_image",
-				detail: "auto",
-				image_url: `data:${item.mimeType};base64,${item.data}`
-			}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
-			if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
-			else if (providerStyle) continue;
-		}
-		else if (msg.role === "assistant") {
+				text: sanitizeTransportPayloadText(msg.content)
+			}]));
+			else {
+				const content = msg.content.map((item) => item.type === "text" ? {
+					type: "input_text",
+					text: sanitizeTransportPayloadText(item.text)
+				} : {
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
+				if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
+				else if (providerStyle) continue;
+			}
+		} else if (msg.role === "assistant") {
 			const output = [];
 			let textFallbackOrdinal = 0;
 			let previousReplayItemWasReasoning = false;
@@ -485,12 +596,18 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 					...itemId ? { id: itemId } : {},
 					call_id: callId,
 					name: block.name,
+					...block.async ? { async: true } : {},
 					arguments: providerStyle ? JSON.stringify(block.arguments) : typeof block.arguments === "string" ? block.arguments : JSON.stringify(block.arguments ?? {})
 				});
 				previousReplayItemWasReasoning = false;
 			}
-			if (output.length > 0) messages.push(...output);
-			else if (providerStyle) continue;
+			while (true) {
+				const last = output.at(-1);
+				if (last?.type !== "reasoning" || !last.id?.startsWith("rs_") || typeof last.encrypted_content === "string" && last.encrypted_content.length > 0) break;
+				output.pop();
+			}
+			appendAssistant(messages, output, msg);
+			if (output.length === 0 && providerStyle) continue;
 		} else if (msg.role === "toolResult") {
 			const textResult = extractToolResultText(msg.content);
 			const sanitizedTextResult = sanitizeTransportPayloadText(textResult);
@@ -592,84 +709,83 @@ async function resolveNextResponsesEncryptedContentAttempt(attempt, error, optio
 	};
 }
 async function createResponsesStreamWithEncryptedContentRetry(params) {
-	const sendAttempt = async (attempt) => {
-		const { data, response } = await params.client.responses.create(attempt.request, params.requestOptions).withResponse();
-		commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
-			if (checkpoint) params.onCompactionRejected?.(checkpoint);
-		});
-		if (!isAsyncIterable(data)) throw new Error("OpenAI Responses streaming request returned a non-stream response");
-		return {
-			stream: data,
-			response,
-			attempt
-		};
+	const send = async (initialAttempt) => {
+		let attempt = initialAttempt;
+		for (;;) {
+			params.observePrompt?.(attempt.request, {
+				egress: "responses-sdk",
+				payloadVariant: attempt.kind
+			});
+			try {
+				const { data, response } = await params.client.responses.create(attempt.request, params.requestOptions).withResponse();
+				commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
+					if (checkpoint) params.onCompactionRejected?.(checkpoint);
+				});
+				if (!isAsyncIterable(data)) throw new Error("OpenAI Responses streaming request returned a non-stream response");
+				return {
+					stream: data,
+					response,
+					attempt
+				};
+			} catch (error) {
+				let nextAttempt = await resolveNextResponsesEncryptedContentAttempt(attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest });
+				if (!nextAttempt && attempt.request.previous_response_id && error && typeof error === "object" && typeof error.status === "number" && error.code === "previous_response_not_found") {
+					const request = { ...params.buildFullHistoryRequest ? await params.buildFullHistoryRequest() : attempt.request };
+					delete request.previous_response_id;
+					nextAttempt = {
+						kind: "continuation-rejected",
+						request
+					};
+				}
+				if (!nextAttempt) throw error;
+				const retryDescription = nextAttempt.kind === "reasoning-stripped" ? "without encrypted reasoning content" : nextAttempt.kind === "compaction-stripped" ? "without encrypted compaction content" : "full history after rejected previous_response_id";
+				log.warn(`[responses] retrying ${retryDescription} provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+				attempt = nextAttempt;
+			}
+		}
 	};
-	let attempt = {
+	const result = await send({
 		kind: params.initialAttemptKind ?? "initial",
 		request: params.request,
 		...params.initialRejectedCompaction ? { rejectedCompaction: params.initialRejectedCompaction } : {}
-	};
-	while (true) {
-		params.observePrompt?.(attempt.request, {
-			egress: "responses-sdk",
-			payloadVariant: attempt.kind
-		});
-		try {
-			const result = await sendAttempt(attempt);
-			return {
-				...result,
-				stream: { async *[Symbol.asyncIterator]() {
-					let rejectedEvent;
-					try {
-						for await (const event of params.wrapStream?.(result) ?? result.stream) {
-							if (isRecord(event)) {
-								const failure = event.type === "response.failed" && isRecord(event.response) ? event.response.error : event.type === "error" ? event.error ?? event : void 0;
-								if (isRecord(failure) && params.canRetryStream?.() === true && isInvalidEncryptedContentError(failure)) {
-									rejectedEvent = event;
-									const message = typeof failure.message === "string" ? failure.message : "";
-									throw Object.assign(new Error(message), {
-										code: failure.code,
-										status: failure.status
-									});
-								}
+	});
+	return {
+		...result,
+		stream: { async *[Symbol.asyncIterator]() {
+			let current = result;
+			for (;;) {
+				let rejectedEvent;
+				try {
+					for await (const event of params.wrapStream?.(current) ?? current.stream) {
+						if (isRecord(event)) {
+							const failure = event.type === "response.failed" && isRecord(event.response) ? event.response.error : event.type === "error" ? event.error ?? event : void 0;
+							if (isRecord(failure) && params.canRetryStream?.() === true && isInvalidEncryptedContentError(failure)) {
+								rejectedEvent = event;
+								const message = typeof failure.message === "string" ? failure.message : "";
+								throw Object.assign(new Error(message), {
+									code: failure.code,
+									status: failure.status
+								});
 							}
-							yield event;
 						}
-					} catch (error) {
-						const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(result.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
-						if (!nextAttempt) {
-							if (rejectedEvent !== void 0) {
-								yield rejectedEvent;
-								return;
-							}
-							throw error;
+						yield event;
+					}
+					return;
+				} catch (error) {
+					const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(current.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
+					if (!nextAttempt) {
+						if (rejectedEvent !== void 0) {
+							yield rejectedEvent;
+							return;
 						}
-						log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
-						yield* (await createResponsesStreamWithEncryptedContentRetry({
-							...params,
-							request: nextAttempt.request,
-							initialAttemptKind: nextAttempt.kind,
-							initialRejectedCompaction: nextAttempt.rejectedCompaction
-						})).stream;
+						throw error;
 					}
-				} }
-			};
-		} catch (error) {
-			let nextAttempt = await resolveNextResponsesEncryptedContentAttempt(attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest });
-			if (!nextAttempt && attempt.request.previous_response_id && error && typeof error === "object" && typeof error.status === "number" && error.code === "previous_response_not_found") {
-				const request = { ...params.buildFullHistoryRequest ? await params.buildFullHistoryRequest() : attempt.request };
-				delete request.previous_response_id;
-				nextAttempt = {
-					kind: "continuation-rejected",
-					request
-				};
+					log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+					current = await send(nextAttempt);
+				}
 			}
-			if (!nextAttempt) throw error;
-			const retryDescription = nextAttempt.kind === "reasoning-stripped" ? "without encrypted reasoning content" : nextAttempt.kind === "compaction-stripped" ? "without encrypted compaction content" : "full history after rejected previous_response_id";
-			log.warn(`[responses] retrying ${retryDescription} provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
-			attempt = nextAttempt;
-		}
-	}
+		} }
+	};
 }
 function resolveAzureOpenAIApiVersion(env = process.env) {
 	return env.AZURE_OPENAI_API_VERSION?.trim() || "preview";
@@ -725,14 +841,14 @@ function createResponsesToolCallTracker() {
 		state.callId ??= identity.callId;
 		return state;
 	};
-	const resolveCompatible = (candidates, identity) => {
+	const resolveCompatible = (candidates, identity, allowUnmatchedIdentity) => {
 		const uniqueCandidates = [...new Set(candidates)];
-		if (!identity.itemId && !identity.callId) return uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
+		if (!identity.itemId && !identity.callId) return allowUnmatchedIdentity && uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
 		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
 		const matches = compatible.filter((state) => sharesIdentity(state, identity));
 		const matched = matches.length === 1 ? matches.at(0) : void 0;
 		if (matched) return adoptIdentity(matched, identity);
-		const soleCompatible = uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
+		const soleCompatible = allowUnmatchedIdentity && uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
 		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
 	};
 	return {
@@ -743,9 +859,10 @@ function createResponsesToolCallTracker() {
 				return;
 			}
 			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
+			state.outputIndex = outputIndex;
 			indexedCalls.set(outputIndex, state);
 		},
-		resolve(event, identity = readEventIdentity(event)) {
+		resolve(event, identity = readEventIdentity(event), allowUnmatchedIdentity = true) {
 			const outputIndex = readOutputIndex(event);
 			if (outputIndex !== void 0) {
 				const indexed = indexedCalls.get(outputIndex);
@@ -753,14 +870,15 @@ function createResponsesToolCallTracker() {
 					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
 					return adoptIdentity(indexed, identity);
 				}
-				const unindexed = resolveCompatible(unindexedCalls, identity);
+				const unindexed = resolveCompatible(unindexedCalls, identity, allowUnmatchedIdentity);
 				if (unindexed) {
 					unindexedCalls.delete(unindexed);
+					unindexed.outputIndex = outputIndex;
 					indexedCalls.set(outputIndex, unindexed);
 				}
 				return unindexed;
 			}
-			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity);
+			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity, allowUnmatchedIdentity);
 		},
 		forget(toolCall) {
 			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
@@ -771,6 +889,10 @@ function createResponsesToolCallTracker() {
 		},
 		hasActive() {
 			return indexedCalls.size > 0 || unindexedCalls.size > 0;
+		},
+		hasExactlyActive(expected) {
+			const active = /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls]);
+			return active.size === expected.length && expected.every((state) => active.has(state));
 		}
 	};
 }
@@ -896,9 +1018,10 @@ const RESPONSE_FAILED_FAILURE_FIELD_KEYS = [
 function readResponseFailedString(record, key) {
 	return stringifyUnknown(record?.[key]);
 }
-function buildResponsesFailedEventSummary(message, responseId, observation) {
+function buildResponsesFailedEventSummary(message, responseId, code, observation) {
 	const summary = { message };
 	if (responseId) summary.responseId = responseId;
+	if (code) summary.code = code;
 	if (observation) summary.observation = observation;
 	return summary;
 }
@@ -1017,11 +1140,11 @@ function normalizeResponsesFailedEvent(event, model) {
 	if (error) {
 		const code = readResponseFailedString(error, "code").trim();
 		const message = readResponseFailedString(error, "message").trim();
-		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId);
+		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId, code || void 0);
 	}
 	const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
 	if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
-	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, buildResponsesFailedNoDetailsObservation(event, model, response));
+	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, void 0, buildResponsesFailedNoDetailsObservation(event, model, response));
 }
 var ResponsesStreamFailure = class extends Error {
 	constructor(failure, response) {
@@ -1029,6 +1152,7 @@ var ResponsesStreamFailure = class extends Error {
 		this.name = "ResponsesStreamFailure";
 		this.responseId = failure.responseId;
 		this.response = response;
+		this.code = failure.code;
 		this.observation = failure.observation;
 	}
 };
@@ -1123,7 +1247,8 @@ function createResponsesOutputTracker() {
 	const outputs = /* @__PURE__ */ new Map();
 	const identity = (item) => {
 		if ((item.type === "reasoning" || item.type === "message") && item.id) return `${item.type}:${item.id}`;
-		return item.type === "function_call" ? `function_call:${item.call_id ?? item.id ?? ""}` : void 0;
+		const callId = item.call_id ?? item.id;
+		return item.type === "function_call" && callId ? `function_call:${callId}` : void 0;
 	};
 	const get = (item, outputIndex) => {
 		const key = identity(item);
@@ -1210,8 +1335,11 @@ function createResponsesOutputSlotTracker() {
 * package and managed transports from drifting on token buckets, service-tier pricing, or future
 * terminal-event semantics.
 */
+function readReportedCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
 function readCount(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+	return readReportedCount(value) ?? 0;
 }
 /**
 * Split a terminal usage payload into the priced buckets.
@@ -1229,12 +1357,21 @@ function mapResponsesTerminalUsage(usage) {
 	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
 	const output = readCount(usage.output_tokens);
 	const bucketTotal = input + output + cacheRead + cacheWrite;
+	const totalTokens = Math.max(bucketTotal, readCount(usage.total_tokens));
+	const reportedInput = readReportedCount(usage.input_tokens);
+	const reportedOutput = readReportedCount(usage.output_tokens);
+	const reportedTotal = readReportedCount(usage.total_tokens);
 	return {
 		input,
 		output,
 		cacheRead,
 		cacheWrite,
-		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
+		contextUsage: reportedInput !== void 0 && (reportedOutput !== void 0 || reportedTotal !== void 0 && reportedTotal >= reportedInput) && cacheRead + cacheWrite <= reportedInput ? {
+			state: "available",
+			promptTokens: reportedInput,
+			totalTokens: Math.max(totalTokens, reportedInput + (reportedOutput ?? 0))
+		} : { state: "unavailable" },
+		totalTokens
 	};
 }
 /** Reasoning tokens are reported by the agent path only; the package path does not track them. */
@@ -1392,30 +1529,34 @@ function createResponsesTerminalController(params) {
 		});
 		return index;
 	};
-	const appendToolCall = (item) => {
-		const validated = resolveCompletedResponsesToolCall(item);
-		const toolCall = {
+	const emitToolCallCompletion = (item, outputIndex, started, validated) => {
+		const completed = {
+			id: resolveResponsesToolCallId(item, started?.block.id),
+			...validated
+		};
+		const toolCall = started ? Object.assign(started.block, completed) : {
 			type: "toolCall",
-			id: resolveResponsesToolCallId(item),
-			name: validated.name,
-			arguments: validated.arguments
+			...completed
 		};
-		blocks.push(toolCall);
-		const contentIndex = blocks.length - 1;
-		stream.push({
-			type: "toolcall_start",
-			contentIndex,
-			partial: output
-		});
+		delete toolCall.partialJson;
+		const contentIndex = started?.contentIndex ?? blocks.length;
+		if (!started) {
+			blocks.push(toolCall);
+			stream.push({
+				type: "toolcall_start",
+				contentIndex,
+				partial: output
+			});
+		}
+		params.outputs.set(item, contentIndex, outputIndex, true);
 		stream.push({
 			type: "toolcall_end",
 			contentIndex,
 			toolCall,
 			partial: output
 		});
-		return contentIndex;
 	};
-	const recoverTerminalOutput = (items, includeToolCalls) => {
+	const recoverTerminalOutput = (items, completeToolCall) => {
 		let hasCompletedLaterOutput = false;
 		for (const [outputIndex, item] of [...items.entries()].toReversed()) {
 			const tracked = params.outputs.get(item, outputIndex);
@@ -1428,9 +1569,8 @@ function createResponsesTerminalController(params) {
 				hasCompletedLaterOutput = true;
 				continue;
 			}
-			if (item.type === "function_call" && !includeToolCalls) continue;
+			if (item.type === "function_call" && !completeToolCall) continue;
 			if (hasCompletedLaterOutput) throw new Error("Responses stream omitted an output item before completed output");
-			if (item.type === "function_call") resolveCompletedResponsesToolCall(item);
 		}
 		for (const [terminalIndex, item] of items.entries()) if (item.type === "message") {
 			const tracked = params.outputs.get(item, terminalIndex);
@@ -1451,9 +1591,9 @@ function createResponsesTerminalController(params) {
 					}
 				}
 				captureOpenAIResponsesCompaction(output, item, replayIndex, model, options?.reasoningReplayMetadata);
-			} else if (includeToolCalls && item.type === "function_call") {
-				if (params.outputs.get(item, terminalIndex)) continue;
-				params.outputs.set(item, appendToolCall(item), terminalIndex, true);
+			} else if (completeToolCall && item.type === "function_call") {
+				if (params.outputs.get(item, terminalIndex)?.completed) continue;
+				completeToolCall(terminalIndex);
 			}
 		}
 	};
@@ -1480,7 +1620,6 @@ function createResponsesTerminalController(params) {
 		}
 	};
 	const finalizeResponse = (response, terminalEventType) => {
-		params.markFinalized();
 		backfillReasoning(response.output ?? []);
 		finalizeTerminalFacts(response);
 		const terminal = resolveResponsesTerminalStopReason({
@@ -1495,7 +1634,8 @@ function createResponsesTerminalController(params) {
 	return {
 		finalizeResponse,
 		finalizeFailedResponse: finalizeTerminalFacts,
-		recoverTerminalOutput
+		recoverTerminalOutput,
+		emitToolCallCompletion
 	};
 }
 //#endregion
@@ -1505,6 +1645,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	const outputSlots = createResponsesOutputSlotTracker();
 	const outputs = createResponsesOutputTracker();
 	let terminalResponse;
+	let incompleteToolCall;
 	let lastTextBlock = null;
 	const blocks = output.content;
 	const compactionTracker = createCompactionTracker(output, model, options);
@@ -1594,7 +1735,27 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	const materializeDeferredTextSlots = (except) => {
 		for (const slot of outputSlots.values()) if (slot !== except && slot.type === "text") materializeDeferredTextSlot(slot);
 	};
-	const { finalizeResponse, finalizeFailedResponse, recoverTerminalOutput } = createResponsesTerminalController({
+	const appendThinkingDelta = (slot, delta) => {
+		slot.block.thinking += delta;
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta,
+			partial: output
+		});
+	};
+	const projectTextDelta = (slot, delta) => {
+		if (slot.pendingText !== null) appendResponsesPendingTextDelta(slot, delta, materializeDeferredTextSlot);
+		else if (slot.block && slot.contentIndex !== void 0) {
+			slot.block.text += delta;
+			stream.push({
+				type: "text_delta",
+				contentIndex: slot.contentIndex,
+				delta
+			});
+		}
+	};
+	const terminal = createResponsesTerminalController({
 		output,
 		stream,
 		model,
@@ -1603,9 +1764,52 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		getLastTextBlock: () => lastTextBlock,
 		setLastTextBlock: (block) => {
 			lastTextBlock = block;
-		},
-		markFinalized: () => void 0
+		}
 	});
+	const finalizeToolCall = (item, outputIndex, streamingToolCall, validated) => {
+		const identity = {
+			type: item.type,
+			id: item.id || streamingToolCall?.itemId,
+			call_id: item.call_id || streamingToolCall?.callId
+		};
+		const finalOutputIndex = outputIndex ?? streamingToolCall?.outputIndex;
+		if (finalOutputIndex === void 0 && !identity.id && !identity.call_id) {
+			if (!streamingToolCall) throw new Error("Responses stream completed tool call without an output identity");
+			return;
+		}
+		if (streamingToolCall) {
+			streamingToolCalls.forget(streamingToolCall);
+			for (const slot of outputSlots.values()) if (slot.type === "toolCall" && slot.toolCall === streamingToolCall) outputSlots.forget(slot);
+		}
+		terminal.emitToolCallCompletion(identity, finalOutputIndex, streamingToolCall, {
+			...validated,
+			...options?.asyncToolExecution && isRecord(item) && item.async === true ? { async: true } : {}
+		});
+	};
+	const prepareTerminalToolCalls = (items) => {
+		const prepared = /* @__PURE__ */ new Map();
+		const recovered = [];
+		const callIds = /* @__PURE__ */ new Set();
+		const allowUnmatchedIdentity = items.filter((item, index) => item.type === "function_call" && !outputs.get(item, index)?.completed).length === 1;
+		for (const [outputIndex, item] of items.entries()) {
+			const tracked = outputs.get(item, outputIndex);
+			if (item.type !== "function_call") continue;
+			if (item.call_id && callIds.has(item.call_id)) throw new Error("Responses stream repeated a terminal tool-call identity");
+			if (item.call_id) callIds.add(item.call_id);
+			if (tracked?.completed) continue;
+			const state = streamingToolCalls.resolve({ output_index: outputIndex }, readResponsesToolCallItemIdentity(item), allowUnmatchedIdentity);
+			if (tracked && !state) throw new Error("Responses stream completed with unresolved tool calls");
+			const validated = resolveCompletedResponsesToolCall(item, { name: state?.block.name });
+			if (state) recovered.push(state);
+			prepared.set(outputIndex, () => finalizeToolCall(item, outputIndex, state, validated));
+		}
+		if (!streamingToolCalls.hasExactlyActive(recovered)) throw new Error("Responses stream completed with unresolved tool calls");
+		return (outputIndex) => {
+			const complete = prepared.get(outputIndex);
+			if (!complete) throw new Error("Responses stream completed with unresolved tool calls");
+			complete();
+		};
+	};
 	const guardedStream = adaptResponsesStream(withFirstStreamEventTimeout(openaiStream, {
 		provider: model.provider,
 		api: model.api,
@@ -1619,6 +1823,8 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	try {
 		for await (const event of guardedStream) {
 			notifyLlmRequestActivity(options?.signal);
+			if (event.type === "response.output_item.done" && event.item.type === "function_call" && event.item.status === "incomplete") incompleteToolCall ??= event.item;
+			if (incompleteToolCall && event.type !== "response.completed" && event.type !== "response.incomplete" && event.type !== "response.failed" && event.type !== "error") continue;
 			if (event.type === "response.created") output.responseId = event.response.id;
 			else if (event.type === "response.output_item.added") {
 				materializeDeferredTextSlots();
@@ -1666,38 +1872,20 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				slot.item.summary = slot.item.summary || [];
 				const lastPart = slot.item.summary[slot.item.summary.length - 1];
 				if (!lastPart) continue;
-				slot.block.thinking += event.delta;
 				lastPart.text += event.delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: slot.contentIndex,
-					delta: event.delta,
-					partial: output
-				});
+				appendThinkingDelta(slot, event.delta);
 			} else if (event.type === "response.reasoning_summary_part.done") {
 				const slot = outputSlots.resolve(event, "thinking");
 				if (!slot) continue;
 				slot.item.summary = slot.item.summary || [];
 				const lastPart = slot.item.summary[slot.item.summary.length - 1];
 				if (!lastPart) continue;
-				slot.block.thinking += "\n\n";
 				lastPart.text += "\n\n";
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: slot.contentIndex,
-					delta: "\n\n",
-					partial: output
-				});
+				appendThinkingDelta(slot, "\n\n");
 			} else if (event.type === "response.reasoning_text.delta") {
 				const slot = outputSlots.resolve(event, "thinking");
 				if (!slot) continue;
-				slot.block.thinking += event.delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: slot.contentIndex,
-					delta: event.delta,
-					partial: output
-				});
+				appendThinkingDelta(slot, event.delta);
 			} else if (event.type === "response.content_part.added") {
 				const slot = outputSlots.resolve(event, "text");
 				if (!slot) continue;
@@ -1717,15 +1905,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					slot.item.content.push(lastPart);
 				}
 				lastPart.text += event.delta;
-				if (slot.pendingText !== null) appendResponsesPendingTextDelta(slot, event.delta, materializeDeferredTextSlot);
-				else if (slot.block && slot.contentIndex !== void 0) {
-					slot.block.text += event.delta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: slot.contentIndex,
-						delta: event.delta
-					});
-				}
+				projectTextDelta(slot, event.delta);
 			} else if (isAzureResponsesTextDeltaEvent(event)) {
 				const slot = outputSlots.resolve(event, "text");
 				if (!slot) continue;
@@ -1739,15 +1919,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					slot.item.content.push(lastPart);
 				}
 				lastPart.text += event.delta;
-				if (slot.pendingText !== null) appendResponsesPendingTextDelta(slot, event.delta, materializeDeferredTextSlot);
-				else if (slot.block && slot.contentIndex !== void 0) {
-					slot.block.text += event.delta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: slot.contentIndex,
-						delta: event.delta
-					});
-				}
+				projectTextDelta(slot, event.delta);
 			} else if (event.type === "response.refusal.delta") {
 				const slot = outputSlots.resolve(event, "text");
 				if (!slot) continue;
@@ -1761,15 +1933,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					slot.item.content.push(lastPart);
 				}
 				lastPart.refusal += event.delta;
-				if (slot.pendingText !== null) appendResponsesPendingTextDelta(slot, event.delta, materializeDeferredTextSlot);
-				else if (slot.block && slot.contentIndex !== void 0) {
-					slot.block.text += event.delta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: slot.contentIndex,
-						delta: event.delta
-					});
-				}
+				projectTextDelta(slot, event.delta);
 			} else if (event.type === "response.function_call_arguments.delta") {
 				const toolCall = streamingToolCalls.resolve(event);
 				if (toolCall) {
@@ -1881,64 +2045,36 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					}
 					outputSlots.forget(outputSlot);
 				} else if (item.type === "function_call") {
+					if (outputs.get(item, readResponsesOutputIndex(event))?.completed) continue;
 					const streamingToolCall = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
 					if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
-					const streamedArguments = streamingToolCall?.block.partialJson ?? "";
 					const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
 					if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
-					const finalArguments = completedArguments !== void 0 && (completedArguments.length > 0 || !streamedArguments) ? completedArguments : streamedArguments;
 					const validated = resolveCompletedResponsesToolCall(item, {
 						name: streamingToolCall?.block.name,
-						arguments: finalArguments
+						arguments: completedArguments || streamingToolCall?.block.partialJson || ""
 					});
-					let toolCall;
-					let contentIndex;
-					if (streamingToolCall) {
-						const block = streamingToolCall.block;
-						block.id = resolveResponsesToolCallId(item, block.id);
-						block.name = validated.name;
-						block.arguments = validated.arguments;
-						delete block.partialJson;
-						toolCall = block;
-						contentIndex = streamingToolCall.contentIndex;
-					} else {
-						toolCall = {
-							type: "toolCall",
-							id: resolveResponsesToolCallId(item),
-							name: validated.name,
-							arguments: validated.arguments
-						};
-						blocks.push(toolCall);
-						contentIndex = blocks.length - 1;
-						stream.push({
-							type: "toolcall_start",
-							contentIndex,
-							partial: output
-						});
-					}
-					if (streamingToolCall) {
-						streamingToolCalls.forget(streamingToolCall);
-						for (const slot of outputSlots.values()) if (slot.type === "toolCall" && slot.toolCall === streamingToolCall) outputSlots.forget(slot);
-					}
-					stream.push({
-						type: "toolcall_end",
-						contentIndex,
-						toolCall,
-						partial: output
-					});
-					outputs.set(item, contentIndex, readResponsesOutputIndex(event), true);
+					finalizeToolCall(item, readResponsesOutputIndex(event), streamingToolCall, validated);
 				}
 			} else if (event.type === "response.completed" || event.type === "response.incomplete") {
-				if (streamingToolCalls.hasActive()) throw new Error("Responses stream completed with unresolved tool calls");
-				finalizeResponse(event.response, event.type);
-				if (event.type === "response.completed" || output.stopReason === "length") recoverTerminalOutput(event.response.output ?? [], event.type === "response.completed");
+				terminal.finalizeResponse(event.response, event.type);
+				if (incompleteToolCall) {
+					if (output.errorMessage) throw new Error(output.errorMessage);
+					resolveCompletedResponsesToolCall(incompleteToolCall);
+				}
+				if (event.type === "response.incomplete" && streamingToolCalls.hasActive()) throw new Error(output.errorMessage ?? "Responses stream completed with unresolved tool calls");
+				if (event.type === "response.completed" || output.stopReason === "length") {
+					const items = event.response.output ?? [];
+					const completeToolCall = event.type === "response.completed" ? prepareTerminalToolCalls(items) : void 0;
+					terminal.recoverTerminalOutput(items, completeToolCall);
+				}
 				terminalResponse = event.type === "response.completed" ? event.response : null;
 				if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
 				break;
 			} else if (event.type === "error") throw new Error(event.message ? `Error Code ${event.code}: ${event.message}` : "Unknown error");
 			else if (event.type === "response.failed") {
 				const failure = normalizeResponsesFailedEvent(isRecord(event) ? event : {}, model);
-				finalizeFailedResponse(event.response, failure.responseId);
+				terminal.finalizeFailedResponse(event.response, failure.responseId);
 				throw new ResponsesStreamFailure(failure, event.response);
 			}
 		}
@@ -2019,9 +2155,6 @@ function shouldLogStrictToolDowngradeDiagnostic(diagnostics, model) {
 }
 //#endregion
 //#region packages/ai/src/providers/openai-responses-shared.ts
-function isResponsesReasoningEffort(effort) {
-	return effort === "minimal" || effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh" || effort === "max";
-}
 function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
 	return convertProviderResponsesMessages(model, context, allowedToolCallProviders, options);
 }
@@ -2038,17 +2171,17 @@ function applyResponsesServiceTierPricing(usage, serviceTier, model) {
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 }
 function resolveResponsesReasoningEffort(model, reasoning) {
-	const clampedReasoning = reasoning ? clampThinkingLevel(model, reasoning) : void 0;
-	if (!clampedReasoning || clampedReasoning === "off") return;
-	if (clampedReasoning === "max") return supportsOpenAIReasoningEffort(model, "max") ? "max" : "xhigh";
-	if (clampedReasoning === "minimal" && model.provider === "openai" && supportsOpenAIReasoningEffort(model, "max")) {
-		const effort = resolveOpenAIReasoningEffortForModel({
-			model,
-			effort: "minimal"
-		});
-		return isResponsesReasoningEffort(effort) ? effort : void 0;
-	}
-	return clampedReasoning;
+	if (!reasoning) return;
+	const clampedReasoning = model.reasoning && model.thinkingLevelMap?.[reasoning] === void 0 && resolveOpenAIModelReasoningEfforts(model)?.includes(reasoning) ? reasoning : clampThinkingLevel(model, reasoning);
+	return clampedReasoning === "off" ? void 0 : clampedReasoning;
+}
+function resolveResponsesRequestReasoningEffort(model, reasoning) {
+	const mapped = model.thinkingLevelMap?.[reasoning === "none" ? "off" : reasoning];
+	if (mapped !== void 0) return mapped ?? void 0;
+	return resolveOpenAIModelReasoningEfforts(model) === void 0 ? reasoning === "off" ? "none" : reasoning : resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: reasoning
+	});
 }
 function applyCommonResponsesParams(params, model, context, options, config) {
 	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
@@ -2058,19 +2191,20 @@ function applyCommonResponsesParams(params, model, context, options, config) {
 		if (converted.tools.length > 0) params.tools = converted.tools;
 	}
 	if (!model.reasoning) return;
+	const requestedEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : config?.setDefaultReasoningOff ?? true ? "off" : void 0);
+	const effort = requestedEffort === void 0 ? void 0 : resolveResponsesRequestReasoningEffort(model, requestedEffort);
+	if (effort === void 0) return;
+	params.reasoning = { effort };
 	if (options?.reasoningEffort || options?.reasoningSummary) {
-		params.reasoning = {
-			effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium",
-			summary: options?.reasoningSummary || "auto"
-		};
+		params.reasoning.summary = options?.reasoningSummary || "auto";
 		params.include = ["reasoning.encrypted_content"];
-	} else if ((config?.setDefaultReasoningOff ?? true) && model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+	}
 }
 function buildResponsesRequestOptions(options) {
 	return {
 		...options?.signal ? { signal: options.signal } : {},
 		...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-		maxRetries: options?.maxRetries ?? 0
+		maxRetries: 0
 	};
 }
 function cleanStreamingScratchBuffers(output) {
@@ -2137,27 +2271,22 @@ async function runResponsesStreamLifecycle(params) {
 				authProfileId: options?.authProfileId
 			})
 		});
-		if (options?.signal?.aborted) throw transportAbortError(options.signal);
-		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
-		stream.push({
-			type: "done",
-			reason: output.stopReason,
-			message: output
+		finalizeTransportStream({
+			stream,
+			output,
+			signal: options?.signal
 		});
-		stream.end();
 	} catch (error) {
-		cleanStreamingScratchBuffers(output);
-		const terminal = projectProviderError(error, options?.signal);
-		Object.assign(output, terminal);
-		stream.push({
-			type: "error",
-			reason: terminal.stopReason,
-			error: output
+		failTransportStream({
+			stream,
+			output,
+			signal: options?.signal,
+			error,
+			cleanup: () => cleanStreamingScratchBuffers(output)
 		});
-		stream.end();
 	} finally {
 		firstEventAbort?.dispose();
 	}
 }
 //#endregion
-export { isAzureResponsesTextDeltaEvent as A, buildResponsesInputMessage as B, summarizeResponsesTools as C, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as D, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as E, commitResponsesEncryptedContentAttempt as F, suppressOpenAIResponsesCompaction as G, createOpenAIResponsesAssistantOutput as H, createResponsesStreamWithEncryptedContentRetry as I, resolveModelPayloadDebugMode as J, resolveReplayableResponsesMessageId as K, isInvalidEncryptedContentError as L, isResponsesTextContentPartType as M, isResponsesTextDeltaEventType as N, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as O, resolveResponsesMessageSnapshotCollapse as P, resolveAzureOpenAIApiVersion as R, summarizeResponsesPayload as S, readResponsesToolCallItemIdentity as T, buildOpenAIResponsesReasoningReplayMetadata as U, convertResponsesMessages$1 as V, captureOpenAIResponsesCompaction as W, resolveModelSseDebugMode as Y, safeDebugValue as _, resolveResponsesReasoningEffort as a, summarizeOpenAITransportError as b, processResponsesStream as c, resolveResponsesTerminalStopReason as d, observeResponsesStream as f, normalizeResponsesFailedEvent as g, logResponsesFailedNoDetails as h, createResponsesAssistantOutput as i, isAzureResponsesTextDeltaEventType as j, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as k, mapResponsesTerminalUsage as l, buildResponsesFailedNoDetailsObservation as m, applyResponsesServiceTierPricing as n, runResponsesStreamLifecycle as o, ResponsesStreamFailure as p, emitModelTransportDebug as q, convertResponsesMessages as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, readResponsesReasoningTokens as u, stringifyRedactedEvent as v, createResponsesToolCallTracker as w, summarizeResponsesFailedNoDetailsObservation as x, stringifyRedactedPayload as y, resolveNextResponsesEncryptedContentAttempt as z };
+export { resolveModelPayloadDebugMode as $, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as A, resolveNextResponsesEncryptedContentAttempt as B, summarizeResponsesPayload as C, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as D, readResponsesToolCallItemIdentity as E, resolveResponsesMessageSnapshotCollapse as F, responsesInputFingerprint as G, convertResponsesMessages$1 as H, commitResponsesEncryptedContentAttempt as I, captureOpenAIResponsesCompaction as J, CompactionReplayRefreshRequiredError as K, createResponsesStreamWithEncryptedContentRetry as L, isAzureResponsesTextDeltaEventType as M, isResponsesTextContentPartType as N, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as O, isResponsesTextDeltaEventType as P, emitModelTransportDebug as Q, isInvalidEncryptedContentError as R, summarizeResponsesFailedNoDetailsObservation as S, createResponsesToolCallTracker as T, createOpenAIResponsesAssistantOutput as U, buildResponsesInputMessage as V, recordResponsesInputReplay as W, suppressOpenAIResponsesCompaction as X, resolveNewestOpenAIResponsesCompactionReplay as Y, resolveReplayableResponsesMessageId as Z, normalizeResponsesFailedEvent as _, resolveResponsesReasoningEffort as a, stringifyRedactedPayload as b, convertResponsesToolPayload as c, readResponsesReasoningTokens as d, resolveModelSseDebugMode as et, resolveResponsesTerminalStopReason as f, logResponsesFailedNoDetails as g, buildResponsesFailedNoDetailsObservation as h, createResponsesAssistantOutput as i, isAzureResponsesTextDeltaEvent as j, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as k, processResponsesStream as l, ResponsesStreamFailure as m, applyResponsesServiceTierPricing as n, resolveResponsesRequestReasoningEffort as o, observeResponsesStream as p, buildOpenAIResponsesReasoningReplayMetadata as q, convertResponsesMessages as r, runResponsesStreamLifecycle as s, applyCommonResponsesParams as t, mapResponsesTerminalUsage as u, safeDebugValue as v, summarizeResponsesTools as w, summarizeOpenAITransportError as x, stringifyRedactedEvent as y, resolveAzureOpenAIApiVersion as z };