@ai-sdk-tool/parser 2.0.4 → 2.0.6

package/dist/index.mjs

@@ -1,5 +1,149 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/tool-call-middleware.ts
-import { generateId } from "@ai-sdk/provider-utils";
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+
+// src/utils/conv-tool-prompt.ts
+function convertToolPrompt({
+  paramsPrompt,
+  paramsTools,
+  toolSystemPromptTemplate,
+  toolCallTag,
+  toolCallEndTag,
+  toolResponseTag,
+  toolResponseEndTag
+}) {
+  const processedPrompt = paramsPrompt.map((message) => {
+    if (message.role === "assistant") {
+      const mergedContents = [];
+      for (const content of message.content) {
+        if (content.type === "tool-call") {
+          mergedContents.push({
+            type: "text",
+            text: `${toolCallTag}${JSON.stringify({
+              arguments: content.args,
+              name: content.toolName
+            })}${toolCallEndTag}`
+          });
+        } else {
+          mergedContents.push(content);
+        }
+      }
+      const finalContents = [];
+      for (const item of mergedContents) {
+        if (finalContents.length > 0 && item.type === "text" && finalContents[finalContents.length - 1].type === "text") {
+          const last = finalContents[finalContents.length - 1];
+          if (last.type === "text" && item.type === "text") {
+            finalContents[finalContents.length - 1] = {
+              type: "text",
+              text: last.text + "\n" + item.text
+            };
+          }
+        } else {
+          finalContents.push(item);
+        }
+      }
+      return {
+        role: "assistant",
+        content: finalContents
+      };
+    } 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(paramsTools || {}))
+  );
+  const toolSystemPrompt = processedPrompt[0].role === "system" ? [
+    {
+      role: "system",
+      content: HermesPrompt + "\n\n" + processedPrompt[0].content
+    },
+    ...processedPrompt.slice(1)
+  ] : [
+    {
+      role: "system",
+      content: HermesPrompt
+    },
+    ...processedPrompt
+  ];
+  return toolSystemPrompt;
+}
+
+// src/utils/dynamic-tool-schema.ts
+function createDynamicIfThenElseSchema(tools) {
+  let currentSchema = {};
+  const toolNames = [];
+  for (let i = tools.length - 1; i >= 0; i--) {
+    const tool = tools[i];
+    if (tool.type === "provider-defined") {
+      throw new Error(
+        "Provider-defined tools are not supported by this middleware. Please use custom tools."
+      );
+    }
+    toolNames.unshift(tool.name);
+    const toolCondition = {
+      if: {
+        properties: {
+          name: {
+            const: tool.name
+          }
+        },
+        required: ["name"]
+      },
+      then: {
+        properties: {
+          name: {
+            const: tool.name
+          },
+          // Cast tool.parameters to JSONSchema7 here.
+          arguments: tool.parameters
+        },
+        required: ["name", "arguments"]
+      }
+    };
+    if (Object.keys(currentSchema).length > 0) {
+      toolCondition.else = currentSchema;
+    }
+    currentSchema = toolCondition;
+  }
+  return {
+    type: "object",
+    // Explicitly specify type as "object"
+    properties: {
+      name: {
+        type: "string",
+        description: "Name of the tool to call",
+        enum: toolNames
+      },
+      arguments: {
+        type: "object",
+        // By default, arguments is also specified as object type
+        description: "Argument object to be passed to the tool"
+      }
+    },
+    required: ["name", "arguments"],
+    ...currentSchema
+  };
+}
 
 // src/utils/get-potential-start-index.ts
 function getPotentialStartIndex(text, searchedText) {
@@ -20,6 +164,12 @@ function getPotentialStartIndex(text, searchedText) {
 }
 
 // src/utils/relaxed-json.ts
+var relaxed_json_exports = {};
+__export(relaxed_json_exports, {
+  parse: () => parse,
+  stringify: () => stringify,
+  transform: () => transform
+});
 function some(array, f) {
   let acc = false;
   for (let i = 0; i < array.length; i++) {
@@ -241,6 +391,13 @@ function stripTrailingComma(tokens) {
   });
   return res;
 }
+function transform(text) {
+  let tokens = lexer(text);
+  tokens = stripTrailingComma(tokens);
+  return tokens.reduce((str, token) => {
+    return str + token.match;
+  }, "");
+}
 function popToken(tokens, state) {
   const token = tokens[state.pos];
   state.pos += 1;
@@ -608,8 +765,161 @@ function parse(text, optsOrReviver) {
     }
   }
 }
+function stringifyPair(obj, key) {
+  return JSON.stringify(key) + ":" + stringify(obj[key]);
+}
+function stringify(obj) {
+  const type = typeof obj;
+  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
+    return JSON.stringify(obj);
+  }
+  if (type === "undefined") {
+    return "null";
+  }
+  if (Array.isArray(obj)) {
+    const elements = obj.map(stringify).join(",");
+    return "[" + elements + "]";
+  }
+  if (type === "object") {
+    const keys = Object.keys(obj);
+    keys.sort();
+    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
+    return "{" + pairs + "}";
+  }
+  return "null";
+}
+
+// src/stream-handler.ts
+import { generateId } from "@ai-sdk/provider-utils";
+async function normalToolStream({
+  doStream,
+  toolCallTag,
+  toolCallEndTag
+}) {
+  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 = relaxed_json_exports.parse(toolCall);
+              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",
+                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
+  };
+}
+async function toolChoiceStream({
+  doGenerate
+}) {
+  const result = await doGenerate();
+  const toolJson = result.content[0].type === "text" ? JSON.parse(result.content[0].text) : {};
+  const toolCallChunk = {
+    type: "tool-call",
+    toolCallType: "function",
+    toolCallId: generateId(),
+    toolName: toolJson.name,
+    args: JSON.stringify(toolJson.arguments || {})
+  };
+  const finishChunk = {
+    type: "finish",
+    usage: result.usage,
+    finishReason: "tool-calls"
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(toolCallChunk);
+      controller.enqueue(finishChunk);
+      controller.close();
+    }
+  });
+  return {
+    request: result.request,
+    response: result.response,
+    stream
+  };
+}
 
 // src/tool-call-middleware.ts
