@ai-sdk-tool/parser 3.0.0 → 3.1.1

package/dist/{v6.cjs → chunk-WX5U7G6L.js}

@@ -1,1644 +1,1644 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-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-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/v6/index.ts
-var v6_exports = {};
-__export(v6_exports, {
-  createToolMiddleware: () => createToolMiddleware,
-  gemmaToolMiddleware: () => gemmaToolMiddleware,
-  hermesToolMiddleware: () => hermesToolMiddleware,
-  morphXmlToolMiddleware: () => morphXmlToolMiddleware,
-  orchestratorToolMiddleware: () => orchestratorToolMiddleware
-});
-module.exports = __toCommonJS(v6_exports);
-
-// src/core/utils/debug.ts
-var LINE_SPLIT_REGEX = /\r?\n/;
-function normalizeBooleanString(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "1" || normalized === "true" || normalized === "yes") {
-    return true;
-  }
-  if (normalized === "0" || normalized === "false" || normalized === "no") {
-    return false;
-  }
-  return;
-}
-function getDebugLevel() {
-  const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW || "off";
-  const envLower = String(envVal).toLowerCase();
-  if (envLower === "stream" || envLower === "parse" || envLower === "off") {
-    return envLower;
-  }
-  const boolEnv = normalizeBooleanString(envLower);
-  if (boolEnv === true) {
-    return "stream";
-  }
-  if (envLower === "2") {
-    return "parse";
-  }
-  return "off";
-}
-function color(code) {
-  return (text) => `\x1B[${code}m${text}\x1B[0m`;
-}
-var ANSI_GRAY = 90;
-var ANSI_YELLOW = 33;
-var ANSI_CYAN = 36;
-var ANSI_BG_BLUE = 44;
-var ANSI_BG_GREEN = 42;
-var ANSI_INVERSE = 7;
-var ANSI_UNDERLINE = 4;
-var ANSI_BOLD = 1;
-var cGray = color(ANSI_GRAY);
-var cYellow = color(ANSI_YELLOW);
-var cCyan = color(ANSI_CYAN);
-var cBgBlue = color(ANSI_BG_BLUE);
-var cBgGreen = color(ANSI_BG_GREEN);
-var cInverse = color(ANSI_INVERSE);
-var cUnderline = color(ANSI_UNDERLINE);
-var cBold = color(ANSI_BOLD);
-var MAX_SNIPPET_LENGTH = 800;
-function safeStringify(value) {
-  try {
-    return `
-${typeof value === "string" ? value : JSON.stringify(value, null, 2)}`;
-  } catch (e) {
-    return String(value);
+// src/core/heuristics/engine.ts
+function applyRawSegmentUpdate(current, result) {
+  if (result.rawSegment !== void 0) {
+    return { ...current, rawSegment: result.rawSegment };
   }
+  return current;
 }
-function formatError(error) {
-  if (error instanceof Error) {
-    const stack = error.stack ? `
-${error.stack}` : "";
-    return `
-${error.name}: ${error.message}${stack}`;
+function applyParsedUpdate(current, result) {
+  if (result.parsed !== void 0) {
+    return { ...current, parsed: result.parsed };
   }
-  return safeStringify(error);
+  return current;
 }
-function truncateSnippet(snippet) {
-  if (snippet.length <= MAX_SNIPPET_LENGTH) {
-    return snippet;
+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 `${snippet.slice(0, MAX_SNIPPET_LENGTH)}
-\u2026[truncated ${snippet.length - MAX_SNIPPET_LENGTH} chars]`;
+  return current;
 }
-function logParseFailure({
-  phase,
-  reason,
-  snippet,
-  error
-}) {
-  if (getDebugLevel() !== "parse") {
-    return;
-  }
-  const label = cBgBlue(`[${phase}]`);
-  console.log(cGray("[debug:mw:fail]"), label, cYellow(reason));
-  if (snippet) {
-    const formatted = truncateSnippet(snippet);
-    console.log(cGray("[debug:mw:fail:snippet]"), formatted);
+function attemptReparse(current, result, reparseCount, maxReparses, parse4) {
+  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
+    return { state: current, newCount: reparseCount };
   }
-  if (error) {
-    console.log(cGray("[debug:mw:fail:error]"), cCyan(formatError(error)));
+  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 logRawChunk(part) {
-  console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
-}
-function logParsedChunk(part) {
-  console.log(cGray("[debug:mw:out]"), cCyan(safeStringify(part)));
-}
-function getHighlightStyle() {
-  const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW_STYLE || "bg";
-  const normalized = String(envVal).trim().toLowerCase();
-  if (normalized === "inverse" || normalized === "invert") {
-    return "inverse";
-  }
-  if (normalized === "underline" || normalized === "ul") {
-    return "underline";
-  }
-  if (normalized === "bold") {
-    return "bold";
-  }
-  if (normalized === "bg" || normalized === "background") {
-    return "bg";
-  }
-  const asBool = normalizeBooleanString(normalized);
-  if (asBool === true) {
-    return "bg";
+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 "bg";
+  return current;
 }
-function getHighlightFunction(style) {
-  if (style === "inverse") {
-    return cInverse;
-  }
-  if (style === "underline") {
-    return cUnderline;
+function applyHeuristicPipeline(ctx, config, options) {
+  let current = ctx;
+  if (config.preParse && config.preParse.length > 0) {
+    current = executePhase(current, config.preParse, options);
   }
-  if (style === "bold") {
-    return cBold;
+  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 (style === "bg") {
-    return cBgGreen;
+  if (current.errors.length > 0 && config.fallbackReparse && config.fallbackReparse.length > 0) {
+    current = executePhase(current, config.fallbackReparse, options);
   }
-  return cYellow;
-}
-function renderHighlightedText(originalText, style, highlight) {
-  if (style === "bg" || style === "inverse" || style === "underline" || style === "bold") {
-    return originalText.split(LINE_SPLIT_REGEX).map((line) => line.length ? highlight(line) : line).join("\n");
+  if (current.parsed !== null && config.postParse && config.postParse.length > 0) {
+    current = executePhase(current, config.postParse, options);
   }
-  return highlight(originalText);
+  return current;
 }
-function logParsedSummary({
-  toolCalls,
-  originalText
-}) {
-  if (originalText) {
-    const style = getHighlightStyle();
-    const highlight = getHighlightFunction(style);
-    const rendered = renderHighlightedText(originalText, style, highlight);
-    console.log(cGray("[debug:mw:origin]"), `
-${rendered}`);
-  }
-  if (toolCalls.length > 0) {
-    const styledSummary = safeStringify(toolCalls).split(LINE_SPLIT_REGEX).map((line) => line.length ? cBgBlue(line) : line).join("\n");
-    console.log(cGray("[debug:mw:summary]"), styledSummary);
-  }
+function createIntermediateCall(toolName, rawSegment, schema) {
+  return {
+    toolName,
+    schema,
+    rawSegment,
+    parsed: null,
+    errors: [],
+    meta: { originalContent: rawSegment }
+  };
 }
-
-// src/core/utils/get-potential-start-index.ts
-function getPotentialStartIndex(text, searchedText) {
-  if (searchedText.length === 0) {
-    return null;
-  }
-  const directIndex = text.indexOf(searchedText);
-  if (directIndex !== -1) {
-    return directIndex;
-  }
-  for (let i = text.length - 1; i >= 0; i -= 1) {
-    const suffix = text.substring(i);
-    if (searchedText.startsWith(suffix)) {
-      return i;
+function mergePipelineConfigs(...configs) {
+  var _a, _b, _c;
+  const result = {
+    preParse: [],
+    fallbackReparse: [],
+    postParse: []
+  };
+  for (const config of configs) {
+    if (config.preParse) {
+      result.preParse = [...(_a = result.preParse) != null ? _a : [], ...config.preParse];
+    }
+    if (config.fallbackReparse) {
+      result.fallbackReparse = [
+        ...(_b = result.fallbackReparse) != null ? _b : [],
+        ...config.fallbackReparse
+      ];
+    }
+    if (config.postParse) {
+      result.postParse = [...(_c = result.postParse) != null ? _c : [], ...config.postParse];
     }
   }
-  return null;
-}
-
-// src/core/utils/id.ts
-function generateId() {
-  return Math.random().toString(36).substring(2, 15);
-}
-
-// src/core/utils/regex.ts
-function escapeRegExp(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return result;
 }
 
-// src/core/utils/robust-json.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;
+// src/core/heuristics/xml-defaults.ts
+import { parse, unwrapJsonSchema } from "@ai-sdk-tool/rxml";
+var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
+var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
+var WHITESPACE_REGEX = /\s/;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var NAME_START_CHAR_RE = /[A-Za-z_:]/;
+var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
+var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
+var normalizeCloseTagsHeuristic = {
+  id: "normalize-close-tags",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const normalized = ctx.rawSegment.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    if (normalized !== ctx.rawSegment) {
+      return { rawSegment: normalized };
     }
+    return {};
   }
-  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;
+};
+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 };
     }
-    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 {};
+  }
+};
+var balanceTagsHeuristic = {
+  id: "balance-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const balanced = balanceTags(original);
+    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
+    if (!hasMalformedClose && balanced.length > normalized.length) {
+      return false;
     }
-    return tokens;
-  };
+    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 fStringSingle(m) {
-  const content = m[1].replace(
-    /([^'\\]|\\['bnrtf\\]|\\u[0-9a-fA-F]{4})/g,
-    (mm) => {
-      if (mm === '"') {
-        return '\\"';
-      }
-      if (mm === "\\'") {
-        return "'";
+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;
       }
-      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)
-  };
+    out += ch;
+  }
+  return out;
+}
+function balanceTags(xml) {
+  const src = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>").replace(STATUS_TO_STEP_BOUNDARY_RE, "</status></step><step>");
+  let i = 0;
+  const len = src.length;
+  const out = [];
+  const stack = [];
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      out.push(src.slice(i));
+      break;
+    }
+    out.push(src.slice(i, lt));
+    if (lt + 1 >= len) {
+      break;
+    }
+    const next = src[lt + 1];
+    if (next === "!" || next === "?") {
+      i = handleSpecialTagSegment(src, lt, out);
+      continue;
+    }
+    if (next === "/") {
+      i = handleClosingTagSegment(src, lt, out, stack);
+      continue;
+    }
+    i = handleOpeningTagSegment(src, lt, out, stack);
+  }
+  for (let k = stack.length - 1; k >= 0; k -= 1) {
+    out.push(`</${stack[k]}>`);
+  }
+  return out.join("");
+}
+function skipWs(s, p, len) {
+  let idx = p;
+  while (idx < len && WHITESPACE_REGEX.test(s[idx])) {
+    idx += 1;
+  }
+  return idx;
+}
+function parseTagNameAt(s, p, len) {
+  let idx = p;
+  const start = idx;
+  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
+    idx += 1;
+  }
+  return { name: s.slice(start, idx), pos: idx };
+}
+function handleSpecialTagSegment(src, lt, out) {
+  const gt = src.indexOf(">", lt + 1);
+  if (gt === -1) {
+    out.push(src.slice(lt));
+    return src.length;
+  }
+  out.push(src.slice(lt, gt + 1));
+  return gt + 1;
+}
+function handleClosingTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 2, len);
+  const { name, pos } = parseTagNameAt(src, p, len);
+  p = pos;
+  const gt = src.indexOf(">", p);
+  const closingText = gt === -1 ? src.slice(lt) : src.slice(lt, gt + 1);
+  const idx = stack.lastIndexOf(name);
+  if (idx !== -1) {
+    for (let k = stack.length - 1; k > idx; k -= 1) {
+      out.push(`</${stack[k]}>`);
+      stack.pop();
+    }
+    out.push(closingText);
+    stack.pop();
+  }
+  return gt === -1 ? len : gt + 1;
+}
+function handleOpeningTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 1, len);
+  const nameStart = p;
+  const parsed = parseTagNameAt(src, p, len);
+  p = parsed.pos;
+  const name = src.slice(nameStart, p);
+  const q = src.indexOf(">", p);
+  if (q === -1) {
+    out.push(src.slice(lt));
+    return len;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX.test(src[r])) {
+    r -= 1;
+  }
+  const selfClosing = src[r] === "/";
+  out.push(src.slice(lt, q + 1));
+  if (!selfClosing && name) {
+    stack.push(name);
+  }
+  return q + 1;
 }
-function 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 extractSchemaProperties(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return void 0;
+  }
+  return unwrapped.properties;
 }
-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 shouldDeduplicateStringTags(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return false;
+  }
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = unwrapJsonSchema(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
 }
-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 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);
+    }
+  }
+  return names;
 }
