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

package/dist/{openai-responses-shared-Befb4D6R.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 { C as stripSystemPromptCacheBoundary, D as normalizeOptionalString, E as normalizeLowercaseStringOrEmpty, d as isRecord, i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages } from "./transform-messages-BmS70CP5.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-CFqm42J2.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
@@ -1462,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,
@@ -1631,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 });
@@ -1650,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) {
@@ -1689,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,
@@ -1711,13 +1712,49 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 async function processResponsesStream(openaiStream, output, stream, model, options) {
-	let currentItem = null;
-	let currentBlock = null;
 	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) => {
+		const outputIndex = event.output_index;
+		return typeof outputIndex === "number" && Number.isInteger(outputIndex) && outputIndex >= 0 ? outputIndex : void 0;
+	};
+	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 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 forgetOutputSlot = (event, slot) => {
+		const outputIndex = readOutputIndex(event);
+		if (outputIndex === void 0) {
+			if (unindexedOutputSlot === slot) unindexedOutputSlot = void 0;
+			else for (const [indexedOutput, indexedSlot] of outputSlots) if (indexedSlot === slot) outputSlots.delete(indexedOutput);
+			return;
+		}
+		if (outputSlots.get(outputIndex) === slot) outputSlots.delete(outputIndex);
+	};
+	const forgetToolCallOutputSlot = (toolCall) => {
+		for (const [outputIndex, slot] of outputSlots) if (slot.type === "toolCall" && slot.toolCall === toolCall) outputSlots.delete(outputIndex);
+	};
 	const readIdentityValue = (value) => {
 		return (typeof value === "string" ? value.trim() : "") || void 0;
 	};
@@ -1729,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,
@@ -1764,42 +1916,11 @@ 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") {
+		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),
@@ -1815,8 +1936,10 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				...readResponsesToolCallItemIdentity(item)
 			};
 			streamingToolCalls.register(event, toolCallState);
-			currentItem = item;
-			currentBlock = toolCallBlock;
+			if (readOutputIndex(event) !== void 0) registerOutputSlot(event, {
+				type: "toolCall",
+				toolCall: toolCallState
+			});
 			output.content.push(toolCallBlock);
 			stream.push({
 				type: "toolcall_start",
@@ -1825,113 +1948,107 @@ 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 = streamingToolCalls.resolve(event);
@@ -1967,72 +2084,78 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		} 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 = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
 			if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
@@ -2066,10 +2189,9 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					partial: output
 				});
 			}
-			if (streamingToolCall) streamingToolCalls.forget(streamingToolCall);
-			if (currentBlock === toolCall) {
-				currentBlock = null;
-				currentItem = null;
+			if (streamingToolCall) {
+				streamingToolCalls.forget(streamingToolCall);
+				forgetToolCallOutputSlot(streamingToolCall);
 			}
 			stream.push({
 				type: "toolcall_end",
@@ -2078,44 +2200,22 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				partial: output
 			});
 		}
-	} else if (event.type === "response.completed") {
+	} else if (event.type === "response.completed" || event.type === "response.incomplete") {
 		if (streamingToolCalls.hasActive()) 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";
+		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 (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";