+function isToolChoiceActive(params) {
+  var _a, _b;
+  const toolChoice = (_b = (_a = params == null ? void 0 : params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
+  return typeof params.providerOptions === "object" && params.providerOptions !== null && typeof params.providerOptions.toolCallMiddleware === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required");
+}
 function createToolMiddleware({
   toolCallTag,
   toolCallEndTag,
@@ -619,99 +929,39 @@ function createToolMiddleware({
 }) {
   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: 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
-      };
+    wrapStream: async ({ doStream, doGenerate, params }) => {
+      if (isToolChoiceActive(params)) {
+        return toolChoiceStream({
+          doGenerate
+        });
+      } else {
+        return normalToolStream({
+          doStream,
+          toolCallTag,
+          toolCallEndTag
+        });
+      }
     },
-    wrapGenerate: async ({ doGenerate }) => {
+    wrapGenerate: async ({ doGenerate, params }) => {
       const result = await doGenerate();
       if (result.content.length === 0) {
         return result;
       }
+      if (isToolChoiceActive(params)) {
+        const toolJson = result.content[0].type === "text" ? JSON.parse(result.content[0].text) : {};
+        return {
+          ...result,
+          content: [
+            {
+              type: "tool-call",
+              toolCallType: "function",
+              toolCallId: generateId2(),
+              toolName: toolJson.name,
+              args: JSON.stringify(toolJson.arguments || {})
+            }
+          ]
+        };
+      }
       const toolCallRegex = new RegExp(
         `${toolCallTag}(.*?)(?:${toolCallEndTag}|$)`,
         "gs"
@@ -727,7 +977,7 @@ function createToolMiddleware({
           let match;
           const parseAndCreateToolCall = (toolCallJson) => {
             try {
-              const parsedToolCall = parse(toolCallJson);
+              const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
               if (!parsedToolCall || typeof parsedToolCall.name !== "string" || typeof parsedToolCall.arguments === "undefined") {
                 console.error(
                   "Failed to parse tool call: Invalid structure",
@@ -738,7 +988,7 @@ function createToolMiddleware({
               return {
                 type: "tool-call",
                 toolCallType: "function",
-                toolCallId: generateId(),
+                toolCallId: generateId2(),
                 toolName: parsedToolCall.name,
                 // Ensure args is always a JSON string
                 args: typeof parsedToolCall.arguments === "string" ? parsedToolCall.arguments : JSON.stringify(parsedToolCall.arguments)
@@ -791,64 +1041,87 @@ function createToolMiddleware({
       };
     },
     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;
+      var _a, _b, _c, _d;
+      const toolSystemPrompt = convertToolPrompt({
+        paramsPrompt: params.prompt,
+        paramsTools: params.tools,
+        toolSystemPromptTemplate,
+        toolCallTag,
+        toolCallEndTag,
+        toolResponseTag,
+        toolResponseEndTag
       });
-      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 {
+      const baseReturnParams = {
         ...params,
         prompt: toolSystemPrompt,
-        // set the mode back to regular and remove the default tools.
+        // Reset tools and toolChoice to default after prompt transformation
         tools: [],
         toolChoice: void 0
       };
+      if (((_a = params.toolChoice) == null ? void 0 : _a.type) === "none") {
+        throw new Error(
+          "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
+        );
+      }
+      if (((_b = params.toolChoice) == null ? void 0 : _b.type) === "tool") {
+        const selectedToolName = params.toolChoice.toolName;
+        const selectedTool = (_c = params.tools) == null ? void 0 : _c.find(
+          (tool) => tool.name === selectedToolName
+        );
+        if (!selectedTool) {
+          throw new Error(
+            `Tool with name '${selectedToolName}' not found in params.tools.`
+          );
+        }
+        if (selectedTool.type === "provider-defined") {
+          throw new Error(
+            "Provider-defined tools are not supported by this middleware. Please use custom tools."
+          );
+        }
+        return {
+          ...baseReturnParams,
+          responseFormat: {
+            type: "json",
+            schema: {
+              type: "object",
+              properties: {
+                name: {
+                  const: selectedTool.name
+                },
+                arguments: selectedTool.parameters
+              },
+              required: ["name", "arguments"]
+            },
+            name: selectedTool.name,
+            description: selectedTool.description
+          },
+          providerOptions: {
+            toolCallMiddleware: {
+              toolChoice: params.toolChoice
+            }
+          }
+        };
+      }
+      if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "required") {
+        if (!params.tools || params.tools.length === 0) {
+          throw new Error(
+            "Tool choice type 'required' is set, but no tools are provided in params.tools."
+          );
+        }
+        return {
+          ...baseReturnParams,
+          responseFormat: {
+            type: "json",
+            schema: createDynamicIfThenElseSchema(params.tools)
+          },
+          providerOptions: {
+            toolCallMiddleware: {
+              toolChoice: { type: "required" }
+            }
+          }
+        };
+      }
+      return baseReturnParams;
     }
   };
 }