@openclaw/ai 2026.10.5 → 2026.10.10-beta.2

package/dist/{openai-responses-terminal-usage-BygjiAdi.d.mts → openai-responses-terminal-usage-CpVjkqn-.d.mts}

@@ -1,5 +1,5 @@
-import { $ as StopReason, a as AssistantMessage, pt as Usage } from "./types-Bd2T86VJ.mjs";
-import "./types-Kdfw_04V.mjs";
+import { $ as StopReason, a as AssistantMessage, pt as Usage } from "./types-CVYzKrMl.mjs";
+import "./types-CBJthzJX.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. */

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

@@ -1,8 +1,43 @@
 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-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";
+import { r as parseLocalSchemaRefPointer } from "./validation-9FSkE8T-.mjs";
+import { r as normalizeLowercaseStringOrEmpty } from "./string-coerce-Cj8sqWHx.mjs";
+import { N as uniqueValues, j as normalizeStringEntries } from "./openai-responses-contracts-Bx-16mnf.mjs";
+import { S as walkSchemaValue, _ as SCHEMA_MAP_KEYS, a as SCHEMA_LITERAL_KEYS, b as evaluateSchemaWalk, c as inlineLocalToolSchemaRefs, d as inheritToolSchemaTruncation, f as reportToolSchemaTruncation, g as SCHEMA_ARRAY_KEYS, h as wasToolSchemaTruncated, i as publishRuntimeToolInputSchema, l as setOwnSchemaProperty, m as truncateToolSchemaDepth, o as canPreserveRootSchemaRefs, s as copySchemaMeta$1, t as getPublishedRuntimeToolInputSchema, v as SCHEMA_NESTED_KEYS, x as walkSchemaArray, y as SCHEMA_OBJECT_KEYS } from "./tool-schema-json-projection-B0hHDV7N.mjs";
+//#region packages/ai/src/providers/openai-function-tool.ts
+const preparedTools = /* @__PURE__ */ new WeakMap();
+const MAX_DESCRIPTOR_VARIANTS = 8;
+/** Reuse wire descriptors only when their parameter owner published immutable JSON. */
+function prepareOpenAIFunctionTool(name, description, parameters, strict) {
+	const published = getPublishedRuntimeToolInputSchema(parameters);
+	const variants = published ? preparedTools.get(parameters) : void 0;
+	const cached = variants?.find(({ responses }) => responses.name === name && responses.description === description && responses.strict === strict);
+	if (cached) return cached;
+	const descriptor = {
+		name,
+		description,
+		parameters,
+		...strict !== void 0 ? { strict } : {}
+	};
+	const result = {
+		responses: {
+			type: "function",
+			...descriptor
+		},
+		completions: {
+			type: "function",
+			function: descriptor
+		}
+	};
+	if (published) {
+		Object.freeze(descriptor);
+		Object.freeze(result.responses);
+		Object.freeze(result.completions);
+		Object.freeze(result);
+		preparedTools.set(parameters, [result, ...variants ?? []].slice(0, MAX_DESCRIPTOR_VARIANTS));
+	}
+	return result;
+}
+//#endregion
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"~optional",
@@ -33,7 +68,7 @@ const SCHEMA_META_KEYS = [
 	"title",
 	"default"
 ];
