@ai-sdk-tool/parser 1.0.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ai-sdk-tool/parser",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@9.14.4+sha1.64b6e81e79630419b675c555ef3b65607cfd6315",
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^0.2.9",
+    "ai": "^4.3.4",
+    "relaxed-json": "^1.0.3",
+    "tsx": "^4.19.3",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0"
+  }
+}

package/src/hermes-middleware.ts

@@ -0,0 +1,270 @@
+import {
+  generateId,
+  LanguageModelV1Middleware,
+  LanguageModelV1Prompt,
+  LanguageModelV1StreamPart,
+} from "ai";
+import * as RJSON from "relaxed-json";
+import { getPotentialStartIndex } from "./utils";
+
+const defaultTemplate = (tools: string) =>
+  `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>`;
+
+export function hermesToolMiddleware({
+  toolCallTag = "<tool_call>",
+  toolCallEndTag = "</tool_call>",
+  toolResponseTag = "<tool_response>",
+  toolResponseEndTag = "</tool_response>",
+  toolSystemPromptTemplate = defaultTemplate,
+}: {
+  toolCallTag?: string;
+  toolCallEndTag?: string;
+  toolResponseTag?: string;
+  toolResponseEndTag?: string;
+  toolSystemPromptTemplate?: (tools: string) => string;
+}): LanguageModelV1Middleware {
+  return {
+    middlewareVersion: "v1",
+    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: string[] = [];
+
+      const transformStream = new TransformStream<
+        LanguageModelV1StreamPart,
+        LanguageModelV1StreamPart
+      >({
+        transform(chunk, controller) {
+          if (chunk.type === "finish") {
+            if (toolCallBuffer.length > 0) {
+              toolCallBuffer.forEach((toolCall) => {
+                try {
+                  const parsedToolCall = RJSON.parse(toolCall) as {
+                    name: string;
+                    arguments: string;
+                  };
+
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallType: "function",
+                    toolCallId: 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.message}`,
+                  });
+                }
+              });
+            }
+
+            // stop token
+            controller.enqueue(chunk);
+
+            return;
+          } else if (chunk.type !== "text-delta") {
+            controller.enqueue(chunk);
+            return;
+          }
+
+          buffer += chunk.textDelta;
+
+          function publish(text: string) {
+            if (text.length > 0) {
+              const prefix =
+                afterSwitch && (isToolCall ? !isFirstToolCall : !isFirstText)
+                  ? "\n" // separator
+                  : "";
+
+              if (isToolCall) {
+                if (!toolCallBuffer[toolCallIndex]) {
+                  toolCallBuffer[toolCallIndex] = "";
+                }
+
+                toolCallBuffer[toolCallIndex] += text;
+              } else {
+                controller.enqueue({
+                  type: "text-delta",
+                  textDelta: prefix + text,
+                });
+              }
+
+              afterSwitch = false;
+
+              if (isToolCall) {
+                isFirstToolCall = false;
+              } else {
+                isFirstText = false;
+              }
+            }
+          }
+
+          do {
+            const nextTag = isToolCall ? toolCallEndTag : toolCallTag;
+            const startIndex = getPotentialStartIndex(buffer, nextTag);
+
+            // no opening or closing tag found, publish the buffer
+            if (startIndex == null) {
+              publish(buffer);
+              buffer = "";
+              break;
+            }
+
+            // publish text before the tag
+            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.text?.includes(toolCallTag)) {
+        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]);
+
+      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) as {
+            name: string;
+            arguments: string;
+          };
+
+          const toolName = parsedToolCall.name;
+          const args = parsedToolCall.arguments;
+
+          return {
+            toolCallType: "function",
+            toolCallId: generateId(),
+            toolName: toolName,
+            args: RJSON.stringify(args),
+          };
+        }),
+      };
+    },
+
+    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;
+      }) as LanguageModelV1Prompt;
+
+      // Appropriate fixes are needed as they are disappearing in LanguageModelV2
+      const originalToolDefinitions =
+        params.mode.type === "regular" && params.mode.tools
+          ? params.mode.tools
+          : {};
+
+      const HermesPrompt = toolSystemPromptTemplate(
+        JSON.stringify(Object.entries(originalToolDefinitions))
+      );
+
+      const toolSystemPrompt: LanguageModelV1Prompt =
+        processedPrompt[0].role === "system"
+          ? [
+              {
+                role: "system",
+                content: HermesPrompt + "\n\n" + processedPrompt[0].content,
+              },
+              ...processedPrompt.slice(1),
+            ]
+          : [
+              {
+                role: "system",
+                content: HermesPrompt,
+              },
+              ...processedPrompt,
+            ];
+
+      return {
+        ...params,
+        mode: {
+          // set the mode back to regular and remove the default tools.
+          type: "regular",
+        },
+        prompt: toolSystemPrompt,
+      };
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,83 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText, streamText, wrapLanguageModel } from "ai";
+import { z } from "zod";
+import { hermesToolMiddleware } from "./hermes-middleware";
+
+const openrouter = createOpenAICompatible({
+  name: "openrouter",
+  apiKey: process.env.OPENROUTER_API_KEY,
+  baseURL: "https://openrouter.ai/api/v1",
+});
+
+async function main() {
+  const result = streamText({
+    // model: openrouter("openai/gpt-4o"),
+    model: wrapLanguageModel({
+      model: openrouter("google/gemma-3-27b-it"),
+      // model: openrouter("nousresearch/hermes-3-llama-3.1-70b"),
+      middleware: hermesToolMiddleware({
+        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```",
+      }),
+    }),
+    system: "You are a helpful assistant.",
+    // prompt: "What is the weather in New York and Los Angeles?",
+    prompt: "What is the weather in my city?",
+    maxSteps: 4,
+    tools: {
+      get_location: {
+        description: "Get the User's location.",
+        parameters: z.object({}),
+        execute: async () => {
+          // Simulate a location API call
+          return {
+            city: "New York",
+            country: "USA",
+          };
+        },
+      },
+      get_weather: {
+        description:
+          "Get the weather for a given city. " +
+          "Example cities: 'New York', 'Los Angeles', 'Paris'.",
+        parameters: z.object({ city: z.string() }),
+        execute: async ({ city }) => {
+          // Simulate a weather API call
+          const temperature = Math.floor(Math.random() * 100);
+          return {
+            city,
+            temperature,
+            condition: "sunny",
+          };
+        },
+      },
+    },
+  });
+
+  for await (const part of result.fullStream) {
+    if (part.type === "text-delta") {
+      process.stdout.write(part.textDelta);
+    } else if (part.type === "tool-result") {
+      console.log({
+        name: part.toolName,
+        args: part.args,
+        result: part.result,
+      });
+    }
+  }
+
+  console.log("\n\n[done]");
+}
+
+main().catch(console.error);

package/src/utils.ts

@@ -0,0 +1,31 @@
+/**
+ * Returns the index of the start of the searchedText in the text, or null if it
+ * is not found.
+ * ref: https://github.com/vercel/ai/blob/452bf12f0be9cb398d4af85a006bca13c8ce36d8/packages/ai/core/util/get-potential-start-index.ts
+ */
+export function getPotentialStartIndex(
+  text: string,
+  searchedText: string
+): number | null {
+  // Return null immediately if searchedText is empty.
+  if (searchedText.length === 0) {
+    return null;
+  }
+
+  // Check if the searchedText exists as a direct substring of text.
+  const directIndex = text.indexOf(searchedText);
+  if (directIndex !== -1) {
+    return directIndex;
+  }
+
+  // Otherwise, look for the largest suffix of "text" that matches
+  // a prefix of "searchedText". We go from the end of text inward.
+  for (let i = text.length - 1; i >= 0; i--) {
+    const suffix = text.substring(i);
+    if (searchedText.startsWith(suffix)) {
+      return i;
+    }
+  }
+
+  return null;
+}