@openclaw/ai 2026.9.2 → 2026.9.3

package/dist/{openai-tool-schema-_pTAJqKF.mjs → openai-tool-schema-CzjyYXun.mjs}

@@ -1,433 +1,6 @@
-import { c as normalizeLowercaseStringOrEmpty, o as isRecord } from "./utf16-slice-qz3nsy87.mjs";
-import { n as applyProviderReportedUsageCost, r as calculateCost } from "./sanitize-unicode-D6xUvZaS.mjs";
-import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
-import { r as uniqueValues, t as normalizeStringEntries } from "./string-normalization--fwJ4S2q.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-CGnVB74a.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-mJhXDcyz.mjs";
-import { C as headersToRecord, _ as transportAbortError, f as notifyProviderHttpResponse } from "./transport-stream-shared-CZqMhfIw.mjs";
-//#region packages/ai/src/transports/openai-transport-shared.ts
-/** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
-const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
-const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
-const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
-const log = {
-	debug(message, data) {
-		getAiTransportHost().logDebug("openai-transport", () => ({
-			message,
-			data
-		}));
-	},
-	info(message, data) {
-		getAiTransportHost().logInfo("openai-transport", message, data);
-	},
-	warn(message, data) {
-		getAiTransportHost().logWarn("openai-transport", message, data);
-	}
-};
-function resolveOpenAIClientBaseUrl(model, baseUrl = model.baseUrl) {
-	if (baseUrl?.trim()) return baseUrl;
-	if (model.provider.trim().toLowerCase() === "openai") return;
-	throw new Error(`Provider "${model.provider}" requires an explicit base URL before using an OpenAI-compatible API. Reload provider metadata or configure an endpoint.`);
-}
-const EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH = {
-	deltas: [],
-	mirroredThinking: [],
-	hasThinking: false,
-	hasVisibleText: false
-};
-const OPENAI_COMPLETIONS_REASONING_FIELDS = [
-	"reasoning_content",
-	"reasoning",
-	"reasoning_text"
-];
-function appendOpenAICompletionsReasoningDelta(batch, next) {
-	if (next.kind === "thinking") batch.hasThinking = true;
-	else batch.hasVisibleText = true;
-	const previous = batch.deltas[batch.deltas.length - 1];
-	if (!previous || previous.kind !== next.kind) {
-		batch.deltas.push(next);
-		if (next.kind === "thinking") batch.mirroredThinking.push(next.text);
-		return;
-	}
-	if (next.kind === "thinking" && previous.kind === "thinking") {
-		if (previous.signature !== next.signature) {
-			batch.deltas.push(next);
-			batch.mirroredThinking.push(next.text);
-			return;
-		}
-		previous.text += next.text;
-		batch.mirroredThinking[batch.mirroredThinking.length - 1] += next.text;
-		return;
-	}
-	previous.text += next.text;
-}
-function createOpenAICompletionsReasoningBatch() {
-	return {
-		deltas: [],
-		mirroredThinking: [],
-		hasThinking: false,
-		hasVisibleText: false
-	};
-}
-function readOpenAICompletionsReasoningBatch(delta, visibleReasoningDetailTypes) {
-	let batch;
-	const reasoningDetails = delta.reasoning_details;
-	let usedReasoningThinkingDetails = false;
-	if (Array.isArray(reasoningDetails)) for (const item of reasoningDetails) {
-		if (!isRecord(item)) continue;
-		const detail = item;
-		if (typeof detail.text !== "string" || !detail.text) continue;
-		if (detail.type === "reasoning.text") {
-			usedReasoningThinkingDetails = true;
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "thinking",
-				signature: "reasoning_details",
-				text: detail.text
-			});
-			continue;
-		}
-		if (typeof detail.type === "string" && visibleReasoningDetailTypes.has(detail.type)) {
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "text",
-				text: detail.text,
-				source: "reasoning_detail"
-			});
-		}
-	}
-	if (!usedReasoningThinkingDetails) for (const field of OPENAI_COMPLETIONS_REASONING_FIELDS) {
-		const value = delta[field];
-		if (typeof value === "string" && value.length > 0) {
-			batch ??= createOpenAICompletionsReasoningBatch();
-			appendOpenAICompletionsReasoningDelta(batch, {
-				kind: "thinking",
-				signature: field,
-				text: value
-			});
-			break;
-		}
-	}
-	return batch ?? EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH;
-}
-function parseOpenAICompletionsUsage(rawUsage, model, options) {
-	const cacheRead = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
-	const cacheWrite = rawUsage.prompt_tokens_details?.cache_write_tokens ?? rawUsage.prompt_tokens_details?.cache_creation_input_tokens ?? 0;
-	const input = Math.max(0, (rawUsage.prompt_tokens || 0) - cacheRead - cacheWrite);
-	const output = rawUsage.completion_tokens || 0;
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
-	const usage = {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		...options?.includeReasoningTokens !== false && typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
-		totalTokens: input + output + cacheRead + cacheWrite,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	applyProviderReportedUsageCost(usage, rawUsage.cost);
-	return usage;
-}
-function createOpenAIResponseHook(onResponse, response, model) {
-	return onResponse ? () => onResponse({
-		status: response.status,
-		headers: headersToRecord(response.headers)
-	}, model) : void 0;
-}
-function createOpenAIProviderAcceptanceHook(options, response, model) {
-	return () => notifyProviderHttpResponse({
-		options,
-		response,
-		model
-	});
-}
-function throwIfModelStreamAborted(signal) {
-	if (signal?.aborted) throw transportAbortError(signal);
-}
-/** Measure one UTF-8 append without double-counting a surrogate pair split across chunks. */
-function measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk) {
-	let bytes = Buffer.byteLength(chunk, "utf8");
-	if (!chunk) return {
-		bytes,
-		endsWithHighSurrogate: bufferEndsWithHighSurrogate
-	};
-	const nextCodeUnit = chunk.charCodeAt(0);
-	if (bufferEndsWithHighSurrogate && nextCodeUnit >= 56320 && nextCodeUnit <= 57343) bytes -= 2;
-	const finalCodeUnit = chunk.charCodeAt(chunk.length - 1);
-	return {
-		bytes,
-		endsWithHighSurrogate: finalCodeUnit >= 55296 && finalCodeUnit <= 56319
-	};
-}
-function createModelStreamCooperativeScheduler(signal) {
-	let lastYieldedAt = Date.now();
-	let eventsSinceYield = 0;
-	return { async afterEvent() {
-		throwIfModelStreamAborted(signal);
-		eventsSinceYield += 1;
-		const now = Date.now();
-		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
-		eventsSinceYield = 0;
-		lastYieldedAt = now;
-		await new Promise((resolve) => {
-			setTimeout(resolve, 0);
-		});
-		throwIfModelStreamAborted(signal);
-	} };
-}
-function resolvePromptCacheKey(options, cacheRetention) {
-	if (cacheRetention === "none") return;
-	return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
-}
-function isOpenAICompletionsThinkingEnabled(effort) {
-	const normalized = effort.trim().toLowerCase();
-	return normalized !== "off" && normalized !== "none";
-}
-function readOpenAICompletionsContentDeltas(content, topLevelRefusal, mirroredThinking = []) {
-	let deltas = readOpenAICompletionsContentPartDeltas(content);
-	if (mirroredThinking.length > 0) {
-		const structuredThinking = deltas.filter((delta) => delta.kind === "thinking").map((delta) => delta.text);
-		const mirrorsCombinedThinking = structuredThinking.length > 1 && mirroredThinking.includes(structuredThinking.join(""));
-		deltas = deltas.filter((delta) => delta.kind !== "thinking" || !mirrorsCombinedThinking && !mirroredThinking.includes(delta.text));
-	}
-	if (typeof topLevelRefusal !== "string" || !topLevelRefusal) return deltas;
-	const structuredRefusals = deltas.filter((delta) => delta.kind === "text" && delta.source === "refusal").map((delta) => delta.text);
-	if (structuredRefusals.some((refusal) => refusal === topLevelRefusal) || structuredRefusals.length > 1 && structuredRefusals.join("") === topLevelRefusal) return deltas;
-	return [...deltas, {
-		kind: "text",
-		text: topLevelRefusal,
-		source: "refusal"
-	}];
-}
-function readOpenAICompletionsContentPartDeltas(content) {
-	if (typeof content === "string") return content ? [{
-		kind: "text",
-		text: content
-	}] : [];
-	if (Array.isArray(content)) return content.flatMap(readOpenAICompletionsContentPartDeltas);
-	if (!content || typeof content !== "object") return [];
-	const record = content;
-	const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
-	const extractText = (value) => {
-		if (typeof value === "string") return value;
-		if (Array.isArray(value)) return value.map(extractText).join("");
-		if (value && typeof value === "object") {
-			const nested = value;
-			return extractText(nested.text ?? nested.content ?? nested.thinking ?? nested.refusal);
-		}
-		return "";
-	};
-	const text = extractText(record.text ?? record.content ?? record.thinking ?? record.refusal);
-	if (!text) return [];
-	if (type.includes("thinking") || type.includes("reasoning")) return [{
-		kind: "thinking",
-		text
-	}];
-	if (type === "refusal") return [{
-		kind: "text",
-		text,
-		source: "refusal"
-	}];
-	if (["text", "output_text"].includes(type) || type.endsWith(".output_text")) return [{
-		kind: "text",
-		text
-	}];
-	return [];
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-projection.ts
-function unreadableToolDiagnostic(toolIndex) {
-	return {
-		toolIndex,
-		violations: [`tool[${toolIndex}] is unreadable`]
-	};
-}
-/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
-function projectOpenAITools(tools) {
-	let inputToolCount;
-	try {
-		inputToolCount = tools.length;
-	} catch {
-		return {
-			inputToolCount: 0,
-			tools: [],
-			diagnostics: [unreadableToolDiagnostic(0)]
-		};
-	}
-	const projectedTools = [];
-	const diagnostics = [];
-	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
-		let tool;
-		try {
-			const candidate = tools[toolIndex];
-			if (!candidate) {
-				diagnostics.push(unreadableToolDiagnostic(toolIndex));
-				continue;
-			}
-			tool = candidate;
-		} catch {
-			diagnostics.push(unreadableToolDiagnostic(toolIndex));
-			continue;
-		}
-		let name;
-		try {
-			name = tool.name;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is unreadable`]
-			});
-			continue;
-		}
-		if (typeof name !== "string" || !name) {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is empty`]
-			});
-			continue;
-		}
-		let parameters;
-		try {
-			parameters = tool.parameters;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: [`${name}.parameters is unreadable`]
-			});
-			continue;
-		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
-		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
-			});
-			continue;
-		}
-		let descriptionValue;
-		try {
-			descriptionValue = tool.description;
-		} catch {}
-		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
-		projectedTools.push({
-			toolIndex,
-			name,
-			...description !== void 0 ? { description } : {},
-			parameters: schemaProjection.schema
-		});
-	}
-	return {
-		inputToolCount,
-		tools: projectedTools,
-		diagnostics
-	};
-}
-function requireProjectedFunction(name, projection, choiceLabel) {
-	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
-}
-/** Keeps Responses tool choices aligned with surviving function schemas. */
-function reconcileOpenAIResponsesToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "function") {
-		const functionName = choice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
-		return {
-			type: "function",
-			name: functionName
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const mode = choice.mode;
-	const tools = choice.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") {
-			normalizedAllowedTools.push(tool);
-			continue;
-		}
-		const functionName = tool.name;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			name: functionName
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		mode,
-		tools: normalizedAllowedTools
-	};
-}
-/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
-function reconcileOpenAICompletionsToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
-	if (choiceType === "function") {
-		const functionChoice = choice.function;
-		if (!isRecord(functionChoice)) return choice;
-		const functionName = functionChoice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
-		return {
-			type: "function",
-			function: { name: functionName }
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const allowedConfig = choice.allowed_tools;
-	if (!isRecord(allowedConfig)) return choice;
-	const mode = allowedConfig.mode;
-	const tools = allowedConfig.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") continue;
-		const functionChoice = tool.function;
-		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			function: { name: functionName }
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		allowed_tools: {
-			mode,
-			tools: normalizedAllowedTools
-		}
-	};
-}
-//#endregion
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { r as uniqueValues, t as normalizeStringEntries } from "./string-normalization-CmLIasuf.mjs";
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"patternProperties",
@@ -969,136 +542,46 @@ function isTypedObjectSchemaMissingValidProperties(schemaRecord, conditionalKey)
 function isTrulyEmptySchema(schemaRecord) {
 	return Object.keys(schemaRecord).length === 0;
 }