-function copySchemaMeta$1(from, to) {
+function copySchemaMeta(from, to) {
 	for (const key of SCHEMA_META_KEYS) if (key in from && from[key] !== void 0) to[key] = from[key];
 	return to;
 }
@@ -72,7 +107,7 @@ function isNullSchema(variant) {
 	const typeValue = variant.type;
 	return typeValue === "null" || Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null";
 }
-function extendSchemaDefs$1(defs, schema) {
+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;
@@ -80,7 +115,7 @@ function extendSchemaDefs$1(defs, schema) {
 	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) {
+function tryResolveLocalRef(ref, defs) {
 	if (!defs) return;
 	const tokens = parseLocalSchemaRefPointer(ref);
 	const [table, name] = tokens ?? [];
@@ -94,13 +129,13 @@ function simplifyUnionVariants(params) {
 	const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
 	if (flattened) return {
 		kind: "simplified",
-		value: copySchemaMeta$1(obj, flattened)
+		value: copySchemaMeta(obj, flattened)
 	};
 	if (stripped && nonNullVariants.length === 1) {
 		const lone = nonNullVariants[0];
 		return {
 			kind: "simplified",
-			value: isRecord(lone) ? copySchemaMeta$1(obj, { ...lone }) : lone
+			value: isRecord(lone) ? copySchemaMeta(obj, { ...lone }) : lone
 		};
 	}
 	return {
@@ -120,22 +155,26 @@ function sanitizeRequiredFields(schema) {
 	else delete schema.required;
 	return schema;
 }
-function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors) {
+function* cleanSchemaForGeminiWithDefs(schema, defs, refStack, ancestors, budget, depth = 0) {
+	if (depth > 128) {
+		budget.truncated = true;
+		return {};
+	}
 	return yield walkSchemaValue(schema, ancestors, function* (obj) {
-		const nextDefs = extendSchemaDefs$1(defs, obj);
-		const visit = (value) => cleanSchemaForGeminiWithDefs(value, nextDefs, refStack, ancestors);
+		const nextDefs = extendSchemaDefs(defs, obj);
+		const visit = (value) => cleanSchemaForGeminiWithDefs(value, nextDefs, refStack, ancestors, budget, depth + 1);
 		const refValue = typeof obj.$ref === "string" ? obj.$ref : void 0;
 		if (refValue) {
 			if (refStack?.has(refValue)) return {};
-			const resolved = tryResolveLocalRef$1(refValue, nextDefs);
+			const resolved = tryResolveLocalRef(refValue, nextDefs);
 			if (resolved) {
 				const nextRefStack = new Set(refStack);
 				nextRefStack.add(refValue);
-				const cleaned = yield cleanSchemaForGeminiWithDefs(resolved, nextDefs, nextRefStack, /* @__PURE__ */ new Set());
+				const cleaned = yield cleanSchemaForGeminiWithDefs(resolved, nextDefs, nextRefStack, /* @__PURE__ */ new Set(), budget, depth + 1);
 				if (!cleaned || typeof cleaned !== "object" || Array.isArray(cleaned)) return cleaned;
-				return copySchemaMeta$1(obj, { ...cleaned });
+				return copySchemaMeta(obj, { ...cleaned });
 			}
-			return copySchemaMeta$1(obj, {});
+			return copySchemaMeta(obj, {});
 		}
 		const unions = {};
 		for (const key of ["anyOf", "oneOf"]) {
@@ -201,202 +240,29 @@ 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;
-	return copySchemaMeta$1(obj, objects.length === 1 ? { ...first } : type ? { type } : {});
-}
-function cleanSchemaForGemini(schema) {
-	return evaluateSchemaWalk(cleanSchemaForGeminiWithDefs(schema, void 0, void 0, /* @__PURE__ */ new Set()));
-}
-//#endregion
-//#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: 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);
-	return next;
-}
-function resolveJsonPointerPath(value, tokens) {
-	let current = value;
-	for (const key of tokens) {
-		if (!current || typeof current !== "object") return;
-		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;
-}
-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 tokens = parseLocalSchemaRefPointer(ref);
-	if (!tokens) return;
-	const [table, name, ...remainingPath] = tokens;
-	if (defs && name && (table === "$defs" || table === "definitions")) {
-		const resolved = (table === "$defs" ? defs.$defs : defs.definitions).get(name);
-		if (resolved !== void 0) return resolveJsonPointerPath(resolved, remainingPath);
-	}
-	return resolveJsonPointerPath(rootDocument, tokens);
-}
-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("#/") || parseLocalSchemaRefPointer(refValue)) state.unresolvedLocalRefs = true;
-			return { ...obj };
-		}
-		const nextRefStack = new Set(refStack);
-		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) {
-		for (const key of [
-			"$defs",
-			"definitions",
-			"components"
-		]) if (key in obj) result[key] = obj[key];
-	}
-	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);
+	return copySchemaMeta(obj, objects.length === 1 ? { ...first } : type ? { type } : {});
 }
-/** 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 || tryResolveLocalRef(node.$ref, void 0, schema) === 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;
+function cleanSchemaForGemini(schema, toolName) {
+	const budget = { truncated: false };
+	const boundedSchema = truncateToolSchemaDepth(schema, toolName);
+	const normalized = evaluateSchemaWalk(cleanSchemaForGeminiWithDefs(boundedSchema, void 0, void 0, /* @__PURE__ */ new Set(), budget));
+	if (budget.truncated) reportToolSchemaTruncation(schema, toolName);
+	return inheritToolSchemaTruncation(boundedSchema, normalized, budget.truncated);
 }
 //#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",
