@ai-sdk-tool/parser 3.1.3 → 3.2.0

package/dist/index.cjs

@@ -31,17 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  applyHeuristicPipeline: () => applyHeuristicPipeline,
-  balanceTagsHeuristic: () => balanceTagsHeuristic,
   createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
-  createIntermediateCall: () => createIntermediateCall,
   createToolMiddleware: () => createToolMiddleware,
   decodeOriginalTools: () => decodeOriginalTools,
-  dedupeShellStringTagsHeuristic: () => dedupeShellStringTagsHeuristic,
-  defaultPipelineConfig: () => defaultPipelineConfig,
   encodeOriginalTools: () => encodeOriginalTools,
-  escapeInvalidLtHeuristic: () => escapeInvalidLtHeuristic,
-  escapeRegExp: () => escapeRegExp2,
+  escapeRegExp: () => escapeRegExp,
   extractOnErrorOption: () => extractOnErrorOption,
   extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
   getDebugLevel: () => getDebugLevel,
@@ -57,10 +51,7 @@ __export(src_exports, {
   logParsedChunk: () => logParsedChunk,
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
-  mergePipelineConfigs: () => mergePipelineConfigs,
-  normalizeCloseTagsHeuristic: () => normalizeCloseTagsHeuristic,
   originalToolsSchema: () => originalToolsSchema,
-  repairAgainstSchemaHeuristic: () => repairAgainstSchemaHeuristic,
   toolChoiceStream: () => toolChoiceStream,
   transformParams: () => transformParams,
   wrapGenerate: () => wrapGenerate,
@@ -73,473 +64,6 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("@ai-sdk-tool/rjson"), module.exports);
 
-// src/core/heuristics/engine.ts
-function applyRawSegmentUpdate(current, result) {
-  if (result.rawSegment !== void 0) {
-    return { ...current, rawSegment: result.rawSegment };
-  }
-  return current;
-}
-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, parse3) {
-  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
-    return { state: current, newCount: reparseCount };
-  }
-  try {
-    const reparsed = parse3(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/core/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 MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
-var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
-var WHITESPACE_REGEX = /\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;
-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;
-  let out = "";
-  for (let i = 0; i < len; i += 1) {
-    const ch = xml[i];
-    if (ch === "<") {
-      const next = i + 1 < len ? xml[i + 1] : "";
-      const isValidStart = NAME_START_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?";
-      const isIndexTag = !isValidStart && isIndexTagAt(xml, i);
-      if (!(isValidStart || isIndexTag)) {
-        out += "&lt;";
-        continue;
-      }
-    }
-    out += ch;
-  }
-  return out;
-}
-function balanceTags(xml) {
-  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 = [];
-  const stack = [];
-  while (i < len) {
-    const lt = src.indexOf("<", i);
-    if (lt === -1) {
-      out.push(src.slice(i));
-      break;
-    }
-    out.push(src.slice(i, lt));
-    if (lt + 1 >= len) {
-      break;
-    }
-    const next = src[lt + 1];
-    if (next === "!" || next === "?") {
-      i = handleSpecialTagSegment(src, lt, out);
-      continue;
-    }
-    if (next === "/") {
-      i = handleClosingTagSegment(src, lt, out, stack);
-      continue;
-    }
-    i = handleOpeningTagSegment(src, lt, out, stack);
-  }
-  for (let k = stack.length - 1; k >= 0; k -= 1) {
-    out.push(`</${stack[k]}>`);
-  }
-  return out.join("");
-}
-function skipWs(s, p, len) {
-  let idx = p;
-  while (idx < len && WHITESPACE_REGEX.test(s[idx])) {
-    idx += 1;
-  }
-  return idx;
-}
-function parseTagNameAt(s, p, len) {
-  let idx = p;
-  const start = idx;
-  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
-    idx += 1;
-  }
-  return { name: s.slice(start, idx), pos: idx };
-}
-function handleSpecialTagSegment(src, lt, out) {
-  const gt = src.indexOf(">", lt + 1);
-  if (gt === -1) {
-    out.push(src.slice(lt));
-    return src.length;
-  }
-  out.push(src.slice(lt, gt + 1));
-  return gt + 1;
-}
-function handleClosingTagSegment(src, lt, out, stack) {
-  const len = src.length;
-  let p = skipWs(src, lt + 2, len);
-  const { name, pos } = parseTagNameAt(src, p, len);
-  p = pos;
-  const gt = src.indexOf(">", p);
-  const closingText = gt === -1 ? src.slice(lt) : src.slice(lt, gt + 1);
-  const idx = stack.lastIndexOf(name);
-  if (idx !== -1) {
-    for (let k = stack.length - 1; k > idx; k -= 1) {
-      out.push(`</${stack[k]}>`);
-      stack.pop();
-    }
-    out.push(closingText);
-    stack.pop();
-  }
-  return gt === -1 ? len : gt + 1;
-}
-function handleOpeningTagSegment(src, lt, out, stack) {
-  const len = src.length;
-  let p = skipWs(src, lt + 1, len);
-  const nameStart = p;
-  const parsed = parseTagNameAt(src, p, len);
-  p = parsed.pos;
-  const name = src.slice(nameStart, p);
-  const q = src.indexOf(">", p);
-  if (q === -1) {
-    out.push(src.slice(lt));
-    return len;
-  }
-  let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX.test(src[r])) {
-    r -= 1;
-  }
-  const selfClosing = src[r] === "/";
-  out.push(src.slice(lt, q + 1));
-  if (!selfClosing && name) {
-    stack.push(name);
-  }
-  return q + 1;
-}
-function extractSchemaProperties(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return void 0;
-  }
-  return unwrapped.properties;
-}
-function shouldDeduplicateStringTags(schema) {
-  const props = extractSchemaProperties(schema);
-  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 props = extractSchemaProperties(schema);
-  if (!props) {
-    return [];
-  }
-  const names = [];
-  for (const key of Object.keys(props)) {
-    const prop = (0, import_rxml.unwrapJsonSchema)(props[key]);
-    if ((prop == null ? void 0 : prop.type) === "string") {
-      names.push(key);
-    }
-  }
-  return names;
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function dedupeSingleTag(xml, key) {
-  var _a, _b;
-  const escaped = escapeRegExp(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;
-  }
-  const properties = extractSchemaProperties(schema);
-  if (!properties) {
-    return input;
-  }
-  applySchemaProps(input, properties);
-  return input;
-}
-function applySchemaProps(obj, properties) {
-  for (const key of Object.keys(obj)) {
-    const propSchema = properties[key];
-    if (!propSchema) {
-      continue;
-    }
-    const prop = (0, import_rxml.unwrapJsonSchema)(propSchema);
-    if ((prop == null ? void 0 : prop.type) === "array" && prop.items) {
-      const itemSchema = (0, import_rxml.unwrapJsonSchema)(prop.items);
-      obj[key] = coerceArrayItems(obj[key], itemSchema);
-      continue;
-    }
-    if ((prop == null ? void 0 : prop.type) === "object") {
-      const val = obj[key];
-      if (val && typeof val === "object") {
-        obj[key] = repairParsedAgainstSchema(val, prop);
-      }
-    }
-  }
-}
-function coerceArrayItems(val, itemSchema) {
-  if (!Array.isArray(val)) {
-    return val;
-  }
-  return val.map((v) => coerceArrayItem(v, itemSchema));
-}
-function coerceArrayItem(v, itemSchema) {
-  const itemType = itemSchema == null ? void 0 : itemSchema.type;
-  if (typeof v === "string" && itemType === "object") {
-    const parsed = tryParseStringToSchemaObject(v, itemSchema);
-    if (parsed !== null) {
-      return parsed;
-    }
-    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);
-  }
-  return v;
-}
-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;
-  }
-}
-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 null;
-}
-
 // src/core/protocols/json-protocol.ts
 var import_rjson = require("@ai-sdk-tool/rjson");
 
