@ai-sdk-tool/parser 3.3.1 → 3.3.3

package/dist/{chunk-OUGMLYAW.js → chunk-2KK5BDZF.js}

@@ -4,6 +4,13 @@ var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
 var NEWLINE_SPLIT_REGEX = /\n+/;
 var COMMA_SPLIT_REGEX = /,\s*/;
 var DIGIT_KEY_REGEX = /^\d+$/;
+var WHITESPACE_REGEX = /\s+/g;
+var HAS_WHITESPACE_REGEX = /\s/;
+var SINGLE_QUOTE = "'";
+var DOUBLE_QUOTE = '"';
+var SNAKE_SEGMENT_REGEX = /_([a-zA-Z0-9])/g;
+var CAMEL_BOUNDARY_REGEX = /([a-z0-9])([A-Z])/g;
+var LEADING_UNDERSCORES_REGEX = /^_+/;
 function unwrapJsonSchema(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -252,9 +259,158 @@ function coerceStringToArray(s, unwrapped) {
   }
   return null;
 }
+function getStrictObjectSchemaInfo(unwrapped) {
+  if (getSchemaType(unwrapped) !== "object") {
+    return null;
+  }
+  if (unwrapped.additionalProperties !== false) {
+    return null;
+  }
+  const properties = unwrapped.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const required = Array.isArray(unwrapped.required) ? unwrapped.required.filter(
+    (value) => typeof value === "string" && value.length > 0
+  ) : [];
+  const patternProps = unwrapped.patternProperties;
+  const patternProperties = patternProps && typeof patternProps === "object" && !Array.isArray(patternProps) ? patternProps : void 0;
+  return {
+    properties: propertyMap,
+    required,
+    patternProperties
+  };
+}
+function isSingularPluralPair(left, right) {
+  return left.length > 1 && right.length > 1 && (left === `${right}s` || right === `${left}s`);
+}
+function snakeToCamel(value) {
+  const trimmed = value.replace(LEADING_UNDERSCORES_REGEX, "");
+  if (trimmed.length === 0) {
+    return value;
+  }
+  const camelized = trimmed.replace(
+    SNAKE_SEGMENT_REGEX,
+    (_, c) => c.toUpperCase()
+  );
+  return camelized.charAt(0).toLowerCase() + camelized.slice(1);
+}
+function camelToSnake(value) {
+  return value.replace(CAMEL_BOUNDARY_REGEX, "$1_$2").toLowerCase();
+}
+function isCaseStylePair(targetKey, sourceKey) {
+  if (targetKey === sourceKey) {
+    return false;
+  }
+  const sourceLooksSnake = sourceKey.includes("_");
+  const targetLooksSnake = targetKey.includes("_");
+  if (sourceLooksSnake && snakeToCamel(sourceKey) === targetKey) {
+    return true;
+  }
+  if (!sourceLooksSnake && targetLooksSnake && camelToSnake(sourceKey) === targetKey) {
+    return true;
+  }
+  return false;
+}
+function isUnexpectedKey(key, schemaInfo) {
+  if (Object.hasOwn(schemaInfo.properties, key)) {
+    return false;
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    schemaInfo.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    return patternSchemas.every((schema) => schema === false);
+  }
+  return true;
+}
+function computeMissingAndUnexpectedKeys(input, schemaInfo) {
+  const missingRequired = schemaInfo.required.filter(
+    (key) => !Object.hasOwn(input, key)
+  );
+  const unexpectedKeys = Object.keys(input).filter(
+    (key) => isUnexpectedKey(key, schemaInfo)
+  );
+  return { missingRequired, unexpectedKeys };
+}
+function applySingularPluralRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isSingularPluralPair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (getSchemaType(schemaInfo.properties[targetKey]) !== "array") {
+    return null;
+  }
+  if (!Array.isArray(input[sourceKey])) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyCaseStyleRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isCaseStylePair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyStrictRequiredKeyRename(input, unwrapped) {
+  const schemaInfo = getStrictObjectSchemaInfo(unwrapped);
+  if (!schemaInfo) {
+    return input;
+  }
+  const singularPlural = applySingularPluralRequiredKeyRename(
+    input,
+    schemaInfo
+  );
+  if (singularPlural) {
+    return singularPlural;
+  }
+  const caseStyle = applyCaseStyleRequiredKeyRename(input, schemaInfo);
+  if (caseStyle) {
+    return caseStyle;
+  }
+  return input;
+}
 function coerceObjectToObject(value, unwrapped) {
+  const normalizedInput = applyStrictRequiredKeyRename(value, unwrapped);
   const out = {};
-  for (const [k, v] of Object.entries(value)) {
+  for (const [k, v] of Object.entries(normalizedInput)) {
     out[k] = coerceValueForKey(v, k, unwrapped);
   }
   return out;
@@ -265,6 +421,109 @@ function coerceArrayToArray(value, prefixItems, itemsSchema) {
   }
   return value.map((v) => coerceBySchema(v, itemsSchema));
 }
+function isPrimitiveSchemaType(schemaType) {
+  return schemaType === "string" || schemaType === "number" || schemaType === "integer" || schemaType === "boolean";
+}
+function isPrimitiveMatchForSchemaType(value, schemaType) {
+  if (schemaType === "string") {
+    return typeof value === "string";
+  }
+  if (schemaType === "number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (schemaType === "integer") {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+  }
+  return typeof value === "boolean";
+}
+function coercePrimitiveWrappedObject(value, itemsSchema) {
+  const schemaType = getSchemaType(itemsSchema);
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(singleValue, itemsSchema);
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
+function coerceParallelArraysObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (prefixItems && prefixItems.length > 0) {
+    return null;
+  }
+  const unwrappedItems = unwrapJsonSchema(itemsSchema);
+  if (!unwrappedItems || typeof unwrappedItems !== "object" || Array.isArray(unwrappedItems)) {
+    return null;
+  }
+  const itemSchema = unwrappedItems;
+  if (getSchemaType(itemSchema) !== "object") {
+    return null;
+  }
+  if (itemSchema.additionalProperties !== false) {
+    return null;
+  }
+  const properties = itemSchema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const entries = Object.entries(maybe);
+  if (entries.length < 2) {
+    return null;
+  }
+  if (!entries.every(([, value]) => Array.isArray(value))) {
+    return null;
+  }
+  if (!entries.every(([key]) => Object.hasOwn(propertyMap, key))) {
+    return null;
+  }
+  if (!entries.every(([key]) => {
+    const schemaType = getSchemaType(propertyMap[key]);
+    return schemaType !== "array" && schemaType !== "object";
+  })) {
+    return null;
+  }
+  const lengths = [
+    ...new Set(entries.map(([, value]) => value.length))
+  ];
+  if (lengths.length !== 1) {
+    return null;
+  }
+  const length = lengths[0];
+  if (length < 2) {
+    return null;
+  }
+  const zipped = [];
+  for (let index = 0; index < length; index += 1) {
+    const item = {};
+    for (const [key, value] of entries) {
+      item[key] = value[index];
+    }
+    zipped.push(item);
+  }
+  return coerceArrayToArray(zipped, prefixItems, itemsSchema);
+}
+function coerceSingleKeyObjectToArray(singleValue, itemsSchema) {
+  if (Array.isArray(singleValue)) {
+    return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+  }
+  if (singleValue && typeof singleValue === "object") {
+    const primitiveWrapped = coercePrimitiveWrappedObject(
+      singleValue,
+      itemsSchema
+    );
+    if (primitiveWrapped !== null) {
+      return [primitiveWrapped];
+    }
+    return [coerceBySchema(singleValue, itemsSchema)];
+  }
+  return null;
+}
 function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
   if (Object.hasOwn(maybe, "item")) {
     const items = maybe.item;
@@ -276,15 +535,23 @@ function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
     const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
+  const parallelArrays = coerceParallelArraysObjectToArray(
+    maybe,
+    prefixItems,
+    itemsSchema
+  );
+  if (parallelArrays !== null) {
+    return parallelArrays;
+  }
   if (keys.length === 1) {
     const singleKey = keys[0];
     if (!(schemaIsUnconstrained(itemsSchema) || schemaHasProperty(itemsSchema, singleKey))) {
-      const singleValue = maybe[singleKey];
-      if (Array.isArray(singleValue)) {
-        return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      if (singleValue && typeof singleValue === "object") {
-        return [coerceBySchema(singleValue, itemsSchema)];
+      const result = coerceSingleKeyObjectToArray(
+        maybe[singleKey],
+        itemsSchema
+      );
+      if (result !== null) {
+        return result;
       }
     }
   }
@@ -314,6 +581,86 @@ function coerceStringToPrimitive(s, schemaType) {
   }
   return null;
 }
+function coercePrimitiveToString(value, schemaType) {
+  if (schemaType !== "string") {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function coerceStringByEnumWhitespace(rawValue, unwrapped) {
+  const enumValues = unwrapped.enum;
+  if (!Array.isArray(enumValues) || enumValues.length === 0) {
+    return null;
+  }
+  if (!enumValues.every((item) => typeof item === "string")) {
+    return null;
+  }
+  const normalizedEnumValues = enumValues;
+  if (normalizedEnumValues.includes(rawValue)) {
+    return null;
+  }
+  const unquoted = unwrapMatchingQuotes(rawValue);
+  if (unquoted !== null) {
+    const exactMatches = normalizedEnumValues.filter(
+      (item) => item === unquoted
+    );
+    if (exactMatches.length === 1) {
+      return exactMatches[0];
+    }
+  }
+  const candidates = [rawValue, unquoted].filter(
+    (item) => item !== null
+  );
+  for (const candidate of candidates) {
+    if (!HAS_WHITESPACE_REGEX.test(candidate)) {
+      continue;
+    }
+    const normalizedInput = candidate.replace(WHITESPACE_REGEX, "");
+    const matches = normalizedEnumValues.filter(
+      (item) => item.replace(WHITESPACE_REGEX, "") === normalizedInput
+    );
+    if (matches.length === 1) {
+      return matches[0];
+    }
+  }
+  return null;
+}
+function unwrapMatchingQuotes(value) {
+  if (value.length < 2) {
+    return null;
+  }
+  const first = value[0];
+  const last = value.at(-1);
+  const isQuote = (first === SINGLE_QUOTE || first === DOUBLE_QUOTE) && first === last;
+  if (!isQuote) {
+    return null;
+  }
+  return value.slice(1, -1);
+}
+function coerceObjectToPrimitive(value, schemaType, fullSchema) {
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(
+    singleValue,
+    fullSchema != null ? fullSchema : { type: schemaType }
+  );
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
 function coerceStringValue(value, schemaType, u) {
   const s = value.trim();
   if (schemaType === "object") {
@@ -332,6 +679,10 @@ function coerceStringValue(value, schemaType, u) {
   if (primitiveResult !== null) {
     return primitiveResult;
   }
+  const enumWhitespaceCanonical = coerceStringByEnumWhitespace(s, u);
+  if (enumWhitespaceCanonical !== null) {
+    return enumWhitespaceCanonical;
+  }
   return value;
 }
 function coerceArrayValue(value, prefixItems, itemsSchema) {
@@ -370,9 +721,23 @@ function coerceBySchema(value, schema) {
   if (typeof value === "string") {
     return coerceStringValue(value, schemaType, u);
   }
+  const primitiveString = coercePrimitiveToString(value, schemaType);
+  if (primitiveString !== null) {
+    return primitiveString;
+  }
   if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
     return coerceObjectToObject(value, u);
   }
+  if (value && typeof value === "object" && !Array.isArray(value) && isPrimitiveSchemaType(schemaType)) {
+    const primitiveResult = coerceObjectToPrimitive(
+      value,
+      schemaType,
+      u
+    );
+    if (primitiveResult !== null) {
+      return primitiveResult;
+    }
+  }
   if (schemaType === "array") {
     const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
     const itemsSchema = u.items;
@@ -386,4 +751,4 @@ export {
   getSchemaType,
   coerceBySchema
 };
-//# sourceMappingURL=chunk-OUGMLYAW.js.map
+//# sourceMappingURL=chunk-2KK5BDZF.js.map

package/dist/chunk-2KK5BDZF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema-coerce/index.ts"],"sourcesContent":["// Regex constants for performance\nconst NUMERIC_REGEX = /^-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?$/;\nconst EMPTY_OBJECT_REGEX = /^\\{\\s*\\}$/s;\nconst NEWLINE_SPLIT_REGEX = /\\n+/;\nconst COMMA_SPLIT_REGEX = /,\\s*/;\nconst DIGIT_KEY_REGEX = /^\\d+$/;\nconst WHITESPACE_REGEX = /\\s+/g;\nconst HAS_WHITESPACE_REGEX = /\\s/;\nconst SINGLE_QUOTE = \"'\";\nconst DOUBLE_QUOTE = '\"';\nconst SNAKE_SEGMENT_REGEX = /_([a-zA-Z0-9])/g;\nconst CAMEL_BOUNDARY_REGEX = /([a-z0-9])([A-Z])/g;\nconst LEADING_UNDERSCORES_REGEX = /^_+/;\n\nexport function unwrapJsonSchema(schema: unknown): unknown {\n  if (!schema || typeof schema !== \"object\") {\n    return schema;\n  }\n  const s = schema as Record<string, unknown>;\n  if (s.jsonSchema && typeof s.jsonSchema === \"object\") {\n    return unwrapJsonSchema(s.jsonSchema);\n  }\n  return schema;\n}\n\nexport function getSchemaType(schema: unknown): string | undefined {\n  const unwrapped = unwrapJsonSchema(schema);\n  if (!unwrapped || typeof unwrapped !== \"object\") {\n    return;\n  }\n  const t: unknown = (unwrapped as Record<string, unknown>).type;\n  if (typeof t === \"string\") {\n    return t;\n  }\n  if (Array.isArray(t)) {\n    const preferred = [\n      \"object\",\n      \"array\",\n      \"boolean\",\n      \"number\",\n      \"integer\",\n      \"string\",\n    ];\n    for (const p of preferred) {\n      if (t.includes(p)) {\n        return p;\n      }\n    }\n  }\n  const s = unwrapped as Record<string, unknown>;\n  if (s && typeof s === \"object\" && (s.properties || s.additionalProperties)) {\n    return \"object\";\n  }\n  if (\n    s &&\n    typeof s === \"object\" &&\n    (s.items || (s as Record<string, unknown>).prefixItems)\n  ) {\n    return \"array\";\n  }\n  return;\n}\n\n/**\n * Checks if a property is allowed through schema combinators (anyOf, oneOf, allOf).\n *\n * @param s - The schema object to check\n * @param key - The property key to look for\n * @param depth - Current recursion depth\n * @returns `true` if at least one combinator exists AND allows the property;\n *          `false` if no combinators exist OR none allow the property.\n *          When no combinators are present, returns `false` so the caller can\n *          fall back to other property-checking methods.\n *\n * **oneOf semantics**: JSON Schema's `oneOf` requires exactly one schema to match,\n * but for coercion heuristics we treat it like `anyOf` (at least one allows).\n * This is intentional because:\n * 1. We're determining if a property CAN exist, not validating exact matches\n * 2. Coercion should be permissive - if any branch allows the property, we allow it\n * 3. Strict oneOf validation would require runtime value inspection, not just schema analysis\n */\nfunction schemaAllowsPropertyViaCombinators(\n  s: Record<string, unknown>,\n  key: string,\n  depth: number\n): boolean {\n  const anyOfValues = s.anyOf;\n  const oneOfValues = s.oneOf;\n  const allOfValues = s.allOf;\n\n  let hasCombinator = false;\n  let anyOfAllows = true;\n  let oneOfAllows = true;\n  let allOfAllows = true;\n\n  if (Array.isArray(anyOfValues)) {\n    hasCombinator = true;\n    anyOfAllows = anyOfValues.some((sub) =>\n      schemaHasProperty(sub, key, depth + 1)\n    );\n  }\n\n  if (Array.isArray(oneOfValues)) {\n    hasCombinator = true;\n    oneOfAllows = oneOfValues.some((sub) =>\n      schemaHasProperty(sub, key, depth + 1)\n    );\n  }\n\n  if (Array.isArray(allOfValues)) {\n    hasCombinator = true;\n    allOfAllows = allOfValues.every((sub) =>\n      schemaHasProperty(sub, key, depth + 1)\n    );\n  }\n\n  if (!hasCombinator) {\n    return false;\n  }\n\n  return anyOfAllows && oneOfAllows && allOfAllows;\n}\n\nfunction schemaHasPropertyDirectly(\n  s: Record<string, unknown>,\n  key: string\n): boolean {\n  const props = s.properties;\n  if (\n    props &&\n    typeof props === \"object\" &&\n    !Array.isArray(props) &&\n    Object.hasOwn(props, key) &&\n    (props as Record<string, unknown>)[key] !== false\n  ) {\n    return true;\n  }\n  const required = s.required;\n  if (Array.isArray(required) && required.includes(key)) {\n    return true;\n  }\n  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);\n  return patternSchemas.some((schema) => schema !== false);\n}\n\n/**\n * Checks if a schema allows additional properties beyond those explicitly defined.\n *\n * JSON Schema behavior for additionalProperties:\n * - `additionalProperties: true` or `additionalProperties: { schema }`: Explicitly allows additional properties\n * - `additionalProperties: false`: Explicitly disallows additional properties\n * - `additionalProperties` not specified: Defaults to allowing additional properties (JSON Schema spec)\n *\n * When `additionalProperties` is not explicitly set, this function returns `true` if the schema\n * appears to be an object schema (has `type: \"object\"`, `properties`, `patternProperties`, or `required`).\n * This follows the JSON Schema specification where omitting `additionalProperties` is equivalent to `true`.\n *\n * **Important**: This means schemas like `{ type: \"object\", properties: { foo: ... } }` without\n * `additionalProperties: false` will be treated as allowing any additional property, which affects\n * single-key object unwrapping behavior in array coercion.\n *\n * @param s - The schema object to check\n * @returns `true` if the schema allows additional properties, `false` otherwise\n */\nfunction schemaHasPropertyViaAdditional(s: Record<string, unknown>): boolean {\n  const additional = s.additionalProperties;\n  if (\n    additional === true ||\n    (additional && typeof additional === \"object\" && !Array.isArray(additional))\n  ) {\n    return true;\n  }\n  if (Object.hasOwn(s, \"additionalProperties\")) {\n    return false;\n  }\n  const type = s.type;\n  const isObjectType =\n    type === \"object\" || (Array.isArray(type) && type.includes(\"object\"));\n  const hasObjectKeywords =\n    (s.properties &&\n      typeof s.properties === \"object\" &&\n      !Array.isArray(s.properties)) ||\n    (s.patternProperties &&\n      typeof s.patternProperties === \"object\" &&\n      !Array.isArray(s.patternProperties)) ||\n    (Array.isArray(s.required) && s.required.length > 0);\n  return !!(isObjectType || hasObjectKeywords);\n}\n\nfunction schemaDisallowsPropertyDirectly(\n  s: Record<string, unknown>,\n  key: string\n): boolean {\n  const props = s.properties;\n  if (\n    props &&\n    typeof props === \"object\" &&\n    !Array.isArray(props) &&\n    Object.hasOwn(props, key) &&\n    (props as Record<string, unknown>)[key] === false\n  ) {\n    return true;\n  }\n  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);\n  return patternSchemas.some((schema) => schema === false);\n}\n\n/**\n * Checks if a schema allows a specific property key.\n *\n * Recursively checks through schema combinators (allOf, anyOf, oneOf) to determine\n * if the given key is allowed by the schema.\n *\n * @param schema - The JSON Schema to check\n * @param key - The property key to check for\n * @param depth - Current recursion depth (default: 0)\n * @returns `true` if the schema allows the property, `false` otherwise\n *\n * @remarks\n * The depth limit of 5 prevents infinite recursion in deeply nested or circular\n * schema references. This limit is sufficient for most real-world schemas while\n * protecting against pathological cases. When the limit is exceeded, the function\n * conservatively returns `true` to prevent unwrapping - it's safer to keep a\n * wrapper key than to incorrectly remove it and lose data.\n */\nfunction schemaHasProperty(schema: unknown, key: string, depth = 0): boolean {\n  if (depth > 5) {\n    return true;\n  }\n  const unwrapped = unwrapJsonSchema(schema);\n  // Unconstrained schemas (true, null, {}) allow any property\n  if (schemaIsUnconstrained(unwrapped)) {\n    return true;\n  }\n  if (!unwrapped || typeof unwrapped !== \"object\") {\n    return false;\n  }\n  const s = unwrapped as Record<string, unknown>;\n\n  if (schemaDisallowsPropertyDirectly(s, key)) {\n    return false;\n  }\n  if (schemaHasPropertyDirectly(s, key)) {\n    return true;\n  }\n  if (schemaHasPropertyViaAdditional(s)) {\n    return true;\n  }\n  return schemaAllowsPropertyViaCombinators(s, key, depth);\n}\n\nfunction schemaIsUnconstrained(schema: unknown): boolean {\n  const unwrapped = unwrapJsonSchema(schema);\n  if (unwrapped == null || unwrapped === true) {\n    return true;\n  }\n  if (typeof unwrapped !== \"object\" || Array.isArray(unwrapped)) {\n    return false;\n  }\n  return Object.keys(unwrapped).length === 0;\n}\n\n/**\n * Gets all schemas from patternProperties that match the given key.\n *\n * @param patternProperties - The patternProperties object from a JSON Schema\n * @param key - The property key to match against patterns\n * @returns Array of schemas whose patterns match the key\n *\n * @remarks\n * **Security consideration**: This function executes regex patterns from the schema.\n * In typical usage (AI SDK tool parsing), schemas come from trusted application code.\n * However, if schemas can originate from untrusted sources, be aware of potential\n * ReDoS (Regular Expression Denial of Service) with malicious patterns like `(a+)+$`.\n * Consider adding regex timeout or safe-regex validation if processing untrusted schemas.\n */\nfunction getPatternSchemasForKey(\n  patternProperties: unknown,\n  key: string\n): unknown[] {\n  if (\n    !patternProperties ||\n    typeof patternProperties !== \"object\" ||\n    Array.isArray(patternProperties)\n  ) {\n    return [];\n  }\n  const schemas: unknown[] = [];\n  for (const [pattern, schema] of Object.entries(\n    patternProperties as Record<string, unknown>\n  )) {\n    try {\n      const regex = new RegExp(pattern);\n      if (regex.test(key)) {\n        schemas.push(schema);\n      }\n    } catch {\n      // Ignore invalid regex patterns.\n    }\n  }\n  return schemas;\n}\n\nfunction coerceValueForKey(\n  value: unknown,\n  key: string,\n  unwrapped: Record<string, unknown>\n): unknown {\n  const schemas: unknown[] = [];\n  const props = unwrapped.properties as Record<string, unknown> | undefined;\n  if (props && Object.hasOwn(props, key)) {\n    schemas.push(props[key]);\n  }\n  const patternSchemas = getPatternSchemasForKey(\n    unwrapped.patternProperties,\n    key\n  );\n  if (patternSchemas.length > 0) {\n    schemas.push(...patternSchemas);\n  }\n\n  if (schemas.length > 0) {\n    let out = value;\n    for (const schema of schemas) {\n      if (typeof schema === \"boolean\") {\n        continue;\n      }\n      out = coerceBySchema(out, schema);\n    }\n    return out;\n  }\n\n  const additional = unwrapped.additionalProperties;\n  if (\n    additional &&\n    typeof additional === \"object\" &&\n    !Array.isArray(additional)\n  ) {\n    return coerceBySchema(value, additional);\n  }\n  if (additional === true || additional === false) {\n    return value;\n  }\n\n  return coerceBySchema(value, undefined);\n}\n\n/**\n * Coerce string value without schema information\n */\nfunction coerceStringWithoutSchema(value: string): unknown {\n  const s = value.trim();\n  const lower = s.toLowerCase();\n  if (lower === \"true\") {\n    return true;\n  }\n  if (lower === \"false\") {\n    return false;\n  }\n  if (NUMERIC_REGEX.test(s)) {\n    const num = Number(s);\n    if (Number.isFinite(num)) {\n      return num;\n    }\n  }\n\n  // Fallback: try parsing JSON-like strings when no schema info\n  if (\n    (s.startsWith(\"{\") && s.endsWith(\"}\")) ||\n    (s.startsWith(\"[\") && s.endsWith(\"]\"))\n  ) {\n    try {\n      const parsed = JSON.parse(s);\n      return coerceBySchema(parsed, undefined);\n    } catch {\n      // If parsing fails, return original value\n    }\n  }\n  return value;\n}\n\n/**\n * Coerce string to object using schema\n */\nfunction coerceStringToObject(\n  s: string,\n  unwrapped: Record<string, unknown>\n): unknown {\n  try {\n    let normalized = s.replace(/'/g, '\"');\n    normalized = normalized.replace(EMPTY_OBJECT_REGEX, \"{}\");\n\n    const obj = JSON.parse(normalized);\n    if (obj && typeof obj === \"object\" && !Array.isArray(obj)) {\n      return coerceObjectToObject(obj as Record<string, unknown>, unwrapped);\n    }\n  } catch {\n    // fallthrough\n  }\n  return null;\n}\n\n/**\n * Coerce string to array using schema\n */\nfunction coerceStringToArray(\n  s: string,\n  unwrapped: Record<string, unknown>\n): unknown {\n  const prefixItems = Array.isArray(unwrapped.prefixItems)\n    ? (unwrapped.prefixItems as unknown[])\n    : undefined;\n  const itemsSchema = unwrapped.items as unknown;\n\n  try {\n    const normalized = s.replace(/'/g, '\"');\n    const arr = JSON.parse(normalized);\n    if (Array.isArray(arr)) {\n      if (prefixItems && arr.length === prefixItems.length) {\n        return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));\n      }\n      return arr.map((v) => coerceBySchema(v, itemsSchema));\n    }\n  } catch {\n    const csv = s.includes(\"\\n\")\n      ? s.split(NEWLINE_SPLIT_REGEX)\n      : s.split(COMMA_SPLIT_REGEX);\n    const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);\n    if (prefixItems && trimmed.length === prefixItems.length) {\n      return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));\n    }\n    return trimmed.map((x) => coerceBySchema(x, itemsSchema));\n  }\n  return null;\n}\n\ninterface StrictObjectSchemaInfo {\n  properties: Record<string, unknown>;\n  required: string[];\n  patternProperties?: Record<string, unknown>;\n}\n\nfunction getStrictObjectSchemaInfo(\n  unwrapped: Record<string, unknown>\n): StrictObjectSchemaInfo | null {\n  if (getSchemaType(unwrapped) !== \"object\") {\n    return null;\n  }\n  if (unwrapped.additionalProperties !== false) {\n    return null;\n  }\n\n  const properties = unwrapped.properties;\n  if (\n    !properties ||\n    typeof properties !== \"object\" ||\n    Array.isArray(properties)\n  ) {\n    return null;\n  }\n\n  const propertyMap = properties as Record<string, unknown>;\n  const required = Array.isArray(unwrapped.required)\n    ? unwrapped.required.filter(\n        (value): value is string =>\n          typeof value === \"string\" && value.length > 0\n      )\n    : [];\n\n  const patternProps = unwrapped.patternProperties;\n  const patternProperties =\n    patternProps &&\n    typeof patternProps === \"object\" &&\n    !Array.isArray(patternProps)\n      ? (patternProps as Record<string, unknown>)\n      : undefined;\n\n  return {\n    properties: propertyMap,\n    required,\n    patternProperties,\n  };\n}\n\nfunction isSingularPluralPair(left: string, right: string): boolean {\n  return (\n    left.length > 1 &&\n    right.length > 1 &&\n    (left === `${right}s` || right === `${left}s`)\n  );\n}\n\nfunction snakeToCamel(value: string): string {\n  const trimmed = value.replace(LEADING_UNDERSCORES_REGEX, \"\");\n  if (trimmed.length === 0) {\n    return value;\n  }\n  const camelized = trimmed.replace(SNAKE_SEGMENT_REGEX, (_, c: string) =>\n    c.toUpperCase()\n  );\n  return camelized.charAt(0).toLowerCase() + camelized.slice(1);\n}\n\nfunction camelToSnake(value: string): string {\n  return value.replace(CAMEL_BOUNDARY_REGEX, \"$1_$2\").toLowerCase();\n}\n\nfunction isCaseStylePair(targetKey: string, sourceKey: string): boolean {\n  if (targetKey === sourceKey) {\n    return false;\n  }\n  const sourceLooksSnake = sourceKey.includes(\"_\");\n  const targetLooksSnake = targetKey.includes(\"_\");\n\n  if (sourceLooksSnake && snakeToCamel(sourceKey) === targetKey) {\n    return true;\n  }\n  if (\n    !sourceLooksSnake &&\n    targetLooksSnake &&\n    camelToSnake(sourceKey) === targetKey\n  ) {\n    return true;\n  }\n  return false;\n}\n\nfunction isUnexpectedKey(\n  key: string,\n  schemaInfo: StrictObjectSchemaInfo\n): boolean {\n  if (Object.hasOwn(schemaInfo.properties, key)) {\n    return false;\n  }\n  const patternSchemas = getPatternSchemasForKey(\n    schemaInfo.patternProperties,\n    key\n  );\n  if (patternSchemas.length > 0) {\n    return patternSchemas.every((schema) => schema === false);\n  }\n  return true;\n}\n\nfunction computeMissingAndUnexpectedKeys(\n  input: Record<string, unknown>,\n  schemaInfo: StrictObjectSchemaInfo\n): { missingRequired: string[]; unexpectedKeys: string[] } {\n  const missingRequired = schemaInfo.required.filter(\n    (key) => !Object.hasOwn(input, key)\n  );\n  const unexpectedKeys = Object.keys(input).filter((key) =>\n    isUnexpectedKey(key, schemaInfo)\n  );\n  return { missingRequired, unexpectedKeys };\n}\n\nfunction applySingularPluralRequiredKeyRename(\n  input: Record<string, unknown>,\n  schemaInfo: StrictObjectSchemaInfo\n): Record<string, unknown> | null {\n  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(\n    input,\n    schemaInfo\n  );\n\n  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {\n    return null;\n  }\n\n  const targetKey = missingRequired[0];\n  const sourceKey = unexpectedKeys[0];\n  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {\n    return null;\n  }\n  if (!isSingularPluralPair(targetKey, sourceKey)) {\n    return null;\n  }\n  if (getSchemaType(schemaInfo.properties[targetKey]) !== \"array\") {\n    return null;\n  }\n  if (!Array.isArray(input[sourceKey])) {\n    return null;\n  }\n  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {\n    return null;\n  }\n\n  const output: Record<string, unknown> = { ...input };\n  output[targetKey] = output[sourceKey];\n  delete output[sourceKey];\n  return output;\n}\n\nfunction applyCaseStyleRequiredKeyRename(\n  input: Record<string, unknown>,\n  schemaInfo: StrictObjectSchemaInfo\n): Record<string, unknown> | null {\n  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(\n    input,\n    schemaInfo\n  );\n\n  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {\n    return null;\n  }\n\n  const targetKey = missingRequired[0];\n  const sourceKey = unexpectedKeys[0];\n  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {\n    return null;\n  }\n  if (!isCaseStylePair(targetKey, sourceKey)) {\n    return null;\n  }\n  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {\n    return null;\n  }\n\n  const output: Record<string, unknown> = { ...input };\n  output[targetKey] = output[sourceKey];\n  delete output[sourceKey];\n  return output;\n}\n\nfunction applyStrictRequiredKeyRename(\n  input: Record<string, unknown>,\n  unwrapped: Record<string, unknown>\n): Record<string, unknown> {\n  const schemaInfo = getStrictObjectSchemaInfo(unwrapped);\n  if (!schemaInfo) {\n    return input;\n  }\n\n  const singularPlural = applySingularPluralRequiredKeyRename(\n    input,\n    schemaInfo\n  );\n  if (singularPlural) {\n    return singularPlural;\n  }\n\n  const caseStyle = applyCaseStyleRequiredKeyRename(input, schemaInfo);\n  if (caseStyle) {\n    return caseStyle;\n  }\n\n  return input;\n}\n\n/**\n * Coerce object to object using schema\n */\nfunction coerceObjectToObject(\n  value: Record<string, unknown>,\n  unwrapped: Record<string, unknown>\n): Record<string, unknown> {\n  const normalizedInput = applyStrictRequiredKeyRename(value, unwrapped);\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(normalizedInput)) {\n    out[k] = coerceValueForKey(v, k, unwrapped);\n  }\n  return out;\n}\n\n/**\n * Coerce array to array using schema\n */\nfunction coerceArrayToArray(\n  value: unknown[],\n  prefixItems: unknown[] | undefined,\n  itemsSchema: unknown\n): unknown[] {\n  if (prefixItems && value.length === prefixItems.length) {\n    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));\n  }\n  return value.map((v) => coerceBySchema(v, itemsSchema));\n}\n\nfunction isPrimitiveSchemaType(\n  schemaType: string | undefined\n): schemaType is \"string\" | \"number\" | \"integer\" | \"boolean\" {\n  return (\n    schemaType === \"string\" ||\n    schemaType === \"number\" ||\n    schemaType === \"integer\" ||\n    schemaType === \"boolean\"\n  );\n}\n\nfunction isPrimitiveMatchForSchemaType(\n  value: unknown,\n  schemaType: \"string\" | \"number\" | \"integer\" | \"boolean\"\n): boolean {\n  if (schemaType === \"string\") {\n    return typeof value === \"string\";\n  }\n  if (schemaType === \"number\") {\n    return typeof value === \"number\" && Number.isFinite(value);\n  }\n  if (schemaType === \"integer\") {\n    return (\n      typeof value === \"number\" &&\n      Number.isFinite(value) &&\n      Number.isInteger(value)\n    );\n  }\n  return typeof value === \"boolean\";\n}\n\nfunction coercePrimitiveWrappedObject(\n  value: Record<string, unknown>,\n  itemsSchema: unknown\n): unknown {\n  const schemaType = getSchemaType(itemsSchema);\n  if (!isPrimitiveSchemaType(schemaType)) {\n    return null;\n  }\n\n  const keys = Object.keys(value);\n  if (keys.length !== 1) {\n    return null;\n  }\n\n  const singleValue = value[keys[0]];\n  if (singleValue && typeof singleValue === \"object\") {\n    return null;\n  }\n\n  const coerced = coerceBySchema(singleValue, itemsSchema);\n  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;\n}\n\n/**\n * Expand object-of-parallel-arrays into array-of-objects when schema is strict.\n *\n * Example:\n * { field: [\"status\",\"amount\"], op: [\"=\",\">\"], value: [\"paid\",\"100\"] }\n * -> [\n *   { field: \"status\", op: \"=\", value: \"paid\" },\n *   { field: \"amount\", op: \">\", value: \"100\" }\n * ]\n *\n * Safety boundary:\n * - items schema must be an object schema with explicit `properties`\n * - `additionalProperties` must be `false`\n * - all input keys must be explicit properties\n * - each mapped property must be primitive-like (not array/object)\n * - all values must be arrays with identical length >= 2\n */\nfunction coerceParallelArraysObjectToArray(\n  maybe: Record<string, unknown>,\n  prefixItems: unknown[] | undefined,\n  itemsSchema: unknown\n): unknown[] | null {\n  if (prefixItems && prefixItems.length > 0) {\n    return null;\n  }\n\n  const unwrappedItems = unwrapJsonSchema(itemsSchema);\n  if (\n    !unwrappedItems ||\n    typeof unwrappedItems !== \"object\" ||\n    Array.isArray(unwrappedItems)\n  ) {\n    return null;\n  }\n  const itemSchema = unwrappedItems as Record<string, unknown>;\n  if (getSchemaType(itemSchema) !== \"object\") {\n    return null;\n  }\n  if (itemSchema.additionalProperties !== false) {\n    return null;\n  }\n\n  const properties = itemSchema.properties;\n  if (\n    !properties ||\n    typeof properties !== \"object\" ||\n    Array.isArray(properties)\n  ) {\n    return null;\n  }\n  const propertyMap = properties as Record<string, unknown>;\n\n  const entries = Object.entries(maybe);\n  if (entries.length < 2) {\n    return null;\n  }\n  if (!entries.every(([, value]) => Array.isArray(value))) {\n    return null;\n  }\n  if (!entries.every(([key]) => Object.hasOwn(propertyMap, key))) {\n    return null;\n  }\n  if (\n    !entries.every(([key]) => {\n      const schemaType = getSchemaType(propertyMap[key]);\n      return schemaType !== \"array\" && schemaType !== \"object\";\n    })\n  ) {\n    return null;\n  }\n\n  const lengths = [\n    ...new Set(entries.map(([, value]) => (value as unknown[]).length)),\n  ];\n  if (lengths.length !== 1) {\n    return null;\n  }\n  const length = lengths[0];\n  if (length < 2) {\n    return null;\n  }\n\n  const zipped: Record<string, unknown>[] = [];\n  for (let index = 0; index < length; index += 1) {\n    const item: Record<string, unknown> = {};\n    for (const [key, value] of entries) {\n      item[key] = (value as unknown[])[index];\n    }\n    zipped.push(item);\n  }\n\n  return coerceArrayToArray(zipped, prefixItems, itemsSchema);\n}\n\nfunction coerceSingleKeyObjectToArray(\n  singleValue: unknown,\n  itemsSchema: unknown\n): unknown[] | null {\n  if (Array.isArray(singleValue)) {\n    return singleValue.map((v) => coerceBySchema(v, itemsSchema));\n  }\n  if (singleValue && typeof singleValue === \"object\") {\n    const primitiveWrapped = coercePrimitiveWrappedObject(\n      singleValue as Record<string, unknown>,\n      itemsSchema\n    );\n    if (primitiveWrapped !== null) {\n      return [primitiveWrapped];\n    }\n    return [coerceBySchema(singleValue, itemsSchema)];\n  }\n  return null;\n}\n\n/**\n * Coerce object to array using schema\n */\nfunction coerceObjectToArray(\n  maybe: Record<string, unknown>,\n  prefixItems: unknown[] | undefined,\n  itemsSchema: unknown\n): unknown {\n  if (Object.hasOwn(maybe, \"item\")) {\n    const items = maybe.item as unknown;\n    const arr = Array.isArray(items) ? items : [items];\n    return coerceArrayToArray(arr, prefixItems, itemsSchema);\n  }\n\n  const keys = Object.keys(maybe);\n\n  // Check for numeric keys (traditional tuple handling)\n  if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {\n    const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);\n    return coerceArrayToArray(arr, prefixItems, itemsSchema);\n  }\n\n  const parallelArrays = coerceParallelArraysObjectToArray(\n    maybe,\n    prefixItems,\n    itemsSchema\n  );\n  if (parallelArrays !== null) {\n    return parallelArrays;\n  }\n\n  // Check for single field that contains an array or object (common XML pattern)\n  // This handles both: { user: [{ name: \"A\" }, { name: \"B\" }] } and { user: { name: \"A\" } }\n  if (keys.length === 1) {\n    const singleKey = keys[0];\n    if (\n      !(\n        schemaIsUnconstrained(itemsSchema) ||\n        schemaHasProperty(itemsSchema, singleKey)\n      )\n    ) {\n      const result = coerceSingleKeyObjectToArray(\n        maybe[singleKey],\n        itemsSchema\n      );\n      if (result !== null) {\n        return result;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Coerce primitive to array using schema\n */\nfunction coercePrimitiveToArray(\n  value: unknown,\n  prefixItems: unknown[] | undefined,\n  itemsSchema: unknown\n): unknown[] {\n  if (prefixItems && prefixItems.length > 0) {\n    return [coerceBySchema(value, prefixItems[0])];\n  }\n  return [coerceBySchema(value, itemsSchema)];\n}\n\n/**\n * Coerce string to primitive type using schema\n */\nfunction coerceStringToPrimitive(\n  s: string,\n  schemaType: string | undefined\n): unknown {\n  if (schemaType === \"boolean\") {\n    const lower = s.toLowerCase();\n    if (lower === \"true\") {\n      return true;\n    }\n    if (lower === \"false\") {\n      return false;\n    }\n  }\n  if (\n    (schemaType === \"number\" || schemaType === \"integer\") &&\n    NUMERIC_REGEX.test(s)\n  ) {\n    const num = Number(s);\n    if (Number.isFinite(num)) {\n      return num;\n    }\n  }\n  return null;\n}\n\nfunction coercePrimitiveToString(\n  value: unknown,\n  schemaType: string | undefined\n): string | null {\n  if (schemaType !== \"string\") {\n    return null;\n  }\n  if (typeof value === \"boolean\") {\n    return value ? \"true\" : \"false\";\n  }\n  if (typeof value === \"number\" && Number.isFinite(value)) {\n    return String(value);\n  }\n  return null;\n}\n\n/**\n * Conservative enum canonicalization for whitespace-only differences.\n *\n * Some reasoning-heavy models (for example, ERNIE-4.5-21B-A3B-Thinking) can\n * output spaced enum tokens such as \"1 d\" while the schema enum is \"1d\".\n *\n * Safety boundary:\n * - Only runs for string-only enum lists.\n * - Only runs when the model output contains whitespace.\n * - Only rewrites when whitespace-normalized comparison yields exactly one match.\n */\nfunction coerceStringByEnumWhitespace(\n  rawValue: string,\n  unwrapped: Record<string, unknown>\n): string | null {\n  const enumValues = unwrapped.enum;\n  if (!Array.isArray(enumValues) || enumValues.length === 0) {\n    return null;\n  }\n  if (!enumValues.every((item) => typeof item === \"string\")) {\n    return null;\n  }\n  const normalizedEnumValues = enumValues as string[];\n  if (normalizedEnumValues.includes(rawValue)) {\n    return null;\n  }\n\n  const unquoted = unwrapMatchingQuotes(rawValue);\n  if (unquoted !== null) {\n    const exactMatches = normalizedEnumValues.filter(\n      (item) => item === unquoted\n    );\n    if (exactMatches.length === 1) {\n      return exactMatches[0];\n    }\n  }\n\n  const candidates = [rawValue, unquoted].filter(\n    (item): item is string => item !== null\n  );\n  for (const candidate of candidates) {\n    if (!HAS_WHITESPACE_REGEX.test(candidate)) {\n      continue;\n    }\n    const normalizedInput = candidate.replace(WHITESPACE_REGEX, \"\");\n    const matches = normalizedEnumValues.filter(\n      (item) => item.replace(WHITESPACE_REGEX, \"\") === normalizedInput\n    );\n    if (matches.length === 1) {\n      return matches[0];\n    }\n  }\n\n  return null;\n}\n\nfunction unwrapMatchingQuotes(value: string): string | null {\n  if (value.length < 2) {\n    return null;\n  }\n  const first = value[0];\n  const last = value.at(-1);\n  const isQuote =\n    (first === SINGLE_QUOTE || first === DOUBLE_QUOTE) && first === last;\n  if (!isQuote) {\n    return null;\n  }\n  return value.slice(1, -1);\n}\n\nfunction coerceObjectToPrimitive(\n  value: Record<string, unknown>,\n  schemaType: string | undefined,\n  fullSchema?: Record<string, unknown>\n): unknown {\n  if (!isPrimitiveSchemaType(schemaType)) {\n    return null;\n  }\n\n  const keys = Object.keys(value);\n  if (keys.length !== 1) {\n    return null;\n  }\n\n  const singleValue = value[keys[0]];\n  if (singleValue && typeof singleValue === \"object\") {\n    return null;\n  }\n\n  const coerced = coerceBySchema(\n    singleValue,\n    fullSchema ?? { type: schemaType }\n  );\n  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;\n}\n\nfunction coerceStringValue(\n  value: string,\n  schemaType: string | undefined,\n  u: Record<string, unknown>\n): unknown {\n  const s = value.trim();\n\n  if (schemaType === \"object\") {\n    const result = coerceStringToObject(s, u);\n    if (result !== null) {\n      return result;\n    }\n  }\n\n  if (schemaType === \"array\") {\n    const result = coerceStringToArray(s, u);\n    if (result !== null) {\n      return result;\n    }\n  }\n\n  const primitiveResult = coerceStringToPrimitive(s, schemaType);\n  if (primitiveResult !== null) {\n    return primitiveResult;\n  }\n\n  const enumWhitespaceCanonical = coerceStringByEnumWhitespace(s, u);\n  if (enumWhitespaceCanonical !== null) {\n    return enumWhitespaceCanonical;\n  }\n\n  return value;\n}\n\nfunction coerceArrayValue(\n  value: unknown,\n  prefixItems: unknown[] | undefined,\n  itemsSchema: unknown\n): unknown {\n  if (Array.isArray(value)) {\n    return coerceArrayToArray(value, prefixItems, itemsSchema);\n  }\n\n  if (value && typeof value === \"object\") {\n    const result = coerceObjectToArray(\n      value as Record<string, unknown>,\n      prefixItems,\n      itemsSchema\n    );\n    if (result !== null) {\n      return result;\n    }\n    // To prevent infinite recursion, check if the itemsSchema is also for an array.\n    // If so, just wrap the object. Otherwise, coerce it against the itemsSchema.\n    if (getSchemaType(itemsSchema) === \"array\") {\n      return [value];\n    }\n    return [coerceBySchema(value, itemsSchema)];\n  }\n\n  if (\n    value == null ||\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    return coercePrimitiveToArray(value, prefixItems, itemsSchema);\n  }\n\n  return [value];\n}\n\nexport function coerceBySchema(value: unknown, schema?: unknown): unknown {\n  const unwrapped = unwrapJsonSchema(schema);\n  if (!unwrapped || typeof unwrapped !== \"object\") {\n    if (typeof value === \"string\") {\n      return coerceStringWithoutSchema(value);\n    }\n    return value;\n  }\n\n  const schemaType = getSchemaType(unwrapped);\n  const u = unwrapped as Record<string, unknown>;\n\n  // Handle string values\n  if (typeof value === \"string\") {\n    return coerceStringValue(value, schemaType, u);\n  }\n\n  // Coerce primitive scalars to string when schema explicitly expects a string.\n  const primitiveString = coercePrimitiveToString(value, schemaType);\n  if (primitiveString !== null) {\n    return primitiveString;\n  }\n\n  // Handle object to object coercion\n  if (\n    schemaType === \"object\" &&\n    value &&\n    typeof value === \"object\" &&\n    !Array.isArray(value)\n  ) {\n    return coerceObjectToObject(value as Record<string, unknown>, u);\n  }\n\n  // Handle object wrappers when schema expects a primitive value.\n  if (\n    value &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    isPrimitiveSchemaType(schemaType)\n  ) {\n    const primitiveResult = coerceObjectToPrimitive(\n      value as Record<string, unknown>,\n      schemaType,\n      u\n    );\n    if (primitiveResult !== null) {\n      return primitiveResult;\n    }\n  }\n\n  // Handle array coercion\n  if (schemaType === \"array\") {\n    const prefixItems = Array.isArray(u.prefixItems)\n      ? (u.prefixItems as unknown[])\n      : undefined;\n    const itemsSchema = u.items as unknown;\n\n    return coerceArrayValue(value, prefixItems, itemsSchema);\n  }\n\n  return value;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-EW3A6Y7O.js → chunk-CXWS24JX.js}

@@ -2,7 +2,7 @@ import {
   coerceBySchema,
   getSchemaType,
   unwrapJsonSchema
-} from "./chunk-OUGMLYAW.js";
+} from "./chunk-2KK5BDZF.js";
 
 // src/rxml/errors/types.ts
 var RXMLParseError = class extends Error {
@@ -1846,6 +1846,11 @@ function createIntermediateCall(toolName, rawSegment, schema) {
   };
 }
 
+// src/core/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/rxml/heuristics/xml-defaults.ts
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
@@ -2087,9 +2092,6 @@ function getStringPropertyNames(schema) {
   }
   return names;
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function dedupeSingleTag(xml, key) {
   var _a, _b;
   const escaped = escapeRegExp(key);
@@ -2210,7 +2212,8 @@ function parse2(xml, schema, options = {}) {
 }
 
 export {
+  escapeRegExp,
   stringify,
   parse2 as parse
 };
-//# sourceMappingURL=chunk-EW3A6Y7O.js.map
+//# sourceMappingURL=chunk-CXWS24JX.js.map