-function normalizeArraySchemasMissingItems(schema) {
-	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const nextSchema = { ...schema };
-	if (nextSchema.type === "array" && nextSchema.items === void 0) {
-		nextSchema.items = {};
-		changed = true;
-	}
-	const normalizeSchemaValue = (key) => {
-		if (!(key in nextSchema)) return;
-		const value = nextSchema[key];
-		if (Array.isArray(value)) {
-			const normalized = value.map(normalizeArraySchemasMissingItems);
-			if (normalized.some((entry, index) => entry !== value[index])) {
-				nextSchema[key] = normalized;
-				changed = true;
-			}
-			return;
-		}
-		const normalized = normalizeArraySchemasMissingItems(value);
-		if (normalized !== value) {
-			nextSchema[key] = normalized;
-			changed = true;
-		}
-	};
-	for (const key of [
-		"items",
-		"contains",
-		"additionalProperties",
-		"propertyNames",
-		"not",
-		"if",
-		"then",
-		"else"
-	]) normalizeSchemaValue(key);
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf",
-		"prefixItems"
-	]) normalizeSchemaValue(key);
-	for (const key of [
-		"properties",
-		"patternProperties",
-		"dependentSchemas",
-		"$defs",
-		"definitions"
-	]) {
-		const value = nextSchema[key];
-		if (!isRecord(value)) continue;
-		let entriesChanged = false;
-		const normalizedEntries = Object.entries(value).map(([entryKey, entryValue]) => {
-			const normalizedEntryValue = normalizeArraySchemasMissingItems(entryValue);
-			if (normalizedEntryValue !== entryValue) entriesChanged = true;
-			return [entryKey, normalizedEntryValue];
-		});
-		if (entriesChanged) {
-			nextSchema[key] = Object.fromEntries(normalizedEntries);
-			changed = true;
-		}
-	}
-	return changed ? nextSchema : schema;
-}
-function schemaAllowsArrayType(schema) {
-	const type = schema.type;
-	return type === "array" || Array.isArray(type) && type.includes("array");
-}
-const ARRAY_ITEMS_SCHEMA_OBJECT_KEYS = /* @__PURE__ */ new Set([
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then"
-]);
-const ARRAY_ITEMS_SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-const ARRAY_ITEMS_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
-function stripEmptyArrayItemsFromArraySchemas(schema) {
+function normalizeArraySchemaItems(schema, mode) {
 	if (Array.isArray(schema)) {
-		let changed = false;
-		const entries = schema.map((entry) => {
-			const next = stripEmptyArrayItemsFromArraySchemas(entry);
-			changed ||= next !== entry;
-			return next;
-		});
-		return changed ? entries : schema;
+		if (mode === "add") return schema;
+		const entries = schema.map((entry) => normalizeArraySchemaItems(entry, "omit"));
+		return entries.some((entry, index) => entry !== schema[index]) ? entries : schema;
 	}
 	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const entries = Object.entries(schema).flatMap(([key, value]) => {
-		if (key === "items" && schemaAllowsArrayType(schema) && isRecord(value) && isTrulyEmptySchema(value)) {
+	const missingItems = mode !== "omit" && schema.type === "array" && schema.items === void 0;
+	let changed = missingItems;
+	const normalized = { ...schema };
+	if (missingItems) {
+		if (mode === "add") normalized.items = {};
+		else delete normalized.items;
+	}
+	const allowsArray = schema.type === "array" || Array.isArray(schema.type) && schema.type.includes("array");
+	const normalizeValue = (value, valueMode) => {
+		if (!Array.isArray(value)) return normalizeArraySchemaItems(value, valueMode);
+		const entries = value.map((entry) => normalizeArraySchemaItems(entry, valueMode));
+		return entries.some((entry, index) => entry !== value[index]) ? entries : value;
+	};
+	for (const [key, value] of Object.entries(normalized)) {
+		if (mode !== "add" && key === "items" && allowsArray && isRecord(value) && isTrulyEmptySchema(value)) {
+			delete normalized.items;
 			changed = true;
-			return [];
-		}
-		if (ARRAY_ITEMS_SCHEMA_OBJECT_KEYS.has(key)) {
-			const next = stripEmptyArrayItemsFromArraySchemas(value);
-			changed ||= next !== value;
-			return [[key, next]];
+			continue;
 		}
-		if (ARRAY_ITEMS_SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const next = stripEmptyArrayItemsFromArraySchemas(value);
-			changed ||= next !== value;
-			return [[key, next]];
+		let next = value;
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			const entries = Object.entries(value).map(([entryKey, entry]) => [entryKey, normalizeArraySchemaItems(entry, mode)]);
+			if (entries.some(([entryKey, entry]) => entry !== value[entryKey])) next = Object.fromEntries(entries);
+		} else if (SCHEMA_OBJECT_KEYS.has(key) || SCHEMA_ARRAY_KEYS.has(key)) {
+			const valueMode = SCHEMA_OBJECT_KEYS.has(key) || Array.isArray(value) ? mode : "add";
+			if (valueMode === mode || mode !== "omit") next = normalizeValue(value, valueMode);
 		}
-		if (ARRAY_ITEMS_SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			let mapChanged = false;
-			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
-				const entryNext = stripEmptyArrayItemsFromArraySchemas(entryValue);
-				mapChanged ||= entryNext !== entryValue;
-				return [entryKey, entryNext];
-			}));
-			changed ||= mapChanged;
-			return [[key, mapChanged ? next : value]];
+		if (next !== value) {
+			setOwnSchemaProperty(normalized, key, next);
+			changed = true;
 		}
-		return [[key, value]];
-	});
-	return changed ? Object.fromEntries(entries) : schema;
+	}
+	return changed ? normalized : schema;
 }
 function copySchemaMeta(from, to) {
 	for (const key of [
@@ -1353,8 +836,7 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
 	const isLlamacppGbnfProfile = normalizedToolSchemaProfile === "llamacpp";
 	function applyProviderCleaning(s) {
-		const normalizedSchema = normalizeArraySchemasMissingItems(s);
-		let arrayItemsCompatibleSchema = omitEmptyArrayItems ? stripEmptyArrayItemsFromArraySchemas(normalizedSchema) : normalizedSchema;
+		let arrayItemsCompatibleSchema = normalizeArraySchemaItems(s, omitEmptyArrayItems ? "normalize" : "add");
 		if (isLlamacppGbnfProfile) arrayItemsCompatibleSchema = cleanSchemaForLlamacppGbnf(arrayItemsCompatibleSchema);
 		if (isGeminiProvider && !isAnthropicProvider) {
 			const geminiCompatibleSchema = cleanSchemaForGemini(arrayItemsCompatibleSchema);
@@ -1682,4 +1164,4 @@ function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
 }
 //#endregion
-export { readOpenAICompletionsReasoningBatch as A, createOpenAIProviderAcceptanceHook as C, measureUtf8AppendBytes as D, log as E, resolvePromptCacheKey as M, throwIfModelStreamAborted as N, parseOpenAICompletionsUsage as O, createModelStreamCooperativeScheduler as S, isOpenAICompletionsThinkingEnabled as T, cleanSchemaForGemini as _, resolveOpenAIProjectedToolsStrictToolFlag as a, reconcileOpenAIResponsesToolChoice as b, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, stripUnsupportedSchemaKeywords as f, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as g, findLlamacppGbnfSchemaViolations as h, normalizeStrictOpenAIJsonSchema as i, resolveOpenAIClientBaseUrl as j, readOpenAICompletionsContentDeltas as k, normalizeToolParameterSchema as l, cleanSchemaForLlamacppGbnf as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u, projectOpenAITools as v, createOpenAIResponseHook as w, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as x, reconcileOpenAICompletionsToolChoice as y };
+export { cleanSchemaForGemini as _, resolveOpenAIProjectedToolsStrictToolFlag as a, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, stripUnsupportedSchemaKeywords as f, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as g, findLlamacppGbnfSchemaViolations as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, cleanSchemaForLlamacppGbnf as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u };

package/dist/openai-tool-schema-ynZBgqW-.d.mts

@@ -0,0 +1,38 @@
+import { n as OpenAIToolProjection } from "./openai-tool-projection-793cE3QX.mjs";
+import { TSchema } from "typebox";
+//#region packages/ai/src/providers/openai-tool-schema-compat.d.ts
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+declare function normalizeOpenAIStrictCompatSchema(schema: unknown): TSchema;
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+declare function findOpenAIStrictSchemaViolations(schema: unknown, path: string, options?: {
+  requireObjectRoot?: boolean;
+}): string[];
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema.d.ts
+/**
+ * OpenAI strict-tool-schema normalization and diagnostics.
+ *
+ * Strict schemas need all object properties required and `additionalProperties: false`; model
+ * compatibility settings can also remove unsupported schema constructs before strict checks run.
+ */
+type ToolSchemaCompatInput = {
+  unsupportedToolSchemaKeywords?: unknown;
+  omitEmptyArrayItems?: unknown;
+};
+/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
+declare function normalizeStrictOpenAIJsonSchema(schema: unknown, modelCompat?: ToolSchemaCompatInput | null): unknown;
+/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
+declare function normalizeOpenAIStrictToolParameters<T>(schema: T, strict: boolean, modelCompat?: ToolSchemaCompatInput | null): T;
+/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
+declare function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean;
+type OpenAIStrictToolSchemaDiagnostic = {
+  toolIndex: number;
+  toolName?: string;
+  violations: string[];
+};
+/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
+declare function findOpenAIStrictToolProjectionDiagnostics(projection: OpenAIToolProjection): OpenAIStrictToolSchemaDiagnostic[];
+/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
+declare function resolveOpenAIProjectedToolsStrictToolFlag(projection: OpenAIToolProjection, strict: boolean | null | undefined): boolean | undefined;
+//#endregion
+export { resolveOpenAIProjectedToolsStrictToolFlag as a, normalizeStrictOpenAIJsonSchema as i, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t };