@ai-sdk-tool/parser 2.1.7 → 3.0.0-canary.1

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "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)
@@ -17,20 +15,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/index.ts
 var src_exports = {};
 __export(src_exports, {
-  RJSON: () => robust_json_exports,
   createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
   createToolMiddleware: () => createToolMiddleware,
   decodeOriginalTools: () => decodeOriginalTools,
@@ -47,75 +36,175 @@ __export(src_exports, {
   isToolChoiceActive: () => isToolChoiceActive,
   isToolResultPart: () => isToolResultPart,
   jsonMixProtocol: () => jsonMixProtocol,
+  logParseFailure: () => logParseFailure,
   logParsedChunk: () => logParsedChunk,
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
   morphXmlProtocol: () => morphXmlProtocol,
   morphXmlToolMiddleware: () => morphXmlToolMiddleware,
-  originalToolsSchema: () => originalToolsSchema
+  originalToolsSchema: () => originalToolsSchema,
+  parseRJSON: () => parse,
+  stringifyRJSON: () => stringify,
+  transformRJSON: () => transform
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/protocols/dummy-protocol.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-
 // src/protocols/json-mix-protocol.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
-// src/utils/dynamic-tool-schema.ts
-function createDynamicIfThenElseSchema(tools) {
-  let currentSchema = {};
-  const toolNames = [];
-  for (let i = tools.length - 1; i >= 0; i--) {
-    const tool = tools[i];
-    if (tool.type === "provider-defined") {
-      throw new Error(
-        "Provider-defined tools are not supported by this middleware. Please use custom tools."
-      );
-    }
-    toolNames.unshift(tool.name);
-    const toolCondition = {
-      if: {
-        properties: {
-          name: {
-            const: tool.name
-          }
-        },
-        required: ["name"]
-      },
-      then: {
-        properties: {
-          name: {
-            const: tool.name
-          },
-          arguments: tool.inputSchema
-        },
-        required: ["name", "arguments"]
-      }
-    };
-    if (Object.keys(currentSchema).length > 0) {
-      toolCondition.else = currentSchema;
-    }
-    currentSchema = toolCondition;
+// src/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);
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const stack = error.stack ? `
+${error.stack}` : "";
+    return `
+${error.name}: ${error.message}${stack}`;
+  }
+  return safeStringify(error);
+}
+function truncateSnippet(snippet) {
+  if (snippet.length <= MAX_SNIPPET_LENGTH) {
+    return snippet;
+  }
+  return `${snippet.slice(0, MAX_SNIPPET_LENGTH)}
+\u2026[truncated ${snippet.length - MAX_SNIPPET_LENGTH} chars]`;
+}
+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 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";
+  }
+  return "bg";
+}
+function getHighlightFunction(style) {
+  if (style === "inverse") {
+    return cInverse;
+  }
+  if (style === "underline") {
+    return cUnderline;
+  }
+  if (style === "bold") {
+    return cBold;
+  }
+  if (style === "bg") {
+    return cBgGreen;
+  }
+  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");
+  }
+  return highlight(originalText);
+}
+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);
   }
