@ai-sdk-tool/parser 3.2.1 → 3.3.1

package/dist/rxml.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Core types for the robust-xml parser
+ * Based on TXML structure but enhanced for schema-aware parsing
+ */
+type OnErrorFn = (message: string, metadata?: Record<string, unknown>) => void;
+/**
+ * Represents a parsed XML node in the DOM tree
+ */
+interface RXMLNode {
+    tagName: string;
+    attributes: Record<string, string | null>;
+    children: (RXMLNode | string)[];
+}
+/**
+ * Options for XML parsing
+ */
+interface ParseOptions {
+    /** Position to start parsing from (for streaming) */
+    pos?: number;
+    /** Array of tag names that don't have children and don't need to be closed */
+    noChildNodes?: string[];
+    /** Whether to set position information in result */
+    setPos?: boolean;
+    /** Keep comments in the parsed result */
+    keepComments?: boolean;
+    /** Keep whitespace like spaces, tabs and line breaks as string content */
+    keepWhitespace?: boolean;
+    /** Name of the text node property (default: "#text") */
+    textNodeName?: string;
+    /** Whether to throw on duplicate string tags */
+    throwOnDuplicateStringTags?: boolean;
+    /** Error handling callback */
+    onError?: OnErrorFn;
+    /**
+     * Apply internal repair heuristics for fragment parsing.
+     * When enabled, parsing attempts normalization/repair before throwing.
+     */
+    repair?: boolean;
+    /** Maximum reparses when repair heuristics are enabled */
+    maxReparses?: number;
+    /** Whether to parse a single node instead of children */
+    parseNode?: boolean;
+    /** Filter function for nodes */
+    filter?: (node: RXMLNode, index: number, depth: number, path: string) => boolean;
+    /** Simplify the result structure */
+    simplify?: boolean;
+}
+/**
+ * Options for XML stringification
+ */
+interface StringifyOptions {
+    /** Whether to format the output with indentation */
+    format?: boolean;
+    /** Whether to suppress empty nodes */
+    suppressEmptyNode?: boolean;
+    /**
+     * Whether to use minimal escaping per XML 1.0:
+     * - In character data: escape '&' and '<' (and '>' only in ']]>' sequence)
+     * - In attribute values: escape '&', '<', and only the wrapping quote
+     * Defaults to false (conservative escaping of &, <, >, ", ')
+     */
+    minimalEscaping?: boolean;
+    /** Error handling callback */
+    onError?: OnErrorFn;
+    /**
+     * Whether to serialize boolean-like attributes (value === null)
+     * as name="name" to follow strict XML attribute rules.
+     * When false (default), serialize as a convenience flag without value
+     * (e.g., <item checked>), for compatibility with existing outputs.
+     */
+    strictBooleanAttributes?: boolean;
+    /**
+     * Whether to include the XML declaration
+     */
+    declaration?: boolean;
+}
+
+/**
+ * XML stringification based on TXML's stringify approach
+ * Replaces the fast-xml-parser XMLBuilder with a native implementation
+ */
+
+/**
+ * Stringify an object to XML
+ */
+declare function stringify(rootTag: string, obj: unknown, options?: StringifyOptions): string;
+
+declare function parse(xml: string, schema: unknown, options?: ParseOptions): Record<string, unknown>;
+
+export { type ParseOptions, type StringifyOptions, parse, stringify };

package/dist/rxml.js

@@ -0,0 +1,10 @@
+import {
+  parse,
+  stringify
+} from "./chunk-EW3A6Y7O.js";
+import "./chunk-OUGMLYAW.js";
+export {
+  parse,
+  stringify
+};
+//# sourceMappingURL=rxml.js.map

package/dist/rxml.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/schema-coerce.cjs

