@ai-sdk-tool/parser 1.0.2 → 2.0.0

package/dist/index.js

@@ -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,31 +15,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   createToolMiddleware: () => createToolMiddleware,
-  defaultTemplate: () => defaultTemplate,
   gemmaToolMiddleware: () => gemmaToolMiddleware,
   hermesToolMiddleware: () => hermesToolMiddleware
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/tool-call-middleware.ts
-var import_ai = require("ai");
-var RJSON = __toESM(require("relaxed-json"));
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
-// src/utils.ts
+// src/utils/get-potential-start-index.ts
 function getPotentialStartIndex(text, searchedText) {
   if (searchedText.length === 0) {
     return null;
@@ -59,26 +47,606 @@ function getPotentialStartIndex(text, searchedText) {
   return null;
 }
 
+// src/utils/relaxed-json.ts
+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 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 key;
+  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);
+  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) {
+  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 = options.duplicate || 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,
+      // Internal state: true means *check* for duplicates
+      warnings: []
+    };
+    return parseAny(tokens, state, true);
+  } else {
+    const newtext = 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 = check duplicates
+        warnings: []
+      };
+      return parseAny(tokens, state, true);
+    } else {
+      tokens = lexer(text);
+      tokens = stripTrailingComma(tokens);
+      const newtext2 = tokens.reduce((str, token) => str + token.match, "");
+      return JSON.parse(newtext2, options.reviver);
+    }
+  }
+}
+
 // src/tool-call-middleware.ts
