@openclaw/ai 2026.7.1 → 2026.7.2-beta.2

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

@@ -1,13 +1,13 @@
 import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-DgmOla96.mjs";
+import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-Q1LSRIdo.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { n as parseStreamingJson } from "./json-parse-DzNSIQBq.mjs";
+import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { C as normalizeLowercaseStringOrEmpty, b as stripSystemPromptCacheBoundary, c as isRecord, i as extractToolResultText, n as describeToolResultMediaPlaceholder, t as transformMessages, w as normalizeOptionalString } from "./transform-messages-BhGF_fF4.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-BknoV11q.mjs";
+import { t as projectOpenAITools } from "./openai-tool-projection-CFqm42J2.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
 function normalizeStringEntries(list) {
@@ -54,6 +54,20 @@ const SCHEMA_META_KEYS = [
 function copySchemaMeta$1(from, to) {
 	for (const key of SCHEMA_META_KEYS) if (key in from && from[key] !== void 0) to[key] = from[key];
 }
+function stringifyGeminiEnumValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "boolean") return String(value);
+}
+function cleanGeminiEnumValues(value) {
+	if (!Array.isArray(value)) return;
+	const values = value.flatMap((entry) => {
+		const stringified = stringifyGeminiEnumValue(entry);
+		return stringified === void 0 ? [] : [stringified];
+	});
+	const unique = [...new Set(values)];
+	return unique.length > 0 ? unique : void 0;
+}
 function tryFlattenLiteralAnyOf(variants) {
 	if (variants.length === 0) return null;
 	const allValues = [];
@@ -208,7 +222,13 @@ function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
 	for (const [key, value] of Object.entries(obj)) {
 		if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) continue;
 		if (key === "const") {
-			cleaned.enum = [value];
+			const enumValues = cleanGeminiEnumValues([value]);
+			if (enumValues) cleaned.enum = enumValues;
+			continue;
+		}
+		if (key === "enum") {
+			const enumValues = cleanGeminiEnumValues(value);
+			if (enumValues) cleaned.enum = enumValues;
 			continue;
 		}
 		if (key === "required" && Array.isArray(value) && value.length === 0) continue;
@@ -583,8 +603,8 @@ function resolveJsonPointerPath(value, segments) {
 		if (!current || typeof current !== "object") return;
 		const key = decodeJsonPointerSegment(segment);
 		if (Array.isArray(current)) {
-			const index = Number(key);
-			if (!Number.isInteger(index) || index < 0 || index >= current.length) return;
+			const index = /^(?:0|[1-9]\d*)$/.test(key) ? Number(key) : -1;
+			if (index < 0 || index >= current.length) return;
 			current = current[index];
 			continue;
 		}
@@ -933,6 +953,16 @@ const GENERIC_REASONING_EFFORTS = [
 	"medium",
 	"high"
 ];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"off"
+]);
 function normalizeModelId(id) {
 	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
 }