@@ -0,0 +1,415 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema-coerce/index.ts
+var schema_coerce_exports = {};
+__export(schema_coerce_exports, {
+  coerceBySchema: () => coerceBySchema,
+  getSchemaType: () => getSchemaType,
+  unwrapJsonSchema: () => unwrapJsonSchema
+});
+module.exports = __toCommonJS(schema_coerce_exports);
+var NUMERIC_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
+var NEWLINE_SPLIT_REGEX = /\n+/;
+var COMMA_SPLIT_REGEX = /,\s*/;
+var DIGIT_KEY_REGEX = /^\d+$/;
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return;
+  }
+  const t = unwrapped.type;
+  if (typeof t === "string") {
+    return t;
+  }
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) {
+      if (t.includes(p)) {
+        return p;
+      }
+    }
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  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();
+  if (lower === "true") {
+    return true;
+  }
+  if (lower === "false") {
+    return false;
+  }
+  if (NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(s);
+      return coerceBySchema(parsed, void 0);
+    } catch (e) {
+    }
+  }
+  return value;
+}
+function coerceStringToObject(s, unwrapped) {
+  try {
+    let normalized = s.replace(/'/g, '"');
+    normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
+    const obj = JSON.parse(normalized);
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      return coerceObjectToObject(obj, unwrapped);
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function coerceStringToArray(s, unwrapped) {
+  const prefixItems = Array.isArray(unwrapped.prefixItems) ? unwrapped.prefixItems : void 0;
+  const itemsSchema = unwrapped.items;
+  try {
+    const normalized = s.replace(/'/g, '"');
+    const arr = JSON.parse(normalized);
+    if (Array.isArray(arr)) {
+      if (prefixItems && arr.length === prefixItems.length) {
+        return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return arr.map((v) => coerceBySchema(v, itemsSchema));
+    }
+  } catch (e) {
+    const csv = s.includes("\n") ? s.split(NEWLINE_SPLIT_REGEX) : s.split(COMMA_SPLIT_REGEX);
+    const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+    if (prefixItems && trimmed.length === prefixItems.length) {
+      return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
+    }
+    return trimmed.map((x) => coerceBySchema(x, itemsSchema));
+  }
+  return null;
+}
+function coerceObjectToObject(value, unwrapped) {
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = coerceValueForKey(v, k, unwrapped);
+  }
+  return out;
+}
+function coerceArrayToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && value.length === prefixItems.length) {
+    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+  }
+  return value.map((v) => coerceBySchema(v, itemsSchema));
+}
+function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (Object.hasOwn(maybe, "item")) {
+    const items = maybe.item;
+    const arr = Array.isArray(items) ? items : [items];
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+  }
+  const keys = Object.keys(maybe);
+  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) {
+  if (prefixItems && prefixItems.length > 0) {
+    return [coerceBySchema(value, prefixItems[0])];
+  }
+  return [coerceBySchema(value, itemsSchema)];
+}
+function coerceStringToPrimitive(s, schemaType) {
+  if (schemaType === "boolean") {
+    const lower = s.toLowerCase();
+    if (lower === "true") {
+      return true;
+    }
+    if (lower === "false") {
+      return false;
+    }
+  }
+  if ((schemaType === "number" || schemaType === "integer") && NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return null;
+}
+function coerceStringValue(value, schemaType, u) {
+  const s = value.trim();
+  if (schemaType === "object") {
+    const result = coerceStringToObject(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  if (schemaType === "array") {
+    const result = coerceStringToArray(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  const primitiveResult = coerceStringToPrimitive(s, schemaType);
+  if (primitiveResult !== null) {
+    return primitiveResult;
+  }
+  return value;
+}
+function coerceArrayValue(value, prefixItems, itemsSchema) {
+  if (Array.isArray(value)) {
+    return coerceArrayToArray(value, prefixItems, itemsSchema);
+  }
+  if (value && typeof value === "object") {
+    const result = coerceObjectToArray(
+      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];
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      return coerceStringWithoutSchema(value);
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  const u = unwrapped;
+  if (typeof value === "string") {
+    return coerceStringValue(value, schemaType, u);
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    return coerceObjectToObject(value, u);
+  }
+  if (schemaType === "array") {
+    const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
+    const itemsSchema = u.items;
+    return coerceArrayValue(value, prefixItems, itemsSchema);
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  coerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+});
+//# sourceMappingURL=schema-coerce.cjs.map

package/dist/schema-coerce.cjs.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/schema-coerce.d.cts

@@ -0,0 +1,5 @@
+declare function unwrapJsonSchema(schema: unknown): unknown;
+declare function getSchemaType(schema: unknown): string | undefined;
+declare function coerceBySchema(value: unknown, schema?: unknown): unknown;
+
+export { coerceBySchema, getSchemaType, unwrapJsonSchema };

package/dist/schema-coerce.d.ts

@@ -0,0 +1,5 @@
+declare function unwrapJsonSchema(schema: unknown): unknown;
+declare function getSchemaType(schema: unknown): string | undefined;
+declare function coerceBySchema(value: unknown, schema?: unknown): unknown;
+
+export { coerceBySchema, getSchemaType, unwrapJsonSchema };

package/dist/schema-coerce.js

@@ -0,0 +1,11 @@
+import {
+  coerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+} from "./chunk-OUGMLYAW.js";
+export {
+  coerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+};
+//# sourceMappingURL=schema-coerce.js.map

package/dist/schema-coerce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}