@openclaw/ai 2026.10.1 → 2026.10.5-beta.1

package/dist/{openai-tool-schema-DYNePiF8.mjs → openai-tool-schema-DDPXsvJP.mjs}

@@ -1,8 +1,8 @@
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
 import { t as parseLocalSchemaRefPointer } from "./json-schema-Bp07Qui3.mjs";
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-CtgOVOSv.mjs";
-import { i as uniqueValues, t as normalizeStringEntries } from "./string-normalization-PN10hf6d.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";
+import { i as uniqueValues, t as normalizeStringEntries } from "./string-normalization-I3ux50s9.mjs";
+import { a as SCHEMA_NESTED_KEYS, c as walkSchemaArray, i as SCHEMA_MAP_KEYS$1, l as walkSchemaValue, o as SCHEMA_OBJECT_KEYS$1, r as SCHEMA_ARRAY_KEYS$1, s as evaluateSchemaWalk } from "./tool-schema-json-projection-B8sG1I9v.mjs";
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"~optional",
@@ -35,18 +35,11 @@ const SCHEMA_META_KEYS = [
 ];
 function copySchemaMeta$1(from, to) {
 	for (const key of SCHEMA_META_KEYS) if (key in from && from[key] !== void 0) to[key] = from[key];
-}
-function stringifyGeminiEnumValue(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (typeof value === "boolean") return String(value);
+	return to;
 }
 function cleanGeminiEnumValues(value) {
 	if (!Array.isArray(value)) return;
-	const values = value.flatMap((entry) => {
-		const stringified = stringifyGeminiEnumValue(entry);
-		return stringified === void 0 ? [] : [stringified];
-	});
+	const values = value.filter((entry) => typeof entry === "string" || typeof entry === "boolean" || typeof entry === "number" && Number.isFinite(entry)).map(String);
 	const unique = [...new Set(values)];
 	return unique.length > 0 ? unique : void 0;
 }
