@ai-sdk-tool/parser 2.1.3 → 2.1.5

package/dist/index.js

@@ -89,9 +89,9 @@ function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/utils/relaxed-json.ts
-var relaxed_json_exports = {};
-__export(relaxed_json_exports, {
+// src/utils/robust-json.ts
+var robust_json_exports = {};
+__export(robust_json_exports, {
   parse: () => parse,
   stringify: () => stringify,
   transform: () => transform
@@ -722,210 +722,6 @@ function stringify(obj) {
   return "null";
 }
 
-// src/utils/coercion.ts
-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 void 0;
-  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 void 0;
-}
-function coerceBySchema(value, schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    if (typeof value === "string") {
-      const s = value.trim();
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.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;
-  }
-  const schemaType = getSchemaType(unwrapped);
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "object") {
-      try {
-        let normalized = s.replace(/'/g, '"');
-        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
-        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;
-        }
-      } catch (e) {
-      }
-    }
-    if (schemaType === "array") {
-      try {
-        const normalized = s.replace(/'/g, '"');
-        const arr = JSON.parse(normalized);
-        if (Array.isArray(arr)) {
-          const u = unwrapped;
-          const prefixItems = Array.isArray(
-            u.prefixItems
-          ) ? u.prefixItems : void 0;
-          const itemsSchema = u.items;
-          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(/\n+/) : s.split(/,\s*/);
-        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
-        const u = unwrapped;
-        const prefixItems = Array.isArray(
-          u.prefixItems
-        ) ? u.prefixItems : void 0;
-        const itemsSchema = u.items;
-        if (prefixItems && trimmed.length === prefixItems.length) {
-          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
-        }
-        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
-      }
-    }
-  }
-  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
-    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);
-    }
-    return out;
-  }
-  if (schemaType === "array") {
-    const u = unwrapped;
-    const itemsSchema = u.items;
-    const prefixItems = Array.isArray(
-      u.prefixItems
-    ) ? u.prefixItems : void 0;
-    if (Array.isArray(value)) {
-      if (prefixItems && value.length === prefixItems.length) {
-        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
-      }
-      return value.map((v) => coerceBySchema(v, itemsSchema));
-    }
-    if (value && typeof value === "object") {
-      const maybe = value;
-      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
-        const items = maybe.item;
-        const arr = Array.isArray(items) ? items : [items];
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      const keys = Object.keys(maybe);
-      if (keys.length === 1) {
-        const singleKey = keys[0];
-        const singleValue = maybe[singleKey];
-        if (Array.isArray(singleValue)) {
-          const coercedArray = singleValue.map(
-            (v) => coerceBySchema(v, itemsSchema)
-          );
-          return coercedArray;
-        }
-      }
-      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
-        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-    }
-    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      if (prefixItems && prefixItems.length > 0) {
-        return [coerceBySchema(value, prefixItems[0])];
-      }
-      return [coerceBySchema(value, itemsSchema)];
-    }
-  }
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "boolean") {
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-    }
-    if (schemaType === "number" || schemaType === "integer") {
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-        const num = Number(s);
-        if (Number.isFinite(num)) return num;
-      }
-    }
-  }
-  return value;
-}
-function fixToolCallWithSchema(part, tools) {
-  var _a;
-  if (part.type !== "tool-call") return part;
-  const tc = part;
-  let args = {};
-  if (typeof tc.input === "string") {
-    try {
-      args = JSON.parse(tc.input);
-    } catch (e) {
-      return part;
-    }
-  } else if (tc.input && typeof tc.input === "object") {
-    args = tc.input;
-  }
-  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
-  return {
-    ...part,
-    input: JSON.stringify(coerced != null ? coerced : {})
-  };
-}
-function coerceToolCallInput(part, tools) {
-  return fixToolCallWithSchema(part, tools);
-}
-
 // src/utils/debug.ts
 function normalizeBooleanString(value) {
   const normalized = value.trim().toLowerCase();
@@ -1013,38 +809,34 @@ function extractOnErrorOption(providerOptions) {
   return void 0;
 }
 
-// src/utils/protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/utils/provider-options.ts
+var originalToolsSchema = {
+  encode: encodeOriginalTools,
+  decode: decodeOriginalTools
+};
+function encodeOriginalTools(tools) {
+  return (tools == null ? void 0 : tools.map((t) => ({
+    name: t.name,
+    inputSchema: JSON.stringify(t.inputSchema)
+  }))) || [];
+}
+function decodeOriginalTools(originalTools) {
+  const tools = (originalTools == null ? void 0 : originalTools.map(
+    (t) => ({
+      name: t.name,
+      inputSchema: JSON.parse(t.inputSchema)
+    })
+  )) || [];
+  return tools;
+}
+function extractToolNamesFromOriginalTools(originalTools) {
+  return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
 }
-
-// src/utils/tools.ts
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
   return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
 }
