@openclaw/ai 2026.9.4 → 2026.9.6

package/dist/openai-responses-terminal-usage-BNFbvY9f.d.mts

@@ -0,0 +1,47 @@
+import { K as StopReason, a as AssistantMessage, ot as Usage } from "./types-qZFbaDbK.mjs";
+import "./types-DTvddOfm.mjs";
+import OpenAI from "openai";
+//#region packages/ai/src/providers/openai-responses-terminal-usage.d.ts
+/** A known output ceiling can resume sampling after admitted tools have settled. */
+declare function isResponsesOutputLimitToolCallError(message: Pick<AssistantMessage, "stopReason" | "errorCode" | "diagnostics">): boolean;
+/** Terminal usage payload, modeled structurally so untyped callers can pass raw records. */
+type ResponsesTerminalUsagePayload = {
+  input_tokens?: number | null;
+  output_tokens?: number | null;
+  total_tokens?: number | null;
+  input_tokens_details?: {
+    cached_tokens?: number | null;
+    cache_write_tokens?: number | null;
+  } | null;
+  output_tokens_details?: {
+    reasoning_tokens?: number | null;
+  } | null;
+};
+/**
+ * Split a terminal usage payload into the priced buckets.
+ *
+ * OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
+ * billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
+ * split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
+ * whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
+ * short of what the buckets actually price.
+ */
+declare function mapResponsesTerminalUsage(usage: ResponsesTerminalUsagePayload | undefined | null): Pick<Usage, "input" | "output" | "cacheRead" | "cacheWrite" | "contextUsage" | "totalTokens"> | undefined;
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+declare function readResponsesReasoningTokens(usage: ResponsesTerminalUsagePayload | undefined | null): number | undefined;
+/**
+ * Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+ * content-filtered turn is a provider error rather than a truncated answer, and a turn that
+ * produced tool calls reports `toolUse` instead of a plain stop.
+ */
+declare function resolveResponsesTerminalStopReason(params: {
+  status: OpenAI.Responses.ResponseStatus | undefined;
+  terminalEventType?: "response.completed" | "response.incomplete";
+  incompleteReason?: string;
+  hasToolCall: boolean;
+}): {
+  stopReason: StopReason;
+  errorMessage?: string;
+};
+//#endregion
+export { resolveResponsesTerminalStopReason as a, readResponsesReasoningTokens as i, isResponsesOutputLimitToolCallError as n, mapResponsesTerminalUsage as r, ResponsesTerminalUsagePayload as t };

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

@@ -1,8 +1,35 @@
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { r as uniqueValues, t as normalizeStringEntries } from "./string-normalization-CmLIasuf.mjs";
+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
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+	"~optional",
 	"patternProperties",
 	"additionalProperties",
 	"$schema",
@@ -158,89 +185,123 @@ 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") {
+				const enumValues = cleanGeminiEnumValues([value]);
+				if (enumValues) cleaned.enum = enumValues;
+				continue;
+			}
+			if (key === "enum") {
+				const enumValues = cleanGeminiEnumValues(value);
+				if (enumValues) cleaned.enum = enumValues;
+				continue;
+			}
+			if (key === "required" && Array.isArray(value) && value.length === 0) continue;
+			if (key === "type" && (hasAnyOf || hasOneOf)) continue;
+			if (key === "type" && Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+				const types = value.filter((entry) => entry !== "null");
+				cleaned.type = types.length === 1 ? types[0] : types;
+				continue;
+			}
+			if (key === "properties") {
+				if (value && typeof value === "object" && !Array.isArray(value)) {
+					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;
+		}
+		if (cleaned.anyOf && Array.isArray(cleaned.anyOf)) {
+			const flattened = flattenUnionFallback(cleaned, cleaned.anyOf);
+			if (flattened) return sanitizeRequiredFields(flattened);
+		}
+		if (cleaned.oneOf && Array.isArray(cleaned.oneOf)) {
+			const flattened = flattenUnionFallback(cleaned, cleaned.oneOf);
+			if (flattened) return sanitizeRequiredFields(flattened);
+		}
+		return sanitizeRequiredFields(cleaned);
+	} finally {
+		ancestors.delete(schema);
 	}
-	return sanitizeRequiredFields(cleaned);
 }
 /**
 * Last-resort flattening for anyOf/oneOf arrays that could not be simplified
@@ -272,9 +333,7 @@ function flattenUnionFallback(obj, variants) {
 	return merged;
 }
 function cleanSchemaForGemini(schema) {
-	if (!schema || typeof schema !== "object") return schema;
-	if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
-	return cleanSchemaForGeminiWithDefs(schema, extendSchemaDefs$1(void 0, schema), void 0);
+	return evaluateSchemaWalk(cleanSchemaForGeminiWithDefs(schema, void 0, void 0, /* @__PURE__ */ new Set()));
 }
 //#endregion
 //#region packages/ai/src/providers/clean-for-llamacpp-gbnf.ts
