@ai-sdk-tool/parser 2.1.5 → 2.1.7

package/dist/community.cjs

@@ -0,0 +1,2164 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/community/index.ts
+var community_exports = {};
+__export(community_exports, {
+  sijawaraConciseXmlToolMiddleware: () => sijawaraConciseXmlToolMiddleware,
+  sijawaraDetailedXmlToolMiddleware: () => sijawaraDetailedXmlToolMiddleware
+});
+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");
+
+// 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;
+  }
+  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
+function getPotentialStartIndex(text, searchedText) {
+  if (searchedText.length === 0) {
+    return null;
+  }
+  const directIndex = text.indexOf(searchedText);
+  if (directIndex !== -1) {
+    return directIndex;
+  }
+  for (let i = text.length - 1; i >= 0; i--) {
+    const suffix = text.substring(i);
+    if (searchedText.startsWith(suffix)) {
+      return i;
+    }
+  }
+  return null;
+}
+
+// src/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/robust-json.ts
+var robust_json_exports = {};
+__export(robust_json_exports, {
+  parse: () => parse,
+  stringify: () => stringify,
+  transform: () => transform
+});
+function some(array, f) {
+  let acc = false;
+  for (let i = 0; i < array.length; i++) {
+    const result = f(array[i], i, array);
+    acc = result === void 0 ? false : result;
+    if (acc) {
+      return acc;
+    }
+  }
+  return acc;
+}
+function makeLexer(tokenSpecs) {
+  return function(contents) {
+    const tokens = [];
+    let line = 1;
+    function findToken() {
+      const result = some(tokenSpecs, (tokenSpec) => {
+        const m = tokenSpec.re.exec(contents);
+        if (m) {
+          const raw = m[0];
+          contents = contents.slice(raw.length);
+          return {
+            raw,
+            matched: tokenSpec.f(m)
+            // Process the match using the spec's function
+          };
+        } else {
+          return void 0;
+        }
+      });
+      return result === false ? void 0 : result;
+    }
+    while (contents !== "") {
+      const matched = findToken();
+      if (!matched) {
+        const err = new SyntaxError(
+          `Unexpected character: ${contents[0]}; input: ${contents.substr(
+            0,
+            100
+          )}`
+        );
+        err.line = line;
+        throw err;
+      }
+      const tokenWithLine = matched.matched;
+      tokenWithLine.line = line;
+      line += matched.raw.replace(/[^\n]/g, "").length;
+      tokens.push(tokenWithLine);
+    }
+    return tokens;
+  };
+}
+function fStringSingle(m) {
+  const content = m[1].replace(
+    /([^'\\]|\\['bnrtf\\]|\\u[0-9a-fA-F]{4})/g,
+    (mm) => {
+      if (mm === '"') {
+        return '\\"';
+      } else if (mm === "\\'") {
+        return "'";
+      } else {
+        return mm;
+      }
+    }
+  );
+  const match = `"${content}"`;
+  return {
+    type: "string",
+    match,
+    // The transformed, double-quoted string representation
+    // Use JSON.parse on the transformed string to handle escape sequences correctly
+    value: JSON.parse(match)
+  };
+}
+function fStringDouble(m) {
+  return {
+    type: "string",
+    match: m[0],
+    // The raw matched string (including quotes)
+    value: JSON.parse(m[0])
+    // Use JSON.parse to handle escapes and get the value
+  };
+}
+function fIdentifier(m) {
+  const value = m[0];
+  const match = '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + // Escape backslashes and quotes
+  '"';
+  return {
+    type: "string",
+    // Treat identifiers as strings
+    value,
+    // The original identifier name
+    match
+    // The double-quoted string representation
+  };
+}
+function fComment(m) {
+  const match = m[0].replace(/./g, (c) => /\s/.test(c) ? c : " ");
+  return {
+    type: " ",
+    // Represent comments as whitespace tokens
+    match,
+    // String containing original newlines and spaces for other chars
+    value: void 0
+    // Comments don't have a semantic value
+  };
+}
+function fNumber(m) {
+  return {
+    type: "number",
+    match: m[0],
+    // The raw matched number string
+    value: parseFloat(m[0])
+    // Convert string to number
+  };
+}
+function fKeyword(m) {
+  let value;
+  switch (m[0]) {
+    case "null":
+      value = null;
+      break;
+    case "true":
+      value = true;
+      break;
+    case "false":
+      value = false;
+      break;
+    default:
+      throw new Error(`Unexpected keyword: ${m[0]}`);
+  }
+  return {
+    type: "atom",
+    // Use 'atom' type for these literals
+    match: m[0],
+    // The raw matched keyword
+    value
+    // The corresponding JavaScript value
+  };
+}
+function makeTokenSpecs(relaxed) {
+  function f(type) {
+    return function(m) {
+      return { type, match: m[0], value: void 0 };
+    };
+  }
+  let tokenSpecs = [
+    { re: /^\s+/, f: f(" ") },
+    // Whitespace
+    { re: /^\{/, f: f("{") },
+    // Object start
+    { re: /^\}/, f: f("}") },
+    // Object end
+    { re: /^\[/, f: f("[") },
+    // Array start
+    { re: /^\]/, f: f("]") },
+    // Array end
+    { re: /^,/, f: f(",") },
+    // Comma separator
+    { re: /^:/, f: f(":") },
+    // Key-value separator
+    { re: /^(?:true|false|null)/, f: fKeyword },
+    // Keywords
+    // Number: optional sign, digits, optional decimal part, optional exponent
+    { re: /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, f: fNumber },
+    // String: double-quoted, handles escapes
+    { re: /^"(?:[^"\\]|\\["bnrtf\\/]|\\u[0-9a-fA-F]{4})*"/, f: fStringDouble }
+  ];
+  if (relaxed) {
+    tokenSpecs = tokenSpecs.concat([
+      // Single-quoted strings
+      {
+        re: /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/,
+        f: fStringSingle
+      },
+      // Single-line comments (// ...)
+      { re: /^\/\/.*?(?:\r\n|\r|\n)/, f: fComment },
+      // Multi-line comments (/* ... */)
+      { re: /^\/\*[\s\S]*?\*\//, f: fComment },
+      // Unquoted identifiers (treated as strings)
+      // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
+      { re: /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/, f: fIdentifier }
+      // Note: The order matters here. Identifiers are checked after keywords/numbers.
+    ]);
+  }
+  return tokenSpecs;
+}
+var lexer = makeLexer(makeTokenSpecs(true));
+var strictLexer = makeLexer(makeTokenSpecs(false));
+function previousNWSToken(tokens, index) {
+  for (; index >= 0; index--) {
+    if (tokens[index].type !== " ") {
+      return index;
+    }
+  }
+  return void 0;
+}
+function stripTrailingComma(tokens) {
+  const res = [];
+  tokens.forEach((token, index) => {
+    if (index > 0 && (token.type === "]" || token.type === "}")) {
+      const prevNWSTokenIndex = previousNWSToken(res, res.length - 1);
+      if (prevNWSTokenIndex !== void 0 && res[prevNWSTokenIndex].type === ",") {
+        const preCommaIndex = previousNWSToken(res, prevNWSTokenIndex - 1);
+        if (preCommaIndex !== void 0 && res[preCommaIndex].type !== "[" && res[preCommaIndex].type !== "{") {
+          res[prevNWSTokenIndex] = {
+            type: " ",
+            match: " ",
+            // Represent as a single space
+            value: void 0,
+            // Whitespace has no value
+            line: res[prevNWSTokenIndex].line
+            // Preserve original line number
+          };
+        }
+      }
+    }
+    res.push(token);
+  });
+  return res;
+}
+function transform(text) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  return tokens.reduce((str, token) => {
+    return str + token.match;
+  }, "");
+}
+function popToken(tokens, state) {
+  const token = tokens[state.pos];
+  state.pos += 1;
+  if (!token) {
+    const lastLine = tokens.length !== 0 ? tokens[tokens.length - 1].line : 1;
+    return { type: "eof", match: "", value: void 0, line: lastLine };
+  }
+  return token;
+}
+function strToken(token) {
+  switch (token.type) {
+    case "atom":
+    case "string":
+    case "number":
+      return `${token.type} ${token.match}`;
+    case "eof":
+      return "end-of-file";
+    default:
+      return `'${token.type}'`;
+  }
+}
+function skipColon(tokens, state) {
+  const colon = popToken(tokens, state);
+  if (colon.type !== ":") {
+    const message = `Unexpected token: ${strToken(colon)}, expected ':'`;
+    if (state.tolerant) {
+      state.warnings.push({
+        message,
+        line: colon.line
+      });
+      state.pos -= 1;
+    } else {
+      const err = new SyntaxError(message);
+      err.line = colon.line;
+      throw err;
+    }
+  }
+}
+function skipPunctuation(tokens, state, valid) {
+  const punctuation = [",", ":", "]", "}"];
+  let token = popToken(tokens, state);
+  while (true) {
+    if (valid && valid.includes(token.type)) {
+      return token;
+    } else if (token.type === "eof") {
+      return token;
+    } else if (punctuation.includes(token.type)) {
+      const message = `Unexpected token: ${strToken(
+        token
+      )}, expected '[', '{', number, string or atom`;
+      if (state.tolerant) {
+        state.warnings.push({
+          message,
+          line: token.line
+        });
+        token = popToken(tokens, state);
+      } else {
+        const err = new SyntaxError(message);
+        err.line = token.line;
+        throw err;
+      }
+    } else {
+      return token;
+    }
+  }
+}
+function raiseError(state, token, message) {
+  if (state.tolerant) {
+    state.warnings.push({
+      message,
+      line: token.line
+    });
+  } else {
+    const err = new SyntaxError(message);
+    err.line = token.line;
+    throw err;
+  }
+}
+function raiseUnexpected(state, token, expected) {
+  raiseError(
+    state,
+    token,
+    `Unexpected token: ${strToken(token)}, expected ${expected}`
+  );
+}
+function checkDuplicates(state, obj, token) {
+  const key = String(token.value);
+  if (!state.duplicate && Object.prototype.hasOwnProperty.call(obj, key)) {
+    raiseError(state, token, `Duplicate key: ${key}`);
+  }
+}
+function appendPair(state, obj, key, value) {
+  const finalValue = state.reviver ? state.reviver(key, value) : value;
+  if (finalValue !== void 0) {
+    obj[key] = finalValue;
+  }
+}
+function parsePair(tokens, state, obj) {
+  let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
+  let value;
+  if (token.type !== "string") {
+    raiseUnexpected(state, token, "string key");
+    if (state.tolerant) {
+      switch (token.type) {
+        case ":":
+          token = {
+            type: "string",
+            value: "null",
+            match: '"null"',
+            line: token.line
+          };
+          state.pos -= 1;
+          break;
+        case "number":
+        // Use number as string key
+        case "atom":
+          token = {
+            type: "string",
+            value: String(token.value),
+            match: `"${token.value}"`,
+            line: token.line
+          };
+          break;
+        case "[":
+        // Assume missing key before an array
+        case "{":
+          state.pos -= 1;
+          value = parseAny(tokens, state);
+          checkDuplicates(state, obj, {
+            type: "string",
+            value: "null",
+            match: '"null"',
+            line: token.line
+          });
+          appendPair(state, obj, "null", value);
+          return;
+        // Finished parsing this "pair"
+        case "eof":
+          return;
+        // Cannot recover
+        default:
+          return;
+      }
+    } else {
+      return;
+    }
+  }
+  checkDuplicates(state, obj, token);
+  const key = String(token.value);
+  skipColon(tokens, state);
+  value = parseAny(tokens, state);
+  appendPair(state, obj, key, value);
+}
+function parseElement(tokens, state, arr) {
+  const key = arr.length;
+  const value = parseAny(tokens, state);
+  arr[key] = state.reviver ? state.reviver(String(key), value) : value;
+}
+function parseObject(tokens, state) {
+  const obj = {};
+  return parseMany(tokens, state, obj, {
+    skip: [":", "}"],
+    // Initially skip over colon or closing brace (for empty/tolerant cases)
+    elementParser: parsePair,
+    // Use parsePair to parse each key-value element
+    elementName: "string key",
+    // Expected element type for errors
+    endSymbol: "}"
+    // The closing token for an object
+  });
+}
+function parseArray(tokens, state) {
+  const arr = [];
+  return parseMany(tokens, state, arr, {
+    skip: ["]"],
+    // Initially skip over closing bracket (for empty/tolerant cases)
+    elementParser: parseElement,
+    // Use parseElement to parse each array item
+    elementName: "json value",
+    // Expected element type for errors
+    endSymbol: "]"
+    // The closing token for an array
+  });
+}
+function 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 {
+      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;
+      }
+    }
+    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;
+    }
+  }
+}
+function endChecks(tokens, state, ret) {
+  if (state.pos < tokens.length) {
+    if (state.tolerant) {
+      skipPunctuation(tokens, state);
+    }
+    if (state.pos < tokens.length) {
+      raiseError(
+        state,
+        tokens[state.pos],
+        `Unexpected token: ${strToken(tokens[state.pos])}, expected end-of-input`
+      );
+    }
+  }
+  if (state.tolerant && state.warnings.length > 0) {
+    const message = state.warnings.length === 1 ? state.warnings[0].message : `${state.warnings.length} parse warnings`;
+    const err = new SyntaxError(message);
+    err.line = state.warnings[0].line;
+    err.warnings = state.warnings;
+    err.obj = ret;
+    throw err;
+  }
+}
+function parseAny(tokens, state, end = false) {
+  const token = skipPunctuation(tokens, state);
+  let ret;
+  if (token.type === "eof") {
+    if (end) {
+      raiseUnexpected(state, token, "json value");
+    }
+    raiseUnexpected(state, token, "json value");
+    return void 0;
+  }
+  switch (token.type) {
+    case "{":
+      ret = parseObject(tokens, state);
+      break;
+    case "[":
+      ret = parseArray(tokens, state);
+      break;
+    case "string":
+    // String literal
+    case "number":
+    // Number literal
+    case "atom":
+      ret = token.value;
+      break;
+    default:
+      raiseUnexpected(state, token, "json value");
+      if (state.tolerant) {
+        ret = null;
+      } else {
+        return void 0;
+      }
+  }
+  if (end) {
+    ret = state.reviver ? state.reviver("", ret) : ret;
+    endChecks(tokens, state, ret);
+  }
+  return ret;
+}
+function parse(text, optsOrReviver) {
+  var _a;
+  let options = {};
+  if (typeof optsOrReviver === "function") {
+    options.reviver = optsOrReviver;
+  } else if (optsOrReviver !== null && typeof optsOrReviver === "object") {
+    options = { ...optsOrReviver };
+  } else if (optsOrReviver !== void 0) {
+    throw new TypeError(
+      "Second argument must be a reviver function or an options object."
+    );
+  }
+  if (options.relaxed === void 0) {
+    if (options.warnings === true || options.tolerant === true) {
+      options.relaxed = true;
+    } else if (options.warnings === false && options.tolerant === false) {
+      options.relaxed = false;
+    } else {
+      options.relaxed = true;
+    }
+  }
+  options.tolerant = options.tolerant || options.warnings || false;
+  options.warnings = options.warnings || false;
+  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
+      );
+    }
+  }
+  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
+      );
+    }
+  }
+}
+function stringifyPair(obj, key) {
+  return JSON.stringify(key) + ":" + stringify(obj[key]);
+}
+function stringify(obj) {
+  const type = typeof obj;
+  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
+    return JSON.stringify(obj);
+  }
+  if (type === "undefined") {
+    return "null";
+  }
+  if (Array.isArray(obj)) {
+    const elements = obj.map(stringify).join(",");
+    return "[" + elements + "]";
+  }
+  if (type === "object") {
+    const keys = Object.keys(obj);
+    keys.sort();
+    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
+    return "{" + pairs + "}";
+  }
+  return "null";
+}
+
+// src/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;
+  }
+  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;
+  }
+  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 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 logRawChunk(part) {
+  console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
+}
+function logParsedChunk(part) {
+  console.log(cGray("[debug:mw:out]"), cCyan(safeStringify(part)));
+}
+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}`);
+  }
+  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);
+  }
+}
+
+// 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 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 isToolResultPart(content) {
+  const c = content;
+  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+}
+function hasInputProperty(obj) {
+  return typeof obj === "object" && obj !== null && "input" in obj;
+}
+
+// src/protocols/json-mix-protocol.ts
+var jsonMixProtocol = ({
+  toolCallStart = "<tool_call>",
+  toolCallEnd = "</tool_call>",
+  toolResponseStart = "<tool_response>",
+  toolResponseEnd = "</tool_response>"
+} = {}) => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
+      name: tool.name,
+      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
+      parameters: tool.inputSchema
+    }));
+    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    try {
+      args = JSON.parse(toolCall.input);
+    } catch (e) {
+      args = toolCall.input;
+    }
+    return `${toolCallStart}${JSON.stringify({
+      name: toolCall.toolName,
+      arguments: args
+    })}${toolCallEnd}`;
+  },
+  formatToolResponse(toolResult) {
+    return `${toolResponseStart}${JSON.stringify({
+      toolName: toolResult.toolName,
+      result: toolResult.output
+    })}${toolResponseEnd}`;
+  },
+  parseGeneratedText({ text, options }) {
+    var _a;
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const toolCallRegex = new RegExp(
+      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
+      "gs"
+    );
+    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;
+    }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools: _tools, options } = { tools: [] }) {
+    let isInsideToolCall = false;
+    let buffer = "";
+    let currentToolCallJson = "";
+    let currentTextId = null;
+    let 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);
+          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 = "";
+          }
+        }
+      }
+    });
+  },
+  extractToolCallSegments({ text }) {
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
+    const segments = [];
+    let m;
+    while ((m = regex.exec(text)) != null) {
+      segments.push(m[0]);
+    }
+    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 morphXmlProtocol = () => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    const toolsForPrompt = (tools || []).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: RXML.unwrapJsonSchema(tool.inputSchema)
+    }));
+    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
+    if (typeof inputValue === "string") {
+      try {
+        args = JSON.parse(inputValue);
+      } catch (e) {
+        args = inputValue;
+      }
+    } else {
+      args = inputValue;
+    }
+    return RXML.stringify(toolCall.toolName, args, {
+      suppressEmptyNode: false,
+      format: false
+    });
+  },
+  formatToolResponse(toolResult) {
+    return 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 });
+      }
+      currentIndex = toolCall.endIndex;
+    }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools, options }) {
+    const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+    const maxStartTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
+    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 = "";
+        }
+      }
+      if (currentTextId && !text) {
+        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;
+            }
+          }
+        }
+      },
+      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 });
+        }
+      }
+    });
+  },
+  extractToolCallSegments({ text, tools }) {
+    const toolNames = tools.map((t) => t.name).filter(Boolean);
+    if (toolNames.length === 0) return [];
+    return findToolCalls(text, toolNames).map((tc) => tc.segment);
+  }
+});
+function getToolSchema(tools, toolName) {
+  var _a;
+  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+}
+function findToolCalls(text, toolNames) {
+  var _a;
+  const toolCalls = [];
+  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 segment = text.substring(tagStart, fullTagEnd);
+        const content = (_a = RXML.extractRawInner(segment, toolName)) != null ? _a : text.substring(contentStart, contentEnd);
+        toolCalls.push({
+          toolName,
+          startIndex: tagStart,
+          endIndex: fullTagEnd,
+          content,
+          segment
+        });
+        searchIndex = fullTagEnd;
+      } else {
+        searchIndex = tagStart + startTag.length;
+      }
+    }
+  }
+  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_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) {
+      }
+    } else if (debugLevelToolChoice === "parse") {
+      logParsedSummary({ toolCalls: [toolCall], originalText: originText });
+    }
+    return {
+      ...result2,
+      content: [toolCall]
+    };
+  }
+  const tools = originalToolsSchema.decode(
+    (_f = (_e = params.providerOptions) == null ? void 0 : _e.toolCallMiddleware) == null ? void 0 : _f.originalTools
+  );
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const parsed = result.content.flatMap((contentItem) => {
+    var _a2;
+    if (contentItem.type !== "text") {
+      return [contentItem];
+    }
+    const debugLevel2 = getDebugLevel();
+    if (debugLevel2 === "stream") {
+      logRawChunk(contentItem.text);
+    }
+    return protocol.parseGeneratedText({
+      text: contentItem.text,
+      tools,
+      options: {
+        ...extractOnErrorOption(params.providerOptions),
+        ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
+      }
+    });
+  });
+  const newContent = parsed.map(
+    (part) => fixToolCallWithSchema(part, tools)
+  );
+  const debugLevel = getDebugLevel();
+  if (debugLevel === "stream") {
+    newContent.forEach((part) => logParsedChunk(part));
+  }
+  const allText = result.content.filter(
+    (c) => c.type === "text"
+  ).map((c) => c.text).join("\n\n");
+  const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
+  const originalText = segments.join("\n\n");
+  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;
+  if (dbg) {
+    dbg.originalText = originalText;
+    try {
+      dbg.toolCalls = JSON.stringify(
+        toolCalls.map((tc) => ({
+          toolName: tc.toolName,
+          input: tc.input
+        }))
+      );
+    } catch (e) {
+    }
+  } else if (debugLevel === "parse") {
+    logParsedSummary({ toolCalls, originalText });
+  }
+  return {
+    ...result,
+    content: newContent
+  };
+}
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") return part;
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = 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");
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a, _b, _c;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
+  const debugLevel = getDebugLevel();
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
+  const options = {
+    ...extractOnErrorOption(params.providerOptions),
+    ...(_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware
+  };
+  if (debugLevel === "off") {
+    return {
+      stream: stream.pipeThrough(
+        protocol.createStreamParser({
+          tools,
+          options
+        })
+      ),
+      ...rest
+    };
+  }
+  if (debugLevel === "stream") {
+    const withRawTap2 = stream.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logRawChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    const parsed2 = withRawTap2.pipeThrough(
+      protocol.createStreamParser({
+        tools,
+        options
+      })
+    );
+    const withParsedTap = parsed2.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logParsedChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    return {
+      stream: withParsedTap,
+      ...rest
+    };
+  }
+  let fullRawText = "";
+  const withRawTap = stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "text-delta") {
+          const delta = part.delta;
+          if (typeof delta === "string" && delta.length > 0) {
+            fullRawText += delta;
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  );
+  const parsed = withRawTap.pipeThrough(
+    protocol.createStreamParser({
+      tools,
+      options
+    })
+  );
+  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);
+        };
+      })()
+    })
+  );
+  return {
+    stream: withSummary,
+    ...rest
+  };
+}
+async function toolChoiceStream({
+  doGenerate,
+  options
+}) {
+  var _a, _b;
+  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") {
+    try {
+      toolJson = JSON.parse(result.content[0].text);
+    } catch (error) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        options,
+        "Failed to parse toolChoice JSON from streamed model output",
+        {
+          text: result.content[0].text,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      toolJson = {};
+    }
+  }
+  const toolCallChunk = {
+    type: "tool-call",
+    toolCallId: (0, import_provider_utils5.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
+    },
+    finishReason: "tool-calls"
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(toolCallChunk);
+      controller.enqueue(finishChunk);
+      controller.close();
+    }
+  });
+  const debugLevel = getDebugLevel();
+  const firstText = (result == null ? void 0 : result.content) && result.content[0] && result.content[0].type === "text" && result.content[0].text || "";
+  const streamWithSummary = debugLevel === "parse" ? stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "finish") {
+          try {
+            logParsedSummary({
+              toolCalls: [toolCallChunk],
+              originalText: typeof firstText === "string" ? firstText : ""
+            });
+          } catch (e) {
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  ) : stream;
+  return {
+    request: (result == null ? void 0 : result.request) || {},
+    response: (result == null ? void 0 : result.response) || {},
+    stream: streamWithSummary
+  };
+}
+
+// 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
+    },
+    ...processedPrompt.slice(1)
+  ] : [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...processedPrompt
+  ];
+  const baseReturnParams = {
+    ...params,
+    prompt: finalPrompt,
+    tools: [],
+    toolChoice: void 0,
+    providerOptions: {
+      ...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") {
+    throw new Error(
+      "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
+    );
+  }
+  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
+    );
+    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
+          },
+          required: ["name", "arguments"]
+        },
+        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 || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          toolChoice: params.toolChoice
+        }
+      }
+    };
+  }
+  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 || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          toolChoice: { type: "required" }
+        }
+      }
+    };
+  }
+  return baseReturnParams;
+}
+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)
+          });
+        }
+      }
+      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++) {
+    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
+              }
+            ]
+          };
+        }
+      }
+    }
+  }
+  for (let i = processedPrompt.length - 1; i > 0; i--) {
+    const current = processedPrompt[i];
+    const prev = processedPrompt[i - 1];
+    if (current.role === "user" && prev.role === "user") {
+      const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+      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 }]
+      };
+      processedPrompt.splice(i, 1);
+    }
+  }
+  return processedPrompt;
+}
+
+// src/tool-call-middleware.ts
+function createToolMiddleware({
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream, doGenerate, params }) => {
+      if (isToolChoiceActive(params)) {
+        return toolChoiceStream({
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
+        });
+      } else {
+        return wrapStream({
+          protocol: resolvedProtocol,
+          doStream,
+          doGenerate,
+          params
+        });
+      }
+    },
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({
+      params
+    }) => {
+      return transformParams({
+        protocol: resolvedProtocol,
+        toolSystemPromptTemplate,
+        params
+      });
+    }
+  };
+}
+
+// src/index.ts
+var gemmaToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol(
+    // Customize the tool call delimiters to use markdown code fences
+    {
+      toolCallStart: "```tool_call\n",
+      // TODO: Support specifying multiple possible tags,
+      // e.g., for gemma, it would be nice to be able to set both `` and ``` at the same time.
+      toolCallEnd: "\n```",
+      toolResponseStart: "```tool_response\n",
+      toolResponseEnd: "\n```"
+    }
+  ),
+  toolSystemPromptTemplate(tools) {
+    return `You have access to functions. If you decide to invoke any of the function(s),
+you MUST put it in the format of markdown code fence block with the language name of tool_call , e.g.
+\`\`\`tool_call
+{'name': <function-name>, 'arguments': <args-dict>}
+\`\`\`
+You SHOULD NOT include any other text in the response if you call a function
+${tools}`;
+  }
+});
+var hermesToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You are a function calling AI model.
+You are provided with function signatures within <tools></tools> XML tags.
+You may call one or more functions to assist with the user query.
+Don't make assumptions about what values to plug into functions.
+Here are the available tools: <tools>${tools}</tools>
+Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
+  }
+});
+var morphXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You are a function calling AI model.
+
+Available functions are listed inside <tools></tools>.
+<tools>${tools}</tools>
+
+# Rules
+- Use exactly one XML element whose tag name is the function name.
+- Put each parameter as a child element.
+- Values must follow the schema exactly (numbers, arrays, objects, enums \u2192 copy as-is).
+- Do not add or remove functions or parameters.
+- Each required parameter must appear once.
+- Output nothing before or after the function call.
+
+# Example
+<get_weather>
+  <location>New York</location>
+  <unit>celsius</unit>
+</get_weather>`;
+  }
+});
+
+// src/community/index.ts
+var sijawaraDetailedXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You have access to callable functions (tools).
+    Tool list/context:
+    ${tools}
+
+    ===============================
+    TOOL CALLING FORMAT
+    ===============================
+    - Use the XML-like format for tool calls:
+      <tool_name>
+        <parameter_name>
+          value
+        </parameter_name>
+        ...
+      </tool_name>
+
+    ===============================
+    ARRAY PARAMETERS
+    ===============================
+    - For array/multiple values, repeat the parameter for each value.
+    - Example:
+      <send_messages>
+        <recipient>
+          alice@example.com
+        </recipient>
+        <recipient>
+          bob@example.com
+        </recipient>
+        <message>
+          Hello!
+        </message>
+      </send_messages>
+
+    ===============================
+    SINGLE VALUE PARAMETERS
+    ===============================
+    - For single values, use one parameter block.
+    - Example:
+      <get_weather>
+        <location>
+          San Francisco
+        </location>
+      </get_weather>
+
+    ===============================
+    GENERAL RULES
+    ===============================
+    - First line: tool (function) name in angle brackets.
+    - Parameters: each on their own line, in angle brackets, with name and value.
+    - Include all required parameters. If info is missing, ask the user.
+    - Do NOT use JSON\u2014use only the specified XML-like format for tool calls.
+    - If no call is needed, reply without a tool call.`;
+  }
+});
+var sijawaraConciseXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You have access to callable functions (tools).
+    Tool list/context:
+    ${tools}
+
+    STRICT CALLING RULES:
+    - Use the XML-like format for tool calls:
+
+      <tool_name>
+        <parameter_name>
+          value
+        </parameter_name>
+        ...
+      </tool_name>
+
+    - First line: the tool (function) name in angle brackets.
+    - Parameters: each in their own angle brackets with name and value.
+    - Include all required parameters. If info is missing, ask the user.
+    - Do NOT use JSON. Use only the specified XML-like format.
+    - If no call is needed, reply without a tool call.
+
+    Example:
+    <get_weather>
+      <location>
+        San Francisco
+      </location>
+    </get_weather>`;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sijawaraConciseXmlToolMiddleware,
+  sijawaraDetailedXmlToolMiddleware
+});
+//# sourceMappingURL=community.cjs.map