-function getFunctionTools(params) {
-  var _a, _b;
-  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
-    (t) => t.type === "function"
-  );
-  if (functionTools.length > 0) return functionTools;
-  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_b = params.providerOptions.toolCallMiddleware) == null ? void 0 : _b.toolNames) || [];
-  const toStringArray = (val) => Array.isArray(val) ? val.filter(
-    (item) => typeof item === "string"
-  ) : [];
-  const toolNames = toStringArray(rawToolNames);
-  if (toolNames.length > 0) {
-    return toolNames.map((name) => ({
-      type: "function",
-      name,
-      description: "",
-      inputSchema: { type: "object" }
-    }));
-  }
-  return [];
-}
 
 // src/utils/type-guards.ts
 function isToolCallContent(content) {
@@ -1114,7 +906,7 @@ var jsonMixProtocol = ({
       }
       if (toolCallJson) {
         try {
-          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          const parsedToolCall = robust_json_exports.parse(toolCallJson);
           processedElements.push({
             type: "tool-call",
             toolCallId: generateId2(),
@@ -1237,7 +1029,7 @@ var jsonMixProtocol = ({
             isInsideToolCall = true;
           } else {
             try {
-              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
+              const parsedToolCall = robust_json_exports.parse(currentToolCallJson);
               if (currentTextId && hasEmittedTextStart) {
                 controller.enqueue({ type: "text-end", id: currentTextId });
                 currentTextId = null;
@@ -1299,619 +1091,17 @@ var jsonMixProtocol = ({
 
 // src/protocols/morph-xml-protocol.ts
 import { generateId as generateId3 } from "@ai-sdk/provider-utils";
-import { XMLBuilder, XMLParser } from "fast-xml-parser";
-var WARN_ON_DUPLICATE_STRING_TAGS = true;
-function getToolSchema(tools, originalSchemas, toolName) {
-  var _a;
-  const original = originalSchemas[toolName];
-  if (original) return original;
-  const fallback = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-  return fallback;
-}
-function getPropertySchema(toolSchema, key) {
-  const unwrapped = unwrapJsonSchema(toolSchema);
-  if (!unwrapped || typeof unwrapped !== "object") return void 0;
-  const u = unwrapped;
-  const props = u.properties;
-  if (props && Object.prototype.hasOwnProperty.call(props, key)) {
-    return props[key];
-  }
-  return void 0;
-}
-function extractRawInner(xmlContent, tagName) {
-  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
-  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
-  const len = xmlContent.length;
-  const target = tagName;
-  let bestStart = -1;
-  let bestEnd = -1;
-  let bestDepth = Number.POSITIVE_INFINITY;
-  const skipQuoted = (s, i2) => {
-    const quote = s[i2];
-    i2++;
-    while (i2 < s.length) {
-      const ch = s[i2];
-      if (ch === "\\") {
-        i2 += 2;
-        continue;
-      }
-      if (ch === quote) {
-        return i2 + 1;
-      }
-      i2++;
-    }
-    return i2;
-  };
-  let i = 0;
-  let depth = 0;
-  while (i < len) {
-    const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) return void 0;
-    i = lt + 1;
-    if (i >= len) return void 0;
-    const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
-      continue;
-    } else if (ch === "/") {
-      let j = i + 1;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const gt = xmlContent.indexOf(">", j);
-      i = gt === -1 ? len : gt + 1;
-      depth = Math.max(0, depth - 1);
-      continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      let isSelfClosing = false;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") {
-          break;
-        }
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          isSelfClosing = true;
-          k++;
-          break;
-        }
-        k++;
-      }
-      const tagEnd = k;
-      if (name === target) {
-        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-        if (isSelfClosing) {
-          if (depth < bestDepth) {
-            bestStart = contentStart;
-            bestEnd = contentStart;
-            bestDepth = depth;
-            if (bestDepth === 0) {
-            }
-          }
-        } else {
-          let pos = contentStart;
-          let sameDepth = 1;
-          while (pos < len) {
-            const nextLt = xmlContent.indexOf("<", pos);
-            if (nextLt === -1) break;
-            const nx = nextLt + 1;
-            if (nx >= len) break;
-            const h = xmlContent[nx];
-            if (h === "!") {
-              if (xmlContent.startsWith("!--", nx + 1)) {
-                const close = xmlContent.indexOf("-->", nx + 4);
-                pos = close === -1 ? len : close + 3;
-                continue;
-              }
-              if (xmlContent.startsWith("![CDATA[", nx + 1)) {
-                const close = xmlContent.indexOf("]]>", nx + 9);
-                pos = close === -1 ? len : close + 3;
-                continue;
-              }
-              const gt2 = xmlContent.indexOf(">", nx + 1);
-              pos = gt2 === -1 ? len : gt2 + 1;
-              continue;
-            } else if (h === "?") {
-              const close = xmlContent.indexOf("?>", nx + 1);
-              pos = close === -1 ? len : close + 2;
-              continue;
-            } else if (h === "/") {
-              let t = nx + 1;
-              if (t < len && isNameStartChar(xmlContent[t])) {
-                t++;
-                while (t < len && isNameChar(xmlContent[t])) t++;
-              }
-              const endName = xmlContent.slice(nx + 1, t);
-              const gt2 = xmlContent.indexOf(">", t);
-              if (endName === target) {
-                sameDepth--;
-                if (sameDepth === 0) {
-                  if (depth < bestDepth) {
-                    bestStart = contentStart;
-                    bestEnd = nextLt;
-                    bestDepth = depth;
-                    if (bestDepth === 0) {
-                    }
-                  }
-                  break;
-                }
-              }
-              pos = gt2 === -1 ? len : gt2 + 1;
-              continue;
-            } else {
-              let t = nx;
-              if (t < len && isNameStartChar(xmlContent[t])) {
-                t++;
-                while (t < len && isNameChar(xmlContent[t])) t++;
-              }
-              const startName = xmlContent.slice(nx, t);
-              let u = t;
-              let selfClose = false;
-              while (u < len) {
-                const cu = xmlContent[u];
-                if (cu === '"' || cu === "'") {
-                  u = skipQuoted(xmlContent, u);
-                  continue;
-                }
-                if (cu === ">") break;
-                if (cu === "/" && xmlContent[u + 1] === ">") {
-                  selfClose = true;
-                  u++;
-                  break;
-                }
-                u++;
-              }
-              if (startName === target && !selfClose) {
-                sameDepth++;
-              }
-              pos = xmlContent[u] === ">" ? u + 1 : u + 1;
-              continue;
-            }
-          }
-        }
-      }
-      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-      depth += isSelfClosing ? 0 : 1;
-      continue;
-    }
-  }
-  if (bestStart !== -1) {
-    return xmlContent.slice(bestStart, bestEnd);
-  }
-  return void 0;
-}
-function findFirstTopLevelRange(xmlContent, tagName) {
-  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
-  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
-  const len = xmlContent.length;
-  const target = tagName;
-  const skipQuoted = (s, i2) => {
-    const quote = s[i2];
-    i2++;
-    while (i2 < s.length) {
-      const ch = s[i2];
-      if (ch === "\\") {
-        i2 += 2;
-        continue;
-      }
-      if (ch === quote) return i2 + 1;
-      i2++;
-    }
-    return i2;
-  };
-  let i = 0;
-  let depth = 0;
-  while (i < len) {
-    const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) return void 0;
-    i = lt + 1;
-    if (i >= len) return void 0;
-    const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
-      continue;
-    } else if (ch === "/") {
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      depth = Math.max(0, depth - 1);
-      continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      let isSelfClosing = false;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") break;
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          isSelfClosing = true;
-          k++;
-          break;
-        }
-        k++;
-      }
-      const tagEnd = k;
-      if (depth === 0 && name === target) {
-        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-        if (isSelfClosing) return { start: contentStart, end: contentStart };
-        let pos = contentStart;
-        let sameDepth = 1;
-        while (pos < len) {
-          const nextLt = xmlContent.indexOf("<", pos);
-          if (nextLt === -1) break;
-          const nx = nextLt + 1;
-          if (nx >= len) break;
-          const h = xmlContent[nx];
-          if (h === "!") {
-            if (xmlContent.startsWith("!--", nx + 1)) {
-              const close = xmlContent.indexOf("-->", nx + 4);
-              pos = close === -1 ? len : close + 3;
-              continue;
-            }
-            if (xmlContent.startsWith("![CDATA[", nx + 1)) {
-              const close = xmlContent.indexOf("]]>", nx + 9);
-              pos = close === -1 ? len : close + 3;
-              continue;
-            }
-            const gt2 = xmlContent.indexOf(">", nx + 1);
-            pos = gt2 === -1 ? len : gt2 + 1;
-            continue;
-          } else if (h === "?") {
-            const close = xmlContent.indexOf("?>", nx + 1);
-            pos = close === -1 ? len : close + 2;
-            continue;
-          } else if (h === "/") {
-            let t = nx + 1;
-            if (t < len && isNameStartChar(xmlContent[t])) {
-              t++;
-              while (t < len && isNameChar(xmlContent[t])) t++;
-            }
-            const endName = xmlContent.slice(nx + 1, t);
-            const gt2 = xmlContent.indexOf(">", t);
-            if (endName === target) {
-              sameDepth--;
-              if (sameDepth === 0) {
-                return { start: contentStart, end: nextLt };
-              }
-            }
-            pos = gt2 === -1 ? len : gt2 + 1;
-            continue;
-          } else {
-            let t = nx;
-            if (t < len && isNameStartChar(xmlContent[t])) {
-              t++;
-              while (t < len && isNameChar(xmlContent[t])) t++;
-            }
-            let u = t;
-            let selfClose = false;
-            while (u < len) {
-              const cu = xmlContent[u];
-              if (cu === '"' || cu === "'") {
-                u = skipQuoted(xmlContent, u);
-                continue;
-              }
-              if (cu === ">") break;
-              if (cu === "/" && xmlContent[u + 1] === ">") {
-                selfClose = true;
-                u++;
-                break;
-              }
-              u++;
-            }
-            if (!selfClose) {
-            }
-            pos = xmlContent[u] === ">" ? u + 1 : u + 1;
-            continue;
-          }
-        }
-        return void 0;
-      }
-      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-      depth += isSelfClosing ? 0 : 1;
-      continue;
-    }
-  }
-  return void 0;
-}
-function countTagOccurrences(xmlContent, tagName, excludeRanges, skipFirst = true) {
-  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
-  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
-  const len = xmlContent.length;
-  const target = tagName;
-  const skipQuoted = (s, i2) => {
-    const quote = s[i2];
-    i2++;
-    while (i2 < s.length) {
-      const ch = s[i2];
-      if (ch === "\\") {
-        i2 += 2;
-        continue;
-      }
-      if (ch === quote) return i2 + 1;
-      i2++;
-    }
-    return i2;
-  };
-  let i = 0;
-  let count = 0;
-  const isExcluded = (pos) => {
-    if (!excludeRanges || excludeRanges.length === 0) return false;
-    for (const r of excludeRanges) {
-      if (pos >= r.start && pos < r.end) return true;
-    }
-    return false;
-  };
-  while (i < len) {
-    const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) break;
-    i = lt + 1;
-    if (i >= len) break;
-    const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
-      continue;
-    } else if (ch === "/") {
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") break;
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          k++;
-          break;
-        }
-        k++;
-      }
-      if (name === target && !isExcluded(lt)) {
-        if (skipFirst) {
-          skipFirst = false;
-        } else {
-          count++;
-        }
-      }
-      i = k + 1;
-      continue;
-    }
-  }
-  return count;
-}
-function processParsedArgs(parsedArgs, toolSchema, toolContent, toolName, options) {
-  var _a, _b, _c;
-  const args = {};
-  let cancelToolCall = false;
-  const stringTypedProps = (() => {
-    const set = /* @__PURE__ */ new Set();
-    const unwrapped = unwrapJsonSchema(toolSchema);
-    if (unwrapped && typeof unwrapped === "object") {
-      const u = unwrapped;
-      const props = u.properties;
-      if (props && typeof props === "object") {
-        for (const key of Object.keys(props)) {
-          const t = getSchemaType(props[key]);
-          if (t === "string") set.add(key);
-        }
-      }
-    }
-    return set;
-  })();
-  for (const k of Object.keys(parsedArgs || {})) {
-    const v = parsedArgs[k];
-    let val = v;
-    const propSchema = getPropertySchema(toolSchema, k);
-    const propType = getSchemaType(propSchema);
-    if (propType === "string" && !Array.isArray(v)) {
-      const excludeRanges = [];
-      for (const other of stringTypedProps) {
-        if (other === k) continue;
-        const range = findFirstTopLevelRange(toolContent, other);
-        if (range) excludeRanges.push(range);
-      }
-      const occurrences = countTagOccurrences(
-        toolContent,
-        k,
-        excludeRanges,
-        true
-      );
-      if (occurrences > 0) {
-        if (WARN_ON_DUPLICATE_STRING_TAGS) {
-          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-            options,
-            `Duplicate string tags for <${k}> detected; cancelling tool call`,
-            {
-              toolName,
-              toolCall: `<${toolName}>${toolContent}</${toolName}>`
-            }
-          );
-        }
-        cancelToolCall = true;
-        break;
-      }
-      const raw = extractRawInner(toolContent, k);
-      if (typeof raw === "string") {
-        args[k] = raw;
-        continue;
-      }
-    }
-    if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
-      val = v == null ? void 0 : v["#text"];
-    }
-    if (Array.isArray(v)) {
-      if (propType === "string") {
-        const mapped = v.map((item) => {
-          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-            const textVal = item == null ? void 0 : item["#text"];
-            return typeof textVal === "string" ? textVal : String(textVal);
-          }
-          return typeof item === "string" ? item : String(item);
-        });
-        if (mapped.length > 1 && WARN_ON_DUPLICATE_STRING_TAGS) {
-          (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-            options,
-            `Duplicate string tags for <${k}> detected; cancelling tool call`,
-            {
-              toolName,
-              toolCall: `<${toolName}>${toolContent}</${toolName}>`
-            }
-          );
-        }
-        if (mapped.length > 1) {
-          cancelToolCall = true;
-          break;
-        } else {
-          args[k] = (_c = mapped[0]) != null ? _c : "";
-          continue;
-        }
-      } else {
-        val = v.map((item) => {
-          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-            const textVal = item == null ? void 0 : item["#text"];
-            return typeof textVal === "string" ? textVal.trim() : textVal;
-          }
-          return typeof item === "string" ? item.trim() : item;
-        });
-      }
-    } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
-      const obj = v;
-      const keys = Object.keys(obj);
-      if (keys.length === 1 && keys[0] === "item") {
-        const itemValue = obj.item;
-        if (Array.isArray(itemValue)) {
-          val = itemValue.map((item) => {
-            let currentVal = item;
-            if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-              currentVal = item == null ? void 0 : item["#text"];
-            }
-            const trimmed = typeof currentVal === "string" ? currentVal.trim() : currentVal;
-            if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-              const num = Number(trimmed);
-              if (Number.isFinite(num)) return num;
-            }
-            return trimmed;
-          });
-        } else {
-          const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
-          if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-            const num = Number(trimmed);
-            val = Number.isFinite(num) ? num : trimmed;
-          } else {
-            val = trimmed;
-          }
-        }
-      } else {
-        let isIndexedTuple = false;
-        if (keys.length > 0 && keys.every((key) => /^\d+$/.test(key))) {
-          const indices = keys.map((k2) => parseInt(k2, 10)).sort((a, b) => a - b);
-          isIndexedTuple = indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
-        }
-        if (isIndexedTuple) {
-          const sortedKeys = keys.sort(
-            (a, b) => parseInt(a, 10) - parseInt(b, 10)
-          );
-          val = sortedKeys.map((key) => {
-            const item = obj[key];
-            if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-              const textVal = item == null ? void 0 : item["#text"];
-              return typeof textVal === "string" ? textVal.trim() : textVal;
-            }
-            return typeof item === "string" ? item.trim() : item;
-          });
-        } else {
-          val = v;
-        }
-      }
-    }
-    args[k] = typeof val === "string" ? val.trim() : val;
-  }
-  return { args, cancelToolCall };
-}
+import * as RXML from "@ai-sdk-tool/rxml";
 var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: unwrapJsonSchema(tool.inputSchema)