-var defaultTemplate = (tools) => `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>
-{'arguments': <args-dict>, 'name': <function-name>}
-</tool_call>`;
 function createToolMiddleware({
-  toolCallTag = "<tool_call>",
-  toolCallEndTag = "</tool_call>",
-  toolResponseTag = "<tool_response>",
-  toolResponseEndTag = "</tool_response>",
-  toolSystemPromptTemplate = defaultTemplate
+  toolCallTag,
+  toolCallEndTag,
+  toolResponseTag,
+  toolResponseEndTag,
+  toolSystemPromptTemplate
 }) {
   return {
-    middlewareVersion: "v1",
+    middlewareVersion: "v2",
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();
       let isFirstToolCall = true;
@@ -94,30 +662,30 @@ function createToolMiddleware({
             if (toolCallBuffer.length > 0) {
               toolCallBuffer.forEach((toolCall) => {
                 try {
-                  const parsedToolCall = RJSON.parse(toolCall);
+                  const parsedToolCall = parse(toolCall);
                   controller.enqueue({
                     type: "tool-call",
                     toolCallType: "function",
-                    toolCallId: (0, import_ai.generateId)(),
+                    toolCallId: (0, import_provider_utils.generateId)(),
                     toolName: parsedToolCall.name,
                     args: JSON.stringify(parsedToolCall.arguments)
                   });
                 } catch (e) {
                   console.error(`Error parsing tool call: ${toolCall}`, e);
                   controller.enqueue({
-                    type: "text-delta",
-                    textDelta: `Failed to parse tool call: ${e}`
+                    type: "text",
+                    text: `Failed to parse tool call: ${e}`
                   });
                 }
               });
             }
             controller.enqueue(chunk);
             return;
-          } else if (chunk.type !== "text-delta") {
+          } else if (chunk.type !== "text") {
             controller.enqueue(chunk);
             return;
           }
-          buffer += chunk.textDelta;
+          buffer += chunk.text;
           function publish(text) {
             if (text.length > 0) {
               const prefix = afterSwitch && (isToolCall ? !isFirstToolCall : !isFirstText) ? "\n" : "";
@@ -128,8 +696,8 @@ function createToolMiddleware({
                 toolCallBuffer[toolCallIndex] += text;
               } else {
                 controller.enqueue({
-                  type: "text-delta",
-                  textDelta: prefix + text
+                  type: "text",
+                  text: prefix + text
                 });
               }
               afterSwitch = false;
@@ -168,32 +736,37 @@ function createToolMiddleware({
       };
     },
     wrapGenerate: async ({ doGenerate }) => {
-      var _a;
       const result = await doGenerate();
-      if (!((_a = result.text) == null ? void 0 : _a.includes(toolCallTag))) {
+      if (result.content.length !== 1) {
+        return result;
+      }
+      if (result.content[0].type === "text" && !result.content[0].text.includes(toolCallTag)) {
         return result;
       }
       const toolCallRegex = new RegExp(
         `${toolCallTag}(.*?)(?:${toolCallEndTag}|$)`,
         "gs"
       );
-      const matches = [...result.text.matchAll(toolCallRegex)];
+      const matches = result.content[0].type === "text" ? Array.from(result.content[0].text.matchAll(toolCallRegex)) : [];
       const function_call_tuples = matches.map((match) => match[1] || match[2]);
-      return {
-        ...result,
-        // TODO: Return the remaining value after extracting the tool call tag.
-        text: "",
-        toolCalls: function_call_tuples.map((toolCall) => {
-          const parsedToolCall = RJSON.parse(toolCall);
+      const tool_calls = function_call_tuples.map(
+        (toolCall) => {
+          const parsedToolCall = parse(toolCall);
           const toolName = parsedToolCall.name;
           const args = parsedToolCall.arguments;
           return {
+            type: "tool-call",
             toolCallType: "function",
-            toolCallId: (0, import_ai.generateId)(),
+            toolCallId: (0, import_provider_utils.generateId)(),
             toolName,
-            args: RJSON.stringify(args)
+            args: JSON.stringify(args)
           };
-        })
+        }
+      );
+      return {
+        ...result,
+        // TODO: Return the remaining value after extracting the tool call tag.
+        content: [...tool_calls]
       };
     },
     transformParams: async ({ params }) => {
@@ -232,9 +805,8 @@ function createToolMiddleware({
         }
         return message;
       });
-      const originalToolDefinitions = params.mode.type === "regular" && params.mode.tools ? params.mode.tools : {};
       const HermesPrompt = toolSystemPromptTemplate(
-        JSON.stringify(Object.entries(originalToolDefinitions))
+        JSON.stringify(Object.entries(params.tools || {}))
       );
       const toolSystemPrompt = processedPrompt[0].role === "system" ? [
         {
@@ -251,11 +823,10 @@ function createToolMiddleware({
       ];
       return {
         ...params,
-        mode: {
-          // set the mode back to regular and remove the default tools.
-          type: "regular"
-        },
-        prompt: toolSystemPrompt
+        prompt: toolSystemPrompt,
+        // set the mode back to regular and remove the default tools.
+        tools: [],
+        toolChoice: void 0
       };
     }
   };
@@ -265,23 +836,39 @@ function createToolMiddleware({
 var gemmaToolMiddleware = createToolMiddleware({
   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
-  \`\`\`tool_call
-  {'name': <function-name>, 'arguments': <args-dict>}
-  \`\`\`
-  You SHOULD NOT include any other text in the response if you call a function
-  ${tools}`;
+you MUST put it in the format of
+\`\`\`tool_call
+{'name': <function-name>, 'arguments': <args-dict>}
+\`\`\`
+You SHOULD NOT include any other text in the response if you call a function
+${tools}`;
   },
   toolCallTag: "```tool_call\n",
   toolCallEndTag: "```",
   toolResponseTag: "```tool_response\n",
   toolResponseEndTag: "\n```"
 });
-var hermesToolMiddleware = createToolMiddleware({});
+var hermesToolMiddleware = createToolMiddleware({
+  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>
+{'arguments': <args-dict>, 'name': <function-name>}
+</tool_call>`;
+  },
+  toolCallTag: "<tool_call>",
+  toolCallEndTag: "</tool_call>",
+  toolResponseTag: "<tool_response>",
+  toolResponseEndTag: "</tool_response>"
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createToolMiddleware,
-  defaultTemplate,
   gemmaToolMiddleware,
   hermesToolMiddleware
 });