-function fNumber(m) {
-  return {
-    type: "number",
-    match: m[0],
-    // The raw matched number string
-    value: Number.parseFloat(m[0])
-    // Convert string to number
-  };
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-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]}`);
+function dedupeSingleTag(xml, key) {
+  var _a, _b;
+  const escaped = escapeRegExp(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
   }
-  return {
-    type: "atom",
-    // Use 'atom' type for these literals
-    match: m[0],
-    // The raw matched keyword
-    value
-    // The corresponding JavaScript value
-  };
+  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 makeTokenSpecs(relaxed) {
-  function f(type) {
-    return (m) => {
-      return { type, match: m[0], value: void 0 };
-    };
+function repairParsedAgainstSchema(input, schema) {
+  if (!input || typeof input !== "object") {
+    return input;
   }
-  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.
-    ]);
+  const properties = extractSchemaProperties(schema);
+  if (!properties) {
+    return input;
   }
-  return tokenSpecs;
+  applySchemaProps(input, properties);
+  return input;
 }
-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;
+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);
+      }
     }
   }
-  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
-          };
-        }
-      }
+function coerceArrayItems(val, itemSchema) {
+  if (!Array.isArray(val)) {
+    return val;
+  }
+  return val.map((v) => coerceArrayItem(v, itemSchema));
+}
+function coerceArrayItem(v, itemSchema) {
+  const itemType = itemSchema == null ? void 0 : itemSchema.type;
+  if (typeof v === "string" && itemType === "object") {
+    const parsed = tryParseStringToSchemaObject(v, itemSchema);
+    if (parsed !== null) {
+      return parsed;
     }
-    res.push(token);
-  });
-  return res;
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
+    );
+    if (fallback) {
+      return fallback;
+    }
+    return v;
+  }
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(v, itemSchema);
+  }
+  return v;
 }
-function 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 };
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = parse(normalized, itemSchema, { noChildNodes: [] });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
   }
-  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 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;
 }
-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;
-    }
+
+// src/core/utils/debug.ts
+var LINE_SPLIT_REGEX = /\r?\n/;
+function normalizeBooleanString(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes") {
+    return true;
   }
-}
-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;
-    }
+  if (normalized === "0" || normalized === "false" || normalized === "no") {
+    return false;
   }
+  return;
 }
-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 getDebugLevel() {
+  const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW || "off";
+  const envLower = String(envVal).toLowerCase();
+  if (envLower === "stream" || envLower === "parse" || envLower === "off") {
+    return envLower;
+  }
+  const boolEnv = normalizeBooleanString(envLower);
+  if (boolEnv === true) {
+    return "stream";
+  }
+  if (envLower === "2") {
+    return "parse";
   }
+  return "off";
 }
-function raiseUnexpected(state, token, expected) {
-  raiseError(
-    state,
-    token,
-    `Unexpected token: ${strToken(token)}, expected ${expected}`
-  );
+function color(code) {
+  return (text) => `\x1B[${code}m${text}\x1B[0m`;
 }
-function checkDuplicates(state, obj, token) {
-  const key = String(token.value);
-  if (!state.duplicate && Object.hasOwn(obj, key)) {
-    raiseError(state, token, `Duplicate key: ${key}`);
+var ANSI_GRAY = 90;
+var ANSI_YELLOW = 33;
+var ANSI_CYAN = 36;
+var ANSI_BG_BLUE = 44;
+var ANSI_BG_GREEN = 42;
+var ANSI_INVERSE = 7;
+var ANSI_UNDERLINE = 4;
+var ANSI_BOLD = 1;
+var cGray = color(ANSI_GRAY);
+var cYellow = color(ANSI_YELLOW);
+var cCyan = color(ANSI_CYAN);
+var cBgBlue = color(ANSI_BG_BLUE);
+var cBgGreen = color(ANSI_BG_GREEN);
+var cInverse = color(ANSI_INVERSE);
+var cUnderline = color(ANSI_UNDERLINE);
+var cBold = color(ANSI_BOLD);
+var MAX_SNIPPET_LENGTH = 800;
+function safeStringify(value) {
+  try {
+    return `
+${typeof value === "string" ? value : JSON.stringify(value, null, 2)}`;
+  } catch (e) {
+    return String(value);
   }
 }
-function appendPair(state, obj, key, value) {
-  const finalValue = state.reviver ? state.reviver(key, value) : value;
-  if (finalValue !== void 0) {
-    obj[key] = finalValue;
+function formatError(error) {
+  if (error instanceof Error) {
+    const stack = error.stack ? `
+${error.stack}` : "";
+    return `
+${error.name}: ${error.message}${stack}`;
   }
+  return safeStringify(error);
 }
-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;
-    }
+function truncateSnippet(snippet) {
+  if (snippet.length <= MAX_SNIPPET_LENGTH) {
+    return snippet;
   }
-  checkDuplicates(state, obj, token);
-  const key = String(token.value);
-  skipColon(tokens, state);
-  value = parseAny(tokens, state);
-  appendPair(state, obj, key, value);
+  return `${snippet.slice(0, MAX_SNIPPET_LENGTH)}
+\u2026[truncated ${snippet.length - MAX_SNIPPET_LENGTH} chars]`;
 }
-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 logParseFailure({
+  phase,
+  reason,
+  snippet,
+  error
+}) {
+  if (getDebugLevel() !== "parse") {
+    return;
+  }
+  const label = cBgBlue(`[${phase}]`);
+  console.log(cGray("[debug:mw:fail]"), label, cYellow(reason));
+  if (snippet) {
+    const formatted = truncateSnippet(snippet);
+    console.log(cGray("[debug:mw:fail:snippet]"), formatted);
+  }
+  if (error) {
+    console.log(cGray("[debug:mw:fail:error]"), cCyan(formatError(error)));
+  }
 }
-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 logRawChunk(part) {
+  console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
 }
-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 logParsedChunk(part) {
+  console.log(cGray("[debug:mw:out]"), cCyan(safeStringify(part)));
 }
-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;
+function getHighlightStyle() {
+  const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW_STYLE || "bg";
+  const normalized = String(envVal).trim().toLowerCase();
+  if (normalized === "inverse" || normalized === "invert") {
+    return "inverse";
+  }
+  if (normalized === "underline" || normalized === "ul") {
+    return "underline";
+  }
+  if (normalized === "bold") {
+    return "bold";
+  }
+  if (normalized === "bg" || normalized === "background") {
+    return "bg";
   }
-  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;
+  const asBool = normalizeBooleanString(normalized);
+  if (asBool === true) {
+    return "bg";
   }
-  opts.elementParser(tokens, state, result);
-  return null;
+  return "bg";
 }
-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;
+function getHighlightFunction(style) {
+  if (style === "inverse") {
+    return cInverse;
   }
-  if (token.type === opts.endSymbol) {
-    return result;
+  if (style === "underline") {
+    return cUnderline;
   }
-  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 (style === "bold") {
+    return cBold;
   }
-  if (token.type === opts.endSymbol) {
-    return result;
+  if (style === "bg") {
+    return cBgGreen;
   }
-  if (token.type === ",") {
-    const handledResult = handleCommaToken({
-      token,
-      tokens,
-      state,
-      opts,
-      result
-    });
-    if (handledResult !== null) {
-      return handledResult;
-    }
-    return;
+  return cYellow;
+}
+function renderHighlightedText(originalText, style, highlight) {
+  if (style === "bg" || style === "inverse" || style === "underline" || style === "bold") {
+    return originalText.split(LINE_SPLIT_REGEX).map((line) => line.length ? highlight(line) : line).join("\n");
   }
-  opts.elementParser(tokens, state, result);
-  return;
+  return highlight(originalText);
 }
-function parseMany(tokens, state, result, opts) {
-  const initialResult = parseManyInitialElement(tokens, state, result, opts);
-  if (initialResult !== void 0) {
-    return initialResult;
+function logParsedSummary({
+  toolCalls,
+  originalText
+}) {
+  if (originalText) {
+    const style = getHighlightStyle();
+    const highlight = getHighlightFunction(style);
+    const rendered = renderHighlightedText(originalText, style, highlight);
+    console.log(cGray("[debug:mw:origin]"), `
+${rendered}`);
   }
-  while (true) {
-    const token = popToken(tokens, state);
-    const processedResult = parseManyProcessToken({
-      token,
-      tokens,
-      state,
-      opts,
-      result
-    });
-    if (processedResult !== void 0) {
-      return processedResult;
-    }
+  if (toolCalls.length > 0) {
+    const styledSummary = safeStringify(toolCalls).split(LINE_SPLIT_REGEX).map((line) => line.length ? cBgBlue(line) : line).join("\n");
+    console.log(cGray("[debug:mw:summary]"), styledSummary);
   }
 }
-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`
-      );
-    }
+
+// src/core/utils/get-potential-start-index.ts
+function getPotentialStartIndex(text, searchedText) {
+  if (searchedText.length === 0) {
+    return null;
   }
-  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;
+  const directIndex = text.indexOf(searchedText);
+  if (directIndex !== -1) {
+    return directIndex;
+  }
+  for (let i = text.length - 1; i >= 0; i -= 1) {
+    const suffix = text.substring(i);
+    if (searchedText.startsWith(suffix)) {
+      return i;
+    }
   }
+  return null;
 }