@@ -62,9 +55,8 @@ function tryFlattenLiteralAnyOf(variants) {
 		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;
+		if (!variantType || commonType !== null && commonType !== variantType) return null;
+		commonType = variantType;
 		allValues.push(literalValue);
 	}
 	if (commonType && allValues.length > 0) return {
@@ -75,21 +67,17 @@ function tryFlattenLiteralAnyOf(variants) {
 }
 function isNullSchema(variant) {
 	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;
-	const typeValue = record.type;
-	if (typeValue === "null") return true;
-	if (Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null") return true;
-	return false;
+	if ("const" in variant && variant.const === null) return true;
+	if (Array.isArray(variant.enum) && variant.enum.length === 1) return variant.enum[0] === null;
+	const typeValue = variant.type;
+	return typeValue === "null" || Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null";
 }
 function extendSchemaDefs$1(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 ? 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);
+	const next = new Map(defs);
+	for (const entry of [defsEntry, legacyDefsEntry]) for (const [key, value] of Object.entries(entry ?? {})) next.set(key, value);
 	return next;
 }
 function tryResolveLocalRef$1(ref, defs) {
@@ -104,30 +92,15 @@ function simplifyUnionVariants(params) {
 	const nonNullVariants = variants.filter((variant) => !isNullSchema(variant));
 	const stripped = nonNullVariants.length !== variants.length;
 	const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
-	if (flattened) {
-		const result = {
-			type: flattened.type,
-			enum: flattened.enum
-		};
-		copySchemaMeta$1(obj, result);
-		return {
-			kind: "simplified",
-			value: result
-		};
-	}
+	if (flattened) return {
+		kind: "simplified",
+		value: copySchemaMeta$1(obj, flattened)
+	};
 	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
+			value: isRecord(lone) ? copySchemaMeta$1(obj, { ...lone }) : lone
 		};
 	}
 	return {
@@ -147,69 +120,42 @@ function sanitizeRequiredFields(schema) {
 	else delete schema.required;
 	return schema;
 }
-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 (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;
+	return yield walkSchemaValue(schema, ancestors, function* (obj) {
 		const nextDefs = extendSchemaDefs$1(defs, obj);
+		const visit = (value) => cleanSchemaForGeminiWithDefs(value, nextDefs, refStack, ancestors);
 		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();
+				const nextRefStack = new Set(refStack);
 				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;
+				return copySchemaMeta$1(obj, { ...cleaned });
+			}
+			return copySchemaMeta$1(obj, {});
+		}
+		const unions = {};
+		for (const key of ["anyOf", "oneOf"]) {
+			const variants = obj[key];
+			if (Array.isArray(variants)) {
+				const cleaned = [];
+				yield walkSchemaArray(variants, visit, cleaned);
+				unions[key] = cleaned;
 			}
-			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;
-		if (hasAnyOf) {
-			const variants = obj.anyOf;
-			cleanedAnyOf = [];
-			yield cleanSchemaArray(variants, nextDefs, refStack, ancestors, cleanedAnyOf);
-		}
-		let cleanedOneOf;
-		if (hasOneOf) {
-			const variants = obj.oneOf;
-			cleanedOneOf = [];
-			yield cleanSchemaArray(variants, nextDefs, refStack, ancestors, cleanedOneOf);
-		}
-		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;
+		for (const key of ["anyOf", "oneOf"]) {
+			const variants = unions[key];
+			if (variants) {
+				const simplified = simplifyUnionVariants({
+					obj,
+					variants
+				});
+				if (simplified.kind === "simplified") return simplified.value;
+				unions[key] = simplified.value;
+			}
 		}
 		const cleaned = {};
 		for (const [key, value] of Object.entries(obj)) {
@@ -220,7 +166,7 @@ function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
 				continue;
 			}
 			if (key === "required" && Array.isArray(value) && value.length === 0) continue;
-			if (key === "type" && (hasAnyOf || hasOneOf)) continue;
+			if (key === "type" && (unions.anyOf || unions.oneOf)) 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;
@@ -229,32 +175,20 @@ function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
 			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);
+					for (const entry of entries) entry[1] = yield visit(entry[1]);
 					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;
+			} else if ((key === "items" || key === "allOf") && Array.isArray(value)) cleaned[key] = yield walkSchemaArray(value, visit);
+			else if (key === "items" && value && typeof value === "object") cleaned[key] = yield visit(value);
+			else if ((key === "anyOf" || key === "oneOf") && Array.isArray(value)) cleaned[key] = unions[key];
+			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);
-	}
+	});
 }
 /**
 * Last-resort flattening for anyOf/oneOf arrays that could not be simplified
@@ -267,9 +201,7 @@ function flattenUnionFallback(obj, variants) {
 	const types = new Set(objects.map((v) => v.type).filter(Boolean));
 	const first = objects[0];
 	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;
+	return copySchemaMeta$1(obj, objects.length === 1 ? { ...first } : type ? { type } : {});
 }
 function cleanSchemaForGemini(schema) {
 	return evaluateSchemaWalk(cleanSchemaForGeminiWithDefs(schema, void 0, void 0, /* @__PURE__ */ new Set()));
@@ -295,12 +227,9 @@ 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()
+	const next = {
+		$defs: new Map(defs?.$defs),
+		definitions: new Map(defs?.definitions)
 	};
 	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);
@@ -321,10 +250,6 @@ function resolveJsonPointerPath(value, tokens) {
 	}
 	return current;
 }
-function resolveLocalJsonPointer(rootDocument, ref) {
-	const tokens = parseLocalSchemaRefPointer(ref);
-	return tokens ? resolveJsonPointerPath(rootDocument, tokens) : void 0;
-}
 const SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
 	"$defs",
 	"definitions",
@@ -378,7 +303,7 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 			if (refValue.startsWith("#/") || parseLocalSchemaRefPointer(refValue)) state.unresolvedLocalRefs = true;
 			return { ...obj };
 		}
