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

package/dist/{openai-responses-shared-Befb4D6R.mjs → openai-responses-shared-CzCurmY1.mjs}

@@ -1,12 +1,12 @@
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-Q1LSRIdo.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { C as isImageWithMediaPayload, T as isRecord, _ as normalizeOptionalString, a as stripSystemPromptCacheBoundary, c as transformMessages, g as normalizeLowercaseStringOrEmpty, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.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 { 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 shortHash } from "./hash-CHgqbJmD.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DP4xEyBY.mjs";
+import { t as projectOpenAITools } from "./openai-tool-projection-ITOU9bG1.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
@@ -1076,6 +1076,66 @@ function resolveResponsesMessageSnapshotCollapse(params) {
 	return { kind: "keep" };
 }
 //#endregion
+//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
+function readCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+* Split a terminal usage payload into the priced buckets.
+*
+* OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
+* billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
+* split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
+* whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
+* short of what the buckets actually price.
+*/
+function mapResponsesTerminalUsage(usage) {
+	if (!usage) return;
+	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
+	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
+	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
+	const output = readCount(usage.output_tokens);
+	const bucketTotal = input + output + cacheRead + cacheWrite;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
+	};
+}
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+function readResponsesReasoningTokens(usage) {
+	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? reasoningTokens : void 0;
+}
+function mapResponsesTerminalStopReason(status) {
+	if (!status) return "stop";
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed":
+		case "cancelled": return "error";
+		case "in_progress":
+		case "queued": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
+	}
+}
+/**
+* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+* content-filtered turn is a provider error rather than a truncated answer, and a turn that
+* produced tool calls reports `toolUse` instead of a plain stop.
+*/
+function resolveResponsesTerminalStopReason(params) {
+	if (params.status === "incomplete" && params.incompleteReason === "content_filter") return {
+		stopReason: "error",
+		errorMessage: "Provider incomplete_reason: content_filter"
+	};
+	const stopReason = mapResponsesTerminalStopReason(params.status);
+	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
+	return { stopReason };
+}
+//#endregion
 //#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
 function readIdentityValue(value) {
 	return (typeof value === "string" ? value.trim() : "") || void 0;
@@ -1152,6 +1212,151 @@ function createResponsesToolCallTracker() {
 	};
 }
 //#endregion
+//#region packages/ai/src/providers/openai-tool-schema-compat.ts
+const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"description",
+	"examples",
+	"format",
+	"title"
+]);
+const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function normalizeOpenAIStrictCompatSchemaMap(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(schema)) {
+		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? normalized : schema;
+}
+function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	let hadNullType = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
+			changed = true;
+			continue;
+		}
+		if (value === null && key === "type") {
+			hadNullType = true;
+			changed = true;
+			continue;
+		}
+		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (Object.keys(normalized).length === 0) {
+		if (!options.promoteEmptyObject) return schema;
+		return {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		};
+	}
+	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
+	const hasArrayShapeHints = "items" in normalized;
+	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
+		normalized.type = hasObjectShapeHints ? "object" : "array";
+		changed = true;
+	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
+	if (normalized.type === "object" && !("properties" in normalized)) {
+		normalized.properties = {};
+		changed = true;
+	}
+	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
+	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
+		normalized.required = [];
+		changed = true;
+	}
+	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
+		normalized.additionalProperties = false;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+function normalizeOpenAIStrictCompatSchema(schema) {
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+}
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+function findOpenAIStrictSchemaViolations(schema, path, options) {
+	if (Array.isArray(schema)) {
+		if (options?.requireObjectRoot) return [`${path}.type`];
+		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
+	}
+	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
+	const record = schema;
+	const violations = [];
+	for (const key of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (key in record) violations.push(`${path}.${key}`);
+	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
+	if (record.type === "object") {
+		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) violations.push(`${path}.required`);
+		else if (properties) {
+			const requiredSet = new Set(required);
+			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
+		}
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
+		const schemaMap = record[key];
+		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
+		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
+		const value = record[key];
+		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+	}
+	return violations;
+}
+//#endregion
 //#region packages/ai/src/providers/openai-tool-schema.ts
 /**
 * OpenAI strict JSON-schema normalization for tool inventories and request payloads.
@@ -1245,7 +1450,7 @@ function findOpenAIStrictToolProjectionDiagnostics(projection) {
 		...diagnostic.toolName ? { toolName: diagnostic.toolName } : {},
 		violations: [...diagnostic.violations]
 	})), ...projection.tools.flatMap((tool) => {
-		const violations = findStrictOpenAIJsonSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
+		const violations = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
 		return violations.length > 0 ? [{
 			toolIndex: tool.toolIndex,
 			toolName: tool.name,
@@ -1272,34 +1477,6 @@ function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
 		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
 	});
 }
-function findStrictOpenAIJsonSchemaViolations(schema, path) {
-	if (Array.isArray(schema)) return schema.flatMap((entry, index) => findStrictOpenAIJsonSchemaViolations(entry, `${path}[${index}]`));
-	if (!schema || typeof schema !== "object") return [];
-	const record = schema;
-	const violations = [];
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf"
-	]) if (key in record) violations.push(`${path}.${key}`);
-	if (Array.isArray(record.type)) violations.push(`${path}.type`);
-	if (record.type === "object") {
-		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
-		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
-		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
-		if (!required) violations.push(`${path}.required`);
-		else {
-			const requiredSet = new Set(required);
-			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
-		}
-	}
-	if (record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)) for (const [key, value] of Object.entries(record.properties)) violations.push(...findStrictOpenAIJsonSchemaViolations(value, `${path}.properties.${key}`));
-	for (const [key, value] of Object.entries(record)) {
-		if (key === "properties") continue;
-		if (value && typeof value === "object") violations.push(...findStrictOpenAIJsonSchemaViolations(value, `${path}.${key}`));
-	}
-	return violations;
-}
 /** Resolves strict mode for the projected tools that will be emitted in the request payload. */
 function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	if (strict !== true) return strict === false ? false : void 0;