-	"allOf",
-	"anyOf",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"oneOf",
-	"prefixItems",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-]);
 /** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
-function cleanSchemaForLlamacppGbnf(schema) {
+function cleanSchemaForLlamacppGbnf(schema, toolName) {
+	const bounded = truncateToolSchemaDepth(schema, toolName);
+	return inheritToolSchemaTruncation(bounded, cleanSchema(bounded));
+}
+function cleanSchema(schema) {
 	if (Array.isArray(schema)) {
 		let changed = false;
 		const entries = schema.map((entry) => {
-			const next = cleanSchemaForLlamacppGbnf(entry);
+			const next = cleanSchema(entry);
 			changed ||= next !== entry;
 			return next;
 		});
@@ -418,12 +284,12 @@ function cleanSchemaForLlamacppGbnf(schema) {
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
 			let mapChanged = false;
 			next = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => {
-				const cleanedChild = cleanSchemaForLlamacppGbnf(childValue);
+				const cleanedChild = cleanSchema(childValue);
 				mapChanged ||= cleanedChild !== childValue;
 				return [childKey, cleanedChild];
 			}));
 			if (!mapChanged) next = value;
-		} else if (SCHEMA_CHILD_KEYS.has(key)) next = cleanSchemaForLlamacppGbnf(value);
+		} else if (key !== "contentSchema" && SCHEMA_NESTED_KEYS.has(key)) next = cleanSchema(value);
 		cleaned[key] = next;
 		changed ||= next !== value;
 	}
@@ -438,12 +304,12 @@ function collectSchemaViolations(node, path, violations) {
 	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.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);
+	else if (key !== "contentSchema" && SCHEMA_NESTED_KEYS.has(key)) collectSchemaViolations(value, `${path}.${key}`, violations);
 }
 /** Reports schema paths that llama.cpp cannot compile into GBNF. */
 function findLlamacppGbnfSchemaViolations(schema, path) {
 	const violations = [];
-	collectSchemaViolations(schema, path, violations);
+	collectSchemaViolations(truncateToolSchemaDepth(schema), path, violations);
 	return violations;
 }
 //#endregion
@@ -454,12 +320,12 @@ function* stripSchemaKeywords(schema, unsupportedKeywords, ancestors) {
 		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)) {
+			if (SCHEMA_MAP_KEYS.has(key) && value && typeof value === "object" && !Array.isArray(value)) {
 				const entries = Object.entries(value);
 				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 walkSchemaArray(value, visit);
-			else if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") cleaned[key] = yield visit(value);
+			} else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) cleaned[key] = yield walkSchemaArray(value, visit);
+			else if (SCHEMA_OBJECT_KEYS.has(key) && value && typeof value === "object") cleaned[key] = yield visit(value);
 			else cleaned[key] = value;
 		}
 		return cleaned;
@@ -467,7 +333,8 @@ function* stripSchemaKeywords(schema, unsupportedKeywords, ancestors) {
 }
 /** Remove schema keywords unsupported by a target provider/tool surface. */
 function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
