@ai-sdk-tool/parser 1.0.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,875 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createToolMiddleware: () => createToolMiddleware,
+  gemmaToolMiddleware: () => gemmaToolMiddleware,
+  hermesToolMiddleware: () => hermesToolMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tool-call-middleware.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+
+// 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/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
+function createToolMiddleware({
+  toolCallTag,
+  toolCallEndTag,
+  toolResponseTag,
+  toolResponseEndTag,
+  toolSystemPromptTemplate
+}) {
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream }) => {
+      const { stream, ...rest } = await doStream();
+      let isFirstToolCall = true;
+      let isFirstText = true;
+      let afterSwitch = false;
+      let isToolCall = false;
+      let buffer = "";
+      let toolCallIndex = -1;
+      let toolCallBuffer = [];
+      const transformStream = new TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === "finish") {
+            if (toolCallBuffer.length > 0) {
+              toolCallBuffer.forEach((toolCall) => {
+                try {
+                  const parsedToolCall = parse(toolCall);
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallType: "function",
+                    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",
+                    text: `Failed to parse tool call: ${e}`
+                  });
+                }
+              });
+            }
+            controller.enqueue(chunk);
+            return;
+          } else if (chunk.type !== "text") {
+            controller.enqueue(chunk);
+            return;
+          }
+          buffer += chunk.text;
+          function publish(text) {
+            if (text.length > 0) {
+              const prefix = afterSwitch && (isToolCall ? !isFirstToolCall : !isFirstText) ? "\n" : "";
+              if (isToolCall) {
+                if (!toolCallBuffer[toolCallIndex]) {
+                  toolCallBuffer[toolCallIndex] = "";
+                }
+                toolCallBuffer[toolCallIndex] += text;
+              } else {
+                controller.enqueue({
+                  type: "text",
+                  text: prefix + text
+                });
+              }
+              afterSwitch = false;
+              if (isToolCall) {
+                isFirstToolCall = false;
+              } else {
+                isFirstText = false;
+              }
+            }
+          }
+          do {
+            const nextTag = isToolCall ? toolCallEndTag : toolCallTag;
+            const startIndex = getPotentialStartIndex(buffer, nextTag);
+            if (startIndex == null) {
+              publish(buffer);
+              buffer = "";
+              break;
+            }
+            publish(buffer.slice(0, startIndex));
+            const foundFullMatch = startIndex + nextTag.length <= buffer.length;
+            if (foundFullMatch) {
+              buffer = buffer.slice(startIndex + nextTag.length);
+              toolCallIndex++;
+              isToolCall = !isToolCall;
+              afterSwitch = true;
+            } else {
+              buffer = buffer.slice(startIndex);
+              break;
+            }
+          } while (true);
+        }
+      });
+      return {
+        stream: stream.pipeThrough(transformStream),
+        ...rest
+      };
+    },
+    wrapGenerate: async ({ doGenerate }) => {
+      const result = await doGenerate();
+      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.content[0].type === "text" ? Array.from(result.content[0].text.matchAll(toolCallRegex)) : [];
+      const function_call_tuples = matches.map((match) => match[1] || match[2]);
+      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_provider_utils.generateId)(),
+            toolName,
+            args: JSON.stringify(args)
+          };
+        }
+      );
+      return {
+        ...result,
+        // TODO: Return the remaining value after extracting the tool call tag.
+        content: [...tool_calls]
+      };
+    },
+    transformParams: async ({ params }) => {
+      const processedPrompt = params.prompt.map((message) => {
+        if (message.role === "assistant") {
+          return {
+            role: "assistant",
+            content: message.content.map((content) => {
+              if (content.type === "tool-call") {
+                return {
+                  type: "text",
+                  text: `${toolCallTag}${JSON.stringify({
+                    arguments: content.args,
+                    name: content.toolName
+                  })}${toolCallEndTag}`
+                };
+              }
+              return content;
+            })
+          };
+        } else if (message.role === "tool") {
+          return {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: message.content.map(
+                  (content) => `${toolResponseTag}${JSON.stringify({
+                    toolName: content.toolName,
+                    result: content.result
+                  })}${toolResponseEndTag}`
+                ).join("\n")
+              }
+            ]
+          };
+        }
+        return message;
+      });
+      const HermesPrompt = toolSystemPromptTemplate(
+        JSON.stringify(Object.entries(params.tools || {}))
+      );
+      const toolSystemPrompt = processedPrompt[0].role === "system" ? [
+        {
+          role: "system",
+          content: HermesPrompt + "\n\n" + processedPrompt[0].content
+        },
+        ...processedPrompt.slice(1)
+      ] : [
+        {
+          role: "system",
+          content: HermesPrompt
+        },
+        ...processedPrompt
+      ];
+      return {
+        ...params,
+        prompt: toolSystemPrompt,
+        // set the mode back to regular and remove the default tools.
+        tools: [],
+        toolChoice: void 0
+      };
+    }
+  };
+}
+
+// src/index.ts
+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}`;
+  },
+  toolCallTag: "```tool_call\n",
+  toolCallEndTag: "```",
+  toolResponseTag: "```tool_response\n",
+  toolResponseEndTag: "\n```"
+});
+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,
+  gemmaToolMiddleware,
+  hermesToolMiddleware
+});
+//# sourceMappingURL=index.js.map