@openclaw/ai 2026.8.1-beta.3 → 2026.8.2

package/dist/openai-tool-schema-CSMh5e9O.mjs

@@ -0,0 +1,1697 @@
+import { c as normalizeLowercaseStringOrEmpty, o as isRecord } from "./utf16-slice-qz3nsy87.mjs";
+import { n as applyProviderReportedUsageCost, r as calculateCost } from "./sanitize-unicode-S6binQG-.mjs";
+import { n as getAiTransportHost } from "./host-BIaiBURL.mjs";
+import { r as uniqueValues, t as normalizeStringEntries } from "./string-normalization--fwJ4S2q.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BtZiml7r.mjs";
+import { C as headersToRecord, _ as transportAbortError, f as notifyProviderHttpResponse } from "./transport-stream-shared-D8nQWCUo.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
+//#region packages/ai/src/providers/clean-for-gemini.ts
+const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+	"patternProperties",
+	"additionalProperties",
+	"$schema",
+	"$id",
+	"$ref",
+	"$defs",
+	"definitions",
+	"examples",
+	"minLength",
+	"maxLength",
+	"minimum",
+	"maximum",
+	"multipleOf",
+	"pattern",
+	"format",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"minProperties",
+	"maxProperties",
+	"not"
+]);
+const SCHEMA_META_KEYS = [
+	"description",
+	"title",
+	"default"
+];
+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 = [];
+	let commonType = null;
+	for (const variant of variants) {
+		if (!variant || typeof variant !== "object") return null;
+		const v = variant;
+		let literalValue;
+		if ("const" in v) literalValue = v.const;
+		else if (Array.isArray(v.enum) && v.enum.length === 1) literalValue = v.enum[0];
+		else return null;
+		const variantType = typeof v.type === "string" ? v.type : null;
+		if (!variantType) return null;
+		if (commonType === null) commonType = variantType;
+		else if (commonType !== variantType) return null;
+		allValues.push(literalValue);
+	}
+	if (commonType && allValues.length > 0) return {
+		type: commonType,
+		enum: allValues
+	};
+	return null;
+}
+function isNullSchema(variant) {
+	if (!variant || typeof variant !== "object" || Array.isArray(variant)) return false;
+	const record = variant;
+	if ("const" in record && record.const === null) return true;
+	if (Array.isArray(record.enum) && record.enum.length === 1) return record.enum[0] === null;
+	const typeValue = record.type;
+	if (typeValue === "null") return true;
+	if (Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null") return true;
+	return false;
+}
+function stripNullVariants(variants) {
+	if (variants.length === 0) return {
+		variants,
+		stripped: false
+	};
+	const nonNull = variants.filter((variant) => !isNullSchema(variant));
+	return {
+		variants: nonNull,
+		stripped: nonNull.length !== variants.length
+	};
+}
+function extendSchemaDefs$1(defs, schema) {
+	const defsEntry = schema.$defs && typeof schema.$defs === "object" && !Array.isArray(schema.$defs) ? schema.$defs : void 0;
+	const legacyDefsEntry = schema.definitions && typeof schema.definitions === "object" && !Array.isArray(schema.definitions) ? schema.definitions : void 0;
+	if (!defsEntry && !legacyDefsEntry) return defs;
+	const next = defs ? new Map(defs) : /* @__PURE__ */ new Map();
+	if (defsEntry) for (const [key, value] of Object.entries(defsEntry)) next.set(key, value);
+	if (legacyDefsEntry) for (const [key, value] of Object.entries(legacyDefsEntry)) next.set(key, value);
+	return next;
+}
+function decodeJsonPointerSegment$1(segment) {
+	return segment.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function tryResolveLocalRef$1(ref, defs) {
+	if (!defs) return;
+	const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+	if (!match) return;
+	const name = decodeJsonPointerSegment$1(match[1] ?? "");
+	if (!name) return;
+	return defs.get(name);
+}
+function simplifyUnionVariants(params) {
+	const { obj, variants } = params;
+	const { variants: nonNullVariants, stripped } = stripNullVariants(variants);
+	const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
+	if (flattened) {
+		const result = {
+			type: flattened.type,
+			enum: flattened.enum
+		};
+		copySchemaMeta$1(obj, result);
+		return {
+			kind: "simplified",
+			value: result
+		};
+	}
+	if (stripped && nonNullVariants.length === 1) {
+		const lone = nonNullVariants[0];
+		if (lone && typeof lone === "object" && !Array.isArray(lone)) {
+			const result = { ...lone };
+			copySchemaMeta$1(obj, result);
+			return {
+				kind: "simplified",
+				value: result
+			};
+		}
+		return {
+			kind: "simplified",
+			value: lone
+		};
+	}
+	return {
+		kind: "variants",
+		value: stripped ? nonNullVariants : variants
+	};
+}
+function sanitizeRequiredFields(schema) {
+	if (!Array.isArray(schema.required)) return schema;
+	if (!schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
+		if (schema.type === "object") delete schema.required;
+		return schema;
+	}
+	const properties = schema.properties;
+	const required = schema.required.filter((key) => typeof key === "string" && Object.hasOwn(properties, key));
+	if (required.length > 0) schema.required = required;
+	else delete schema.required;
+	return schema;
+}
+function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
+	if (!schema || typeof schema !== "object") return schema;
+	if (Array.isArray(schema)) return schema.map((item) => cleanSchemaForGeminiWithDefs(item, defs, refStack));
+	const obj = schema;
+	const nextDefs = extendSchemaDefs$1(defs, obj);
+	const refValue = typeof obj.$ref === "string" ? obj.$ref : void 0;
+	if (refValue) {
+		if (refStack?.has(refValue)) return {};
+		const resolved = tryResolveLocalRef$1(refValue, nextDefs);
+		if (resolved) {
+			const nextRefStack = refStack ? new Set(refStack) : /* @__PURE__ */ new Set();
+			nextRefStack.add(refValue);
+			const cleaned = cleanSchemaForGeminiWithDefs(resolved, nextDefs, nextRefStack);
+			if (!cleaned || typeof cleaned !== "object" || Array.isArray(cleaned)) return cleaned;
+			const result = { ...cleaned };
+			copySchemaMeta$1(obj, result);
+			return result;
+		}
+		const result = {};
+		copySchemaMeta$1(obj, result);
+		return result;
+	}
+	const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
+	const hasOneOf = "oneOf" in obj && Array.isArray(obj.oneOf);
+	let cleanedAnyOf = hasAnyOf ? obj.anyOf.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack)) : void 0;
+	let cleanedOneOf = hasOneOf ? obj.oneOf.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack)) : void 0;
+	if (hasAnyOf) {
+		const simplified = simplifyUnionVariants({
+			obj,
+			variants: cleanedAnyOf ?? []
+		});
+		if (simplified.kind === "simplified") return simplified.value;
+		cleanedAnyOf = simplified.value;
+	}
+	if (hasOneOf) {
+		const simplified = simplifyUnionVariants({
+			obj,
+			variants: cleanedOneOf ?? []
+		});
+		if (simplified.kind === "simplified") return simplified.value;
+		cleanedOneOf = simplified.value;
+	}
+	const cleaned = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) continue;
+		if (key === "const") {
+			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;
+		if (key === "type" && (hasAnyOf || hasOneOf)) continue;
+		if (key === "type" && Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+			const types = value.filter((entry) => entry !== "null");
+			cleaned.type = types.length === 1 ? types[0] : types;
+			continue;
+		}
+		if (key === "properties") {
+			if (value && typeof value === "object" && !Array.isArray(value)) cleaned[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cleanSchemaForGeminiWithDefs(v, nextDefs, refStack)]));
+			else cleaned[key] = {};
+		} else if (key === "items" && value) {
+			if (Array.isArray(value)) cleaned[key] = value.map((entry) => cleanSchemaForGeminiWithDefs(entry, nextDefs, refStack));
+			else if (typeof value === "object") cleaned[key] = cleanSchemaForGeminiWithDefs(value, nextDefs, refStack);
+			else cleaned[key] = value;
+		} else if (key === "anyOf" && Array.isArray(value)) cleaned[key] = cleanedAnyOf ?? value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
+		else if (key === "oneOf" && Array.isArray(value)) cleaned[key] = cleanedOneOf ?? value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
+		else if (key === "allOf" && Array.isArray(value)) cleaned[key] = value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
+		else cleaned[key] = value;
+	}
+	if (cleaned.anyOf && Array.isArray(cleaned.anyOf)) {
+		const flattened = flattenUnionFallback(cleaned, cleaned.anyOf);
+		if (flattened) return sanitizeRequiredFields(flattened);
+	}
+	if (cleaned.oneOf && Array.isArray(cleaned.oneOf)) {
+		const flattened = flattenUnionFallback(cleaned, cleaned.oneOf);
+		if (flattened) return sanitizeRequiredFields(flattened);
+	}
+	return sanitizeRequiredFields(cleaned);
+}
+/**
+* Last-resort flattening for anyOf/oneOf arrays that could not be simplified
+* by `simplifyUnionVariants`. Picks a representative type so the schema is
+* accepted by Google's restricted JSON Schema validation.
+*/
+function flattenUnionFallback(obj, variants) {
+	const objects = variants.filter((v) => Boolean(v) && typeof v === "object");
+	if (objects.length === 0) return;
+	const types = new Set(objects.map((v) => v.type).filter(Boolean));
+	if (objects.length === 1) {
+		const merged = { ...objects[0] };
+		copySchemaMeta$1(obj, merged);
+		return merged;
+	}
+	if (types.size === 1) {
+		const merged = { type: Array.from(types)[0] };
+		copySchemaMeta$1(obj, merged);
+		return merged;
+	}
+	const first = objects[0];
+	if (first?.type) {
+		const merged = { type: first.type };
+		copySchemaMeta$1(obj, merged);
+		return merged;
+	}
+	const merged = {};
+	copySchemaMeta$1(obj, merged);
+	return merged;
+}
+function cleanSchemaForGemini(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
+	return cleanSchemaForGeminiWithDefs(schema, extendSchemaDefs$1(void 0, schema), void 0);
+}
+//#endregion
+//#region packages/ai/src/providers/clean-for-llamacpp-gbnf.ts
+/** llama.cpp rejects grammar repetitions whose expanded rule count reaches 2000. */
+const LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD = 2e3;
+const SCHEMA_MAP_KEYS$2 = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const SCHEMA_CHILD_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function cleanSchemaNode(node) {
+	if (Array.isArray(node)) {
+		let changed = false;
+		const entries = node.map((entry) => {
+			const next = cleanSchemaNode(entry);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? entries : node;
+	}
+	if (!isRecord(node)) return node;
+	let changed = false;
+	const cleaned = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "pattern") {
+			changed = true;
+			continue;
+		}
+		if (key === "maxLength" && typeof value === "number" && value >= 2e3) {
+			changed = true;
+			continue;
+		}
+		let next = value;
+		if (SCHEMA_MAP_KEYS$2.has(key) && isRecord(value)) {
+			let mapChanged = false;
+			next = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => {
+				const cleanedChild = cleanSchemaNode(childValue);
+				mapChanged ||= cleanedChild !== childValue;
+				return [childKey, cleanedChild];
+			}));
+			if (!mapChanged) next = value;
+		} else if (SCHEMA_CHILD_KEYS.has(key)) next = cleanSchemaNode(value);
+		cleaned[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? cleaned : node;
+}
+function collectSchemaViolations(node, path, violations) {
+	if (Array.isArray(node)) {
+		node.forEach((entry, index) => collectSchemaViolations(entry, `${path}[${index}]`, violations));
+		return;
+	}
+	if (!isRecord(node)) return;
+	if ("pattern" in node) violations.push(`${path}.pattern`);
+	if (typeof node.maxLength === "number" && node.maxLength >= 2e3) violations.push(`${path}.maxLength`);
+	for (const [key, value] of Object.entries(node)) if (SCHEMA_MAP_KEYS$2.has(key) && isRecord(value)) for (const [childKey, childValue] of Object.entries(value)) collectSchemaViolations(childValue, `${path}.${key}.${childKey}`, violations);
+	else if (SCHEMA_CHILD_KEYS.has(key)) collectSchemaViolations(value, `${path}.${key}`, violations);
+}
+/** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
+function cleanSchemaForLlamacppGbnf(schema) {
+	return cleanSchemaNode(schema);
+}
+/** Reports schema paths that llama.cpp cannot compile into GBNF. */
+function findLlamacppGbnfSchemaViolations(schema, path) {
+	const violations = [];
+	collectSchemaViolations(schema, path, violations);
+	return violations;
+}
+//#endregion
+//#region packages/ai/src/providers/schema-keyword-strip.ts
+const SCHEMA_MAP_KEYS$1 = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+/** Containers whose value is a single nested schema. */
+const SCHEMA_OBJECT_KEYS$1 = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+/** Containers whose value is a list of nested schemas. */
+const SCHEMA_ARRAY_KEYS$1 = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"items",
+	"oneOf",
+	"prefixItems"
+]);
+/** Recursively remove schema keywords unsupported by a target provider/tool surface. */
+function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
+	if (!schema || typeof schema !== "object") return schema;
+	if (Array.isArray(schema)) return schema.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
+	const obj = schema;
+	const cleaned = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (unsupportedKeywords.has(key)) continue;
+		if (SCHEMA_MAP_KEYS$1.has(key) && value && typeof value === "object" && !Array.isArray(value)) {
+			cleaned[key] = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [childKey, stripUnsupportedSchemaKeywords(childValue, unsupportedKeywords)]));
+			continue;
+		}
+		if (SCHEMA_ARRAY_KEYS$1.has(key) && Array.isArray(value)) {
+			cleaned[key] = value.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
+			continue;
+		}
+		if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") {
+			cleaned[key] = stripUnsupportedSchemaKeywords(value, unsupportedKeywords);
+			continue;
+		}
+		cleaned[key] = value;
+	}
+	return cleaned;
+}
+//#endregion
+//#region packages/ai/src/providers/agent-tools-parameter-schema.ts
+/**
+* Normalizes model-facing tool parameter schemas across provider quirks.
+* Handles local JSON Schema refs, OpenAPI nullable syntax, top-level unions,
+* and provider-specific unsupported keyword stripping.
+*/
+/** Extracts the compat record whether callers pass a model (`{ compat }`) or the compat itself. */
+function extractToolSchemaModelCompat(modelOrCompat) {
+	if (!modelOrCompat || typeof modelOrCompat !== "object") return;
+	if ("compat" in modelOrCompat) {
+		const compat = modelOrCompat.compat;
+		return compat && typeof compat === "object" ? compat : void 0;
+	}
+	return modelOrCompat;
+}
+/** JSON Schema keywords this model/provider rejects in tool schemas. */
+function resolveUnsupportedToolSchemaKeywords(modelOrCompat) {
+	const keywords = extractToolSchemaModelCompat(modelOrCompat)?.unsupportedToolSchemaKeywords ?? [];
+	return new Set(normalizeStringEntries(keywords.filter((keyword) => typeof keyword === "string")));
+}
+/** Whether empty `items: {}` on array schemas must be omitted for this model/provider. */
+function shouldOmitEmptyArrayItems(modelOrCompat) {
+	return extractToolSchemaModelCompat(modelOrCompat)?.omitEmptyArrayItems === true;
+}
+const MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
+const toolParameterSchemaCache = /* @__PURE__ */ new WeakMap();
+function resolveToolParameterSchemaCacheKey(options) {
+	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
+	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
+	const toolSchemaProfile = normalizeLowercaseStringOrEmpty(options?.modelCompat?.toolSchemaProfile);
+	const unsupportedKeywords = Array.from(resolveUnsupportedToolSchemaKeywords(options?.modelCompat)).toSorted();
+	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
+	return JSON.stringify([
+		normalizedProvider,
+		normalizedModelId,
+		toolSchemaProfile,
+		unsupportedKeywords,
+		omitEmptyArrayItems
+	]);
+}
+function getCachedToolParameterSchema(schema, key) {
+	return toolParameterSchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
+}
+function rememberCachedToolParameterSchema(schema, key, value) {
+	const entries = toolParameterSchemaCache.get(schema) ?? [];
+	toolParameterSchemaCache.set(schema, [{
+		key,
+		value
+	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
+	return value;
+}
+function isGeminiModelId(modelId) {
+	return /(?:^|[/:])gemini(?:$|[-/:.])/.test(modelId);
+}
+function extractEnumValues(schema) {
+	if (!schema || typeof schema !== "object") return;
+	const record = schema;
+	if (Array.isArray(record.enum)) return record.enum;
+	if ("const" in record) return [record.const];
+	const variants = Array.isArray(record.anyOf) ? record.anyOf : Array.isArray(record.oneOf) ? record.oneOf : null;
+	if (variants) {
+		const values = variants.flatMap((variant) => {
+			return extractEnumValues(variant) ?? [];
+		});
+		return values.length > 0 ? values : void 0;
+	}
+}
+function mergePropertySchemas(existing, incoming) {
+	if (!existing) return incoming;
+	if (!incoming) return existing;
+	const existingEnum = extractEnumValues(existing);
+	const incomingEnum = extractEnumValues(incoming);
+	if (existingEnum || incomingEnum) {
+		const values = uniqueValues([...existingEnum ?? [], ...incomingEnum ?? []]);
+		const merged = {};
+		for (const source of [existing, incoming]) {
+			if (!source || typeof source !== "object") continue;
+			const record = source;
+			for (const key of [
+				"title",
+				"description",
+				"default"
+			]) if (!(key in merged) && key in record) merged[key] = record[key];
+		}
+		const types = new Set(values.map((value) => typeof value));
+		if (types.size === 1) merged.type = Array.from(types)[0];
+		merged.enum = values;
+		return merged;
+	}
+	return existing;
+}
+function setOwnSchemaProperty(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
+function hasTopLevelArrayKeyword(schemaRecord, key) {
+	return Array.isArray(schemaRecord[key]);
+}
+function getFlattenableVariantKey(schemaRecord) {
+	if (hasTopLevelArrayKeyword(schemaRecord, "anyOf")) return "anyOf";
+	if (hasTopLevelArrayKeyword(schemaRecord, "oneOf")) return "oneOf";
+	return null;
+}
+function getTopLevelConditionalKey(schemaRecord) {
+	return getFlattenableVariantKey(schemaRecord) ?? (hasTopLevelArrayKeyword(schemaRecord, "allOf") ? "allOf" : null);
+}
+function hasTopLevelObjectSchema(schemaRecord, conditionalKey) {
+	return schemaRecord.type === "object" && isRecord(schemaRecord.properties) && conditionalKey === null;
+}
+function isObjectLikeSchemaMissingType(schemaRecord, conditionalKey) {
+	return !("type" in schemaRecord) && (isRecord(schemaRecord.properties) || Array.isArray(schemaRecord.required)) && conditionalKey === null;
+}
+function isTypedObjectSchemaMissingValidProperties(schemaRecord, conditionalKey) {
+	return schemaRecord.type === "object" && !isRecord(schemaRecord.properties) && conditionalKey === null;
+}
+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) {
+	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 (!isRecord(schema)) return schema;
+	let changed = false;
+	const entries = Object.entries(schema).flatMap(([key, value]) => {
+		if (key === "items" && schemaAllowsArrayType(schema) && isRecord(value) && isTrulyEmptySchema(value)) {
+			changed = true;
+			return [];
+		}
+		if (ARRAY_ITEMS_SCHEMA_OBJECT_KEYS.has(key)) {
+			const next = stripEmptyArrayItemsFromArraySchemas(value);
+			changed ||= next !== value;
+			return [[key, next]];
+		}
+		if (ARRAY_ITEMS_SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+			const next = stripEmptyArrayItemsFromArraySchemas(value);
+			changed ||= next !== value;
+			return [[key, next]];
+		}
+		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]];
+		}
+		return [[key, value]];
+	});
+	return changed ? Object.fromEntries(entries) : schema;
+}
+function copySchemaMeta(from, to) {
+	for (const key of [
+		"title",
+		"description",
+		"default"
+	]) if (key in from && from[key] !== void 0) to[key] = from[key];
+}
+function extendSchemaDefs(defs, schema) {
+	const defsEntry = schema.$defs && typeof schema.$defs === "object" && !Array.isArray(schema.$defs) ? schema.$defs : void 0;
+	const legacyDefsEntry = schema.definitions && typeof schema.definitions === "object" && !Array.isArray(schema.definitions) ? schema.definitions : void 0;
+	if (!defsEntry && !legacyDefsEntry) return defs;
+	const next = defs ? {
+		$defs: new Map(defs.$defs),
+		definitions: new Map(defs.definitions)
+	} : {
+		$defs: /* @__PURE__ */ new Map(),
+		definitions: /* @__PURE__ */ new Map()
+	};
+	if (defsEntry) for (const [key, value] of Object.entries(defsEntry)) next.$defs.set(key, value);
+	if (legacyDefsEntry) for (const [key, value] of Object.entries(legacyDefsEntry)) next.definitions.set(key, value);
+	return next;
+}
+function decodeJsonPointerSegment(segment) {
+	return segment.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function resolveJsonPointerPath(value, segments) {
+	let current = value;
+	for (const segment of segments) {
+		if (!current || typeof current !== "object") return;
+		const key = decodeJsonPointerSegment(segment);
+		if (Array.isArray(current)) {
+			const index = /^(?:0|[1-9]\d*)$/.test(key) ? Number(key) : -1;
+			if (index < 0 || index >= current.length) return;
+			current = current[index];
+			continue;
+		}
+		const record = current;
+		if (!Object.hasOwn(record, key)) return;
+		current = record[key];
+	}
+	return current;
+}
+function resolveLocalJsonPointer(rootDocument, ref) {
+	if (!ref.startsWith("#/")) return;
+	return resolveJsonPointerPath(rootDocument, ref.slice(2).split("/"));
+}
+const SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const SCHEMA_OBJECT_KEYS = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then"
+]);
+const SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"items",
+	"oneOf",
+	"prefixItems"
+]);
+const SCHEMA_LITERAL_KEYS = /* @__PURE__ */ new Set([
+	"const",
+	"default",
+	"enum",
+	"examples"
+]);
+function tryResolveLocalRef(ref, defs, rootDocument) {
+	const match = ref.match(/^#\/(\$defs|definitions)\/([^/]+)(?:\/(.*))?$/);
+	if (match && defs) {
+		const namespace = match[1] === "$defs" ? defs.$defs : defs.definitions;
+		const name = decodeJsonPointerSegment(match[2] ?? "");
+		const resolved = name ? namespace.get(name) : void 0;
+		if (resolved !== void 0) return resolveJsonPointerPath(resolved, match[3] ? match[3].split("/") : []);
+	}
+	return resolveLocalJsonPointer(rootDocument, ref);
+}
+function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocument) {
+	if (!schema || typeof schema !== "object") return schema;
+	if (Array.isArray(schema)) return schema.map((entry) => inlineLocalSchemaRefsWithDefs(entry, defs, refStack, state, rootDocument));
+	const obj = schema;
+	const nextDefs = extendSchemaDefs(defs, obj);
+	const refValue = typeof obj.$ref === "string" ? obj.$ref : void 0;
+	if (refValue) {
+		if (refStack?.has(refValue)) return {};
+		const resolved = tryResolveLocalRef(refValue, nextDefs, rootDocument);
+		if (resolved === void 0) {
+			if (refValue.startsWith("#/")) state.unresolvedLocalRefs = true;
+			return { ...obj };
+		}
+		const nextRefStack = refStack ? new Set(refStack) : /* @__PURE__ */ new Set();
+		nextRefStack.add(refValue);
+		const inlined = inlineLocalSchemaRefsWithDefs(resolved, nextDefs, nextRefStack, state, rootDocument);
+		if (!inlined || typeof inlined !== "object" || Array.isArray(inlined)) return inlined;
+		const result = { ...inlined };
+		copySchemaMeta(obj, result);
+		if (obj.nullable === true) result.nullable = true;
+		return result;
+	}
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (key === "$defs" || key === "definitions" || key === "components") continue;
+		if (SCHEMA_LITERAL_KEYS.has(key)) {
+			setOwnSchemaProperty(result, key, value);
+			continue;
+		}
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			setOwnSchemaProperty(result, key, Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, inlineLocalSchemaRefsWithDefs(entryValue, nextDefs, refStack, state, rootDocument)])));
+			continue;
+		}
+		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
+			setOwnSchemaProperty(result, key, inlineLocalSchemaRefsWithDefs(value, nextDefs, refStack, state, rootDocument));
+			continue;
+		}
+		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+			setOwnSchemaProperty(result, key, value.map((entry) => inlineLocalSchemaRefsWithDefs(entry, nextDefs, refStack, state, rootDocument)));
+			continue;
+		}
+		setOwnSchemaProperty(result, key, value);
+	}
+	if (state.unresolvedLocalRefs) {
+		if ("$defs" in obj) result.$defs = obj.$defs;
+		if ("definitions" in obj) result.definitions = obj.definitions;
+		if ("components" in obj) result.components = obj.components;
+	}
+	return result;
+}
+/** Inline local $ref pointers so providers receive self-contained tool schemas. */
+function inlineLocalToolSchemaRefs(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	return inlineLocalSchemaRefsWithDefs(schema, extendSchemaDefs(void 0, schema), void 0, { unresolvedLocalRefs: false }, schema);
+}
+const OPENAPI_SCHEMA_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"discriminator",
+	"externalDocs",
+	"readOnly",
+	"writeOnly",
+	"xml",
+	"example"
+]);
+function appendNullSchemaType(type) {
+	if (type === "null") return type;
+	if (typeof type === "string") return [type, "null"];
+	if (Array.isArray(type)) return type.includes("null") ? type : [...type, "null"];
+	return type;
+}
+function isNullSchemaLike(schema) {
+	if (!isRecord(schema)) return false;
+	if (schema.type === "null") return true;
+	if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+	if ("const" in schema && schema.const === null) return true;
+	return Array.isArray(schema.enum) && schema.enum.includes(null);
+}
+function hasOpenApiComposition(schema) {
+	return [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	].some((key) => Array.isArray(schema[key]));
+}
+function schemaCompositionAlreadyAllowsNull(schema) {
+	return Array.isArray(schema.anyOf) && schema.anyOf.some(isNullSchemaLike) || Array.isArray(schema.oneOf) && schema.oneOf.some(isNullSchemaLike);
+}
+function wrapNullableComposedSchema(schema) {
+	if (schemaCompositionAlreadyAllowsNull(schema)) return schema;
+	const wrapped = { anyOf: [schema, { type: "null" }] };
+	copySchemaMeta(schema, wrapped);
+	return wrapped;
+}
+function normalizeOpenApiSchemaKeywords(schema) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeOpenApiSchemaKeywords(entry);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!isRecord(schema)) return schema;
+	let changed = false;
+	const nullable = schema.nullable === true;
+	const normalized = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (key === "nullable" || OPENAPI_SCHEMA_ANNOTATION_KEYS.has(key)) {
+			changed = true;
+			continue;
+		}
+		if (SCHEMA_LITERAL_KEYS.has(key)) {
+			normalized[key] = value;
+			continue;
+		}
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			let mapChanged = false;
+			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
+				const nextEntry = normalizeOpenApiSchemaKeywords(entryValue);
+				mapChanged ||= nextEntry !== entryValue;
+				return [entryKey, nextEntry];
+			}));
+			normalized[key] = mapChanged ? next : value;
+			changed ||= mapChanged;
+			continue;
+		}
+		if (key === "components") {
+			normalized[key] = value;
+			continue;
+		}
+		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
+			const next = normalizeOpenApiSchemaKeywords(value);
+			normalized[key] = next;
+			changed ||= next !== value;
+			continue;
+		}
+		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+			const next = value.map(normalizeOpenApiSchemaKeywords);
+			normalized[key] = next;
+			changed ||= next.some((entry, index) => entry !== value[index]);
+			continue;
+		}
+		normalized[key] = value;
+	}
+	if (nullable) {
+		if (hasOpenApiComposition(normalized)) return wrapNullableComposedSchema(normalized);
+		if ("type" in normalized) {
+			const nextType = appendNullSchemaType(normalized.type);
+			if (nextType !== normalized.type) normalized.type = nextType;
+		}
+		if (Array.isArray(normalized.enum) && !normalized.enum.includes(null)) normalized.enum = [...normalized.enum, null];
+	}
+	return changed || nullable ? normalized : schema;
+}
+function normalizeToolParameterSchemaUncached(schema, options) {
+	const inlinedSchema = normalizeOpenApiSchemaKeywords(inlineLocalToolSchemaRefs(schema));
+	const schemaRecord = inlinedSchema && typeof inlinedSchema === "object" ? inlinedSchema : void 0;
+	if (!schemaRecord) return inlinedSchema;
+	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
+	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
+	const normalizedToolSchemaProfile = normalizeLowercaseStringOrEmpty(options?.modelCompat?.toolSchemaProfile);
+	const isGeminiProvider = normalizedProvider.includes("google") || normalizedProvider.includes("gemini") || isGeminiModelId(normalizedModelId) || normalizedToolSchemaProfile === "gemini";
+	const isAnthropicProvider = normalizedProvider.includes("anthropic");
+	const unsupportedToolSchemaKeywords = resolveUnsupportedToolSchemaKeywords(options?.modelCompat);
+	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
+	const isLlamacppGbnfProfile = normalizedToolSchemaProfile === "llamacpp";
+	function applyProviderCleaning(s) {
+		const normalizedSchema = normalizeArraySchemasMissingItems(s);
+		let arrayItemsCompatibleSchema = omitEmptyArrayItems ? stripEmptyArrayItemsFromArraySchemas(normalizedSchema) : normalizedSchema;
+		if (isLlamacppGbnfProfile) arrayItemsCompatibleSchema = cleanSchemaForLlamacppGbnf(arrayItemsCompatibleSchema);
+		if (isGeminiProvider && !isAnthropicProvider) {
+			const geminiCompatibleSchema = cleanSchemaForGemini(arrayItemsCompatibleSchema);
+			return unsupportedToolSchemaKeywords.size > 0 ? stripUnsupportedSchemaKeywords(geminiCompatibleSchema, unsupportedToolSchemaKeywords) : geminiCompatibleSchema;
+		}
+		if (unsupportedToolSchemaKeywords.size > 0) return stripUnsupportedSchemaKeywords(arrayItemsCompatibleSchema, unsupportedToolSchemaKeywords);
+		return arrayItemsCompatibleSchema;
+	}
+	const conditionalKey = getTopLevelConditionalKey(schemaRecord);
+	const flattenableVariantKey = getFlattenableVariantKey(schemaRecord);
+	if (hasTopLevelObjectSchema(schemaRecord, conditionalKey)) return applyProviderCleaning(schemaRecord);
+	if (isObjectLikeSchemaMissingType(schemaRecord, conditionalKey)) return applyProviderCleaning({
+		...schemaRecord,
+		type: "object",
+		properties: isRecord(schemaRecord.properties) ? schemaRecord.properties : {}
+	});
+	if (isTypedObjectSchemaMissingValidProperties(schemaRecord, conditionalKey)) return applyProviderCleaning({
+		...schemaRecord,
+		properties: {}
+	});
+	if (!flattenableVariantKey) {
+		if (isTrulyEmptySchema(schemaRecord)) return applyProviderCleaning({
+			type: "object",
+			properties: {}
+		});
+		if (conditionalKey === "allOf") return applyProviderCleaning(inlinedSchema);
+		return applyProviderCleaning(inlinedSchema);
+	}
+	const variants = schemaRecord[flattenableVariantKey];
+	const mergedProperties = isRecord(schemaRecord.properties) ? { ...schemaRecord.properties } : {};
+	const requiredCounts = /* @__PURE__ */ new Map();
+	let objectVariants = 0;
+	for (const entry of variants) {
+		if (!entry || typeof entry !== "object") continue;
+		const props = entry.properties;
+		if (!props || typeof props !== "object") continue;
+		objectVariants += 1;
+		for (const [key, value] of Object.entries(props)) {
+			if (!(key in mergedProperties)) {
+				mergedProperties[key] = value;
+				continue;
+			}
+			mergedProperties[key] = mergePropertySchemas(mergedProperties[key], value);
+		}
+		const required = Array.isArray(entry.required) ? entry.required : [];
+		for (const key of required) {
+			if (typeof key !== "string") continue;
+			requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
+		}
+	}
+	const baseRequired = Array.isArray(schemaRecord.required) ? schemaRecord.required.filter((key) => typeof key === "string") : void 0;
+	const mergedRequired = baseRequired && baseRequired.length > 0 ? baseRequired : objectVariants > 0 ? Array.from(requiredCounts.entries()).filter(([, count]) => count === objectVariants).map(([key]) => key) : void 0;
+	const nextSchema = { ...schemaRecord };
+	return applyProviderCleaning({
+		type: "object",
+		...typeof nextSchema.title === "string" ? { title: nextSchema.title } : {},
+		...typeof nextSchema.description === "string" ? { description: nextSchema.description } : {},
+		properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : schemaRecord.properties ?? {},
+		...mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {},
+		additionalProperties: "additionalProperties" in schemaRecord ? schemaRecord.additionalProperties : true
+	});
+}
+/** Return a provider-compatible JSON schema for a model-facing tool. */
+function normalizeToolParameterSchema(schema, options) {
+	if (!schema || typeof schema !== "object") return normalizeToolParameterSchemaUncached(schema, options);
+	const cacheKey = resolveToolParameterSchemaCacheKey(options);
+	const cached = getCachedToolParameterSchema(schema, cacheKey);
+	if (cached) return cached;
+	return rememberCachedToolParameterSchema(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema-compat.ts
+const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"description",
+	"examples",
+	"format",
+	"title"
+]);
+const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function normalizeOpenAIStrictCompatSchemaMap(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(schema)) {
+		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? normalized : schema;
+}
+function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	let hadNullType = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
+			changed = true;
+			continue;
+		}
+		if (value === null && key === "type") {
+			hadNullType = true;
+			changed = true;
+			continue;
+		}
+		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (Object.keys(normalized).length === 0) {
+		if (!options.promoteEmptyObject) return schema;
+		return {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		};
+	}
+	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
+	const hasArrayShapeHints = "items" in normalized;
+	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
+		normalized.type = hasObjectShapeHints ? "object" : "array";
+		changed = true;
+	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
+	if (normalized.type === "object" && !("properties" in normalized)) {
+		normalized.properties = {};
+		changed = true;
+	}
+	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
+	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
+		normalized.required = [];
+		changed = true;
+	}
+	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
+		normalized.additionalProperties = false;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+function normalizeOpenAIStrictCompatSchema(schema) {
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+}
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+function findOpenAIStrictSchemaViolations(schema, path, options) {
+	if (Array.isArray(schema)) {
+		if (options?.requireObjectRoot) return [`${path}.type`];
+		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
+	}
+	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
+	const record = schema;
+	const violations = [];
+	for (const key of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (key in record) violations.push(`${path}.${key}`);
+	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
+	if (record.type === "object") {
+		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) violations.push(`${path}.required`);
+		else if (properties) {
+			const requiredSet = new Set(required);
+			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
+		}
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
+		const schemaMap = record[key];
+		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
+		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
+		const value = record[key];
+		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+	}
+	return violations;
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema.ts
+/**
+* OpenAI strict JSON-schema normalization for tool inventories and request payloads.
+*
+* Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
+*/
+const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
+const strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
+function resolveToolSchemaModelCompat(compat) {
+	if (!compat) return;
+	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
+	if (unsupportedToolSchemaKeywords.length === 0 && compat.omitEmptyArrayItems !== true) return;
+	return {
+		...unsupportedToolSchemaKeywords.length > 0 ? { unsupportedToolSchemaKeywords } : {},
+		...compat.omitEmptyArrayItems === true ? { omitEmptyArrayItems: true } : {}
+	};
+}
+function resolveStrictOpenAISchemaCacheKey(modelCompat) {
+	const compat = resolveToolSchemaModelCompat(modelCompat);
+	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
+}
+function readCachedStrictOpenAISchema(schema, key) {
+	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
+}
+function rememberStrictOpenAISchema(schema, key, value) {
+	const entries = strictOpenAISchemaCache.get(schema) ?? [];
+	strictOpenAISchemaCache.set(schema, [{
+		key,
+		value
+	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
+	return value;
+}
+/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
+function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
+	const schemaInput = schema ?? {};
+	if (!schemaInput || typeof schemaInput !== "object") return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
+	const cacheKey = resolveStrictOpenAISchemaCacheKey(modelCompat);
+	const cached = readCachedStrictOpenAISchema(schemaInput, cacheKey);
+	if (cached !== void 0) return cached;
+	return rememberStrictOpenAISchema(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
+}
+function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeStrictOpenAIJsonSchemaRecursive(entry, depth);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		const next = normalizeStrictOpenAIJsonSchemaRecursive(value, key === "properties" ? depth : depth + 1);
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (normalized.type === "object") {
+		const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : void 0;
+		if (properties && Object.keys(properties).length === 0 && !Array.isArray(normalized.required)) {
+			normalized.required = [];
+			changed = true;
+		}
+		if (depth === 0 && !("additionalProperties" in normalized)) {
+			normalized.additionalProperties = false;
+			changed = true;
+		}
+	}
+	return changed ? normalized : schema;
+}
+/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
+function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
+	const toolSchemaCompat = resolveToolSchemaModelCompat(modelCompat);
+	if (!strict) return normalizeToolParameterSchema(schema ?? {}, { modelCompat: toolSchemaCompat });
+	return normalizeStrictOpenAIJsonSchema(schema, toolSchemaCompat);
+}
+/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
+function isStrictOpenAIJsonSchemaCompatible(schema) {
+	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
+}
+/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
+function findOpenAIStrictToolProjectionDiagnostics(projection) {
+	return [...projection.diagnostics.map((diagnostic) => ({
+		toolIndex: diagnostic.toolIndex,
+		...diagnostic.toolName ? { toolName: diagnostic.toolName } : {},
+		violations: [...diagnostic.violations]
+	})), ...projection.tools.flatMap((tool) => {
+		const violations = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
+		return violations.length > 0 ? [{
+			toolIndex: tool.toolIndex,
+			toolName: tool.name,
+			violations
+		}] : [];
+	})];
+}
+function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
+	if (Array.isArray(schema)) return schema.every((entry) => isStrictOpenAIJsonSchemaCompatibleRecursive(entry));
+	if (!schema || typeof schema !== "object") return true;
+	const record = schema;
+	if ("anyOf" in record || "oneOf" in record || "allOf" in record) return false;
+	if (Array.isArray(record.type)) return false;
+	if (record.type === "object" && record.additionalProperties !== false) return false;
+	if (record.type === "object") {
+		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) return false;
+		const requiredSet = new Set(required);
+		if (Object.keys(properties).some((key) => !requiredSet.has(key))) return false;
+	}
+	return Object.entries(record).every(([key, entry]) => {
+		if (key === "properties" && entry && typeof entry === "object" && !Array.isArray(entry)) return Object.values(entry).every((value) => isStrictOpenAIJsonSchemaCompatibleRecursive(value));
+		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
+	});
+}
+/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
+function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
+	if (strict !== true) return strict === false ? false : void 0;
+	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 };