@ai-sdk-tool/parser 2.0.15 → 2.1.0

package/dist/index.js

@@ -7,91 +7,6 @@ var __export = (target, all) => {
 // src/tool-call-middleware.ts
 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.input,
-              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,
-                // TODO: If the tool result part contains content, modify to respect and include it.
-                result: content.output
-              })}${toolResponseEndTag}`
-            ).join("\n")
-          }
-        ]
-      };
-    }
-    return message;
-  });
-  const toolsForPrompt = (paramsTools || []).filter((tool) => tool.type === "function").map((tool) => ({
-    name: tool.name,
-    description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
-    parameters: tool.inputSchema
-  }));
-  const HermesPrompt = toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
-  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 = {};
@@ -794,161 +709,84 @@ function stringify(obj) {
   return "null";
 }
 
-// src/stream-handler.ts
-import { generateId } from "@ai-sdk/provider-utils";
-async function normalToolStream({
-  doStream,
-  toolCallTag,
-  toolCallEndTag
-}) {
+// src/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/type-guards.ts
+function isToolCallContent(content) {
+  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
+  (typeof content.input === "string" || typeof content.input === "object");
+}
+function isToolResultPart(content) {
+  const c = content;
+  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+}
+function hasInputProperty(obj) {
+  return typeof obj === "object" && obj !== null && "input" in obj;
+}
+
+// src/utils/tools.ts
+function isToolChoiceActive(params) {
+  var _a, _b, _c;
+  const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
+  return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
+}
+function getFunctionTools(params) {
+  var _a, _b;
+  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_a = params.providerOptions.toolCallMiddleware) == null ? void 0 : _a.toolNames) || [];
+  const toStringArray = (val) => Array.isArray(val) ? val.filter(
+    (item) => typeof item === "string"
+  ) : [];
+  const toolNames = toStringArray(rawToolNames);
+  if (toolNames.length > 0) {
+    return toolNames.map((name) => ({
+      type: "function",
+      name,
+      description: "",
+      inputSchema: { type: "object" }
+    }));
+  }
+  return ((_b = params.tools) != null ? _b : []).filter(
+    (t) => t.type === "function"
+  );
+}
+
+// src/utils/on-error.ts
+function extractOnErrorOption(providerOptions) {
   var _a;
-  const { stream, ...rest } = await doStream();
-  let isFirstToolCall = true;
-  let isFirstText = true;
-  let afterSwitch = false;
-  let isToolCall = false;
-  let buffer = "";
-  let toolCallIndex = -1;
-  let toolCallBuffer = [];
-  let currentTextId = null;
-  let hasEmittedTextStart = false;
-  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",
-            id: currentTextId
-          });
-          currentTextId = null;
-          hasEmittedTextStart = false;
-        }
-        if (toolCallBuffer.length > 0) {
-          toolCallBuffer.forEach((toolCall) => {
-            try {
-              const parsedToolCall = relaxed_json_exports.parse(toolCall);
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId: generateId(),
-                toolName: parsedToolCall.name,
-                input: JSON.stringify(parsedToolCall.arguments)
-              });
-            } catch (e) {
-              console.error(`Error parsing tool call: ${toolCall}`, e);
-              const errorId = generateId();
-              controller.enqueue({
-                type: "text-start",
-                id: errorId
-              });
-              controller.enqueue({
-                type: "text-delta",
-                id: errorId,
-                delta: `${toolCallTag}${toolCall}${toolCallEndTag}`
-              });
-              controller.enqueue({
-                type: "text-end",
-                id: errorId
-              });
-            }
-          });
-        }
-        controller.enqueue(chunk);
-        return;
-      } else if (chunk.type !== "text-delta") {
-        controller.enqueue(chunk);
-        return;
-      }
-      buffer += chunk.delta;
-      function publish(text) {
-        if (text.length > 0 || isToolCall) {
-          const prefix = afterSwitch && (isToolCall ? !isFirstToolCall : !isFirstText) ? "\n" : "";
-          if (isToolCall) {
-            if (currentTextId && hasEmittedTextStart) {
-              controller.enqueue({
-                type: "text-end",
-                id: currentTextId
-              });
-              currentTextId = null;
-              hasEmittedTextStart = false;
-            }
-            if (!toolCallBuffer[toolCallIndex]) {
-              toolCallBuffer[toolCallIndex] = "";
-            }
-            toolCallBuffer[toolCallIndex] += text;
-          } else if (text.length > 0) {
-            if (!currentTextId) {
-              currentTextId = generateId();
-              controller.enqueue({
-                type: "text-start",
-                id: currentTextId
-              });
-              hasEmittedTextStart = true;
-            }
-            controller.enqueue({
-              type: "text-delta",
-              id: currentTextId,
-              delta: 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;
-        }
-        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 {
-          break;
-        }
-      } while (true);
-    }
-  });
-  return {
-    stream: (_a = stream == null ? void 0 : stream.pipeThrough(transformStream)) != null ? _a : new ReadableStream(),
-    ...rest
-  };
+  if (providerOptions && typeof providerOptions === "object") {
+    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
+    return onError ? { onError } : void 0;
+  }
+  return void 0;
 }
+
+// src/stream-handler.ts
+import { generateId } from "@ai-sdk/provider-utils";
 async function toolChoiceStream({
-  doGenerate
+  doGenerate,
+  options
 }) {
-  var _a;
+  var _a, _b;
   const result = await doGenerate();
-  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) : {};
+  let toolJson = {};
+  if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
+    try {
+      toolJson = JSON.parse(result.content[0].text);
+    } catch (error) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        options,
+        "Failed to parse toolChoice JSON from streamed model output",
+        {
+          text: result.content[0].text,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      toolJson = {};
+    }
+  }
   const toolCallChunk = {
     type: "tool-call",
     toolCallId: generateId(),
@@ -980,156 +818,220 @@ async function toolChoiceStream({
 }
 
 // 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 isProtocolFactory(protocol) {
+  return typeof protocol === "function";
 }
 function createToolMiddleware({
-  toolCallTag,
-  toolCallEndTag,
-  toolResponseTag,
-  toolResponseEndTag,
+  protocol,
   toolSystemPromptTemplate
 }) {
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
   return {
     middlewareVersion: "v2",
     wrapStream: async ({ doStream, doGenerate, params }) => {
       if (isToolChoiceActive(params)) {
         return toolChoiceStream({
-          doGenerate
-        });
-      } else {
-        return normalToolStream({
-          doStream,
-          toolCallTag,
-          toolCallEndTag
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
         });
       }
+      const { stream, ...rest } = await doStream();
+      return {
+        stream: stream.pipeThrough(
+          resolvedProtocol.createStreamParser({
+            tools: getFunctionTools(params),
+            options: extractOnErrorOption(params.providerOptions)
+          })
+        ),
+        ...rest
+      };
     },
     wrapGenerate: async ({ doGenerate, params }) => {
-      const result = await doGenerate();
-      if (result.content.length === 0) {
-        return result;
-      }
+      var _a, _b;
       if (isToolChoiceActive(params)) {
-        const toolJson = result.content[0].type === "text" ? JSON.parse(result.content[0].text) : {};
+        const result2 = await doGenerate();
+        let parsed = {};
+        const first = (_a = result2.content) == null ? void 0 : _a[0];
+        if (first && first.type === "text") {
+          try {
+            parsed = JSON.parse(first.text);
+          } catch (error) {
+            const options = extractOnErrorOption(params.providerOptions);
+            (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+              options,
+              "Failed to parse toolChoice JSON from generated model output",
+              {
+                text: first.text,
+                error: error instanceof Error ? error.message : String(error)
+              }
+            );
+            parsed = {};
+          }
+        }
         return {
-          ...result,
+          ...result2,
           content: [
             {
               type: "tool-call",
-              toolCallType: "function",
               toolCallId: generateId2(),
-              toolName: toolJson.name || "unknown",
-              input: JSON.stringify(toolJson.arguments || {})
+              toolName: parsed.name || "unknown",
+              input: JSON.stringify(parsed.arguments || {})
             }
           ]
         };
       }
-      const toolCallRegex = new RegExp(
-        `${toolCallTag}(.*?)(?:${toolCallEndTag}|$)`,
-        "gs"
-      );
-      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 = relaxed_json_exports.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",
-                toolCallId: generateId2(),
-                toolName: parsedToolCall.name,
-                // Ensure args is always a JSON string
-                input: 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);
+      const result = await doGenerate();
+      if (result.content.length === 0) {
+        return result;
+      }
+      const newContent = result.content.flatMap((contentItem) => {
+        if (contentItem.type !== "text") {
+          return [contentItem];
+        }
+        return resolvedProtocol.parseGeneratedText({
+          text: contentItem.text,
+          tools: getFunctionTools(params),
+          options: extractOnErrorOption(params.providerOptions)
+        });
+      });
+      return {
+        ...result,
+        content: newContent
+      };
+    },
+    transformParams: async ({ params }) => {
+      var _a, _b, _c, _d, _e, _f;
+      const convertToolPrompt = (prompt) => {
+        const processedPrompt2 = prompt.map((message) => {
+          var _a2;
+          if (message.role === "assistant") {
+            const newContent = [];
+            for (const content of message.content) {
+              if (isToolCallContent(content)) {
+                newContent.push({
+                  type: "text",
+                  text: resolvedProtocol.formatToolCall(content)
+                });
+              } else if (content.type === "text") {
+                newContent.push(content);
+              } else if (content.type === "reasoning") {
+                newContent.push(content);
               } else {
-                console.warn(
-                  `Could not process tool call, keeping original text: ${match[0]}`
+                const options = extractOnErrorOption(params.providerOptions);
+                (_a2 = options == null ? void 0 : options.onError) == null ? void 0 : _a2.call(
+                  options,
+                  "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+                  { content }
                 );
-                processedElements.push({ type: "text", text: match[0] });
+                newContent.push({
+                  type: "text",
+                  text: JSON.stringify(content)
+                });
               }
             }
-            currentIndex = endIndex;
+            const onlyText = newContent.every((c) => c.type === "text");
+            const condensedAssistant = onlyText ? [
+              {
+                type: "text",
+                text: newContent.map((c) => c.text).join("\n")
+              }
+            ] : newContent;
+            return { role: "assistant", content: condensedAssistant };
           }
-          if (currentIndex < text.length) {
-            const remainingText = text.substring(currentIndex);
-            if (remainingText.trim()) {
-              processedElements.push({ type: "text", text: remainingText });
+          if (message.role === "tool") {
+            return {
+              role: "user",
+              // Map tool results to text response blocks, then condense into a single text block
+              content: [
+                {
+                  type: "text",
+                  text: message.content.map(
+                    (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
+                      toolResult
+                    )
+                  ).join("\n")
+                }
+              ]
+            };
+          }
+          return message;
+        });
+        for (let i = 0; i < processedPrompt2.length; i++) {
+          const msg = processedPrompt2[i];
+          if (Array.isArray(msg.content)) {
+            const allText = msg.content.every((c) => (c == null ? void 0 : c.type) === "text");
+            if (allText && msg.content.length > 1) {
+              processedPrompt2[i] = {
+                role: msg.role,
+                content: [
+                  {
+                    type: "text",
+                    text: msg.content.map((c) => c.text).join("\n")
+                  }
+                ]
+              };
             }
           }
-          return processedElements;
         }
-      );
-      return {
-        ...result,
-        content: newContent
+        for (let i = processedPrompt2.length - 1; i > 0; i--) {
+          const current = processedPrompt2[i];
+          const prev = processedPrompt2[i - 1];
+          if (current.role === "user" && prev.role === "user") {
+            const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+            const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+            processedPrompt2[i - 1] = {
+              role: "user",
+              content: [
+                { type: "text", text: prevContent + "\n" + currentContent }
+              ]
+            };
+            processedPrompt2.splice(i, 1);
+          }
+        }
+        return processedPrompt2;
       };
-    },
-    transformParams: async ({ params }) => {
-      var _a, _b, _c, _d;
-      const toolSystemPrompt = convertToolPrompt({
-        paramsPrompt: params.prompt,
-        paramsTools: params.tools,
-        toolSystemPromptTemplate,
-        toolCallTag,
-        toolCallEndTag,
-        toolResponseTag,
-        toolResponseEndTag
+      const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+        (t) => t.type === "function"
+      );
+      const systemPrompt = resolvedProtocol.formatTools({
+        tools: functionTools,
+        toolSystemPromptTemplate
       });
+      const processedPrompt = convertToolPrompt(params.prompt);
+      const finalPrompt = ((_b = processedPrompt[0]) == null ? void 0 : _b.role) === "system" ? [
+        {
+          role: "system",
+          content: systemPrompt + "\n\n" + processedPrompt[0].content
+        },
+        ...processedPrompt.slice(1)
+      ] : [
+        {
+          role: "system",
+          content: systemPrompt
+        },
+        ...processedPrompt
+      ];
       const baseReturnParams = {
         ...params,
-        prompt: toolSystemPrompt,
-        // Reset tools and toolChoice to default after prompt transformation
+        prompt: finalPrompt,
         tools: [],
-        toolChoice: void 0
+        toolChoice: void 0,
+        providerOptions: {
+          ...params.providerOptions || {},
+          toolCallMiddleware: {
+            ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
+            toolNames: functionTools.map((t) => t.name)
+          }
+        }
       };
-      if (((_a = params.toolChoice) == null ? void 0 : _a.type) === "none") {
+      if (((_c = params.toolChoice) == null ? void 0 : _c.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") {
+      if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "tool") {
         const selectedToolName = params.toolChoice.toolName;
-        const selectedTool = (_c = params.tools) == null ? void 0 : _c.find(
+        const selectedTool = (_e = params.tools) == null ? void 0 : _e.find(
           (tool) => tool.type === "function" ? tool.name === selectedToolName : tool.id === selectedToolName
         );
         if (!selectedTool) {
@@ -1160,13 +1062,15 @@ function createToolMiddleware({
             description: selectedTool.type === "function" && typeof selectedTool.description === "string" ? selectedTool.description : void 0
           },
           providerOptions: {
+            ...baseReturnParams.providerOptions || {},
             toolCallMiddleware: {
+              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
               toolChoice: params.toolChoice
             }
           }
         };
       }
-      if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "required") {
+      if (((_f = params.toolChoice) == null ? void 0 : _f.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."
@@ -1176,10 +1080,14 @@ function createToolMiddleware({
           ...baseReturnParams,
           responseFormat: {
             type: "json",
-            schema: createDynamicIfThenElseSchema(params.tools)
+            schema: createDynamicIfThenElseSchema(
+              params.tools.filter((t) => t.type === "function")
+            )
           },
           providerOptions: {
+            ...baseReturnParams.providerOptions || {},
             toolCallMiddleware: {
+              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
               toolChoice: { type: "required" }
             }
           }
@@ -1190,8 +1098,476 @@ function createToolMiddleware({
   };
 }
 
+// src/protocols/json-mix-protocol.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
+var jsonMixProtocol = ({
+  toolCallStart = "<tool_call>",
+  toolCallEnd = "</tool_call>",
+  toolResponseStart = "<tool_response>",
+  toolResponseEnd = "</tool_response>"
+} = {}) => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
+      name: tool.name,
+      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
+      parameters: tool.inputSchema
+    }));
+    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    try {
+      args = JSON.parse(toolCall.input);
+    } catch (e) {
+      args = toolCall.input;
+    }
+    return `${toolCallStart}${JSON.stringify({
+      name: toolCall.toolName,
+      arguments: args
+    })}${toolCallEnd}`;
+  },
+  formatToolResponse(toolResult) {
+    return `${toolResponseStart}${JSON.stringify({
+      toolName: toolResult.toolName,
+      result: toolResult.output
+    })}${toolResponseEnd}`;
+  },
+  parseGeneratedText({ text, options }) {
+    var _a;
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const toolCallRegex = new RegExp(
+      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
+      "gs"
+    );
+    const processedElements = [];
+    let currentIndex = 0;
+    let match;
+    while ((match = toolCallRegex.exec(text)) !== null) {
+      const startIndex = match.index;
+      const toolCallJson = match[1];
+      if (startIndex > currentIndex) {
+        const textSegment = text.substring(currentIndex, startIndex);
+        if (textSegment.trim()) {
+          processedElements.push({ type: "text", text: textSegment });
+        }
+      }
+      if (toolCallJson) {
+        try {
+          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          processedElements.push({
+            type: "tool-call",
+            toolCallId: generateId3(),
+            toolName: parsedToolCall.name,
+            input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+          });
+        } catch (error) {
+          if (options == null ? void 0 : options.onError) {
+            options.onError(
+              "Could not process JSON tool call, keeping original text.",
+              { toolCall: match[0], error }
+            );
+          }
+          processedElements.push({ type: "text", text: match[0] });
+        }
+      }
+      currentIndex = startIndex + match[0].length;
+    }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools: _tools, options } = { tools: [] }) {
+    let isInsideToolCall = false;
+    let buffer = "";
+    let currentToolCallJson = "";
+    let currentTextId = null;
+    let hasEmittedTextStart = false;
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
+        if (chunk.type === "finish") {
+          if (isInsideToolCall && buffer.length > 0) {
+            if (!currentTextId) {
+              currentTextId = generateId3();
+              controller.enqueue({ type: "text-start", id: currentTextId });
+              hasEmittedTextStart = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: `${toolCallStart}${buffer}`
+            });
+            buffer = "";
+          } else if (!isInsideToolCall && buffer.length > 0) {
+            if (!currentTextId) {
+              currentTextId = generateId3();
+              controller.enqueue({ type: "text-start", id: currentTextId });
+              hasEmittedTextStart = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: buffer
+            });
+            buffer = "";
+          }
+          if (currentTextId && hasEmittedTextStart) {
+            controller.enqueue({ type: "text-end", id: currentTextId });
+            currentTextId = null;
+            hasEmittedTextStart = false;
+          }
+          if (currentToolCallJson) {
+            const errorId = generateId3();
+            controller.enqueue({ type: "text-start", id: errorId });
+            controller.enqueue({
+              type: "text-delta",
+              id: errorId,
+              delta: `${toolCallStart}${currentToolCallJson}`
+            });
+            controller.enqueue({ type: "text-end", id: errorId });
+            currentToolCallJson = "";
+          }
+          controller.enqueue(chunk);
+          return;
+        }
+        if (chunk.type !== "text-delta") {
+          controller.enqueue(chunk);
+          return;
+        }
+        buffer += chunk.delta;
+        const publish = (text) => {
+          if (isInsideToolCall) {
+            if (currentTextId && hasEmittedTextStart) {
+              controller.enqueue({ type: "text-end", id: currentTextId });
+              currentTextId = null;
+              hasEmittedTextStart = false;
+            }
+            currentToolCallJson += text;
+          } else if (text.length > 0) {
+            if (!currentTextId) {
+              currentTextId = generateId3();
+              controller.enqueue({ type: "text-start", id: currentTextId });
+              hasEmittedTextStart = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: text
+            });
+          }
+        };
+        let startIndex;
+        while ((startIndex = getPotentialStartIndex(
+          buffer,
+          isInsideToolCall ? toolCallEnd : toolCallStart
+        )) != null) {
+          const tag = isInsideToolCall ? toolCallEnd : toolCallStart;
+          if (startIndex + tag.length > buffer.length) {
+            break;
+          }
+          publish(buffer.slice(0, startIndex));
+          buffer = buffer.slice(startIndex + tag.length);
+          if (!isInsideToolCall) {
+            currentToolCallJson = "";
+            isInsideToolCall = true;
+          } else {
+            try {
+              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
+              if (currentTextId && hasEmittedTextStart) {
+                controller.enqueue({ type: "text-end", id: currentTextId });
+                currentTextId = null;
+                hasEmittedTextStart = false;
+              }
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: generateId3(),
+                toolName: parsedToolCall.name,
+                input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+              });
+            } catch (e) {
+              const errorId = generateId3();
+              controller.enqueue({ type: "text-start", id: errorId });
+              controller.enqueue({
+                type: "text-delta",
+                id: errorId,
+                delta: `${toolCallStart}${currentToolCallJson}${toolCallEnd}`
+              });
+              controller.enqueue({ type: "text-end", id: errorId });
+              if (options == null ? void 0 : options.onError) {
+                options.onError(
+                  "Could not process streaming JSON tool call; emitting original text.",
+                  {
+                    toolCall: `${toolCallStart}${currentToolCallJson}${toolCallEnd}`
+                  }
+                );
+              }
+            }
+            currentToolCallJson = "";
+            isInsideToolCall = false;
+          }
+        }
+        if (!isInsideToolCall) {
+          const potentialIndex = getPotentialStartIndex(buffer, toolCallStart);
+          if (potentialIndex != null && potentialIndex + toolCallStart.length > buffer.length) {
+            publish(buffer.slice(0, potentialIndex));
+            buffer = buffer.slice(potentialIndex);
+          } else {
+            publish(buffer);
+            buffer = "";
+          }
+        }
+      }
+    });
+  }
+});
+
+// src/protocols/xml-protocol.ts
+import { generateId as generateId4 } from "@ai-sdk/provider-utils";
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+var xmlProtocol = () => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    const toolsForPrompt = (tools || []).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  },
+  formatToolCall(toolCall) {
+    const builder = new XMLBuilder({ format: true, suppressEmptyNode: true });
+    let args = {};
+    const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
+    if (typeof inputValue === "string") {
+      try {
+        args = JSON.parse(inputValue);
+      } catch (e) {
+        args = inputValue;
+      }
+    } else {
+      args = inputValue;
+    }
+    const xmlContent = builder.build({
+      [toolCall.toolName]: args
+    });
+    return xmlContent;
+  },
+  formatToolResponse(toolResult) {
+    const builder = new XMLBuilder({ format: true });
+    const xmlContent = builder.build({
+      tool_response: {
+        tool_name: toolResult.toolName,
+        result: toolResult.output
+      }
+    });
+    return xmlContent;
+  },
+  parseGeneratedText({ text, tools, options }) {
+    var _a, _b;
+    const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+    if (toolNames.length === 0) {
+      return [{ type: "text", text }];
+    }
+    const toolNamesPattern = toolNames.map((n) => escapeRegExp(n)).join("|");
+    const toolCallRegex = new RegExp(
+      String.raw`<(${toolNamesPattern})>([\s\S]*?)<\/\1>`,
+      "g"
+    );
+    const processedElements = [];
+    let currentIndex = 0;
+    let match;
+    while ((match = toolCallRegex.exec(text)) !== null) {
+      const startIndex = match.index;
+      const toolName = match[1];
+      const toolContent = match[2].trim();
+      if (startIndex > currentIndex) {
+        const textSegment = text.substring(currentIndex, startIndex);
+        if (textSegment.trim()) {
+          processedElements.push({ type: "text", text: textSegment });
+        }
+      }
+      try {
+        const parser = new XMLParser({
+          ignoreAttributes: false,
+          parseTagValue: false,
+          ignoreDeclaration: true,
+          textNodeName: "#text"
+        });
+        const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
+        const args = {};
+        for (const k of Object.keys(parsedArgs || {})) {
+          const v = parsedArgs[k];
+          let val = v;
+          if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
+            val = v == null ? void 0 : v["#text"];
+          }
+          args[k] = typeof val === "string" ? val.trim() : val;
+        }
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: generateId4(),
+          toolName,
+          input: JSON.stringify(args)
+        });
+      } catch (error) {
+        const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
+        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, message, { toolCall: match[0], toolName, error });
+        processedElements.push({ type: "text", text: match[0] });
+      }
+      currentIndex = startIndex + match[0].length;
+    }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools, options }) {
+    const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+    let buffer = "";
+    let currentToolCall = null;
+    let currentTextId = null;
+    const flushText = (controller, text) => {
+      const content = text != null ? text : buffer;
+      if (content) {
+        if (!currentTextId) {
+          currentTextId = generateId4();
+          controller.enqueue({ type: "text-start", id: currentTextId });
+        }
+        controller.enqueue({
+          type: "text-delta",
+          id: currentTextId,
+          delta: content
+        });
+        if (text === void 0) {
+          buffer = "";
+        }
+      }
+      if (currentTextId && !text) {
+        controller.enqueue({ type: "text-end", id: currentTextId });
+        currentTextId = null;
+      }
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
+        if (chunk.type !== "text-delta") {
+          if (buffer) flushText(controller);
+          controller.enqueue(chunk);
+          return;
+        }
+        buffer += chunk.delta;
+        while (true) {
+          if (currentToolCall) {
+            const endTag = `</${currentToolCall.name}>`;
+            const endTagIndex = buffer.indexOf(endTag);
+            if (endTagIndex !== -1) {
+              const toolContent = buffer.substring(0, endTagIndex);
+              buffer = buffer.substring(endTagIndex + endTag.length);
+              try {
+                const parser = new XMLParser({
+                  ignoreAttributes: false,
+                  parseTagValue: false,
+                  ignoreDeclaration: true,
+                  textNodeName: "#text"
+                });
+                const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
+                const args = {};
+                for (const k of Object.keys(parsedArgs || {})) {
+                  const v = parsedArgs[k];
+                  let val = v;
+                  if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
+                    val = v == null ? void 0 : v["#text"];
+                  }
+                  args[k] = typeof val === "string" ? val.trim() : val;
+                }
+                flushText(controller);
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: generateId4(),
+                  toolName: currentToolCall.name,
+                  input: JSON.stringify(args)
+                });
+              } catch (e) {
+                const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
+                if (options == null ? void 0 : options.onError) {
+                  options.onError(
+                    "Could not process streaming XML tool call; emitting original text.",
+                    {
+                      toolCall: originalCallText,
+                      toolName: currentToolCall.name
+                    }
+                  );
+                }
+                flushText(controller, originalCallText);
+              }
+              currentToolCall = null;
+            } else {
+              break;
+            }
+          } else {
+            let earliestStartTagIndex = -1;
+            let earliestToolName = "";
+            if (toolNames.length > 0) {
+              for (const name of toolNames) {
+                const startTag = `<${name}>`;
+                const index = buffer.indexOf(startTag);
+                if (index !== -1 && (earliestStartTagIndex === -1 || index < earliestStartTagIndex)) {
+                  earliestStartTagIndex = index;
+                  earliestToolName = name;
+                }
+              }
+            }
+            if (earliestStartTagIndex !== -1) {
+              const textBeforeTag = buffer.substring(0, earliestStartTagIndex);
+              flushText(controller, textBeforeTag);
+              const startTag = `<${earliestToolName}>`;
+              buffer = buffer.substring(
+                earliestStartTagIndex + startTag.length
+              );
+              currentToolCall = { name: earliestToolName, content: "" };
+            } else {
+              break;
+            }
+          }
+        }
+      },
+      flush(controller) {
+        if (currentToolCall) {
+          const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
+          flushText(controller, unfinishedCall);
+        } else if (buffer) {
+          flushText(controller);
+        }
+        if (currentTextId) {
+          controller.enqueue({ type: "text-end", id: currentTextId });
+        }
+      }
+    });
+  }
+});
+
+// src/protocols/dummy-protocol.ts
+import { generateId as generateId5 } from "@ai-sdk/provider-utils";
+
 // src/index.ts
 var gemmaToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol(
+    // Customize the tool call delimiters to use markdown code fences
+    {
+      toolCallStart: "```tool_call\n",
+      toolCallEnd: "\n``",
+      // two backticks are more common in gemma output @
+      toolResponseStart: "```tool_response\n",
+      toolResponseEnd: "\n```"
+    }
+  ),
   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 markdown code fence block with the language name of tool_call , e.g.
