@openclaw/ai 2026.9.5 → 2026.9.7

package/dist/{openai-tool-schema-BO8rwyAD.mjs → openai-tool-schema-vsl-cE-n.mjs}

@@ -1,8 +1,10 @@
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
 import { i as uniqueValues, t as normalizeStringEntries } from "./string-normalization-J9ZiLfGO.mjs";
+import { a as SCHEMA_OBJECT_KEYS$1, i as SCHEMA_MAP_KEYS$1, o as evaluateSchemaWalk, r as SCHEMA_ARRAY_KEYS$1 } from "./tool-schema-json-projection-Ct8SeBeJ.mjs";
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+	"~optional",
 	"patternProperties",
 	"additionalProperties",
 	"$schema",
@@ -71,7 +73,7 @@ function tryFlattenLiteralAnyOf(variants) {
 	return null;
 }
 function isNullSchema(variant) {
-	if (!variant || typeof variant !== "object" || Array.isArray(variant)) return false;
+	if (!isRecord(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;
@@ -80,20 +82,9 @@ function isNullSchema(variant) {
 	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;
+	const defsEntry = isRecord(schema.$defs) ? schema.$defs : void 0;
+	const legacyDefsEntry = isRecord(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);
@@ -113,7 +104,8 @@ function tryResolveLocalRef$1(ref, defs) {
 }
 function simplifyUnionVariants(params) {
 	const { obj, variants } = params;
-	const { variants: nonNullVariants, stripped } = stripNullVariants(variants);
+	const nonNullVariants = variants.filter((variant) => !isNullSchema(variant));
+	const stripped = nonNullVariants.length !== variants.length;
 	const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
 	if (flattened) {
 		const result = {
@@ -148,7 +140,7 @@ function simplifyUnionVariants(params) {
 }
 function sanitizeRequiredFields(schema) {
 	if (!Array.isArray(schema.required)) return schema;
-	if (!schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
+	if (!isRecord(schema.properties)) {
 		if (schema.type === "object") delete schema.required;
 		return schema;
 	}
@@ -158,89 +150,114 @@ function sanitizeRequiredFields(schema) {
 	else delete schema.required;
 	return schema;
 }
-function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
+function* cleanSchemaArray(schemas, defs, refStack, ancestors, result) {
+	result.length = schemas.length;
+	for (let index = 0; index < result.length; index += 1) if (index in schemas) result[index] = yield cleanSchemaForGeminiWithDefs(schemas[index], defs, refStack, ancestors);
+	return result;
+}
+function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
 	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 };
+	if (ancestors.has(schema)) throw new TypeError("Tool schema contains a circular reference.");
+	ancestors.add(schema);
+	try {
+		if (Array.isArray(schema)) {
+			const result = [];
+			yield cleanSchemaArray(schema, defs, refStack, ancestors, result);
+			return result;
+		}
+		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 = yield cleanSchemaForGeminiWithDefs(resolved, nextDefs, nextRefStack, /* @__PURE__ */ new Set());
+				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 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;
+		const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
+		const hasOneOf = "oneOf" in obj && Array.isArray(obj.oneOf);
+		let cleanedAnyOf;
+		if (hasAnyOf) {
+			const variants = obj.anyOf;
+			cleanedAnyOf = [];
+			yield cleanSchemaArray(variants, nextDefs, refStack, ancestors, cleanedAnyOf);
 		}
-		if (key === "enum") {
-			const enumValues = cleanGeminiEnumValues(value);
-			if (enumValues) cleaned.enum = enumValues;
-			continue;
+		let cleanedOneOf;
+		if (hasOneOf) {
+			const variants = obj.oneOf;
+			cleanedOneOf = [];
+			yield cleanSchemaArray(variants, nextDefs, refStack, ancestors, cleanedOneOf);
 		}
-		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 (hasAnyOf) {
+			const simplified = simplifyUnionVariants({
+				obj,
+				variants: cleanedAnyOf ?? []
+			});
+			if (simplified.kind === "simplified") return simplified.value;
+			cleanedAnyOf = simplified.value;
 		}
-		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);
+		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" || key === "enum") {
+				const enumValues = cleanGeminiEnumValues(key === "const" ? [value] : 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)) {
+					const entries = Object.entries(value);
+					for (const entry of entries) entry[1] = yield cleanSchemaForGeminiWithDefs(entry[1], nextDefs, refStack, ancestors);
+					cleaned[key] = Object.fromEntries(entries);
+				} else cleaned[key] = {};
+			} else if (key === "items" && value) {
+				if (Array.isArray(value)) {
+					const result = [];
+					yield cleanSchemaArray(value, nextDefs, refStack, ancestors, result);
+					cleaned[key] = result;
+				} else if (typeof value === "object") cleaned[key] = yield cleanSchemaForGeminiWithDefs(value, nextDefs, refStack, ancestors);
+				else cleaned[key] = value;
+			} else if (key === "anyOf" && Array.isArray(value)) cleaned[key] = cleanedAnyOf;
+			else if (key === "oneOf" && Array.isArray(value)) cleaned[key] = cleanedOneOf;
+			else if (key === "allOf" && Array.isArray(value)) {
+				const result = [];
+				yield cleanSchemaArray(value, nextDefs, refStack, ancestors, result);
+				cleaned[key] = result;
+			} else cleaned[key] = value;
+		}
+		for (const variants of [cleaned.anyOf, cleaned.oneOf]) if (Array.isArray(variants)) {
+			const flattened = flattenUnionFallback(cleaned, variants);
+			if (flattened) return sanitizeRequiredFields(flattened);
+		}
+		return sanitizeRequiredFields(cleaned);
+	} finally {
+		ancestors.delete(schema);
 	}
-	return sanitizeRequiredFields(cleaned);
 }
 /**
 * Last-resort flattening for anyOf/oneOf arrays that could not be simplified
@@ -251,40 +268,192 @@ 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 = {};
+	const type = types.size === 1 ? Array.from(types)[0] : first?.type;
+	const merged = objects.length === 1 ? { ...first } : type ? { type } : {};
 	copySchemaMeta$1(obj, merged);
 	return merged;
 }
 function cleanSchemaForGemini(schema) {
-	return cleanSchemaForGeminiWithDefs(schema, void 0, void 0);
+	return evaluateSchemaWalk(cleanSchemaForGeminiWithDefs(schema, void 0, void 0, /* @__PURE__ */ new Set()));
 }
 //#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([
+//#region packages/ai/src/providers/tool-schema-refs.ts
+function setOwnSchemaProperty(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
+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 = isRecord(schema.$defs) ? schema.$defs : void 0;
+	const legacyDefsEntry = isRecord(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;
+		}
+		if (!isRecord(current) || !Object.hasOwn(current, key)) return;
+		current = current[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 (Array.isArray(schema)) return schema.map((entry) => inlineLocalSchemaRefsWithDefs(entry, defs, refStack, state, rootDocument));
+	if (!isRecord(schema)) return schema;
+	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 (!isRecord(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;
+		let next = value;
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			const entries = Object.entries(value);
+			for (const entry of entries) entry[1] = inlineLocalSchemaRefsWithDefs(entry[1], nextDefs, refStack, state, rootDocument);
+			next = Object.fromEntries(entries);
+		} else if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) next = inlineLocalSchemaRefsWithDefs(value, nextDefs, refStack, state, rootDocument);
+		else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) next = value.map((entry) => inlineLocalSchemaRefsWithDefs(entry, nextDefs, refStack, state, rootDocument));
+		setOwnSchemaProperty(result, key, next);
+	}
+	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;
+	const schemaRecord = schema;
+	return inlineLocalSchemaRefsWithDefs(schema, Array.isArray(schema) ? extendSchemaDefs(void 0, schemaRecord) : void 0, void 0, { unresolvedLocalRefs: false }, schema);
+}
+/** Keep compact root definitions. Fall back for scopes or refs we must rewrite. */
+function canPreserveRootSchemaRefs(schema) {
+	if (!isRecord(schema) || schema.type !== "object" || !isRecord(schema.properties) || ["$defs", "definitions"].some((key) => key in schema && !isRecord(schema[key])) || [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	].some((key) => Array.isArray(schema[key])) || "$ref" in schema) return false;
+	let hasRefs = false;
+	const ancestors = /* @__PURE__ */ new Set();
+	function visit(node, inDefinitions = false) {
+		if (!isRecord(node)) return true;
+		if (ancestors.has(node) || "$id" in node || "id" in node || "components" in node || node !== schema && ("$defs" in node || "definitions" in node)) return false;
+		if ("$ref" in node) {
+			if (typeof node.$ref !== "string" || !/^#\/(\$defs|definitions)\/[^/]+$/.test(node.$ref) || node.nullable === true || resolveLocalJsonPointer(schema, node.$ref) === void 0) return false;
+			hasRefs ||= !inDefinitions;
+		}
+		ancestors.add(node);
+		try {
+			for (const [key, value] of Object.entries(node)) if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+				const childInDefinitions = inDefinitions || key === "$defs" || key === "definitions";
+				if (!Object.values(value).every((entry) => visit(entry, childInDefinitions))) return false;
+			} else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+				if (!value.every((entry) => visit(entry, inDefinitions))) return false;
+			} else if (SCHEMA_OBJECT_KEYS.has(key) && !visit(value, inDefinitions)) return false;
+			return true;
+		} finally {
+			ancestors.delete(node);
+		}
+	}
+	return visit(schema) && hasRefs;
+}
+//#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_CHILD_KEYS = /* @__PURE__ */ new Set([
 	"additionalItems",
 	"additionalProperties",