-function parseAny(tokens, state, end = false) {
-  const token = skipPunctuation(tokens, state);
-  let ret;
-  if (token.type === "eof") {
-    if (end) {
-      raiseUnexpected(state, token, "json value");
+
+// src/core/utils/id.ts
+function generateId() {
+  return Math.random().toString(36).substring(2, 15);
+}
+
+// src/core/utils/regex.ts
+function escapeRegExp2(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/utils/robust-json.ts
+var WHITESPACE_TEST_REGEX = /\s/;
+var WHITESPACE_REGEX2 = /^\s+/;
+var OBJECT_START_REGEX = /^\{/;
+var OBJECT_END_REGEX = /^\}/;
+var ARRAY_START_REGEX = /^\[/;
+var ARRAY_END_REGEX = /^\]/;
+var COMMA_REGEX = /^,/;
+var COLON_REGEX = /^:/;
+var KEYWORD_REGEX = /^(?:true|false|null)/;
+var NUMBER_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+var STRING_DOUBLE_REGEX = /^"(?:[^"\\]|\\["bnrtf\\/]|\\u[0-9a-fA-F]{4})*"/;
+var STRING_SINGLE_REGEX = /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/;
+var COMMENT_SINGLE_REGEX = /^\/\/.*?(?:\r\n|\r|\n)/;
+var COMMENT_MULTI_REGEX = /^\/\*[\s\S]*?\*\//;
+var IDENTIFIER_REGEX = /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/;
+function some(array, f) {
+  let acc = false;
+  for (let i = 0; i < array.length; i += 1) {
+    const result = f(array[i], i, array);
+    acc = result === void 0 ? false : result;
+    if (acc) {
+      return acc;
     }
-    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 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;
       }
-  }
-  if (end) {
-    ret = state.reviver ? state.reviver("", ret) : ret;
-    endChecks(tokens, state, ret);
-  }
-  return ret;
+      const tokenWithLine = matched.matched;
+      tokenWithLine.line = line;
+      line += matched.raw.replace(/[^\n]/g, "").length;
+      tokens.push(tokenWithLine);
+    }
+    return tokens;
+  };
 }
-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;
+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;
     }
-  }
-  options.tolerant = options.tolerant || options.warnings;
-  options.duplicate = (_a = options.duplicate) != null ? _a : false;
-  return options;
+  );
+  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 createParseState(options) {
-  var _a, _b;
+function fStringDouble(m) {
   return {
-    pos: 0,
-    reviver: options.reviver,
-    tolerant: (_a = options.tolerant) != null ? _a : false,
-    duplicate: (_b = options.duplicate) != null ? _b : false,
-    warnings: []
+    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 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 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 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 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 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);
-}
-
-// src/core/protocols/json-mix-protocol.ts
-function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
-  var _a, _b;
-  try {
-    const parsedToolCall = parse(toolCallJson);
-    processedElements.push({
-      type: "tool-call",
-      toolCallId: generateId(),
-      toolName: parsedToolCall.name,
-      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-    });
-  } catch (error) {
-    logParseFailure({
-      phase: "generated-text",
-      reason: "Failed to parse tool call JSON segment",
-      snippet: fullMatch,
-      error
-    });
-    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-      options,
-      "Could not process JSON tool call, keeping original text.",
-      { toolCall: fullMatch, error }
-    );
-    processedElements.push({ type: "text", text: fullMatch });
-  }
-}
-function addTextSegment(text, processedElements) {
-  if (text.trim()) {
-    processedElements.push({ type: "text", text });
-  }
-}
-function processMatchedToolCall(context) {
-  const { match, text, currentIndex, processedElements, options } = context;
-  const startIndex = match.index;
-  const toolCallJson = match[1];
-  if (startIndex > currentIndex) {
-    const textSegment = text.substring(currentIndex, startIndex);
-    addTextSegment(textSegment, processedElements);
-  }
-  if (toolCallJson) {
-    processToolCallJson(toolCallJson, match[0], processedElements, options);
-  }
-  return startIndex + match[0].length;
-}
-function flushBuffer(state, controller, toolCallStart) {
-  if (state.buffer.length === 0) {
-    return;
-  }
-  if (!state.currentTextId) {
-    state.currentTextId = generateId();
-    controller.enqueue({
-      type: "text-start",
-      id: state.currentTextId
-    });
-    state.hasEmittedTextStart = true;
-  }
-  const deltaContent = state.isInsideToolCall ? `${toolCallStart}${state.buffer}` : state.buffer;
-  controller.enqueue({
-    type: "text-delta",
-    id: state.currentTextId,
-    textDelta: deltaContent,
-    delta: deltaContent
-  });
-  state.buffer = "";
+function fNumber(m) {
+  return {
+    type: "number",
+    match: m[0],
+    // The raw matched number string
+    value: Number.parseFloat(m[0])
+    // Convert string to number
+  };
 }
-function closeTextBlock(state, controller) {
-  if (state.currentTextId && state.hasEmittedTextStart) {
-    controller.enqueue({
-      type: "text-end",
-      id: state.currentTextId
-    });
-    state.currentTextId = null;
-    state.hasEmittedTextStart = false;
+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 emitIncompleteToolCall(state, controller, toolCallStart) {
-  if (!state.currentToolCallJson) {
-    return;
+function makeTokenSpecs(relaxed) {
+  function f(type) {
+    return (m) => {
+      return { type, match: m[0], value: 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,
-    textDelta: errorContent,
-    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);
+  let tokenSpecs = [
+    { re: WHITESPACE_REGEX2, f: f(" ") },
+    // Whitespace
+    { re: OBJECT_START_REGEX, f: f("{") },
+    // Object start
+    { re: OBJECT_END_REGEX, f: f("}") },
+    // Object end
+    { re: ARRAY_START_REGEX, f: f("[") },
+    // Array start
+    { re: ARRAY_END_REGEX, f: f("]") },
+    // Array end
+    { re: COMMA_REGEX, f: f(",") },
+    // Comma separator
+    { re: COLON_REGEX, f: f(":") },
+    // Key-value separator
+    { re: KEYWORD_REGEX, f: fKeyword },
+    // Keywords
+    // Number: optional sign, digits, optional decimal part, optional exponent
+    { re: NUMBER_REGEX, f: fNumber },
+    // String: double-quoted, handles escapes
+    { re: STRING_DOUBLE_REGEX, f: fStringDouble }
+  ];
+  if (relaxed) {
+    tokenSpecs = tokenSpecs.concat([
+      // Single-quoted strings
+      {
+        re: STRING_SINGLE_REGEX,
+        f: fStringSingle
+      },
+      // Single-line comments (// ...)
+      { re: COMMENT_SINGLE_REGEX, f: fComment },
+      // Multi-line comments (/* ... */)
+      { re: COMMENT_MULTI_REGEX, f: fComment },
+      // Unquoted identifiers (treated as strings)
+      // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
+      { re: IDENTIFIER_REGEX, f: fIdentifier }
+      // Note: The order matters here. Identifiers are checked after keywords/numbers.
+    ]);
   }
-  closeTextBlock(state, controller);
-  emitIncompleteToolCall(state, controller, toolCallStart);
-  controller.enqueue(chunk);
+  return tokenSpecs;
 }
-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;
+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;
     }
-    controller.enqueue({
-      type: "text-delta",
-      id: state.currentTextId,
-      textDelta: text,
-      delta: text
-    });
   }
+  return;
 }
-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,
-      textDelta: errorContent,
-      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 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 processTagMatch(context) {
-  const { state } = context;
-  if (state.isInsideToolCall) {
-    emitToolCall(context);
-    state.currentToolCallJson = "";
-    state.isInsideToolCall = false;
-  } else {
-    state.currentToolCallJson = "";
-    state.isInsideToolCall = true;
-  }
+function transform(text) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  return tokens.reduce((str, token) => str + token.match, "");
 }
-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 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 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 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}'`;
   }
 }
-var jsonMixProtocol = ({
-  toolCallStart = "<tool_call>",
-  toolCallEnd = "</tool_call>",
-  toolResponseStart = "<tool_response>",
-  toolResponseEnd = "</tool_response>"
-} = {}) => ({
-  formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
-      name: tool.name,
-      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
-      parameters: tool.inputSchema
-    }));
-    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
-  },
-  formatToolCall(toolCall) {
-    let args = {};
-    try {
-      args = JSON.parse(toolCall.input);
-    } catch (e) {
-      args = toolCall.input;
-    }
-    return `${toolCallStart}${JSON.stringify({
-      name: toolCall.toolName,
-      arguments: args
-    })}${toolCallEnd}`;
-  },
-  formatToolResponse(toolResult) {
-    return `${toolResponseStart}${JSON.stringify({
-      toolName: toolResult.toolName,
-      result: toolResult.result
-    })}${toolResponseEnd}`;
-  },
-  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
+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
       });
