@openclaw/ai 2026.7.1 → 2026.7.2-beta.1

package/dist/{openai-responses-shared-sj2YUPYc.mjs → openai-responses-shared-B9mtGvXq.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 { T as normalizeOptionalString, i as extractToolResultText, l as isRecord, n as describeToolResultMediaPlaceholder, t as transformMessages, w as normalizeLowercaseStringOrEmpty, x as stripSystemPromptCacheBoundary } from "./transform-messages-DNWpwvXA.mjs";
 import { 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-cTLC4F65.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
@@ -1263,6 +1309,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 +1378,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 +1467,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({
@@ -1427,7 +1487,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
 			const hasImages = msg.content.some((c) => c.type === "image");
 			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 = [];
@@ -1496,7 +1556,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 +1637,76 @@ async function runResponsesStreamLifecycle(params) {
 async function processResponsesStream(openaiStream, output, stream, model, options) {
 	let currentItem = null;
 	let currentBlock = null;
+	const toolCallsByOutputIndex = /* @__PURE__ */ new Map();
+	const unindexedToolCalls = /* @__PURE__ */ new Set();
 	let lastTextBlock = null;
 	let pendingMessageText = null;
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
+	const readOutputIndex = (event) => typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
+	const readIdentityValue = (value) => {
+		return (typeof value === "string" ? value.trim() : "") || void 0;
+	};
+	const readEventToolCallIdentity = (event) => ({ itemId: readIdentityValue(event.item_id) });
+	const readItemToolCallIdentity = (item) => ({
+		itemId: readIdentityValue(item.id),
+		callId: readIdentityValue(item.call_id)
+	});
+	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
+	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
+	const adoptToolCallIdentity = (state, identity) => {
+		state.itemId ??= identity.itemId;
+		state.callId ??= identity.callId;
+		return state;
+	};
+	const resolveCompatibleToolCall = (candidates, identity) => {
+		const uniqueCandidates = [...new Set(candidates)];
+		if (!identity.itemId && !identity.callId) return uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
+		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
+		const matches = compatible.filter((state) => sharesIdentity(state, identity));
+		const matched = matches.length === 1 ? matches.at(0) : void 0;
+		if (matched) return adoptToolCallIdentity(matched, identity);
+		const soleCompatible = uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
+		return soleCompatible ? adoptToolCallIdentity(soleCompatible, identity) : void 0;
+	};
+	const resolveStreamingToolCall = (event, identity = readEventToolCallIdentity(event)) => {
+		const outputIndex = readOutputIndex(event);
+		if (outputIndex !== void 0) {
+			const indexed = toolCallsByOutputIndex.get(outputIndex);
+			if (indexed) return !identitiesConflict(indexed, identity) ? adoptToolCallIdentity(indexed, identity) : void 0;
+			const unindexed = resolveCompatibleToolCall(unindexedToolCalls, identity);
+			if (unindexed) {
+				unindexedToolCalls.delete(unindexed);
+				toolCallsByOutputIndex.set(outputIndex, unindexed);
+			}
+			return unindexed;
+		}
+		return resolveCompatibleToolCall([...toolCallsByOutputIndex.values(), ...unindexedToolCalls], identity);
+	};
+	const forgetStreamingToolCall = (toolCall) => {
+		for (const [trackedIndex, tracked] of toolCallsByOutputIndex) if (tracked === toolCall) toolCallsByOutputIndex.delete(trackedIndex);
+		unindexedToolCalls.delete(toolCall);
+	};
+	const markActiveToolCallArgumentsUnreliable = () => {
+		for (const toolCall of /* @__PURE__ */ new Set([...toolCallsByOutputIndex.values(), ...unindexedToolCalls])) toolCall.argumentStreamReliable = false;
+	};
+	const hasActiveStreamingToolCall = () => toolCallsByOutputIndex.size > 0 || unindexedToolCalls.size > 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 +1759,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 +1770,29 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				});
 			}
 		} else if (item.type === "function_call") {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex !== void 0 && toolCallsByOutputIndex.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
 			currentItem = item;
 			currentBlock = {
 				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 = blockIndex();
+			const toolCallState = {
+				block: currentBlock,
+				contentIndex,
+				argumentStreamReliable: true,
+				...readItemToolCallIdentity(item)
+			};
+			if (outputIndex !== void 0) toolCallsByOutputIndex.set(outputIndex, toolCallState);
+			else unindexedToolCalls.add(toolCallState);
 			stream.push({
 				type: "toolcall_start",
-				contentIndex: blockIndex(),
+				contentIndex,
 				partial: output
 			});
 		}
@@ -1775,34 +1906,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 = resolveStreamingToolCall(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 (hasActiveStreamingToolCall()) markActiveToolCallArgumentsUnreliable();
 	} else if (event.type === "response.function_call_arguments.done") {
-		if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-			const previousPartialJson = currentBlock.partialJson;
+		const toolCall = resolveStreamingToolCall(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 (hasActiveStreamingToolCall()) markActiveToolCallArgumentsUnreliable();
 	} else if (event.type === "response.output_item.done") {
 		const item = event.item;
 		if (item.type !== "message") {
@@ -1846,7 +1980,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 +2006,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 = resolveStreamingToolCall(event, readItemToolCallIdentity(item));
+			if (!streamingToolCall && hasActiveStreamingToolCall()) 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) forgetStreamingToolCall(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 (hasActiveStreamingToolCall()) throw new Error("Responses stream completed with unresolved tool calls");
 		const response = event.response;
 		if (response?.id) output.responseId = response.id;
 		if (response?.usage) {
@@ -1927,6 +2087,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 (hasActiveStreamingToolCall()) throw new Error("Responses stream ended with unresolved tool calls");
 }
 function mapStopReason(status) {
 	if (!status) return "stop";
@@ -1941,4 +2102,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 { supportsOpenAITemperature as A, isOpenAIGpt54MiniModel as C, resolveOpenAIReasoningEffortForModel as D, normalizeOpenAIReasoningEffort as E, stripUnsupportedSchemaKeywords as F, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as I, cleanSchemaForGemini as L, normalizeToolParameterSchema as M, resolveUnsupportedToolSchemaKeywords as N, resolveOpenAISupportedReasoningEfforts as O, shouldOmitEmptyArrayItems as P, resolveResponsesMessageSnapshotCollapse as S, isOpenAIGpt56Model as T, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as _, resolveResponsesReasoningEffort as a, isResponsesTextContentPartType as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as g, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as h, processResponsesStream as i, extractToolSchemaModelCompat as j, supportsOpenAIReasoningEffort as k, findOpenAIStrictToolProjectionDiagnostics as l, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, isAzureResponsesTextDeltaEvent as v, isOpenAIGpt55Model as w, isResponsesTextDeltaEventType as x, isAzureResponsesTextDeltaEventType as y };

package/dist/{openai-tool-projection-BknoV11q.mjs → openai-tool-projection-cTLC4F65.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 { l as isRecord } from "./transform-messages-DNWpwvXA.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-Cvm71xlk.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-B2jr3vtJ.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-D-39Trax.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-DTpD8YVy.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-b4lfJxYS.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-DCA0K85L.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-D6sIQ1bL.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-C7PoDjpW.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-rDGwkoZK.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-L_ABazIA.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() ?? "";

package/dist/{tool-schema-json-projection-BXtBc_mD.mjs → tool-schema-json-projection-BwNu3nDi.mjs}

@@ -1,10 +1,11 @@
+import { types } from "node:util";
 //#region packages/ai/src/providers/tool-schema-json-projection.ts
 function isJsonValue(value) {
 	if (value === null) return true;
 	switch (typeof value) {
 		case "boolean":
-		case "number":
 		case "string": return true;
+		case "number": return Number.isFinite(value);
 		case "object":
 			if (Array.isArray(value)) return value.every(isJsonValue);
 			return Object.values(value).every(isJsonValue);
@@ -14,10 +15,25 @@ function isJsonValue(value) {
 function isJsonObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isNonFiniteNumberValue(value) {
+	if (typeof value === "number") return !Number.isFinite(value);
+	if (value === null || typeof value !== "object" || !types.isNumberObject(value)) return false;
+	return !Number.isFinite(Number.prototype.valueOf.call(value));
+}
 function serializeToolInputSchema(value, path) {
+	const nonFiniteNumber = { path: null };
+	const paths = /* @__PURE__ */ new WeakMap();
+	let isRoot = true;
 	let text;
 	try {
-		text = JSON.stringify(value);
+		text = JSON.stringify(value, function(key, entry) {
+			const holderPath = paths.get(this);
+			const entryPath = isRoot ? path : holderPath === void 0 ? `${path}.${key}` : Array.isArray(this) ? `${holderPath}[${key}]` : `${holderPath}.${key}`;
+			isRoot = false;
+			if (nonFiniteNumber.path === null && isNonFiniteNumberValue(entry)) nonFiniteNumber.path = entryPath;
+			else if (entry && typeof entry === "object") paths.set(entry, entryPath);
+			return entry;
+		});
 	} catch {
 		return {
 			schema: {},
@@ -28,6 +44,10 @@ function serializeToolInputSchema(value, path) {
 		schema: {},
 		violations: [`${path} is not JSON-serializable`]
 	};
+	if (nonFiniteNumber.path !== null) return {
+		schema: {},
+		violations: [`${nonFiniteNumber.path} is not JSON-serializable`]
+	};
 	const parsed = JSON.parse(text);
 	if (!isJsonValue(parsed)) return {
 		schema: {},