@@ -302,20 +471,21 @@ const SCHEMA_CHILD_KEYS = /* @__PURE__ */ new Set([
 	"unevaluatedItems",
 	"unevaluatedProperties"
 ]);
-function cleanSchemaNode(node) {
-	if (Array.isArray(node)) {
+/** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
+function cleanSchemaForLlamacppGbnf(schema) {
+	if (Array.isArray(schema)) {
 		let changed = false;
-		const entries = node.map((entry) => {
-			const next = cleanSchemaNode(entry);
+		const entries = schema.map((entry) => {
+			const next = cleanSchemaForLlamacppGbnf(entry);
 			changed ||= next !== entry;
 			return next;
 		});
-		return changed ? entries : node;
+		return changed ? entries : schema;
 	}
-	if (!isRecord(node)) return node;
+	if (!isRecord(schema)) return schema;
 	let changed = false;
 	const cleaned = {};
-	for (const [key, value] of Object.entries(node)) {
+	for (const [key, value] of Object.entries(schema)) {
 		if (key === "pattern") {
 			changed = true;
 			continue;
@@ -325,19 +495,19 @@ function cleanSchemaNode(node) {
 			continue;
 		}
 		let next = value;
-		if (SCHEMA_MAP_KEYS$2.has(key) && isRecord(value)) {
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
 			let mapChanged = false;
 			next = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => {
-				const cleanedChild = cleanSchemaNode(childValue);
+				const cleanedChild = cleanSchemaForLlamacppGbnf(childValue);
 				mapChanged ||= cleanedChild !== childValue;
 				return [childKey, cleanedChild];
 			}));
 			if (!mapChanged) next = value;
-		} else if (SCHEMA_CHILD_KEYS.has(key)) next = cleanSchemaNode(value);
+		} else if (SCHEMA_CHILD_KEYS.has(key)) next = cleanSchemaForLlamacppGbnf(value);
 		cleaned[key] = next;
 		changed ||= next !== value;
 	}
-	return changed ? cleaned : node;
+	return changed ? cleaned : schema;
 }
 function collectSchemaViolations(node, path, violations) {
 	if (Array.isArray(node)) {
@@ -347,13 +517,9 @@ function collectSchemaViolations(node, path, violations) {
 	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);
+	for (const [key, value] of Object.entries(node)) if (SCHEMA_MAP_KEYS.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 = [];
@@ -362,60 +528,38 @@ function findLlamacppGbnfSchemaViolations(schema, path) {
 }
 //#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) {
+function* stripSchemaArray(schemas, unsupportedKeywords, ancestors) {
+	const result = [];
+	result.length = schemas.length;
+	for (let index = 0; index < result.length; index += 1) if (index in schemas) result[index] = yield stripSchemaKeywords(schemas[index], unsupportedKeywords, ancestors);
+	return result;
+}
+function* stripSchemaKeywords(schema, unsupportedKeywords, ancestors) {
 	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;
+	if (ancestors.has(schema)) throw new TypeError("Tool schema contains a circular reference.");
+	ancestors.add(schema);
+	try {
+		if (Array.isArray(schema)) return yield stripSchemaArray(schema, unsupportedKeywords, ancestors);
+		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)) {
+				const entries = Object.entries(value);
+				for (const entry of entries) entry[1] = yield stripSchemaKeywords(entry[1], unsupportedKeywords, ancestors);
+				cleaned[key] = Object.fromEntries(entries);
+			} else if (SCHEMA_ARRAY_KEYS$1.has(key) && Array.isArray(value)) cleaned[key] = yield stripSchemaArray(value, unsupportedKeywords, ancestors);
+			else if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") cleaned[key] = yield stripSchemaKeywords(value, unsupportedKeywords, ancestors);
+			else cleaned[key] = value;
 		}
-		cleaned[key] = value;
+		return cleaned;
+	} finally {
+		ancestors.delete(schema);
 	}
-	return cleaned;
+}
+/** Remove schema keywords unsupported by a target provider/tool surface. */
+function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
+	return evaluateSchemaWalk(stripSchemaKeywords(schema, unsupportedKeywords, /* @__PURE__ */ new Set()));
 }
 //#endregion
 //#region packages/ai/src/providers/tool-schema-normalization-cache.ts
@@ -549,37 +693,6 @@ function mergePropertySchemas(existing, incoming) {
 	}
 	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 normalizeArraySchemaItems(schema, mode) {
 	if (Array.isArray(schema)) {
 		if (mode === "add") return schema;
@@ -601,7 +714,7 @@ function normalizeArraySchemaItems(schema, mode) {
 		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)) {
+		if (mode !== "add" && key === "items" && allowsArray && isRecord(value) && Object.keys(value).length === 0) {
 			delete normalized.items;
 			changed = true;
 			continue;
@@ -622,150 +735,6 @@ function normalizeArraySchemaItems(schema, mode) {
 	}
 	return changed ? normalized : 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)) {
-			const entries = Object.entries(value);
-			for (const entry of entries) entry[1] = inlineLocalSchemaRefsWithDefs(entry[1], nextDefs, refStack, state, rootDocument);
-			setOwnSchemaProperty(result, key, Object.fromEntries(entries));
-			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;
-	const schemaRecord = schema;
-	return inlineLocalSchemaRefsWithDefs(schema, Array.isArray(schema) ? extendSchemaDefs(void 0, schemaRecord) : void 0, void 0, { unresolvedLocalRefs: false }, schema);
-}
 const OPENAPI_SCHEMA_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
 	"discriminator",
 	"externalDocs",
@@ -860,9 +829,6 @@ function normalizeOpenApiSchemaKeywords(schema) {
 	return changed || nullable ? normalized ?? schema : 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);
@@ -871,36 +837,37 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 	const unsupportedToolSchemaKeywords = resolveUnsupportedToolSchemaKeywords(options?.modelCompat);
 	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
 	const isLlamacppGbnfProfile = normalizedToolSchemaProfile === "llamacpp";
+	const inlinedSchema = normalizeOpenApiSchemaKeywords(normalizedProvider === "openai" && !isGeminiProvider && !isLlamacppGbnfProfile && ![
+		"$ref",
+		"$defs",
+		"definitions"
+	].some((key) => unsupportedToolSchemaKeywords.has(key)) && canPreserveRootSchemaRefs(schema) ? schema : inlineLocalToolSchemaRefs(schema));
+	const schemaRecord = inlinedSchema && typeof inlinedSchema === "object" ? inlinedSchema : void 0;
+	if (!schemaRecord) return inlinedSchema;
 	function applyProviderCleaning(s) {
 		let arrayItemsCompatibleSchema = normalizeArraySchemaItems(s, omitEmptyArrayItems ? "normalize" : "add");
 		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);
+		if (isGeminiProvider && !isAnthropicProvider) arrayItemsCompatibleSchema = cleanSchemaForGemini(arrayItemsCompatibleSchema);
+		if (unsupportedToolSchemaKeywords.size > 0) arrayItemsCompatibleSchema = 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",
+	const flattenableVariantKey = Array.isArray(schemaRecord.anyOf) ? "anyOf" : Array.isArray(schemaRecord.oneOf) ? "oneOf" : void 0;
+	if (!flattenableVariantKey && !Array.isArray(schemaRecord.allOf)) {
+		const hasProperties = isRecord(schemaRecord.properties);
+		if (schemaRecord.type === "object") return applyProviderCleaning(hasProperties ? schemaRecord : {
+			...schemaRecord,
 			properties: {}
 		});
-		if (conditionalKey === "allOf") return applyProviderCleaning(inlinedSchema);
-		return applyProviderCleaning(inlinedSchema);
+		if (!("type" in schemaRecord) && (hasProperties || Array.isArray(schemaRecord.required))) return applyProviderCleaning({
+			...schemaRecord,
+			type: "object",
+			properties: hasProperties ? schemaRecord.properties : {}
+		});
 	}
+	if (!flattenableVariantKey) return applyProviderCleaning(Object.keys(schemaRecord).length === 0 ? {
+		type: "object",
+		properties: {}
+	} : inlinedSchema);
 	const variants = schemaRecord[flattenableVariantKey];
 	const mergedProperties = isRecord(schemaRecord.properties) ? { ...schemaRecord.properties } : {};
 	const requiredCounts = /* @__PURE__ */ new Map();
@@ -919,11 +886,10 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 	}
 	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 } : {},