-  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/utils/get-potential-start-index.ts
@@ -127,7 +216,7 @@ function getPotentialStartIndex(text, searchedText) {
   if (directIndex !== -1) {
     return directIndex;
   }
-  for (let i = text.length - 1; i >= 0; i--) {
+  for (let i = text.length - 1; i >= 0; i -= 1) {
     const suffix = text.substring(i);
     if (searchedText.startsWith(suffix)) {
       return i;
@@ -142,15 +231,24 @@ function escapeRegExp(literal) {
 }
 
 // src/utils/robust-json.ts
-var robust_json_exports = {};
-__export(robust_json_exports, {
-  parse: () => parse,
-  stringify: () => stringify,
-  transform: () => transform
-});
+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++) {
+  for (let i = 0; i < array.length; i += 1) {
     const result = f(array[i], i, array);
     acc = result === void 0 ? false : result;
     if (acc) {
@@ -160,31 +258,31 @@ function some(array, f) {
   return acc;
 }
 function makeLexer(tokenSpecs) {
-  return function(contents) {
+  return (contents) => {
     const tokens = [];
     let line = 1;
+    let remainingContents = contents;
     function findToken() {
       const result = some(tokenSpecs, (tokenSpec) => {
-        const m = tokenSpec.re.exec(contents);
+        const m = tokenSpec.re.exec(remainingContents);
         if (m) {
           const raw = m[0];
-          contents = contents.slice(raw.length);
+          remainingContents = remainingContents.slice(raw.length);
           return {
             raw,
             matched: tokenSpec.f(m)
             // Process the match using the spec's function
           };
-        } else {
-          return void 0;
         }
+        return;
       });
       return result === false ? void 0 : result;
     }
-    while (contents !== "") {
+    while (remainingContents !== "") {
       const matched = findToken();
       if (!matched) {
         const err = new SyntaxError(
-          `Unexpected character: ${contents[0]}; input: ${contents.substr(
+          `Unexpected character: ${remainingContents[0]}; input: ${remainingContents.substr(
             0,
             100
           )}`
@@ -206,11 +304,11 @@ function fStringSingle(m) {
     (mm) => {
       if (mm === '"') {
         return '\\"';
-      } else if (mm === "\\'") {
+      }
+      if (mm === "\\'") {
         return "'";
-      } else {
-        return mm;
       }
+      return mm;
     }
   );
   const match = `"${content}"`;
@@ -245,7 +343,10 @@ function fIdentifier(m) {
   };
 }
 function fComment(m) {
-  const match = m[0].replace(/./g, (c) => /\s/.test(c) ? c : " ");
+  const match = m[0].replace(
+    /./g,
+    (c) => WHITESPACE_TEST_REGEX.test(c) ? c : " "
+  );
   return {
     type: " ",
     // Represent comments as whitespace tokens
@@ -260,7 +361,7 @@ function fNumber(m) {
     type: "number",
     match: m[0],
     // The raw matched number string
-    value: parseFloat(m[0])
+    value: Number.parseFloat(m[0])
     // Convert string to number
   };
 }
@@ -290,46 +391,46 @@ function fKeyword(m) {
 }
 function makeTokenSpecs(relaxed) {
   function f(type) {
-    return function(m) {
+    return (m) => {
       return { type, match: m[0], value: void 0 };
     };
   }
   let tokenSpecs = [
-    { re: /^\s+/, f: f(" ") },
+    { re: WHITESPACE_REGEX, f: f(" ") },
     // Whitespace
-    { re: /^\{/, f: f("{") },
+    { re: OBJECT_START_REGEX, f: f("{") },
     // Object start
-    { re: /^\}/, f: f("}") },
+    { re: OBJECT_END_REGEX, f: f("}") },
     // Object end
-    { re: /^\[/, f: f("[") },
+    { re: ARRAY_START_REGEX, f: f("[") },
     // Array start
-    { re: /^\]/, f: f("]") },
+    { re: ARRAY_END_REGEX, f: f("]") },
     // Array end
-    { re: /^,/, f: f(",") },
+    { re: COMMA_REGEX, f: f(",") },
     // Comma separator
-    { re: /^:/, f: f(":") },
+    { re: COLON_REGEX, f: f(":") },
     // Key-value separator
-    { re: /^(?:true|false|null)/, f: fKeyword },
+    { re: KEYWORD_REGEX, f: fKeyword },
     // Keywords
     // Number: optional sign, digits, optional decimal part, optional exponent
-    { re: /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, f: fNumber },
+    { re: NUMBER_REGEX, f: fNumber },
     // String: double-quoted, handles escapes
-    { re: /^"(?:[^"\\]|\\["bnrtf\\/]|\\u[0-9a-fA-F]{4})*"/, f: fStringDouble }
+    { re: STRING_DOUBLE_REGEX, f: fStringDouble }
   ];
   if (relaxed) {
     tokenSpecs = tokenSpecs.concat([
       // Single-quoted strings
       {
-        re: /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/,
+        re: STRING_SINGLE_REGEX,
         f: fStringSingle
       },
       // Single-line comments (// ...)
-      { re: /^\/\/.*?(?:\r\n|\r|\n)/, f: fComment },
+      { re: COMMENT_SINGLE_REGEX, f: fComment },
       // Multi-line comments (/* ... */)
-      { re: /^\/\*[\s\S]*?\*\//, f: fComment },
+      { re: COMMENT_MULTI_REGEX, f: fComment },
       // Unquoted identifiers (treated as strings)
       // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
-      { re: /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/, f: fIdentifier }
+      { re: IDENTIFIER_REGEX, f: fIdentifier }
       // Note: The order matters here. Identifiers are checked after keywords/numbers.
     ]);
   }
@@ -338,12 +439,13 @@ function makeTokenSpecs(relaxed) {
 var lexer = makeLexer(makeTokenSpecs(true));
 var strictLexer = makeLexer(makeTokenSpecs(false));
 function previousNWSToken(tokens, index) {
-  for (; index >= 0; index--) {
-    if (tokens[index].type !== " ") {
-      return index;
+  let currentIndex = index;
+  for (; currentIndex >= 0; currentIndex -= 1) {
+    if (tokens[currentIndex].type !== " ") {
+      return currentIndex;
     }
   }
-  return void 0;
+  return;
 }
 function stripTrailingComma(tokens) {
   const res = [];
@@ -372,15 +474,14 @@ function stripTrailingComma(tokens) {
 function transform(text) {
   let tokens = lexer(text);
   tokens = stripTrailingComma(tokens);
-  return tokens.reduce((str, token) => {
-    return str + token.match;
-  }, "");
+  return tokens.reduce((str, token) => str + token.match, "");
 }
 function popToken(tokens, state) {
+  var _a, _b;
   const token = tokens[state.pos];
   state.pos += 1;
   if (!token) {
-    const lastLine = tokens.length !== 0 ? tokens[tokens.length - 1].line : 1;
+    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;
@@ -418,11 +519,13 @@ function skipPunctuation(tokens, state, valid) {
   const punctuation = [",", ":", "]", "}"];
   let token = popToken(tokens, state);
   while (true) {
-    if (valid && valid.includes(token.type)) {
+    if (valid == null ? void 0 : valid.includes(token.type)) {
       return token;
-    } else if (token.type === "eof") {
+    }
+    if (token.type === "eof") {
       return token;
-    } else if (punctuation.includes(token.type)) {
+    }
+    if (punctuation.includes(token.type)) {
       const message = `Unexpected token: ${strToken(
         token
       )}, expected '[', '{', number, string or atom`;
@@ -463,7 +566,7 @@ function raiseUnexpected(state, token, expected) {
 }
 function checkDuplicates(state, obj, token) {
   const key = String(token.value);
-  if (!state.duplicate && Object.prototype.hasOwnProperty.call(obj, key)) {
+  if (!state.duplicate && Object.hasOwn(obj, key)) {
     raiseError(state, token, `Duplicate key: ${key}`);
   }
 }
@@ -560,51 +663,84 @@ function parseArray(tokens, state) {
     // The closing token for an array
   });
 }
-function parseMany(tokens, state, result, opts) {
-  let token = skipPunctuation(tokens, state, opts.skip);
-  if (token.type === "eof") {
-    raiseUnexpected(state, token, `'${opts.endSymbol}' or ${opts.elementName}`);
-    if (state.tolerant) {
-      return result;
-    } else {
+function handleInvalidToken(token, state, opts, result) {
+  raiseUnexpected(state, token, `',' or '${opts.endSymbol}'`);
+  if (state.tolerant) {
+    if (token.type === "eof") {
       return result;
     }
+    state.pos -= 1;
+    return null;
+  }
+  return result;
+}
+function handleCommaToken(params) {
+  const { token, tokens, state, opts, result } = params;
+  const nextToken = tokens[state.pos];
+  if (state.tolerant && nextToken && nextToken.type === opts.endSymbol) {
+    raiseError(state, token, `Trailing comma before '${opts.endSymbol}'`);
+    popToken(tokens, state);
+    return result;
+  }
+  opts.elementParser(tokens, state, result);
+  return null;
+}
+function parseManyInitialElement(tokens, state, result, opts) {
+  const token = skipPunctuation(tokens, state, opts.skip);
+  if (token.type === "eof") {
+    raiseUnexpected(state, token, `'${opts.endSymbol}' or ${opts.elementName}`);
+    return result;
   }
   if (token.type === opts.endSymbol) {
     return result;
   }
   state.pos -= 1;
   opts.elementParser(tokens, state, result);
-  while (true) {
-    token = popToken(tokens, state);
-    if (token.type !== opts.endSymbol && token.type !== ",") {
-      raiseUnexpected(state, token, `',' or '${opts.endSymbol}'`);
-      if (state.tolerant) {
-        if (token.type === "eof") {
-          return result;
-        }
-        state.pos -= 1;
-      } else {
-        return 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;
     }
-    switch (token.type) {
-      case opts.endSymbol:
-        return result;
-      case ",": {
-        const nextToken = tokens[state.pos];
-        if (state.tolerant && nextToken && nextToken.type === opts.endSymbol) {
-          raiseError(state, token, `Trailing comma before '${opts.endSymbol}'`);
-          popToken(tokens, state);
-          return result;
-        }
-        opts.elementParser(tokens, state, result);
-        break;
-      }
-      // Default case is only reachable in tolerant mode recovery above
-      default:
-        opts.elementParser(tokens, state, result);
-        break;
+  }
+  if (token.type === opts.endSymbol) {
+    return result;
+  }
+  if (token.type === ",") {
+    const handledResult = handleCommaToken({
+      token,
+      tokens,
+      state,
+      opts,
+      result
+    });
+    if (handledResult !== null) {
+      return handledResult;
+    }
+    return;
+  }
+  opts.elementParser(tokens, state, result);
+  return;
+}
+function parseMany(tokens, state, result, opts) {
+  const initialResult = parseManyInitialElement(tokens, state, result, opts);
+  if (initialResult !== void 0) {
+    return initialResult;
+  }
+  while (true) {
+    const token = popToken(tokens, state);
+    const processedResult = parseManyProcessToken({
+      token,
+      tokens,
+      state,
+      opts,
+      result
+    });
+    if (processedResult !== void 0) {
+      return processedResult;
     }
   }
 }
@@ -638,7 +774,7 @@ function parseAny(tokens, state, end = false) {
       raiseUnexpected(state, token, "json value");
     }
     raiseUnexpected(state, token, "json value");
-    return void 0;
+    return;
   }
   switch (token.type) {
     case "{":
@@ -659,7 +795,7 @@ function parseAny(tokens, state, end = false) {
       if (state.tolerant) {
         ret = null;
       } else {
-        return void 0;
+        return;
       }
   }
   if (end) {
@@ -668,7 +804,7 @@ function parseAny(tokens, state, end = false) {
   }
   return ret;
 }
-function parse(text, optsOrReviver) {
+function normalizeParseOptions(optsOrReviver) {
   var _a;
   let options = {};
   if (typeof optsOrReviver === "function") {
@@ -689,69 +825,54 @@ function parse(text, optsOrReviver) {
       options.relaxed = true;
     }
   }
-  options.tolerant = options.tolerant || options.warnings || false;
-  options.warnings = options.warnings || false;
+  options.tolerant = options.tolerant || options.warnings;
   options.duplicate = (_a = options.duplicate) != null ? _a : false;
-  if (!options.relaxed && !options.warnings && !options.tolerant) {
-    if (!options.duplicate) {
-    } else {
-      return JSON.parse(
-        text,
-        options.reviver
-      );
-    }
-  }
+  return options;
+}
+function createParseState(options) {
+  var _a, _b;
+  return {
+    pos: 0,
+    reviver: options.reviver,
+    tolerant: (_a = options.tolerant) != null ? _a : false,
+    duplicate: (_b = options.duplicate) != null ? _b : false,
+    warnings: []
+  };
+}
+function parseWithCustomParser(text, options) {
   const lexerToUse = options.relaxed ? lexer : strictLexer;
   let tokens = lexerToUse(text);
   if (options.relaxed) {
     tokens = stripTrailingComma(tokens);
   }
-  if (options.warnings || options.tolerant) {
-    tokens = tokens.filter((token) => token.type !== " ");
-    const state = {
-      pos: 0,
-      reviver: options.reviver,
-      tolerant: options.tolerant,
-      duplicate: options.duplicate,
-      // true = allow duplicate keys, false = reject duplicates
-      warnings: []
-    };
-    return parseAny(tokens, state, true);
-  } else {
-    tokens.reduce((str, token) => {
-      return str + token.match;
-    }, "");
-    if (!options.relaxed && !options.warnings && !options.tolerant && options.duplicate) {
-      return JSON.parse(text, options.reviver);
-    } else if (options.warnings || options.tolerant || !options.duplicate) {
-      tokens = lexerToUse(text);
-      if (options.relaxed) {
-        tokens = stripTrailingComma(tokens);
-      }
-      tokens = tokens.filter((token) => token.type !== " ");
-      const state = {
-        pos: 0,
-        reviver: options.reviver,
-        tolerant: options.tolerant || false,
-        // Ensure boolean
-        duplicate: options.duplicate,
-        // true = allow duplicate keys, false = reject duplicates
-        warnings: []
-      };
-      return parseAny(tokens, state, true);
-    } else {
-      tokens = lexer(text);
-      tokens = stripTrailingComma(tokens);
-      const newtext = tokens.reduce((str, token) => str + token.match, "");
-      return JSON.parse(
-        newtext,
-        options.reviver
-      );
-    }
+  tokens = tokens.filter((token) => token.type !== " ");
+  const state = createParseState(options);
+  return parseAny(tokens, state, true);
+}
+function parseWithTransform(text, options) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  const newtext = tokens.reduce((str, token) => str + token.match, "");
+  return JSON.parse(
+    newtext,
+    options.reviver
+  );
+}
+function parse(text, optsOrReviver) {
+  const options = normalizeParseOptions(optsOrReviver);
+  if (!(options.relaxed || options.warnings || options.tolerant) && options.duplicate) {
+    return JSON.parse(
+      text,
+      options.reviver
+    );
+  }
+  if (options.warnings || options.tolerant || !options.duplicate) {
+    return parseWithCustomParser(text, options);
   }
+  return parseWithTransform(text, options);
 }
 function stringifyPair(obj, key) {
-  return JSON.stringify(key) + ":" + stringify(obj[key]);
+  return `${JSON.stringify(key)}:${stringify(obj[key])}`;
 }
 function stringify(obj) {
   const type = typeof obj;
@@ -763,147 +884,211 @@ function stringify(obj) {
   }
   if (Array.isArray(obj)) {
     const elements = obj.map(stringify).join(",");
-    return "[" + elements + "]";
+    return `[${elements}]`;
   }
   if (type === "object") {
     const keys = Object.keys(obj);
     keys.sort();
     const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
-    return "{" + pairs + "}";
+    return `{${pairs}}`;
   }
   return "null";
 }
 
-// src/utils/debug.ts
-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;
+// src/protocols/json-mix-protocol.ts
+function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
+  var _a;
+  try {
+    const parsedToolCall = parse(toolCallJson);
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils.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
+    });
+    if (options == null ? void 0 : options.onError) {
+      options.onError(
+        "Could not process JSON tool call, keeping original text.",
+        { toolCall: fullMatch, error }
+      );
+    }
+    processedElements.push({ type: "text", text: fullMatch });
   }
-  return void 0;
 }
-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;
+function addTextSegment(text, processedElements) {
+  if (text.trim()) {
+    processedElements.push({ type: "text", text });
   }
-  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`;
+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;
 }
-var cGray = color(90);
-var cYellow = color(33);
-var cCyan = color(36);
-var cBgBlue = color(44);
-var cBgGreen = color(42);
-var cInverse = color(7);
-var cUnderline = color(4);
-var cBold = color(1);
-function safeStringify(value) {
-  try {
-    return `
-${typeof value === "string" ? value : JSON.stringify(value, null, 2)}`;
-  } catch (e) {
-    return String(value);
+function flushBuffer(state, controller, toolCallStart) {
+  if (state.buffer.length === 0) {
+    return;
+  }
+  if (!state.currentTextId) {
+    state.currentTextId = (0, import_provider_utils.generateId)();
+    controller.enqueue({ type: "text-start", id: state.currentTextId });
+    state.hasEmittedTextStart = true;
   }
+  const delta = state.isInsideToolCall ? `${toolCallStart}${state.buffer}` : state.buffer;
+  controller.enqueue({
+    type: "text-delta",
+    id: state.currentTextId,
+    delta
+  });
+  state.buffer = "";
 }
-function logRawChunk(part) {
-  console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
+function closeTextBlock(state, controller) {
+  if (state.currentTextId && state.hasEmittedTextStart) {
+    controller.enqueue({ type: "text-end", id: state.currentTextId });
+    state.currentTextId = null;
+    state.hasEmittedTextStart = false;
+  }
 }
-function logParsedChunk(part) {
-  console.log(cGray("[debug:mw:out]"), cCyan(safeStringify(part)));
+function emitIncompleteToolCall(state, controller, toolCallStart) {
+  if (!state.currentToolCallJson) {
+    return;
+  }
+  logParseFailure({
+    phase: "stream",
+    reason: "Incomplete streaming tool call segment emitted as text",
+    snippet: `${toolCallStart}${state.currentToolCallJson}`
+  });
+  const errorId = (0, import_provider_utils.generateId)();
+  controller.enqueue({ type: "text-start", id: errorId });
+  controller.enqueue({
+    type: "text-delta",
+    id: errorId,
+    delta: `${toolCallStart}${state.currentToolCallJson}`
+  });
+  controller.enqueue({ type: "text-end", id: errorId });
+  state.currentToolCallJson = "";
 }
-function logParsedSummary({
-  toolCalls,
-  originalText
-}) {
-  if (originalText) {
-    const style = (() => {
-      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";
-      return "bg";
-    })();
-    const highlight = style === "inverse" ? cInverse : style === "underline" ? cUnderline : style === "bold" ? cBold : style === "bg" ? cBgGreen : cYellow;
-    const rendered = style === "bg" || style === "inverse" || style === "underline" || style === "bold" ? originalText.split(/\r?\n/).map((line) => line.length ? highlight(line) : line).join("\n") : highlight(originalText);
-    console.log(cGray("[debug:mw:origin]"), `
-${rendered}`);
+function handleFinishChunk(state, controller, toolCallStart, chunk) {
+  if (state.buffer.length > 0) {
+    flushBuffer(state, controller, toolCallStart);
   }
-  if (toolCalls.length > 0) {
-    const styledSummary = safeStringify(toolCalls).split(/\r?\n/).map((line) => line.length ? cBgBlue(line) : line).join("\n");
-    console.log(cGray("[debug:mw:summary]"), styledSummary);
+  closeTextBlock(state, controller);
+  emitIncompleteToolCall(state, controller, toolCallStart);
+  controller.enqueue(chunk);
+}
+function publishText(text, state, controller) {
+  if (state.isInsideToolCall) {
+    closeTextBlock(state, controller);
+    state.currentToolCallJson += text;
+  } else if (text.length > 0) {
+    if (!state.currentTextId) {
+      state.currentTextId = (0, import_provider_utils.generateId)();
+      controller.enqueue({ type: "text-start", id: state.currentTextId });
+      state.hasEmittedTextStart = true;
+    }
+    controller.enqueue({
+      type: "text-delta",
+      id: state.currentTextId,
+      delta: text
+    });
   }
 }
-
-// src/utils/on-error.ts
-function extractOnErrorOption(providerOptions) {
+function emitToolCall(context) {
   var _a;
-  if (providerOptions && typeof providerOptions === "object") {
-    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
-    return onError ? { onError } : void 0;
+  const { state, controller, toolCallStart, toolCallEnd, options } = context;
+  try {
+    const parsedToolCall = parse(state.currentToolCallJson);
+    closeTextBlock(state, controller);
+    controller.enqueue({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils.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 = (0, import_provider_utils.generateId)();
+    controller.enqueue({ type: "text-start", id: errorId });
+    controller.enqueue({
+      type: "text-delta",
+      id: errorId,
+      delta: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`
+    });
+    controller.enqueue({ type: "text-end", id: errorId });
+    if (options == null ? void 0 : options.onError) {
+      options.onError(
+        "Could not process streaming JSON tool call; emitting original text.",
+        {
+          toolCall: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`
+        }
+      );
+    }
   }
-  return void 0;
-}
-
-// src/utils/provider-options.ts
-var originalToolsSchema = {
-  encode: encodeOriginalTools,
-  decode: decodeOriginalTools
-};
-function encodeOriginalTools(tools) {
-  return (tools == null ? void 0 : tools.map((t) => ({
-    name: t.name,
-    inputSchema: JSON.stringify(t.inputSchema)
-  }))) || [];
-}
-function decodeOriginalTools(originalTools) {
-  const tools = (originalTools == null ? void 0 : originalTools.map(
-    (t) => ({
-      name: t.name,
-      inputSchema: JSON.parse(t.inputSchema)
-    })
-  )) || [];
-  return tools;
 }
-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/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");
+function processTagMatch(context) {
+  const { state } = context;
+  if (state.isInsideToolCall) {
+    emitToolCall(context);
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = false;
+  } else {
+    state.currentToolCallJson = "";
+    state.isInsideToolCall = true;
+  }
 }
-function isToolResultPart(content) {
-  const c = content;
-  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+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 hasInputProperty(obj) {
-  return typeof obj === "object" && obj !== null && "input" in obj;
+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 = "";
+  }
 }
-
-// src/protocols/json-mix-protocol.ts
 var jsonMixProtocol = ({
   toolCallStart = "<tool_call>",
   toolCallEnd = "</tool_call>",
@@ -937,7 +1122,6 @@ var jsonMixProtocol = ({
     })}${toolResponseEnd}`;
   },
   parseGeneratedText({ text, options }) {
-    var _a;
     const startEsc = escapeRegExp(toolCallStart);
     const endEsc = escapeRegExp(toolCallEnd);
     const toolCallRegex = new RegExp(
@@ -946,185 +1130,50 @@ var jsonMixProtocol = ({
     );
     const processedElements = [];
     let currentIndex = 0;
-    let match;
-    while ((match = toolCallRegex.exec(text)) !== null) {
-      const startIndex = match.index;
-      const toolCallJson = match[1];
-      if (startIndex > currentIndex) {
-        const textSegment = text.substring(currentIndex, startIndex);
-        if (textSegment.trim()) {
-          processedElements.push({ type: "text", text: textSegment });
-        }
-      }
-      if (toolCallJson) {
-        try {
-          const parsedToolCall = robust_json_exports.parse(toolCallJson);
-          processedElements.push({
-            type: "tool-call",
-            toolCallId: (0, import_provider_utils2.generateId)(),
-            toolName: parsedToolCall.name,
-            input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-          });
-        } catch (error) {
-          if (options == null ? void 0 : options.onError) {
-            options.onError(
-              "Could not process JSON tool call, keeping original text.",
-              { toolCall: match[0], error }
-            );
-          }
-          processedElements.push({ type: "text", text: match[0] });
-        }
-      }
-      currentIndex = startIndex + match[0].length;
+    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);
-      if (remainingText.trim()) {
-        processedElements.push({ type: "text", text: remainingText });
-      }
+      addTextSegment(remainingText, processedElements);
     }
     return processedElements;
   },
   createStreamParser({ tools: _tools, options } = { tools: [] }) {
-    let isInsideToolCall = false;
-    let buffer = "";
-    let currentToolCallJson = "";
-    let currentTextId = null;
-    let hasEmittedTextStart = false;
+    const state = {
+      isInsideToolCall: false,
+      buffer: "",
+      currentToolCallJson: "",
+      currentTextId: null,
+      hasEmittedTextStart: false
+    };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a;
         if (chunk.type === "finish") {
-          if (isInsideToolCall && buffer.length > 0) {
-            if (!currentTextId) {
-              currentTextId = (0, import_provider_utils2.generateId)();
-              controller.enqueue({ type: "text-start", id: currentTextId });
-              hasEmittedTextStart = true;
-            }
-            controller.enqueue({
-              type: "text-delta",
-              id: currentTextId,
-              delta: `${toolCallStart}${buffer}`
-            });
-            buffer = "";
-          } else if (!isInsideToolCall && buffer.length > 0) {
-            if (!currentTextId) {
-              currentTextId = (0, import_provider_utils2.generateId)();
-              controller.enqueue({ type: "text-start", id: currentTextId });
-              hasEmittedTextStart = true;
-            }
-            controller.enqueue({
-              type: "text-delta",
-              id: currentTextId,
-              delta: buffer
-            });
-            buffer = "";
-          }
-          if (currentTextId && hasEmittedTextStart) {
-            controller.enqueue({ type: "text-end", id: currentTextId });
-            currentTextId = null;
-            hasEmittedTextStart = false;
-          }
-          if (currentToolCallJson) {
-            const errorId = (0, import_provider_utils2.generateId)();
-            controller.enqueue({ type: "text-start", id: errorId });
-            controller.enqueue({
-              type: "text-delta",
-              id: errorId,
-              delta: `${toolCallStart}${currentToolCallJson}`
-            });
-            controller.enqueue({ type: "text-end", id: errorId });
-            currentToolCallJson = "";
-          }
-          controller.enqueue(chunk);
+          handleFinishChunk(state, controller, toolCallStart, chunk);
           return;
         }
         if (chunk.type !== "text-delta") {
           controller.enqueue(chunk);
           return;
         }
-        buffer += chunk.delta;
-        const publish = (text) => {
-          if (isInsideToolCall) {
-            if (currentTextId && hasEmittedTextStart) {
-              controller.enqueue({ type: "text-end", id: currentTextId });
-              currentTextId = null;
-              hasEmittedTextStart = false;
-            }
-            currentToolCallJson += text;
-          } else if (text.length > 0) {
-            if (!currentTextId) {
-              currentTextId = (0, import_provider_utils2.generateId)();
-              controller.enqueue({ type: "text-start", id: currentTextId });
-              hasEmittedTextStart = true;
-            }
-            controller.enqueue({
-              type: "text-delta",
-              id: currentTextId,
-              delta: text
-            });
-          }
-        };
-        let startIndex;
-        while ((startIndex = getPotentialStartIndex(
-          buffer,
-          isInsideToolCall ? toolCallEnd : toolCallStart
-        )) != null) {
-          const tag = isInsideToolCall ? toolCallEnd : toolCallStart;
-          if (startIndex + tag.length > buffer.length) {
-            break;
-          }
-          publish(buffer.slice(0, startIndex));
-          buffer = buffer.slice(startIndex + tag.length);
-          if (!isInsideToolCall) {
-            currentToolCallJson = "";
-            isInsideToolCall = true;
-          } else {
-            try {
-              const parsedToolCall = robust_json_exports.parse(currentToolCallJson);
-              if (currentTextId && hasEmittedTextStart) {
-                controller.enqueue({ type: "text-end", id: currentTextId });
-                currentTextId = null;
-                hasEmittedTextStart = false;
-              }
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId: (0, import_provider_utils2.generateId)(),
-                toolName: parsedToolCall.name,
-                input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-              });
-            } catch (e) {
-              const errorId = (0, import_provider_utils2.generateId)();
-              controller.enqueue({ type: "text-start", id: errorId });
-              controller.enqueue({
-                type: "text-delta",
-                id: errorId,
-                delta: `${toolCallStart}${currentToolCallJson}${toolCallEnd}`
-              });
-              controller.enqueue({ type: "text-end", id: errorId });
-              if (options == null ? void 0 : options.onError) {
-                options.onError(
-                  "Could not process streaming JSON tool call; emitting original text.",
-                  {
-                    toolCall: `${toolCallStart}${currentToolCallJson}${toolCallEnd}`
-                  }
-                );
-              }
-            }
-            currentToolCallJson = "";
-            isInsideToolCall = false;
-          }
-        }
-        if (!isInsideToolCall) {
-          const potentialIndex = getPotentialStartIndex(buffer, toolCallStart);
-          if (potentialIndex != null && potentialIndex + toolCallStart.length > buffer.length) {
-            publish(buffer.slice(0, potentialIndex));
-            buffer = buffer.slice(potentialIndex);
-          } else {
-            publish(buffer);
-            buffer = "";
-          }
-        }
+        state.buffer += chunk.delta;
+        processBufferTags({
+          state,
+          controller,
+          toolCallStart,
+          toolCallEnd,
+          options
+        });
+        handlePartialTag(state, controller, toolCallStart);
       }
     });
   },
@@ -1133,23 +1182,710 @@ var jsonMixProtocol = ({
     const endEsc = escapeRegExp(toolCallEnd);
     const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
     const segments = [];
-    let m;
-    while ((m = regex.exec(text)) != null) {
+    let m = regex.exec(text);
+    while (m != null) {
       segments.push(m[0]);
+      m = regex.exec(text);
     }
     return segments;
   }
 });
 
 // src/protocols/morph-xml-protocol.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var RXML = __toESM(require("@ai-sdk-tool/rxml"), 1);
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_rxml = require("@ai-sdk-tool/rxml");
+
+// src/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");
+}
+function isToolResultPart(content) {
+  const c = content;
+  return !!c && 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/protocols/morph-xml-protocol.ts
+var WHITESPACE_REGEX2 = /\s/;
+var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
+var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
+var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
+function normalizeCloseTags(xml) {
+  return xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+}
+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] : "";
+      if (!(NAME_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?")) {
+        out += "&lt;";
+        continue;
+      }
+    }
+    out += ch;
+  }
+  return out;
+}
+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;
+  }
+  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
+}
+function tryParseSecondaryXml(content, toolSchema, options) {
+  const normalized = normalizeCloseTags(content);
+  const balanced = balanceTags(content);
+  const hasMalformedClose = MALFORMED_CLOSE_RE.test(content);
+  if (!hasMalformedClose && balanced.length > normalized.length) {
+    return null;
+  }
+  try {
+    let parsed = (0, import_rxml.parse)(balanced, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
+    return parsed;
+  } catch (_e) {
+    if (shouldDeduplicateStringTags(toolSchema)) {
+      const deduped = dedupeStringTagsAgainstSchema(balanced, toolSchema);
+      if (deduped !== balanced) {
+        try {
+          let reparsed = (0, import_rxml.parse)(deduped, toolSchema, {
+            onError: options == null ? void 0 : options.onError,
+            noChildNodes: []
+          });
+          reparsed = repairParsedAgainstSchema(reparsed, toolSchema, options);
+          return reparsed;
+        } catch (_) {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+}
+function balanceTags(xml) {
+  const src = normalizeCloseTags(xml).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_REGEX2.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_REGEX2.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 repairParsedAgainstSchema(input, schema, options) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return input;
+  }
+  const properties = unwrapped.properties;
+  if (!properties) {
+    return input;
+  }
+  applySchemaProps(input, properties, options);
+  return input;
+}
+function applySchemaProps(obj, properties, options) {
+  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, options);
+      continue;
+    }
+    if (propType === "object") {
+      const val = obj[key];
+      if (val && typeof val === "object") {
+        obj[key] = repairParsedAgainstSchema(
+          val,
+          prop,
+          options
+        );
+      }
+    }
+  }
+}
+function coerceArrayItems(val, itemSchema, options) {
+  if (!Array.isArray(val)) {
+    return val;
+  }
+  return val.map((v) => coerceArrayItem(v, itemSchema, options));
+}
+function coerceArrayItem(v, itemSchema, options) {
+  const itemType = itemSchema == null ? void 0 : itemSchema.type;
+  if (typeof v === "string" && itemType === "object") {
+    const parsed = tryParseStringToSchemaObject(v, itemSchema, options);
+    if (parsed !== null) {
+      return parsed;
+    }
+    const fallback = extractStepStatusFromString(normalizeCloseTags(v));
+    if (fallback) {
+      return fallback;
+    }
+    return v;
+  }
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(
+      v,
+      itemSchema,
+      options
+    );
+  }
+  return v;
+}
+function getStringPropertyNames(schema) {
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return [];
+  }
+  const props = unwrapped.properties;
+  if (!props) {
+    return [];
+  }
+  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);
+    }
+  }
+  return names;
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+}
+function dedupeStringTagsAgainstSchema(xml, schema) {
+  const names = getStringPropertyNames(schema);
+  let out = xml;
+  for (const key of names) {
+    out = dedupeSingleTag(out, key);
+  }
+  return out;
+}
+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;
+  }
+  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 tryParseStringToSchemaObject(xml, itemSchema, options) {
+  try {
+    const fixed = (0, import_rxml.parse)(normalizeCloseTags(xml), itemSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
+  }
+}
+function extractStepStatusFromString(normXml) {
+  const stepMatch = normXml.match(STEP_TAG_RE);
+  const statusMatch = normXml.match(STATUS_TAG_RE);
+  if (stepMatch && statusMatch) {
+    return { step: stepMatch[1], status: statusMatch[1] };
+  }
+  return null;
+}
+function processTextBeforeToolCall(text, currentIndex, toolCallStartIndex, processedElements) {
+  if (toolCallStartIndex > currentIndex) {
+    const textSegment = text.substring(currentIndex, toolCallStartIndex);
+    if (textSegment.trim()) {
+      processedElements.push({ type: "text", text: textSegment });
+    }
+  }
+  return currentIndex;
+}
+function processToolCall(params) {
+  var _a;
+  const { toolCall, tools, options, text, processedElements } = params;
+  const toolSchema = getToolSchema(tools, toolCall.toolName);
+  try {
+    const primary = escapeInvalidLt(normalizeCloseTags(toolCall.content));
+    let parsed = (0, import_rxml.parse)(primary, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: toolCall.toolName,
+      input: JSON.stringify(parsed)
+    });
+  } catch (error) {
+    const reparsed = tryParseSecondaryXml(
+      toolCall.content,
+      toolSchema,
+      options
+    );
+    if (reparsed !== null) {
+      processedElements.push({
+        type: "tool-call",
+        toolCallId: (0, import_provider_utils2.generateId)(),
+        toolName: toolCall.toolName,
+        input: JSON.stringify(reparsed)
+      });
+      return;
+    }
+    const originalCallText = text.substring(
+      toolCall.startIndex,
+      toolCall.endIndex
+    );
+    const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
+      toolCall: originalCallText,
+      toolName: toolCall.toolName,
+      error
+    });
+    processedElements.push({ type: "text", text: originalCallText });
+  }
+}
+function addRemainingText(text, currentIndex, processedElements) {
+  if (currentIndex < text.length) {
+    const remainingText = text.substring(currentIndex);
+    if (remainingText.trim()) {
+      processedElements.push({ type: "text", text: remainingText });
+    }
+  }
+}
+function handleStreamingToolCallEnd(params) {
+  const { toolContent, currentToolCall, tools, options, ctrl, flushText } = params;
+  const toolSchema = getToolSchema(tools, currentToolCall.name);
+  try {
+    const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
+    let parsed = (0, import_rxml.parse)(primary, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema, options);
+    flushText(ctrl);
+    ctrl.enqueue({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: currentToolCall.name,
+      input: JSON.stringify(parsed)
+    });
+  } catch (error) {
+    const parsed = tryParseSecondaryXml(toolContent, toolSchema, options);
+    if (parsed !== null) {
+      flushText(ctrl);
+      ctrl.enqueue({
+        type: "tool-call",
+        toolCallId: (0, import_provider_utils2.generateId)(),
+        toolName: currentToolCall.name,
+        input: JSON.stringify(parsed)
+      });
+      return;
+    }
+    handleStreamingToolCallError({
+      error,
+      currentToolCall,
+      toolContent,
+      options,
+      ctrl,
+      flushText
+    });
+  }
+}
+function handleStreamingToolCallError(params) {
+  var _a;
+  const { error, currentToolCall, toolContent, options, ctrl, flushText } = params;
+  const endTag = `</${currentToolCall.name}>`;
+  const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
+  let message = "Could not process streaming XML tool call; emitting original text.";
+  if (error instanceof import_rxml.RXMLDuplicateStringTagError) {
+    message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  } else if (error instanceof import_rxml.RXMLCoercionError) {
+    message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  } else if (error instanceof import_rxml.RXMLParseError) {
+    message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  }
+  (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
+    toolCall: originalCallText,
+    toolName: currentToolCall.name,
+    error
+  });
+  flushText(ctrl, originalCallText);
+}
+function findEarliestToolTag(buffer, toolNames) {
+  let bestIndex = -1;
+  let bestName = "";
+  let bestSelfClosing = false;
+  if (toolNames.length > 0) {
+    for (const name of toolNames) {
+      const openTag = `<${name}>`;
+      const selfTag = `<${name}/>`;
+      const idxOpen = buffer.indexOf(openTag);
+      const idxSelf = buffer.indexOf(selfTag);
+      if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
+        bestIndex = idxOpen;
+        bestName = name;
+        bestSelfClosing = false;
+      }
+      if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
+        bestIndex = idxSelf;
+        bestName = name;
+        bestSelfClosing = true;
+      }
+    }
+  }
+  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+}
+function handleNoToolTagInBuffer(buffer, maxStartTagLen, controller, flushText) {
+  const tail = Math.max(0, maxStartTagLen - 1);
+  const safeLen = Math.max(0, buffer.length - tail);
+  if (safeLen > 0) {
+    const textToFlush = buffer.slice(0, safeLen);
+    flushText(controller, textToFlush);
+    return { buffer: buffer.slice(safeLen), shouldContinue: true };
+  }
+  return { buffer, shouldContinue: false };
+}
+function processToolCallInBuffer(params) {
+  const {
+    buffer,
+    currentToolCall,
+    tools,
+    options,
+    controller,
+    flushText,
+    setBuffer
+  } = params;
+  const endTag = `</${currentToolCall.name}>`;
+  const normalized = normalizeCloseTags(buffer);
+  const effectiveBuffer = normalized;
+  const endTagIndex = effectiveBuffer.indexOf(endTag);
+  if (endTagIndex !== -1) {
+    const toolContent = effectiveBuffer.substring(0, endTagIndex);
+    const newBuffer = effectiveBuffer.substring(endTagIndex + endTag.length);
+    setBuffer("");
+    handleStreamingToolCallEnd({
+      toolContent,
+      currentToolCall,
+      tools,
+      options,
+      ctrl: controller,
+      flushText
+    });
+    setBuffer(newBuffer);
+    return { buffer: newBuffer, currentToolCall: null, shouldBreak: false };
+  }
+  return { buffer: effectiveBuffer, currentToolCall, shouldBreak: true };
+}
+function processNoToolCallInBuffer(params) {
+  const {
+    buffer,
+    toolNames,
+    maxStartTagLen,
+    controller,
+    flushText,
+    tools,
+    options
+  } = params;
+  const {
+    index: earliestStartTagIndex,
+    name: earliestToolName,
+    selfClosing
+  } = findEarliestToolTag(buffer, toolNames);
+  if (earliestStartTagIndex !== -1) {
+    const textBeforeTag = buffer.substring(0, earliestStartTagIndex);
+    flushText(controller, textBeforeTag);
+    if (selfClosing) {
+      const selfTag = `<${earliestToolName}/>`;
+      const newBuffer2 = buffer.substring(
+        earliestStartTagIndex + selfTag.length
+      );
+      handleStreamingToolCallEnd({
+        toolContent: "",
+        currentToolCall: { name: earliestToolName, content: "" },
+        tools,
+        options,
+        ctrl: controller,
+        flushText
+      });
+      return {
+        buffer: newBuffer2,
+        currentToolCall: null,
+        shouldBreak: false,
+        shouldContinue: false
+      };
+    }
+    const startTag = `<${earliestToolName}>`;
+    const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
+    return {
+      buffer: newBuffer,
+      currentToolCall: { name: earliestToolName, content: "" },
+      shouldBreak: false,
+      shouldContinue: false
+    };
+  }
+  const result = handleNoToolTagInBuffer(
+    buffer,
+    maxStartTagLen,
+    controller,
+    flushText
+  );
+  return {
+    buffer: result.buffer,
+    currentToolCall: null,
+    shouldBreak: !result.shouldContinue,
+    shouldContinue: result.shouldContinue
+  };
+}
+function createFlushTextHandler(getBuffer, setBuffer, getCurrentTextId, setCurrentTextId) {
+  return (controller, text) => {
+    const content = text != null ? text : getBuffer();
+    if (content) {
+      const currentTextId2 = getCurrentTextId();
+      if (!currentTextId2) {
+        const newId = (0, import_provider_utils2.generateId)();
+        setCurrentTextId(newId);
+        controller.enqueue({ type: "text-start", id: newId });
+      }
+      controller.enqueue({
+        type: "text-delta",
+        id: getCurrentTextId(),
+        delta: content
+      });
+      if (text === void 0) {
+        setBuffer("");
+      }
+    }
+    const currentTextId = getCurrentTextId();
+    if (currentTextId && !text) {
+      controller.enqueue({ type: "text-end", id: currentTextId });
+      setCurrentTextId(null);
+    }
+  };
+}
+function processBufferWithToolCall(params, controller) {
+  const {
+    getBuffer,
+    setBuffer,
+    getCurrentToolCall,
+    setCurrentToolCall,
+    tools,
+    options,
+    flushText
+  } = params;
+  const currentToolCall = getCurrentToolCall();
+  if (!currentToolCall) {
+    return true;
+  }
+  const result = processToolCallInBuffer({
+    buffer: getBuffer(),
+    currentToolCall,
+    tools,
+    options,
+    controller,
+    flushText,
+    setBuffer
+  });
+  setBuffer(result.buffer);
+  setCurrentToolCall(result.currentToolCall);
+  return result.shouldBreak;
+}
+function processBufferWithoutToolCall(params, controller) {
+  const {
+    getBuffer,
+    setBuffer,
+    setCurrentToolCall,
+    tools,
+    options,
+    toolNames,
+    maxStartTagLen,
+    flushText
+  } = params;
+  const result = processNoToolCallInBuffer({
+    buffer: getBuffer(),
+    toolNames,
+    maxStartTagLen,
+    controller,
+    flushText,
+    tools,
+    options
+  });
+  setBuffer(result.buffer);
+  setCurrentToolCall(result.currentToolCall);
+  return {
+    shouldBreak: result.shouldBreak,
+    shouldContinue: result.shouldContinue
+  };
+}
+function processBufferLoop(params, controller) {
+  while (true) {
+    const currentToolCall = params.getCurrentToolCall();
+    if (currentToolCall) {
+      const shouldBreak = processBufferWithToolCall(params, controller);
+      if (shouldBreak) {
+        break;
+      }
+    } else {
+      const { shouldBreak, shouldContinue } = processBufferWithoutToolCall(
+        params,
+        controller
+      );
+      if (shouldContinue) {
+        continue;
+      }
+      if (shouldBreak) {
+        break;
+      }
+    }
+  }
+}
+function createProcessBufferHandler(params) {
+  return (controller) => {
+    processBufferLoop(params, controller);
+  };
+}
 var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: RXML.unwrapJsonSchema(tool.inputSchema)
+      parameters: (0, import_rxml.unwrapJsonSchema)(tool.inputSchema)
     }));
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
@@ -1165,67 +1901,46 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    return RXML.stringify(toolCall.toolName, args, {
+    return (0, import_rxml.stringify)(toolCall.toolName, args, {
       suppressEmptyNode: false,
       format: false
     });
   },
   formatToolResponse(toolResult) {
-    return RXML.stringify("tool_response", {
+    return (0, import_rxml.stringify)("tool_response", {
       tool_name: toolResult.toolName,
       result: toolResult.output
     });
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a;
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
     if (toolNames.length === 0) {
       return [{ type: "text", text }];
     }
     const processedElements = [];
     let currentIndex = 0;
-    const toolCalls = findToolCalls(text, toolNames);
-    for (const toolCall of toolCalls) {
-      if (toolCall.startIndex > currentIndex) {
-        const textSegment = text.substring(currentIndex, toolCall.startIndex);
-        if (textSegment.trim()) {
-          processedElements.push({ type: "text", text: textSegment });
-        }
-      }
-      try {
-        const toolSchema = getToolSchema(tools, toolCall.toolName);
-        const parsed = RXML.parse(toolCall.content, toolSchema, {
-          onError: options == null ? void 0 : options.onError,
-          // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
-          noChildNodes: []
-        });
-        processedElements.push({
-          type: "tool-call",
-          toolCallId: (0, import_provider_utils3.generateId)(),
-          toolName: toolCall.toolName,
-          input: JSON.stringify(parsed)
-        });
-      } catch (error) {
-        const originalCallText = text.substring(
-          toolCall.startIndex,
-          toolCall.endIndex
-        );
-        const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
-        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-          toolCall: originalCallText,
-          toolName: toolCall.toolName,
-          error
-        });
-        processedElements.push({ type: "text", text: originalCallText });
+    const toolCallsRaw = findToolCalls(text, toolNames);
+    const toolCallsNorm = collectToolCallsFromNormalizedText(text, toolNames);
+    const seen = /* @__PURE__ */ new Set();
+    const toolCalls = [...toolCallsRaw, ...toolCallsNorm].filter((tc) => {
+      const key = `${tc.toolName}:${tc.startIndex}:${tc.endIndex}`;
+      if (seen.has(key)) {
+        return false;
       }
+      seen.add(key);
+      return true;
+    }).sort((a, b) => a.startIndex - b.startIndex);
+    for (const toolCall of toolCalls) {
+      currentIndex = processTextBeforeToolCall(
+        text,
+        currentIndex,
+        toolCall.startIndex,
+        processedElements
+      );
+      processToolCall({ toolCall, tools, options, text, processedElements });
       currentIndex = toolCall.endIndex;
     }
-    if (currentIndex < text.length) {
-      const remainingText = text.substring(currentIndex);
-      if (remainingText.trim()) {
-        processedElements.push({ type: "text", text: remainingText });
-      }
-    }
+    addRemainingText(text, currentIndex, processedElements);
     return processedElements;
   },
   createStreamParser({ tools, options }) {
@@ -1234,129 +1949,67 @@ var morphXmlProtocol = () => ({
     let buffer = "";
     let currentToolCall = null;
     let currentTextId = null;
-    const flushText = (controller, text) => {
-      const content = text != null ? text : buffer;
-      if (content) {
-        if (!currentTextId) {
-          currentTextId = (0, import_provider_utils3.generateId)();
-          controller.enqueue({ type: "text-start", id: currentTextId });
-        }
-        controller.enqueue({
-          type: "text-delta",
-          id: currentTextId,
-          delta: content
-        });
-        if (text === void 0) {
-          buffer = "";
+    const flushText = createFlushTextHandler(
+      () => buffer,
+      (newBuffer) => {
+        buffer = newBuffer;
+      },
+      () => currentTextId,
+      (newId) => {
+        currentTextId = newId;
+      }
+    );
+    const processChunk = (chunk, controller) => {
+      if (chunk.type !== "text-delta") {
+        if (buffer) {
+          flushText(controller);
         }
+        controller.enqueue(chunk);
+        return;
+      }
+      buffer += chunk.delta;
+      processBuffer(controller);
+    };
+    const processBuffer = createProcessBufferHandler({
+      getBuffer: () => buffer,
+      setBuffer: (newBuffer) => {
+        buffer = newBuffer;
+      },
+      getCurrentToolCall: () => currentToolCall,
+      setCurrentToolCall: (newToolCall) => {
+        currentToolCall = newToolCall;
+      },
+      tools,
+      options,
+      toolNames,
+      maxStartTagLen,
+      flushText
+    });
+    const flushBuffer2 = (controller) => {
+      if (currentToolCall) {
+        const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
+        flushText(controller, unfinishedCall);
+      } else if (buffer) {
+        flushText(controller);
       }
-      if (currentTextId && !text) {
+      if (currentTextId) {
         controller.enqueue({ type: "text-end", id: currentTextId });
-        currentTextId = null;
       }
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a;
-        if (chunk.type !== "text-delta") {
-          if (buffer) flushText(controller);
-          controller.enqueue(chunk);
-          return;
-        }
-        buffer += chunk.delta;
-        while (true) {
-          if (currentToolCall) {
-            const endTag = `</${currentToolCall.name}>`;
-            const endTagIndex = buffer.indexOf(endTag);
-            if (endTagIndex !== -1) {
-              const toolContent = buffer.substring(0, endTagIndex);
-              buffer = buffer.substring(endTagIndex + endTag.length);
-              try {
-                const toolSchema = getToolSchema(tools, currentToolCall.name);
-                const parsed = RXML.parse(toolContent, toolSchema, {
-                  onError: options == null ? void 0 : options.onError,
-                  // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
-                  noChildNodes: []
-                });
-                flushText(controller);
-                controller.enqueue({
-                  type: "tool-call",
-                  toolCallId: (0, import_provider_utils3.generateId)(),
-                  toolName: currentToolCall.name,
-                  input: JSON.stringify(parsed)
-                });
-              } catch (error) {
-                const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
-                let message = "Could not process streaming XML tool call; emitting original text.";
-                if (error instanceof RXML.RXMLDuplicateStringTagError) {
-                  message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-                } else if (error instanceof RXML.RXMLCoercionError) {
-                  message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-                } else if (error instanceof RXML.RXMLParseError) {
-                  message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-                }
-                (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-                  toolCall: originalCallText,
-                  toolName: currentToolCall.name,
-                  error
-                });
-                flushText(controller, originalCallText);
-              }
-              currentToolCall = null;
-            } else {
-              break;
-            }
-          } else {
-            let earliestStartTagIndex = -1;
-            let earliestToolName = "";
-            if (toolNames.length > 0) {
-              for (const name of toolNames) {
-                const startTag = `<${name}>`;
-                const index = buffer.indexOf(startTag);
-                if (index !== -1 && (earliestStartTagIndex === -1 || index < earliestStartTagIndex)) {
-                  earliestStartTagIndex = index;
-                  earliestToolName = name;
-                }
-              }
-            }
-            if (earliestStartTagIndex !== -1) {
-              const textBeforeTag = buffer.substring(0, earliestStartTagIndex);
-              flushText(controller, textBeforeTag);
-              const startTag = `<${earliestToolName}>`;
-              buffer = buffer.substring(
-                earliestStartTagIndex + startTag.length
-              );
-              currentToolCall = { name: earliestToolName, content: "" };
-            } else {
-              const tail = Math.max(0, maxStartTagLen - 1);
-              const safeLen = Math.max(0, buffer.length - tail);
-              if (safeLen > 0) {
-                const textToFlush = buffer.slice(0, safeLen);
-                flushText(controller, textToFlush);
-                buffer = buffer.slice(safeLen);
-                continue;
-              }
-              break;
-            }
-          }
-        }
+        processChunk(chunk, controller);
       },
       flush(controller) {
-        if (currentToolCall) {
-          const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
-          flushText(controller, unfinishedCall);
-        } else if (buffer) {
-          flushText(controller);
-        }
-        if (currentTextId) {
-          controller.enqueue({ type: "text-end", id: currentTextId });
-        }
+        flushBuffer2(controller);
       }
     });
   },
   extractToolCallSegments({ text, tools }) {
     const toolNames = tools.map((t) => t.name).filter(Boolean);
-    if (toolNames.length === 0) return [];
+    if (toolNames.length === 0) {
+      return [];
+    }
     return findToolCalls(text, toolNames).map((tc) => tc.segment);
   }
 });
@@ -1364,140 +2017,371 @@ function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
 }
-function findToolCalls(text, toolNames) {
+function findClosingTagEndFlexible(text, contentStart, toolName) {
+  let pos = contentStart;
+  let depth = 1;
+  while (pos < text.length) {
+    const tok = nextTagToken(text, pos);
+    if (tok.kind === "eof") {
+      break;
+    }
+    const result = updateDepthWithToken(tok, toolName, depth);
+    depth = result.depth;
+    if (result.closedAt !== void 0) {
+      return result.closedAt;
+    }
+    pos = tok.nextPos;
+  }
+  return -1;
+}
+function skipSpecialSegment(text, lt) {
+  const next = text[lt + 1];
+  if (next !== "!" && next !== "?") {
+    return null;
+  }
+  const gt = text.indexOf(">", lt + 1);
+  if (gt === -1) {
+    return null;
+  }
+  return gt + 1;
+}
+function consumeClosingTag(text, lt, toolName) {
+  let p = lt + 2;
+  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+    p += 1;
+  }
+  if (text.slice(p, p + toolName.length) === toolName) {
+    p += toolName.length;
+    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+      p += 1;
+    }
+    if (text[p] === ">") {
+      const endPos2 = p + 1;
+      return { matched: true, endPos: endPos2 };
+    }
+  }
+  const gt = text.indexOf(">", lt + 1);
+  const endPos = gt === -1 ? text.length : gt + 1;
+  return { matched: false, endPos };
+}
+function consumeOpenTag(text, lt) {
+  let p = lt + 1;
+  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+    p += 1;
+  }
+  const nameStart = p;
+  while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+    p += 1;
+  }
+  const name = text.slice(nameStart, p);
+  const q = text.indexOf(">", p);
+  if (q === -1) {
+    return null;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+    r -= 1;
+  }
+  const selfClosing = text[r] === "/";
+  return { name, selfClosing, nextPos: q + 1 };
+}
+function updateDepthWithToken(tok, toolName, depth) {
+  if (tok.kind === "close" && tok.name === toolName) {
+    const newDepth = depth - 1;
+    return newDepth === 0 ? { depth: newDepth, closedAt: tok.nextPos } : { depth: newDepth };
+  }
+  if (tok.kind === "open" && tok.name === toolName && !tok.selfClosing) {
+    return { depth: depth + 1 };
+  }
+  return { depth };
+}
+function nextTagToken(text, fromPos) {
+  const lt = text.indexOf("<", fromPos);
+  if (lt === -1 || lt + 1 >= text.length) {
+    return { kind: "eof", nextPos: text.length };
+  }
+  const next = text[lt + 1];
+  const specialEnd = skipSpecialSegment(text, lt);
+  if (specialEnd !== null) {
+    return { kind: "special", nextPos: specialEnd };
+  }
+  if (next === "/") {
+    const closing = consumeClosingTag(text, lt, "");
+    let p = lt + 2;
+    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+      p += 1;
+    }
+    const nameStart = p;
+    while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+      p += 1;
+    }
+    const name = text.slice(nameStart, p);
+    return { kind: "close", name, nextPos: closing.endPos };
+  }
+  const open = consumeOpenTag(text, lt);
+  if (open === null) {
+    return { kind: "eof", nextPos: text.length };
+  }
+  return {
+    kind: "open",
+    name: open.name,
+    selfClosing: open.selfClosing,
+    nextPos: open.nextPos
+  };
+}
+function collectToolCallsFromNormalizedText(text, toolNames) {
   var _a;
-  const toolCalls = [];
+  const normalizedText = normalizeCloseTags(text);
+  const collected = [];
   for (const toolName of toolNames) {
-    let searchIndex = 0;
-    while (searchIndex < text.length) {
-      const startTag = `<${toolName}>`;
-      const tagStart = text.indexOf(startTag, searchIndex);
-      if (tagStart === -1) break;
-      const remainingText = text.substring(tagStart);
-      const range = RXML.findFirstTopLevelRange(remainingText, toolName);
-      if (range) {
-        const contentStart = tagStart + startTag.length;
-        const contentEnd = contentStart + (range.end - range.start);
-        let fullTagEnd = contentEnd + `</${toolName}>`.length;
-        const closeHead = text.indexOf(`</${toolName}`, contentEnd);
-        if (closeHead === contentEnd) {
-          let p = closeHead + 2 + toolName.length;
-          while (p < text.length && /\s/.test(text[p])) p++;
-          if (text[p] === ">") fullTagEnd = p + 1;
+    const startTag = `<${toolName}>`;
+    let idx = 0;
+    let lastOrigIdx = 0;
+    while (idx < normalizedText.length) {
+      const tagStartNorm = normalizedText.indexOf(startTag, idx);
+      if (tagStartNorm === -1) {
+        break;
+      }
+      const contentStartNorm = tagStartNorm + startTag.length;
+      const endNorm = findClosingTagEndFlexible(
+        normalizedText,
+        contentStartNorm,
+        toolName
+      );
+      if (endNorm > contentStartNorm) {
+        const tagStartOrig = text.indexOf(startTag, lastOrigIdx);
+        const contentStartOrig = tagStartOrig + startTag.length;
+        let endOrig = findClosingTagEndFlexible(
+          text,
+          contentStartOrig,
+          toolName
+        );
+        if (endOrig === -1) {
+          const approxLen = endNorm - tagStartNorm;
+          endOrig = Math.min(text.length, tagStartOrig + approxLen);
         }
-        const segment = text.substring(tagStart, fullTagEnd);
-        const content = (_a = RXML.extractRawInner(segment, toolName)) != null ? _a : text.substring(contentStart, contentEnd);
-        toolCalls.push({
+        const segment = text.substring(tagStartOrig, endOrig);
+        const inner = (_a = (0, import_rxml.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+        collected.push({
           toolName,
-          startIndex: tagStart,
-          endIndex: fullTagEnd,
-          content,
+          startIndex: tagStartOrig,
+          endIndex: endOrig,
+          content: inner,
           segment
         });
-        searchIndex = fullTagEnd;
+        lastOrigIdx = endOrig;
+        idx = endNorm;
       } else {
-        searchIndex = tagStart + startTag.length;
+        idx = contentStartNorm;
       }
     }
   }
+  return collected.sort((a, b) => a.startIndex - b.startIndex);
+}
+function getNextTagInfo(text, toolName, fromIndex) {
+  const startTag = `<${toolName}>`;
+  const selfTag = `<${toolName}/>`;
+  const openIdx = text.indexOf(startTag, fromIndex);
+  const selfIdx = text.indexOf(selfTag, fromIndex);
+  const hasOpen = openIdx !== -1;
+  const hasSelf = selfIdx !== -1;
+  if (!(hasOpen || hasSelf)) {
+    return {
+      found: false,
+      tagStart: -1,
+      selfClosing: false,
+      startTag,
+      selfTag
+    };
+  }
+  const pickSelf = hasSelf && (!hasOpen || selfIdx < openIdx);
+  const tagStart = pickSelf ? selfIdx : openIdx;
+  return { found: true, tagStart, selfClosing: pickSelf, startTag, selfTag };
+}
+function findToolCallsForName(text, toolName) {
+  var _a;
+  const toolCalls = [];
+  let searchIndex = 0;
+  while (searchIndex < text.length) {
+    const info = getNextTagInfo(text, toolName, searchIndex);
+    if (!info.found) {
+      break;
+    }
+    const { tagStart, selfClosing, startTag, selfTag } = info;
+    if (selfClosing) {
+      const endIndex = tagStart + selfTag.length;
+      const segment = text.substring(tagStart, endIndex);
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex,
+        content: "",
+        segment
+      });
+      searchIndex = endIndex;
+      continue;
+    }
+    const contentStart = tagStart + startTag.length;
+    const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
+    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
+      const segment = text.substring(tagStart, fullTagEnd);
+      const inner = (_a = (0, import_rxml.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex: fullTagEnd,
+        content: inner,
+        segment
+      });
+      searchIndex = fullTagEnd;
+    } else {
+      searchIndex = contentStart;
+    }
+  }
+  return toolCalls;
+}
+function findToolCalls(text, toolNames) {
+  const toolCalls = [];
+  for (const toolName of toolNames) {
+    const calls = findToolCallsForName(text, toolName);
+    toolCalls.push(...calls);
+  }
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 
-// src/protocols/tool-call-protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/generate-handler.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_rxml2 = require("@ai-sdk-tool/rxml");
+
+// src/utils/on-error.ts
+function extractOnErrorOption(providerOptions) {
+  var _a;
+  if (providerOptions && typeof providerOptions === "object") {
+    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
+    return onError ? { onError } : void 0;
+  }
+  return;
+}
+
+// src/utils/provider-options.ts
+var originalToolsSchema = {
+  encode: encodeOriginalTools,
+  decode: decodeOriginalTools
+};
+function encodeOriginalTools(tools) {
+  return (tools == null ? void 0 : tools.map((t) => ({
+    name: t.name,
+    inputSchema: JSON.stringify(t.inputSchema)
+  }))) || [];
+}
+function decodeOriginalTools(originalTools) {
+  if (!originalTools) {
+    return [];
+  }
+  return originalTools.map(
+    (t) => ({
+      type: "function",
+      name: t.name,
+      inputSchema: JSON.parse(t.inputSchema)
+    })
+  );
+}
+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/generate-handler.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var RXML2 = __toESM(require("@ai-sdk-tool/rxml"), 1);
-async function wrapGenerate({
-  protocol,
-  doGenerate,
-  params
-}) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  if (isToolChoiceActive(params)) {
-    const result2 = await doGenerate();
-    let parsed2 = {};
-    const first = (_a = result2.content) == null ? void 0 : _a[0];
-    if (first && first.type === "text") {
-      const debugLevel2 = getDebugLevel();
-      if (debugLevel2 === "parse") {
-        logRawChunk(first.text);
-      }
-      try {
-        parsed2 = JSON.parse(first.text);
-      } catch (error) {
-        const options = extractOnErrorOption(params.providerOptions);
-        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-          options,
-          "Failed to parse toolChoice JSON from generated model output",
-          {
-            text: first.text,
-            error: error instanceof Error ? error.message : String(error)
-          }
-        );
-        parsed2 = {};
-      }
-    }
-    const toolCall = {
-      type: "tool-call",
-      toolCallId: (0, import_provider_utils4.generateId)(),
-      toolName: parsed2.name || "unknown",
-      input: JSON.stringify(parsed2.arguments || {})
-    };
-    const debugLevelToolChoice = getDebugLevel();
-    const originText = first && first.type === "text" ? first.text : "";
-    const dbg2 = (_d = (_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) == null ? void 0 : _d.debugSummary;
-    if (dbg2) {
-      dbg2.originalText = originText;
-      try {
-        dbg2.toolCalls = JSON.stringify([
-          { toolName: toolCall.toolName, input: toolCall.input }
-        ]);
-      } catch (e) {
+function parseToolChoiceJson(text, providerOptions) {
+  var _a;
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    const options = extractOnErrorOption(providerOptions);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+      options,
+      "Failed to parse toolChoice JSON from generated model output",
+      {
+        text,
+        error: error instanceof Error ? error.message : String(error)
       }
-    } else if (debugLevelToolChoice === "parse") {
-      logParsedSummary({ toolCalls: [toolCall], originalText: originText });
+    );
+    return {};
+  }
+}
+function logDebugSummary(debugSummary, toolCall, originText) {
+  if (debugSummary) {
+    debugSummary.originalText = originText;
+    try {
+      debugSummary.toolCalls = JSON.stringify([
+        { toolName: toolCall.toolName, input: toolCall.input }
+      ]);
+    } catch (e) {
     }
-    return {
-      ...result2,
-      content: [toolCall]
-    };
+  } else if (getDebugLevel() === "parse") {
+    logParsedSummary({ toolCalls: [toolCall], originalText: originText });
   }
-  const tools = originalToolsSchema.decode(
-    (_f = (_e = params.providerOptions) == null ? void 0 : _e.toolCallMiddleware) == null ? void 0 : _f.originalTools
-  );
+}
+async function handleToolChoice(doGenerate, params) {
+  var _a, _b, _c;
   const result = await doGenerate();
-  if (result.content.length === 0) {
-    return result;
+  const first = (_a = result.content) == null ? void 0 : _a[0];
+  let parsed = {};
+  if (first && first.type === "text") {
+    if (getDebugLevel() === "parse") {
+      logRawChunk(first.text);
+    }
+    parsed = parseToolChoiceJson(first.text, params.providerOptions);
   }
-  const parsed = result.content.flatMap((contentItem) => {
-    var _a2;
+  const toolCall = {
+    type: "tool-call",
+    toolCallId: (0, import_provider_utils3.generateId)(),
+    toolName: parsed.name || "unknown",
+    input: JSON.stringify(parsed.arguments || {})
+  };
+  const originText = first && first.type === "text" ? first.text : "";
+  const debugSummary = (_c = (_b = params.providerOptions) == null ? void 0 : _b.toolCallMiddleware) == null ? void 0 : _c.debugSummary;
+  logDebugSummary(debugSummary, toolCall, originText);
+  return {
+    ...result,
+    content: [toolCall]
+  };
+}
+function parseContent(content, protocol, tools, providerOptions) {
+  const parsed = content.flatMap((contentItem) => {
     if (contentItem.type !== "text") {
       return [contentItem];
     }
-    const debugLevel2 = getDebugLevel();
-    if (debugLevel2 === "stream") {
+    if (getDebugLevel() === "stream") {
       logRawChunk(contentItem.text);
     }
     return protocol.parseGeneratedText({
       text: contentItem.text,
       tools,
       options: {
-        ...extractOnErrorOption(params.providerOptions),
-        ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
+        ...extractOnErrorOption(providerOptions),
+        ...providerOptions == null ? void 0 : providerOptions.toolCallMiddleware
       }
     });
   });
-  const newContent = parsed.map(
+  return parsed.map(
     (part) => fixToolCallWithSchema(part, tools)
   );
-  const debugLevel = getDebugLevel();
-  if (debugLevel === "stream") {
-    newContent.forEach((part) => logParsedChunk(part));
+}
+function logParsedContent(content) {
+  if (getDebugLevel() === "stream") {
+    for (const part of content) {
+      logParsedChunk(part);
+    }
   }
+}
+function computeDebugSummary(options) {
+  var _a;
+  const { result, newContent, protocol, tools, providerOptions } = options;
   const allText = result.content.filter(
     (c) => c.type === "text"
   ).map((c) => c.text).join("\n\n");
@@ -1506,7 +2390,7 @@ async function wrapGenerate({
   const toolCalls = newContent.filter(
     (p) => p.type === "tool-call"
   );
-  const dbg = (_h = (_g = params.providerOptions) == null ? void 0 : _g.toolCallMiddleware) == null ? void 0 : _h.debugSummary;
+  const dbg = (_a = providerOptions == null ? void 0 : providerOptions.toolCallMiddleware) == null ? void 0 : _a.debugSummary;
   if (dbg) {
     dbg.originalText = originalText;
     try {
@@ -1518,9 +2402,40 @@ async function wrapGenerate({
       );
     } catch (e) {
     }
-  } else if (debugLevel === "parse") {
+  } else if (getDebugLevel() === "parse") {
     logParsedSummary({ toolCalls, originalText });
   }
+}
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  params
+}) {
+  var _a, _b;
+  if (isToolChoiceActive(params)) {
+    return handleToolChoice(doGenerate, params);
+  }
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const newContent = parseContent(
+    result.content,
+    protocol,
+    tools,
+    params.providerOptions
+  );
+  logParsedContent(newContent);
+  computeDebugSummary({
+    result,
+    newContent,
+    protocol,
+    tools,
+    providerOptions: params.providerOptions
+  });
   return {
     ...result,
     content: newContent
@@ -1528,7 +2443,9 @@ async function wrapGenerate({
 }
 function fixToolCallWithSchema(part, tools) {
   var _a;
-  if (part.type !== "tool-call") return part;
+  if (part.type !== "tool-call") {
+    return part;
+  }
   const tc = part;
   let args = {};
   if (typeof tc.input === "string") {
@@ -1541,15 +2458,81 @@ function fixToolCallWithSchema(part, tools) {
     args = tc.input;
   }
   const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = RXML2.coerceBySchema(args, schema);
+  const coerced = (0, import_rxml2.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
   };
 }
-
-// src/stream-handler.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// src/protocols/tool-call-protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
+// src/stream-handler.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+function extractToolCallSegments(protocol, fullRawText, tools) {
+  const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
+    text: fullRawText,
+    tools
+  }) : [];
+  return segments.join("\n\n");
+}
+function serializeToolCalls(parsedToolCalls) {
+  const toolCallParts = parsedToolCalls.filter(
+    (p) => p.type === "tool-call"
+  );
+  return JSON.stringify(
+    toolCallParts.map((tc) => ({
+      toolName: tc.toolName,
+      input: tc.input
+    }))
+  );
+}
+function handleDebugSummary(parsedToolCalls, origin, params) {
+  var _a, _b;
+  const dbg = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.debugSummary;
+  if (dbg) {
+    dbg.originalText = origin;
+    try {
+      dbg.toolCalls = serializeToolCalls(parsedToolCalls);
+    } catch (e) {
+    }
+  } else {
+    logParsedSummary({
+      toolCalls: parsedToolCalls,
+      originalText: origin
+    });
+  }
+}
+function createDebugSummaryTransform({
+  protocol,
+  getFullRawText,
+  tools,
+  params
+}) {
+  return new TransformStream({
+    transform: /* @__PURE__ */ (() => {
+      const parsedToolCalls = [];
+      return (part, controller) => {
+        if (part.type === "tool-call") {
+          parsedToolCalls.push(part);
+        }
+        if (part.type === "finish") {
+          try {
+            const raw = getFullRawText();
+            logRawChunk(raw);
+            const origin = extractToolCallSegments(protocol, raw, tools);
+            handleDebugSummary(parsedToolCalls, origin, params);
+          } catch (e) {
+          }
+        }
+        controller.enqueue(part);
+      };
+    })()
+  });
+}
 async function wrapStream({
   protocol,
   doStream,
@@ -1636,48 +2619,11 @@ async function wrapStream({
     })
   );
   const withSummary = parsed.pipeThrough(
-    new TransformStream({
-      transform: /* @__PURE__ */ (() => {
-        const parsedToolCalls = [];
-        return (part, controller) => {
-          var _a2, _b2;
-          if (part.type === "tool-call") {
-            parsedToolCalls.push(part);
-          }
-          if (part.type === "finish") {
-            try {
-              const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
-                text: fullRawText,
-                tools
-              }) : [];
-              const origin = segments.join("\n\n");
-              const dbg = (_b2 = (_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware) == null ? void 0 : _b2.debugSummary;
-              if (dbg) {
-                dbg.originalText = origin;
-                try {
-                  const toolCallParts = parsedToolCalls.filter(
-                    (p) => p.type === "tool-call"
-                  );
-                  dbg.toolCalls = JSON.stringify(
-                    toolCallParts.map((tc) => ({
-                      toolName: tc.toolName,
-                      input: tc.input
-                    }))
-                  );
-                } catch (e) {
-                }
-              } else {
-                logParsedSummary({
-                  toolCalls: parsedToolCalls,
-                  originalText: origin
-                });
-              }
-            } catch (e) {
-            }
-          }
-          controller.enqueue(part);
-        };
-      })()
+    createDebugSummaryTransform({
+      protocol,
+      getFullRawText: () => fullRawText,
+      tools,
+      params
     })
   );
   return {
@@ -1689,7 +2635,7 @@ async function toolChoiceStream({
   doGenerate,
   options
 }) {
-  var _a, _b;
+  var _a, _b, _c;
   const result = await doGenerate();
   let toolJson = {};
   if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
@@ -1709,19 +2655,26 @@ async function toolChoiceStream({
   }
   const toolCallChunk = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils5.generateId)(),
+    toolCallId: (0, import_provider_utils4.generateId)(),
     toolName: toolJson.name || "unknown",
     input: JSON.stringify(toolJson.arguments || {})
   };
   const finishChunk = {
     type: "finish",
-    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
-    {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0
+    usage: (result == null ? void 0 : result.usage) || {
+      inputTokens: {
+        total: 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: 0,
+        text: void 0,
+        reasoning: void 0
+      }
     },
-    finishReason: "tool-calls"
+    finishReason: { unified: "tool-calls", raw: void 0 }
   };
   const stream = new ReadableStream({
     start(controller) {
@@ -1731,7 +2684,7 @@ async function toolChoiceStream({
     }
   });
   const debugLevel = getDebugLevel();
-  const firstText = (result == null ? void 0 : result.content) && result.content[0] && result.content[0].type === "text" && result.content[0].text || "";
+  const firstText = ((_c = result == null ? void 0 : result.content) == null ? void 0 : _c[0]) && result.content[0].type === "text" && result.content[0].text || "";
   const streamWithSummary = debugLevel === "parse" ? stream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
@@ -1755,40 +2708,110 @@ async function toolChoiceStream({
   };
 }
 
-// src/transform-handler.ts
-async function transformParams({
-  params,
-  protocol,
-  toolSystemPromptTemplate
-}) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
-  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
-    (t) => t.type === "function"
-  );
-  const systemPrompt = resolvedProtocol.formatTools({
-    tools: functionTools,
-    toolSystemPromptTemplate
-  });
-  const processedPrompt = convertToolPrompt(
-    (_b = params.prompt) != null ? _b : [],
-    resolvedProtocol,
-    extractOnErrorOption(params.providerOptions)
-  );
-  const finalPrompt = ((_c = processedPrompt[0]) == null ? void 0 : _c.role) === "system" ? [
-    {
-      role: "system",
-      content: systemPrompt + "\n\n" + processedPrompt[0].content
+// src/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"
+      }
     },
-    ...processedPrompt.slice(1)
-  ] : [
+    required: ["name", "arguments"],
+    ...currentSchema
+  };
+}
+
+// src/transform-handler.ts
+function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
+  const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
+  if (systemIndex !== -1) {
+    const existing = processedPrompt[systemIndex].content;
+    let existingText = "";
+    if (typeof existing === "string") {
+      existingText = existing;
+    } else if (Array.isArray(existing)) {
+      existingText = existing.map((p) => {
+        var _a;
+        return (p == null ? void 0 : p.type) === "text" ? (_a = p.text) != null ? _a : "" : "";
+      }).filter(Boolean).join("\n");
+    } else {
+      existingText = String(existing != null ? existing : "");
+    }
+    const mergedContent = placement === "first" ? `${systemPrompt}
+
+${existingText}` : `${existingText}
+
+${systemPrompt}`;
+    return processedPrompt.map(
+      (m, idx) => idx === systemIndex ? {
+        ...m,
+        content: mergedContent
+      } : m
+    );
+  }
+  if (placement === "first") {
+    return [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      ...processedPrompt
+    ];
+  }
+  return [
+    ...processedPrompt,
     {
       role: "system",
       content: systemPrompt
-    },
-    ...processedPrompt
+    }
   ];
-  const baseReturnParams = {
+}
+function buildBaseReturnParams(params, finalPrompt, functionTools) {
+  return {
     ...params,
     prompt: finalPrompt,
     tools: [],
@@ -1797,184 +2820,242 @@ async function transformParams({
       ...params.providerOptions || {},
       toolCallMiddleware: {
         ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
-        // INTERNAL: used by the middleware so downstream parsers can access
-        // the original tool schemas even if providers strip `params.tools`.
-        // Not a stable public API.
         originalTools: originalToolsSchema.encode(functionTools)
       }
     }
   };
-  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "none") {
+}
+function findProviderDefinedTool(tools, selectedToolName) {
+  return tools.find((t) => {
+    if (t.type === "function") {
+      return false;
+    }
+    const anyTool = t;
+    return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
+  });
+}
+function handleToolChoiceTool(params, baseReturnParams) {
+  var _a, _b, _c;
+  const selectedToolName = (_a = params.toolChoice) == null ? void 0 : _a.toolName;
+  if (!selectedToolName) {
+    throw new Error("Tool name is required for 'tool' toolChoice type.");
+  }
+  const providerDefinedMatch = findProviderDefinedTool(
+    (_b = params.tools) != null ? _b : [],
+    selectedToolName
+  );
+  if (providerDefinedMatch) {
     throw new Error(
-      "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
+      "Provider-defined tools are not supported by this middleware. Please use custom tools."
     );
   }
-  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "tool") {
-    const selectedToolName = params.toolChoice.toolName;
-    const providerDefinedMatch = ((_f = params.tools) != null ? _f : []).find((t) => {
-      if (t.type === "function") return false;
-      const anyTool = t;
-      return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
-    });
-    if (providerDefinedMatch) {
-      throw new Error(
-        "Provider-defined tools are not supported by this middleware. Please use custom tools."
-      );
-    }
-    const selectedTool = ((_g = params.tools) != null ? _g : []).find(
-      (t) => t.type === "function" && t.name === selectedToolName
+  const selectedTool = ((_c = params.tools) != null ? _c : []).find(
+    (t) => t.type === "function" && t.name === selectedToolName
+  );
+  if (!selectedTool) {
+    throw new Error(
+      `Tool with name '${selectedToolName}' not found in params.tools.`
     );
-    if (!selectedTool) {
-      throw new Error(
-        `Tool with name '${selectedToolName}' not found in params.tools.`
-      );
-    }
-    return {
-      ...baseReturnParams,
-      responseFormat: {
-        type: "json",
-        schema: {
-          type: "object",
-          properties: {
-            name: {
-              const: selectedTool.name
-            },
-            arguments: selectedTool.inputSchema
+  }
+  return {
+    ...baseReturnParams,
+    responseFormat: {
+      type: "json",
+      schema: {
+        type: "object",
+        properties: {
+          name: {
+            const: selectedTool.name
           },
-          required: ["name", "arguments"]
+          arguments: selectedTool.inputSchema
         },
-        name: selectedTool.name,
-        description: typeof selectedTool.description === "string" ? selectedTool.description : void 0
+        required: ["name", "arguments"]
       },
-      providerOptions: {
-        ...baseReturnParams.providerOptions || {},
-        toolCallMiddleware: {
-          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-          // INTERNAL: used by the middleware to activate the tool-choice
-          // fast-path in handlers. Not a stable public API.
-          toolChoice: params.toolChoice
-        }
+      name: selectedTool.name,
+      description: typeof selectedTool.description === "string" ? selectedTool.description : void 0
+    },
+    providerOptions: {
+      ...baseReturnParams.providerOptions || {},
+      toolCallMiddleware: {
+        ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+        ...params.toolChoice ? { toolChoice: params.toolChoice } : {}
       }
-    };
+    }
+  };
+}
+function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
+  if (!params.tools || params.tools.length === 0) {
+    throw new Error(
+      "Tool choice type 'required' is set, but no tools are provided in params.tools."
+    );
   }
-  if (((_h = params.toolChoice) == null ? void 0 : _h.type) === "required") {
-    if (!params.tools || params.tools.length === 0) {
-      throw new Error(
-        "Tool choice type 'required' is set, but no tools are provided in params.tools."
+  return {
+    ...baseReturnParams,
+    responseFormat: {
+      type: "json",
+      schema: createDynamicIfThenElseSchema(functionTools)
+    },
+    providerOptions: {
+      ...baseReturnParams.providerOptions || {},
+      toolCallMiddleware: {
+        ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+        toolChoice: { type: "required" }
+      }
+    }
+  };
+}
+function transformParams({
+  params,
+  protocol,
+  toolSystemPromptTemplate,
+  placement = "first"
+}) {
+  var _a, _b, _c, _d, _e;
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  const systemPrompt = resolvedProtocol.formatTools({
+    tools: functionTools,
+    toolSystemPromptTemplate
+  });
+  const processedPrompt = convertToolPrompt(
+    (_b = params.prompt) != null ? _b : [],
+    resolvedProtocol,
+    extractOnErrorOption(params.providerOptions)
+  );
+  const finalPrompt = buildFinalPrompt(
+    systemPrompt,
+    processedPrompt,
+    placement
+  );
+  const baseReturnParams = buildBaseReturnParams(
+    params,
+    finalPrompt,
+    functionTools
+  );
+  if (((_c = params.toolChoice) == null ? void 0 : _c.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") {
+    return handleToolChoiceTool(params, baseReturnParams);
+  }
+  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "required") {
+    return handleToolChoiceRequired(params, baseReturnParams, functionTools);
+  }
+  return baseReturnParams;
+}
+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)
+      });
     }
-    return {
-      ...baseReturnParams,
-      responseFormat: {
-        type: "json",
-        schema: createDynamicIfThenElseSchema(functionTools)
-      },
-      providerOptions: {
-        ...baseReturnParams.providerOptions || {},
-        toolCallMiddleware: {
-          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-          // INTERNAL: used by the middleware to activate the tool-choice
-          // fast-path in handlers. Not a stable public API.
-          toolChoice: { type: "required" }
-        }
+  }
+  const onlyText = newContent.every((c) => c.type === "text");
+  return onlyText ? [
+    {
+      type: "text",
+      text: newContent.map((c) => c.text).join("\n")
+    }
+  ] : newContent;
+}
+function processToolMessage(content, resolvedProtocol) {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: content.map((toolResult) => resolvedProtocol.formatToolResponse(toolResult)).join("\n")
       }
+    ]
+  };
+}
+function processMessage(message, resolvedProtocol, providerOptions) {
+  if (message.role === "assistant") {
+    const condensedContent = processAssistantContent(
+      message.content,
+      resolvedProtocol,
+      providerOptions
+    );
+    return {
+      role: "assistant",
+      content: condensedContent
     };
   }
-  return baseReturnParams;
+  if (message.role === "tool") {
+    const toolResultParts = message.content.filter(
+      (part) => part.type === "tool-result"
+    );
+    return processToolMessage(toolResultParts, resolvedProtocol);
+  }
+  return message;
 }
-function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
-  const processedPrompt = prompt.map((message) => {
-    var _a;
-    if (message.role === "assistant") {
-      const newContent = [];
-      for (const content of message.content) {
-        if (isToolCallContent(content)) {
-          newContent.push({
-            type: "text",
-            text: resolvedProtocol.formatToolCall(content)
-          });
-        } else if (content.type === "text") {
-          newContent.push(content);
-        } else if (content.type === "reasoning") {
-          newContent.push(content);
-        } 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 }
-          );
-          newContent.push({
-            type: "text",
-            text: JSON.stringify(content)
-          });
-        }
+function isAllTextContent(content) {
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  return content.every(
+    (c) => (c == null ? void 0 : c.type) === "text"
+  );
+}
+function joinTextContent(content) {
+  return content.map((c) => c.text).join("\n");
+}
+function createCondensedMessage(role, joinedText) {
+  if (role === "system") {
+    return {
+      role: "system",
+      content: joinedText
+    };
+  }
+  return {
+    role,
+    content: [
+      {
+        type: "text",
+        text: joinedText
       }
-      const onlyText = newContent.every((c) => c.type === "text");
-      const condensedAssistant = onlyText ? [
-        {
-          type: "text",
-          text: newContent.map((c) => c.text).join("\n")
-        }
-      ] : newContent;
-      return { role: "assistant", content: condensedAssistant };
-    }
-    if (message.role === "tool") {
-      return {
-        role: "user",
-        // Map tool results to text response blocks, then condense into a single text block
-        content: [
-          {
-            type: "text",
-            text: message.content.map(
-              (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
-                toolResult
-              )
-            ).join("\n")
-          }
-        ]
-      };
-    }
-    return message;
-  });
-  for (let i = 0; i < processedPrompt.length; i++) {
+    ]
+  };
+}
+function condenseTextContent(processedPrompt) {
+  for (let i = 0; i < processedPrompt.length; i += 1) {
     const msg = processedPrompt[i];
-    if (Array.isArray(msg.content)) {
-      const allText = msg.content.every(
-        (c) => (c == null ? void 0 : c.type) === "text"
-      );
-      if (allText && msg.content.length > 1) {
-        const joinedText = msg.content.map((c) => c.text).join("\n");
-        if (msg.role === "system") {
-          processedPrompt[i] = {
-            role: "system",
-            content: joinedText
-          };
-        } else if (msg.role === "assistant") {
-          processedPrompt[i] = {
-            role: "assistant",
-            content: [
-              {
-                type: "text",
-                text: joinedText
-              }
-            ]
-          };
-        } else {
-          processedPrompt[i] = {
-            role: "user",
-            content: [
-              {
-                type: "text",
-                text: joinedText
-              }
-            ]
-          };
-        }
-      }
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
+    const shouldCondense = isAllTextContent(msg.content) && msg.content.length > 1;
+    if (shouldCondense) {
+      const joinedText = joinTextContent(msg.content);
+      processedPrompt[i] = createCondensedMessage(msg.role, joinedText);
     }
   }
-  for (let i = processedPrompt.length - 1; i > 0; i--) {
+  return processedPrompt;
+}
+function mergeConsecutiveUserMessages(processedPrompt) {
+  for (let i = processedPrompt.length - 1; i > 0; i -= 1) {
     const current = processedPrompt[i];
     const prev = processedPrompt[i - 1];
     if (current.role === "user" && prev.role === "user") {
@@ -1982,51 +3063,57 @@ function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
       const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
       processedPrompt[i - 1] = {
         role: "user",
-        content: [{ type: "text", text: prevContent + "\n" + currentContent }]
+        content: [{ type: "text", text: `${prevContent}
+${currentContent}` }]
       };
       processedPrompt.splice(i, 1);
     }
   }
   return processedPrompt;
 }
+function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+  let processedPrompt = prompt.map(
+    (message) => processMessage(message, resolvedProtocol, providerOptions)
+  );
+  processedPrompt = condenseTextContent(processedPrompt);
+  processedPrompt = mergeConsecutiveUserMessages(processedPrompt);
+  return processedPrompt;
+}
 
 // src/tool-call-middleware.ts
 function createToolMiddleware({
   protocol,
-  toolSystemPromptTemplate
+  toolSystemPromptTemplate,
+  placement = "last"
 }) {
   const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
   return {
-    middlewareVersion: "v2",
-    wrapStream: async ({ doStream, doGenerate, params }) => {
+    specificationVersion: "v3",
+    wrapStream: ({ doStream, doGenerate, params }) => {
       if (isToolChoiceActive(params)) {
         return toolChoiceStream({
           doGenerate,
           options: extractOnErrorOption(params.providerOptions)
         });
-      } else {
-        return wrapStream({
-          protocol: resolvedProtocol,
-          doStream,
-          doGenerate,
-          params
-        });
       }
+      return wrapStream({
+        protocol: resolvedProtocol,
+        doStream,
+        doGenerate,
+        params
+      });
     },
     wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
       protocol: resolvedProtocol,
       doGenerate,
       params
     }),
-    transformParams: async ({
+    transformParams: async ({ params }) => transformParams({
+      protocol: resolvedProtocol,
+      toolSystemPromptTemplate,
+      placement,
       params
-    }) => {
-      return transformParams({
-        protocol: resolvedProtocol,
-        toolSystemPromptTemplate,
-        params
-      });
-    }
+    })
   };
 }
 
@@ -2070,6 +3157,7 @@ For each function call return a json object with function name and arguments wit
 });
 var morphXmlToolMiddleware = createToolMiddleware({
   protocol: morphXmlProtocol,
+  placement: "last",
   toolSystemPromptTemplate(tools) {
     return `You are a function calling AI model.
 
@@ -2093,7 +3181,6 @@ Available functions are listed inside <tools></tools>.
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RJSON,
   createDynamicIfThenElseSchema,
   createToolMiddleware,
   decodeOriginalTools,
@@ -2110,11 +3197,15 @@ Available functions are listed inside <tools></tools>.
   isToolChoiceActive,
   isToolResultPart,
   jsonMixProtocol,
+  logParseFailure,
   logParsedChunk,
   logParsedSummary,
   logRawChunk,
   morphXmlProtocol,
   morphXmlToolMiddleware,
-  originalToolsSchema
+  originalToolsSchema,
+  parseRJSON,
+  stringifyRJSON,
+  transformRJSON
 });
 //# sourceMappingURL=index.cjs.map