@ai-sdk-tool/parser 2.1.2 → 2.1.3

package/dist/index.js

@@ -1300,6 +1300,607 @@ 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 };
+}
 var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
@@ -1370,91 +1971,31 @@ var morphXmlProtocol = () => ({
           textNodeName: "#text"
         });
         const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-        const args = {};
-        for (const k of Object.keys(parsedArgs || {})) {
-          const v = parsedArgs[k];
-          let val = v;
-          if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
-            val = v == null ? void 0 : v["#text"];
-          }
-          if (Array.isArray(v)) {
-            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) => {
-                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                    const textVal = item == null ? void 0 : item["#text"];
-                    const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
-                    if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
-                      const num = Number(trimmed2);
-                      if (Number.isFinite(num)) return num;
-                    }
-                    return trimmed2;
-                  }
-                  const trimmed = typeof item === "string" ? item.trim() : item;
-                  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);
-                  if (Number.isFinite(num)) {
-                    val = num;
-                  } else {
-                    val = trimmed;
-                  }
-                } else {
-                  val = trimmed;
-                }
-              }
-            } else {
-              const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
-                const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
-                return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
-              })();
-              if (isIndexedTuple) {
-                const sortedKeys = keys.sort(
-                  (a, b) => parseInt(a) - parseInt(b)
-                );
-                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;
-        }
-        const originalSchema = originalSchemas[toolName];
-        const fallbackSchema = (_b = tools.find((t) => t.name === toolName)) == null ? void 0 : _b.inputSchema;
-        const schema = originalSchema || fallbackSchema;
-        const coercedArgs = coerceBySchema(args, schema);
-        processedElements.push({
-          type: "tool-call",
-          toolCallId: generateId3(),
+        const toolSchema = getToolSchema(tools, originalSchemas, toolName);
+        const { args, cancelToolCall } = processParsedArgs(
+          parsedArgs,
+          toolSchema,
+          toolContent,
           toolName,
-          input: JSON.stringify(coercedArgs)
-        });
+          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 });
@@ -1499,7 +2040,7 @@ var morphXmlProtocol = () => ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a, _b;
+        var _a;
         if (chunk.type !== "text-delta") {
           if (buffer) flushText(controller);
           controller.enqueue(chunk);
@@ -1521,94 +2062,43 @@ var morphXmlProtocol = () => ({
                   textNodeName: "#text"
                 });
                 const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-                const args = {};
-                for (const k of Object.keys(parsedArgs || {})) {
-                  const v = parsedArgs[k];
-                  let val = v;
-                  if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
-                    val = v == null ? void 0 : v["#text"];
-                  }
-                  if (Array.isArray(v)) {
-                    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) => {
-                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                            const textVal = item == null ? void 0 : item["#text"];
-                            const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
-                            if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
-                              const num = Number(trimmed2);
-                              if (Number.isFinite(num)) return num;
-                            }
-                            return trimmed2;
-                          }
-                          const trimmed = typeof item === "string" ? item.trim() : item;
-                          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);
-                          if (Number.isFinite(num)) {
-                            val = num;
-                          } else {
-                            val = trimmed;
-                          }
-                        } else {
-                          val = trimmed;
-                        }
-                      }
-                    } else {
-                      const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
-                        const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
-                        return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
-                      })();
-                      if (isIndexedTuple) {
-                        const sortedKeys = keys.sort(
-                          (a, b) => parseInt(a) - parseInt(b)
-                        );
-                        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;
+                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
                       }
-                    }
+                    );
                   }
-                  args[k] = typeof val === "string" ? val.trim() : val;
+                  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)
+                  });
                 }
-                const originalSchema = originalSchemas[currentToolCall.name];
-                const fallbackSchema = (_b = tools.find(
-                  (t) => t.name === currentToolCall.name
-                )) == null ? void 0 : _b.inputSchema;
-                const toolSchema = originalSchema || fallbackSchema;
-                const coercedArgs = coerceBySchema(args, toolSchema);
-                flushText(controller);
-                controller.enqueue({
-                  type: "tool-call",
-                  toolCallId: generateId3(),
-                  toolName: currentToolCall.name,
-                  input: JSON.stringify(coercedArgs)
-                });
               } catch (e) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
                 if (options == null ? void 0 : options.onError) {