-		const nextRefStack = refStack ? new Set(refStack) : /* @__PURE__ */ new Set();
+		const nextRefStack = new Set(refStack);
 		nextRefStack.add(refValue);
 		const inlined = inlineLocalSchemaRefsWithDefs(resolved, nextDefs, nextRefStack, state, rootDocument);
 		if (!isRecord(inlined)) return inlined;
@@ -400,9 +325,11 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 		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;
+		for (const key of [
+			"$defs",
+			"definitions",
+			"components"
+		]) if (key in obj) result[key] = obj[key];
 	}
 	return result;
 }
@@ -425,7 +352,7 @@ function canPreserveRootSchemaRefs(schema) {
 		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;
+			if (typeof node.$ref !== "string" || !/^#\/(\$defs|definitions)\/[^/]+$/.test(node.$ref) || node.nullable === true || tryResolveLocalRef(node.$ref, void 0, schema) === void 0) return false;
 			hasRefs ||= !inDefinitions;
 		}
 		ancestors.add(node);
@@ -521,34 +448,22 @@ function findLlamacppGbnfSchemaViolations(schema, path) {
 }
 //#endregion
 //#region packages/ai/src/providers/schema-keyword-strip.ts
-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 (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 visit = (value) => stripSchemaKeywords(value, unsupportedKeywords, ancestors);
+	return yield walkSchemaValue(schema, ancestors, function* (obj) {
 		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);
+				for (const entry of entries) entry[1] = yield visit(entry[1]);
 				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 if (SCHEMA_ARRAY_KEYS$1.has(key) && Array.isArray(value)) cleaned[key] = yield walkSchemaArray(value, visit);
+			else if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") cleaned[key] = yield visit(value);
 			else cleaned[key] = value;
 		}
 		return cleaned;
-	} finally {
-		ancestors.delete(schema);
-	}
+	});
 }
 /** Remove schema keywords unsupported by a target provider/tool surface. */
 function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
@@ -607,6 +522,136 @@ function createToolSchemaNormalizationCache(maxEntries) {
 	};
 }
 //#endregion