@@ -1462,7 +1639,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 +1809,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 +1828,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 +1867,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 +1889,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 +1943,137 @@ 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;
+		const mappedUsage = mapResponsesTerminalUsage(response.usage);
+		if (mappedUsage) output.usage = {
+			...mappedUsage,
+			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);
+		}
+		const terminal = resolveResponsesTerminalStopReason({
+			status: response.status,
+			incompleteReason: response.incomplete_details?.reason,
+			hasToolCall: output.content.some((block) => block.type === "toolCall")
+		});
+		output.stopReason = terminal.stopReason;
+		if (terminal.errorMessage) output.errorMessage = terminal.errorMessage;
 	};
 	const guardedStream = withFirstStreamEventTimeout(openaiStream, {
 		provider: model.provider,
@@ -1764,42 +2087,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 +2107,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 +2119,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 +2255,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 +2360,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,56 +2371,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");
-}
-function mapStopReason(status) {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed": return "stop";
-		case "incomplete": return "length";
-		case "failed":
-		case "cancelled": return "error";
-		case "in_progress":
-		case "queued": return "stop";
-		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
-	}
+	if (!terminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
 }
 //#endregion
-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 };
+export { isOpenAIGpt54MiniModel as A, resolveUnsupportedToolSchemaKeywords as B, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as C, isResponsesTextContentPartType as D, isAzureResponsesTextDeltaEventType as E, resolveOpenAISupportedReasoningEfforts as F, uniqueStrings as G, stripUnsupportedSchemaKeywords as H, supportsOpenAIReasoningEffort as I, supportsOpenAITemperature as L, isOpenAIGpt56Model as M, normalizeOpenAIReasoningEffort as N, isResponsesTextDeltaEventType as O, resolveOpenAIReasoningEffortForModel as P, extractToolSchemaModelCompat as R, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as S, isAzureResponsesTextDeltaEvent as T, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as U, shouldOmitEmptyArrayItems as V, cleanSchemaForGemini as W, readResponsesToolCallItemIdentity as _, resolveResponsesReasoningEffort as a, resolveResponsesTerminalStopReason as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, createResponsesToolCallTracker as g, normalizeOpenAIStrictCompatSchema as h, processResponsesStream as i, isOpenAIGpt55Model as j, resolveResponsesMessageSnapshotCollapse as k, findOpenAIStrictToolProjectionDiagnostics as l, findOpenAIStrictSchemaViolations as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, mapResponsesTerminalUsage as v, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as w, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as x, readResponsesReasoningTokens as y, normalizeToolParameterSchema as z };