@ai-sdk-tool/parser 3.3.0 → 3.3.2

package/dist/{chunk-DZB6Y354.js → chunk-OUGMLYAW.js}

@@ -47,6 +47,153 @@ function getSchemaType(schema) {
   }
   return;
 }
+function schemaAllowsPropertyViaCombinators(s, key, depth) {
+  const anyOfValues = s.anyOf;
+  const oneOfValues = s.oneOf;
+  const allOfValues = s.allOf;
+  let hasCombinator = false;
+  let anyOfAllows = true;
+  let oneOfAllows = true;
+  let allOfAllows = true;
+  if (Array.isArray(anyOfValues)) {
+    hasCombinator = true;
+    anyOfAllows = anyOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(oneOfValues)) {
+    hasCombinator = true;
+    oneOfAllows = oneOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(allOfValues)) {
+    hasCombinator = true;
+    allOfAllows = allOfValues.every(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (!hasCombinator) {
+    return false;
+  }
+  return anyOfAllows && oneOfAllows && allOfAllows;
+}
+function schemaHasPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] !== false) {
+    return true;
+  }
+  const required = s.required;
+  if (Array.isArray(required) && required.includes(key)) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema !== false);
+}
+function schemaHasPropertyViaAdditional(s) {
+  const additional = s.additionalProperties;
+  if (additional === true || additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return true;
+  }
+  if (Object.hasOwn(s, "additionalProperties")) {
+    return false;
+  }
+  const type = s.type;
+  const isObjectType = type === "object" || Array.isArray(type) && type.includes("object");
+  const hasObjectKeywords = s.properties && typeof s.properties === "object" && !Array.isArray(s.properties) || s.patternProperties && typeof s.patternProperties === "object" && !Array.isArray(s.patternProperties) || Array.isArray(s.required) && s.required.length > 0;
+  return !!(isObjectType || hasObjectKeywords);
+}
+function schemaDisallowsPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] === false) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema === false);
+}
+function schemaHasProperty(schema, key, depth = 0) {
+  if (depth > 5) {
+    return true;
+  }
+  const unwrapped = unwrapJsonSchema(schema);
+  if (schemaIsUnconstrained(unwrapped)) {
+    return true;
+  }
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return false;
+  }
+  const s = unwrapped;
+  if (schemaDisallowsPropertyDirectly(s, key)) {
+    return false;
+  }
+  if (schemaHasPropertyDirectly(s, key)) {
+    return true;
+  }
+  if (schemaHasPropertyViaAdditional(s)) {
+    return true;
+  }
+  return schemaAllowsPropertyViaCombinators(s, key, depth);
+}
+function schemaIsUnconstrained(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (unwrapped == null || unwrapped === true) {
+    return true;
+  }
+  if (typeof unwrapped !== "object" || Array.isArray(unwrapped)) {
+    return false;
+  }
+  return Object.keys(unwrapped).length === 0;
+}
+function getPatternSchemasForKey(patternProperties, key) {
+  if (!patternProperties || typeof patternProperties !== "object" || Array.isArray(patternProperties)) {
+    return [];
+  }
+  const schemas = [];
+  for (const [pattern, schema] of Object.entries(
+    patternProperties
+  )) {
+    try {
+      const regex = new RegExp(pattern);
+      if (regex.test(key)) {
+        schemas.push(schema);
+      }
+    } catch (e) {
+    }
+  }
+  return schemas;
+}
+function coerceValueForKey(value, key, unwrapped) {
+  const schemas = [];
+  const props = unwrapped.properties;
+  if (props && Object.hasOwn(props, key)) {
+    schemas.push(props[key]);
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    unwrapped.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    schemas.push(...patternSchemas);
+  }
+  if (schemas.length > 0) {
+    let out = value;
+    for (const schema of schemas) {
+      if (typeof schema === "boolean") {
+        continue;
+      }
+      out = coerceBySchema(out, schema);
+    }
+    return out;
+  }
+  const additional = unwrapped.additionalProperties;
+  if (additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return coerceBySchema(value, additional);
+  }
+  if (additional === true || additional === false) {
+    return value;
+  }
+  return coerceBySchema(value, void 0);
+}
 function coerceStringWithoutSchema(value) {
   const s = value.trim();
   const lower = s.toLowerCase();
@@ -77,13 +224,7 @@ function coerceStringToObject(s, unwrapped) {
     normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
     const obj = JSON.parse(normalized);
     if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-      const props = unwrapped.properties;
-      const out = {};
-      for (const [k, v] of Object.entries(obj)) {
-        const propSchema = props ? props[k] : void 0;
-        out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-      }
-      return out;
+      return coerceObjectToObject(obj, unwrapped);
     }
   } catch (e) {
   }
@@ -113,10 +254,8 @@ function coerceStringToArray(s, unwrapped) {
 }
 function coerceObjectToObject(value, unwrapped) {
   const out = {};
-  const props = unwrapped.properties;
   for (const [k, v] of Object.entries(value)) {
-    const propSchema = props ? props[k] : void 0;
-    out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+    out[k] = coerceValueForKey(v, k, unwrapped);
   }
   return out;
 }
@@ -133,16 +272,22 @@ function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
   const keys = Object.keys(maybe);
-  if (keys.length === 1) {
-    const singleValue = maybe[keys[0]];
-    if (Array.isArray(singleValue)) {
-      return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-    }
-  }
   if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
     const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
+  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)];
+      }
+    }
+  }
   return null;
 }
 function coercePrimitiveToArray(value, prefixItems, itemsSchema) {
@@ -202,11 +347,15 @@ function coerceArrayValue(value, prefixItems, itemsSchema) {
     if (result !== null) {
       return result;
     }
+    if (getSchemaType(itemsSchema) === "array") {
+      return [value];
+    }
+    return [coerceBySchema(value, itemsSchema)];
   }
   if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
     return coercePrimitiveToArray(value, prefixItems, itemsSchema);
   }
-  return value;
+  return [value];
 }
 function coerceBySchema(value, schema) {
   const unwrapped = unwrapJsonSchema(schema);
@@ -237,4 +386,4 @@ export {
   getSchemaType,
   coerceBySchema
 };
-//# sourceMappingURL=chunk-DZB6Y354.js.map
+//# sourceMappingURL=chunk-OUGMLYAW.js.map

package/dist/chunk-OUGMLYAW.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+$/;\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\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 out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(value)) {\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\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  // 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 singleValue = maybe[singleKey];\n      if (Array.isArray(singleValue)) {\n        return singleValue.map((v) => coerceBySchema(v, itemsSchema));\n      }\n      // Also extract when single key's value is an object and wrap in array (single/multiple element consistency)\n      if (singleValue && typeof singleValue === \"object\") {\n        return [coerceBySchema(singleValue, itemsSchema)];\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 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  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  // 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 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-TR2ARLIF.js → chunk-ZDBNJWLY.js}

@@ -2,7 +2,7 @@ import {
   coerceBySchema,
   getSchemaType,
   unwrapJsonSchema
-} from "./chunk-DZB6Y354.js";
+} from "./chunk-OUGMLYAW.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-TR2ARLIF.js.map
+//# sourceMappingURL=chunk-ZDBNJWLY.js.map