@ai-sdk-tool/parser 2.0.11 → 2.0.13

package/dist/index.js

@@ -1,33 +1,11 @@
-"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_utils2 = require("@ai-sdk/provider-utils");
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
 // src/utils/conv-tool-prompt.ts
 function convertToolPrompt({
@@ -356,15 +334,15 @@ function makeTokenSpecs(relaxed) {
     { re: /^(?:true|false|null)/, f: fKeyword },
     // Keywords
     // Number: optional sign, digits, optional decimal part, optional exponent
-    { re: /^\-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, f: fNumber },
+    { re: /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/, f: fNumber },
     // String: double-quoted, handles escapes
-    { re: /^"(?:[^"\\]|\\["bnrtf\\\/]|\\u[0-9a-fA-F]{4})*"/, f: fStringDouble }
+    { 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})*)'/,
+        re: /^'((?:[^'\\]|\\['bnrtf\\/]|\\u[0-9a-fA-F]{4})*)'/,
         f: fStringSingle
       },
       // Single-line comments (// ...)
@@ -373,7 +351,7 @@ function makeTokenSpecs(relaxed) {
       { re: /^\/\*[\s\S]*?\*\//, f: fComment },
       // Unquoted identifiers (treated as strings)
       // Allows letters, numbers, _, -, +, ., *, ?, !, |, &, %, ^, /, #, \
-      { re: /^[$a-zA-Z0-9_\-+\.\*\?!\|&%\^\/#\\]+/, f: fIdentifier }
+      { re: /^[$a-zA-Z0-9_\-+.*?!|&%^/#\\]+/, f: fIdentifier }
       // Note: The order matters here. Identifiers are checked after keywords/numbers.
     ]);
   }
@@ -636,7 +614,7 @@ function parseMany(tokens, state, result, opts) {
     switch (token.type) {
       case opts.endSymbol:
         return result;
-      case ",":
+      case ",": {
         const nextToken = tokens[state.pos];
         if (state.tolerant && nextToken && nextToken.type === opts.endSymbol) {
           raiseError(state, token, `Trailing comma before '${opts.endSymbol}'`);
@@ -645,6 +623,7 @@ function parseMany(tokens, state, result, opts) {
         }
         opts.elementParser(tokens, state, result);
         break;
+      }
       // Default case is only reachable in tolerant mode recovery above
       default:
         opts.elementParser(tokens, state, result);
@@ -713,6 +692,7 @@ function parseAny(tokens, state, end = false) {
   return ret;
 }
 function parse(text, optsOrReviver) {
+  var _a;
   let options = {};
   if (typeof optsOrReviver === "function") {
     options.reviver = optsOrReviver;
@@ -734,7 +714,7 @@ function parse(text, optsOrReviver) {
   }
   options.tolerant = options.tolerant || options.warnings || false;
   options.warnings = options.warnings || false;
-  options.duplicate = options.duplicate || false;
+  options.duplicate = (_a = options.duplicate) != null ? _a : false;
   if (!options.relaxed && !options.warnings && !options.tolerant) {
     if (!options.duplicate) {
     } else {
@@ -752,8 +732,8 @@ function parse(text, optsOrReviver) {
       pos: 0,
       reviver: options.reviver,
       tolerant: options.tolerant,
-      duplicate: !options.duplicate,
-      // Internal state: true means *check* for duplicates
+      duplicate: options.duplicate,
+      // true = allow duplicate keys, false = reject duplicates
       warnings: []
     };
     return parseAny(tokens, state, true);
@@ -774,8 +754,8 @@ function parse(text, optsOrReviver) {
         reviver: options.reviver,
         tolerant: options.tolerant || false,
         // Ensure boolean
-        duplicate: !options.duplicate,
-        // true = check duplicates
+        duplicate: options.duplicate,
+        // true = allow duplicate keys, false = reject duplicates
         warnings: []
       };
       return parseAny(tokens, state, true);
@@ -812,12 +792,13 @@ function stringify(obj) {
 }
 
 // src/stream-handler.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import { generateId } from "@ai-sdk/provider-utils";
 async function normalToolStream({
   doStream,
   toolCallTag,
   toolCallEndTag
 }) {
+  var _a;
   const { stream, ...rest } = await doStream();
   let isFirstToolCall = true;
   let isFirstText = true;
@@ -831,6 +812,25 @@ async function normalToolStream({
   const transformStream = new TransformStream({
     transform(chunk, controller) {
       if (chunk.type === "finish") {
+        if (isToolCall && (buffer.length > 0 || toolCallIndex >= 0 && toolCallBuffer[toolCallIndex])) {
+          if (!currentTextId) {
+            currentTextId = generateId();
+            controller.enqueue({
+              type: "text-start",
+              id: currentTextId
+            });
+            hasEmittedTextStart = true;
+          }
+          const incompleteContent = (toolCallBuffer[toolCallIndex] || "") + buffer;
+          controller.enqueue({
+            type: "text-delta",
+            id: currentTextId,
+            delta: toolCallTag + incompleteContent
+          });
+          if (toolCallIndex >= 0) {
+            toolCallBuffer = toolCallBuffer.slice(0, toolCallIndex);
+          }
+        }
         if (currentTextId && hasEmittedTextStart) {
           controller.enqueue({
             type: "text-end",
@@ -845,13 +845,13 @@ async function normalToolStream({
               const parsedToolCall = relaxed_json_exports.parse(toolCall);
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: (0, import_provider_utils.generateId)(),
+                toolCallId: generateId(),
                 toolName: parsedToolCall.name,
                 input: JSON.stringify(parsedToolCall.arguments)
               });
             } catch (e) {
               console.error(`Error parsing tool call: ${toolCall}`, e);
-              const errorId = (0, import_provider_utils.generateId)();
+              const errorId = generateId();
               controller.enqueue({
                 type: "text-start",
                 id: errorId
@@ -859,7 +859,7 @@ async function normalToolStream({
               controller.enqueue({
                 type: "text-delta",
                 id: errorId,
-                delta: `Failed to parse tool call: ${e}`
+                delta: `${toolCallTag}${toolCall}${toolCallEndTag}`
               });
               controller.enqueue({
                 type: "text-end",
@@ -876,7 +876,7 @@ async function normalToolStream({
       }
       buffer += chunk.delta;
       function publish(text) {
-        if (text.length > 0) {
+        if (text.length > 0 || isToolCall) {
           const prefix = afterSwitch && (isToolCall ? !isFirstToolCall : !isFirstText) ? "\n" : "";
           if (isToolCall) {
             if (currentTextId && hasEmittedTextStart) {
@@ -891,9 +891,9 @@ async function normalToolStream({
               toolCallBuffer[toolCallIndex] = "";
             }
             toolCallBuffer[toolCallIndex] += text;
-          } else {
+          } else if (text.length > 0) {
             if (!currentTextId) {
-              currentTextId = (0, import_provider_utils.generateId)();
+              currentTextId = generateId();
               controller.enqueue({
                 type: "text-start",
                 id: currentTextId
@@ -922,39 +922,44 @@ async function normalToolStream({
           buffer = "";
           break;
         }
-        publish(buffer.slice(0, startIndex));
         const foundFullMatch = startIndex + nextTag.length <= buffer.length;
         if (foundFullMatch) {
+          publish(buffer.slice(0, startIndex));
           buffer = buffer.slice(startIndex + nextTag.length);
           toolCallIndex++;
           isToolCall = !isToolCall;
           afterSwitch = true;
         } else {
-          buffer = buffer.slice(startIndex);
           break;
         }
       } while (true);
     }
   });
   return {
-    stream: stream.pipeThrough(transformStream),
+    stream: (_a = stream == null ? void 0 : stream.pipeThrough(transformStream)) != null ? _a : new ReadableStream(),
     ...rest
   };
 }
 async function toolChoiceStream({
   doGenerate
 }) {
+  var _a;
   const result = await doGenerate();
-  const toolJson = result.content[0].type === "text" ? JSON.parse(result.content[0].text) : {};
+  const toolJson = (result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text" ? JSON.parse(result.content[0].text) : {};
   const toolCallChunk = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils.generateId)(),
-    toolName: toolJson.name,
+    toolCallId: generateId(),
+    toolName: toolJson.name || "unknown",
     input: JSON.stringify(toolJson.arguments || {})
   };
   const finishChunk = {
     type: "finish",
-    usage: result.usage,
+    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    },
     finishReason: "tool-calls"
   };
   const stream = new ReadableStream({
@@ -965,8 +970,8 @@ async function toolChoiceStream({
     }
   });
   return {
-    request: result.request,
-    response: result.response,
+    request: (result == null ? void 0 : result.request) || {},
+    response: (result == null ? void 0 : result.response) || {},
     stream
   };
 }
@@ -1012,8 +1017,8 @@ function createToolMiddleware({
             {
               type: "tool-call",
               toolCallType: "function",
-              toolCallId: (0, import_provider_utils2.generateId)(),
-              toolName: toolJson.name,
+              toolCallId: generateId2(),
+              toolName: toolJson.name || "unknown",
               input: JSON.stringify(toolJson.arguments || {})
             }
           ]
@@ -1044,7 +1049,7 @@ function createToolMiddleware({
               }
               return {
                 type: "tool-call",
-                toolCallId: (0, import_provider_utils2.generateId)(),
+                toolCallId: generateId2(),
                 toolName: parsedToolCall.name,
                 // Ensure args is always a JSON string
                 input: typeof parsedToolCall.arguments === "string" ? parsedToolCall.arguments : JSON.stringify(parsedToolCall.arguments)
@@ -1122,7 +1127,7 @@ function createToolMiddleware({
       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
+          (tool) => tool.type === "function" ? tool.name === selectedToolName : tool.id === selectedToolName
         );
         if (!selectedTool) {
           throw new Error(
@@ -1186,7 +1191,7 @@ 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
+you MUST put it in the format of markdown code fence block with the language name of tool_call , e.g.
 \`\`\`tool_call
 {'name': <function-name>, 'arguments': <args-dict>}
 \`\`\`
@@ -1194,7 +1199,8 @@ You SHOULD NOT include any other text in the response if you call a function
 ${tools}`;
   },
   toolCallTag: "```tool_call\n",
-  toolCallEndTag: "```",
+  toolCallEndTag: "\n``",
+  // two backticks are more common in gemma output
   toolResponseTag: "```tool_response\n",
   toolResponseEndTag: "\n```"
 });
@@ -1216,10 +1222,9 @@ For each function call return a json object with function name and arguments wit
   toolResponseTag: "<tool_response>",
   toolResponseEndTag: "</tool_response>"
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   createToolMiddleware,
   gemmaToolMiddleware,
   hermesToolMiddleware
-});
+};
 //# sourceMappingURL=index.js.map