-      match = toolCallRegex.exec(text);
+      state.pos -= 1;
+    } else {
+      const err = new SyntaxError(message);
+      err.line = colon.line;
+      throw err;
     }
-    if (currentIndex < text.length) {
-      const remainingText = text.substring(currentIndex);
-      addTextSegment(remainingText, processedElements);
+  }
+}
+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;
     }
-    return processedElements;
-  },
-  createStreamParser({ options }) {
-    const state = {
-      isInsideToolCall: false,
-      buffer: "",
-      currentToolCallJson: "",
-      currentTextId: null,
-      hasEmittedTextStart: false
-    };
-    return new TransformStream({
-      transform(chunk, controller) {
-        var _a, _b;
-        if (chunk.type === "finish") {
-          handleFinishChunk(state, controller, toolCallStart, chunk);
-          return;
-        }
-        if (chunk.type !== "text-delta") {
-          controller.enqueue(chunk);
-          return;
-        }
-        const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
-        state.buffer += textContent;
-        processBufferTags({
-          state,
-          controller,
-          toolCallStart,
-          toolCallEnd,
-          options
+    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
         });
-        handlePartialTag(state, controller, toolCallStart);
+        token = popToken(tokens, state);
+      } else {
+        const err = new SyntaxError(message);
+        err.line = token.line;
+        throw err;
       }
-    });
-  },
-  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);
+    } else {
+      return token;
     }
-    return segments;
-  }
-});
-
-// src/core/protocols/morph-xml-protocol.ts
-var import_rxml2 = require("@ai-sdk-tool/rxml");
-
-// src/core/heuristics/engine.ts
-function applyRawSegmentUpdate(current, result) {
-  if (result.rawSegment !== void 0) {
-    return { ...current, rawSegment: result.rawSegment };
   }
-  return current;
 }
-function applyParsedUpdate(current, result) {
-  if (result.parsed !== void 0) {
-    return { ...current, parsed: result.parsed };
+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;
   }
-  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 raiseUnexpected(state, token, expected) {
+  raiseError(
+    state,
+    token,
+    `Unexpected token: ${strToken(token)}, expected ${expected}`
+  );
 }
-function attemptReparse(current, result, reparseCount, maxReparses, parse4) {
-  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
-    return { state: current, newCount: reparseCount };
+function checkDuplicates(state, obj, token) {
+  const key = String(token.value);
+  if (!state.duplicate && Object.hasOwn(obj, key)) {
+    raiseError(state, token, `Duplicate key: ${key}`);
   }
-  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 appendPair(state, obj, key, value) {
+  const finalValue = state.reviver ? state.reviver(key, value) : value;
+  if (finalValue !== void 0) {
+    obj[key] = finalValue;
   }
 }
-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;
+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;
     }
   }
-  return current;
+  checkDuplicates(state, obj, token);
+  const key = String(token.value);
+  skipColon(tokens, state);
+  value = parseAny(tokens, state);
+  appendPair(state, obj, key, value);
 }
-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] };
+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;
   }
-  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 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;
   }
-  return current;
+  opts.elementParser(tokens, state, result);
+  return null;
 }
-function createIntermediateCall(toolName, rawSegment, schema) {
-  return {
-    toolName,
-    schema,
-    rawSegment,
-    parsed: null,
-    errors: [],
-    meta: { originalContent: rawSegment }
-  };
+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;
 }
-
-// src/core/heuristics/xml-defaults.ts
-var import_rxml = require("@ai-sdk-tool/rxml");
-var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
-var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
-var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
-var WHITESPACE_REGEX2 = /\s/;
-var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
-var NAME_START_CHAR_RE = /[A-Za-z_:]/;
-var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
-var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
-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 };
+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;
     }
-    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 };
+  if (token.type === opts.endSymbol) {
+    return result;
+  }
+  if (token.type === ",") {
+    const handledResult = handleCommaToken({
+      token,
+      tokens,
+      state,
+      opts,
+      result
+    });
+    if (handledResult !== null) {
+      return handledResult;
     }
-    return {};
+    return;
   }
-};
-var balanceTagsHeuristic = {
-  id: "balance-tags",
-  phase: "fallback-reparse",
-  applies: (ctx) => {
-    var _a;
-    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
-    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
-    const balanced = balanceTags(original);
-    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
-    if (!hasMalformedClose && balanced.length > normalized.length) {
-      return false;
+  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;
     }
-    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);
+}
+function endChecks(tokens, state, ret) {
+  if (state.pos < tokens.length) {
+    if (state.tolerant) {
+      skipPunctuation(tokens, state);
     }
-    if (deduped !== ctx.rawSegment) {
-      return { rawSegment: deduped, reparse: true };
+    if (state.pos < tokens.length) {
+      raiseError(
+        state,
+        tokens[state.pos],
+        `Unexpected token: ${strToken(tokens[state.pos])}, expected end-of-input`
+      );
     }
-    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 {};
+  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;
   }
-};
-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;
-      }
+function parseAny(tokens, state, end = false) {
+  const token = skipPunctuation(tokens, state);
+  let ret;
+  if (token.type === "eof") {
+    if (end) {
+      raiseUnexpected(state, token, "json value");
     }
-    out += ch;
+    raiseUnexpected(state, token, "json value");
+    return;
   }
-  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));
+  switch (token.type) {
+    case "{":
+      ret = parseObject(tokens, state);
       break;
-    }
-    out.push(src.slice(i, lt));
-    if (lt + 1 >= len) {
+    case "[":
+      ret = parseArray(tokens, state);
       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);
+    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;
+      }
   }
-  for (let k = stack.length - 1; k >= 0; k -= 1) {
-    out.push(`</${stack[k]}>`);
+  if (end) {
+    ret = state.reviver ? state.reviver("", ret) : ret;
+    endChecks(tokens, state, ret);
   }
-  return out.join("");
+  return ret;
 }
-function skipWs(s, p, len) {
-  let idx = p;
-  while (idx < len && WHITESPACE_REGEX2.test(s[idx])) {
-    idx += 1;
+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."
+    );
   }
-  return idx;
+  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 parseTagNameAt(s, p, len) {
-  let idx = p;
-  const start = idx;
-  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
-    idx += 1;
+function createParseState(options) {
+  var _a, _b;
+  return {
+    pos: 0,
+    reviver: options.reviver,
+    tolerant: (_a = options.tolerant) != null ? _a : false,
+    duplicate: (_b = options.duplicate) != null ? _b : false,
+    warnings: []
+  };
+}
+function parseWithCustomParser(text, options) {
+  const lexerToUse = options.relaxed ? lexer : strictLexer;
+  let tokens = lexerToUse(text);
+  if (options.relaxed) {
+    tokens = stripTrailingComma(tokens);
+  }
+  tokens = tokens.filter((token) => token.type !== " ");
+  const state = createParseState(options);
+  return parseAny(tokens, state, true);
+}
+function parseWithTransform(text, options) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  const newtext = tokens.reduce((str, token) => str + token.match, "");
+  return JSON.parse(
+    newtext,
+    options.reviver
+  );
+}
+function parse2(text, optsOrReviver) {
+  const options = normalizeParseOptions(optsOrReviver);
+  if (!(options.relaxed || options.warnings || options.tolerant) && options.duplicate) {
+    return JSON.parse(
+      text,
+      options.reviver
+    );
+  }
+  if (options.warnings || options.tolerant || !options.duplicate) {
+    return parseWithCustomParser(text, options);
   }
-  return { name: s.slice(start, idx), pos: idx };
+  return parseWithTransform(text, options);
 }
-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 stringifyPair(obj, key) {
+  return `${JSON.stringify(key)}:${stringify(obj[key])}`;
 }
-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();
+function stringify(obj) {
+  const type = typeof obj;
+  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
+    return JSON.stringify(obj);
   }
-  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;
+  if (type === "undefined") {
+    return "null";
   }
-  let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX2.test(src[r])) {
-    r -= 1;
+  if (Array.isArray(obj)) {
+    const elements = obj.map(stringify).join(",");
+    return `[${elements}]`;
   }
-  const selfClosing = src[r] === "/";
-  out.push(src.slice(lt, q + 1));
-  if (!selfClosing && name) {
-    stack.push(name);
+  if (type === "object") {
+    const keys = Object.keys(obj);
+    keys.sort();
+    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
+    return `{${pairs}}`;
   }
-  return q + 1;
+  return "null";
 }
-function shouldDeduplicateStringTags(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return false;
-  }
-  const props = unwrapped.properties;
-  if (!props) {
-    return false;
-  }
-  const commandRaw = props.command;
-  if (!commandRaw) {
-    return false;
+
+// src/core/protocols/json-protocol.ts
+function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
+  var _a, _b;
+  try {
+    const parsedToolCall = parse2(toolCallJson);
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: generateId(),
+      toolName: parsedToolCall.name,
+      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+    });
+  } catch (error) {
+    logParseFailure({
+      phase: "generated-text",
+      reason: "Failed to parse tool call JSON segment",
+      snippet: fullMatch,
+      error
+    });
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+      options,
+      "Could not process JSON tool call, keeping original text.",
+      { toolCall: fullMatch, error }
+    );
+    processedElements.push({ type: "text", text: fullMatch });
   }
