@ai-sdk-tool/parser 3.1.2 → 3.2.0

package/dist/community.cjs

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -35,449 +36,43 @@ __export(community_exports, {
 });
 module.exports = __toCommonJS(community_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, 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 }
-  };
-}
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
+  createToolMiddleware: () => createToolMiddleware,
+  decodeOriginalTools: () => decodeOriginalTools,
+  encodeOriginalTools: () => encodeOriginalTools,
+  escapeRegExp: () => escapeRegExp,
+  extractOnErrorOption: () => extractOnErrorOption,
+  extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
+  getDebugLevel: () => getDebugLevel,
+  getPotentialStartIndex: () => getPotentialStartIndex,
+  hasInputProperty: () => hasInputProperty,
+  hermesToolMiddleware: () => hermesToolMiddleware,
+  isProtocolFactory: () => isProtocolFactory,
+  isTCMProtocolFactory: () => isTCMProtocolFactory,
+  isToolChoiceActive: () => isToolChoiceActive,
+  isToolResultPart: () => isToolResultPart,
+  jsonProtocol: () => jsonProtocol,
+  logParseFailure: () => logParseFailure,
+  logParsedChunk: () => logParsedChunk,
+  logParsedSummary: () => logParsedSummary,
+  logRawChunk: () => logRawChunk,
+  originalToolsSchema: () => originalToolsSchema,
+  toolChoiceStream: () => toolChoiceStream,
+  transformParams: () => transformParams,
+  wrapGenerate: () => wrapGenerate,
+  wrapStream: () => wrapStream,
+  xmlProtocol: () => xmlProtocol,
+  xmlToolMiddleware: () => xmlToolMiddleware,
+  yamlProtocol: () => yamlProtocol,
+  yamlToolMiddleware: () => yamlToolMiddleware
+});
+__reExport(src_exports, require("@ai-sdk-tool/rjson"));
 
-// 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");
 
 // src/core/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -658,652 +253,15 @@ function generateId() {
 }
 
 // src/core/utils/regex.ts
