@ai-sdk-tool/parser 1.0.2 → 2.0.1

package/dist/index.mjs

@@ -1,10 +1,7 @@
 // src/tool-call-middleware.ts
-import {
-  generateId
-} from "ai";
-import * as RJSON from "relaxed-json";
+import { generateId } from "@ai-sdk/provider-utils";
 
-// src/utils.ts
+// src/utils/get-potential-start-index.ts
 function getPotentialStartIndex(text, searchedText) {
   if (searchedText.length === 0) {
     return null;
@@ -22,26 +19,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;
@@ -57,7 +634,7 @@ 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",
@@ -68,19 +645,19 @@ function createToolMiddleware({
                 } 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" : "";
@@ -91,8 +668,8 @@ function createToolMiddleware({
                 toolCallBuffer[toolCallIndex] += text;
               } else {
                 controller.enqueue({
-                  type: "text-delta",
-                  textDelta: prefix + text
+                  type: "text",
+                  text: prefix + text
                 });
               }
               afterSwitch = false;
@@ -131,32 +708,86 @@ 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 === 0) {
         return result;
       }
       const toolCallRegex = new RegExp(
         `${toolCallTag}(.*?)(?:${toolCallEndTag}|$)`,
         "gs"
       );
-      const matches = [...result.text.matchAll(toolCallRegex)];
-      const function_call_tuples = matches.map((match) => match[1] || match[2]);
+      const newContent = result.content.flatMap(
+        (contentItem) => {
+          if (contentItem.type !== "text" || !contentItem.text.includes(toolCallTag)) {
+            return [contentItem];
+          }
+          const text = contentItem.text;
+          const processedElements = [];
+          let currentIndex = 0;
+          let match;
+          const parseAndCreateToolCall = (toolCallJson) => {
+            try {
+              const parsedToolCall = parse(toolCallJson);
+              if (!parsedToolCall || typeof parsedToolCall.name !== "string" || typeof parsedToolCall.arguments === "undefined") {
+                console.error(
+                  "Failed to parse tool call: Invalid structure",
+                  toolCallJson
+                );
+                return null;
+              }
+              return {
+                type: "tool-call",
+                toolCallType: "function",
+                toolCallId: generateId(),
+                toolName: parsedToolCall.name,
+                // Ensure args is always a JSON string
+                args: typeof parsedToolCall.arguments === "string" ? parsedToolCall.arguments : JSON.stringify(parsedToolCall.arguments)
+              };
+            } catch (error) {
+              console.error(
+                "Failed to parse tool call JSON:",
+                error,
+                "JSON:",
+                toolCallJson
+              );
+              return null;
+            }
+          };
+          while ((match = toolCallRegex.exec(text)) !== null) {
+            const startIndex = match.index;
+            const endIndex = startIndex + match[0].length;
+            const toolCallJson = match[1];
+            if (startIndex > currentIndex) {
+              const textSegment = text.substring(currentIndex, startIndex);
+              if (textSegment.trim()) {
+                processedElements.push({ type: "text", text: textSegment });
+              }
+            }
+            if (toolCallJson) {
+              const toolCallObject = parseAndCreateToolCall(toolCallJson);
+              if (toolCallObject) {
+                processedElements.push(toolCallObject);
+              } else {
+                console.warn(
+                  `Could not process tool call, keeping original text: ${match[0]}`
+                );
+                processedElements.push({ type: "text", text: match[0] });
+              }
+            }
+            currentIndex = endIndex;
+          }
+          if (currentIndex < text.length) {
+            const remainingText = text.substring(currentIndex);
+            if (remainingText.trim()) {
+              processedElements.push({ type: "text", text: remainingText });
+            }
+          }
+          return processedElements;
+        }
+      );
       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 toolName = parsedToolCall.name;
-          const args = parsedToolCall.arguments;
-          return {
-            toolCallType: "function",
-            toolCallId: generateId(),
-            toolName,
-            args: RJSON.stringify(args)
-          };
-        })
+        content: newContent
       };
     },
     transformParams: async ({ params }) => {
@@ -195,9 +826,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" ? [
         {
@@ -214,11 +844,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
       };
     }
   };
@@ -228,22 +857,38 @@ 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>"
+});
 export {
   createToolMiddleware,
-  defaultTemplate,
   gemmaToolMiddleware,
   hermesToolMiddleware
 };