+		...typeof schemaRecord.title === "string" ? { title: schemaRecord.title } : {},
+		...typeof schemaRecord.description === "string" ? { description: schemaRecord.description } : {},
 		properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : schemaRecord.properties ?? {},
 		...mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {},
 		additionalProperties: "additionalProperties" in schemaRecord ? schemaRecord.additionalProperties : true
@@ -939,14 +905,6 @@ function normalizeToolParameterSchema(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",
@@ -954,39 +912,22 @@ const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
 	"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"
-]);
+const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = new Set([...SCHEMA_OBJECT_KEYS$1, ...SCHEMA_ARRAY_KEYS$1].toSorted());
 function normalizeOpenAIStrictCompatSchemaMap(schema) {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	if (!isRecord(schema)) return schema;
 	let changed = false;
 	const normalized = Object.fromEntries(Object.entries(schema).map(([key, value]) => {
-		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
+		const next = normalizeOpenAIStrictCompatSchemaRecursive(value);
 		changed ||= next !== value;
 		return [key, next];
 	}));
 	return changed ? normalized : schema;
 }
-function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
+function normalizeOpenAIStrictCompatSchemaRecursive(schema, promoteEmptyObject = false) {
 	if (Array.isArray(schema)) {
 		let changed = false;
 		const normalized = schema.map((entry) => {
-			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
+			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry);
 			changed ||= next !== entry;
 			return next;
 		});
@@ -1002,13 +943,13 @@ function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
 			changed = true;
 			return [];
 		}