-function escapeRegExp2(literal) {
+function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/core/utils/robust-json.ts
-var WHITESPACE_TEST_REGEX = /\s/;
-var WHITESPACE_REGEX2 = /^\s+/;
-var OBJECT_START_REGEX = /^\{/;
-var OBJECT_END_REGEX = /^\}/;
-var ARRAY_START_REGEX = /^\[/;
-var ARRAY_END_REGEX = /^\]/;
-var COMMA_REGEX = /^,/;
-var COLON_REGEX = /^:/;
-var KEYWORD_REGEX = /^(?:true|false|null)/;
-var NUMBER_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/;
-var STRING_DOUBLE_REGEX = /^"(?:[^"\\]|\\["bnrtf\\/]|\\u[0-9a-fA-F]{4})*"/;
-var STRING_SINGLE_REGEX = /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/;
-var COMMENT_SINGLE_REGEX = /^\/\/.*?(?:\r\n|\r|\n)/;
-var COMMENT_MULTI_REGEX = /^\/\*[\s\S]*?\*\//;
-var IDENTIFIER_REGEX = /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/;
-function some(array, f) {
-  let acc = false;
-  for (let i = 0; i < array.length; i += 1) {
-    const result = f(array[i], i, array);
-    acc = result === void 0 ? false : result;
-    if (acc) {
-      return acc;
-    }
-  }
-  return acc;
-}
-function makeLexer(tokenSpecs) {
-  return (contents) => {
-    const tokens = [];
-    let line = 1;
-    let remainingContents = contents;
-    function findToken() {
-      const result = some(tokenSpecs, (tokenSpec) => {
-        const m = tokenSpec.re.exec(remainingContents);
-        if (m) {
-          const raw = m[0];
-          remainingContents = remainingContents.slice(raw.length);
-          return {
-            raw,
-            matched: tokenSpec.f(m)
-            // Process the match using the spec's function
-          };
-        }
-        return;
-      });
-      return result === false ? void 0 : result;
-    }
-    while (remainingContents !== "") {
-      const matched = findToken();
-      if (!matched) {
-        const err = new SyntaxError(
-          `Unexpected character: ${remainingContents[0]}; input: ${remainingContents.substr(
-            0,
-            100
-          )}`
-        );
-        err.line = line;
-        throw err;
-      }
-      const tokenWithLine = matched.matched;
-      tokenWithLine.line = line;
-      line += matched.raw.replace(/[^\n]/g, "").length;
-      tokens.push(tokenWithLine);
-    }
-    return tokens;
-  };
-}
-function fStringSingle(m) {
-  const content = m[1].replace(
-    /([^'\\]|\\['bnrtf\\]|\\u[0-9a-fA-F]{4})/g,
-    (mm) => {
-      if (mm === '"') {
-        return '\\"';
-      }
-      if (mm === "\\'") {
-        return "'";
-      }
-      return mm;
-    }
-  );
-  const match = `"${content}"`;
-  return {
-    type: "string",
-    match,
-    // The transformed, double-quoted string representation
-    // Use JSON.parse on the transformed string to handle escape sequences correctly
-    value: JSON.parse(match)
-  };
-}
-function fStringDouble(m) {
-  return {
-    type: "string",
-    match: m[0],
-    // The raw matched string (including quotes)
-    value: JSON.parse(m[0])
-    // Use JSON.parse to handle escapes and get the value
-  };
-}
-function fIdentifier(m) {
-  const value = m[0];
-  const match = '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + // Escape backslashes and quotes
-  '"';
-  return {
-    type: "string",
-    // Treat identifiers as strings
-    value,
-    // The original identifier name
-    match
-    // The double-quoted string representation
-  };
-}
-function fComment(m) {
-  const match = m[0].replace(
-    /./g,
-    (c) => WHITESPACE_TEST_REGEX.test(c) ? c : " "
-  );
-  return {
-    type: " ",
-    // Represent comments as whitespace tokens
-    match,
-    // String containing original newlines and spaces for other chars
-    value: void 0
-    // Comments don't have a semantic value
-  };
-}
-function fNumber(m) {
-  return {
-    type: "number",
-    match: m[0],
-    // The raw matched number string
-    value: Number.parseFloat(m[0])
-    // Convert string to number
-  };
-}
-function fKeyword(m) {
-  let value;
-  switch (m[0]) {
-    case "null":
-      value = null;
-      break;
-    case "true":
-      value = true;
-      break;
-    case "false":
-      value = false;
-      break;
-    default:
-      throw new Error(`Unexpected keyword: ${m[0]}`);
-  }
-  return {
-    type: "atom",
-    // Use 'atom' type for these literals
-    match: m[0],
-    // The raw matched keyword
-    value
-    // The corresponding JavaScript value
-  };
-}
-function makeTokenSpecs(relaxed) {
-  function f(type) {
-    return (m) => {
-      return { type, match: m[0], value: void 0 };
-    };
-  }
-  let tokenSpecs = [
-    { re: WHITESPACE_REGEX2, f: f(" ") },
-    // Whitespace
-    { re: OBJECT_START_REGEX, f: f("{") },
-    // Object start
-    { re: OBJECT_END_REGEX, f: f("}") },
-    // Object end
-    { re: ARRAY_START_REGEX, f: f("[") },
-    // Array start
-    { re: ARRAY_END_REGEX, f: f("]") },
-    // Array end
-    { re: COMMA_REGEX, f: f(",") },
-    // Comma separator
-    { re: COLON_REGEX, f: f(":") },
-    // Key-value separator
-    { re: KEYWORD_REGEX, f: fKeyword },
-    // Keywords
-    // Number: optional sign, digits, optional decimal part, optional exponent
-    { re: NUMBER_REGEX, f: fNumber },
-    // String: double-quoted, handles escapes
-    { re: STRING_DOUBLE_REGEX, f: fStringDouble }
-  ];
-  if (relaxed) {
-    tokenSpecs = tokenSpecs.concat([
-      // Single-quoted strings
-      {
-        re: STRING_SINGLE_REGEX,
-        f: fStringSingle
-      },
-      // Single-line comments (// ...)
-      { re: COMMENT_SINGLE_REGEX, f: fComment },
-      // Multi-line comments (/* ... */)
-      { re: COMMENT_MULTI_REGEX, f: fComment },
-      // Unquoted identifiers (treated as strings)
-      // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
-      { re: IDENTIFIER_REGEX, f: fIdentifier }
-      // Note: The order matters here. Identifiers are checked after keywords/numbers.
-    ]);
-  }
-  return tokenSpecs;
-}
-var lexer = makeLexer(makeTokenSpecs(true));
-var strictLexer = makeLexer(makeTokenSpecs(false));
-function previousNWSToken(tokens, index) {
-  let currentIndex = index;
-  for (; currentIndex >= 0; currentIndex -= 1) {
-    if (tokens[currentIndex].type !== " ") {
-      return currentIndex;
-    }
-  }
-  return;
-}
-function stripTrailingComma(tokens) {
-  const res = [];
-  tokens.forEach((token, index) => {
-    if (index > 0 && (token.type === "]" || token.type === "}")) {
-      const prevNWSTokenIndex = previousNWSToken(res, res.length - 1);
-      if (prevNWSTokenIndex !== void 0 && res[prevNWSTokenIndex].type === ",") {
-        const preCommaIndex = previousNWSToken(res, prevNWSTokenIndex - 1);
-        if (preCommaIndex !== void 0 && res[preCommaIndex].type !== "[" && res[preCommaIndex].type !== "{") {
-          res[prevNWSTokenIndex] = {
-            type: " ",
-            match: " ",
-            // Represent as a single space
-            value: void 0,
-            // Whitespace has no value
-            line: res[prevNWSTokenIndex].line
-            // Preserve original line number
-          };
-        }
-      }
-    }
-    res.push(token);
-  });
-  return res;
-}
-function popToken(tokens, state) {
-  var _a, _b;
-  const token = tokens[state.pos];
-  state.pos += 1;
-  if (!token) {
-    const lastLine = tokens.length !== 0 ? (_b = (_a = tokens.at(-1)) == null ? void 0 : _a.line) != null ? _b : 1 : 1;
-    return { type: "eof", match: "", value: void 0, line: lastLine };
-  }
-  return token;
-}
-function strToken(token) {
-  switch (token.type) {
-    case "atom":
-    case "string":
-    case "number":
-      return `${token.type} ${token.match}`;
-    case "eof":
-      return "end-of-file";
-    default:
-      return `'${token.type}'`;
-  }
-}
-function skipColon(tokens, state) {
-  const colon = popToken(tokens, state);
-  if (colon.type !== ":") {
-    const message = `Unexpected token: ${strToken(colon)}, expected ':'`;
-    if (state.tolerant) {
-      state.warnings.push({
-        message,
-        line: colon.line
-      });
-      state.pos -= 1;
-    } else {
-      const err = new SyntaxError(message);
-      err.line = colon.line;
-      throw err;
-    }
-  }
-}
-function skipPunctuation(tokens, state, valid) {
-  const punctuation = [",", ":", "]", "}"];
-  let token = popToken(tokens, state);
-  while (true) {
-    if (valid == null ? void 0 : valid.includes(token.type)) {
-      return token;
-    }
-    if (token.type === "eof") {
-      return token;
-    }
-    if (punctuation.includes(token.type)) {
-      const message = `Unexpected token: ${strToken(
-        token
-      )}, expected '[', '{', number, string or atom`;
-      if (state.tolerant) {
-        state.warnings.push({
-          message,
-          line: token.line
-        });
-        token = popToken(tokens, state);
-      } else {
-        const err = new SyntaxError(message);
-        err.line = token.line;
-        throw err;
-      }
-    } else {
-      return token;
-    }
-  }
-}
-function raiseError(state, token, message) {
-  if (state.tolerant) {
-    state.warnings.push({
-      message,
-      line: token.line
-    });
-  } else {
-    const err = new SyntaxError(message);
-    err.line = token.line;
-    throw err;
-  }
-}
-function raiseUnexpected(state, token, expected) {
-  raiseError(
-    state,
-    token,
-    `Unexpected token: ${strToken(token)}, expected ${expected}`
-  );
-}
-function checkDuplicates(state, obj, token) {
-  const key = String(token.value);
-  if (!state.duplicate && Object.hasOwn(obj, key)) {
-    raiseError(state, token, `Duplicate key: ${key}`);
-  }
-}
-function appendPair(state, obj, key, value) {
-  const finalValue = state.reviver ? state.reviver(key, value) : value;
-  if (finalValue !== void 0) {
-    obj[key] = finalValue;
-  }
-}
-function parsePair(tokens, state, obj) {
-  let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
-  let value;
-  if (token.type !== "string") {
-    raiseUnexpected(state, token, "string key");
-    if (state.tolerant) {
-      switch (token.type) {
-        case ":":
-          token = {
-            type: "string",
-            value: "null",
-            match: '"null"',
-            line: token.line
-          };
-          state.pos -= 1;
-          break;
-        case "number":
-        // Use number as string key
-        case "atom":
-          token = {
-            type: "string",
-            value: String(token.value),
-            match: `"${token.value}"`,
-            line: token.line
-          };
-          break;
-        case "[":
-        // Assume missing key before an array
-        case "{":
-          state.pos -= 1;
-          value = parseAny(tokens, state);
-          checkDuplicates(state, obj, {
-            type: "string",
-            value: "null",
-            match: '"null"',
-            line: token.line
-          });
-          appendPair(state, obj, "null", value);
-          return;
-        // Finished parsing this "pair"
-        case "eof":
-          return;
-        // Cannot recover
-        default:
-          return;
-      }
-    } else {
-      return;
-    }
-  }
-  checkDuplicates(state, obj, token);
-  const key = String(token.value);
-  skipColon(tokens, state);
-  value = parseAny(tokens, state);
-  appendPair(state, obj, key, value);
-}
-function parseElement(tokens, state, arr) {
-  const key = arr.length;
-  const value = parseAny(tokens, state);
-  arr[key] = state.reviver ? state.reviver(String(key), value) : value;
-}
-function parseObject(tokens, state) {
-  const obj = {};
-  return parseMany(tokens, state, obj, {
-    skip: [":", "}"],
-    // Initially skip over colon or closing brace (for empty/tolerant cases)
-    elementParser: parsePair,
-    // Use parsePair to parse each key-value element
-    elementName: "string key",
-    // Expected element type for errors
-    endSymbol: "}"
-    // The closing token for an object
-  });
-}
-function parseArray(tokens, state) {
-  const arr = [];
-  return parseMany(tokens, state, arr, {
-    skip: ["]"],
-    // Initially skip over closing bracket (for empty/tolerant cases)
-    elementParser: parseElement,
-    // Use parseElement to parse each array item
-    elementName: "json value",
-    // Expected element type for errors
-    endSymbol: "]"
-    // The closing token for an array
-  });
-}
-function handleInvalidToken(token, state, opts, result) {
-  raiseUnexpected(state, token, `',' or '${opts.endSymbol}'`);
-  if (state.tolerant) {
-    if (token.type === "eof") {
-      return result;
-    }
-    state.pos -= 1;
-    return null;
-  }
-  return result;
-}
-function handleCommaToken(params) {
-  const { token, tokens, state, opts, result } = params;
-  const nextToken = tokens[state.pos];
-  if (state.tolerant && nextToken && nextToken.type === opts.endSymbol) {
-    raiseError(state, token, `Trailing comma before '${opts.endSymbol}'`);
-    popToken(tokens, state);
-    return result;
-  }
-  opts.elementParser(tokens, state, result);
-  return null;
-}
-function parseManyInitialElement(tokens, state, result, opts) {
-  const token = skipPunctuation(tokens, state, opts.skip);
-  if (token.type === "eof") {
-    raiseUnexpected(state, token, `'${opts.endSymbol}' or ${opts.elementName}`);
-    return result;
-  }
-  if (token.type === opts.endSymbol) {
-    return result;
-  }
-  state.pos -= 1;
-  opts.elementParser(tokens, state, result);
-  return;
-}
-function parseManyProcessToken(params) {
-  const { token, tokens, state, opts, result } = params;
-  if (token.type !== opts.endSymbol && token.type !== ",") {
-    const handledResult = handleInvalidToken(token, state, opts, result);
-    if (handledResult !== null) {
-      return handledResult;
-    }
-  }
-  if (token.type === opts.endSymbol) {
-    return result;
-  }
-  if (token.type === ",") {
-    const handledResult = handleCommaToken({
-      token,
-      tokens,
-      state,
-      opts,
-      result
-    });
-    if (handledResult !== null) {
-      return handledResult;
-    }
-    return;
-  }
-  opts.elementParser(tokens, state, result);
-  return;
-}
-function parseMany(tokens, state, result, opts) {
-  const initialResult = parseManyInitialElement(tokens, state, result, opts);
-  if (initialResult !== void 0) {
-    return initialResult;
-  }
-  while (true) {
-    const token = popToken(tokens, state);
-    const processedResult = parseManyProcessToken({
-      token,
-      tokens,
-      state,
-      opts,
-      result
-    });
-    if (processedResult !== void 0) {
-      return processedResult;
-    }
-  }
-}
-function endChecks(tokens, state, ret) {
-  if (state.pos < tokens.length) {
-    if (state.tolerant) {
-      skipPunctuation(tokens, state);
-    }
-    if (state.pos < tokens.length) {
-      raiseError(
-        state,
-        tokens[state.pos],
-        `Unexpected token: ${strToken(tokens[state.pos])}, expected end-of-input`
-      );
-    }
-  }
-  if (state.tolerant && state.warnings.length > 0) {
-    const message = state.warnings.length === 1 ? state.warnings[0].message : `${state.warnings.length} parse warnings`;
-    const err = new SyntaxError(message);
-    err.line = state.warnings[0].line;
-    err.warnings = state.warnings;
-    err.obj = ret;
-    throw err;
-  }
-}
-function parseAny(tokens, state, end = false) {
-  const token = skipPunctuation(tokens, state);
-  let ret;
-  if (token.type === "eof") {
-    if (end) {
-      raiseUnexpected(state, token, "json value");
-    }
-    raiseUnexpected(state, token, "json value");
-    return;
-  }
-  switch (token.type) {
-    case "{":
-      ret = parseObject(tokens, state);
-      break;
-    case "[":
-      ret = parseArray(tokens, state);
-      break;
-    case "string":
-    // String literal
-    case "number":
-    // Number literal
-    case "atom":
-      ret = token.value;
-      break;
-    default:
-      raiseUnexpected(state, token, "json value");
-      if (state.tolerant) {
-        ret = null;
-      } else {
-        return;
-      }
-  }
-  if (end) {
-    ret = state.reviver ? state.reviver("", ret) : ret;
-    endChecks(tokens, state, ret);
-  }
-  return ret;
-}
-function normalizeParseOptions(optsOrReviver) {
-  var _a;
-  let options = {};
-  if (typeof optsOrReviver === "function") {
-    options.reviver = optsOrReviver;
-  } else if (optsOrReviver !== null && typeof optsOrReviver === "object") {
-    options = { ...optsOrReviver };
-  } else if (optsOrReviver !== void 0) {
-    throw new TypeError(
-      "Second argument must be a reviver function or an options object."
-    );
-  }
-  if (options.relaxed === void 0) {
-    if (options.warnings === true || options.tolerant === true) {
-      options.relaxed = true;
-    } else if (options.warnings === false && options.tolerant === false) {
-      options.relaxed = false;
-    } else {
-      options.relaxed = true;
-    }
-  }
-  options.tolerant = options.tolerant || options.warnings;
-  options.duplicate = (_a = options.duplicate) != null ? _a : false;
-  return options;
-}
-function createParseState(options) {
-  var _a, _b;
-  return {
-    pos: 0,
-    reviver: options.reviver,
-    tolerant: (_a = options.tolerant) != null ? _a : false,
-    duplicate: (_b = options.duplicate) != null ? _b : false,
-    warnings: []
-  };
-}
-function parseWithCustomParser(text, options) {
-  const lexerToUse = options.relaxed ? lexer : strictLexer;
-  let tokens = lexerToUse(text);
-  if (options.relaxed) {
-    tokens = stripTrailingComma(tokens);
-  }
-  tokens = tokens.filter((token) => token.type !== " ");
-  const state = createParseState(options);
-  return parseAny(tokens, state, true);
-}
-function parseWithTransform(text, options) {
-  let tokens = lexer(text);
-  tokens = stripTrailingComma(tokens);
-  const newtext = tokens.reduce((str, token) => str + token.match, "");
-  return JSON.parse(
-    newtext,
-    options.reviver
-  );
-}
-function parse2(text, optsOrReviver) {
-  const options = normalizeParseOptions(optsOrReviver);
-  if (!(options.relaxed || options.warnings || options.tolerant) && options.duplicate) {
-    return JSON.parse(
-      text,
-      options.reviver
-    );
-  }
-  if (options.warnings || options.tolerant || !options.duplicate) {
-    return parseWithCustomParser(text, options);
-  }
-  return parseWithTransform(text, options);
-}
-
 // src/core/protocols/json-protocol.ts
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a, _b;
   try {
-    const parsedToolCall = parse2(toolCallJson);
+    const parsedToolCall = (0, import_rjson.parse)(toolCallJson);
     processedElements.push({
       type: "tool-call",
       toolCallId: generateId(),
@@ -1431,7 +389,7 @@ function emitToolCall(context) {
   var _a, _b;
   const { state, controller, toolCallStart, toolCallEnd, options } = context;
   try {
-    const parsedToolCall = parse2(state.currentToolCallJson);
+    const parsedToolCall = (0, import_rjson.parse)(state.currentToolCallJson);
     closeTextBlock(state, controller);
     controller.enqueue({
       type: "tool-call",
@@ -1542,8 +500,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"
@@ -1602,8 +560,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);
@@ -1616,98 +574,56 @@ var jsonProtocol = ({
 });
 
 // src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
 function isTCMProtocolFactory(protocol) {
   return typeof protocol === "function";
 }
 
 // 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_REGEX3 = /\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,
@@ -1715,51 +631,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);
   }
@@ -1798,11 +690,11 @@ function consumeClosingTag(text, lt) {
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX3.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);
@@ -1811,7 +703,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -1840,11 +732,11 @@ function nextTagToken(text, fromPos) {
   if (next === "/") {
     const closing = consumeClosingTag(text, lt);
     let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX3.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);
@@ -1861,49 +753,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;
 }
@@ -1980,16 +913,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,
@@ -1997,11 +934,10 @@ function processToolCallInBuffer(params) {
     options,
     ctrl: controller,
     flushText,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   });
   return {
-    buffer: buffer.substring(endIdx + endTag.length),
+    buffer: remainder,
     currentToolCall: null,
     shouldBreak: false
   };
@@ -2014,8 +950,7 @@ function processNoToolCallInBuffer(params) {
     flushText,
     tools,
     options,
-    pipelineConfig,
-    maxReparses,
+    parseOptions,
     setBuffer
   } = params;
   const {
@@ -2050,8 +985,7 @@ function processNoToolCallInBuffer(params) {
       options,
       ctrl: controller,
       flushText,
-      pipelineConfig,
-      maxReparses
+      parseOptions
     });
     return {
       buffer: newBuffer2,
@@ -2070,7 +1004,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();
@@ -2083,8 +1017,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           controller,
           flushText,
           setBuffer,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -2099,8 +1032,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           flushText,
           tools,
           options,
-          pipelineConfig,
-          maxReparses,
+          parseOptions,
           setBuffer
         });
         setBuffer(result.buffer);
@@ -2117,43 +1049,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 || []);
@@ -2167,7 +1068,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
@@ -2188,14 +1089,13 @@ var xmlProtocol = (protocolOptions) => {
             text: text.substring(currentIndex, tc.startIndex)
           });
         }
-        processToolCallWithPipeline({
+        processToolCall({
           toolCall: tc,
           tools,
           options,
           text,
           processedElements,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         currentIndex = tc.endIndex;
       }
@@ -2236,8 +1136,7 @@ var xmlProtocol = (protocolOptions) => {
         options,
         toolNames,
         flushText,
-        pipelineConfig,
-        maxReparses
+        parseOptions
       );
       return new TransformStream({
         transform(chunk, controller) {
@@ -2287,8 +1186,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_REGEX4 = /\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;
@@ -2305,11 +1204,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX4.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);
@@ -2325,11 +1224,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX4.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);
@@ -2338,7 +1237,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -2820,15 +1719,30 @@ function decodeOriginalTools(originalTools) {
     })
   );
 }
+function extractToolNamesFromOriginalTools(originalTools) {
+  return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
+}
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
   return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
 }
 
+// src/core/utils/type-guards.ts
+function isToolResultPart(content) {
+  if (!content || typeof content !== "object") {
+    return false;
+  }
+  const c = content;
+  return c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+}
+function hasInputProperty(obj) {
+  return typeof obj === "object" && obj !== null && "input" in 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 {
@@ -2990,7 +1904,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 : {})
@@ -3654,20 +2568,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,