@ai-sdk-tool/parser 3.0.0-canary.1 → 3.0.0-canary.3

package/dist/community.cjs

@@ -1141,27 +1141,226 @@ var jsonMixProtocol = ({
 
 // src/protocols/morph-xml-protocol.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_rxml = require("@ai-sdk-tool/rxml");
+var import_rxml2 = require("@ai-sdk-tool/rxml");
 
-// src/utils/type-guards.ts
-function isToolCallContent(content) {
-  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
-  (typeof content.input === "string" || typeof content.input === "object");
+// src/heuristics/engine.ts
+function applyRawSegmentUpdate(current, result) {
+  if (result.rawSegment !== void 0) {
+    return { ...current, rawSegment: result.rawSegment };
+  }
+  return current;
 }
-function hasInputProperty(obj) {
-  return typeof obj === "object" && obj !== null && "input" in obj;
+function applyParsedUpdate(current, result) {
+  if (result.parsed !== void 0) {
+    return { ...current, parsed: result.parsed };
+  }
+  return current;
+}
+function applyWarningsUpdate(current, result) {
+  var _a, _b;
+  if (result.warnings && result.warnings.length > 0) {
+    const meta = (_a = current.meta) != null ? _a : {};
+    const existingWarnings = (_b = meta.warnings) != null ? _b : [];
+    return {
+      ...current,
+      meta: { ...meta, warnings: [...existingWarnings, ...result.warnings] }
+    };
+  }
+  return current;
+}
+function attemptReparse(current, result, reparseCount, maxReparses, parse4) {
+  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
+    return { state: current, newCount: reparseCount };
+  }
+  try {
+    const reparsed = parse4(result.rawSegment, current.schema);
+    return {
+      state: { ...current, parsed: reparsed, errors: [] },
+      newCount: reparseCount + 1
+    };
+  } catch (error) {
+    return {
+      state: { ...current, errors: [...current.errors, error] },
+      newCount: reparseCount + 1
+    };
+  }
+}
+function executePhase(ctx, heuristics, options) {
+  var _a;
+  let current = ctx;
+  let reparseCount = 0;
+  const maxReparses = (_a = options.maxReparses) != null ? _a : 2;
+  for (const heuristic of heuristics) {
+    if (!heuristic.applies(current)) {
+      continue;
+    }
+    const result = heuristic.run(current);
+    current = applyRawSegmentUpdate(current, result);
+    current = applyParsedUpdate(current, result);
+    current = applyWarningsUpdate(current, result);
+    const reparseResult = attemptReparse(
+      current,
+      result,
+      reparseCount,
+      maxReparses,
+      options.parse
+    );
+    current = reparseResult.state;
+    reparseCount = reparseResult.newCount;
+    if (result.stop) {
+      break;
+    }
+  }
+  return current;
+}
+function applyHeuristicPipeline(ctx, config, options) {
+  let current = ctx;
+  if (config.preParse && config.preParse.length > 0) {
+    current = executePhase(current, config.preParse, options);
+  }
+  if (current.parsed === null && current.errors.length === 0) {
+    try {
+      const parsed = options.parse(current.rawSegment, current.schema);
+      current = { ...current, parsed, errors: [] };
+    } catch (error) {
+      current = { ...current, errors: [error] };
+    }
+  }
+  if (current.errors.length > 0 && config.fallbackReparse && config.fallbackReparse.length > 0) {
+    current = executePhase(current, config.fallbackReparse, options);
+  }
+  if (current.parsed !== null && config.postParse && config.postParse.length > 0) {
+    current = executePhase(current, config.postParse, options);
+  }
+  return current;
+}
+function createIntermediateCall(toolName, rawSegment, schema) {
+  return {
+    toolName,
+    schema,
+    rawSegment,
+    parsed: null,
+    errors: [],
+    meta: { originalContent: rawSegment }
+  };
+}
+function mergePipelineConfigs(...configs) {
+  var _a, _b, _c;
+  const result = {
+    preParse: [],
+    fallbackReparse: [],
+    postParse: []
+  };
+  for (const config of configs) {
+    if (config.preParse) {
+      result.preParse = [...(_a = result.preParse) != null ? _a : [], ...config.preParse];
+    }
+    if (config.fallbackReparse) {
+      result.fallbackReparse = [
+        ...(_b = result.fallbackReparse) != null ? _b : [],
+        ...config.fallbackReparse
+      ];
+    }
+    if (config.postParse) {
+      result.postParse = [...(_c = result.postParse) != null ? _c : [], ...config.postParse];
+    }
+  }
+  return result;
 }
 
-// src/protocols/morph-xml-protocol.ts
-var WHITESPACE_REGEX2 = /\s/;
-var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+// src/heuristics/xml-defaults.ts
+var import_rxml = require("@ai-sdk-tool/rxml");
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
-var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
 var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
+var WHITESPACE_REGEX2 = /\s/;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var NAME_START_CHAR_RE = /[A-Za-z_:]/;
 var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
 var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
-function normalizeCloseTags(xml) {
-  return xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+var normalizeCloseTagsHeuristic = {
+  id: "normalize-close-tags",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const normalized = ctx.rawSegment.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    if (normalized !== ctx.rawSegment) {
+      return { rawSegment: normalized };
+    }
+    return {};
+  }
+};
+var escapeInvalidLtHeuristic = {
+  id: "escape-invalid-lt",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const escaped = escapeInvalidLt(ctx.rawSegment);
+    if (escaped !== ctx.rawSegment) {
+      return { rawSegment: escaped };
+    }
+    return {};
+  }
+};
+var balanceTagsHeuristic = {
+  id: "balance-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const balanced = balanceTags(original);
+    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
+    if (!hasMalformedClose && balanced.length > normalized.length) {
+      return false;
+    }
+    return balanced !== normalized;
+  },
+  run: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const balanced = balanceTags(original);
+    const escaped = escapeInvalidLt(balanced);
+    return { rawSegment: escaped, reparse: true };
+  }
+};
+var dedupeShellStringTagsHeuristic = {
+  id: "dedupe-shell-string-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => shouldDeduplicateStringTags(ctx.schema),
+  run: (ctx) => {
+    const names = getStringPropertyNames(ctx.schema);
+    let deduped = ctx.rawSegment;
+    for (const key of names) {
+      deduped = dedupeSingleTag(deduped, key);
+    }
+    if (deduped !== ctx.rawSegment) {
+      return { rawSegment: deduped, reparse: true };
+    }
+    return {};
+  }
+};
+var repairAgainstSchemaHeuristic = {
+  id: "repair-against-schema",
+  phase: "post-parse",
+  applies: (ctx) => ctx.parsed !== null && typeof ctx.parsed === "object",
+  run: (ctx) => {
+    const repaired = repairParsedAgainstSchema(ctx.parsed, ctx.schema);
+    if (repaired !== ctx.parsed) {
+      return { parsed: repaired };
+    }
+    return {};
+  }
+};
+var defaultPipelineConfig = {
+  preParse: [normalizeCloseTagsHeuristic, escapeInvalidLtHeuristic],
+  fallbackReparse: [balanceTagsHeuristic, dedupeShellStringTagsHeuristic],
+  postParse: [repairAgainstSchemaHeuristic]
+};
+var INDEX_TAG_RE = /^<(\d+)(?:>|\/?>)/;
+function isIndexTagAt(xml, pos) {
+  const remaining = xml.slice(pos);
+  return INDEX_TAG_RE.test(remaining);
 }
 function escapeInvalidLt(xml) {
   const len = xml.length;
@@ -1170,7 +1369,9 @@ function escapeInvalidLt(xml) {
     const ch = xml[i];
     if (ch === "<") {
       const next = i + 1 < len ? xml[i + 1] : "";
-      if (!(NAME_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?")) {
+      const isValidStart = NAME_START_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?";
+      const isIndexTag = !isValidStart && isIndexTagAt(xml, i);
+      if (!(isValidStart || isIndexTag)) {
         out += "&lt;";
         continue;
       }
@@ -1179,60 +1380,8 @@ function escapeInvalidLt(xml) {
   }
   return out;
 }
-function shouldDeduplicateStringTags(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return false;
-  }
-  const props = unwrapped.properties;
-  if (!props) {
-    return false;
-  }
-  const commandRaw = props.command;
-  if (!commandRaw) {
-    return false;
-  }
-  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
-  return (command == null ? void 0 : command.type) === "array";
-}
-function tryParseSecondaryXml(content, toolSchema, options) {
-  const normalized = normalizeCloseTags(content);
-  const balanced = balanceTags(content);
-  const hasMalformedClose = MALFORMED_CLOSE_RE.test(content);
-  if (!hasMalformedClose && balanced.length > normalized.length) {
-    return null;
-  }
-  try {
-    let parsed = (0, import_rxml.parse)(balanced, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      noChildNodes: []
-    });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
-    return parsed;
-  } catch (_e) {
-    if (shouldDeduplicateStringTags(toolSchema)) {
-      const deduped = dedupeStringTagsAgainstSchema(balanced, toolSchema);
-      if (deduped !== balanced) {
-        try {
-          let reparsed = (0, import_rxml.parse)(deduped, toolSchema, {
-            onError: options == null ? void 0 : options.onError,
-            noChildNodes: []
-          });
-          reparsed = repairParsedAgainstSchema(reparsed, toolSchema, options);
-          return reparsed;
-        } catch (_) {
-          return null;
-        }
-      }
-    }
-    return null;
-  }
-}
 function balanceTags(xml) {
-  const src = normalizeCloseTags(xml).replace(
-    STATUS_TO_STEP_BOUNDARY_RE,
-    "</status></step><step>"
-  );
+  const src = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>").replace(STATUS_TO_STEP_BOUNDARY_RE, "</status></step><step>");
   let i = 0;
   const len = src.length;
   const out = [];
@@ -1328,7 +1477,69 @@ function handleOpeningTagSegment(src, lt, out, stack) {
   }
   return q + 1;
 }
-function repairParsedAgainstSchema(input, schema, options) {
+function shouldDeduplicateStringTags(schema) {
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return false;
+  }
+  const props = unwrapped.properties;
+  if (!props) {
+    return false;
+  }
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
+}
+function getStringPropertyNames(schema) {
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return [];
+  }
+  const props = unwrapped.properties;
+  if (!props) {
+    return [];
+  }
+  const names = [];
+  for (const key of Object.keys(props)) {
+    const prop = (0, import_rxml.unwrapJsonSchema)(
+      props[key]
+    );
+    const type = prop.type;
+    if (type === "string") {
+      names.push(key);
+    }
+  }
+  return names;
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function dedupeSingleTag(xml, key) {
+  var _a, _b;
+  const escaped = escapeRegExp2(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
+  }
+  const last = matches.at(-1);
+  let result = "";
+  let cursor = 0;
+  for (const m of matches) {
+    const idx = (_a = m.index) != null ? _a : 0;
+    result += xml.slice(cursor, idx);
+    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
+      result += m[0];
+    }
+    cursor = idx + m[0].length;
+  }
+  result += xml.slice(cursor);
+  return result;
+}
+function repairParsedAgainstSchema(input, schema) {
   if (!input || typeof input !== "object") {
     return input;
   }
@@ -1340,10 +1551,10 @@ function repairParsedAgainstSchema(input, schema, options) {
   if (!properties) {
     return input;
   }
-  applySchemaProps(input, properties, options);
+  applySchemaProps(input, properties);
   return input;
 }
-function applySchemaProps(obj, properties, options) {
+function applySchemaProps(obj, properties) {
   for (const key of Object.keys(obj)) {
     const propSchema = properties[key];
     if (!propSchema) {
@@ -1354,121 +1565,122 @@ function applySchemaProps(obj, properties, options) {
     if (propType === "array" && prop.items) {
       const itemSchemaRaw = prop.items;
       const itemSchema = (0, import_rxml.unwrapJsonSchema)(itemSchemaRaw);
-      obj[key] = coerceArrayItems(obj[key], itemSchema, options);
+      obj[key] = coerceArrayItems(obj[key], itemSchema);
       continue;
     }
     if (propType === "object") {
       const val = obj[key];
       if (val && typeof val === "object") {
-        obj[key] = repairParsedAgainstSchema(
-          val,
-          prop,
-          options
-        );
+        obj[key] = repairParsedAgainstSchema(val, prop);
       }
     }
   }
 }
-function coerceArrayItems(val, itemSchema, options) {
+function coerceArrayItems(val, itemSchema) {
   if (!Array.isArray(val)) {
     return val;
   }
-  return val.map((v) => coerceArrayItem(v, itemSchema, options));
+  return val.map((v) => coerceArrayItem(v, itemSchema));
 }
-function coerceArrayItem(v, itemSchema, options) {
+function coerceArrayItem(v, itemSchema) {
   const itemType = itemSchema == null ? void 0 : itemSchema.type;
   if (typeof v === "string" && itemType === "object") {
-    const parsed = tryParseStringToSchemaObject(v, itemSchema, options);
+    const parsed = tryParseStringToSchemaObject(v, itemSchema);
     if (parsed !== null) {
       return parsed;
     }
-    const fallback = extractStepStatusFromString(normalizeCloseTags(v));
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
+    );
     if (fallback) {
       return fallback;
     }
     return v;
   }
   if (v && typeof v === "object" && itemType === "object") {
-    return repairParsedAgainstSchema(
-      v,
-      itemSchema,
-      options
-    );
+    return repairParsedAgainstSchema(v, itemSchema);
   }
   return v;
 }
-function getStringPropertyNames(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return [];
-  }
-  const props = unwrapped.properties;
-  if (!props) {
-    return [];
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = (0, import_rxml.parse)(normalized, itemSchema, { noChildNodes: [] });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
   }
-  const names = [];
-  for (const key of Object.keys(props)) {
-    const prop = (0, import_rxml.unwrapJsonSchema)(
-      props[key]
-    );
-    const type = prop.type;
-    if (type === "string") {
-      names.push(key);
-    }
+}
+function extractStepStatusFromString(normXml) {
+  const stepMatch = normXml.match(STEP_TAG_RE);
+  const statusMatch = normXml.match(STATUS_TAG_RE);
+  if (stepMatch && statusMatch) {
+    return { step: stepMatch[1], status: statusMatch[1] };
   }
-  return names;
+  return null;
 }
-function escapeRegExp2(s) {
-  return s.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+
+// src/utils/type-guards.ts
+function isToolCallContent(content) {
+  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
+  (typeof content.input === "string" || typeof content.input === "object");
 }
-function dedupeStringTagsAgainstSchema(xml, schema) {
-  const names = getStringPropertyNames(schema);
-  let out = xml;
-  for (const key of names) {
-    out = dedupeSingleTag(out, key);
-  }
-  return out;
+function hasInputProperty(obj) {
+  return typeof obj === "object" && obj !== null && "input" in obj;
 }
-function dedupeSingleTag(xml, key) {
-  var _a, _b;
-  const escaped = escapeRegExp2(key);
-  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
-  const matches = Array.from(xml.matchAll(re));
-  if (matches.length <= 1) {
-    return xml;
-  }
-  const last = matches.at(-1);
-  let result = "";
-  let cursor = 0;
-  for (const m of matches) {
-    const idx = (_a = m.index) != null ? _a : 0;
-    result += xml.slice(cursor, idx);
-    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
-      result += m[0];
-    }
-    cursor = idx + m[0].length;
-  }
-  result += xml.slice(cursor);
-  return result;
+
+// src/protocols/morph-xml-protocol.ts
+var defaultPipelineConfig2 = defaultPipelineConfig;
+var applyHeuristicPipeline2 = applyHeuristicPipeline;
+var createIntermediateCall2 = createIntermediateCall;
+var mergePipelineConfigs2 = mergePipelineConfigs;
+var WHITESPACE_REGEX3 = /\s/;
+var MALFORMED_CLOSE_RE2 = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+var MALFORMED_CLOSE_RE_G2 = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
+var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
+function normalizeCloseTags(xml) {
+  return xml.replace(MALFORMED_CLOSE_RE_G2, "</$1>");
 }
-function tryParseStringToSchemaObject(xml, itemSchema, options) {
+function tryParseSecondaryXml(content, toolSchema, options) {
+  const normalized = normalizeCloseTags(content);
+  const balanced = balanceTags(content);
+  const hasMalformedClose = MALFORMED_CLOSE_RE2.test(content);
+  if (!hasMalformedClose && balanced.length > normalized.length) {
+    return null;
+  }
   try {
-    const fixed = (0, import_rxml.parse)(normalizeCloseTags(xml), itemSchema, {
+    let parsed = (0, import_rxml2.parse)(balanced, toolSchema, {
       onError: options == null ? void 0 : options.onError,
       noChildNodes: []
     });
-    return typeof fixed === "string" ? null : fixed;
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
+    return parsed;
   } catch (e) {
+    if (shouldDeduplicateStringTags(toolSchema)) {
+      const deduped = dedupeStringTagsAgainstSchema(balanced, toolSchema);
+      if (deduped !== balanced) {
+        try {
+          let reparsed = (0, import_rxml2.parse)(deduped, toolSchema, {
+            onError: options == null ? void 0 : options.onError,
+            noChildNodes: []
+          });
+          reparsed = repairParsedAgainstSchema(reparsed, toolSchema);
+          return reparsed;
+        } catch (e2) {
+          return null;
+        }
+      }
+    }
     return null;
   }
 }
-function extractStepStatusFromString(normXml) {
-  const stepMatch = normXml.match(STEP_TAG_RE);
-  const statusMatch = normXml.match(STATUS_TAG_RE);
-  if (stepMatch && statusMatch) {
-    return { step: stepMatch[1], status: statusMatch[1] };
+function dedupeStringTagsAgainstSchema(xml, schema) {
+  const names = getStringPropertyNames(schema);
+  let out = xml;
+  for (const key of names) {
+    out = dedupeSingleTag(out, key);
   }
-  return null;
+  return out;
 }
 function processTextBeforeToolCall(text, currentIndex, toolCallStartIndex, processedElements) {
   if (toolCallStartIndex > currentIndex) {
@@ -1479,18 +1691,60 @@ function processTextBeforeToolCall(text, currentIndex, toolCallStartIndex, proce
   }
   return currentIndex;
 }
+function processToolCallWithPipeline(params) {
+  var _a;
+  const {
+    toolCall,
+    tools,
+    options,
+    text,
+    processedElements,
+    pipelineConfig = defaultPipelineConfig2,
+    maxReparses
+  } = params;
+  const toolSchema = getToolSchema(tools, toolCall.toolName);
+  const ctx = createIntermediateCall2(
+    toolCall.toolName,
+    toolCall.content,
+    toolSchema
+  );
+  const result = applyHeuristicPipeline2(ctx, pipelineConfig, {
+    parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+    onError: options == null ? void 0 : options.onError,
+    maxReparses
+  });
+  if (result.parsed !== null) {
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: toolCall.toolName,
+      input: JSON.stringify(result.parsed)
+    });
+  } else {
+    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: result.errors[0]
+    });
+    processedElements.push({ type: "text", text: originalCallText });
+  }
+}
 function processToolCall(params) {
   var _a;
   const { toolCall, tools, options, text, processedElements } = params;
   const toolSchema = getToolSchema(tools, toolCall.toolName);
   try {
     const primary = escapeInvalidLt(normalizeCloseTags(toolCall.content));
-    let parsed = (0, import_rxml.parse)(primary, toolSchema, {
+    let parsed = (0, import_rxml2.parse)(primary, toolSchema, {
       onError: options == null ? void 0 : options.onError,
-      // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
       noChildNodes: []
     });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
     processedElements.push({
       type: "tool-call",
       toolCallId: (0, import_provider_utils2.generateId)(),
@@ -1533,16 +1787,67 @@ function addRemainingText(text, currentIndex, processedElements) {
     }
   }
 }
+function handleStreamingToolCallEndWithPipeline(params) {
+  var _a;
+  const {
+    toolContent,
+    currentToolCall,
+    tools,
+    options,
+    ctrl,
+    flushText,
+    pipelineConfig = defaultPipelineConfig2,
+    maxReparses
+  } = params;
+  const toolSchema = getToolSchema(tools, currentToolCall.name);
+  const ctx = createIntermediateCall2(
+    currentToolCall.name,
+    toolContent,
+    toolSchema
+  );
+  const result = applyHeuristicPipeline2(ctx, pipelineConfig, {
+    parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+    onError: options == null ? void 0 : options.onError,
+    maxReparses
+  });
+  flushText(ctrl);
+  if (result.parsed !== null) {
+    ctrl.enqueue({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: currentToolCall.name,
+      input: JSON.stringify(result.parsed)
+    });
+  } else {
+    const endTag = `</${currentToolCall.name}>`;
+    const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
+    const error = result.errors[0];
+    let message = "Could not process streaming XML tool call; emitting original text.";
+    if (error instanceof import_rxml2.RXMLDuplicateStringTagError) {
+      message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+    } else if (error instanceof import_rxml2.RXMLCoercionError) {
+      message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+    } else if (error instanceof import_rxml2.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(ctrl, originalCallText);
+  }
+}
 function handleStreamingToolCallEnd(params) {
   const { toolContent, currentToolCall, tools, options, ctrl, flushText } = params;
   const toolSchema = getToolSchema(tools, currentToolCall.name);
   try {
     const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
-    let parsed = (0, import_rxml.parse)(primary, toolSchema, {
+    let parsed = (0, import_rxml2.parse)(primary, toolSchema, {
       onError: options == null ? void 0 : options.onError,
       noChildNodes: []
     });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
     flushText(ctrl);
     ctrl.enqueue({
       type: "tool-call",
@@ -1578,11 +1883,11 @@ function handleStreamingToolCallError(params) {
   const endTag = `</${currentToolCall.name}>`;
   const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
   let message = "Could not process streaming XML tool call; emitting original text.";
-  if (error instanceof import_rxml.RXMLDuplicateStringTagError) {
+  if (error instanceof import_rxml2.RXMLDuplicateStringTagError) {
     message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof import_rxml.RXMLCoercionError) {
+  } else if (error instanceof import_rxml2.RXMLCoercionError) {
     message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof import_rxml.RXMLParseError) {
+  } else if (error instanceof import_rxml2.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, {
@@ -1634,7 +1939,9 @@ function processToolCallInBuffer(params) {
     options,
     controller,
     flushText,
-    setBuffer
+    setBuffer,
+    pipelineConfig,
+    maxReparses
   } = params;
   const endTag = `</${currentToolCall.name}>`;
   const normalized = normalizeCloseTags(buffer);
@@ -1644,14 +1951,27 @@ function processToolCallInBuffer(params) {
     const toolContent = effectiveBuffer.substring(0, endTagIndex);
     const newBuffer = effectiveBuffer.substring(endTagIndex + endTag.length);
     setBuffer("");
-    handleStreamingToolCallEnd({
-      toolContent,
-      currentToolCall,
-      tools,
-      options,
-      ctrl: controller,
-      flushText
-    });
+    if (pipelineConfig) {
+      handleStreamingToolCallEndWithPipeline({
+        toolContent,
+        currentToolCall,
+        tools,
+        options,
+        ctrl: controller,
+        flushText,
+        pipelineConfig,
+        maxReparses
+      });
+    } else {
+      handleStreamingToolCallEnd({
+        toolContent,
+        currentToolCall,
+        tools,
+        options,
+        ctrl: controller,
+        flushText
+      });
+    }
     setBuffer(newBuffer);
     return { buffer: newBuffer, currentToolCall: null, shouldBreak: false };
   }
@@ -1665,7 +1985,9 @@ function processNoToolCallInBuffer(params) {
     controller,
     flushText,
     tools,
-    options
+    options,
+    pipelineConfig,
+    maxReparses
   } = params;
   const {
     index: earliestStartTagIndex,
@@ -1680,14 +2002,27 @@ function processNoToolCallInBuffer(params) {
       const newBuffer2 = buffer.substring(
         earliestStartTagIndex + selfTag.length
       );
-      handleStreamingToolCallEnd({
-        toolContent: "",
-        currentToolCall: { name: earliestToolName, content: "" },
-        tools,
-        options,
-        ctrl: controller,
-        flushText
-      });
+      if (pipelineConfig) {
+        handleStreamingToolCallEndWithPipeline({
+          toolContent: "",
+          currentToolCall: { name: earliestToolName, content: "" },
+          tools,
+          options,
+          ctrl: controller,
+          flushText,
+          pipelineConfig,
+          maxReparses
+        });
+      } else {
+        handleStreamingToolCallEnd({
+          toolContent: "",
+          currentToolCall: { name: earliestToolName, content: "" },
+          tools,
+          options,
+          ctrl: controller,
+          flushText
+        });
+      }
       return {
         buffer: newBuffer2,
         currentToolCall: null,
@@ -1751,7 +2086,9 @@ function processBufferWithToolCall(params, controller) {
     setCurrentToolCall,
     tools,
     options,
-    flushText
+    flushText,
+    pipelineConfig,
+    maxReparses
   } = params;
   const currentToolCall = getCurrentToolCall();
   if (!currentToolCall) {
@@ -1764,7 +2101,9 @@ function processBufferWithToolCall(params, controller) {
     options,
     controller,
     flushText,
-    setBuffer
+    setBuffer,
+    pipelineConfig,
+    maxReparses
   });
   setBuffer(result.buffer);
   setCurrentToolCall(result.currentToolCall);
@@ -1779,7 +2118,9 @@ function processBufferWithoutToolCall(params, controller) {
     options,
     toolNames,
     maxStartTagLen,
-    flushText
+    flushText,
+    pipelineConfig,
+    maxReparses
   } = params;
   const result = processNoToolCallInBuffer({
     buffer: getBuffer(),
@@ -1788,7 +2129,9 @@ function processBufferWithoutToolCall(params, controller) {
     controller,
     flushText,
     tools,
-    options
+    options,
+    pipelineConfig,
+    maxReparses
   });
   setBuffer(result.buffer);
   setCurrentToolCall(result.currentToolCall);
@@ -1824,139 +2167,218 @@ function createProcessBufferHandler(params) {
     processBufferLoop(params, controller);
   };
 }
-var morphXmlProtocol = () => ({
-  formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: (0, import_rxml.unwrapJsonSchema)(tool.inputSchema)
-    }));
-    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
-  },
-  formatToolCall(toolCall) {
-    let args = {};
-    const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
-    if (typeof inputValue === "string") {
-      try {
-        args = JSON.parse(inputValue);
-      } catch (e) {
+function buildPipelineOptions(protocolOptions) {
+  var _a, _b, _c;
+  const maxReparses = protocolOptions == null ? void 0 : protocolOptions.maxReparses;
+  if (protocolOptions == null ? void 0 : protocolOptions.pipeline) {
+    return {
+      pipelineConfig: mergePipelineConfigs2(
+        defaultPipelineConfig2,
+        protocolOptions.pipeline
+      ),
+      maxReparses
+    };
+  }
+  if (protocolOptions == null ? void 0 : protocolOptions.heuristics) {
+    return {
+      pipelineConfig: {
+        ...defaultPipelineConfig2,
+        preParse: [
+          ...(_a = defaultPipelineConfig2.preParse) != null ? _a : [],
+          ...protocolOptions.heuristics.filter((h) => h.phase === "pre-parse")
+        ],
+        fallbackReparse: [
+          ...(_b = defaultPipelineConfig2.fallbackReparse) != null ? _b : [],
+          ...protocolOptions.heuristics.filter(
+            (h) => h.phase === "fallback-reparse"
+          )
+        ],
+        postParse: [
+          ...(_c = defaultPipelineConfig2.postParse) != null ? _c : [],
+          ...protocolOptions.heuristics.filter((h) => h.phase === "post-parse")
+        ]
+      },
+      maxReparses
+    };
+  }
+  return { pipelineConfig: void 0, maxReparses };
+}
+var morphXmlProtocol = (protocolOptions) => {
+  const { pipelineConfig, maxReparses } = buildPipelineOptions(protocolOptions);
+  return {
+    formatTools({ tools, toolSystemPromptTemplate }) {
+      const toolsForPrompt = (tools || []).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: (0, import_rxml2.unwrapJsonSchema)(tool.inputSchema)
+      }));
+      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+    },
+    formatToolCall(toolCall) {
+      let args = {};
+      const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
+      if (typeof inputValue === "string") {
+        try {
+          args = JSON.parse(inputValue);
+        } catch (e) {
+          args = inputValue;
+        }
+      } else {
         args = inputValue;
       }
-    } else {
-      args = inputValue;
-    }
-    return (0, import_rxml.stringify)(toolCall.toolName, args, {
-      suppressEmptyNode: false,
-      format: false
-    });
-  },
-  formatToolResponse(toolResult) {
-    return (0, import_rxml.stringify)("tool_response", {
-      tool_name: toolResult.toolName,
-      result: toolResult.output
-    });
-  },
-  parseGeneratedText({ text, tools, options }) {
-    const toolNames = tools.map((t) => t.name).filter((name) => name != null);
-    if (toolNames.length === 0) {
-      return [{ type: "text", text }];
-    }
-    const processedElements = [];
-    let currentIndex = 0;
-    const toolCallsRaw = findToolCalls(text, toolNames);
-    const toolCallsNorm = collectToolCallsFromNormalizedText(text, toolNames);
-    const seen = /* @__PURE__ */ new Set();
-    const toolCalls = [...toolCallsRaw, ...toolCallsNorm].filter((tc) => {
-      const key = `${tc.toolName}:${tc.startIndex}:${tc.endIndex}`;
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    }).sort((a, b) => a.startIndex - b.startIndex);
-    for (const toolCall of toolCalls) {
-      currentIndex = processTextBeforeToolCall(
-        text,
-        currentIndex,
-        toolCall.startIndex,
-        processedElements
-      );
-      processToolCall({ toolCall, tools, options, text, processedElements });
-      currentIndex = toolCall.endIndex;
-    }
-    addRemainingText(text, currentIndex, processedElements);
-    return processedElements;
-  },
-  createStreamParser({ tools, options }) {
-    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;
-    const flushText = createFlushTextHandler(
-      () => buffer,
-      (newBuffer) => {
-        buffer = newBuffer;
-      },
-      () => currentTextId,
-      (newId) => {
-        currentTextId = newId;
+      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
+        suppressEmptyNode: false,
+        format: false
+      });
+    },
+    formatToolResponse(toolResult) {
+      return (0, import_rxml2.stringify)("tool_response", {
+        tool_name: toolResult.toolName,
+        result: toolResult.output
+      });
+    },
+    parseGeneratedText({ text, tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+      if (toolNames.length === 0) {
+        return [{ type: "text", text }];
       }
-    );
-    const processChunk = (chunk, controller) => {
-      if (chunk.type !== "text-delta") {
-        if (buffer) {
-          flushText(controller);
+      const processedElements = [];
+      let currentIndex = 0;
+      const toolCallsRaw = findToolCalls(text, toolNames);
+      const toolCallsNorm = collectToolCallsFromNormalizedText(text, toolNames);
+      const seen = /* @__PURE__ */ new Set();
+      const toolCalls = [...toolCallsRaw, ...toolCallsNorm].filter((tc) => {
+        const key = `${tc.toolName}:${tc.startIndex}:${tc.endIndex}`;
+        if (seen.has(key)) {
+          return false;
         }
-        controller.enqueue(chunk);
-        return;
-      }
-      buffer += chunk.delta;
-      processBuffer(controller);
-    };
-    const processBuffer = createProcessBufferHandler({
-      getBuffer: () => buffer,
-      setBuffer: (newBuffer) => {
-        buffer = newBuffer;
-      },
-      getCurrentToolCall: () => currentToolCall,
-      setCurrentToolCall: (newToolCall) => {
-        currentToolCall = newToolCall;
-      },
-      tools,
-      options,
-      toolNames,
-      maxStartTagLen,
-      flushText
-    });
-    const flushBuffer2 = (controller) => {
-      if (currentToolCall) {
-        const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
-        flushText(controller, unfinishedCall);
-      } else if (buffer) {
-        flushText(controller);
+        seen.add(key);
+        return true;
+      }).sort((a, b) => a.startIndex - b.startIndex);
+      if (process.env.DEBUG_PARSER_OUTPUT === "true") {
+        console.log("\n=== PARSER DEBUG ===");
+        console.log(`Available tools: ${toolNames.join(", ")}`);
+        console.log(`Full text length: ${text.length}`);
+        console.log(`Full text:
+${text}
+`);
+        console.log(`Tool calls found: ${toolCalls.length}`);
+        for (let i = 0; i < toolCalls.length; i++) {
+          const tc = toolCalls[i];
+          console.log(`
+[Tool Call ${i + 1}] ${tc.toolName}`);
+          console.log(`Position: ${tc.startIndex} - ${tc.endIndex}`);
+          console.log(`Segment:
+${tc.segment}`);
+          console.log(`Content:
+${tc.content}`);
+        }
+        console.log("===================\n");
       }
-      if (currentTextId) {
-        controller.enqueue({ type: "text-end", id: currentTextId });
+      for (const toolCall of toolCalls) {
+        currentIndex = processTextBeforeToolCall(
+          text,
+          currentIndex,
+          toolCall.startIndex,
+          processedElements
+        );
+        if (pipelineConfig) {
+          processToolCallWithPipeline({
+            toolCall,
+            tools,
+            options,
+            text,
+            processedElements,
+            pipelineConfig,
+            maxReparses
+          });
+        } else {
+          processToolCall({
+            toolCall,
+            tools,
+            options,
+            text,
+            processedElements
+          });
+        }
+        currentIndex = toolCall.endIndex;
       }
-    };
-    return new TransformStream({
-      transform(chunk, controller) {
-        processChunk(chunk, controller);
-      },
-      flush(controller) {
-        flushBuffer2(controller);
+      addRemainingText(text, currentIndex, processedElements);
+      return processedElements;
+    },
+    createStreamParser({ tools, options }) {
+      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;
+      const flushText = createFlushTextHandler(
+        () => buffer,
+        (newBuffer) => {
+          buffer = newBuffer;
+        },
+        () => currentTextId,
+        (newId) => {
+          currentTextId = newId;
+        }
+      );
+      const processChunk = (chunk, controller) => {
+        if (chunk.type !== "text-delta") {
+          if (buffer) {
+            flushText(controller);
+          }
+          controller.enqueue(chunk);
+          return;
+        }
+        buffer += chunk.delta;
+        processBuffer(controller);
+      };
+      const processBuffer = createProcessBufferHandler({
+        getBuffer: () => buffer,
+        setBuffer: (newBuffer) => {
+          buffer = newBuffer;
+        },
+        getCurrentToolCall: () => currentToolCall,
+        setCurrentToolCall: (newToolCall) => {
+          currentToolCall = newToolCall;
+        },
+        tools,
+        options,
+        toolNames,
+        maxStartTagLen,
+        flushText,
+        pipelineConfig,
+        maxReparses
+      });
+      const flushBuffer2 = (controller) => {
+        if (currentToolCall) {
+          const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
+          flushText(controller, unfinishedCall);
+        } else if (buffer) {
+          flushText(controller);
+        }
+        if (currentTextId) {
+          controller.enqueue({ type: "text-end", id: currentTextId });
+        }
+      };
+      return new TransformStream({
+        transform(chunk, controller) {
+          processChunk(chunk, controller);
+        },
+        flush(controller) {
+          flushBuffer2(controller);
+        }
+      });
+    },
+    extractToolCallSegments({ text, tools }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [];
       }
-    });
-  },
-  extractToolCallSegments({ text, tools }) {
-    const toolNames = tools.map((t) => t.name).filter(Boolean);
-    if (toolNames.length === 0) {
-      return [];
+      return findToolCalls(text, toolNames).map((tc) => tc.segment);
     }
-    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;
@@ -1989,32 +2411,22 @@ function skipSpecialSegment(text, lt) {
   }
   return gt + 1;
 }
-function consumeClosingTag(text, lt, toolName) {
+function consumeClosingTag(text, lt, _toolName) {
   let p = lt + 2;
-  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
     p += 1;
   }
-  if (text.slice(p, p + toolName.length) === toolName) {
-    p += toolName.length;
-    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
-      p += 1;
-    }
-    if (text[p] === ">") {
-      const endPos2 = p + 1;
-      return { matched: true, endPos: endPos2 };
-    }
-  }
   const gt = text.indexOf(">", lt + 1);
   const endPos = gt === -1 ? text.length : gt + 1;
   return { matched: false, endPos };
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
-  while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
     p += 1;
   }
   const name = text.slice(nameStart, p);
@@ -2023,7 +2435,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -2052,11 +2464,11 @@ function nextTagToken(text, fromPos) {
   if (next === "/") {
     const closing = consumeClosingTag(text, lt, "");
     let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+    while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
-    while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
       p += 1;
     }
     const name = text.slice(nameStart, p);
@@ -2105,7 +2517,7 @@ function collectToolCallsFromNormalizedText(text, toolNames) {
           endOrig = Math.min(text.length, tagStartOrig + approxLen);
         }
         const segment = text.substring(tagStartOrig, endOrig);
-        const inner = (_a = (0, import_rxml.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+        const inner = (_a = (0, import_rxml2.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
         collected.push({
           toolName,
           startIndex: tagStartOrig,
@@ -2169,7 +2581,7 @@ function findToolCallsForName(text, toolName) {
     const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
     if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
       const segment = text.substring(tagStart, fullTagEnd);
-      const inner = (_a = (0, import_rxml.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+      const inner = (_a = (0, import_rxml2.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
       toolCalls.push({
         toolName,
         startIndex: tagStart,
@@ -2195,7 +2607,7 @@ function findToolCalls(text, toolNames) {
 
 // src/generate-handler.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_rxml2 = require("@ai-sdk-tool/rxml");
+var import_rxml3 = require("@ai-sdk-tool/rxml");
 
 // src/utils/on-error.ts
 function extractOnErrorOption(providerOptions) {
@@ -2399,7 +2811,7 @@ function fixToolCallWithSchema(part, tools) {
     args = tc.input;
   }
   const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml2.coerceBySchema)(args, schema);
+  const coerced = (0, import_rxml3.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})