-	return evaluateSchemaWalk(stripSchemaKeywords(schema, unsupportedKeywords, /* @__PURE__ */ new Set()));
+	const bounded = truncateToolSchemaDepth(schema);
+	return inheritToolSchemaTruncation(bounded, evaluateSchemaWalk(stripSchemaKeywords(bounded, unsupportedKeywords, /* @__PURE__ */ new Set())));
 }
 //#endregion
 //#region packages/ai/src/providers/tool-schema-normalization-cache.ts
@@ -505,19 +372,25 @@ function createToolSchemaNormalizationCache(maxEntries) {
 	return {
 		get(source, key) {
 			const prepared = preparedSchemas?.get(source);
-			if (!prepared) return directCache.get(source, key);
+			if (!prepared) return inheritToolSchemaTruncation(source, directCache.get(source, key));
 			const entry = preparedCache.get(prepared.source, key);
-			return entry?.inputJson === prepared.inputJson ? JSON.parse(entry.outputJson) : void 0;
+			return entry?.inputJson === prepared.inputJson && entry.inputTruncated === wasToolSchemaTruncated(source) ? inheritToolSchemaTruncation(source, JSON.parse(entry.outputJson), entry.truncated) : void 0;
 		},
 		remember(source, key, value) {
+			const result = inheritToolSchemaTruncation(source, value);
 			const prepared = preparedSchemas?.get(source);
-			if (!prepared) return directCache.remember(source, key, value);
-			const outputJson = JSON.stringify(value);
+			if (!prepared) {
+				const published = getPublishedRuntimeToolInputSchema(source) ? publishRuntimeToolInputSchema(result) : void 0;
+				return directCache.remember(source, key, published?.violations.length === 0 ? published.schema : result);
+			}
+			const outputJson = JSON.stringify(result);
 			if (outputJson !== void 0) preparedCache.remember(prepared.source, key, {
 				inputJson: prepared.inputJson,
-				outputJson
+				inputTruncated: wasToolSchemaTruncated(source),
+				outputJson,
+				truncated: wasToolSchemaTruncated(result)
 			});
-			return value;
+			return result;
 		}
 	};
 }
@@ -545,12 +418,36 @@ const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
 	"format",
 	"title"
 ]);
-function normalizeToolSchema(schema, profile, depth = 0) {
+function inferUnionBranchType(schema) {
+	const types = /* @__PURE__ */ new Set();
+	const values = "const" in schema ? [schema.const] : schema.enum;
+	if (Array.isArray(values)) for (const value of values) types.add(value === null ? "null" : Array.isArray(value) ? "array" : typeof value);
+	for (const [type, keywords] of [
+		["number", [
+			"minimum",
+			"maximum",
+			"exclusiveMinimum",
+			"exclusiveMaximum",
+			"multipleOf"
+		]],
+		["string", [
+			"minLength",
+			"maxLength",
+			"pattern",
+			"format"
+		]],
+		["object", ["properties", "required"]],
+		["array", ["items"]]
+	]) if (keywords.some((key) => key in schema)) types.add(type);
+	return types.size === 1 ? types.values().next().value : void 0;
+}
+function normalizeToolSchemaRecursive(schema, profile, depth = 0, inferBranchType = false) {
+	const mapProfile = profile === "strict-map" ? "strict" : profile === "compat-map" ? "compat" : profile === "openapi-map" ? "openapi" : profile === "moonshot-map" ? "moonshot" : void 0;
 	if (Array.isArray(schema)) {
-		if (profile === "compat-map" || profile === "openapi-map") return schema;
+		if (mapProfile) return schema;
 		let changed = false;
 		const normalized = schema.map((entry) => {
-			const next = normalizeToolSchema(entry, profile, profile === "strict" ? depth : 1);
+			const next = normalizeToolSchemaRecursive(entry, profile, profile === "strict" ? depth : 1, inferBranchType);
 			changed ||= next !== entry;
 			return next;
 		});
@@ -578,10 +475,10 @@ function normalizeToolSchema(schema, profile, depth = 0) {
 				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);
+			if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) next = normalizeToolSchemaRecursive(value, "openapi-map", 1);
+			else if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) next = normalizeToolSchemaRecursive(value, profile, 1);
 			else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-				const nextEntries = value.map((entry) => normalizeToolSchema(entry, profile, 1));
+				const nextEntries = value.map((entry) => normalizeToolSchemaRecursive(entry, profile, 1));
 				changed ||= nextEntries.some((entry, index) => entry !== value[index]);
 				entries.push([key, nextEntries]);
 				continue;
@@ -591,15 +488,27 @@ function normalizeToolSchema(schema, profile, depth = 0) {
 			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);
+		if (profile === "strict") {
+			if (SCHEMA_MAP_KEYS.has(key)) next = normalizeToolSchemaRecursive(value, "strict-map", depth);
+			else if (SCHEMA_NESTED_KEYS.has(key)) next = normalizeToolSchemaRecursive(value, profile, depth + 1);
+		} else if (mapProfile) next = normalizeToolSchemaRecursive(value, mapProfile, profile === "strict-map" ? depth + 1 : 1);
+		else if (SCHEMA_MAP_KEYS.has(key)) next = normalizeToolSchemaRecursive(value, profile === "moonshot" ? "moonshot-map" : "compat-map", 1);
+		else if (SCHEMA_NESTED_KEYS.has(key)) next = normalizeToolSchemaRecursive(value, profile === "moonshot" ? "moonshot" : "compat", 1, profile === "moonshot" && (key === "anyOf" || key === "oneOf"));
 		changed ||= next !== value;
 		entries.push([key, next]);
 	}
 	const normalized = Object.fromEntries(entries);
