@ai-sdk-tool/parser 2.1.3 → 2.1.4

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
@@ -1013,11 +1013,6 @@ function extractOnErrorOption(providerOptions) {
   return void 0;
 }
 
-// src/utils/protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
 // src/utils/tools.ts
 function isToolChoiceActive(params) {
   var _a, _b, _c;
@@ -1114,7 +1109,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 +1232,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,8 +1294,14 @@ 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;
+import {
+  findFirstTopLevelRange,
+  parse as parseXml,
+  RXMLCoercionError,
+  RXMLDuplicateStringTagError,
+  RXMLParseError,
+  stringify as stringify2
+} from "@ai-sdk-tool/rxml";
 function getToolSchema(tools, originalSchemas, toolName) {
   var _a;
   const original = originalSchemas[toolName];
@@ -1308,598 +1309,42 @@ function getToolSchema(tools, originalSchemas, toolName) {
   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;
-            }
-          }
+function findToolCalls(text, toolNames) {
+  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 = 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;
         }
-      }
-      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;
+        const toolContent = text.substring(contentStart, contentEnd);
+        const fullSegment = text.substring(tagStart, fullTagEnd);
+        toolCalls.push({
+          toolName,
+          startIndex: tagStart,
+          endIndex: fullTagEnd,
+          content: toolContent,
+          segment: fullSegment
         });
-      }
-    } 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;
-          }
-        }
+        searchIndex = fullTagEnd;
       } 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;
-        }
+        searchIndex = tagStart + startTag.length;
       }
     }
-    args[k] = typeof val === "string" ? val.trim() : val;
   }
-  return { args, cancelToolCall };
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
@@ -1911,7 +1356,6 @@ var morphXmlProtocol = () => ({
     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 +1367,63 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    const xmlContent = builder.build({
-      [toolCall.toolName]: args
+    return stringify2(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 stringify2("tool_response", {
+      tool_name: toolResult.toolName,
+      result: toolResult.output
     });
-    return xmlContent;
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a, _b, _c;
+    var _a;
     const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     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 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
+        const toolSchema = getToolSchema(
+          tools,
+          originalSchemas,
+          toolCall.toolName
         );
-        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)
-          });
-        }
+        const parsed = parseXml(toolCall.content, toolSchema, {
+          onError: options == null ? void 0 : options.onError
+        });
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: generateId3(),
+          toolName: toolCall.toolName,
+          input: JSON.stringify(parsed)
+        });
       } 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);
@@ -2055,61 +1477,36 @@ 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 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) {
+                const parsed = parseXml(toolContent, toolSchema, {
+                  onError: options == null ? void 0 : options.onError
+                });
+                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 RXMLDuplicateStringTagError) {
+                  message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof RXMLCoercionError) {
+                  message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof 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;
@@ -2159,18 +1556,15 @@ 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);
   }
 });
 
+// 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";
 async function wrapGenerate({
@@ -2785,11 +2179,30 @@ San Fransisco
   }
 });
 export {
+  robust_json_exports as RJSON,
+  coerceBySchema,
+  coerceToolCallInput,
+  createDynamicIfThenElseSchema,
   createToolMiddleware,
+  escapeRegExp,
+  extractOnErrorOption,
+  fixToolCallWithSchema,
   gemmaToolMiddleware,
+  getDebugLevel,
+  getFunctionTools,
+  getPotentialStartIndex,
+  getSchemaType,
+  hasInputProperty,
   hermesToolMiddleware,
+  isToolCallContent,
+  isToolChoiceActive,
+  isToolResultPart,
   jsonMixProtocol,
+  logParsedChunk,
+  logParsedSummary,
+  logRawChunk,
   morphXmlProtocol,
+  unwrapJsonSchema,
   xmlToolMiddleware
 };
 //# sourceMappingURL=index.js.map