-		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;
+		const next = SCHEMA_MAP_KEYS$1.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value) : value;
 		changed ||= next !== value;
 		return [[key, next]];
 	});
 	const normalized = Object.fromEntries(entries);
 	if (Object.keys(normalized).length === 0) {
-		if (!options.promoteEmptyObject) return schema;
+		if (!promoteEmptyObject) return schema;
 		return {
 			type: "object",
 			properties: {},
@@ -1026,7 +967,7 @@ function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
 		normalized.properties = {};
 		changed = true;
 	}
-	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
+	const hasEmptyProperties = isRecord(normalized.properties) && Object.keys(normalized.properties).length === 0;
 	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
 		normalized.required = [];
 		changed = true;
@@ -1039,7 +980,7 @@ function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
 }
 /** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
 function normalizeOpenAIStrictCompatSchema(schema) {
-	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, true);
 }
 /** Finds schema paths that violate OpenAI strict tool-schema requirements. */
 function findOpenAIStrictSchemaViolations(schema, path, options) {
@@ -1056,7 +997,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 		"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;
+	const properties = isRecord(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;
@@ -1066,9 +1007,9 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 			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) {
+	for (const key of SCHEMA_MAP_KEYS$1) {
 		const schemaMap = record[key];
-		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
+		if (!isRecord(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) {
@@ -1079,11 +1020,6 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 }
 //#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 strictOpenAISchemaCache = createToolSchemaNormalizationCache(8);
 function resolveToolSchemaModelCompat(compat) {
 	if (!compat) return;
@@ -1126,7 +1062,7 @@ function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
 		return [key, next];
 	}));
 	if (normalized.type === "object") {
-		const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : void 0;
+		const properties = isRecord(normalized.properties) ? normalized.properties : void 0;
 		if (properties && Object.keys(properties).length === 0 && !Array.isArray(normalized.required)) {
 			normalized.required = [];
 			changed = true;
@@ -1171,14 +1107,14 @@ function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
 	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 properties = isRecord(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));
+		if (key === "properties" && isRecord(entry)) return Object.values(entry).every(isStrictOpenAIJsonSchemaCompatibleRecursive);
 		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
 	});
 }