@@ -955,7 +985,9 @@ function isOpenAIGpt56Model(model) {
 }
 /** Normalize user-facing reasoning effort names to API effort names. */
 function normalizeOpenAIReasoningEffort(effort) {
-	return effort === "minimal" ? "minimal" : effort;
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
 }
 function readCompatReasoningEfforts(compat) {
 	if (!compat || typeof compat !== "object") return;
@@ -984,6 +1016,19 @@ function resolveOpenAISupportedReasoningEfforts(model) {
 	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
 	return GENERIC_REASONING_EFFORTS;
 }
+/**
+* Return whether a model accepts the temperature parameter. The GPT-5.6
+* family rejects it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return !/^gpt-5\.6(?:-|$)/u.test(id);
+}
 /** Return whether a model accepts a requested reasoning effort. */
 function supportsOpenAIReasoningEffort(model, effort) {
 	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
@@ -991,7 +1036,8 @@ function supportsOpenAIReasoningEffort(model, effort) {
 /** Resolve a requested reasoning effort to the closest value supported by the model. */
 function resolveOpenAIReasoningEffortForModel(params) {
 	const requested = normalizeOpenAIReasoningEffort(params.effort);
-	const normalized = normalizeOpenAIReasoningEffort(params.fallbackMap?.[requested] ?? requested);
+	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
+	const normalized = mapped === void 0 ? requested : mapped.trim();
 	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
 	if (supported.includes(normalized)) return normalized;
 	if (requested === "off" && supported.includes("none")) return "none";
@@ -1000,7 +1046,7 @@ function resolveOpenAIReasoningEffortForModel(params) {
 	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
 	if (requested === "xhigh" && supported.includes("high")) return "high";
 	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
-	return supported.find((effort) => effort !== "none");
+	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
 }
 //#endregion
 //#region packages/ai/src/providers/openai-responses-stream-compat.ts
@@ -1030,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.
@@ -1263,6 +1385,20 @@ function sortResponsesToolsByName(tools) {
 //#endregion
 //#region packages/ai/src/providers/openai-responses-shared.ts
 const EMPTY_TOOL_RESULT_TEXT = "(no output)";
+function splitResponsesToolCallId(id) {
+	const separatorIndex = id.indexOf("|");
+	return separatorIndex === -1 ? [id, void 0] : [id.slice(0, separatorIndex), id.slice(separatorIndex + 1)];
+}
+function resolveResponsesToolCallId(item, fallbackId) {
+	const callId = typeof item.call_id === "string" ? item.call_id.trim() : "";
+	const itemId = typeof item.id === "string" ? item.id.trim() : "";
+	const [fallbackCallId, fallbackItemId = ""] = splitResponsesToolCallId(fallbackId ?? "");
+	const resolvedCallId = callId || fallbackCallId;
+	const resolvedItemId = itemId || fallbackItemId;
+	if (resolvedCallId) return resolvedItemId ? `${resolvedCallId}|${resolvedItemId}` : resolvedCallId;
+	const generatedCallId = `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
+	return resolvedItemId ? `${generatedCallId}|${resolvedItemId}` : generatedCallId;
+}
 function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
@@ -1318,7 +1454,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 	const normalizeToolCallId = (id, targetModel, source) => {
 		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
 		if (!id.includes("|")) return normalizeIdPart(id);
-		const [callId, itemId] = id.split("|");
+		const [callId, itemId = ""] = splitResponsesToolCallId(id);
 		const normalizedCallId = normalizeIdPart(callId);
 		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
 		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
@@ -1407,7 +1543,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 				previousReplayItemWasReasoning = false;
 			} else if (block.type === "toolCall") {
 				const toolCall = block;
-				const [callId, itemIdRaw] = toolCall.id.split("|");
+				const [callId, itemIdRaw] = splitResponsesToolCallId(toolCall.id);
 				let itemId = shouldReplayResponsesItemIds ? itemIdRaw : void 0;
 				if (shouldReplayResponsesItemIds && isDifferentModel && itemId?.startsWith("fc_")) itemId = void 0;
 				output.push({
@@ -1424,10 +1560,10 @@ 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] = msg.toolCallId.split("|");
+			const [callId] = splitResponsesToolCallId(msg.toolCallId);
 			let output;
 			if (hasImages && model.input.includes("image")) {
 				const contentParts = [];
@@ -1439,7 +1575,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}`
@@ -1496,7 +1632,7 @@ function resolveResponsesReasoningEffort(model, reasoning) {
 }
 function applyCommonResponsesParams(params, model, context, options, config) {
 	if (options?.maxTokens) params.max_output_tokens = options.maxTokens;
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
 	if (context.tools) {
 		const converted = convertResponsesToolPayload(context.tools, { model });
 		if (converted.tools.length > 0) params.tools = converted.tools;
@@ -1577,17 +1713,30 @@ async function runResponsesStreamLifecycle(params) {
 async function processResponsesStream(openaiStream, output, stream, model, options) {
 	let currentItem = null;
 	let currentBlock = null;
+	const streamingToolCalls = createResponsesToolCallTracker();
 	let lastTextBlock = null;
 	let pendingMessageText = null;
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
+	const readIdentityValue = (value) => {
+		return (typeof value === "string" ? value.trim() : "") || void 0;
+	};
+	const resolveCompletedToolCallName = (toolCall, value) => {
+		const streamedName = readIdentityValue(toolCall?.block.name);
+		const completedName = readIdentityValue(value);
+		if (streamedName && completedName && streamedName !== completedName) throw new Error(`Responses stream changed tool-call function name from ${streamedName} to ${completedName}`);
+		const name = completedName ?? streamedName;
+		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 = {
 			type: "text",
-			text: pendingMessageText
+			text: pendingMessageText,
+			...currentItem?.type === "message" && currentItem.phase ? { textSignature: encodeTextSignatureV1(currentItem.id, currentItem.phase ?? void 0) } : {}
 		};
 		blocks.push(currentBlock);
 		stream.push({
@@ -1640,7 +1789,8 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			} else {
 				currentBlock = {
 					type: "text",
-					text: ""
+					text: "",
+					...item.phase ? { textSignature: encodeTextSignatureV1(item.id, item.phase) } : {}
 				};
 				output.content.push(currentBlock);
 				stream.push({
@@ -1650,18 +1800,27 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				});
 			}
 		} else if (item.type === "function_call") {
-			currentItem = item;
-			currentBlock = {
+			const toolCallBlock = {
 				type: "toolCall",
-				id: `${item.call_id}|${item.id}`,
-				name: item.name,
+				id: resolveResponsesToolCallId(item),
+				name: readIdentityValue(item.name) ?? "",
 				arguments: {},
 				partialJson: item.arguments || ""
 			};
-			output.content.push(currentBlock);
+			const contentIndex = output.content.length;
+			const toolCallState = {
+				block: toolCallBlock,
+				contentIndex,
+				argumentStreamReliable: true,
+				...readResponsesToolCallItemIdentity(item)
+			};
+			streamingToolCalls.register(event, toolCallState);
+			currentItem = item;
+			currentBlock = toolCallBlock;
+			output.content.push(toolCallBlock);
 			stream.push({
 				type: "toolcall_start",
-				contentIndex: blockIndex(),
+				contentIndex,
 				partial: output
 			});
 		}
@@ -1775,34 +1934,37 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			}
 		}
 	} else if (event.type === "response.function_call_arguments.delta") {
-		if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-			currentBlock.partialJson += event.delta;
-			currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+		const toolCall = streamingToolCalls.resolve(event);
+		if (toolCall) {
+			toolCall.block.partialJson += event.delta;
+			toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
 			stream.push({
 				type: "toolcall_delta",
-				contentIndex: blockIndex(),
+				contentIndex: toolCall.contentIndex,
 				delta: event.delta,
 				partial: output
 			});
-		}
+		} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
 	} else if (event.type === "response.function_call_arguments.done") {
-		if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-			const previousPartialJson = currentBlock.partialJson;
+		const toolCall = streamingToolCalls.resolve(event);
+		if (toolCall) {
+			const previousPartialJson = toolCall.block.partialJson;
 			const doneArguments = typeof event.arguments === "string" ? event.arguments : void 0;
 			if (doneArguments !== void 0 && (doneArguments.length > 0 || previousPartialJson === "")) {
-				currentBlock.partialJson = doneArguments;
-				currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+				toolCall.block.partialJson = doneArguments;
+				toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
+				toolCall.argumentStreamReliable = true;
 			}
 			if (doneArguments?.startsWith(previousPartialJson)) {
 				const delta = doneArguments.slice(previousPartialJson.length);
 				if (delta.length > 0) stream.push({
 					type: "toolcall_delta",
-					contentIndex: blockIndex(),
+					contentIndex: toolCall.contentIndex,
 					delta,
 					partial: output
 				});
 			}
-		}
+		} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
 	} else if (event.type === "response.output_item.done") {
 		const item = event.item;
 		if (item.type !== "message") {
@@ -1846,7 +2008,8 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				if (currentBlock?.type !== "text") {
 					currentBlock = {
 						type: "text",
-						text: ""
+						text: "",
+						...phase ? { textSignature: encodeTextSignatureV1(item.id, phase) } : {}
 					};
 					blocks.push(currentBlock);
 					stream.push({
@@ -1871,27 +2034,52 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			}
 			currentBlock = null;
 		} else if (item.type === "function_call") {
-			const args = currentBlock?.type === "toolCall" && currentBlock.partialJson ? parseStreamingJson(currentBlock.partialJson) : parseStreamingJson(item.arguments || "{}");
+			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;
+			if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
+			const args = parseStreamingJson(completedArguments !== void 0 && (completedArguments.length > 0 || !streamedArguments) ? completedArguments : streamedArguments || "{}");
 			let toolCall;
-			if (currentBlock?.type === "toolCall") {
-				currentBlock.arguments = args;
-				delete currentBlock.partialJson;
-				toolCall = currentBlock;
-			} else toolCall = {
-				type: "toolCall",
-				id: `${item.call_id}|${item.id}`,
-				name: item.name,
-				arguments: args
-			};
-			currentBlock = null;
+			let contentIndex;
+			if (streamingToolCall) {
+				const block = streamingToolCall.block;
+				block.id = resolveResponsesToolCallId(item, block.id);
+				block.name = completedName;
+				block.arguments = args;
+				delete block.partialJson;
+				toolCall = block;
+				contentIndex = streamingToolCall.contentIndex;
+			} else {
+				toolCall = {
+					type: "toolCall",
+					id: resolveResponsesToolCallId(item),
+					name: completedName,
+					arguments: args
+				};
+				blocks.push(toolCall);
+				contentIndex = blockIndex();
+				stream.push({
+					type: "toolcall_start",
+					contentIndex,
+					partial: output
+				});
+			}
+			if (streamingToolCall) streamingToolCalls.forget(streamingToolCall);
+			if (currentBlock === toolCall) {
+				currentBlock = null;
+				currentItem = null;
+			}
 			stream.push({
 				type: "toolcall_end",
-				contentIndex: blockIndex(),
+				contentIndex,
 				toolCall,
 				partial: output
 			});
 		}
 	} else if (event.type === "response.completed") {
+		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) {
@@ -1927,6 +2115,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		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);
 	}
+	if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
 }
 function mapStopReason(status) {
 	if (!status) return "stop";
@@ -1941,4 +2130,4 @@ function mapStopReason(status) {
 	}
 }
 //#endregion
-export { extractToolSchemaModelCompat as A, isOpenAIGpt54MiniModel as C, resolveOpenAIReasoningEffortForModel as D, normalizeOpenAIReasoningEffort as E, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as F, cleanSchemaForGemini as I, resolveUnsupportedToolSchemaKeywords as M, shouldOmitEmptyArrayItems as N, resolveOpenAISupportedReasoningEfforts as O, stripUnsupportedSchemaKeywords 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, normalizeToolParameterSchema 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 };

package/dist/{openai-tool-projection-BknoV11q.mjs → openai-tool-projection-CFqm42J2.mjs}

@@ -1,5 +1,5 @@
-import { c as isRecord } from "./transform-messages-BhGF_fF4.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BXtBc_mD.mjs";
+import { d as isRecord } from "./transform-messages-BmS70CP5.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
 //#region packages/ai/src/providers/openai-prompt-cache.ts
 /** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
 const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
@@ -35,7 +35,12 @@ function projectOpenAITools(tools) {
 	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
 		let tool;
 		try {
-			tool = tools[toolIndex];
+			const candidate = tools[toolIndex];
+			if (!candidate) {
+				diagnostics.push(unreadableToolDiagnostic(toolIndex));
+				continue;
+			}
+			tool = candidate;
 		} catch {
 			diagnostics.push(unreadableToolDiagnostic(toolIndex));
 			continue;

package/dist/providers.d.mts

@@ -1,4 +1,4 @@
-import { n as ApiRegistry } from "./api-registry-BXYnCOIR.mjs";
+import { n as ApiRegistry } from "./api-registry-Byvoz8Ha.mjs";
 
 //#region packages/ai/src/providers/register-builtins.d.ts
 /** Source id used for built-in API provider registrations. */

package/dist/providers.mjs

@@ -1,4 +1,4 @@
-import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
 //#region packages/ai/src/providers/register-builtins.ts
 /** Source id used for built-in API provider registrations. */
 const BUILT_IN_API_PROVIDER_SOURCE_ID = "core:built-in";
@@ -63,35 +63,35 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-B5gZQM5X.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-BIRSg5x9.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-B9QLIq2U.mjs").then((n) => n.n), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-DPR_O2RW.mjs").then((n) => n.n), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-CePVNdws.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-DxMPt9q9.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-B6LylGxM.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-Cov-Vdc2.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-DNoSk8Uy.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-CHi7Wo4A.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-DVC4Bk_A.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-BuH2NvsR.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-D6sIQ1bL.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-BmsqsNwR.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-rDGwkoZK.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-HZ_0rTwS.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))

package/dist/{reasoning-tag-text-partitioner-axhAdUwg.mjs → reasoning-tag-text-partitioner-BlVe67g6.mjs}

@@ -14,9 +14,13 @@ function scanFenceSpans(buffer, state) {
 		const line = buffer.slice(offset, lineEnd).replace(/\r$/, "");
 		const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
 		if (match && (offset > 0 || startsAtLineStart)) {
-			const indent = match[1];
-			const marker = match[2];
-			const markerChar = marker[0];
+			const [, indent, marker, trailing] = match;
+			if (indent === void 0 || marker === void 0 || trailing === void 0) {
+				if (nextNewline === -1) break;
+				offset = nextNewline + 1;
+				continue;
+			}
+			const markerChar = marker.charAt(0);
 			const markerLen = marker.length;
 			if (!open) open = {
 				start: offset,
@@ -26,7 +30,7 @@ function scanFenceSpans(buffer, state) {
 				marker,
 				indent
 			};
-			else if (open.markerChar === markerChar && markerLen >= open.markerLen && /^[ \t]*$/.test(match[3])) {
+			else if (open.markerChar === markerChar && markerLen >= open.markerLen && /^[ \t]*$/.test(trailing)) {
 				const end = lineEnd;
 				spans.push({
 					start: open.start,
@@ -351,13 +355,13 @@ function findOpenInlineCodeStart(text) {
 	let openTicks = 0;
 	let index = 0;
 	while (index < text.length) {
-		if (text[index] !== "`") {
+		if (text.charAt(index) !== "`") {
 			index += 1;
 			continue;
 		}
 		const runStart = index;
 		let runLength = 0;
-		while (index < text.length && text[index] === "`") {
+		while (index < text.length && text.charAt(index) === "`") {
 			runLength += 1;
 			index += 1;
 		}
@@ -375,8 +379,10 @@ function findOpenFenceStart(text) {
 	const fenceRe = /(^|\n)(```|~~~)[^\n]*(?:\n|$)/g;
 	let open = null;
 	for (const match of text.matchAll(fenceRe)) {
-		const index = (match.index ?? 0) + match[1].length;
-		const marker = match[2] ?? "";
+		const prefix = match.at(1);
+		const marker = match.at(2);
+		if (prefix === void 0 || marker === void 0) continue;
+		const index = (match.index ?? 0) + prefix.length;
 		if (open !== null && open.marker === marker) open = null;
 		else if (!open) open = {
 			marker,

package/dist/{src-CZ503MYJ.mjs → src-CXno1H5g.mjs}

@@ -1,4 +1,4 @@
-import "./validation-FrchoOlv.mjs";
+import "./validation-DAa_yFOM.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";