@openclaw/ai 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{openai-responses-shared-B9mtGvXq.mjs → openai-responses-shared-CwnGU0KW.mjs}

@@ -1,11 +1,11 @@
 import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-Q1LSRIdo.mjs";
+import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { T as normalizeOptionalString, i as extractToolResultText, l as isRecord, n as describeToolResultMediaPlaceholder, t as transformMessages, w as normalizeLowercaseStringOrEmpty, x as stripSystemPromptCacheBoundary } from "./transform-messages-DNWpwvXA.mjs";
+import { D as normalizeLowercaseStringOrEmpty, O as normalizeOptionalString, f as isRecord, i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages, w as stripSystemPromptCacheBoundary } from "./transform-messages-eb6lxDLB.mjs";
 import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-RjWszj8c.mjs";
-import { t as projectOpenAITools } from "./openai-tool-projection-cTLC4F65.mjs";
+import { t as projectOpenAITools } from "./openai-tool-projection-WHf2nuOI.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/normalization-core/src/string-normalization.ts
@@ -1076,6 +1076,82 @@ function resolveResponsesMessageSnapshotCollapse(params) {
 	return { kind: "keep" };
 }
 //#endregion
+//#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
+function readIdentityValue(value) {
+	return (typeof value === "string" ? value.trim() : "") || void 0;
+}
+function readOutputIndex(event) {
+	return typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
+}
+function readEventIdentity(event) {
+	return { itemId: readIdentityValue(event.item_id) };
+}
+function readResponsesToolCallItemIdentity(item) {
+	return {
+		itemId: readIdentityValue(item.id),
+		callId: readIdentityValue(item.call_id)
+	};
+}
+function createResponsesToolCallTracker() {
+	const indexedCalls = /* @__PURE__ */ new Map();
+	const unindexedCalls = /* @__PURE__ */ new Set();
+	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
+	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
+	const adoptIdentity = (state, identity) => {
+		state.itemId ??= identity.itemId;
+		state.callId ??= identity.callId;
+		return state;
+	};
+	const resolveCompatible = (candidates, identity) => {
+		const uniqueCandidates = [...new Set(candidates)];
+		if (!identity.itemId && !identity.callId) return 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;
+		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
+	};
+	return {
+		register(event, state) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex === void 0) {
+				unindexedCalls.add(state);
+				return;
+			}
+			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
+			indexedCalls.set(outputIndex, state);
+		},
+		resolve(event, identity = readEventIdentity(event)) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex !== void 0) {
+				const indexed = indexedCalls.get(outputIndex);
+				if (indexed) {
+					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
+					return adoptIdentity(indexed, identity);
+				}
+				const unindexed = resolveCompatible(unindexedCalls, identity);
+				if (unindexed) {
+					unindexedCalls.delete(unindexed);
+					indexedCalls.set(outputIndex, unindexed);
+				}
+				return unindexed;
+			}
+			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity);
+		},
+		forget(toolCall) {
+			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
+			unindexedCalls.delete(toolCall);
+		},
+		markArgumentsUnreliable() {
+			for (const toolCall of /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls])) toolCall.argumentStreamReliable = false;
+		},
+		hasActive() {
+			return indexedCalls.size > 0 || unindexedCalls.size > 0;
+		}
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/openai-tool-schema.ts
 /**
 * OpenAI strict JSON-schema normalization for tool inventories and request payloads.
@@ -1386,7 +1462,8 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 	};
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
 	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
-		const role = model.reasoning ? "developer" : "system";
+		const compat = model.compat;
+		const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
 		messages.push({
 			type: "message",
 			role,
@@ -1484,7 +1561,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 		} else if (msg.role === "toolResult") {
 			const textResult = extractToolResultText(msg.content);
 			const sanitizedTextResult = sanitizeSurrogates(textResult);
-			const hasImages = msg.content.some((c) => c.type === "image");
+			const hasImages = msg.content.some(isImageWithMediaPayload);
 			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
 			const hasText = sanitizedTextResult.trim().length > 0;
 			const [callId] = splitResponsesToolCallId(msg.toolCallId);
@@ -1499,7 +1576,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 					type: "input_text",
 					text: mediaPlaceholder
 				});
-				for (const block of msg.content) if (block.type === "image") contentParts.push({
+				for (const block of msg.content) if (isImageWithMediaPayload(block)) contentParts.push({
 					type: "input_image",
 					detail: "auto",
 					image_url: `data:${block.mimeType};base64,${block.data}`
@@ -1555,7 +1632,7 @@ function resolveResponsesReasoningEffort(model, reasoning) {
 	return clampedReasoning;
 }
 function applyCommonResponsesParams(params, model, context, options, config) {
-	if (options?.maxTokens) params.max_output_tokens = options.maxTokens;
+	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
 	if (context.tools) {
 		const converted = convertResponsesToolPayload(context.tools, { model });
@@ -1574,7 +1651,7 @@ function buildResponsesRequestOptions(options) {
 	return {
 		...options?.signal ? { signal: options.signal } : {},
 		...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-		...options?.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
+		maxRetries: options?.maxRetries ?? 0
 	};
 }
 function cleanStreamingScratchBuffers(output) {
@@ -1613,7 +1690,7 @@ async function runResponsesStreamLifecycle(params) {
 			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout
 		} : void 0);
 		if (options?.signal?.aborted) throw new Error("Request was aborted");
-		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 		stream.push({
 			type: "done",
 			reason: output.stopReason,
@@ -1635,62 +1712,52 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 async function processResponsesStream(openaiStream, output, stream, model, options) {
-	let currentItem = null;
-	let currentBlock = null;
-	const toolCallsByOutputIndex = /* @__PURE__ */ new Map();
-	const unindexedToolCalls = /* @__PURE__ */ new Set();
+	const streamingToolCalls = createResponsesToolCallTracker();
+	const outputSlots = /* @__PURE__ */ new Map();
+	const reasoningBlocksById = /* @__PURE__ */ new Map();
+	let unindexedOutputSlot;
+	let terminalResponseEvent;
 	let lastTextBlock = null;