@@ -1200,34 +1576,46 @@ you MUST put it in the format of markdown code fence block with the language nam
 \`\`\`
 You SHOULD NOT include any other text in the response if you call a function
 ${tools}`;
-  },
-  toolCallTag: "```tool_call\n",
-  toolCallEndTag: "\n``",
-  // two backticks are more common in gemma output
-  toolResponseTag: "```tool_response\n",
-  toolResponseEndTag: "\n```"
+  }
 });
 var hermesToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol,
   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']}
+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>}
+{"name": "<function-name>", "arguments": <args-dict>}
 </tool_call>`;
-  },
-  toolCallTag: "<tool_call>",
-  toolCallEndTag: "</tool_call>",
-  toolResponseTag: "<tool_response>",
-  toolResponseEndTag: "</tool_response>"
+  }
+});
+var xmlToolMiddleware = createToolMiddleware({
+  protocol: xmlProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You are KorinAI, 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>
+For each function call return a tool call in an XML tag that matches the tool's name, and nothing else.
+Example KorinAI-style call (text form):
+<get_weather>
+<location>
+San Fransisco
+</location>
+</get_weather>`;
+  }
 });
 export {
   createToolMiddleware,
   gemmaToolMiddleware,
-  hermesToolMiddleware
+  hermesToolMiddleware,
+  jsonMixProtocol,
+  xmlProtocol,
+  xmlToolMiddleware
 };
 //# sourceMappingURL=index.js.map