npm - @ai-sdk-tool/parser - Versions diffs - 2.1.7 → 3.0.0-canary.1 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/chunk-L4X363EL.js +3168 -0
package/dist/chunk-L4X363EL.js.map +1 -0
package/dist/community.cjs +2073 -1020
package/dist/community.cjs.map +1 -1
package/dist/community.d.cts +2 -2
package/dist/community.d.ts +2 -2
package/dist/community.js +2 -2
package/dist/community.js.map +1 -1
package/dist/index.cjs +2095 -1004
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +91 -91
package/dist/index.d.ts +91 -91
package/dist/index.js +10 -4
package/package.json +23 -22
package/dist/chunk-GSD5HDOQ.js +0 -2068
package/dist/chunk-GSD5HDOQ.js.map +0 -1

package/dist/community.cjs CHANGED Viewed

@@ -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,14 +15,6 @@ 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/community/index.ts
@@ -35,66 +25,162 @@ __export(community_exports, {
 });
 module.exports = __toCommonJS(community_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
@@ -106,7 +192,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;
@@ -121,15 +207,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) {
@@ -139,31 +234,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
           )}`
@@ -185,11 +280,11 @@ function fStringSingle(m) {
     (mm) => {
       if (mm === '"') {
         return '\\"';
-      } else if (mm === "\\'") {
+      }
+      if (mm === "\\'") {
         return "'";
-      } else {
-        return mm;
       }
+      return mm;
     }
   );
   const match = `"${content}"`;
@@ -224,7 +319,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
@@ -239,7 +337,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
   };
 }
@@ -269,46 +367,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.
     ]);
   }
@@ -317,12 +415,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 = [];
@@ -348,18 +447,12 @@ function stripTrailingComma(tokens) {
   });
   return res;
 }
-function transform(text) {
-  let tokens = lexer(text);
-  tokens = stripTrailingComma(tokens);
-  return tokens.reduce((str, token) => {
-    return 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;
@@ -397,11 +490,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`;
@@ -442,7 +537,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}`);
   }
 }
@@ -539,51 +634,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;
     }
   }
 }
@@ -617,7 +745,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 "{":
@@ -638,7 +766,7 @@ function parseAny(tokens, state, end = false) {
       if (state.tolerant) {
         ret = null;
       } else {
-        return void 0;
+        return;
       }
   }
   if (end) {
@@ -647,7 +775,7 @@ function parseAny(tokens, state, end = false) {
   }
   return ret;
 }
-function parse(text, optsOrReviver) {
+function normalizeParseOptions(optsOrReviver) {
   var _a;
   let options = {};
   if (typeof optsOrReviver === "function") {
@@ -668,218 +796,247 @@ 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 stringifyPair(obj, key) {
-  return JSON.stringify(key) + ":" + stringify(obj[key]);
+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 stringify(obj) {
-  const type = typeof obj;
-  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
-    return JSON.stringify(obj);
-  }
-  if (type === "undefined") {
-    return "null";
-  }
-  if (Array.isArray(obj)) {
-    const elements = obj.map(stringify).join(",");
-    return "[" + elements + "]";
+function parse(text, optsOrReviver) {
+  const options = normalizeParseOptions(optsOrReviver);
+  if (!(options.relaxed || options.warnings || options.tolerant) && options.duplicate) {
+    return JSON.parse(
+      text,
+      options.reviver
+    );
   }
-  if (type === "object") {
-    const keys = Object.keys(obj);
-    keys.sort();
-    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
-    return "{" + pairs + "}";
+  if (options.warnings || options.tolerant || !options.duplicate) {
+    return parseWithCustomParser(text, options);
   }
-  return "null";
+  return parseWithTransform(text, options);
 }
-// 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 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>",
@@ -913,7 +1070,6 @@ var jsonMixProtocol = ({
     })}${toolResponseEnd}`;
   },
   parseGeneratedText({ text, options }) {
-    var _a;
     const startEsc = escapeRegExp(toolCallStart);
     const endEsc = escapeRegExp(toolCallEnd);
     const toolCallRegex = new RegExp(
@@ -922,185 +1078,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);
       }
     });
   },
@@ -1109,23 +1130,706 @@ 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 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));
   },
@@ -1141,67 +1845,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 }) {
@@ -1210,129 +1893,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);
   }
 });
@@ -1340,140 +1961,368 @@ 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 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");
@@ -1482,7 +2331,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 {
@@ -1494,9 +2343,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
@@ -1504,7 +2384,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") {
@@ -1517,15 +2399,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,
@@ -1612,48 +2560,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 {
@@ -1665,7 +2576,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") {
@@ -1685,19 +2596,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) {
@@ -1707,7 +2625,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) {
@@ -1731,40 +2649,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: [],
@@ -1773,184 +2761,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") {
@@ -1958,51 +3004,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
-      });
-    }
+    })
   };
 }
@@ -2046,6 +3098,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.
@@ -2068,7 +3121,7 @@ Available functions are listed inside <tools></tools>.
   }
 });
-// src/community/index.ts
+// src/community/sijawara.ts
 var sijawaraDetailedXmlToolMiddleware = createToolMiddleware({
   protocol: morphXmlProtocol,
   toolSystemPromptTemplate(tools) {