@ai-sdk-tool/parser 3.2.1 → 3.3.1

package/dist/index.cjs

@@ -17,7 +17,6 @@ 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-
@@ -52,7 +51,10 @@ __export(src_exports, {
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
   originalToolsSchema: () => originalToolsSchema,
+  parse: () => parse,
+  stringify: () => stringify,
   toolChoiceStream: () => toolChoiceStream,
+  transform: () => transform,
   transformParams: () => transformParams,
   wrapGenerate: () => wrapGenerate,
   wrapStream: () => wrapStream,
@@ -62,10 +64,671 @@ __export(src_exports, {
   yamlToolMiddleware: () => yamlToolMiddleware
 });
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("@ai-sdk-tool/rjson"), module.exports);
 
-// src/core/protocols/json-protocol.ts
-var import_rjson = require("@ai-sdk-tool/rjson");
+// src/rjson/index.ts
+var WHITESPACE_TEST_REGEX = /\s/;
+var WHITESPACE_REGEX = /^\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_REGEX, 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 parse(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/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -254,7 +917,7 @@ function escapeRegExp(literal) {
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a, _b;
   try {
-    const parsedToolCall = (0, import_rjson.parse)(toolCallJson);
+    const parsedToolCall = parse(toolCallJson);
     processedElements.push({
       type: "tool-call",
       toolCallId: generateId(),
@@ -324,260 +987,2847 @@ function closeTextBlock(state, controller) {
     state.hasEmittedTextStart = false;
   }
 }
-function emitIncompleteToolCall(state, controller, toolCallStart) {
-  if (!state.currentToolCallJson) {
-    return;
+function emitIncompleteToolCall(state, controller, toolCallStart) {
+  if (!state.currentToolCallJson) {
+    return;
+  }
+  logParseFailure({
+    phase: "stream",
+    reason: "Incomplete streaming tool call segment emitted as text",
+    snippet: `${toolCallStart}${state.currentToolCallJson}`
+  });
+  const errorId = generateId();
+  const errorContent = `${toolCallStart}${state.currentToolCallJson}`;
+  controller.enqueue({
+    type: "text-start",
+    id: errorId
+  });
+  controller.enqueue({
+    type: "text-delta",
+    id: errorId,
+    delta: errorContent
+  });
+  controller.enqueue({
+    type: "text-end",
+    id: errorId
+  });
+  state.currentToolCallJson = "";
+}
+function handleFinishChunk(state, controller, toolCallStart, chunk) {
+  if (state.buffer.length > 0) {
+    flushBuffer(state, controller, toolCallStart);
+  }
+  closeTextBlock(state, controller);
+  emitIncompleteToolCall(state, controller, toolCallStart);
+  controller.enqueue(chunk);
+}
+function publishText(text, state, controller) {
+  if (state.isInsideToolCall) {
+    closeTextBlock(state, controller);
+    state.currentToolCallJson += text;
+  } else if (text.length > 0) {
+    if (!state.currentTextId) {
+      state.currentTextId = generateId();
+      controller.enqueue({
+        type: "text-start",
+        id: state.currentTextId
+      });
+      state.hasEmittedTextStart = true;
+    }
+    controller.enqueue({
+      type: "text-delta",
+      id: state.currentTextId,
+      delta: text
+    });
+  }
+}
+function emitToolCall(context) {
+  var _a, _b;
+  const { state, controller, toolCallStart, toolCallEnd, options } = context;
+  try {
+    const parsedToolCall = parse(state.currentToolCallJson);
+    closeTextBlock(state, controller);
+    controller.enqueue({
+      type: "tool-call",
+      toolCallId: generateId(),
+      toolName: parsedToolCall.name,
+      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+    });
+  } catch (error) {
+    logParseFailure({
+      phase: "stream",
+      reason: "Failed to parse streaming tool call JSON segment",
+      snippet: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`,
+      error
+    });
+    const errorId = generateId();
+    const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
+    controller.enqueue({
+      type: "text-start",
+      id: errorId
+    });
+    controller.enqueue({
+      type: "text-delta",
+      id: errorId,
+      delta: errorContent
+    });
+    controller.enqueue({
+      type: "text-end",
+      id: errorId
+    });
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+      options,
+      "Could not process streaming JSON tool call; emitting original text.",
+      {
+        toolCall: errorContent
+      }
+    );
+  }
+}
+function processTagMatch(context) {
+  const { state } = context;
+  if (state.isInsideToolCall) {
+    emitToolCall(context);
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = false;
+  } else {
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = true;
+  }
+}
+function processBufferTags(context) {
+  const { state, controller, toolCallStart, toolCallEnd } = context;
+  let startIndex = getPotentialStartIndex(
+    state.buffer,
+    state.isInsideToolCall ? toolCallEnd : toolCallStart
+  );
+  while (startIndex != null) {
+    const tag = state.isInsideToolCall ? toolCallEnd : toolCallStart;
+    if (startIndex + tag.length > state.buffer.length) {
+      break;
+    }
+    publishText(state.buffer.slice(0, startIndex), state, controller);
+    state.buffer = state.buffer.slice(startIndex + tag.length);
+    processTagMatch(context);
+    startIndex = getPotentialStartIndex(
+      state.buffer,
+      state.isInsideToolCall ? toolCallEnd : toolCallStart
+    );
+  }
+}
+function handlePartialTag(state, controller, toolCallStart) {
+  if (state.isInsideToolCall) {
+    return;
+  }
+  const potentialIndex = getPotentialStartIndex(state.buffer, toolCallStart);
+  if (potentialIndex != null && potentialIndex + toolCallStart.length > state.buffer.length) {
+    publishText(state.buffer.slice(0, potentialIndex), state, controller);
+    state.buffer = state.buffer.slice(potentialIndex);
+  } else {
+    publishText(state.buffer, state, controller);
+    state.buffer = "";
+  }
+}
+var jsonProtocol = ({
+  toolCallStart = "<tool_call>",
+  toolCallEnd = "</tool_call>"
+} = {}) => ({
+  formatTools({
+    tools,
+    toolSystemPromptTemplate
+  }) {
+    return toolSystemPromptTemplate(tools || []);
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    if (toolCall.input != null) {
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = toolCall.input;
+      }
+    }
+    return `${toolCallStart}${JSON.stringify({
+      name: toolCall.toolName,
+      arguments: args
+    })}${toolCallEnd}`;
+  },
+  parseGeneratedText({
+    text,
+    options
+  }) {
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const toolCallRegex = new RegExp(
+      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
+      "gs"
+    );
+    const processedElements = [];
+    let currentIndex = 0;
+    let match = toolCallRegex.exec(text);
+    while (match !== null) {
+      currentIndex = processMatchedToolCall({
+        match,
+        text,
+        currentIndex,
+        processedElements,
+        options
+      });
+      match = toolCallRegex.exec(text);
+    }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      addTextSegment(remainingText, processedElements);
+    }
+    return processedElements;
+  },
+  createStreamParser({
+    options
+  }) {
+    const state = {
+      isInsideToolCall: false,
+      buffer: "",
+      currentToolCallJson: "",
+      currentTextId: null,
+      hasEmittedTextStart: false
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
+        if (chunk.type === "finish") {
+          handleFinishChunk(state, controller, toolCallStart, chunk);
+          return;
+        }
+        if (chunk.type !== "text-delta") {
+          controller.enqueue(chunk);
+          return;
+        }
+        const textContent = (_a = chunk.delta) != null ? _a : "";
+        state.buffer += textContent;
+        processBufferTags({
+          state,
+          controller,
+          toolCallStart,
+          toolCallEnd,
+          options
+        });
+        handlePartialTag(state, controller, toolCallStart);
+      }
+    });
+  },
+  extractToolCallSegments({ text }) {
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
+    const segments = [];
+    let m = regex.exec(text);
+    while (m != null) {
+      segments.push(m[0]);
+      m = regex.exec(text);
+    }
+    return segments;
+  }
+});
+
+// src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+function isTCMProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
+// src/rxml/errors/types.ts
+var RXMLParseError = class extends Error {
+  constructor(message, cause, line, column) {
+    super(message);
+    this.name = "RXMLParseError";
+    this.cause = cause;
+    this.line = line;
+    this.column = column;
+  }
+};
+var RXMLDuplicateStringTagError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RXMLDuplicateStringTagError";
+  }
+};
+var RXMLCoercionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "RXMLCoercionError";
+    this.cause = cause;
+  }
+};
+var RXMLStringifyError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "RXMLStringifyError";
+    this.cause = cause;
+  }
+};
+
+// src/rxml/core/types.ts
+var CharCodes = {
+  OPEN_BRACKET: "<".charCodeAt(0),
+  CLOSE_BRACKET: ">".charCodeAt(0),
+  MINUS: "-".charCodeAt(0),
+  SLASH: "/".charCodeAt(0),
+  EXCLAMATION: "!".charCodeAt(0),
+  QUESTION: "?".charCodeAt(0),
+  SINGLE_QUOTE: "'".charCodeAt(0),
+  DOUBLE_QUOTE: '"'.charCodeAt(0),
+  OPEN_CORNER_BRACKET: "[".charCodeAt(0),
+  CLOSE_CORNER_BRACKET: "]".charCodeAt(0),
+  SPACE: " ".charCodeAt(0),
+  TAB: "	".charCodeAt(0),
+  NEWLINE: "\n".charCodeAt(0),
+  CARRIAGE_RETURN: "\r".charCodeAt(0)
+};
+var DEFAULT_NO_CHILD_NODES = [
+  "img",
+  "br",
+  "input",
+  "meta",
+  "link",
+  "hr",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var NAME_SPACER = "\r\n	>/= ";
+
+// src/rxml/utils/helpers.ts
+var NAME_START_CHAR_REGEX = /[A-Za-z_:]/;
+var NAME_CHAR_REGEX = /[A-Za-z0-9_.:-]/;
+function isNameStartChar(ch) {
+  return NAME_START_CHAR_REGEX.test(ch);
+}
+function isNameChar(ch) {
+  return NAME_CHAR_REGEX.test(ch);
+}
+function skipQuoted(s, i) {
+  const quote = s[i];
+  let pos = i + 1;
+  while (pos < s.length) {
+    const ch = s[pos];
+    if (ch === "\\") {
+      pos += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return pos + 1;
+    }
+    pos += 1;
+  }
+  return pos;
+}
+function parseName(s, pos) {
+  const start = pos;
+  let currentPos = pos;
+  while (NAME_SPACER.indexOf(s[currentPos]) === -1 && s[currentPos]) {
+    currentPos += 1;
+  }
+  return { name: s.slice(start, currentPos), newPos: currentPos };
+}
+function parseString(s, pos) {
+  const startChar = s[pos];
+  const startPos = pos + 1;
+  const endPos = s.indexOf(startChar, startPos);
+  if (endPos === -1) {
+    const tagEnd = s.indexOf(">", startPos);
+    if (tagEnd !== -1) {
+      return { value: s.slice(startPos, tagEnd), newPos: tagEnd };
+    }
+    return { value: s.slice(startPos), newPos: s.length };
+  }
+  return { value: s.slice(startPos, endPos), newPos: endPos + 1 };
+}
+function getLineColumn(s, pos) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < pos && i < s.length; i += 1) {
+    if (s[i] === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function escapeXmlMinimalText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/]]>/g, "]]&gt;");
+}
+function escapeXmlMinimalAttr(value, wrapper = '"') {
+  let escaped = value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+  if (wrapper === '"') {
+    escaped = escaped.replace(/"/g, "&quot;");
+  } else {
+    escaped = escaped.replace(/'/g, "&apos;");
+  }
+  return escaped;
+}
+function unescapeXml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/rxml/builders/stringify.ts
+function stringify2(rootTag, obj, options = {}) {
+  var _a, _b, _c, _d, _e;
+  try {
+    const format = (_a = options.format) != null ? _a : true;
+    const declaration = (_b = options.declaration) != null ? _b : false;
+    const minimalEscaping = (_c = options.minimalEscaping) != null ? _c : false;
+    const suppressEmptyNode = (_d = options.suppressEmptyNode) != null ? _d : false;
+    const strictBooleanAttributes = (_e = options.strictBooleanAttributes) != null ? _e : false;
+    let result = "";
+    if (declaration) {
+      result += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    }
+    result += stringifyValue(rootTag, obj, {
+      depth: 0,
+      format,
+      suppressEmptyNode,
+      minimalEscaping,
+      strictBooleanAttributes
+    });
+    if (result.endsWith("\n")) {
+      return result.slice(0, -1);
+    }
+    return result;
+  } catch (error) {
+    throw new RXMLStringifyError("Failed to stringify XML", error);
+  }
+}
+function escapeContent(content, minimalEscaping) {
+  return minimalEscaping ? escapeXmlMinimalText(content) : escapeXml(content);
+}
+function createSelfClosingTag(tagName, indent, newline) {
+  return `${indent}<${tagName}/>${newline}`;
+}
+function createTextElement(tagName, content, indent, newline) {
+  return `${indent}<${tagName}>${content}</${tagName}>${newline}`;
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function stringifyPrimitive(tagName, value, context, format) {
+  const { minimalEscaping, suppressEmptyNode } = context;
+  const content = escapeContent(String(value), minimalEscaping);
+  if (content === "" && suppressEmptyNode) {
+    return "";
+  }
+  return createTextElement(tagName, content, format.indent, format.newline);
+}
+function stringifyArray(tagName, value, context) {
+  let result = "";
+  for (const item of value) {
+    result += stringifyValue(tagName, item, context);
+  }
+  return result;
+}
+function stringifyValue(tagName, value, context) {
+  const { format, suppressEmptyNode, minimalEscaping } = context;
+  const indent = format ? "  ".repeat(context.depth) : "";
+  const newline = format ? "\n" : "";
+  if (value === null || value === void 0) {
+    if (suppressEmptyNode) {
+      return "";
+    }
+    return createSelfClosingTag(tagName, indent, newline);
+  }
+  if (isPrimitive(value)) {
+    return stringifyPrimitive(tagName, value, context, { indent, newline });
+  }
+  if (Array.isArray(value)) {
+    return stringifyArray(tagName, value, context);
+  }
+  if (typeof value === "object") {
+    return stringifyObject(tagName, value, context);
+  }
+  const content = escapeContent(String(value), minimalEscaping);
+  if (content === "" && suppressEmptyNode) {
+    return "";
+  }
+  return createTextElement(tagName, content, indent, newline);
+}
+function extractObjectParts(obj) {
+  const attributes = {};
+  const elements = {};
+  let textContent;
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("@")) {
+      attributes[key.substring(1)] = value;
+    } else if (key === "#text" || key === "_text") {
+      textContent = String(value);
+    } else if (key === "_attributes") {
+      if (typeof value === "object" && value !== null) {
+        Object.assign(attributes, value);
+      }
+    } else {
+      elements[key] = value;
+    }
+  }
+  return { attributes, elements, textContent };
+}
+function formatAttribute(attrName, attrValue, minimalEscaping, strictBooleanAttributes) {
+  if (attrValue === null) {
+    return strictBooleanAttributes ? ` ${attrName}="${attrName}"` : ` ${attrName}`;
+  }
+  const valueStr = String(attrValue);
+  if (valueStr.indexOf('"') === -1) {
+    const escaped2 = minimalEscaping ? escapeXmlMinimalAttr(valueStr, '"') : escapeXml(valueStr);
+    return ` ${attrName}="${escaped2}"`;
+  }
+  const escaped = minimalEscaping ? escapeXmlMinimalAttr(valueStr, "'") : escapeXml(valueStr);
+  return ` ${attrName}='${escaped}'`;
+}
+function buildOpeningTag(tagName, attributes, context) {
+  let openTag = `<${tagName}`;
+  const { minimalEscaping, strictBooleanAttributes } = context;
+  for (const [attrName, attrValue] of Object.entries(attributes)) {
+    openTag += formatAttribute(
+      attrName,
+      attrValue,
+      minimalEscaping,
+      strictBooleanAttributes
+    );
+  }
+  return openTag;
+}
+function stringifyTextOnlyContent(options) {
+  const { tagName, textContent, openTag, format, minimalEscaping } = options;
+  const content = escapeContent(textContent, minimalEscaping);
+  return `${format.indent}${openTag}${content}</${tagName}>${format.newline}`;
+}
+function stringifyComplexContent(tagName, parts, context, options) {
+  const { format, minimalEscaping, depth } = context;
+  const { textContent, elements } = parts;
+  const hasElements = Object.keys(elements).length > 0;
+  let result = `${options.indent}${options.openTag}`;
+  if (textContent) {
+    const content = escapeContent(textContent, minimalEscaping);
+    result += format ? `${options.newline}${options.childIndent}${content}` : content;
+  }
+  if (hasElements) {
+    if (format) {
+      result += options.newline;
+    }
+    for (const [elementName, elementValue] of Object.entries(elements)) {
+      result += stringifyValue(elementName, elementValue, {
+        ...context,
+        depth: depth + 1
+      });
+    }
+    if (format) {
+      result += options.indent;
+    }
+  }
+  result += `</${tagName}>${options.newline}`;
+  return result;
+}
+function stringifyObject(tagName, obj, context) {
+  const { depth, format, suppressEmptyNode } = context;
+  const indent = format ? "  ".repeat(depth) : "";
+  const newline = format ? "\n" : "";
+  const childIndent = format ? "  ".repeat(depth + 1) : "";
+  const parts = extractObjectParts(obj);
+  const openTag = buildOpeningTag(tagName, parts.attributes, context);
+  const hasElements = Object.keys(parts.elements).length > 0;
+  const hasTextContent = parts.textContent !== void 0 && parts.textContent !== "";
+  if (!(hasElements || hasTextContent)) {
+    if (suppressEmptyNode) {
+      return "";
+    }
+    return `${indent}${openTag}/>${newline}`;
+  }
+  const fullOpenTag = `${openTag}>`;
+  if (!hasElements && hasTextContent && parts.textContent) {
+    return stringifyTextOnlyContent({
+      tagName,
+      textContent: parts.textContent,
+      openTag: fullOpenTag,
+      format: { indent, newline },
+      minimalEscaping: context.minimalEscaping
+    });
+  }
+  return stringifyComplexContent(tagName, parts, context, {
+    indent,
+    newline,
+    childIndent,
+    openTag: fullOpenTag
+  });
+}
+
+// src/schema-coerce/index.ts
+var NUMERIC_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
+var NEWLINE_SPLIT_REGEX = /\n+/;
+var COMMA_SPLIT_REGEX = /,\s*/;
+var DIGIT_KEY_REGEX = /^\d+$/;
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return;
+  }
+  const t = unwrapped.type;
+  if (typeof t === "string") {
+    return t;
+  }
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) {
+      if (t.includes(p)) {
+        return p;
+      }
+    }
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  return;
+}
+function schemaAllowsPropertyViaCombinators(s, key, depth) {
+  const anyOfValues = s.anyOf;
+  const oneOfValues = s.oneOf;
+  const allOfValues = s.allOf;
+  let hasCombinator = false;
+  let anyOfAllows = true;
+  let oneOfAllows = true;
+  let allOfAllows = true;
+  if (Array.isArray(anyOfValues)) {
+    hasCombinator = true;
+    anyOfAllows = anyOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(oneOfValues)) {
+    hasCombinator = true;
+    oneOfAllows = oneOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(allOfValues)) {
+    hasCombinator = true;
+    allOfAllows = allOfValues.every(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (!hasCombinator) {
+    return false;
+  }
+  return anyOfAllows && oneOfAllows && allOfAllows;
+}
+function schemaHasPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] !== false) {
+    return true;
+  }
+  const required = s.required;
+  if (Array.isArray(required) && required.includes(key)) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema !== false);
+}
+function schemaHasPropertyViaAdditional(s) {
+  const additional = s.additionalProperties;
+  if (additional === true || additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return true;
+  }
+  if (Object.hasOwn(s, "additionalProperties")) {
+    return false;
+  }
+  const type = s.type;
+  const isObjectType = type === "object" || Array.isArray(type) && type.includes("object");
+  const hasObjectKeywords = s.properties && typeof s.properties === "object" && !Array.isArray(s.properties) || s.patternProperties && typeof s.patternProperties === "object" && !Array.isArray(s.patternProperties) || Array.isArray(s.required) && s.required.length > 0;
+  return !!(isObjectType || hasObjectKeywords);
+}
+function schemaDisallowsPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] === false) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema === false);
+}
+function schemaHasProperty(schema, key, depth = 0) {
+  if (depth > 5) {
+    return true;
+  }
+  const unwrapped = unwrapJsonSchema(schema);
+  if (schemaIsUnconstrained(unwrapped)) {
+    return true;
+  }
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return false;
+  }
+  const s = unwrapped;
+  if (schemaDisallowsPropertyDirectly(s, key)) {
+    return false;
+  }
+  if (schemaHasPropertyDirectly(s, key)) {
+    return true;
+  }
+  if (schemaHasPropertyViaAdditional(s)) {
+    return true;
+  }
+  return schemaAllowsPropertyViaCombinators(s, key, depth);
+}
+function schemaIsUnconstrained(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (unwrapped == null || unwrapped === true) {
+    return true;
+  }
+  if (typeof unwrapped !== "object" || Array.isArray(unwrapped)) {
+    return false;
+  }
+  return Object.keys(unwrapped).length === 0;
+}
+function getPatternSchemasForKey(patternProperties, key) {
+  if (!patternProperties || typeof patternProperties !== "object" || Array.isArray(patternProperties)) {
+    return [];
+  }
+  const schemas = [];
+  for (const [pattern, schema] of Object.entries(
+    patternProperties
+  )) {
+    try {
+      const regex = new RegExp(pattern);
+      if (regex.test(key)) {
+        schemas.push(schema);
+      }
+    } catch (e) {
+    }
+  }
+  return schemas;
+}
+function coerceValueForKey(value, key, unwrapped) {
+  const schemas = [];
+  const props = unwrapped.properties;
+  if (props && Object.hasOwn(props, key)) {
+    schemas.push(props[key]);
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    unwrapped.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    schemas.push(...patternSchemas);
+  }
+  if (schemas.length > 0) {
+    let out = value;
+    for (const schema of schemas) {
+      if (typeof schema === "boolean") {
+        continue;
+      }
+      out = coerceBySchema(out, schema);
+    }
+    return out;
+  }
+  const additional = unwrapped.additionalProperties;
+  if (additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return coerceBySchema(value, additional);
+  }
+  if (additional === true || additional === false) {
+    return value;
+  }
+  return coerceBySchema(value, void 0);
+}
+function coerceStringWithoutSchema(value) {
+  const s = value.trim();
+  const lower = s.toLowerCase();
+  if (lower === "true") {
+    return true;
+  }
+  if (lower === "false") {
+    return false;
+  }
+  if (NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(s);
+      return coerceBySchema(parsed, void 0);
+    } catch (e) {
+    }
+  }
+  return value;
+}
+function coerceStringToObject(s, unwrapped) {
+  try {
+    let normalized = s.replace(/'/g, '"');
+    normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
+    const obj = JSON.parse(normalized);
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      return coerceObjectToObject(obj, unwrapped);
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function coerceStringToArray(s, unwrapped) {
+  const prefixItems = Array.isArray(unwrapped.prefixItems) ? unwrapped.prefixItems : void 0;
+  const itemsSchema = unwrapped.items;
+  try {
+    const normalized = s.replace(/'/g, '"');
+    const arr = JSON.parse(normalized);
+    if (Array.isArray(arr)) {
+      if (prefixItems && arr.length === prefixItems.length) {
+        return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return arr.map((v) => coerceBySchema(v, itemsSchema));
+    }
+  } catch (e) {
+    const csv = s.includes("\n") ? s.split(NEWLINE_SPLIT_REGEX) : s.split(COMMA_SPLIT_REGEX);
+    const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+    if (prefixItems && trimmed.length === prefixItems.length) {
+      return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
+    }
+    return trimmed.map((x) => coerceBySchema(x, itemsSchema));
+  }
+  return null;
+}
+function coerceObjectToObject(value, unwrapped) {
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = coerceValueForKey(v, k, unwrapped);
+  }
+  return out;
+}
+function coerceArrayToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && value.length === prefixItems.length) {
+    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+  }
+  return value.map((v) => coerceBySchema(v, itemsSchema));
+}
+function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (Object.hasOwn(maybe, "item")) {
+    const items = maybe.item;
+    const arr = Array.isArray(items) ? items : [items];
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+  }
+  const keys = Object.keys(maybe);
+  if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
+    const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+  }
+  if (keys.length === 1) {
+    const singleKey = keys[0];
+    if (!(schemaIsUnconstrained(itemsSchema) || schemaHasProperty(itemsSchema, singleKey))) {
+      const singleValue = maybe[singleKey];
+      if (Array.isArray(singleValue)) {
+        return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+      }
+      if (singleValue && typeof singleValue === "object") {
+        return [coerceBySchema(singleValue, itemsSchema)];
+      }
+    }
+  }
+  return null;
+}
+function coercePrimitiveToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && prefixItems.length > 0) {
+    return [coerceBySchema(value, prefixItems[0])];
+  }
+  return [coerceBySchema(value, itemsSchema)];
+}
+function coerceStringToPrimitive(s, schemaType) {
+  if (schemaType === "boolean") {
+    const lower = s.toLowerCase();
+    if (lower === "true") {
+      return true;
+    }
+    if (lower === "false") {
+      return false;
+    }
+  }
+  if ((schemaType === "number" || schemaType === "integer") && NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return null;
+}
+function coerceStringValue(value, schemaType, u) {
+  const s = value.trim();
+  if (schemaType === "object") {
+    const result = coerceStringToObject(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  if (schemaType === "array") {
+    const result = coerceStringToArray(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  const primitiveResult = coerceStringToPrimitive(s, schemaType);
+  if (primitiveResult !== null) {
+    return primitiveResult;
+  }
+  return value;
+}
+function coerceArrayValue(value, prefixItems, itemsSchema) {
+  if (Array.isArray(value)) {
+    return coerceArrayToArray(value, prefixItems, itemsSchema);
+  }
+  if (value && typeof value === "object") {
+    const result = coerceObjectToArray(
+      value,
+      prefixItems,
+      itemsSchema
+    );
+    if (result !== null) {
+      return result;
+    }
+    if (getSchemaType(itemsSchema) === "array") {
+      return [value];
+    }
+    return [coerceBySchema(value, itemsSchema)];
+  }
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return coercePrimitiveToArray(value, prefixItems, itemsSchema);
+  }
+  return [value];
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      return coerceStringWithoutSchema(value);
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  const u = unwrapped;
+  if (typeof value === "string") {
+    return coerceStringValue(value, schemaType, u);
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    return coerceObjectToObject(value, u);
+  }
+  if (schemaType === "array") {
+    const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
+    const itemsSchema = u.items;
+    return coerceArrayValue(value, prefixItems, itemsSchema);
+  }
+  return value;
+}
+
+// src/rxml/schema/coercion.ts
+function getPropertySchema(toolSchema, key) {
+  const unwrapped = unwrapJsonSchema(toolSchema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return;
+  }
+  const u = unwrapped;
+  const props = u.properties;
+  if (props && Object.hasOwn(props, key)) {
+    return props[key];
+  }
+  return;
+}
+function getNodeValue(children, schema, tagName, textNodeName) {
+  if (children.length === 0) {
+    return "";
+  }
+  if (children.length === 1 && typeof children[0] === "string") {
+    return children[0];
+  }
+  return processComplexContent(
+    children,
+    getPropertySchema(schema, tagName),
+    textNodeName
+  );
+}
+function addAttributesToValue(value, attributes, textNodeName) {
+  if (Object.keys(attributes).length === 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const valueResult = { [textNodeName]: value };
+    for (const [attrName, attrValue] of Object.entries(attributes)) {
+      valueResult[`@_${attrName}`] = attrValue;
+    }
+    return valueResult;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    for (const [attrName, attrValue] of Object.entries(attributes)) {
+      value[`@_${attrName}`] = attrValue;
+    }
+  }
+  return value;
+}
+function addToResult(result, tagName, value) {
+  if (result[tagName]) {
+    if (!Array.isArray(result[tagName])) {
+      result[tagName] = [result[tagName]];
+    }
+    result[tagName].push(value);
+  } else {
+    result[tagName] = value;
+  }
+}
+function domToObject(nodes, schema, textNodeName = "#text") {
+  const result = {};
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      continue;
+    }
+    const { tagName, children, attributes } = node;
+    let value = getNodeValue(children, schema, tagName, textNodeName);
+    value = addAttributesToValue(value, attributes, textNodeName);
+    addToResult(result, tagName, value);
+  }
+  return result;
+}
+function processChildElement(child, schema, textNodeName) {
+  let childValue;
+  if (child.children.length === 0) {
+    childValue = "";
+  } else if (child.children.length === 1 && typeof child.children[0] === "string") {
+    childValue = child.children[0];
+  } else {
+    childValue = processComplexContent(
+      child.children,
+      getPropertySchema(schema, child.tagName),
+      textNodeName
+    );
+  }
+  return addAttributesToValue(childValue, child.attributes, textNodeName);
+}
+function combineContent(textContent, elements, textNodeName) {
+  const hasText = textContent.length > 0;
+  const hasElements = Object.keys(elements).length > 0;
+  if (hasText && hasElements) {
+    return {
+      [textNodeName]: textContent.join("").trim(),
+      ...elements
+    };
+  }
+  if (hasText) {
+    return textContent.join("").trim();
+  }
+  if (hasElements) {
+    return elements;
+  }
+  return "";
+}
+function processComplexContent(children, schema, textNodeName) {
+  const textContent = [];
+  const elements = {};
+  for (const child of children) {
+    if (typeof child === "string") {
+      textContent.push(child);
+    } else {
+      const childValue = processChildElement(child, schema, textNodeName);
+      addToResult(elements, child.tagName, childValue);
+    }
+  }
+  return combineContent(textContent, elements, textNodeName);
+}
+function coerceDomBySchema(domObject, schema) {
+  try {
+    return coerceBySchema(domObject, schema);
+  } catch (error) {
+    throw new RXMLCoercionError("Failed to coerce DOM object by schema", error);
+  }
+}
+function visitObjectProperties(props, collected, visit) {
+  for (const [key, propSchema] of Object.entries(props)) {
+    const t = getSchemaType(propSchema);
+    if (t === "string") {
+      collected.add(key);
+    } else if (t === "object" || t === "array") {
+      visit(propSchema);
+    }
+  }
+}
+function visitArrayItems(u, visit) {
+  const items = u.items;
+  if (items) {
+    visit(items);
+  }
+  const prefix = u.prefixItems;
+  if (Array.isArray(prefix)) {
+    for (const item of prefix) {
+      visit(item);
+    }
+  }
+}
+function getStringTypedProperties(schema) {
+  const collected = /* @__PURE__ */ new Set();
+  const visit = (s) => {
+    const unwrapped = unwrapJsonSchema(s);
+    if (!unwrapped || typeof unwrapped !== "object") {
+      return;
+    }
+    const u = unwrapped;
+    const type = getSchemaType(unwrapped);
+    if (type === "object") {
+      const props = u.properties;
+      if (props && typeof props === "object") {
+        visitObjectProperties(props, collected, visit);
+      }
+    } else if (type === "array") {
+      visitArrayItems(u, visit);
+    }
+  };
+  visit(schema);
+  return collected;
+}
+function processArrayContent(value, schema, textNodeName) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  const schemaType = getSchemaType(schema);
+  if (schemaType === "string") {
+    return value.map((item) => {
+      if (typeof item === "string") {
+        return item.trim();
+      }
+      if (item && typeof item === "object" && textNodeName in item) {
+        const textVal = item[textNodeName];
+        return typeof textVal === "string" ? textVal.trim() : String(textVal);
+      }
+      return String(item);
+    });
+  }
+  return value.map((item) => {
+    if (typeof item === "string") {
+      return item.trim();
+    }
+    if (item && typeof item === "object" && textNodeName in item) {
+      const textVal = item[textNodeName];
+      return typeof textVal === "string" ? textVal.trim() : textVal;
+    }
+    return item;
+  });
+}
+function processIndexedTuple(obj, textNodeName) {
+  const keys = Object.keys(obj);
+  const indices = keys.map((k) => Number.parseInt(k, 10)).sort((a, b) => a - b);
+  const isValidTuple = indices[0] === 0 && indices.every((val, idx) => val === idx);
+  if (!isValidTuple) {
+    return [obj];
+  }
+  const sortedKeys = keys.sort(
+    (a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10)
+  );
+  return sortedKeys.map((key) => {
+    const item = obj[key];
+    if (item && typeof item === "object" && textNodeName in item) {
+      const textVal = item[textNodeName];
+      return typeof textVal === "string" ? textVal.trim() : textVal;
+    }
+    return typeof item === "string" ? item.trim() : item;
+  });
+}
+
+// src/rxml/schema/extraction.ts
+function skipDoctype(xmlContent, i, len) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return gt === -1 ? len : gt + 1;
+}
+function skipComment(xmlContent, i, len) {
+  const close = xmlContent.indexOf("-->", i + 4);
+  return close === -1 ? len : close + 3;
+}
+function skipCdata(xmlContent, i, len) {
+  const close = xmlContent.indexOf("]]>", i + 9);
+  return close === -1 ? len : close + 3;
+}
+function skipProcessingInstruction(xmlContent, i, len) {
+  const close = xmlContent.indexOf("?>", i + 1);
+  return close === -1 ? len : close + 2;
+}
+function skipSpecialConstruct(xmlContent, i, len) {
+  const ch = xmlContent[i];
+  if (ch === "!") {
+    if (xmlContent.startsWith("!DOCTYPE", i + 1)) {
+      return skipDoctype(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("!--", i + 1)) {
+      return skipComment(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("![CDATA[", i + 1)) {
+      return skipCdata(xmlContent, i, len);
+    }
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  if (ch === "?") {
+    return skipProcessingInstruction(xmlContent, i, len);
+  }
+  return -1;
+}
+function parseTagName(xmlContent, i, len) {
+  let j = i;
+  if (j < len && isNameStartChar(xmlContent[j])) {
+    j += 1;
+    while (j < len && isNameChar(xmlContent[j])) {
+      j += 1;
+    }
+  }
+  return { name: xmlContent.slice(i, j), pos: j };
+}
+function skipToTagEnd(xmlContent, start, len) {
+  let k = start;
+  let isSelfClosing = false;
+  while (k < len) {
+    const c = xmlContent[k];
+    if (c === '"' || c === "'") {
+      k = skipQuoted(xmlContent, k);
+      continue;
+    }
+    if (c === ">") {
+      break;
+    }
+    if (c === "/" && xmlContent[k + 1] === ">") {
+      isSelfClosing = true;
+      k += 1;
+      break;
+    }
+    k += 1;
+  }
+  return { pos: k, isSelfClosing };
+}
+function processClosingTagMatch(options) {
+  const { xmlContent, nx, len, tagName, depth, nextLt } = options;
+  const tagInfo = parseTagName(xmlContent, nx + 1, len);
+  const gt = xmlContent.indexOf(">", tagInfo.pos);
+  if (tagInfo.name === tagName) {
+    const newDepth = depth - 1;
+    if (newDepth === 0) {
+      return { newPos: nextLt, newDepth, found: true };
+    }
+    return { newPos: gt === -1 ? len : gt + 1, newDepth, found: false };
+  }
+  return { newPos: gt === -1 ? len : gt + 1, newDepth: depth, found: false };
+}
+function processOpeningTagMatch(options) {
+  const { xmlContent, nx, len, tagName, depth } = options;
+  const tagInfo = parseTagName(xmlContent, nx, len);
+  const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+  const newDepth = tagInfo.name === tagName && !tagEndInfo.isSelfClosing ? depth + 1 : depth;
+  const newPos = xmlContent[tagEndInfo.pos] === ">" ? tagEndInfo.pos + 1 : tagEndInfo.pos + 1;
+  return { newPos, newDepth };
+}
+function findMatchingCloseTag(xmlContent, startPos, tagName, len) {
+  let pos = startPos;
+  let depth = 1;
+  while (pos < len) {
+    const nextLt = xmlContent.indexOf("<", pos);
+    if (nextLt === -1 || nextLt + 1 >= len) {
+      break;
+    }
+    const nx = nextLt + 1;
+    const h = xmlContent[nx];
+    const specialPos = skipSpecialConstruct(xmlContent, nx, len);
+    if (specialPos !== -1) {
+      pos = specialPos;
+      continue;
+    }
+    if (h === "/") {
+      const result = processClosingTagMatch({
+        xmlContent,
+        nx,
+        len,
+        tagName,
+        depth,
+        nextLt
+      });
+      if (result.found) {
+        return result.newPos;
+      }
+      pos = result.newPos;
+      depth = result.newDepth;
+    } else {
+      const result = processOpeningTagMatch({
+        xmlContent,
+        nx,
+        len,
+        tagName,
+        depth
+      });
+      pos = result.newPos;
+      depth = result.newDepth;
+    }
+  }
+  return -1;
+}
+function updateBestMatch(depth, bestDepth, contentStart, contentEnd) {
+  if (depth < bestDepth) {
+    return { start: contentStart, end: contentEnd, depth };
+  }
+  return null;
+}
+function processTargetTag(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len, depth, bestDepth } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    return updateBestMatch(depth, bestDepth, contentStart, contentStart);
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    return updateBestMatch(depth, bestDepth, contentStart, closePos);
+  }
+  return null;
+}
+function handleClosingTagInExtract(xmlContent, i, len, depth) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return {
+    newPos: gt === -1 ? len : gt + 1,
+    newDepth: Math.max(0, depth - 1)
+  };
+}
+function processOpeningTagInExtract(options) {
+  const { xmlContent, i, len, target, depth, bestDepth } = options;
+  const tagInfo = parseTagName(xmlContent, i, len);
+  const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+  const tagEnd = tagEndInfo.pos;
+  const isSelfClosing = tagEndInfo.isSelfClosing;
+  let bestMatch = null;
+  if (tagInfo.name === target) {
+    bestMatch = processTargetTag({
+      xmlContent,
+      tagEnd,
+      isSelfClosing,
+      target,
+      len,
+      depth,
+      bestDepth
+    });
+  }
+  return {
+    newPos: xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1,
+    newDepth: depth + (isSelfClosing ? 0 : 1),
+    bestMatch
+  };
+}
+function extractRawInner(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let bestStart = -1;
+  let bestEnd = -1;
+  let bestDepth = Number.POSITIVE_INFINITY;
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      return;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      const result2 = handleClosingTagInExtract(xmlContent, i, len, depth);
+      i = result2.newPos;
+      depth = result2.newDepth;
+      continue;
+    }
+    const result = processOpeningTagInExtract({
+      xmlContent,
+      i,
+      len,
+      target,
+      depth,
+      bestDepth
+    });
+    if (result.bestMatch) {
+      bestStart = result.bestMatch.start;
+      bestEnd = result.bestMatch.end;
+      bestDepth = result.bestMatch.depth;
+    }
+    i = result.newPos;
+    depth = result.newDepth;
+  }
+  if (bestStart !== -1) {
+    return xmlContent.slice(bestStart, bestEnd);
+  }
+  return;
+}
+function processOpeningTag(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len, ranges } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    ranges.push({ start: contentStart, end: contentStart });
+    return contentStart;
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    ranges.push({ start: contentStart, end: closePos });
+    const gt = xmlContent.indexOf(">", closePos);
+    return gt === -1 ? len : gt + 1;
+  }
+  return -1;
+}
+function handleClosingTagInFindAll(xmlContent, i, len) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return gt === -1 ? len : gt + 1;
+}
+function findAllInnerRanges(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  const ranges = [];
+  let i = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      break;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      i = handleClosingTagInFindAll(xmlContent, i, len);
+      continue;
+    }
+    const tagInfo = parseTagName(xmlContent, i, len);
+    const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+    const tagEnd = tagEndInfo.pos;
+    const isSelfClosing = tagEndInfo.isSelfClosing;
+    if (tagInfo.name !== target) {
+      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+      continue;
+    }
+    const nextPos = processOpeningTag({
+      xmlContent,
+      tagEnd,
+      isSelfClosing,
+      target,
+      len,
+      ranges
+    });
+    if (nextPos === -1) {
+      break;
+    }
+    i = nextPos;
+  }
+  return ranges;
+}
+function findTopLevelTargetRange(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    return { start: contentStart, end: contentStart };
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    return { start: contentStart, end: closePos };
+  }
+  return;
+}
+function handleClosingTagInFindFirst(xmlContent, i, len, depth) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return {
+    newPos: gt === -1 ? len : gt + 1,
+    newDepth: Math.max(0, depth - 1)
+  };
+}
+function findFirstTopLevelRange(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      return;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      const result = handleClosingTagInFindFirst(xmlContent, i, len, depth);
+      i = result.newPos;
+      depth = result.newDepth;
+      continue;
+    }
+    const tagInfo = parseTagName(xmlContent, i, len);
+    const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+    const tagEnd = tagEndInfo.pos;
+    const isSelfClosing = tagEndInfo.isSelfClosing;
+    if (depth === 0 && tagInfo.name === target) {
+      return findTopLevelTargetRange({
+        xmlContent,
+        tagEnd,
+        isSelfClosing,
+        target,
+        len
+      });
+    }
+    i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+    depth += isSelfClosing ? 0 : 1;
+  }
+  return;
+}
+function isPositionExcluded(pos, excludeRanges) {
+  if (!excludeRanges || excludeRanges.length === 0) {
+    return false;
+  }
+  for (const r of excludeRanges) {
+    if (pos >= r.start && pos < r.end) {
+      return true;
+    }
+  }
+  return false;
+}
+function skipCommentInCounting(xmlContent, i, len) {
+  const close = xmlContent.indexOf("-->", i + 4);
+  return close === -1 ? len : close + 3;
+}
+function skipCdataInCounting(xmlContent, i, len) {
+  const close = xmlContent.indexOf("]]>", i + 9);
+  return close === -1 ? len : close + 3;
+}
+function skipSpecialInCounting(xmlContent, ch, i, len) {
+  if (ch === "!") {
+    if (xmlContent.startsWith("!--", i + 1)) {
+      return skipCommentInCounting(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("![CDATA[", i + 1)) {
+      return skipCdataInCounting(xmlContent, i, len);
+    }
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  if (ch === "?") {
+    const close = xmlContent.indexOf("?>", i + 1);
+    return close === -1 ? len : close + 2;
+  }
+  if (ch === "/") {
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  return -1;
+}
+function parseAndCountTag(options) {
+  const { xmlContent, i, len, target, lt, excludeRanges } = options;
+  let j = i;
+  if (j < len && isNameStartChar(xmlContent[j])) {
+    j += 1;
+    while (j < len && isNameChar(xmlContent[j])) {
+      j += 1;
+    }
+  }
+  const name = xmlContent.slice(i, j);
+  let k = j;
+  while (k < len) {
+    const c = xmlContent[k];
+    if (c === '"' || c === "'") {
+      k = skipQuoted(xmlContent, k);
+      continue;
+    }
+    if (c === ">") {
+      break;
+    }
+    if (c === "/" && xmlContent[k + 1] === ">") {
+      k += 1;
+      break;
+    }
+    k += 1;
+  }
+  const shouldCount = name === target && !isPositionExcluded(lt, excludeRanges);
+  return { nextPos: k + 1, shouldCount };
+}
+function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst = true) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let i = 0;
+  let count = 0;
+  let skipFirstLocal = shouldSkipFirst;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) {
+      break;
+    }
+    i = lt + 1;
+    if (i >= len) {
+      break;
+    }
+    const ch = xmlContent[i];
+    const skipPos = skipSpecialInCounting(xmlContent, ch, i, len);
+    if (skipPos !== -1) {
+      i = skipPos;
+      continue;
+    }
+    const result = parseAndCountTag({
+      xmlContent,
+      i,
+      len,
+      target,
+      lt,
+      excludeRanges
+    });
+    if (result.shouldCount) {
+      if (skipFirstLocal) {
+        skipFirstLocal = false;
+      } else {
+        count += 1;
+      }
+    }
+    i = result.nextPos;
+  }
+  return count;
+}
+
+// src/rxml/core/tokenizer.ts
+var XMLTokenizer = class {
+  constructor(xmlString, options = {}) {
+    this.pos = 0;
+    this.xmlString = xmlString;
+    this.options = {
+      keepComments: false,
+      keepWhitespace: false,
+      noChildNodes: DEFAULT_NO_CHILD_NODES.slice(),
+      textNodeName: "#text",
+      throwOnDuplicateStringTags: true,
+      ...options
+    };
+    this.pos = options.pos || 0;
+  }
+  /**
+   * Handle closing tag parsing
+   */
+  handleClosingTag(tagName, children) {
+    const closeStart = this.pos + 2;
+    this.pos = this.xmlString.indexOf(">", this.pos);
+    const closeTag = this.xmlString.substring(closeStart, this.pos);
+    if (tagName && closeTag.trim() !== tagName) {
+      const { line, column } = getLineColumn(this.xmlString, this.pos);
+      throw new RXMLParseError(
+        `Unexpected close tag at line ${line}, column ${column}. Expected </${tagName}>, found </${closeTag}>`,
+        void 0,
+        line,
+        column
+      );
+    }
+    if (this.pos !== -1) {
+      this.pos += 1;
+    }
+    return children;
+  }
+  /**
+   * Check if we're at end of string and should throw unclosed tag error
+   */
+  checkUnclosedTag(tagName, consumedToEnd) {
+    if (tagName && this.pos >= this.xmlString.length && !consumedToEnd) {
+      const { line, column } = getLineColumn(this.xmlString, this.pos - 1);
+      throw new RXMLParseError(
+        `Unclosed tag at line ${line}, column ${column}. Expected closing tag </${tagName}>`,
+        void 0,
+        line,
+        column
+      );
+    }
+  }
+  /**
+   * Process special content (comments, CDATA, DOCTYPE) and track if we consumed to end
+   */
+  processSpecialContent(children) {
+    const prevPos = this.pos;
+    this.handleSpecialContent(children);
+    return this.pos >= this.xmlString.length && prevPos < this.xmlString.length;
+  }
+  /**
+   * Handle text content parsing
+   */
+  handleTextContent(children) {
+    const text = this.parseText();
+    if (this.options.keepWhitespace) {
+      if (text.length > 0) {
+        children.push(text);
+      }
+    } else {
+      const trimmed = text.trim();
+      if (trimmed.length > 0) {
+        children.push(trimmed);
+      }
+    }
+    this.pos += 1;
+  }
+  /**
+   * Handle regular element parsing
+   */
+  handleRegularElement(children) {
+    const node = this.parseNode();
+    children.push(node);
+    if (node.tagName[0] === "?") {
+      children.push(...node.children);
+      node.children = [];
+    }
+  }
+  /**
+   * Process a single child element based on the current character
+   */
+  processSingleChild(children, tagName) {
+    if (this.xmlString.charCodeAt(this.pos) !== CharCodes.OPEN_BRACKET) {
+      this.handleTextContent(children);
+      return { shouldReturn: false, consumedToEnd: false };
+    }
+    const nextChar = this.xmlString.charCodeAt(this.pos + 1);
+    if (nextChar === CharCodes.SLASH) {
+      const result = this.handleClosingTag(tagName, children);
+      if (result !== null) {
+        return { shouldReturn: true, consumedToEnd: false };
+      }
+      return { shouldReturn: false, consumedToEnd: false };
+    }
+    if (nextChar === CharCodes.EXCLAMATION) {
+      const wasConsumedToEnd = this.processSpecialContent(children);
+      return { shouldReturn: false, consumedToEnd: wasConsumedToEnd };
+    }
+    this.handleRegularElement(children);
+    return { shouldReturn: false, consumedToEnd: false };
+  }
+  /**
+   * Parse XML children recursively
+   */
+  parseChildren(tagName) {
+    const children = [];
+    let consumedToEnd = false;
+    while (this.xmlString[this.pos]) {
+      const result = this.processSingleChild(children, tagName);
+      if (result.shouldReturn) {
+        return children;
+      }
+      if (result.consumedToEnd) {
+        consumedToEnd = true;
+      }
+    }
+    this.checkUnclosedTag(tagName, consumedToEnd);
+    return children;
+  }
+  /**
+   * Check if character is whitespace
+   */
+  isWhitespace(code) {
+    return code === CharCodes.SPACE || code === CharCodes.TAB || code === CharCodes.NEWLINE || code === CharCodes.CARRIAGE_RETURN;
+  }
+  /**
+   * Skip whitespace characters
+   */
+  skipWhitespace() {
+    while (this.pos < this.xmlString.length && this.isWhitespace(this.xmlString.charCodeAt(this.pos))) {
+      this.pos += 1;
+    }
+  }
+  /**
+   * Parse attribute value
+   */
+  parseAttributeValue() {
+    if (this.pos >= this.xmlString.length || this.xmlString[this.pos] !== "=") {
+      return null;
+    }
+    this.pos += 1;
+    this.skipWhitespace();
+    const code = this.xmlString.charCodeAt(this.pos);
+    if (code === CharCodes.SINGLE_QUOTE || code === CharCodes.DOUBLE_QUOTE) {
+      const { value: parsedValue, newPos: valueEnd } = parseString(
+        this.xmlString,
+        this.pos
+      );
+      this.pos = valueEnd;
+      return parsedValue;
+    }
+    return null;
+  }
+  /**
+   * Parse single attribute
+   */
+  parseAttribute(attributes) {
+    const { name: attrName, newPos: nameEnd } = parseName(
+      this.xmlString,
+      this.pos
+    );
+    this.pos = nameEnd;
+    this.skipWhitespace();
+    const value = this.parseAttributeValue();
+    attributes[attrName] = value;
+  }
+  /**
+   * Parse all attributes
+   */
+  parseAttributes() {
+    const attributes = {};
+    while (this.xmlString.charCodeAt(this.pos) !== CharCodes.CLOSE_BRACKET && this.xmlString[this.pos]) {
+      const c = this.xmlString.charCodeAt(this.pos);
+      if (this.isWhitespace(c)) {
+        this.pos += 1;
+        continue;
+      }
+      if (c > 64 && c < 91 || c > 96 && c < 123) {
+        this.parseAttribute(attributes);
+      } else {
+        this.pos += 1;
+      }
+    }
+    return attributes;
+  }
+  /**
+   * Parse special tag content (script, style)
+   */
+  parseSpecialTagContent(_tagName, closingTag) {
+    const start = this.pos + 1;
+    this.pos = this.xmlString.indexOf(closingTag, this.pos);
+    if (this.pos === -1) {
+      const children2 = [this.xmlString.slice(start)];
+      this.pos = this.xmlString.length;
+      return children2;
+    }
+    const children = [this.xmlString.slice(start, this.pos)];
+    this.pos += closingTag.length;
+    return children;
+  }
+  /**
+   * Parse node children based on tag type
+   */
+  parseNodeChildren(tagName, isSelfClosing) {
+    var _a;
+    if (isSelfClosing) {
+      this.pos += 1;
+      return [];
+    }
+    if (tagName === "script") {
+      return this.parseSpecialTagContent(tagName, "</script>");
+    }
+    if (tagName === "style") {
+      return this.parseSpecialTagContent(tagName, "</style>");
+    }
+    if (((_a = this.options.noChildNodes) == null ? void 0 : _a.indexOf(tagName)) === -1) {
+      this.pos += 1;
+      return this.parseChildren(tagName);
+    }
+    this.pos += 1;
+    if (DEFAULT_NO_CHILD_NODES.includes(tagName)) {
+      return [];
+    }
+    const closingTag = `</${tagName}>`;
+    const closingPos = this.xmlString.indexOf(closingTag, this.pos);
+    if (closingPos !== -1) {
+      this.pos = closingPos + closingTag.length;
+    }
+    return [];
+  }
+  /**
+   * Parse a single XML node
+   */
+  parseNode() {
+    this.pos += 1;
+    const { name: tagName, newPos } = parseName(this.xmlString, this.pos);
+    this.pos = newPos;
+    const attributes = this.parseAttributes();
+    const isSelfClosing = this.xmlString.charCodeAt(this.pos - 1) === CharCodes.SLASH || tagName[0] === "?" && this.xmlString.charCodeAt(this.pos - 1) === CharCodes.QUESTION;
+    const children = this.parseNodeChildren(tagName, isSelfClosing);
+    return { tagName, attributes, children };
+  }
+  /**
+   * Parse text content until next tag
+   */
+  parseText() {
+    const start = this.pos;
+    this.pos = this.xmlString.indexOf("<", this.pos) - 1;
+    if (this.pos === -2) {
+      this.pos = this.xmlString.length;
+    }
+    return this.xmlString.slice(start, this.pos + 1);
+  }
+  /**
+   * Handle comments, CDATA, and DOCTYPE declarations
+   */
+  handleSpecialContent(children) {
+    if (this.xmlString.charCodeAt(this.pos + 2) === CharCodes.MINUS) {
+      this.handleComment(children);
+    } else if (this.xmlString.charCodeAt(this.pos + 2) === CharCodes.OPEN_CORNER_BRACKET && this.xmlString.charCodeAt(this.pos + 8) === CharCodes.OPEN_CORNER_BRACKET && this.xmlString.substr(this.pos + 3, 5).toLowerCase() === "cdata") {
+      this.handleCData(children);
+    } else {
+      this.handleDoctype(children);
+    }
+  }
+  /**
+   * Handle XML comments
+   */
+  handleComment(children) {
+    const startCommentPos = this.pos;
+    while (this.pos !== -1 && !(this.xmlString.charCodeAt(this.pos) === CharCodes.CLOSE_BRACKET && this.xmlString.charCodeAt(this.pos - 1) === CharCodes.MINUS && this.xmlString.charCodeAt(this.pos - 2) === CharCodes.MINUS)) {
+      this.pos = this.xmlString.indexOf(">", this.pos + 1);
+    }
+    if (this.pos === -1) {
+      this.pos = this.xmlString.length;
+    }
+    if (this.options.keepComments) {
+      children.push(this.xmlString.substring(startCommentPos, this.pos + 1));
+    }
+    this.pos += 1;
+  }
+  /**
+   * Handle CDATA sections
+   */
+  handleCData(children) {
+    const cdataEndIndex = this.xmlString.indexOf("]]>", this.pos);
+    if (cdataEndIndex === -1) {
+      children.push(this.xmlString.substr(this.pos + 9));
+      this.pos = this.xmlString.length;
+    } else {
+      children.push(this.xmlString.substring(this.pos + 9, cdataEndIndex));
+      this.pos = cdataEndIndex + 3;
+    }
+  }
+  /**
+   * Handle DOCTYPE declarations
+   */
+  handleDoctype(children) {
+    const startDoctype = this.pos + 1;
+    this.pos += 2;
+    let encapsulated = false;
+    while ((this.xmlString.charCodeAt(this.pos) !== CharCodes.CLOSE_BRACKET || encapsulated) && this.xmlString[this.pos]) {
+      if (this.xmlString.charCodeAt(this.pos) === CharCodes.OPEN_CORNER_BRACKET) {
+        encapsulated = true;
+      } else if (encapsulated && this.xmlString.charCodeAt(this.pos) === CharCodes.CLOSE_CORNER_BRACKET) {
+        encapsulated = false;
+      }
+      this.pos += 1;
+    }
+    children.push(this.xmlString.substring(startDoctype, this.pos));
+    this.pos += 1;
+  }
+  /**
+   * Get current position
+   */
+  getPosition() {
+    return this.pos;
+  }
+  /**
+   * Set position
+   */
+  setPosition(pos) {
+    this.pos = pos;
+  }
+};
+
+// src/rxml/core/parser.ts
+var WHITESPACE_REGEX2 = /\s/;
+var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var DIGIT_KEY_REGEX2 = /^\d+$/;
+function getTopLevelStringProps(s) {
+  const set = /* @__PURE__ */ new Set();
+  const unwrapped = unwrapJsonSchema(s);
+  if (unwrapped && typeof unwrapped === "object") {
+    const props = unwrapped.properties;
+    if (props && typeof props === "object") {
+      for (const [k, v] of Object.entries(props)) {
+        if (getSchemaType(v) === "string") {
+          set.add(k);
+        }
+      }
+    }
+  }
+  return set;
+}
+function restorePlaceholderString(val, placeholderMap) {
+  if (val.startsWith("__RXML_PLACEHOLDER_")) {
+    const orig = placeholderMap.get(val);
+    return orig !== void 0 ? orig : val;
+  }
+  return val;
+}
+function restorePlaceholdersInObject(obj, _placeholderMap, textNodeName, restorer) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const restored = restorer(v);
+    if (k === textNodeName && typeof restored === "string") {
+      out[k] = restored.trim();
+    } else {
+      out[k] = restored;
+    }
+  }
+  return out;
+}
+function createPlaceholderRestorer(placeholderMap, textNodeName) {
+  const restorer = (val) => {
+    if (val == null) {
+      return val;
+    }
+    if (typeof val === "string") {
+      return restorePlaceholderString(val, placeholderMap);
+    }
+    if (Array.isArray(val)) {
+      return val.map(restorer);
+    }
+    if (typeof val === "object") {
+      return restorePlaceholdersInObject(
+        val,
+        placeholderMap,
+        textNodeName,
+        restorer
+      );
+    }
+    return val;
+  };
+  return restorer;
+}
+function tryConvertToNumber(val) {
+  if (typeof val !== "string") {
+    return val;
+  }
+  const trimmed = val.trim();
+  if (NUMERIC_STRING_REGEX.test(trimmed)) {
+    const num = Number(trimmed);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return trimmed;
+}
+function processItemValue(item, textNodeName) {
+  let currentVal = item;
+  if (item && typeof item === "object" && Object.hasOwn(item, textNodeName)) {
+    currentVal = item[textNodeName];
+  }
+  const trimmed = typeof currentVal === "string" ? currentVal.trim() : currentVal;
+  return tryConvertToNumber(trimmed);
+}
+function processItemWrapper(itemValue, textNodeName) {
+  if (Array.isArray(itemValue)) {
+    return itemValue.map((item) => processItemValue(item, textNodeName));
+  }
+  const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+  return tryConvertToNumber(trimmed);
+}
+function deepDecodeStringsBySchema(input, schema) {
+  var _a;
+  if (input == null || schema == null) {
+    return input;
+  }
+  const type = getSchemaType(schema);
+  if (type === "string" && typeof input === "string") {
+    return unescapeXml(input);
+  }
+  if (type === "array" && Array.isArray(input)) {
+    const unwrapped = unwrapJsonSchema(schema);
+    const itemSchema = (_a = unwrapped == null ? void 0 : unwrapped.items) != null ? _a : {};
+    return input.map((item) => deepDecodeStringsBySchema(item, itemSchema));
+  }
+  if (type === "object" && input && typeof input === "object") {
+    const obj = input;
+    const out = {};
+    for (const key of Object.keys(obj)) {
+      const childSchema = getPropertySchema(schema, key);
+      out[key] = deepDecodeStringsBySchema(obj[key], childSchema);
+    }
+    return out;
+  }
+  if (typeof input === "string") {
+    return unescapeXml(input);
+  }
+  return input;
+}
+function parse2(xmlInner, schema, options = {}) {
+  var _a, _b, _c;
+  const textNodeName = (_a = options.textNodeName) != null ? _a : "#text";
+  const throwDup = (_b = options.throwOnDuplicateStringTags) != null ? _b : true;
+  let actualXmlInner = xmlInner.trim();
+  if (actualXmlInner.startsWith("<") && actualXmlInner.endsWith(">")) {
+    const s = actualXmlInner;
+    let i = 0;
+    let rootStart = -1;
+    let rootName = "";
+    while (i < s.length) {
+      const lt = s.indexOf("<", i);
+      if (lt === -1) {
+        break;
+      }
+      const next = s[lt + 1];
+      if (next === "?") {
+        const end = s.indexOf("?>", lt + 2);
+        i = end === -1 ? s.length : end + 2;
+        continue;
+      }
+      if (next === "!") {
+        if (s.startsWith("!--", lt + 2)) {
+          const end2 = s.indexOf("-->", lt + 5);
+          i = end2 === -1 ? s.length : end2 + 3;
+          continue;
+        }
+        if (s.startsWith("![CDATA[", lt + 2)) {
+          const end2 = s.indexOf("]]>", lt + 9);
+          i = end2 === -1 ? s.length : end2 + 3;
+          continue;
+        }
+        const end = s.indexOf(">", lt + 2);
+        i = end === -1 ? s.length : end + 1;
+        continue;
+      }
+      if (next === "/") {
+        break;
+      }
+      let j = lt + 1;
+      while (j < s.length && s[j] !== " " && s[j] !== "\n" && s[j] !== "\r" && s[j] !== "	" && s[j] !== "/" && s[j] !== ">") {
+        j += 1;
+      }
+      rootStart = lt;
+      rootName = s.slice(lt + 1, j);
+      break;
+    }
+    if (rootStart === 0 && rootName) {
+      const range = findFirstTopLevelRange(s, rootName);
+      if (range) {
+        let fullEnd = range.end + `</${rootName}>`.length;
+        const closeHead = s.indexOf(`</${rootName}`, range.end);
+        if (closeHead === range.end) {
+          let p = closeHead + 2 + rootName.length;
+          while (p < s.length && WHITESPACE_REGEX2.test(s[p])) {
+            p += 1;
+          }
+          if (s[p] === ">") {
+            fullEnd = p + 1;
+          }
+        }
+        if (fullEnd === s.length) {
+          const unwrapped = unwrapJsonSchema(schema);
+          const schemaProps = unwrapped && typeof unwrapped === "object" ? unwrapped.properties : void 0;
+          if (schemaProps && !Object.hasOwn(schemaProps, rootName)) {
+            actualXmlInner = s.slice(range.start, range.end);
+          }
+        }
+      }
+    }
+  }
+  const topLevelStringProps = getTopLevelStringProps(schema);
+  const deepStringTypedProps = getStringTypedProperties(schema);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const key of topLevelStringProps) {
+    const excludeRanges = [];
+    for (const other of topLevelStringProps) {
+      if (other === key) {
+        continue;
+      }
+      const range = findFirstTopLevelRange(actualXmlInner, other);
+      if (range) {
+        excludeRanges.push(range);
+      }
+    }
+    const occurrences = countTagOccurrences(
+      actualXmlInner,
+      key,
+      excludeRanges,
+      true
+    );
+    if (occurrences > 0 && throwDup) {
+      throw new RXMLDuplicateStringTagError(
+        `Duplicate string tags for <${key}> detected`
+      );
+    }
+    if (occurrences > 0 && !throwDup) {
+      duplicateKeys.add(key);
+      if (options.onError) {
+        options.onError(
+          `RXML: Duplicate string tags for <${key}> detected; using first occurrence.`,
+          { tag: key, occurrences }
+        );
+      }
+    }
+  }
+  let xmlInnerForParsing = actualXmlInner;
+  const originalContentMap = /* @__PURE__ */ new Map();
+  try {
+    const ranges = [];
+    for (const key of deepStringTypedProps) {
+      const innerRanges = findAllInnerRanges(actualXmlInner, key);
+      for (const r of innerRanges) {
+        if (r.end > r.start) {
+          ranges.push({ ...r, key });
+        }
+      }
+    }
+    if (ranges.length > 0) {
+      const sorted = [...ranges].sort((a, b) => a.start - b.start);
+      let rebuilt = "";
+      let cursor = 0;
+      for (const r of sorted) {
+        if (r.start < cursor) {
+          continue;
+        }
+        if (cursor < r.start) {
+          rebuilt += actualXmlInner.slice(cursor, r.start);
+        }
+        const placeholder = `__RXML_PLACEHOLDER_${r.key}_${r.start}_${r.end}__`;
+        const originalContent = actualXmlInner.slice(r.start, r.end);
+        originalContentMap.set(placeholder, originalContent);
+        rebuilt += placeholder;
+        cursor = r.end;
+      }
+      if (cursor < actualXmlInner.length) {
+        rebuilt += actualXmlInner.slice(cursor);
+      }
+      xmlInnerForParsing = rebuilt;
+    }
+  } catch (error) {
+    if (options.onError) {
+      options.onError(
+        "RXML: Failed to replace string placeholders, falling back to original XML.",
+        { error }
+      );
+    }
+    xmlInnerForParsing = actualXmlInner;
+  }
+  let parsedNodes;
+  try {
+    const wrappedXml = `<root>${xmlInnerForParsing}</root>`;
+    const tokenizer = new XMLTokenizer(wrappedXml, {
+      ...options,
+      textNodeName
+    });
+    const rootNode = tokenizer.parseNode();
+    parsedNodes = rootNode.children;
+  } catch (cause) {
+    throw new RXMLParseError("Failed to parse XML", cause);
+  }
+  const parsedArgs = domToObject(parsedNodes, schema, textNodeName);
+  const restorePlaceholdersDeep = createPlaceholderRestorer(
+    originalContentMap,
+    textNodeName
+  );
+  const parsedArgsRestored = restorePlaceholdersDeep(parsedArgs);
+  const args = {};
+  for (const k of Object.keys(parsedArgsRestored || {})) {
+    const v = parsedArgsRestored[k];
+    let val = v;
+    const propSchema = getPropertySchema(schema, k);
+    const propType = getSchemaType(propSchema);
+    if (propType === "string" && duplicateKeys.has(k) && Array.isArray(v)) {
+      const firstValue = v[0];
+      if (typeof firstValue === "string" && firstValue.startsWith("__RXML_PLACEHOLDER_")) {
+        const originalContent = originalContentMap.get(firstValue);
+        if (originalContent !== void 0) {
+          args[k] = originalContent;
+          continue;
+        }
+      } else {
+        args[k] = firstValue;
+        continue;
+      }
+    }
+    if (propType === "string" && !Array.isArray(v)) {
+      const placeholderUsed = typeof v === "string" && v.startsWith("__RXML_PLACEHOLDER_") || v && typeof v === "object" && Object.hasOwn(v, textNodeName) && typeof v[textNodeName] === "string" && v[textNodeName].startsWith(
+        "__RXML_PLACEHOLDER_"
+      );
+      if (placeholderUsed) {
+        let placeholderKey;
+        if (typeof v === "string") {
+          placeholderKey = v;
+        } else {
+          placeholderKey = v[textNodeName];
+        }
+        const originalContent = originalContentMap.get(placeholderKey);
+        if (originalContent !== void 0) {
+          args[k] = originalContent;
+          continue;
+        }
+      }
+      const raw = extractRawInner(actualXmlInner, k);
+      if (typeof raw === "string") {
+        args[k] = raw;
+        continue;
+      }
+    }
+    if (v && typeof v === "object" && Object.hasOwn(v, textNodeName)) {
+      val = v[textNodeName];
+    }
+    if (Array.isArray(v)) {
+      if (propType === "string") {
+        const mapped = v.map((item) => {
+          if (item && typeof item === "object" && Object.hasOwn(item, textNodeName)) {
+            const textVal = item[textNodeName];
+            return typeof textVal === "string" ? textVal : String(textVal);
+          }
+          return typeof item === "string" ? item : String(item);
+        });
+        if (mapped.length > 1 && throwDup) {
+          throw new RXMLDuplicateStringTagError(
+            `Duplicate string tags for <${k}> detected`
+          );
+        }
+        if (mapped.length > 1 && !throwDup && options.onError) {
+          options.onError(
+            `RXML: Duplicate string tags for <${k}> detected; using first occurrence.`,
+            { tag: k, occurrences: mapped.length }
+          );
+        }
+        args[k] = (_c = mapped[0]) != null ? _c : "";
+        continue;
+      }
+      val = processArrayContent(v, propSchema, textNodeName);
+    } else if (v && typeof v === "object" && !Object.hasOwn(v, textNodeName)) {
+      const obj = v;
+      const keys2 = Object.keys(obj);
+      if (keys2.length === 1 && keys2[0] === "item") {
+        val = processItemWrapper(obj.item, textNodeName);
+      } else {
+        let isIndexedTuple = false;
+        if (keys2.length > 0 && keys2.every((key) => DIGIT_KEY_REGEX2.test(key))) {
+          const indices = keys2.map((keyStr) => Number.parseInt(keyStr, 10)).sort((a, b) => a - b);
+          isIndexedTuple = indices[0] === 0 && indices.every((indexVal, idx) => indexVal === idx);
+        }
+        if (isIndexedTuple) {
+          val = processIndexedTuple(obj, textNodeName);
+        } else {
+          val = v;
+        }
+      }
+    }
+    args[k] = typeof val === "string" ? val.trim() : val;
+  }
+  for (const key of topLevelStringProps) {
+    if (!Object.hasOwn(args, key)) {
+      const raw = extractRawInner(actualXmlInner, key);
+      if (typeof raw === "string") {
+        args[key] = raw;
+      }
+    }
+  }
+  let dataToCoerce = args;
+  const keys = Object.keys(args);
+  if (keys.length === 1) {
+    const rootKey = keys[0];
+    const rootValue = args[rootKey];
+    const unwrapped = unwrapJsonSchema(schema);
+    if (unwrapped && typeof unwrapped === "object") {
+      const schemaProps = unwrapped.properties;
+      if (schemaProps && !Object.hasOwn(schemaProps, rootKey)) {
+        dataToCoerce = rootValue;
+      }
+    }
+  }
+  try {
+    const coerced = coerceDomBySchema(dataToCoerce, schema);
+    const decoded = deepDecodeStringsBySchema(coerced, schema);
+    return decoded;
+  } catch (error) {
+    throw new RXMLCoercionError("Failed to coerce by schema", error);
+  }
+}
+
+// src/rxml/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/rxml/heuristics/xml-defaults.ts
+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_REGEX3 = /\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 && ctx.errors.length === 0) {
+      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_REGEX3.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_REGEX3.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 = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return void 0;
   }
-  logParseFailure({
-    phase: "stream",
-    reason: "Incomplete streaming tool call segment emitted as text",
-    snippet: `${toolCallStart}${state.currentToolCallJson}`
-  });
-  const errorId = generateId();
-  const errorContent = `${toolCallStart}${state.currentToolCallJson}`;
-  controller.enqueue({
-    type: "text-start",
-    id: errorId
-  });
-  controller.enqueue({
-    type: "text-delta",
-    id: errorId,
-    delta: errorContent
-  });
-  controller.enqueue({
-    type: "text-end",
-    id: errorId
-  });
-  state.currentToolCallJson = "";
+  return unwrapped.properties;
 }
-function handleFinishChunk(state, controller, toolCallStart, chunk) {
-  if (state.buffer.length > 0) {
-    flushBuffer(state, controller, toolCallStart);
+function shouldDeduplicateStringTags(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return false;
   }
-  closeTextBlock(state, controller);
-  emitIncompleteToolCall(state, controller, toolCallStart);
-  controller.enqueue(chunk);
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = unwrapJsonSchema(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
 }
-function publishText(text, state, controller) {
-  if (state.isInsideToolCall) {
-    closeTextBlock(state, controller);
-    state.currentToolCallJson += text;
-  } else if (text.length > 0) {
-    if (!state.currentTextId) {
-      state.currentTextId = generateId();
-      controller.enqueue({
-        type: "text-start",
-        id: state.currentTextId
-      });
-      state.hasEmittedTextStart = true;
+function getStringPropertyNames(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return [];
+  }
+  const names = [];
+  for (const key of Object.keys(props)) {
+    const prop = unwrapJsonSchema(props[key]);
+    if ((prop == null ? void 0 : prop.type) === "string") {
+      names.push(key);
     }
-    controller.enqueue({
-      type: "text-delta",
-      id: state.currentTextId,
-      delta: text
-    });
   }
+  return names;
 }
-function emitToolCall(context) {
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function dedupeSingleTag(xml, key) {
   var _a, _b;
-  const { state, controller, toolCallStart, toolCallEnd, options } = context;
-  try {
-    const parsedToolCall = (0, import_rjson.parse)(state.currentToolCallJson);
-    closeTextBlock(state, controller);
-    controller.enqueue({
-      type: "tool-call",
-      toolCallId: generateId(),
-      toolName: parsedToolCall.name,
-      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-    });
-  } catch (error) {
-    logParseFailure({
-      phase: "stream",
-      reason: "Failed to parse streaming tool call JSON segment",
-      snippet: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`,
-      error
-    });
-    const errorId = generateId();
-    const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
-    controller.enqueue({
-      type: "text-start",
-      id: errorId
-    });
-    controller.enqueue({
-      type: "text-delta",
-      id: errorId,
-      delta: errorContent
-    });
-    controller.enqueue({
-      type: "text-end",
-      id: errorId
-    });
-    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-      options,
-      "Could not process streaming JSON tool call; emitting original text.",
-      {
-        toolCall: errorContent
-      }
-    );
+  const escaped = escapeRegExp2(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
+  }
+  const last = matches.at(-1);
+  let result = "";
+  let cursor = 0;
+  for (const m of matches) {
+    const idx = (_a = m.index) != null ? _a : 0;
+    result += xml.slice(cursor, idx);
+    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
+      result += m[0];
+    }
+    cursor = idx + m[0].length;
   }
+  result += xml.slice(cursor);
+  return result;
 }
-function processTagMatch(context) {
-  const { state } = context;
-  if (state.isInsideToolCall) {
-    emitToolCall(context);
-    state.currentToolCallJson = "";
-    state.isInsideToolCall = false;
-  } else {
-    state.currentToolCallJson = "";
-    state.isInsideToolCall = true;
+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 processBufferTags(context) {
-  const { state, controller, toolCallStart, toolCallEnd } = context;
-  let startIndex = getPotentialStartIndex(
-    state.buffer,
-    state.isInsideToolCall ? toolCallEnd : toolCallStart
-  );
-  while (startIndex != null) {
-    const tag = state.isInsideToolCall ? toolCallEnd : toolCallStart;
-    if (startIndex + tag.length > state.buffer.length) {
-      break;
+function applySchemaProps(obj, properties) {
+  for (const key of Object.keys(obj)) {
+    const propSchema = properties[key];
+    if (!propSchema) {
+      continue;
+    }
+    const prop = unwrapJsonSchema(propSchema);
+    if ((prop == null ? void 0 : prop.type) === "array" && prop.items) {
+      const itemSchema = 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);
+      }
     }
-    publishText(state.buffer.slice(0, startIndex), state, controller);
-    state.buffer = state.buffer.slice(startIndex + tag.length);
-    processTagMatch(context);
-    startIndex = getPotentialStartIndex(
-      state.buffer,
-      state.isInsideToolCall ? toolCallEnd : toolCallStart
-    );
   }
 }
-function handlePartialTag(state, controller, toolCallStart) {
-  if (state.isInsideToolCall) {
-    return;
-  }
-  const potentialIndex = getPotentialStartIndex(state.buffer, toolCallStart);
-  if (potentialIndex != null && potentialIndex + toolCallStart.length > state.buffer.length) {
-    publishText(state.buffer.slice(0, potentialIndex), state, controller);
-    state.buffer = state.buffer.slice(potentialIndex);
-  } else {
-    publishText(state.buffer, state, controller);
-    state.buffer = "";
+function coerceArrayItems(val, itemSchema) {
+  if (!Array.isArray(val)) {
+    return val;
   }
+  return val.map((v) => coerceArrayItem(v, itemSchema));
 }
-var jsonProtocol = ({
-  toolCallStart = "<tool_call>",
-  toolCallEnd = "</tool_call>"
-} = {}) => ({
-  formatTools({
-    tools,
-    toolSystemPromptTemplate
-  }) {
-    return toolSystemPromptTemplate(tools || []);
-  },
-  formatToolCall(toolCall) {
-    let args = {};
-    if (toolCall.input != null) {
-      try {
-        args = JSON.parse(toolCall.input);
-      } catch (e) {
-        args = toolCall.input;
-      }
+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;
     }
-    return `${toolCallStart}${JSON.stringify({
-      name: toolCall.toolName,
-      arguments: args
-    })}${toolCallEnd}`;
-  },
-  parseGeneratedText({
-    text,
-    options
-  }) {
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
-    const toolCallRegex = new RegExp(
-      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
-      "gs"
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
     );
-    const processedElements = [];
-    let currentIndex = 0;
-    let match = toolCallRegex.exec(text);
-    while (match !== null) {
-      currentIndex = processMatchedToolCall({
-        match,
-        text,
-        currentIndex,
-        processedElements,
-        options
-      });
-      match = toolCallRegex.exec(text);
-    }
-    if (currentIndex < text.length) {
-      const remainingText = text.substring(currentIndex);
-      addTextSegment(remainingText, processedElements);
-    }
-    return processedElements;
-  },
-  createStreamParser({
-    options
-  }) {
-    const state = {
-      isInsideToolCall: false,
-      buffer: "",
-      currentToolCallJson: "",
-      currentTextId: null,
-      hasEmittedTextStart: false
-    };
-    return new TransformStream({
-      transform(chunk, controller) {
-        var _a;
-        if (chunk.type === "finish") {
-          handleFinishChunk(state, controller, toolCallStart, chunk);
-          return;
-        }
-        if (chunk.type !== "text-delta") {
-          controller.enqueue(chunk);
-          return;
-        }
-        const textContent = (_a = chunk.delta) != null ? _a : "";
-        state.buffer += textContent;
-        processBufferTags({
-          state,
-          controller,
-          toolCallStart,
-          toolCallEnd,
-          options
-        });
-        handlePartialTag(state, controller, toolCallStart);
-      }
-    });
-  },
-  extractToolCallSegments({ text }) {
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
-    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
-    const segments = [];
-    let m = regex.exec(text);
-    while (m != null) {
-      segments.push(m[0]);
-      m = regex.exec(text);
+    if (fallback) {
+      return fallback;
     }
-    return segments;
+    return v;
   }
-});
-
-// src/core/protocols/protocol-interface.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(v, itemSchema);
+  }
+  return v;
 }
-function isTCMProtocolFactory(protocol) {
-  return typeof protocol === "function";
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = parse2(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/rxml/parse.ts
+function parse3(xml, schema, options = {}) {
+  if (!options.repair) {
+    return parse2(xml, schema, options);
+  }
+  const baseOptions = {
+    ...options,
+    repair: false
+  };
+  const ctx = createIntermediateCall("", xml, schema);
+  const result = applyHeuristicPipeline(ctx, defaultPipelineConfig, {
+    parse: (raw, s) => parse2(raw, s, baseOptions),
+    onError: options.onError,
+    maxReparses: options.maxReparses
+  });
+  if (result.parsed !== null) {
+    return result.parsed;
+  }
+  const error = result.errors[0];
+  throw new RXMLParseError("Failed to parse XML with repair heuristics", error);
 }
 
 // src/core/protocols/xml-protocol.ts
-var import_rxml = require("@ai-sdk-tool/rxml");
-var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX = /\s/;
+var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX4 = /\s/;
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -591,7 +3841,7 @@ function processToolCall(params) {
     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);
+    const parsed = parse3(toolCall.content, toolSchema, parseConfig);
     processedElements.push({
       type: "tool-call",
       toolCallId: generateId(),
@@ -629,7 +3879,7 @@ function handleStreamingToolCallEnd(params) {
   };
   flushText(ctrl);
   try {
-    const parsedResult = (0, import_rxml.parse)(toolContent, toolSchema, parseConfig);
+    const parsedResult = parse3(toolContent, toolSchema, parseConfig);
     ctrl.enqueue({
       type: "tool-call",
       toolCallId: generateId(),
@@ -679,11 +3929,11 @@ function consumeClosingTag(text, lt) {
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
-  while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
     p += 1;
   }
   const name = text.slice(nameStart, p);
@@ -692,7 +3942,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -721,11 +3971,11 @@ function nextTagToken(text, fromPos) {
   if (next === "/") {
     const closing = consumeClosingTag(text, lt);
     let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
+    while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
-    while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
       p += 1;
     }
     const name = text.slice(nameStart, p);
@@ -896,7 +4146,7 @@ function isOpenTagPrefix(suffix, toolName) {
 }
 function consumeWhitespace(text, index) {
   let i = index;
-  while (i < text.length && WHITESPACE_REGEX.test(text.charAt(i))) {
+  while (i < text.length && WHITESPACE_REGEX4.test(text.charAt(i))) {
     i += 1;
   }
   return i;
@@ -1167,7 +4417,7 @@ var xmlProtocol = (protocolOptions) => {
           args = toolCall.input;
         }
       }
-      return (0, import_rxml.stringify)(toolCall.toolName, args, {
+      return stringify2(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: true,
         minimalEscaping: true
@@ -1285,8 +4535,8 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
-var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX2 = /\s/;
+var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX5 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -1303,11 +4553,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX2.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX5.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < gtIdx && NAME_CHAR_RE2.test(text.charAt(p))) {
+      while (p < gtIdx && NAME_CHAR_RE3.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1323,11 +4573,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX5.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+      while (p < text.length && NAME_CHAR_RE3.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1336,7 +4586,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX5.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -1841,7 +5091,6 @@ function hasInputProperty(obj) {
 
 // src/generate-handler.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_schema_coerce = require("@ai-sdk-tool/schema-coerce");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -2003,7 +5252,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_schema_coerce.coerceBySchema)(args, schema);
+  const coerced = coerceBySchema(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
@@ -2928,14 +6177,16 @@ var yamlToolMiddleware = createToolMiddleware({
   logParsedSummary,
   logRawChunk,
   originalToolsSchema,
+  parse,
+  stringify,
   toolChoiceStream,
+  transform,
   transformParams,
   wrapGenerate,
   wrapStream,
   xmlProtocol,
   xmlToolMiddleware,
   yamlProtocol,
-  yamlToolMiddleware,
-  ...require("@ai-sdk-tool/rjson")
+  yamlToolMiddleware
 });
 //# sourceMappingURL=index.cjs.map