@@ -722,7 +246,7 @@ function generateId() {
 }
 
 // src/core/utils/regex.ts
-function escapeRegExp2(literal) {
+function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -969,8 +493,8 @@ var jsonProtocol = ({
     text,
     options
   }) {
-    const startEsc = escapeRegExp2(toolCallStart);
-    const endEsc = escapeRegExp2(toolCallEnd);
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
     const toolCallRegex = new RegExp(
       `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
       "gs"
@@ -1029,8 +553,8 @@ var jsonProtocol = ({
     });
   },
   extractToolCallSegments({ text }) {
-    const startEsc = escapeRegExp2(toolCallStart);
-    const endEsc = escapeRegExp2(toolCallEnd);
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
     const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
     const segments = [];
     let m = regex.exec(text);
@@ -1051,93 +575,48 @@ function isTCMProtocolFactory(protocol) {
 }
 
 // src/core/protocols/xml-protocol.ts
-var import_rxml2 = require("@ai-sdk-tool/rxml");
-var defaultPipelineConfig2 = defaultPipelineConfig;
-var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX2 = /\s/;
+var import_rxml = require("@ai-sdk-tool/rxml");
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX = /\s/;
+var REGEX_ESCAPE_RE = /[.*+?^${}()|[\]\\]/g;
+function escapeRegExp2(value) {
+  return value.replace(REGEX_ESCAPE_RE, "\\$&");
+}
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
 }
-function normalizeCloseTags(xml) {
-  return xml.replace(/<\/\s+([A-Za-z0-9_:-]+)\s*>/g, "</$1>");
-}
-function tryParseSecondaryXml(content, toolSchema, options) {
-  const balanced = balanceTags(content);
-  try {
-    let parsed = (0, import_rxml2.parse)(balanced, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      noChildNodes: []
-    });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema);
-    return parsed;
-  } catch (e) {
-    if (shouldDeduplicateStringTags(toolSchema)) {
-      const names = getStringPropertyNames(toolSchema);
-      let deduped = balanced;
-      for (const key of names) {
-        deduped = dedupeSingleTag(deduped, key);
-      }
-      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 processToolCallWithPipeline(params) {
-  var _a;
-  const {
-    toolCall,
-    tools,
-    options,
-    text,
-    processedElements,
-    pipelineConfig = defaultPipelineConfig2,
-    maxReparses
-  } = params;
+function processToolCall(params) {
+  var _a, _b;
+  const { toolCall, tools, options, text, processedElements, parseOptions } = params;
   const toolSchema = getToolSchema(tools, toolCall.toolName);
-  const ctx = createIntermediateCall(
-    toolCall.toolName,
-    toolCall.content,
-    toolSchema
-  );
-  const result = applyHeuristicPipeline(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) {
+  const parseConfig = {
+    ...parseOptions != null ? parseOptions : {},
+    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
+  };
+  try {
+    const parsed = (0, import_rxml.parse)(toolCall.content, toolSchema, parseConfig);
     processedElements.push({
       type: "tool-call",
       toolCallId: generateId(),
       toolName: toolCall.toolName,
-      input: JSON.stringify(result.parsed)
+      input: JSON.stringify(parsed)
     });
-  } else {
+  } catch (error) {
     const originalCallText = text.substring(
       toolCall.startIndex,
       toolCall.endIndex
     );
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
       options,
       `Could not process XML tool call: ${toolCall.toolName}`,
-      { toolCall: originalCallText, error: result.errors[0] }
+      { toolCall: originalCallText, error }
     );
     processedElements.push({ type: "text", text: originalCallText });
   }
 }
 function handleStreamingToolCallEnd(params) {
-  var _a;
+  var _a, _b;
   const {
     toolContent,
     currentToolCall,
@@ -1145,51 +624,27 @@ function handleStreamingToolCallEnd(params) {
     options,
     ctrl,
     flushText,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   } = params;
   const toolSchema = getToolSchema(tools, currentToolCall.name);
-  let parsedResult = null;
-  if (pipelineConfig) {
-    const ctx = createIntermediateCall(
-      currentToolCall.name,
-      toolContent,
-      toolSchema
-    );
-    const result = applyHeuristicPipeline(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
-    });
-    parsedResult = result.parsed;
-  } else {
-    try {
-      const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
-      const parsed = (0, import_rxml2.parse)(primary, toolSchema, {
-        onError: options == null ? void 0 : options.onError,
-        noChildNodes: []
-      });
-      parsedResult = repairParsedAgainstSchema(parsed, toolSchema);
-    } catch (e) {
-      parsedResult = tryParseSecondaryXml(
-        toolContent,
-        toolSchema,
-        options != null ? options : {}
-      );
-    }
-  }
+  const parseConfig = {
+    ...parseOptions != null ? parseOptions : {},
+    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
+  };
   flushText(ctrl);
-  if (parsedResult !== null) {
+  try {
+    const parsedResult = (0, import_rxml.parse)(toolContent, toolSchema, parseConfig);
     ctrl.enqueue({
       type: "tool-call",
       toolCallId: generateId(),
       toolName: currentToolCall.name,
       input: JSON.stringify(parsedResult)
     });
-  } else {
+  } catch (error) {
     const original = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not process streaming XML tool call", {
-      toolCall: original
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "Could not process streaming XML tool call", {
+      toolCall: original,
+      error
     });
     flushText(ctrl, original);
   }
@@ -1228,11 +683,11 @@ function consumeClosingTag(text, lt) {
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
-  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+  while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
     p += 1;
   }
   const name = text.slice(nameStart, p);
@@ -1241,7 +696,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -1270,11 +725,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_REGEX.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
-    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+    while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
       p += 1;
     }
     const name = text.slice(nameStart, p);
@@ -1291,49 +746,90 @@ function nextTagToken(text, fromPos) {
     nextPos: open.nextPos
   };
 }
+function findNextToolTag(text, searchIndex, startTag, selfTag) {
+  const openIdx = text.indexOf(startTag, searchIndex);
+  const selfIdx = text.indexOf(selfTag, searchIndex);
+  if (openIdx === -1 && selfIdx === -1) {
+    return null;
+  }
+  const isSelfClosing = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx);
+  return {
+    tagStart: isSelfClosing ? selfIdx : openIdx,
+    isSelfClosing
+  };
+}
+function findLastCloseTagStart(segment, toolName) {
+  const closeTagPattern = new RegExp(
+    `</\\s*${escapeRegExp2(toolName)}\\s*>`,
+    "g"
+  );
+  let closeTagStart = -1;
+  let match = closeTagPattern.exec(segment);
+  while (match !== null) {
+    closeTagStart = match.index;
+    match = closeTagPattern.exec(segment);
+  }
+  if (closeTagStart === -1) {
+    return segment.lastIndexOf("<");
+  }
+  return closeTagStart;
+}
+function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, selfTag) {
+  const endIndex = tagStart + selfTag.length;
+  toolCalls.push({
+    toolName,
+    startIndex: tagStart,
+    endIndex,
+    content: "",
+    segment: text.substring(tagStart, endIndex)
+  });
+  return endIndex;
+}
+function appendOpenToolCallIfComplete(toolCalls, text, toolName, tagStart, startTag) {
+  const contentStart = tagStart + startTag.length;
+  const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
+  if (fullTagEnd === -1 || fullTagEnd <= contentStart) {
+    return contentStart;
+  }
+  const segment = text.substring(tagStart, fullTagEnd);
+  const closeTagStart = findLastCloseTagStart(segment, toolName);
+  const inner = closeTagStart === -1 ? segment.slice(startTag.length) : segment.slice(startTag.length, closeTagStart);
+  toolCalls.push({
+    toolName,
+    startIndex: tagStart,
+    endIndex: fullTagEnd,
+    content: inner,
+    segment
+  });
+  return fullTagEnd;
+}
 function findToolCallsForName(text, toolName) {
-  var _a;
   const toolCalls = [];
+  const startTag = `<${toolName}>`;
+  const selfTag = `<${toolName}/>`;
   let searchIndex = 0;
   while (searchIndex < text.length) {
-    const startTag = `<${toolName}>`;
-    const selfTag = `<${toolName}/>`;
-    const openIdx = text.indexOf(startTag, searchIndex);
-    const selfIdx = text.indexOf(selfTag, searchIndex);
-    if (openIdx === -1 && selfIdx === -1) {
+    const match = findNextToolTag(text, searchIndex, startTag, selfTag);
+    if (match === null) {
       break;
     }
-    const tagStart = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx) ? selfIdx : openIdx;
-    const isSelfClosing = tagStart === selfIdx;
-    if (isSelfClosing) {
-      const endIndex = tagStart + selfTag.length;
-      const segment = text.substring(tagStart, endIndex);
-      toolCalls.push({
+    if (match.isSelfClosing) {
+      searchIndex = pushSelfClosingToolCall(
+        toolCalls,
         toolName,
-        startIndex: tagStart,
-        endIndex,
-        content: "",
-        segment
-      });
-      searchIndex = endIndex;
+        text,
+        match.tagStart,
+        selfTag
+      );
       continue;
     }
-    const contentStart = tagStart + startTag.length;
-    const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
-    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
-      const segment = text.substring(tagStart, fullTagEnd);
-      const inner = (_a = (0, import_rxml2.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
-      toolCalls.push({
-        toolName,
-        startIndex: tagStart,
-        endIndex: fullTagEnd,
-        content: inner,
-        segment
-      });
-      searchIndex = fullTagEnd;
-    } else {
-      searchIndex = contentStart;
-    }
+    searchIndex = appendOpenToolCallIfComplete(
+      toolCalls,
+      text,
+      toolName,
+      match.tagStart,
+      startTag
+    );
   }
   return toolCalls;
 }
@@ -1410,16 +906,20 @@ function processToolCallInBuffer(params) {
     controller,
     flushText,
     setBuffer,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   } = params;
-  const endTag = `</${currentToolCall.name}>`;
-  const endIdx = buffer.indexOf(endTag);
-  if (endIdx === -1) {
+  const endTagPattern = new RegExp(
+    `</\\s*${escapeRegExp2(currentToolCall.name)}\\s*>`
+  );
+  const endMatch = endTagPattern.exec(buffer);
+  if (!endMatch || endMatch.index === void 0) {
     return { buffer, currentToolCall, shouldBreak: true };
   }
+  const endIdx = endMatch.index;
+  const endPos = endIdx + endMatch[0].length;
   const content = buffer.substring(0, endIdx);
-  setBuffer(buffer.substring(endIdx + endTag.length));
+  const remainder = buffer.substring(endPos);
+  setBuffer(remainder);
   handleStreamingToolCallEnd({
     toolContent: content,
     currentToolCall,
@@ -1427,11 +927,10 @@ function processToolCallInBuffer(params) {
     options,
     ctrl: controller,
     flushText,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   });
   return {
-    buffer: buffer.substring(endIdx + endTag.length),
+    buffer: remainder,
     currentToolCall: null,
     shouldBreak: false
   };
@@ -1444,8 +943,7 @@ function processNoToolCallInBuffer(params) {
     flushText,
     tools,
     options,
-    pipelineConfig,
-    maxReparses,
+    parseOptions,
     setBuffer
   } = params;
   const {
@@ -1480,8 +978,7 @@ function processNoToolCallInBuffer(params) {
       options,
       ctrl: controller,
       flushText,
-      pipelineConfig,
-      maxReparses
+      parseOptions
     });
     return {
       buffer: newBuffer2,
@@ -1500,7 +997,7 @@ function processNoToolCallInBuffer(params) {
     shouldContinue: true
   };
 }
-function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, pipelineConfig, maxReparses) {
+function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, parseOptions) {
   return (controller) => {
     while (true) {
       const currentToolCall = getCurrentToolCall();
@@ -1513,8 +1010,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           controller,
           flushText,
           setBuffer,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -1529,8 +1025,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           flushText,
           tools,
           options,
-          pipelineConfig,
-          maxReparses,
+          parseOptions,
           setBuffer
         });
         setBuffer(result.buffer);
@@ -1547,43 +1042,12 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
   };
 }
 var xmlProtocol = (protocolOptions) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  let pipelineConfig = protocolOptions == null ? void 0 : protocolOptions.pipeline;
-  const maxReparses = protocolOptions == null ? void 0 : protocolOptions.maxReparses;
-  if ((protocolOptions == null ? void 0 : protocolOptions.heuristics) && protocolOptions.heuristics.length > 0) {
-    const heuristicsConfig = {
-      preParse: [],
-      fallbackReparse: [],
-      postParse: []
-    };
-    for (const h of protocolOptions.heuristics) {
-      if (h.phase === "pre-parse") {
-        (_a = heuristicsConfig.preParse) == null ? void 0 : _a.push(h);
-      } else if (h.phase === "fallback-reparse") {
-        (_b = heuristicsConfig.fallbackReparse) == null ? void 0 : _b.push(h);
-      } else if (h.phase === "post-parse") {
-        (_c = heuristicsConfig.postParse) == null ? void 0 : _c.push(h);
-      }
-    }
-    if (pipelineConfig) {
-      pipelineConfig = {
-        preParse: [
-          ...(_d = pipelineConfig.preParse) != null ? _d : [],
-          ...(_e = heuristicsConfig.preParse) != null ? _e : []
-        ],
-        fallbackReparse: [
-          ...(_f = pipelineConfig.fallbackReparse) != null ? _f : [],
-          ...(_g = heuristicsConfig.fallbackReparse) != null ? _g : []
-        ],
-        postParse: [
-          ...(_h = pipelineConfig.postParse) != null ? _h : [],
-          ...(_i = heuristicsConfig.postParse) != null ? _i : []
-        ]
-      };
-    } else {
-      pipelineConfig = heuristicsConfig;
-    }
-  }
+  var _a;
+  const parseOptions = {
+    repair: true,
+    noChildNodes: [],
+    ...(_a = protocolOptions == null ? void 0 : protocolOptions.parseOptions) != null ? _a : {}
+  };
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
       return toolSystemPromptTemplate(tools || []);
@@ -1597,7 +1061,7 @@ var xmlProtocol = (protocolOptions) => {
           args = toolCall.input;
         }
       }
-      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
+      return (0, import_rxml.stringify)(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: true,
         minimalEscaping: true
@@ -1618,14 +1082,13 @@ var xmlProtocol = (protocolOptions) => {
             text: text.substring(currentIndex, tc.startIndex)
           });
         }
-        processToolCallWithPipeline({
+        processToolCall({
           toolCall: tc,
           tools,
           options,
           text,
           processedElements,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         currentIndex = tc.endIndex;
       }
@@ -1666,8 +1129,7 @@ var xmlProtocol = (protocolOptions) => {
         options,
         toolNames,
         flushText,
-        pipelineConfig,
-        maxReparses
+        parseOptions
       );
       return new TransformStream({
         transform(chunk, controller) {
@@ -1717,8 +1179,8 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
-var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX3 = /\s/;
+var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX2 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -1735,11 +1197,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX3.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX2.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < gtIdx && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < gtIdx && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1755,11 +1217,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < text.length && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1768,7 +1230,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -2273,7 +1735,7 @@ function hasInputProperty(obj) {
 
 // src/generate-handler.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_rxml3 = require("@ai-sdk-tool/rxml");
+var import_schema_coerce = require("@ai-sdk-tool/schema-coerce");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -2435,7 +1897,7 @@ function fixToolCallWithSchema(part, tools) {
     args = part.input;
   }
   const schema = (_a = tools.find((t) => t.name === part.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml3.coerceBySchema)(args, schema);
+  const coerced = (0, import_schema_coerce.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
@@ -3099,20 +2561,12 @@ function createToolMiddleware({
   const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   return {
     specificationVersion: "v3",
-    wrapStream: ({ doStream, doGenerate, params }) => {
-      if (isToolChoiceActive(params)) {
-        return toolChoiceStream({
-          doGenerate,
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      }
-      return wrapStream({
-        protocol: resolvedProtocol,
-        doStream,
-        doGenerate,
-        params
-      });
-    },
+    wrapStream: ({ doStream, doGenerate, params }) => wrapStream({
+      protocol: resolvedProtocol,
+      doStream,
+      doGenerate,
+      params
+    }),
     wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
       protocol: resolvedProtocol,
       doGenerate,
@@ -3146,16 +2600,10 @@ var yamlToolMiddleware = createToolMiddleware({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyHeuristicPipeline,
-  balanceTagsHeuristic,
   createDynamicIfThenElseSchema,
-  createIntermediateCall,
   createToolMiddleware,
   decodeOriginalTools,
-  dedupeShellStringTagsHeuristic,
-  defaultPipelineConfig,
   encodeOriginalTools,
-  escapeInvalidLtHeuristic,
   escapeRegExp,
   extractOnErrorOption,
   extractToolNamesFromOriginalTools,
@@ -3172,10 +2620,7 @@ var yamlToolMiddleware = createToolMiddleware({
   logParsedChunk,
   logParsedSummary,
   logRawChunk,
-  mergePipelineConfigs,
-  normalizeCloseTagsHeuristic,
   originalToolsSchema,
-  repairAgainstSchemaHeuristic,
   toolChoiceStream,
   transformParams,
   wrapGenerate,