-	let pendingMessageText = null;
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
-	const readOutputIndex = (event) => typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
-	const readIdentityValue = (value) => {
-		return (typeof value === "string" ? value.trim() : "") || void 0;
+	const readOutputIndex = (event) => {
+		const outputIndex = event.output_index;
+		return typeof outputIndex === "number" && Number.isInteger(outputIndex) && outputIndex >= 0 ? outputIndex : void 0;
 	};
-	const readEventToolCallIdentity = (event) => ({ itemId: readIdentityValue(event.item_id) });
-	const readItemToolCallIdentity = (item) => ({
-		itemId: readIdentityValue(item.id),
-		callId: readIdentityValue(item.call_id)
-	});
-	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
-	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
-	const adoptToolCallIdentity = (state, identity) => {
-		state.itemId ??= identity.itemId;
-		state.callId ??= identity.callId;
-		return state;
+	const registerOutputSlot = (event, slot) => {
+		const outputIndex = readOutputIndex(event);
+		if (outputIndex === void 0) {
+			if (unindexedOutputSlot) throw new Error("Responses stream added overlapping unindexed output items");
+			unindexedOutputSlot = slot;
+			return;
+		}
+		if (outputSlots.has(outputIndex)) throw new Error(`Responses stream reused active output index ${outputIndex}`);
+		outputSlots.set(outputIndex, slot);
 	};
-	const resolveCompatibleToolCall = (candidates, identity) => {
-		const uniqueCandidates = [...new Set(candidates)];
-		if (!identity.itemId && !identity.callId) return 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 adoptToolCallIdentity(matched, identity);
-		const soleCompatible = uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
-		return soleCompatible ? adoptToolCallIdentity(soleCompatible, identity) : void 0;
+	const resolveOutputSlot = (event, type) => {
+		const outputIndex = readOutputIndex(event);
+		let slot = outputIndex === void 0 ? unindexedOutputSlot : outputSlots.get(outputIndex);
+		if (outputIndex === void 0 && !slot) {
+			const matchingSlots = [...outputSlots.values()].filter((candidate) => candidate.type === type);
+			slot = matchingSlots.length === 1 ? matchingSlots[0] : void 0;
+		}
+		return slot?.type === type ? slot : void 0;
 	};
-	const resolveStreamingToolCall = (event, identity = readEventToolCallIdentity(event)) => {
+	const forgetOutputSlot = (event, slot) => {
 		const outputIndex = readOutputIndex(event);
-		if (outputIndex !== void 0) {
-			const indexed = toolCallsByOutputIndex.get(outputIndex);
-			if (indexed) return !identitiesConflict(indexed, identity) ? adoptToolCallIdentity(indexed, identity) : void 0;
-			const unindexed = resolveCompatibleToolCall(unindexedToolCalls, identity);
-			if (unindexed) {
-				unindexedToolCalls.delete(unindexed);
-				toolCallsByOutputIndex.set(outputIndex, unindexed);
-			}
-			return unindexed;
+		if (outputIndex === void 0) {
+			if (unindexedOutputSlot === slot) unindexedOutputSlot = void 0;
+			else for (const [indexedOutput, indexedSlot] of outputSlots) if (indexedSlot === slot) outputSlots.delete(indexedOutput);
+			return;
 		}
-		return resolveCompatibleToolCall([...toolCallsByOutputIndex.values(), ...unindexedToolCalls], identity);
+		if (outputSlots.get(outputIndex) === slot) outputSlots.delete(outputIndex);
 	};
-	const forgetStreamingToolCall = (toolCall) => {
-		for (const [trackedIndex, tracked] of toolCallsByOutputIndex) if (tracked === toolCall) toolCallsByOutputIndex.delete(trackedIndex);
-		unindexedToolCalls.delete(toolCall);
+	const forgetToolCallOutputSlot = (toolCall) => {
+		for (const [outputIndex, slot] of outputSlots) if (slot.type === "toolCall" && slot.toolCall === toolCall) outputSlots.delete(outputIndex);
 	};
-	const markActiveToolCallArgumentsUnreliable = () => {
-		for (const toolCall of /* @__PURE__ */ new Set([...toolCallsByOutputIndex.values(), ...unindexedToolCalls])) toolCall.argumentStreamReliable = false;
+	const readIdentityValue = (value) => {
+		return (typeof value === "string" ? value.trim() : "") || void 0;
 	};
-	const hasActiveStreamingToolCall = () => toolCallsByOutputIndex.size > 0 || unindexedToolCalls.size > 0;
 	const resolveCompletedToolCallName = (toolCall, value) => {
 		const streamedName = readIdentityValue(toolCall?.block.name);
 		const completedName = readIdentityValue(value);
@@ -1699,28 +1766,143 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		if (!name) throw new Error("Responses stream completed tool call without a function name");
 		return name;
 	};
-	const appendPendingMessageDelta = (delta) => {
-		pendingMessageText = `${pendingMessageText ?? ""}${delta}`;
-		const priorText = lastTextBlock?.block.text ?? "";
-		if (priorText.startsWith(pendingMessageText) || pendingMessageText.startsWith(priorText)) return;
-		currentBlock = {
+	const createOutputSlot = (event, item) => {
+		if (item.type === "reasoning") {
+			const block = {
+				type: "thinking",
+				thinking: ""
+			};
+			const slot = {
+				type: "thinking",
+				item,
+				block,
+				contentIndex: blocks.length
+			};
+			blocks.push(block);
+			registerOutputSlot(event, slot);
+			stream.push({
+				type: "thinking_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+		if (item.type === "message") {
+			const messageItem = item;
+			const collapseCandidate = lastTextBlock;
+			const block = collapseCandidate ? null : {
+				type: "text",
+				text: "",
+				...messageItem.phase ? { textSignature: encodeTextSignatureV1(messageItem.id, messageItem.phase) } : {}
+			};
+			const slot = {
+				type: "text",
+				item: messageItem,
+				block,
+				contentIndex: block ? blocks.length : void 0,
+				pendingText: collapseCandidate ? "" : null,
+				collapseCandidate
+			};
+			if (block) blocks.push(block);
+			registerOutputSlot(event, slot);
+			if (slot.contentIndex !== void 0) stream.push({
+				type: "text_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+	};
+	const resolveOutputItemSlot = (event, item) => {
+		if (item.type === "reasoning") return resolveOutputSlot(event, "thinking");
+		if (item.type === "message") return resolveOutputSlot(event, "text");
+		const outputIndex = readOutputIndex(event);
+		return outputIndex === void 0 ? void 0 : outputSlots.get(outputIndex);
+	};
+	const getOrCreateOutputSlot = (event, item) => {
+		return resolveOutputItemSlot(event, item) ?? createOutputSlot(event, item);
+	};
+	const materializeDeferredTextSlot = (slot) => {
+		if (slot.block || slot.pendingText === null) return;
+		const text = slot.pendingText;
+		slot.block = {
 			type: "text",
-			text: pendingMessageText,
-			...currentItem?.type === "message" && currentItem.phase ? { textSignature: encodeTextSignatureV1(currentItem.id, currentItem.phase ?? void 0) } : {}
+			text,
+			...slot.item.phase ? { textSignature: encodeTextSignatureV1(slot.item.id, slot.item.phase) } : {}
 		};
-		blocks.push(currentBlock);
+		blocks.push(slot.block);
+		slot.contentIndex = blockIndex();
 		stream.push({
 			type: "text_start",
-			contentIndex: blockIndex(),
+			contentIndex: slot.contentIndex,
 			partial: output
 		});
-		stream.push({
+		if (text) stream.push({
 			type: "text_delta",
-			contentIndex: blockIndex(),
-			delta: pendingMessageText,
+			contentIndex: slot.contentIndex,
+			delta: text,
 			partial: output
 		});
-		pendingMessageText = null;
+		if (lastTextBlock === slot.collapseCandidate) lastTextBlock = null;
+		slot.pendingText = null;
+		slot.collapseCandidate = null;
+	};
+	const materializeDeferredTextSlots = (except) => {
+		for (const slot of outputSlots.values()) if (slot !== except && slot.type === "text") materializeDeferredTextSlot(slot);
+		if (unindexedOutputSlot !== except && unindexedOutputSlot?.type === "text") materializeDeferredTextSlot(unindexedOutputSlot);
+	};
+	const appendPendingMessageDelta = (slot, delta) => {
+		slot.pendingText = `${slot.pendingText ?? ""}${delta}`;
+		const priorText = slot.collapseCandidate?.block.text ?? "";
+		if (priorText.startsWith(slot.pendingText) || slot.pendingText.startsWith(priorText)) return;
+		materializeDeferredTextSlot(slot);
+	};
+	const backfillReasoningSignatures = (responseOutput) => {
+		for (const item of responseOutput) {
+			if (item.type !== "reasoning" || !item.encrypted_content) continue;
+			const block = reasoningBlocksById.get(item.id);
+			if (!block?.thinkingSignature) continue;
+			const storedItem = JSON.parse(block.thinkingSignature);
+			if (storedItem.encrypted_content) continue;
+			block.thinkingSignature = JSON.stringify({
+				...storedItem,
+				encrypted_content: item.encrypted_content
+			});
+		}
+	};
+	const finalizeResponse = (response) => {
+		terminalResponseEvent = "finalized";
+		backfillReasoningSignatures(response.output ?? []);
+		if (response.id) output.responseId = response.id;
+		if (response.usage) {
+			const inputTokenDetails = response.usage.input_tokens_details;
+			const cachedTokens = inputTokenDetails?.cached_tokens || 0;
+			const cacheWriteTokens = inputTokenDetails?.cache_write_tokens || 0;
+			output.usage = {
+				input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
+				output: response.usage.output_tokens || 0,
+				cacheRead: cachedTokens,
+				cacheWrite: cacheWriteTokens,
+				totalTokens: response.usage.total_tokens || 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			};
+		}
+		calculateCost(model, output.usage);
+		if (options?.applyServiceTierPricing) {
+			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response.service_tier, options.serviceTier) : response.service_tier ?? options.serviceTier;
+			options.applyServiceTierPricing(output.usage, serviceTier);
+		}
+		if (response.status === "incomplete" && response.incomplete_details?.reason === "content_filter") {
+			output.stopReason = "error";
+			output.errorMessage = "Provider incomplete_reason: content_filter";
+		} else output.stopReason = mapStopReason(response.status);
+		if (output.content.some((block) => block.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
 	};
 	const guardedStream = withFirstStreamEventTimeout(openaiStream, {
 		provider: model.provider,
@@ -1734,62 +1916,31 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	});
 	for await (const event of guardedStream) if (event.type === "response.created") output.responseId = event.response.id;
 	else if (event.type === "response.output_item.added") {
+		materializeDeferredTextSlots();
 		const item = event.item;
-		if (item.type !== "message") {
-			lastTextBlock = null;
-			pendingMessageText = null;
-		}
-		if (item.type === "reasoning") {
-			currentItem = item;
-			currentBlock = {
-				type: "thinking",
-				thinking: ""
-			};
-			output.content.push(currentBlock);
-			stream.push({
-				type: "thinking_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
-		} else if (item.type === "message") {
-			currentItem = item;
-			if (lastTextBlock) {
-				currentBlock = null;
-				pendingMessageText = "";
-			} else {
-				currentBlock = {
-					type: "text",
-					text: "",
-					...item.phase ? { textSignature: encodeTextSignatureV1(item.id, item.phase) } : {}
-				};
-				output.content.push(currentBlock);
-				stream.push({
-					type: "text_start",
-					contentIndex: blockIndex(),
-					partial: output
-				});
-			}
-		} else if (item.type === "function_call") {
-			const outputIndex = readOutputIndex(event);
-			if (outputIndex !== void 0 && toolCallsByOutputIndex.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
-			currentItem = item;
-			currentBlock = {
+		if (item.type !== "message") lastTextBlock = null;
+		if (item.type === "reasoning" || item.type === "message") createOutputSlot(event, item);
+		else if (item.type === "function_call") {
+			const toolCallBlock = {
 				type: "toolCall",
 				id: resolveResponsesToolCallId(item),
 				name: readIdentityValue(item.name) ?? "",
 				arguments: {},
 				partialJson: item.arguments || ""
 			};
-			output.content.push(currentBlock);
-			const contentIndex = blockIndex();
+			const contentIndex = output.content.length;
 			const toolCallState = {
-				block: currentBlock,
+				block: toolCallBlock,
 				contentIndex,
 				argumentStreamReliable: true,
-				...readItemToolCallIdentity(item)
+				...readResponsesToolCallItemIdentity(item)
 			};
-			if (outputIndex !== void 0) toolCallsByOutputIndex.set(outputIndex, toolCallState);
-			else unindexedToolCalls.add(toolCallState);
+			streamingToolCalls.register(event, toolCallState);
+			if (readOutputIndex(event) !== void 0) registerOutputSlot(event, {
+				type: "toolCall",
+				toolCall: toolCallState
+			});
+			output.content.push(toolCallBlock);
 			stream.push({
 				type: "toolcall_start",
 				contentIndex,
@@ -1797,116 +1948,110 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			});
 		}
 	} else if (event.type === "response.reasoning_summary_part.added") {
-		if (currentItem && currentItem.type === "reasoning") {
-			currentItem.summary = currentItem.summary || [];
-			currentItem.summary.push(event.part);
-		}
+		const slot = resolveOutputSlot(event, "thinking");
+		if (!slot) continue;
+		slot.item.summary = slot.item.summary || [];
+		slot.item.summary.push(event.part);
 	} else if (event.type === "response.reasoning_summary_text.delta") {
-		if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentItem.summary = currentItem.summary || [];
-			const lastPart = currentItem.summary[currentItem.summary.length - 1];
-			if (lastPart) {
-				currentBlock.thinking += event.delta;
-				lastPart.text += event.delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: blockIndex(),
-					delta: event.delta,
-					partial: output
-				});
-			}
-		}
+		const slot = resolveOutputSlot(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 += event.delta;
+		lastPart.text += event.delta;
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
 	} else if (event.type === "response.reasoning_summary_part.done") {
-		if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentItem.summary = currentItem.summary || [];
-			const lastPart = currentItem.summary[currentItem.summary.length - 1];
-			if (lastPart) {
-				currentBlock.thinking += "\n\n";
-				lastPart.text += "\n\n";
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: blockIndex(),
-					delta: "\n\n",
-					partial: output
-				});
-			}
-		}
+		const slot = resolveOutputSlot(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
+		});
 	} else if (event.type === "response.reasoning_text.delta") {
-		if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentBlock.thinking += event.delta;
+		const slot = resolveOutputSlot(event, "thinking");
+		if (!slot) continue;
+		slot.block.thinking += event.delta;
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
+	} else if (event.type === "response.content_part.added") {
+		const slot = resolveOutputSlot(event, "text");
+		if (!slot) continue;
+		slot.item.content = slot.item.content || [];
+		if (event.part.type === "output_text" || event.part.type === "text" || event.part.type === "refusal") slot.item.content.push(event.part);
+	} else if (event.type === "response.output_text.delta") {
+		const slot = resolveOutputSlot(event, "text");
+		if (!slot?.item.content || slot.item.content.length === 0) continue;
+		const lastPart = slot.item.content[slot.item.content.length - 1];
+		if (!isResponsesTextContentPartType(lastPart?.type)) continue;
+		lastPart.text += event.delta;
+		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+		else if (slot.block && slot.contentIndex !== void 0) {
+			slot.block.text += event.delta;
 			stream.push({
-				type: "thinking_delta",
-				contentIndex: blockIndex(),
+				type: "text_delta",
+				contentIndex: slot.contentIndex,
 				delta: event.delta,
 				partial: output
 			});
 		}
-	} else if (event.type === "response.content_part.added") {
-		if (currentItem?.type === "message") {
-			currentItem.content = currentItem.content || [];
-			if (event.part.type === "output_text" || event.part.type === "text" || event.part.type === "refusal") currentItem.content.push(event.part);
-		}
-	} else if (event.type === "response.output_text.delta") {
-		if (currentItem?.type === "message") {
-			if (!currentItem.content || currentItem.content.length === 0) continue;
-			const lastPart = currentItem.content[currentItem.content.length - 1];
-			if (isResponsesTextContentPartType(lastPart?.type)) {
-				lastPart.text += event.delta;
-				if (pendingMessageText !== null) appendPendingMessageDelta(event.delta);
-				else if (currentBlock?.type === "text") {
-					currentBlock.text += event.delta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: blockIndex(),
-						delta: event.delta,
-						partial: output
-					});
-				}
-			}
-		}
 	} else if (isAzureResponsesTextDeltaEvent(event)) {
-		if (currentItem?.type === "message") {
-			currentItem.content = currentItem.content || [];
-			let lastPart = currentItem.content[currentItem.content.length - 1];
-			if (lastPart?.type !== "text") {
-				lastPart = {
-					type: "text",
-					text: ""
-				};
-				currentItem.content.push(lastPart);
-			}
-			lastPart.text += event.delta;
-			if (pendingMessageText !== null) appendPendingMessageDelta(event.delta);
-			else if (currentBlock?.type === "text") {
-				currentBlock.text += event.delta;
-				stream.push({
-					type: "text_delta",
-					contentIndex: blockIndex(),
-					delta: event.delta,
-					partial: output
-				});
-			}
+		const slot = resolveOutputSlot(event, "text");
+		if (!slot) continue;
+		slot.item.content = slot.item.content || [];
+		let lastPart = slot.item.content[slot.item.content.length - 1];
+		if (lastPart?.type !== "text") {
+			lastPart = {
+				type: "text",
+				text: ""
+			};
+			slot.item.content.push(lastPart);
+		}
+		lastPart.text += event.delta;
+		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+		else if (slot.block && slot.contentIndex !== void 0) {
+			slot.block.text += event.delta;
+			stream.push({
+				type: "text_delta",
+				contentIndex: slot.contentIndex,
+				delta: event.delta,
+				partial: output
+			});
 		}
 	} else if (event.type === "response.refusal.delta") {
-		if (currentItem?.type === "message") {
-			if (!currentItem.content || currentItem.content.length === 0) continue;
-			const lastPart = currentItem.content[currentItem.content.length - 1];
-			if (lastPart?.type === "refusal") {
-				lastPart.refusal += event.delta;
-				if (pendingMessageText !== null) appendPendingMessageDelta(event.delta);
-				else if (currentBlock?.type === "text") {
-					currentBlock.text += event.delta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: blockIndex(),
-						delta: event.delta,
-						partial: output
-					});
-				}
-			}
+		const slot = resolveOutputSlot(event, "text");
+		if (!slot?.item.content || slot.item.content.length === 0) continue;
+		const lastPart = slot.item.content[slot.item.content.length - 1];
+		if (lastPart?.type !== "refusal") continue;
+		lastPart.refusal += event.delta;
+		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+		else if (slot.block && slot.contentIndex !== void 0) {
+			slot.block.text += event.delta;
+			stream.push({
+				type: "text_delta",
+				contentIndex: slot.contentIndex,
+				delta: event.delta,
+				partial: output
+			});
 		}
 	} else if (event.type === "response.function_call_arguments.delta") {
-		const toolCall = resolveStreamingToolCall(event);
+		const toolCall = streamingToolCalls.resolve(event);
 		if (toolCall) {
 			toolCall.block.partialJson += event.delta;
 			toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
@@ -1916,9 +2061,9 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				delta: event.delta,
 				partial: output
 			});
-		} else if (hasActiveStreamingToolCall()) markActiveToolCallArgumentsUnreliable();
+		} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
 	} else if (event.type === "response.function_call_arguments.done") {
-		const toolCall = resolveStreamingToolCall(event);
+		const toolCall = streamingToolCalls.resolve(event);
 		if (toolCall) {
 			const previousPartialJson = toolCall.block.partialJson;
 			const doneArguments = typeof event.arguments === "string" ? event.arguments : void 0;
@@ -1936,78 +2081,84 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					partial: output
 				});
 			}
-		} else if (hasActiveStreamingToolCall()) markActiveToolCallArgumentsUnreliable();
+		} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
 	} else if (event.type === "response.output_item.done") {
 		const item = event.item;
-		if (item.type !== "message") {
-			lastTextBlock = null;
-			pendingMessageText = null;
-		}
-		if (item.type === "reasoning" && currentBlock?.type === "thinking") {
+		if (item.type !== "message") lastTextBlock = null;
+		const existingOutputSlot = resolveOutputItemSlot(event, item);
+		materializeDeferredTextSlots(existingOutputSlot);
+		const outputSlot = existingOutputSlot ?? getOrCreateOutputSlot(event, item);
+		if (item.type === "reasoning" && outputSlot?.type === "thinking") {
 			const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
 			const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
-			currentBlock.thinking = summaryText || contentText || currentBlock.thinking;
-			currentBlock.thinkingSignature = JSON.stringify(item);
+			outputSlot.block.thinking = summaryText || contentText || outputSlot.block.thinking;
+			outputSlot.block.thinkingSignature = JSON.stringify(item);
+			if (typeof item.id === "string") reasoningBlocksById.set(item.id, outputSlot.block);
 			stream.push({
 				type: "thinking_end",
-				contentIndex: blockIndex(),
-				content: currentBlock.thinking,
+				contentIndex: outputSlot.contentIndex,
+				content: outputSlot.block.thinking,
 				partial: output
 			});
-			currentBlock = null;
-		} else if (item.type === "message" && (currentBlock?.type === "text" || pendingMessageText !== null)) {
-			const finalText = item.content.map((c) => c.type === "output_text" || c.type === "text" ? c.text : c.refusal).join("");
+			forgetOutputSlot(event, outputSlot);
+		} else if (item.type === "message" && outputSlot?.type === "text" && (outputSlot.block || outputSlot.pendingText !== null)) {
+			const streamedText = outputSlot.pendingText ?? outputSlot.block?.text ?? "";
+			const finalText = item.content == null ? streamedText : item.content.map((c) => c.type === "output_text" || c.type === "text" ? c.text : c.refusal).join("");
 			const phase = item.phase ?? void 0;
-			const collapse = pendingMessageText !== null ? resolveResponsesMessageSnapshotCollapse({
-				prior: lastTextBlock && {
-					text: lastTextBlock.block.text,
-					phase: lastTextBlock.phase
+			const collapse = outputSlot.pendingText !== null ? resolveResponsesMessageSnapshotCollapse({
+				prior: outputSlot.collapseCandidate && {
+					text: outputSlot.collapseCandidate.block.text,
+					phase: outputSlot.collapseCandidate.phase
 				},
 				nextText: finalText,
 				nextPhase: phase
 			}) : { kind: "keep" };
-			pendingMessageText = null;
-			if (collapse.kind === "extend" && lastTextBlock) {
-				lastTextBlock.block.text = collapse.text;
-				lastTextBlock.block.textSignature = encodeTextSignatureV1(item.id, phase);
+			outputSlot.pendingText = null;
+			if (collapse.kind === "extend" && outputSlot.collapseCandidate) {
+				outputSlot.collapseCandidate.block.text = collapse.text;
+				outputSlot.collapseCandidate.block.textSignature = encodeTextSignatureV1(item.id, phase);
 				stream.push({
 					type: "text_end",
-					contentIndex: lastTextBlock.index,
+					contentIndex: outputSlot.collapseCandidate.index,
 					content: collapse.text,
 					partial: output
 				});
+				lastTextBlock = outputSlot.collapseCandidate;
 			} else {
-				if (currentBlock?.type !== "text") {
-					currentBlock = {
+				if (!outputSlot.block) {
+					outputSlot.block = {
 						type: "text",
 						text: "",
 						...phase ? { textSignature: encodeTextSignatureV1(item.id, phase) } : {}
 					};
-					blocks.push(currentBlock);
+					blocks.push(outputSlot.block);
+					outputSlot.contentIndex = blockIndex();
 					stream.push({
 						type: "text_start",
-						contentIndex: blockIndex(),
+						contentIndex: outputSlot.contentIndex,
 						partial: output
 					});
 				}
-				currentBlock.text = finalText;
-				currentBlock.textSignature = encodeTextSignatureV1(item.id, phase);
+				outputSlot.block.text = finalText;
+				outputSlot.block.textSignature = encodeTextSignatureV1(item.id, phase);
+				const contentIndex = outputSlot.contentIndex;
+				if (contentIndex === void 0) throw new Error("Responses stream finalized text without a content index");
 				lastTextBlock = {
-					block: currentBlock,
-					index: blockIndex(),
+					block: outputSlot.block,
+					index: contentIndex,
 					phase
 				};
 				stream.push({
 					type: "text_end",
-					contentIndex: blockIndex(),
-					content: currentBlock.text,
+					contentIndex,
+					content: outputSlot.block.text,
 					partial: output
 				});
 			}
-			currentBlock = null;
+			forgetOutputSlot(event, outputSlot);
 		} else if (item.type === "function_call") {
-			const streamingToolCall = resolveStreamingToolCall(event, readItemToolCallIdentity(item));
-			if (!streamingToolCall && hasActiveStreamingToolCall()) continue;
+			const streamingToolCall = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
+			if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
 			const completedName = resolveCompletedToolCallName(streamingToolCall, item.name);
 			const streamedArguments = streamingToolCall?.block.partialJson ?? "";
 			const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
@@ -2038,10 +2189,9 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					partial: output
 				});
 			}
-			if (streamingToolCall) forgetStreamingToolCall(streamingToolCall);
-			if (currentBlock === toolCall) {
-				currentBlock = null;
-				currentItem = null;
+			if (streamingToolCall) {
+				streamingToolCalls.forget(streamingToolCall);
+				forgetToolCallOutputSlot(streamingToolCall);
 			}
 			stream.push({
 				type: "toolcall_end",
@@ -2050,44 +2200,22 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				partial: output
 			});
 		}
-	} else if (event.type === "response.completed") {
-		if (hasActiveStreamingToolCall()) throw new Error("Responses stream completed with unresolved tool calls");
-		const response = event.response;
-		if (response?.id) output.responseId = response.id;
-		if (response?.usage) {
-			const inputTokenDetails = response.usage.input_tokens_details;
-			const cachedTokens = inputTokenDetails?.cached_tokens || 0;
-			const cacheWriteTokens = inputTokenDetails?.cache_write_tokens || 0;
-			output.usage = {
-				input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
-				output: response.usage.output_tokens || 0,
-				cacheRead: cachedTokens,
-				cacheWrite: cacheWriteTokens,
-				totalTokens: response.usage.total_tokens || 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			};
-		}
-		calculateCost(model, output.usage);
-		if (options?.applyServiceTierPricing) {
-			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response?.service_tier, options.serviceTier) : response?.service_tier ?? options.serviceTier;
-			options.applyServiceTierPricing(output.usage, serviceTier);
-		}
-		output.stopReason = mapStopReason(response?.status);
-		if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
+	} 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);
 	} 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 error = event.response?.error;
 		const details = event.response?.incomplete_details;
-		const msg = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
-		throw new Error(msg);
+		output.responseId = event.response.id;
+		output.stopReason = "error";
+		output.errorMessage = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
+		terminalResponseEvent = "failed";
+		break;
 	}
-	if (hasActiveStreamingToolCall()) throw new Error("Responses stream ended with unresolved tool calls");
+	if (terminalResponseEvent === "failed") return;
+	if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
+	if (!terminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
 }
 function mapStopReason(status) {
 	if (!status) return "stop";
@@ -2102,4 +2230,4 @@ function mapStopReason(status) {
 	}
 }
 //#endregion
-export { supportsOpenAITemperature as A, isOpenAIGpt54MiniModel as C, resolveOpenAIReasoningEffortForModel as D, normalizeOpenAIReasoningEffort as E, stripUnsupportedSchemaKeywords as F, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as I, cleanSchemaForGemini as L, normalizeToolParameterSchema as M, resolveUnsupportedToolSchemaKeywords as N, resolveOpenAISupportedReasoningEfforts as O, shouldOmitEmptyArrayItems as P, resolveResponsesMessageSnapshotCollapse as S, isOpenAIGpt56Model as T, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as _, resolveResponsesReasoningEffort as a, isResponsesTextContentPartType as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as g, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as h, processResponsesStream as i, extractToolSchemaModelCompat as j, supportsOpenAIReasoningEffort as k, findOpenAIStrictToolProjectionDiagnostics as l, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, isAzureResponsesTextDeltaEvent as v, isOpenAIGpt55Model as w, isResponsesTextDeltaEventType as x, isAzureResponsesTextDeltaEventType as y };
+export { resolveOpenAISupportedReasoningEfforts as A, isResponsesTextDeltaEventType as C, isOpenAIGpt56Model as D, isOpenAIGpt55Model as E, resolveUnsupportedToolSchemaKeywords as F, shouldOmitEmptyArrayItems as I, stripUnsupportedSchemaKeywords as L, supportsOpenAITemperature as M, extractToolSchemaModelCompat as N, normalizeOpenAIReasoningEffort as O, normalizeToolParameterSchema as P, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as R, isResponsesTextContentPartType as S, isOpenAIGpt54MiniModel as T, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as _, resolveResponsesReasoningEffort as a, isAzureResponsesTextDeltaEvent as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as g, readResponsesToolCallItemIdentity as h, processResponsesStream as i, supportsOpenAIReasoningEffort as j, resolveOpenAIReasoningEffortForModel as k, findOpenAIStrictToolProjectionDiagnostics as l, createResponsesToolCallTracker as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as v, resolveResponsesMessageSnapshotCollapse as w, isAzureResponsesTextDeltaEventType as x, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as y, cleanSchemaForGemini as z };