-  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
-  return (command == null ? void 0 : command.type) === "array";
 }
-function getStringPropertyNames(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return [];
+function addTextSegment(text, processedElements) {
+  if (text.trim()) {
+    processedElements.push({ type: "text", text });
   }
-  const props = unwrapped.properties;
-  if (!props) {
-    return [];
+}
+function processMatchedToolCall(context) {
+  const { match, text, currentIndex, processedElements, options } = context;
+  const startIndex = match.index;
+  const toolCallJson = match[1];
+  if (startIndex > currentIndex) {
+    const textSegment = text.substring(currentIndex, startIndex);
+    addTextSegment(textSegment, processedElements);
   }
-  const names = [];
-  for (const key of Object.keys(props)) {
-    const prop = (0, import_rxml.unwrapJsonSchema)(
-      props[key]
-    );
-    const type = prop.type;
-    if (type === "string") {
-      names.push(key);
-    }
+  if (toolCallJson) {
+    processToolCallJson(toolCallJson, match[0], processedElements, options);
   }
-  return names;
-}
-function escapeRegExp2(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return startIndex + match[0].length;
 }
-function dedupeSingleTag(xml, key) {
-  var _a, _b;
-  const escaped = escapeRegExp2(key);
-  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
-  const matches = Array.from(xml.matchAll(re));
-  if (matches.length <= 1) {
-    return xml;
+function flushBuffer(state, controller, toolCallStart) {
+  if (state.buffer.length === 0) {
+    return;
   }
-  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;
+  if (!state.currentTextId) {
+    state.currentTextId = generateId();
+    controller.enqueue({
+      type: "text-start",
+      id: state.currentTextId
+    });
+    state.hasEmittedTextStart = true;
   }
-  result += xml.slice(cursor);
-  return result;
+  const deltaContent = state.isInsideToolCall ? `${toolCallStart}${state.buffer}` : state.buffer;
+  controller.enqueue({
+    type: "text-delta",
+    id: state.currentTextId,
+    delta: deltaContent
+  });
+  state.buffer = "";
 }
-function repairParsedAgainstSchema(input, schema) {
-  if (!input || typeof input !== "object") {
-    return input;
+function closeTextBlock(state, controller) {
+  if (state.currentTextId && state.hasEmittedTextStart) {
+    controller.enqueue({
+      type: "text-end",
+      id: state.currentTextId
+    });
+    state.currentTextId = null;
+    state.hasEmittedTextStart = false;
   }
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return input;
+}
+function emitIncompleteToolCall(state, controller, toolCallStart) {
+  if (!state.currentToolCallJson) {
+    return;
   }
-  const properties = unwrapped.properties;
-  if (!properties) {
-    return input;
+  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);
   }
-  applySchemaProps(input, properties);
-  return input;
+  closeTextBlock(state, controller);
+  emitIncompleteToolCall(state, controller, toolCallStart);
+  controller.enqueue(chunk);
 }
-function applySchemaProps(obj, properties) {
-  for (const key of Object.keys(obj)) {
-    const propSchema = properties[key];
-    if (!propSchema) {
-      continue;
-    }
-    const prop = (0, import_rxml.unwrapJsonSchema)(propSchema);
-    const propType = prop.type;
-    if (propType === "array" && prop.items) {
-      const itemSchemaRaw = prop.items;
-      const itemSchema = (0, import_rxml.unwrapJsonSchema)(itemSchemaRaw);
-      obj[key] = coerceArrayItems(obj[key], itemSchema);
-      continue;
+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;
     }
-    if (propType === "object") {
-      const val = obj[key];
-      if (val && typeof val === "object") {
-        obj[key] = repairParsedAgainstSchema(val, prop);
+    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 = parse2(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 coerceArrayItems(val, itemSchema) {
-  if (!Array.isArray(val)) {
-    return val;
+function processTagMatch(context) {
+  const { state } = context;
+  if (state.isInsideToolCall) {
+    emitToolCall(context);
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = false;
+  } else {
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = true;
   }
-  return val.map((v) => coerceArrayItem(v, itemSchema));
 }
-function coerceArrayItem(v, itemSchema) {
-  const itemType = itemSchema == null ? void 0 : itemSchema.type;
-  if (typeof v === "string" && itemType === "object") {
-    const parsed = tryParseStringToSchemaObject(v, itemSchema);
-    if (parsed !== null) {
-      return parsed;
+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;
     }
-    const fallback = extractStepStatusFromString(
-      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
+    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
     );
-    if (fallback) {
-      return fallback;
-    }
-    return v;
-  }
-  if (v && typeof v === "object" && itemType === "object") {
-    return repairParsedAgainstSchema(v, itemSchema);
   }
-  return v;
 }
-function tryParseStringToSchemaObject(xml, itemSchema) {
-  try {
-    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
-    const fixed = (0, import_rxml.parse)(normalized, itemSchema, { noChildNodes: [] });
-    return typeof fixed === "string" ? null : fixed;
-  } catch (e) {
-    return null;
+function 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 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] };
+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 = escapeRegExp2(toolCallStart);
+    const endEsc = escapeRegExp2(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 = escapeRegExp2(toolCallStart);
+    const endEsc = escapeRegExp2(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;
   }
-  return null;
+});
+
+// src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+function isTCMProtocolFactory(protocol) {
+  return typeof protocol === "function";
 }
 
-// src/core/protocols/morph-xml-protocol.ts
+// src/core/protocols/xml-protocol.ts
+import { extractRawInner, parse as parse3, stringify as stringify2 } from "@ai-sdk-tool/rxml";
 var defaultPipelineConfig2 = defaultPipelineConfig;
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX3 = /\s/;
@@ -1652,7 +1652,7 @@ function normalizeCloseTags(xml) {
 function tryParseSecondaryXml(content, toolSchema, options) {
   const balanced = balanceTags(content);
   try {
-    let parsed = (0, import_rxml2.parse)(balanced, toolSchema, {
+    let parsed = parse3(balanced, toolSchema, {
       onError: options == null ? void 0 : options.onError,
       noChildNodes: []
     });
@@ -1667,7 +1667,7 @@ function tryParseSecondaryXml(content, toolSchema, options) {
       }
       if (deduped !== balanced) {
         try {
-          let reparsed = (0, import_rxml2.parse)(deduped, toolSchema, {
+          let reparsed = parse3(deduped, toolSchema, {
             onError: options == null ? void 0 : options.onError,
             noChildNodes: []
           });
@@ -1699,7 +1699,7 @@ function processToolCallWithPipeline(params) {
     toolSchema
   );
   const result = applyHeuristicPipeline(ctx, pipelineConfig, {
-    parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+    parse: (xml, schema) => parse3(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
     onError: options == null ? void 0 : options.onError,
     maxReparses
   });
@@ -1744,7 +1744,7 @@ function handleStreamingToolCallEnd(params) {
       toolSchema
     );
     const result = applyHeuristicPipeline(ctx, pipelineConfig, {
-      parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+      parse: (xml, schema) => parse3(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
       onError: options == null ? void 0 : options.onError,
       maxReparses
     });
@@ -1752,7 +1752,7 @@ function handleStreamingToolCallEnd(params) {
   } else {
     try {
       const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
-      const parsed = (0, import_rxml2.parse)(primary, toolSchema, {
+      const parsed = parse3(primary, toolSchema, {
         onError: options == null ? void 0 : options.onError,
         noChildNodes: []
       });
@@ -1909,7 +1909,7 @@ function findToolCallsForName(text, toolName) {
     const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
     if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
       const segment = text.substring(tagStart, fullTagEnd);
-      const inner = (_a = (0, import_rxml2.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+      const inner = (_a = extractRawInner(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
       toolCalls.push({
         toolName,
         startIndex: tagStart,
@@ -1972,7 +1972,6 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2134,7 +2133,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
     }
   };
 }
-var morphXmlProtocol = (protocolOptions) => {
+var xmlProtocol = (protocolOptions) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   let pipelineConfig = protocolOptions == null ? void 0 : protocolOptions.pipeline;
   const maxReparses = protocolOptions == null ? void 0 : protocolOptions.maxReparses;
@@ -2174,40 +2173,22 @@ var morphXmlProtocol = (protocolOptions) => {
   }
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      const toolsForPrompt = (tools || []).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, import_rxml2.unwrapJsonSchema)(tool.inputSchema)
-      }));
-      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+      return toolSystemPromptTemplate(tools || []);
     },
     formatToolCall(toolCall) {
       let args = {};
-      try {
-        args = JSON.parse(toolCall.input);
-      } catch (e) {
-        args = toolCall.input;
+      if (toolCall.input != null) {
+        try {
+          args = JSON.parse(toolCall.input);
+        } catch (e) {
+          args = toolCall.input;
+        }
       }
-      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
+      return stringify2(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: false
       });
     },
-    formatToolResponse(toolResult) {
-      let result = toolResult.result;
-      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
-        result = result.value;
-      }
-      const xml = (0, import_rxml2.stringify)(
-        "tool_response",
-        {
-          tool_name: toolResult.toolName,
-          result
-        },
-        { declaration: false }
-      );
-      return xml;
-    },
     parseGeneratedText({ text, tools, options }) {
       const toolNames = tools.map((t) => t.name).filter(Boolean);
       if (toolNames.length === 0) {
@@ -2276,7 +2257,7 @@ var morphXmlProtocol = (protocolOptions) => {
       );
       return new TransformStream({
         transform(chunk, controller) {
-          var _a2, _b2;
+          var _a2;
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -2285,7 +2266,7 @@ var morphXmlProtocol = (protocolOptions) => {
             controller.enqueue(chunk);
             return;
           }
-          const textContent = (_b2 = (_a2 = chunk.textDelta) != null ? _a2 : chunk.delta) != null ? _b2 : "";
+          const textContent = (_a2 = chunk.delta) != null ? _a2 : "";
           buffer += textContent;
           processBuffer(controller);
         },
@@ -2320,9 +2301,8 @@ var morphXmlProtocol = (protocolOptions) => {
   };
 };
 
-// src/core/protocols/yaml-xml-protocol.ts
-var import_rxml3 = require("@ai-sdk-tool/rxml");
-var import_yaml = __toESM(require("yaml"), 1);
+// src/core/protocols/yaml-protocol.ts
+import YAML from "yaml";
 var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX4 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
@@ -2469,7 +2449,7 @@ function parseYamlContent(yamlContent, options) {
     normalized = lines.map((line) => line.slice(minIndent)).join("\n");
   }
   try {
-    const doc = import_yaml.default.parseDocument(normalized);
+    const doc = YAML.parseDocument(normalized);
     if (doc.errors && doc.errors.length > 0) {
       (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "YAML parse error", {
         errors: doc.errors.map((e) => e.message)
@@ -2542,7 +2522,6 @@ function createFlushTextHandler2(getCurrentTextId, setCurrentTextId, getHasEmitt
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2590,42 +2569,24 @@ function findEarliestToolTag2(buffer, toolNames) {
     tagLength: bestTagLength
   };
 }
-var yamlXmlProtocol = (_protocolOptions) => {
+var yamlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      const toolsForPrompt = (tools || []).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, import_rxml3.unwrapJsonSchema)(tool.inputSchema)
-      }));
-      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+      return toolSystemPromptTemplate(tools || []);
     },
     formatToolCall(toolCall) {
       let args = {};
-      try {
-        args = JSON.parse(toolCall.input);
-      } catch (e) {
-        args = { value: toolCall.input };
+      if (toolCall.input != null) {
+        try {
+          args = JSON.parse(toolCall.input);
+        } catch (e) {
+          args = { value: toolCall.input };
+        }
       }
-      const yamlContent = import_yaml.default.stringify(args);
+      const yamlContent = YAML.stringify(args);
       return `<${toolCall.toolName}>
 ${yamlContent}</${toolCall.toolName}>`;
     },
-    formatToolResponse(toolResult) {
-      let result = toolResult.result;
-      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
-        result = result.value;
-      }
-      const xml = (0, import_rxml3.stringify)(
-        "tool_response",
-        {
-          tool_name: toolResult.toolName,
-          result
-        },
-        { declaration: false }
-      );
-      return xml;
-    },
     parseGeneratedText({ text, tools, options }) {
       const toolNames = tools.map((t) => t.name).filter(Boolean);
       if (toolNames.length === 0) {
@@ -2739,7 +2700,7 @@ ${yamlContent}</${toolCall.toolName}>`;
       };
       return new TransformStream({
         transform(chunk, controller) {
-          var _a, _b;
+          var _a;
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -2748,7 +2709,7 @@ ${yamlContent}</${toolCall.toolName}>`;
             controller.enqueue(chunk);
             return;
           }
-          const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+          const textContent = (_a = chunk.delta) != null ? _a : "";
           buffer += textContent;
           processBuffer(controller);
         },
@@ -2784,48 +2745,62 @@ ${yamlContent}</${toolCall.toolName}>`;
     }
   };
 };
-function orchestratorSystemPromptTemplate(tools, includeMultilineExample = true) {
-  const multilineExample = includeMultilineExample ? `
-
-For multiline values, use YAML's literal block syntax:
-<write_file>
-file_path: /tmp/example.txt
-contents: |
-  First line
-  Second line
-  Third line
-</write_file>` : "";
-  return `# Tools
 
-You may call one or more functions to assist with the user query.
-
-You are provided with function signatures within <tools></tools> XML tags:
-<tools>${tools}</tools>
-
-# Format
-
-Use exactly one XML element whose tag name is the function name.
-Inside the XML element, specify parameters using YAML syntax (key: value pairs).
-
-# Example
-<get_weather>
-location: New York
-unit: celsius
-</get_weather>${multilineExample}
-
-# Rules
-- Parameter names and values must follow the schema exactly.
-- Use proper YAML syntax for values (strings, numbers, booleans, arrays, objects).
-- Each required parameter must appear once.
-- Do not add functions or parameters not in the schema.
-- After calling a tool, you will receive a response. Use this result to answer the user.
-- Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
-- If a task requires multiple function calls, make ALL of them at once.`;
-}
-
-// src/core/protocols/tool-call-protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/core/utils/dynamic-tool-schema.ts
+function createDynamicIfThenElseSchema(tools) {
+  let currentSchema = {};
+  const toolNames = [];
+  for (let i = tools.length - 1; i >= 0; i -= 1) {
+    const tool = tools[i];
+    if (tool.type === "provider") {
+      throw new Error(
+        "Provider tools are not supported by this middleware. Please use function tools."
+      );
+    }
+    toolNames.unshift(tool.name);
+    const toolCondition = {
+      if: {
+        properties: {
+          name: {
+            const: tool.name
+          }
+        },
+        required: ["name"]
+      },
+      // biome-ignore lint/suspicious/noThenProperty: JSON Schema uses 'then' as a keyword
+      then: {
+        properties: {
+          name: {
+            const: tool.name
+          },
+          arguments: tool.inputSchema
+        },
+        required: ["name", "arguments"]
+      }
+    };
+    if (Object.keys(currentSchema).length > 0) {
+      toolCondition.else = currentSchema;
+    }
+    currentSchema = toolCondition;
+  }
+  return {
+    type: "object",
+    // Explicitly specify type as "object"
+    properties: {
+      name: {
+        type: "string",
+        description: "Name of the tool to call",
+        enum: toolNames
+      },
+      arguments: {
+        type: "object",
+        // By default, arguments is also specified as object type
+        description: "Argument object to be passed to the tool"
+      }
+    },
+    required: ["name", "arguments"],
+    ...currentSchema
+  };
 }
 
 // src/core/utils/on-error.ts
@@ -2861,15 +2836,30 @@ function decodeOriginalTools(originalTools) {
     })
   );
 }
+function extractToolNamesFromOriginalTools(originalTools) {
+  return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
+}
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
   return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
 }
 
-// src/v6/generate-handler.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_rxml4 = require("@ai-sdk-tool/rxml");
+// src/core/utils/type-guards.ts
+function isToolResultPart(content) {
+  if (!content || typeof content !== "object") {
+    return false;
+  }
+  const c = content;
+  return c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+}
+function hasInputProperty(obj) {
+  return typeof obj === "object" && obj !== null && "input" in obj;
+}
+
+// src/generate-handler.ts
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+import { coerceBySchema } from "@ai-sdk-tool/rxml";
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -2913,7 +2903,7 @@ async function handleToolChoice(doGenerate, params) {
   }
   const toolCall = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils.generateId)(),
+    toolCallId: generateId2(),
     toolName: parsed.name || "unknown",
     input: JSON.stringify(parsed.arguments || {})
   };
@@ -3020,92 +3010,218 @@ function fixToolCallWithSchema(part, tools) {
   if (part.type !== "tool-call") {
     return part;
   }
-  const tc = part;
   let args = {};
-  if (typeof tc.input === "string") {
+  if (typeof part.input === "string") {
     try {
-      args = JSON.parse(tc.input);
+      args = JSON.parse(part.input);
     } catch (e) {
       return part;
     }
-  } else if (tc.input && typeof tc.input === "object") {
-    args = tc.input;
+  } else if (part.input && typeof part.input === "object") {
+    args = part.input;
   }
-  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml4.coerceBySchema)(args, schema);
+  const schema = (_a = tools.find((t) => t.name === part.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
   };
 }
 
-// src/v6/stream-handler.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-function mapCorePartToV3(part) {
-  switch (part.type) {
-    case "text-delta":
-      return {
-        type: "text-delta",
-        id: part.id || (0, import_provider_utils2.generateId)(),
-        delta: part.textDelta
-      };
-    case "tool-call":
-      return {
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        input: part.input
-      };
-    case "tool-call-delta":
-      return {
-        type: "tool-call-delta",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        argsTextDelta: part.argsTextDelta
-      };
-    case "finish":
-      return {
-        type: "finish",
-        finishReason: part.finishReason,
-        usage: part.usage
-      };
-    case "error":
-      return {
-        type: "error",
-        error: part.error
-      };
-    default:
-      return part;
+// src/core/prompts/hermes-system-prompt.ts
+function hermesSystemPromptTemplate(tools) {
+  const toolsJson = JSON.stringify(tools);
+  return `You are a function calling AI model.
+You are provided with function signatures within <tools></tools> XML tags.
+You may call one or more functions to assist with the user query.
+Don't make assumptions about what values to plug into functions.
+Here are the available tools: <tools>${toolsJson}</tools>
+Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
+}
+
+// src/core/prompts/tool-response.ts
+function unwrapToolResult(result) {
+  var _a, _b;
+  switch (result.type) {
+    case "text":
+      return (_a = result.value) != null ? _a : "";
+    case "json":
+      return result.value;
+    case "execution-denied": {
+      const reason = result.reason;
+      return reason ? `[Execution Denied: ${reason}]` : "[Execution Denied]";
+    }
+    case "error-text":
+      return `[Error: ${(_b = result.value) != null ? _b : ""}]`;
+    case "error-json":
+      return `[Error: ${JSON.stringify(result.value)}]`;
+    case "content": {
+      return result.value.map((part) => {
+        var _a2;
+        const contentPart = part;
+        switch (contentPart.type) {
+          case "text":
+            return (_a2 = contentPart.text) != null ? _a2 : "";
+          case "image-data":
+            return `[Image: ${contentPart.mediaType}]`;
+          case "image-url":
+            return `[Image URL: ${contentPart.url}]`;
+          case "image-file-id": {
+            const fileId = contentPart.fileId;
+            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+            return `[Image ID: ${displayId}]`;
+          }
+          case "file-data": {
+            const filePart = contentPart;
+            if (filePart.filename) {
+              return `[File: ${filePart.filename} (${filePart.mediaType})]`;
+            }
+            return `[File: ${filePart.mediaType}]`;
+          }
+          case "file-url":
+            return `[File URL: ${contentPart.url}]`;
+          case "file-id": {
+            const fileId = contentPart.fileId;
+            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+            return `[File ID: ${displayId}]`;
+          }
+          case "media":
+            return `[Media: ${contentPart.mediaType}]`;
+          case "custom":
+            return "[Custom content]";
+          default:
+            return "[Unknown content]";
+        }
+      }).join("\n");
+    }
+    default: {
+      const _exhaustive = result;
+      return _exhaustive;
+    }
   }
 }
-function mapV3PartToCore(part) {
-  const p = part;
-  switch (p.type) {
-    case "text-delta":
-      return {
-        type: "text-delta",
-        id: p.id,
-        textDelta: p.delta || p.textDelta || ""
-      };
-    case "tool-call":
-      return {
-        type: "tool-call",
-        toolCallId: p.toolCallId,
-        toolName: p.toolName,
-        input: p.input
-      };
-    case "finish": {
-      const finishReason = p.finishReason;
-      return {
-        type: "finish",
-        finishReason: (typeof finishReason === "object" ? finishReason == null ? void 0 : finishReason.unified : finishReason) || "stop",
-        usage: p.usage
-      };
+function formatToolResponseAsJsonInXml(toolResult) {
+  const unwrappedResult = unwrapToolResult(toolResult.output);
+  return `<tool_response>${JSON.stringify({
+    toolName: toolResult.toolName,
+    result: unwrappedResult
+  })}</tool_response>`;
+}
+function formatToolResponseAsXml(toolResult) {
+  const unwrappedResult = unwrapToolResult(toolResult.output);
+  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
+  const resultLines = formatXmlNode("result", unwrappedResult, 1);
+  return [
+    "<tool_response>",
+    `  ${toolNameXml}`,
+    ...resultLines,
+    "</tool_response>"
+  ].join("\n");
+}
+function formatXmlNode(tagName, value, depth) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${indent}<${tagName}></${tagName}>`];
     }
-    default:
-      return p;
+    const lines2 = [`${indent}<${tagName}>`];
+    for (const item of value) {
+      lines2.push(...formatXmlNode("item", item, depth + 1));
+    }
+    lines2.push(`${indent}</${tagName}>`);
+    return lines2;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  const lines = [`${indent}<${tagName}>`];
+  for (const [key, entryValue] of entries) {
+    lines.push(...formatXmlNode(key, entryValue, depth + 1));
   }
+  lines.push(`${indent}</${tagName}>`);
+  return lines;
+}
+
+// src/core/prompts/xml-system-prompt.ts
+function xmlSystemPromptTemplate(tools) {
+  const toolsJson = JSON.stringify(tools);
+  return `# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>${toolsJson}</tools>
+
+# Rules
+- Use exactly one XML element whose tag name is the function name.
+- Put each parameter as a child element.
+- Values must follow the schema exactly (numbers, arrays, objects, enums \u2192 copy as-is).
+- Do not add or remove functions or parameters.
+- Each required parameter must appear once.
+- Output nothing before or after the function call.
+- After calling a tool, you will receive a response in the format: <tool_response><tool_name>NAME</tool_name><result>RESULT</result></tool_response>. Use this result to answer the user.
+
+# Example
+<get_weather>
+  <location>New York</location>
+  <unit>celsius</unit>
+</get_weather>`;
+}
+
+// src/core/prompts/yaml-system-prompt.ts
+function yamlSystemPromptTemplate(tools, includeMultilineExample = true) {
+  const toolsJson = JSON.stringify(tools);
+  const multilineExample = includeMultilineExample ? `
+
+For multiline values, use YAML's literal block syntax:
+<write_file>
+file_path: /tmp/example.txt
+contents: |
+  First line
+  Second line
+  Third line
+</write_file>` : "";
+  return `# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>${toolsJson}</tools>
+
+# Format
+
+Use exactly one XML element whose tag name is the function name.
+Inside the XML element, specify parameters using YAML syntax (key: value pairs).
+
+# Example
+<get_weather>
+location: New York
+unit: celsius
+</get_weather>${multilineExample}
+
+# Rules
+- Parameter names and values must follow the schema exactly.
+- Use proper YAML syntax for values (strings, numbers, booleans, arrays, objects).
+- Each required parameter must appear once.
+- Do not add functions or parameters not in the schema.
+- After calling a tool, you will receive a response. Use this result to answer the user.
+- Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
+- If a task requires multiple function calls, make ALL of them at once.`;
 }
+
+// src/stream-handler.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
 async function wrapStream({
   protocol,
   doStream,
@@ -3129,23 +3245,24 @@ async function wrapStream({
     ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
   };
   const coreStream = stream.pipeThrough(
-    new TransformStream({
-      transform(part, controller) {
-        if (debugLevel === "stream") {
-          logRawChunk(part);
+    new TransformStream(
+      {
+        transform(part, controller) {
+          if (debugLevel === "stream") {
+            logRawChunk(part);
+          }
+          controller.enqueue(part);
         }
-        controller.enqueue(mapV3PartToCore(part));
       }
-    })
+    )
   ).pipeThrough(protocol.createStreamParser({ tools, options }));
   const v3Stream = coreStream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
-        const v3Part = mapCorePartToV3(part);
         if (debugLevel === "stream") {
-          logParsedChunk(v3Part);
+          logParsedChunk(part);
         }
-        controller.enqueue(v3Part);
+        controller.enqueue(part);
       }
     })
   );
@@ -3180,7 +3297,7 @@ async function toolChoiceStream({
     start(controller) {
       controller.enqueue({
         type: "tool-call",
-        toolCallId: (0, import_provider_utils2.generateId)(),
+        toolCallId: generateId3(),
         toolName: toolJson.name || "unknown",
         input: JSON.stringify(toolJson.arguments || {})
       });
@@ -3202,70 +3319,7 @@ async function toolChoiceStream({
   };
 }
 
-// src/core/utils/dynamic-tool-schema.ts
-function createDynamicIfThenElseSchema(tools) {
-  let currentSchema = {};
-  const toolNames = [];
-  for (let i = tools.length - 1; i >= 0; i -= 1) {
-    const tool = tools[i];
-    if (tool.type === "provider") {
-      throw new Error(
-        "Provider tools are not supported by this middleware. Please use function tools."
-      );
-    }
-    toolNames.unshift(tool.name);
-    const toolCondition = {
-      if: {
-        properties: {
-          name: {
-            const: tool.name
-          }
-        },
-        required: ["name"]
-      },
-      // biome-ignore lint/suspicious/noThenProperty: JSON Schema uses 'then' as a keyword
-      then: {
-        properties: {
-          name: {
-            const: tool.name
-          },
-          arguments: tool.inputSchema
-        },
-        required: ["name", "arguments"]
-      }
-    };
-    if (Object.keys(currentSchema).length > 0) {
-      toolCondition.else = currentSchema;
-    }
-    currentSchema = toolCondition;
-  }
-  return {
-    type: "object",
-    // Explicitly specify type as "object"
-    properties: {
-      name: {
-        type: "string",
-        description: "Name of the tool to call",
-        enum: toolNames
-      },
-      arguments: {
-        type: "object",
-        // By default, arguments is also specified as object type
-        description: "Argument object to be passed to the tool"
-      }
-    },
-    required: ["name", "arguments"],
-    ...currentSchema
-  };
-}
-
-// src/core/utils/type-guards.ts
-function isToolCallContent(content) {
-  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
-  (typeof content.input === "string" || typeof content.input === "object");
-}
-
-// src/v6/transform-handler.ts
+// src/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
   const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
   if (systemIndex !== -1) {
@@ -3408,10 +3462,11 @@ function transformParams({
   params,
   protocol,
   toolSystemPromptTemplate,
+  toolResponsePromptTemplate,
   placement = "first"
 }) {
-  var _a, _b, _c, _d, _e;
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  var _a, _b, _c, _d;
+  const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   const functionTools = ((_a = params.tools) != null ? _a : []).filter(
     (t) => t.type === "function"
   );
@@ -3419,9 +3474,18 @@ function transformParams({
     tools: functionTools,
     toolSystemPromptTemplate
   });
+  let normalizedPrompt;
+  if (Array.isArray(params.prompt)) {
+    normalizedPrompt = params.prompt;
+  } else if (params.prompt) {
+    normalizedPrompt = [params.prompt];
+  } else {
+    normalizedPrompt = [];
+  }
   const processedPrompt = convertToolPrompt(
-    (_b = params.prompt) != null ? _b : [],
+    normalizedPrompt,
     resolvedProtocol,
+    toolResponsePromptTemplate,
     extractOnErrorOption(params.providerOptions)
   );
   const finalPrompt = buildFinalPrompt(
@@ -3434,15 +3498,15 @@ function transformParams({
     finalPrompt,
     functionTools
   );
-  if (((_c = params.toolChoice) == null ? void 0 : _c.type) === "none") {
+  if (((_b = params.toolChoice) == null ? void 0 : _b.type) === "none") {
     throw new Error(
       "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
     );
   }
-  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "tool") {
+  if (((_c = params.toolChoice) == null ? void 0 : _c.type) === "tool") {
     return handleToolChoiceTool(params, baseReturnParams);
   }
-  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "required") {
+  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "required") {
     return handleToolChoiceRequired(params, baseReturnParams, functionTools);
   }
   return baseReturnParams;
@@ -3451,26 +3515,29 @@ function processAssistantContent(content, resolvedProtocol, providerOptions) {
   var _a;
   const newContent = [];
   for (const item of content) {
-    if (isToolCallContent(item)) {
-      newContent.push({
-        type: "text",
-        text: resolvedProtocol.formatToolCall(item)
-      });
-    } else if (item.type === "text") {
-      newContent.push(item);
-    } else if (item.type === "reasoning") {
-      newContent.push(item);
-    } else {
-      const options = extractOnErrorOption(providerOptions);
-      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-        options,
-        "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
-        { content: item }
-      );
-      newContent.push({
-        type: "text",
-        text: JSON.stringify(item)
-      });
+    switch (item.type) {
+      case "tool-call":
+        newContent.push({
+          type: "text",
+          text: resolvedProtocol.formatToolCall(item)
+        });
+        break;
+      case "text":
+      case "reasoning":
+        newContent.push(item);
+        break;
+      default: {
+        const options = extractOnErrorOption(providerOptions);
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+          options,
+          "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+          { content: item }
+        );
+        newContent.push({
+          type: "text",
+          text: JSON.stringify(item)
+        });
+      }
     }
   }
   const onlyText = newContent.every((c) => c.type === "text");
@@ -3481,25 +3548,28 @@ function processAssistantContent(content, resolvedProtocol, providerOptions) {
     }
   ] : newContent;
 }
-function processToolMessage(content, resolvedProtocol) {
+function formatApprovalResponse(part) {
+  const status = part.approved ? "Approved" : "Denied";
+  const reason = part.reason ? `: ${part.reason}` : "";
+  return `[Tool Approval ${status}${reason}]`;
+}
+function processToolMessage(toolResults, approvalResponses, toolResponsePromptTemplate) {
+  const resultTexts = toolResults.map((toolResult) => {
+    return toolResponsePromptTemplate(toolResult);
+  });
+  const approvalTexts = approvalResponses.map(formatApprovalResponse);
+  const allTexts = [...resultTexts, ...approvalTexts];
   return {
     role: "user",
     content: [
       {
         type: "text",
-        text: content.map((toolResult) => {
-          var _a, _b;
-          const tr = toolResult;
-          return resolvedProtocol.formatToolResponse({
-            ...toolResult,
-            result: (_b = (_a = tr.result) != null ? _a : tr.content) != null ? _b : tr.output
-          });
-        }).join("\n")
+        text: allTexts.join("\n")
       }
     ]
   };
 }
-function processMessage(message, resolvedProtocol, providerOptions) {
+function processMessage(message, resolvedProtocol, providerOptions, toolResponsePromptTemplate) {
   if (message.role === "assistant") {
     const condensedContent = processAssistantContent(
       message.content,
@@ -3512,10 +3582,23 @@ function processMessage(message, resolvedProtocol, providerOptions) {
     };
   }
   if (message.role === "tool") {
-    const toolResultParts = message.content.filter(
+    const toolContent = message.content;
+    const toolResultParts = toolContent.filter(
       (part) => part.type === "tool-result"
     );
-    return processToolMessage(toolResultParts, resolvedProtocol);
+    const approvalResponseParts = toolContent.filter(
+      (part) => part.type === "tool-approval-response"
+    );
+    if (!toolResponsePromptTemplate) {
+      throw new Error(
+        'toolResponsePromptTemplate is required when processing messages with role "tool". This parameter is optional for other roles but is required here so tool-result content can be converted into a prompt. Ensure your middleware or transform configuration passes a toolResponsePromptTemplate when tool message processing is enabled.'
+      );
+    }
+    return processToolMessage(
+      toolResultParts,
+      approvalResponseParts,
+      toolResponsePromptTemplate
+    );
   }
   return message;
 }
@@ -3578,22 +3661,28 @@ ${currentContent}` }]
   }
   return processedPrompt;
 }
-function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+function convertToolPrompt(prompt, resolvedProtocol, toolResponsePromptTemplate, providerOptions) {
   let processedPrompt = prompt.map(
-    (message) => processMessage(message, resolvedProtocol, providerOptions)
+    (message) => processMessage(
+      message,
+      resolvedProtocol,
+      providerOptions,
+      toolResponsePromptTemplate
+    )
   );
   processedPrompt = condenseTextContent(processedPrompt);
   processedPrompt = mergeConsecutiveUserMessages(processedPrompt);
   return processedPrompt;
 }
 
-// src/v6/tool-call-middleware.ts
+// src/tool-call-middleware.ts
 function createToolMiddleware({
   protocol,
   toolSystemPromptTemplate,
+  toolResponsePromptTemplate,
   placement = "last"
 }) {
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   return {
     specificationVersion: "v3",
     wrapStream: ({ doStream, doGenerate, params }) => {
@@ -3618,83 +3707,71 @@ function createToolMiddleware({
     transformParams: async ({ params }) => transformParams({
       protocol: resolvedProtocol,
       toolSystemPromptTemplate,
+      toolResponsePromptTemplate,
       placement,
       params
     })
   };
 }
 
-// src/v6/index.ts
-var gemmaToolMiddleware = createToolMiddleware({
-  protocol: jsonMixProtocol({
-    toolCallStart: "```tool_call\n",
-    toolCallEnd: "\n```",
-    toolResponseStart: "```tool_response\n",
-    toolResponseEnd: "\n```"
-  }),
-  toolSystemPromptTemplate(tools) {
-    return `You have access to functions. If you decide to invoke any of the function(s),
-you MUST put it in the format of markdown code fence block with the language name of tool_call , e.g.
-\`\`\`tool_call
-{'name': <function-name>, 'arguments': <args-dict>}
-\`\`\`
-You SHOULD NOT include any other text in the response if you call a function
-${tools}`;
-  }
-});
+// src/preconfigured-middleware.ts
 var hermesToolMiddleware = createToolMiddleware({
-  protocol: jsonMixProtocol,
-  toolSystemPromptTemplate(tools) {
-    return `You are a function calling AI model.
-You are provided with function signatures within <tools></tools> XML tags.
-You may call one or more functions to assist with the user query.
-Don't make assumptions about what values to plug into functions.
-Here are the available tools: <tools>${tools}</tools>
-Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
-For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
-<tool_call>
-{"name": "<function-name>", "arguments": <args-dict>}
-</tool_call>`;
-  }
+  protocol: jsonProtocol({}),
+  toolSystemPromptTemplate: hermesSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsJsonInXml
 });
-var morphXmlToolMiddleware = createToolMiddleware({
-  protocol: morphXmlProtocol,
-  placement: "first",
-  toolSystemPromptTemplate(tools) {
-    return `# Tools
-
-You may call one or more functions to assist with the user query.
-
-You are provided with function signatures within <tools></tools> XML tags:
-<tools>${tools}</tools>
-
-# Rules
-- Use exactly one XML element whose tag name is the function name.
-- Put each parameter as a child element.
-- Values must follow the schema exactly (numbers, arrays, objects, enums \u2192 copy as-is).
-- Do not add or remove functions or parameters.
-- Each required parameter must appear once.
-- Output nothing before or after the function call.
-- After calling a tool, you will receive a response in the format: <tool_response><tool_name>NAME</tool_name><result>RESULT</result></tool_response>. Use this result to answer the user.
-
-# Example
-<get_weather>
-  <location>New York</location>
-  <unit>celsius</unit>
-</get_weather>`;
-  }
+var xmlToolMiddleware = createToolMiddleware({
+  protocol: xmlProtocol({}),
+  toolSystemPromptTemplate: xmlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsXml
 });
-var orchestratorToolMiddleware = createToolMiddleware({
-  protocol: yamlXmlProtocol(),
-  placement: "first",
-  toolSystemPromptTemplate: orchestratorSystemPromptTemplate
+var yamlToolMiddleware = createToolMiddleware({
+  protocol: yamlProtocol({}),
+  toolSystemPromptTemplate: yamlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsXml
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+
+export {
+  applyHeuristicPipeline,
+  createIntermediateCall,
+  mergePipelineConfigs,
+  normalizeCloseTagsHeuristic,
+  escapeInvalidLtHeuristic,
+  balanceTagsHeuristic,
+  dedupeShellStringTagsHeuristic,
+  repairAgainstSchemaHeuristic,
+  defaultPipelineConfig,
+  getDebugLevel,
+  logParseFailure,
+  logRawChunk,
+  logParsedChunk,
+  logParsedSummary,
+  getPotentialStartIndex,
+  escapeRegExp2 as escapeRegExp,
+  transform,
+  parse2 as parse,
+  stringify,
+  jsonProtocol,
+  isProtocolFactory,
+  isTCMProtocolFactory,
+  xmlProtocol,
+  yamlProtocol,
+  createDynamicIfThenElseSchema,
+  extractOnErrorOption,
+  originalToolsSchema,
+  encodeOriginalTools,
+  decodeOriginalTools,
+  extractToolNamesFromOriginalTools,
+  isToolChoiceActive,
+  isToolResultPart,
+  hasInputProperty,
+  wrapGenerate,
+  wrapStream,
+  toolChoiceStream,
+  transformParams,
   createToolMiddleware,
-  gemmaToolMiddleware,
   hermesToolMiddleware,
-  morphXmlToolMiddleware,
-  orchestratorToolMiddleware
-});
-//# sourceMappingURL=v6.cjs.map
+  xmlToolMiddleware,
+  yamlToolMiddleware
+};
+//# sourceMappingURL=chunk-WX5U7G6L.js.map