+      parameters: RXML.unwrapJsonSchema(tool.inputSchema)
     }));
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
   formatToolCall(toolCall) {
-    const builder = new XMLBuilder({ format: true, suppressEmptyNode: true });
     let args = {};
     const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
     if (typeof inputValue === "string") {
@@ -1923,85 +1113,60 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    const xmlContent = builder.build({
-      [toolCall.toolName]: args
+    return RXML.stringify(toolCall.toolName, args, {
+      suppressEmptyNode: false,
+      format: false
     });
-    return xmlContent;
   },
   formatToolResponse(toolResult) {
-    const builder = new XMLBuilder({ format: true });
-    const xmlContent = builder.build({
-      tool_response: {
-        tool_name: toolResult.toolName,
-        result: toolResult.output
-      }
+    return RXML.stringify("tool_response", {
+      tool_name: toolResult.toolName,
+      result: toolResult.output
     });
-    return xmlContent;
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a, _b, _c;
-    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
+    var _a;
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
     if (toolNames.length === 0) {
       return [{ type: "text", text }];
     }
-    const toolNamesPattern = toolNames.map((n) => escapeRegExp(n)).join("|");
-    const toolCallRegex = new RegExp(
-      String.raw`<(${toolNamesPattern})>([\s\S]*?)<\/\1>`,
-      "g"
-    );
     const processedElements = [];
     let currentIndex = 0;
-    let match;
-    while ((match = toolCallRegex.exec(text)) !== null) {
-      const startIndex = match.index;
-      const toolName = match[1];
-      const toolContent = match[2].trim();
-      if (startIndex > currentIndex) {
-        const textSegment = text.substring(currentIndex, startIndex);
+    const toolCalls = findToolCalls(text, toolNames);
+    for (const toolCall of toolCalls) {
+      if (toolCall.startIndex > currentIndex) {
+        const textSegment = text.substring(currentIndex, toolCall.startIndex);
         if (textSegment.trim()) {
           processedElements.push({ type: "text", text: textSegment });
         }
       }
       try {
-        const parser = new XMLParser({
-          ignoreAttributes: false,
-          parseTagValue: false,
-          ignoreDeclaration: true,
-          textNodeName: "#text"
+        const toolSchema = getToolSchema(tools, toolCall.toolName);
+        const parsed = RXML.parse(toolCall.content, toolSchema, {
+          onError: options == null ? void 0 : options.onError,
+          // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
+          noChildNodes: []
+        });
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: generateId3(),
+          toolName: toolCall.toolName,
+          input: JSON.stringify(parsed)
         });
-        const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-        const toolSchema = getToolSchema(tools, originalSchemas, toolName);
-        const { args, cancelToolCall } = processParsedArgs(
-          parsedArgs,
-          toolSchema,
-          toolContent,
-          toolName,
-          options
-        );
-        if (cancelToolCall) {
-          const originalCallText = match[0];
-          (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-            options,
-            `Duplicate string tags detected; cancelling tool call`,
-            { toolCall: originalCallText, toolName }
-          );
-          processedElements.push({ type: "text", text: originalCallText });
-        } else {
-          const coercedArgs = coerceBySchema(args, toolSchema);
-          processedElements.push({
-            type: "tool-call",
-            toolCallId: generateId3(),
-            toolName,
-            input: JSON.stringify(coercedArgs)
-          });
-        }
       } catch (error) {
-        const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
-        (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, message, { toolCall: match[0], toolName, error });
-        processedElements.push({ type: "text", text: match[0] });
+        const originalCallText = text.substring(
+          toolCall.startIndex,
+          toolCall.endIndex
+        );
+        const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
+          toolCall: originalCallText,
+          toolName: toolCall.toolName,
+          error
+        });
+        processedElements.push({ type: "text", text: originalCallText });
       }
-      currentIndex = startIndex + match[0].length;
+      currentIndex = toolCall.endIndex;
     }
     if (currentIndex < text.length) {
       const remainingText = text.substring(currentIndex);
@@ -2012,8 +1177,8 @@ var morphXmlProtocol = () => ({
     return processedElements;
   },
   createStreamParser({ tools, options }) {
-    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+    const maxStartTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
     let buffer = "";
     let currentToolCall = null;
     let currentTextId = null;
@@ -2055,61 +1220,34 @@ var morphXmlProtocol = () => ({
               const toolContent = buffer.substring(0, endTagIndex);
               buffer = buffer.substring(endTagIndex + endTag.length);
               try {
-                const parser = new XMLParser({
-                  ignoreAttributes: false,
-                  parseTagValue: false,
-                  ignoreDeclaration: true,
-                  textNodeName: "#text"
+                const toolSchema = getToolSchema(tools, currentToolCall.name);
+                const parsed = RXML.parse(toolContent, toolSchema, {
+                  onError: options == null ? void 0 : options.onError,
+                  // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
+                  noChildNodes: []
                 });
-                const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-                const toolSchema = getToolSchema(
-                  tools,
-                  originalSchemas,
-                  currentToolCall.name
-                );
-                const { args, cancelToolCall } = processParsedArgs(
-                  parsedArgs,
-                  toolSchema,
-                  toolContent,
-                  currentToolCall.name,
-                  options
-                );
-                if (cancelToolCall) {
-                  const originalCallText = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
-                  if (options == null ? void 0 : options.onError) {
-                    options.onError(
-                      "Duplicate string tags detected; cancelling tool call",
-                      {
-                        toolCall: originalCallText,
-                        toolName: currentToolCall.name
-                      }
-                    );
-                  }
-                  flushText(controller, originalCallText);
-                } else {
-                  const coercedArgs = coerceBySchema(
-                    args,
-                    toolSchema
-                  );
-                  flushText(controller);
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: generateId3(),
-                    toolName: currentToolCall.name,
-                    input: JSON.stringify(coercedArgs)
-                  });
-                }
-              } catch (e) {
+                flushText(controller);
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: generateId3(),
+                  toolName: currentToolCall.name,
+                  input: JSON.stringify(parsed)
+                });
+              } catch (error) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
-                if (options == null ? void 0 : options.onError) {
-                  options.onError(
-                    "Could not process streaming XML tool call; emitting original text.",
-                    {
-                      toolCall: originalCallText,
-                      toolName: currentToolCall.name
-                    }
-                  );
+                let message = "Could not process streaming XML tool call; emitting original text.";
+                if (error instanceof RXML.RXMLDuplicateStringTagError) {
+                  message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof RXML.RXMLCoercionError) {
+                  message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof RXML.RXMLParseError) {
+                  message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
                 }
+                (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
+                  toolCall: originalCallText,
+                  toolName: currentToolCall.name,
+                  error
+                });
                 flushText(controller, originalCallText);
               }
               currentToolCall = null;
@@ -2138,6 +1276,14 @@ var morphXmlProtocol = () => ({
               );
               currentToolCall = { name: earliestToolName, content: "" };
             } else {
+              const tail = Math.max(0, maxStartTagLen - 1);
+              const safeLen = Math.max(0, buffer.length - tail);
+              if (safeLen > 0) {
+                const textToFlush = buffer.slice(0, safeLen);
+                flushText(controller, textToFlush);
+                buffer = buffer.slice(safeLen);
+                continue;
+              }
               break;
             }
           }
@@ -2159,26 +1305,66 @@ var morphXmlProtocol = () => ({
   extractToolCallSegments({ text, tools }) {
     const toolNames = tools.map((t) => t.name).filter(Boolean);
     if (toolNames.length === 0) return [];
-    const names = toolNames.map((n) => escapeRegExp(String(n))).join("|");
-    if (!names) return [];
-    const regex = new RegExp(`<(${names})>[\\s\\S]*?<\\/\\1>`, "g");
-    const segments = [];
-    let m;
-    while ((m = regex.exec(text)) != null) {
-      segments.push(m[0]);
-    }
-    return segments;
+    return findToolCalls(text, toolNames).map((tc) => tc.segment);
   }
 });
+function getToolSchema(tools, toolName) {
+  var _a;
+  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+}
+function findToolCalls(text, toolNames) {
+  var _a;
+  const toolCalls = [];
+  for (const toolName of toolNames) {
+    let searchIndex = 0;
+    while (searchIndex < text.length) {
+      const startTag = `<${toolName}>`;
+      const tagStart = text.indexOf(startTag, searchIndex);
+      if (tagStart === -1) break;
+      const remainingText = text.substring(tagStart);
+      const range = RXML.findFirstTopLevelRange(remainingText, toolName);
+      if (range) {
+        const contentStart = tagStart + startTag.length;
+        const contentEnd = contentStart + (range.end - range.start);
+        let fullTagEnd = contentEnd + `</${toolName}>`.length;
+        const closeHead = text.indexOf(`</${toolName}`, contentEnd);
+        if (closeHead === contentEnd) {
+          let p = closeHead + 2 + toolName.length;
+          while (p < text.length && /\s/.test(text[p])) p++;
+          if (text[p] === ">") fullTagEnd = p + 1;
+        }
+        const segment = text.substring(tagStart, fullTagEnd);
+        const content = (_a = RXML.extractRawInner(segment, toolName)) != null ? _a : text.substring(contentStart, contentEnd);
+        toolCalls.push({
+          toolName,
+          startIndex: tagStart,
+          endIndex: fullTagEnd,
+          content,
+          segment
+        });
+        searchIndex = fullTagEnd;
+      } else {
+        searchIndex = tagStart + startTag.length;
+      }
+    }
+  }
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+}
+
+// src/protocols/tool-call-protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
 
 // src/generate-handler.ts
 import { generateId as generateId4 } from "@ai-sdk/provider-utils";
+import * as RXML2 from "@ai-sdk-tool/rxml";
 async function wrapGenerate({
   protocol,
   doGenerate,
   params
 }) {
-  var _a, _b;
+  var _a, _b, _c, _d;
   if (isToolChoiceActive(params)) {
     const result2 = await doGenerate();
     let parsed2 = {};
@@ -2219,6 +1405,9 @@ async function wrapGenerate({
       content: [toolCall]
     };
   }
+  const tools = originalToolsSchema.decode(
+    (_d = (_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) == null ? void 0 : _d.originalTools
+  );
   const result = await doGenerate();
   if (result.content.length === 0) {
     return result;
@@ -2234,16 +1423,15 @@ async function wrapGenerate({
     }
     return protocol.parseGeneratedText({
       text: contentItem.text,
-      tools: getFunctionTools(params),
+      tools,
       options: {
         ...extractOnErrorOption(params.providerOptions),
         ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
       }
     });
   });
-  const tools = getFunctionTools(params);
   const newContent = parsed.map(
-    (part) => coerceToolCallInput(part, tools)
+    (part) => fixToolCallWithSchema(part, tools)
   );
   const debugLevel = getDebugLevel();
   if (debugLevel === "stream") {
@@ -2265,6 +1453,27 @@ async function wrapGenerate({
     content: newContent
   };
 }
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") return part;
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = RXML2.coerceBySchema(args, schema);
+  return {
+    ...part,
+    input: JSON.stringify(coerced != null ? coerced : {})
+  };
+}
 
 // src/stream-handler.ts
 import { generateId as generateId5 } from "@ai-sdk/provider-utils";
@@ -2274,7 +1483,7 @@ async function wrapStream({
   doGenerate,
   params
 }) {
-  var _a;
+  var _a, _b, _c;
   if (isToolChoiceActive(params)) {
     return toolChoiceStream({
       doGenerate,
@@ -2283,10 +1492,12 @@ async function wrapStream({
   }
   const { stream, ...rest } = await doStream();
   const debugLevel = getDebugLevel();
-  const tools = getFunctionTools(params);
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
   const options = {
     ...extractOnErrorOption(params.providerOptions),
-    ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+    ...(_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware
   };
   if (debugLevel === "off") {
     return {
@@ -2495,10 +1706,10 @@ async function transformParams({
       ...params.providerOptions || {},
       toolCallMiddleware: {
         ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
-        // INTERNAL: used by the middleware to propagate the names of custom
-        // function tools into downstream handlers (stream/generate) when
-        // providers strip or ignore `params.tools`. Not a stable public API.
-        toolNames: functionTools.map((t) => t.name)
+        // INTERNAL: used by the middleware so downstream parsers can access
+        // the original tool schemas even if providers strip `params.tools`.
+        // Not a stable public API.
+        originalTools: originalToolsSchema.encode(functionTools)
       }
     }
   };
@@ -2779,17 +1990,34 @@ When an argument is an array, write each item inside a single element on one lin
 Examples:
 <get_weather>
 <location>
-San Fransisco
+San Francisco
 </location>
 </get_weather>`;
   }
 });
 export {
+  robust_json_exports as RJSON,
+  createDynamicIfThenElseSchema,
   createToolMiddleware,
+  decodeOriginalTools,
+  encodeOriginalTools,
+  escapeRegExp,
+  extractOnErrorOption,
+  extractToolNamesFromOriginalTools,
   gemmaToolMiddleware,
+  getDebugLevel,
+  getPotentialStartIndex,
+  hasInputProperty,
   hermesToolMiddleware,
+  isToolCallContent,
+  isToolChoiceActive,
+  isToolResultPart,
   jsonMixProtocol,
+  logParsedChunk,
+  logParsedSummary,
+  logRawChunk,
   morphXmlProtocol,
+  originalToolsSchema,
   xmlToolMiddleware
 };
 //# sourceMappingURL=index.js.map