+//#region packages/ai/src/providers/tool-schema-normalization.ts
+const OPENAPI_SCHEMA_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"discriminator",
+	"externalDocs",
+	"readOnly",
+	"writeOnly",
+	"xml",
+	"example"
+]);
+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);
+}
+const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"description",
+	"examples",
+	"format",
+	"title"
+]);
+function normalizeToolSchema(schema, profile, depth = 0) {
+	if (Array.isArray(schema)) {
+		if (profile === "compat-map" || profile === "openapi-map") return schema;
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeToolSchema(entry, profile, profile === "strict" ? depth : 1);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!isRecord(schema)) return schema;
+	const record = schema;
+	let changed = false;
+	let hadNullType = false;
+	const nullable = profile === "openapi" && record.nullable === true;
+	const entries = [];
+	for (const [key, value] of Object.entries(record)) {
+		if (profile === "compat" && value === null && (OPENAI_NULLABLE_ANNOTATION_KEYS.has(key) || key === "type")) {
+			hadNullType ||= key === "type";
+			changed = true;
+			continue;
+		}
+		if (profile === "openapi") {
+			if (key === "nullable" || OPENAPI_SCHEMA_ANNOTATION_KEYS.has(key)) {
+				changed = true;
+				continue;
+			}
+			if (SCHEMA_LITERAL_KEYS.has(key) || key === "components") {
+				entries.push([key, value]);
+				continue;
+			}
+			let next = value;
+			if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) next = normalizeToolSchema(value, "openapi-map", 1);
+			else if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) next = normalizeToolSchema(value, profile, 1);
+			else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+				const nextEntries = value.map((entry) => normalizeToolSchema(entry, profile, 1));
+				changed ||= nextEntries.some((entry, index) => entry !== value[index]);
+				entries.push([key, nextEntries]);
+				continue;
+			}
+			changed ||= next !== value;
+			entries.push([key, next]);
+			continue;
+		}
+		let next = value;
+		if (profile === "strict") next = normalizeToolSchema(value, profile, key === "properties" ? depth : depth + 1);
+		else if (profile === "compat-map" || profile === "openapi-map") next = normalizeToolSchema(value, profile === "compat-map" ? "compat" : "openapi", 1);
+		else if (SCHEMA_MAP_KEYS$1.has(key)) next = normalizeToolSchema(value, "compat-map", 1);
+		else if (SCHEMA_NESTED_KEYS.has(key)) next = normalizeToolSchema(value, "compat", 1);
+		changed ||= next !== value;
+		entries.push([key, next]);
+	}
+	const normalized = Object.fromEntries(entries);
+	if (profile === "compat-map" || profile === "openapi-map") return changed ? normalized : schema;
+	if (profile === "openapi") {
+		if (nullable) {
+			if ([
+				normalized.allOf,
+				normalized.anyOf,
+				normalized.oneOf
+			].some(Array.isArray)) {
+				if (Array.isArray(normalized.anyOf) && normalized.anyOf.some(isNullSchemaLike) || Array.isArray(normalized.oneOf) && normalized.oneOf.some(isNullSchemaLike)) return normalized;
+				const wrapped = { anyOf: [normalized, { type: "null" }] };
+				copySchemaMeta(normalized, wrapped);
+				return wrapped;
+			}
+			const type = normalized.type;
+			if (typeof type === "string" && type !== "null") normalized.type = [type, "null"];
+			else if (Array.isArray(type) && !type.includes("null")) normalized.type = [...type, "null"];
+			if (Array.isArray(normalized.enum) && !normalized.enum.includes(null)) normalized.enum = [...normalized.enum, null];
+		}
+		return changed || nullable ? normalized : schema;
+	}
+	if (profile === "compat") {
+		if (Object.keys(normalized).length === 0) {
+			if (depth !== 0) 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 = isRecord(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" && (profile === "strict" ? depth === 0 : hasEmptyProperties) && !("additionalProperties" in normalized)) {
+		normalized.additionalProperties = false;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+//#endregion
 //#region packages/ai/src/providers/agent-tools-parameter-schema.ts
 /**
 * Normalizes model-facing tool parameter schemas across provider quirks.
@@ -632,20 +677,6 @@ function shouldOmitEmptyArrayItems(modelOrCompat) {
 	return extractToolSchemaModelCompat(modelOrCompat)?.omitEmptyArrayItems === true;
 }
 const toolParameterSchemaCache = createToolSchemaNormalizationCache(8);
-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 isGeminiModelId(modelId) {
 	return /(?:^|[/:])gemini(?:$|[-/:.])/.test(modelId);
 }
@@ -750,121 +781,42 @@ function normalizeArraySchemaItems(schema, mode) {
 	}
 	return changed ? normalized : 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 entries = Object.entries(schema);
-	let normalized;
-	for (const [key, value] of entries) {
-		if (key === "nullable" || OPENAPI_SCHEMA_ANNOTATION_KEYS.has(key)) {
-			normalized ??= Object.fromEntries(entries);
-			delete normalized[key];
-			changed = true;
-			continue;
-		}
-		if (SCHEMA_LITERAL_KEYS.has(key) || key === "components") continue;
-		let next = value;
-		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			let mapChanged = false;
-			const mapEntries = Object.entries(value);
-			for (const entry of mapEntries) {
-				const nextEntry = normalizeOpenApiSchemaKeywords(entry[1]);
-				mapChanged ||= nextEntry !== entry[1];
-				entry[1] = nextEntry;
-			}
-			next = mapChanged ? Object.fromEntries(mapEntries) : value;
-		} else if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) next = normalizeOpenApiSchemaKeywords(value);
-		else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const nextEntries = value.map(normalizeOpenApiSchemaKeywords);
-			(normalized ??= Object.fromEntries(entries))[key] = nextEntries;
-			changed ||= nextEntries.some((entry, index) => entry !== value[index]);
-			continue;
-		}
-		if (next !== value) {
-			(normalized ??= Object.fromEntries(entries))[key] = next;
-			changed = true;
-		}
-	}
-	if (nullable) {
-		normalized ??= Object.fromEntries(entries);
-		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 : schema;
-}
-function normalizeToolParameterSchemaUncached(schema, options) {
+/** Return a provider-compatible JSON schema for a model-facing tool. */
+function normalizeToolParameterSchema(schema, options) {
 	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 source = schema && typeof schema === "object" ? schema : void 0;
+	const cacheKey = source ? JSON.stringify([
+		normalizedProvider,
+		normalizedModelId,
+		normalizedToolSchemaProfile,
+		[...unsupportedToolSchemaKeywords].toSorted(),
+		omitEmptyArrayItems
+	]) : "";
+	if (source) {
+		const cached = toolParameterSchemaCache.get(source, cacheKey);
+		if (cached) return cached;
+	}
+	const rememberResult = (normalized) => source ? toolParameterSchemaCache.remember(source, cacheKey, normalized) : normalized;
+	const isGeminiProvider = normalizedProvider.includes("google") || normalizedProvider.includes("gemini") || isGeminiModelId(normalizedModelId) || normalizedToolSchemaProfile === "gemini";
+	const isAnthropicProvider = normalizedProvider.includes("anthropic");
 	const isLlamacppGbnfProfile = normalizedToolSchemaProfile === "llamacpp";
-	const inlinedSchema = normalizeOpenApiSchemaKeywords(normalizedProvider === "openai" && !isGeminiProvider && !isLlamacppGbnfProfile && ![
+	const inlinedSchema = normalizeToolSchema(normalizedProvider === "openai" && !isGeminiProvider && !isLlamacppGbnfProfile && ![
 		"$ref",
 		"$defs",
 		"definitions"
-	].some((key) => unsupportedToolSchemaKeywords.has(key)) && canPreserveRootSchemaRefs(schema) ? schema : inlineLocalToolSchemaRefs(schema));
+	].some((key) => unsupportedToolSchemaKeywords.has(key)) && canPreserveRootSchemaRefs(schema) ? schema : inlineLocalToolSchemaRefs(schema), "openapi");
 	const schemaRecord = inlinedSchema && typeof inlinedSchema === "object" ? inlinedSchema : void 0;
-	if (!schemaRecord) return inlinedSchema;
+	if (!schemaRecord) return rememberResult(inlinedSchema);
 	function applyProviderCleaning(s) {
 		let arrayItemsCompatibleSchema = normalizeArraySchemaItems(s, omitEmptyArrayItems ? "normalize" : "add");
 		if (isLlamacppGbnfProfile) arrayItemsCompatibleSchema = cleanSchemaForLlamacppGbnf(arrayItemsCompatibleSchema);
 		if (isGeminiProvider && !isAnthropicProvider) arrayItemsCompatibleSchema = cleanSchemaForGemini(arrayItemsCompatibleSchema);
 		if (unsupportedToolSchemaKeywords.size > 0) arrayItemsCompatibleSchema = stripUnsupportedSchemaKeywords(arrayItemsCompatibleSchema, unsupportedToolSchemaKeywords);
-		return arrayItemsCompatibleSchema;
+		return rememberResult(arrayItemsCompatibleSchema);
 	}
 	const flattenableVariantKey = Array.isArray(schemaRecord.anyOf) ? "anyOf" : Array.isArray(schemaRecord.oneOf) ? "oneOf" : void 0;
 	if (!flattenableVariantKey && !Array.isArray(schemaRecord.allOf)) {
@@ -922,92 +874,26 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 		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 = toolParameterSchemaCache.get(schema, cacheKey);
-	if (cached) return cached;
-	return toolParameterSchemaCache.remember(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
-}
 //#endregion
 //#region packages/ai/src/providers/openai-tool-schema-compat.ts
-const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
-	"default",
-	"description",
-	"examples",
-	"format",
-	"title"
-]);
-const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = new Set([...SCHEMA_OBJECT_KEYS$1, ...SCHEMA_ARRAY_KEYS$1].toSorted());
-function normalizeOpenAIStrictCompatSchemaMap(schema) {
-	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const normalized = Object.fromEntries(Object.entries(schema).map(([key, value]) => {
-		const next = normalizeOpenAIStrictCompatSchemaRecursive(value);
-		changed ||= next !== value;
-		return [key, next];
-	}));
-	return changed ? normalized : schema;
-}
-function normalizeOpenAIStrictCompatSchemaRecursive(schema, promoteEmptyObject = false) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const normalized = schema.map((entry) => {
-			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry);
-			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 entries = Object.entries(record).flatMap(([key, value]) => {
-		if (value === null && (OPENAI_NULLABLE_ANNOTATION_KEYS.has(key) || key === "type")) {
-			hadNullType ||= key === "type";
-			changed = true;
-			return [];
-		}
-		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 (!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 = isRecord(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, true);
+	return normalizeToolSchema(schema, "compat");
+}
+/**
+* Returns whether a regex pattern contains a lookahead or lookbehind group.
+* Escaped parentheses, character classes, and named groups are not lookarounds.
+*/
+function hasRegexLookaround(pattern) {
+	let inCharacterClass = false;
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === "\\") index += 1;
+		else if (inCharacterClass) inCharacterClass = char !== "]";
+		else if (char === "[") inCharacterClass = true;
+		else if (char === "(" && /^\?<?[=!]/.test(pattern.slice(index + 1, index + 4))) return true;
+	}
+	return false;
 }
 /** Finds schema paths that violate OpenAI strict tool-schema requirements. */
 function findOpenAIStrictSchemaViolations(schema, path, options) {
@@ -1024,6 +910,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 		"allOf"
 	]) if (key in record) violations.push(`${path}.${key}`);
 	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	if (typeof record.pattern === "string" && hasRegexLookaround(record.pattern)) violations.push(`${path}.pattern`);
 	const properties = isRecord(record.properties) ? record.properties : void 0;
 	if (record.type === "object") {
 		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
@@ -1039,7 +926,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 		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) {
+	for (const key of SCHEMA_NESTED_KEYS) {
 		const value = record[key];
 		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
 	}
@@ -1070,40 +957,9 @@ function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
 		const cached = strictOpenAISchemaCache.get(schemaInput, cacheKey);
 		if (cached !== void 0) return cached;
 	}
-	const normalized = normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
+	const normalized = normalizeToolSchema(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), "strict");
 	return cacheable ? strictOpenAISchemaCache.remember(schemaInput, cacheKey, normalized) : normalized;
 }
-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 = Object.fromEntries(Object.entries(record).map(([key, value]) => {
-		const next = normalizeStrictOpenAIJsonSchemaRecursive(value, key === "properties" ? depth : depth + 1);
-		changed ||= next !== value;
-		return [key, next];
-	}));
-	if (normalized.type === "object") {
-		const properties = isRecord(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);
@@ -1112,7 +968,7 @@ function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
 }
 /** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
 function isStrictOpenAIJsonSchemaCompatible(schema) {
-	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
+	return findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(schema), "parameters").length === 0;
 }
 /** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
 function findOpenAIStrictToolProjectionDiagnostics(projection) {
@@ -1129,25 +985,6 @@ function findOpenAIStrictToolProjectionDiagnostics(projection) {
 		}] : [];
 	})];
 }
-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 = 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" && isRecord(entry)) return Object.values(entry).every(isStrictOpenAIJsonSchemaCompatibleRecursive);
-		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;