@ai-sdk-tool/parser 3.1.1 → 3.1.3

package/dist/index.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-
@@ -59,11 +60,8 @@ __export(src_exports, {
   mergePipelineConfigs: () => mergePipelineConfigs,
   normalizeCloseTagsHeuristic: () => normalizeCloseTagsHeuristic,
   originalToolsSchema: () => originalToolsSchema,
-  parse: () => parse2,
   repairAgainstSchemaHeuristic: () => repairAgainstSchemaHeuristic,
-  stringify: () => stringify,
   toolChoiceStream: () => toolChoiceStream,
-  transform: () => transform,
   transformParams: () => transformParams,
   wrapGenerate: () => wrapGenerate,
   wrapStream: () => wrapStream,
@@ -73,6 +71,7 @@ __export(src_exports, {
   yamlToolMiddleware: () => yamlToolMiddleware
 });
 module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@ai-sdk-tool/rjson"), module.exports);
 
 // src/core/heuristics/engine.ts
 function applyRawSegmentUpdate(current, result) {
@@ -99,12 +98,12 @@ function applyWarningsUpdate(current, result) {
   }
   return current;
 }
-function attemptReparse(current, result, reparseCount, maxReparses, parse4) {
+function attemptReparse(current, result, reparseCount, maxReparses, parse3) {
   if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
     return { state: current, newCount: reparseCount };
   }
   try {
-    const reparsed = parse4(result.rawSegment, current.schema);
+    const reparsed = parse3(result.rawSegment, current.schema);
     return {
       state: { ...current, parsed: reparsed, errors: [] },
       newCount: reparseCount + 1
@@ -541,6 +540,9 @@ function extractStepStatusFromString(normXml) {
   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/;
 function normalizeBooleanString(value) {
@@ -724,676 +726,11 @@ function escapeRegExp2(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 transform(text) {
-  let tokens = lexer(text);
-  tokens = stripTrailingComma(tokens);
-  return tokens.reduce((str, token) => str + token.match, "");
-}
-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);
-}
-function stringifyPair(obj, key) {
-  return `${JSON.stringify(key)}:${stringify(obj[key])}`;
-}
-function stringify(obj) {
-  const type = typeof obj;
-  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
-    return JSON.stringify(obj);
-  }
-  if (type === "undefined") {
-    return "null";
-  }
-  if (Array.isArray(obj)) {
-    const elements = obj.map(stringify).join(",");
-    return `[${elements}]`;
-  }
-  if (type === "object") {
-    const keys = Object.keys(obj);
-    keys.sort();
-    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
-    return `{${pairs}}`;
-  }
-  return "null";
-}
-
 // 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(),
@@ -1521,7 +858,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",
@@ -1717,7 +1054,7 @@ function isTCMProtocolFactory(protocol) {
 var import_rxml2 = require("@ai-sdk-tool/rxml");
 var defaultPipelineConfig2 = defaultPipelineConfig;
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX3 = /\s/;
+var WHITESPACE_REGEX2 = /\s/;
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -1891,7 +1228,7 @@ 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_REGEX2.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
@@ -1904,7 +1241,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -1933,7 +1270,7 @@ 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_REGEX2.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
@@ -2262,7 +1599,8 @@ var xmlProtocol = (protocolOptions) => {
       }
       return (0, import_rxml2.stringify)(toolCall.toolName, args, {
         suppressEmptyNode: false,
-        format: false
+        format: true,
+        minimalEscaping: true
       });
     },
     parseGeneratedText({ text, tools, options }) {
@@ -2380,7 +1718,7 @@ 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 WHITESPACE_REGEX3 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -2397,7 +1735,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX4.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX3.test(text[p])) {
         p++;
       }
       const nameStart = p;
@@ -2417,7 +1755,7 @@ 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_REGEX3.test(text[p])) {
         p++;
       }
       const nameStart = p;
@@ -2430,7 +1768,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -3837,17 +3175,15 @@ var yamlToolMiddleware = createToolMiddleware({
   mergePipelineConfigs,
   normalizeCloseTagsHeuristic,
   originalToolsSchema,
-  parse,
   repairAgainstSchemaHeuristic,
-  stringify,
   toolChoiceStream,
-  transform,
   transformParams,
   wrapGenerate,
   wrapStream,
   xmlProtocol,
   xmlToolMiddleware,
   yamlProtocol,
-  yamlToolMiddleware
+  yamlToolMiddleware,
+  ...require("@ai-sdk-tool/rjson")
 });
 //# sourceMappingURL=index.cjs.map