@@ -395,29 +454,96 @@ const SCHEMA_ARRAY_KEYS$1 = /* @__PURE__ */ new Set([
 	"oneOf",
 	"prefixItems"
 ]);
-/** Recursively remove schema keywords unsupported by a target provider/tool surface. */
-function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
+function* stripSchemaArray(schemas, unsupportedKeywords, ancestors, 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 (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 (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") {
-			cleaned[key] = stripUnsupportedSchemaKeywords(value, unsupportedKeywords);
-			continue;
+		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)) {
+				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 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
+let preparedSchemas;
+/** Only synchronous conversion owns these fresh projections; no facts survive its return. */
+function withPreparedToolSchemaNormalization(schemas, convert) {
+	const previous = preparedSchemas;
+	preparedSchemas = schemas;
+	try {
+		return convert();
+	} finally {
+		preparedSchemas = previous;
+	}
+}
+function createBoundedSchemaCache(maxEntries) {
+	const schemas = /* @__PURE__ */ new WeakMap();
+	return {
+		get(source, key) {
+			return schemas.get(source)?.find((entry) => entry.key === key)?.value;
+		},
+		remember(source, key, value) {
+			const entries = schemas.get(source) ?? [];
+			schemas.set(source, [{
+				key,
+				value
+			}, ...entries.filter((entry) => entry.key !== key)].slice(0, maxEntries));
+			return value;
+		}
+	};
+}
+/** Prepared variants cannot evict direct callers' identity-preserving cache entries. */
+function createToolSchemaNormalizationCache(maxEntries) {
+	const directCache = createBoundedSchemaCache(maxEntries);
+	const preparedCache = createBoundedSchemaCache(maxEntries);
+	return {
+		get(source, key) {
+			const prepared = preparedSchemas?.get(source);
+			if (!prepared) return directCache.get(source, key);
+			const entry = preparedCache.get(prepared.source, key);
+			return entry?.inputJson === prepared.inputJson ? JSON.parse(entry.outputJson) : void 0;
+		},
+		remember(source, key, value) {
+			const prepared = preparedSchemas?.get(source);
+			if (!prepared) return directCache.remember(source, key, value);
+			const outputJson = JSON.stringify(value);
+			if (outputJson !== void 0) preparedCache.remember(prepared.source, key, {
+				inputJson: prepared.inputJson,
+				outputJson
+			});
+			return value;
+		}
+	};
 }
 //#endregion
 //#region packages/ai/src/providers/agent-tools-parameter-schema.ts
@@ -444,8 +570,7 @@ function resolveUnsupportedToolSchemaKeywords(modelOrCompat) {
 function shouldOmitEmptyArrayItems(modelOrCompat) {
 	return extractToolSchemaModelCompat(modelOrCompat)?.omitEmptyArrayItems === true;
 }
-const MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const toolParameterSchemaCache = /* @__PURE__ */ new WeakMap();
+const toolParameterSchemaCache = createToolSchemaNormalizationCache(8);
 function resolveToolParameterSchemaCacheKey(options) {
 	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
 	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
@@ -460,17 +585,6 @@ function resolveToolParameterSchemaCacheKey(options) {
 		omitEmptyArrayItems
 	]);
 }
-function getCachedToolParameterSchema(schema, key) {
-	return toolParameterSchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberCachedToolParameterSchema(schema, key, value) {
-	const entries = toolParameterSchemaCache.get(schema) ?? [];
-	toolParameterSchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
 function isGeminiModelId(modelId) {
 	return /(?:^|[/:])gemini(?:$|[-/:.])/.test(modelId);
 }
@@ -570,7 +684,8 @@ function normalizeArraySchemaItems(schema, mode) {
 		}
 		let next = value;
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			const entries = Object.entries(value).map(([entryKey, entry]) => [entryKey, normalizeArraySchemaItems(entry, mode)]);
+			const entries = Object.entries(value);
+			for (const entry of entries) entry[1] = normalizeArraySchemaItems(entry[1], mode);
 			if (entries.some(([entryKey, entry]) => entry !== value[entryKey])) next = Object.fromEntries(entries);
 		} else if (SCHEMA_OBJECT_KEYS.has(key) || SCHEMA_ARRAY_KEYS.has(key)) {
 			const valueMode = SCHEMA_OBJECT_KEYS.has(key) || Array.isArray(value) ? mode : "add";
@@ -699,7 +814,9 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 			continue;
 		}
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			setOwnSchemaProperty(result, key, Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, inlineLocalSchemaRefsWithDefs(entryValue, nextDefs, refStack, state, rootDocument)])));
+			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)) {
@@ -722,7 +839,8 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 /** Inline local $ref pointers so providers receive self-contained tool schemas. */
 function inlineLocalToolSchemaRefs(schema) {
 	if (!schema || typeof schema !== "object") return schema;
-	return inlineLocalSchemaRefsWithDefs(schema, extendSchemaDefs(void 0, schema), void 0, { unresolvedLocalRefs: false }, schema);
+	const 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",
@@ -774,46 +892,40 @@ function normalizeOpenApiSchemaKeywords(schema) {
 	if (!isRecord(schema)) return schema;
 	let changed = false;
 	const nullable = schema.nullable === true;
-	const normalized = {};
-	for (const [key, value] of Object.entries(schema)) {
+	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)) {
-			normalized[key] = value;
-			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 next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
-				const nextEntry = normalizeOpenApiSchemaKeywords(entryValue);
-				mapChanged ||= nextEntry !== entryValue;
-				return [entryKey, nextEntry];
-			}));
-			normalized[key] = mapChanged ? next : value;
-			changed ||= mapChanged;
-			continue;
-		}
-		if (key === "components") {
-			normalized[key] = value;
+			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 (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
-			const next = normalizeOpenApiSchemaKeywords(value);
-			normalized[key] = next;
-			changed ||= next !== value;
-			continue;
-		}
-		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const next = value.map(normalizeOpenApiSchemaKeywords);
-			normalized[key] = next;
-			changed ||= next.some((entry, index) => entry !== value[index]);
-			continue;
+		if (next !== value) {
+			(normalized ??= Object.fromEntries(entries))[key] = next;
+			changed = true;
 		}
-		setOwnSchemaProperty(normalized, key, value);
 	}
 	if (nullable) {
+		normalized ??= Object.fromEntries(entries);
 		if (hasOpenApiComposition(normalized)) return wrapNullableComposedSchema(normalized);
 		if ("type" in normalized) {
 			const nextType = appendNullSchemaType(normalized.type);
@@ -821,7 +933,7 @@ function normalizeOpenApiSchemaKeywords(schema) {
 		}
 		if (Array.isArray(normalized.enum) && !normalized.enum.includes(null)) normalized.enum = [...normalized.enum, null];
 	}
-	return changed || nullable ? normalized : schema;
+	return changed || nullable ? normalized ?? schema : schema;
 }
 function normalizeToolParameterSchemaUncached(schema, options) {
 	const inlinedSchema = normalizeOpenApiSchemaKeywords(inlineLocalToolSchemaRefs(schema));
@@ -897,9 +1009,9 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 function normalizeToolParameterSchema(schema, options) {
 	if (!schema || typeof schema !== "object") return normalizeToolParameterSchemaUncached(schema, options);
 	const cacheKey = resolveToolParameterSchemaCacheKey(options);
-	const cached = getCachedToolParameterSchema(schema, cacheKey);
+	const cached = toolParameterSchemaCache.get(schema, cacheKey);
 	if (cached) return cached;
-	return rememberCachedToolParameterSchema(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
+	return toolParameterSchemaCache.remember(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
 }
 //#endregion
 //#region packages/ai/src/providers/openai-tool-schema-compat.ts
@@ -1048,8 +1160,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 *
 * Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
 */
-const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
+const strictOpenAISchemaCache = createToolSchemaNormalizationCache(8);
 function resolveToolSchemaModelCompat(compat) {
 	if (!compat) return;
 	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
@@ -1063,25 +1174,14 @@ function resolveStrictOpenAISchemaCacheKey(modelCompat) {
 	const compat = resolveToolSchemaModelCompat(modelCompat);
 	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
 }
-function readCachedStrictOpenAISchema(schema, key) {
-	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberStrictOpenAISchema(schema, key, value) {
-	const entries = strictOpenAISchemaCache.get(schema) ?? [];
-	strictOpenAISchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
 /** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
 function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
 	const schemaInput = schema ?? {};
 	if (!schemaInput || typeof schemaInput !== "object") return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
 	const cacheKey = resolveStrictOpenAISchemaCacheKey(modelCompat);
-	const cached = readCachedStrictOpenAISchema(schemaInput, cacheKey);
+	const cached = strictOpenAISchemaCache.get(schemaInput, cacheKey);
 	if (cached !== void 0) return cached;
-	return rememberStrictOpenAISchema(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
+	return strictOpenAISchemaCache.remember(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
 }
 function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
 	if (Array.isArray(schema)) {
@@ -1164,4 +1264,4 @@ function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
 }
 //#endregion
-export { cleanSchemaForGemini as _, resolveOpenAIProjectedToolsStrictToolFlag as a, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, stripUnsupportedSchemaKeywords as f, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as g, findLlamacppGbnfSchemaViolations as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, cleanSchemaForLlamacppGbnf as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u };
+export { GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as _, resolveOpenAIProjectedToolsStrictToolFlag as a, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, withPreparedToolSchemaNormalization as f, findLlamacppGbnfSchemaViolations as g, cleanSchemaForLlamacppGbnf as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, stripUnsupportedSchemaKeywords as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u, cleanSchemaForGemini as v };