@openclaw/ai 2026.9.6 → 2026.9.7

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

@@ -1,32 +1,7 @@
+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";
-//#region packages/ai/src/providers/schema-walk.ts
-/** Resume child schema walks on a heap stack, never through recursive yield delegation. */
-function evaluateSchemaWalk(walk) {
-	const parents = [];
-	let current = walk;
-	let value;
-	try {
-		while (true) {
-			const step = current.next(value);
-			if (!step.done) {
-				parents.push(current);
-				current = step.value;
-				value = void 0;
-				continue;
-			}
-			value = step.value;
-			const parent = parents.pop();
-			if (!parent) return value;
-			current = parent;
-		}
-	} finally {
-		let parent;
-		while (parent = parents.pop()) parent.return(void 0);
-	}
-}
-//#endregion
+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",
@@ -98,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;
@@ -107,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);
@@ -140,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 = {
@@ -175,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;
 	}
@@ -252,13 +217,8 @@ function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
 		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 (key === "const" || key === "enum") {
+				const enumValues = cleanGeminiEnumValues(key === "const" ? [value] : value);
 				if (enumValues) cleaned.enum = enumValues;
 				continue;
 			}
@@ -290,12 +250,8 @@ function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
 				cleaned[key] = result;
 			} 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);
+		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);
@@ -312,23 +268,9 @@ 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;
 }
@@ -336,16 +278,182 @@ function cleanSchemaForGemini(schema) {
 	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",
@@ -363,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;
@@ -386,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)) {
@@ -408,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 = [];
@@ -423,38 +528,8 @@ 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"
-]);
-function* stripSchemaArray(schemas, unsupportedKeywords, ancestors, result) {
+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;
@@ -464,11 +539,7 @@ function* stripSchemaKeywords(schema, unsupportedKeywords, ancestors) {
 	if (ancestors.has(schema)) throw new TypeError("Tool schema contains a circular reference.");
 	ancestors.add(schema);
 	try {
-		if (Array.isArray(schema)) {
-			const result = [];
-			yield stripSchemaArray(schema, unsupportedKeywords, ancestors, result);
-			return result;
-		}
+		if (Array.isArray(schema)) return yield stripSchemaArray(schema, unsupportedKeywords, ancestors);
 		const obj = schema;
 		const cleaned = {};
 		for (const [key, value] of Object.entries(obj)) {
@@ -477,11 +548,8 @@ function* stripSchemaKeywords(schema, unsupportedKeywords, ancestors) {
 				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)) {
-				const result = [];
-				yield stripSchemaArray(value, unsupportedKeywords, ancestors, result);
-				cleaned[key] = result;
-			} else if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") cleaned[key] = yield stripSchemaKeywords(value, unsupportedKeywords, ancestors);
+			} 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;
 		}
 		return cleaned;
@@ -625,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;
@@ -677,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;
@@ -698,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",
@@ -936,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);
@@ -947,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();
@@ -995,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
@@ -1015,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",
@@ -1030,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;
 		});
@@ -1078,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: {},
@@ -1102,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;
@@ -1115,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) {
@@ -1132,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;
@@ -1142,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) {
@@ -1155,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;
@@ -1202,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;
@@ -1247,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);
 	});
 }