-	if (profile === "compat-map" || profile === "openapi-map") return changed ? normalized : schema;
+	if (mapProfile) return changed ? normalized : schema;
+	if (profile === "moonshot") {
+		if (inferBranchType && !("type" in normalized)) {
+			const type = inferUnionBranchType(normalized);
+			if (type) {
+				normalized.type = type;
+				changed = true;
+			}
+		}
+		return changed ? normalized : schema;
+	}
 	if (profile === "openapi") {
 		if (nullable) {
 			if ([
@@ -609,7 +518,7 @@ function normalizeToolSchema(schema, profile, depth = 0) {
 			].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);
+				copySchemaMeta$1(normalized, wrapped);
 				return wrapped;
 			}
 			const type = normalized.type;
@@ -651,6 +560,10 @@ function normalizeToolSchema(schema, profile, depth = 0) {
 	}
 	return changed ? normalized : schema;
 }
+function normalizeToolSchema(schema, profile) {
+	const bounded = truncateToolSchemaDepth(schema);
+	return inheritToolSchemaTruncation(bounded, normalizeToolSchemaRecursive(bounded, profile));
+}
 //#endregion
 //#region packages/ai/src/providers/agent-tools-parameter-schema.ts
 /**
@@ -783,6 +696,9 @@ function normalizeArraySchemaItems(schema, mode) {
 }
 /** Return a provider-compatible JSON schema for a model-facing tool. */
 function normalizeToolParameterSchema(schema, options) {
+	const published = getPublishedRuntimeToolInputSchema(schema);
+	const boundedSchema = published ? schema : truncateToolSchemaDepth(schema, options?.toolName);
+	if (published && wasToolSchemaTruncated(schema)) reportToolSchemaTruncation(schema, options?.toolName);
 	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
 	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
 	const normalizedToolSchemaProfile = normalizeLowercaseStringOrEmpty(options?.modelCompat?.toolSchemaProfile);
@@ -798,9 +714,11 @@ function normalizeToolParameterSchema(schema, options) {
 	]) : "";
 	if (source) {
 		const cached = toolParameterSchemaCache.get(source, cacheKey);
-		if (cached) return cached;
+		if (cached) {
+			if (wasToolSchemaTruncated(cached)) reportToolSchemaTruncation(source, options?.toolName);
+			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";
@@ -808,7 +726,11 @@ function normalizeToolParameterSchema(schema, options) {
 		"$ref",
 		"$defs",
 		"definitions"
-	].some((key) => unsupportedToolSchemaKeywords.has(key)) && canPreserveRootSchemaRefs(schema) ? schema : inlineLocalToolSchemaRefs(schema), "openapi");
+	].some((key) => unsupportedToolSchemaKeywords.has(key)) && canPreserveRootSchemaRefs(boundedSchema) ? boundedSchema : inlineLocalToolSchemaRefs(boundedSchema, options?.toolName), "openapi");
+	const rememberResult = (normalized) => {
+		const result = inheritToolSchemaTruncation(inlinedSchema, normalized);
+		return source ? toolParameterSchemaCache.remember(source, cacheKey, result) : result;
+	};
 	const schemaRecord = inlinedSchema && typeof inlinedSchema === "object" ? inlinedSchema : void 0;
 	if (!schemaRecord) return rememberResult(inlinedSchema);
 	function applyProviderCleaning(s) {
@@ -897,9 +819,13 @@ function hasRegexLookaround(pattern) {
 }
 /** Finds schema paths that violate OpenAI strict tool-schema requirements. */
 function findOpenAIStrictSchemaViolations(schema, path, options) {
+	const bounded = truncateToolSchemaDepth(schema);
+	return wasToolSchemaTruncated(bounded) ? [`${path}.depth`] : collectStrictSchemaViolations(bounded, path, options);
+}
+function collectStrictSchemaViolations(schema, path, options) {
 	if (Array.isArray(schema)) {
 		if (options?.requireObjectRoot) return [`${path}.type`];
-		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
+		return schema.flatMap((item, index) => collectStrictSchemaViolations(item, `${path}[${index}]`));
 	}
 	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
 	const record = schema;
@@ -921,20 +847,21 @@ 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 SCHEMA_MAP_KEYS$1) {
+	for (const key of SCHEMA_MAP_KEYS) {
 		const schemaMap = record[key];
 		if (!isRecord(schemaMap)) continue;
-		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
+		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...collectStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
 	}
 	for (const key of SCHEMA_NESTED_KEYS) {
 		const value = record[key];
-		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+		if (value && typeof value === "object") violations.push(...collectStrictSchemaViolations(value, `${path}.${key}`));
 	}
 	return violations;
 }
 //#endregion
 //#region packages/ai/src/providers/openai-tool-schema.ts
 const strictOpenAISchemaCache = createToolSchemaNormalizationCache(8);
+const publishedStrictCompatibility = /* @__PURE__ */ new WeakMap();
 function resolveToolSchemaModelCompat(compat) {
 	if (!compat) return;
 	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
@@ -968,7 +895,13 @@ function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
 }
 /** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
 function isStrictOpenAIJsonSchemaCompatible(schema) {
-	return findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(schema), "parameters").length === 0;
+	const publishedSchema = getPublishedRuntimeToolInputSchema(schema)?.projection.schema;
+	const source = publishedSchema && typeof publishedSchema === "object" ? publishedSchema : void 0;
+	const cached = source ? publishedStrictCompatibility.get(source) : void 0;
+	if (cached !== void 0) return cached;
+	const compatible = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(schema), "parameters").length === 0;
+	if (source) publishedStrictCompatibility.set(source, compatible);
+	return compatible;
 }
 /** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
 function findOpenAIStrictToolProjectionDiagnostics(projection) {
@@ -991,4 +924,4 @@ function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
 }
 //#endregion
-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 };
+export { findLlamacppGbnfSchemaViolations as _, resolveOpenAIProjectedToolsStrictToolFlag as a, prepareOpenAIFunctionTool as b, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, normalizeToolSchema as f, cleanSchemaForLlamacppGbnf as g, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, stripUnsupportedSchemaKeywords as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, withPreparedToolSchemaNormalization as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as v, cleanSchemaForGemini as y };