@ai-sdk-tool/parser 2.0.16 → 2.1.1

package/dist/index.cjs

@@ -20,99 +20,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  coerceBySchema: () => coerceBySchema,
   createToolMiddleware: () => createToolMiddleware,
+  fixToolCallWithSchema: () => fixToolCallWithSchema,
   gemmaToolMiddleware: () => gemmaToolMiddleware,
-  hermesToolMiddleware: () => hermesToolMiddleware
+  getSchemaType: () => getSchemaType,
+  hermesToolMiddleware: () => hermesToolMiddleware,
+  jsonMixProtocol: () => jsonMixProtocol,
+  unwrapJsonSchema: () => unwrapJsonSchema,
+  xmlProtocol: () => xmlProtocol,
+  xmlToolMiddleware: () => xmlToolMiddleware
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/tool-call-middleware.ts
-var import_provider_utils2 = require("@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/stream-handler.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
 // src/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
@@ -522,7 +444,6 @@ function appendPair(state, obj, key, value) {
 }
 function parsePair(tokens, state, obj) {
   let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
-  let key;
   let value;
   if (token.type !== "string") {
     raiseUnexpected(state, token, "string key");
@@ -572,7 +493,7 @@ function parsePair(tokens, state, obj) {
     }
   }
   checkDuplicates(state, obj, token);
-  key = String(token.value);
+  const key = String(token.value);
   skipColon(tokens, state);
   value = parseAny(tokens, state);
   appendPair(state, obj, key, value);
@@ -743,7 +664,10 @@ function parse(text, optsOrReviver) {
   if (!options.relaxed && !options.warnings && !options.tolerant) {
     if (!options.duplicate) {
     } else {
-      return JSON.parse(text, options.reviver);
+      return JSON.parse(
+        text,
+        options.reviver
+      );
     }
   }
   const lexerToUse = options.relaxed ? lexer : strictLexer;
@@ -763,7 +687,7 @@ function parse(text, optsOrReviver) {
     };
     return parseAny(tokens, state, true);
   } else {
-    const newtext = tokens.reduce((str, token) => {
+    tokens.reduce((str, token) => {
       return str + token.match;
     }, "");
     if (!options.relaxed && !options.warnings && !options.tolerant && options.duplicate) {
@@ -787,8 +711,11 @@ function parse(text, optsOrReviver) {
     } else {
       tokens = lexer(text);
       tokens = stripTrailingComma(tokens);
-      const newtext2 = tokens.reduce((str, token) => str + token.match, "");
-      return JSON.parse(newtext2, options.reviver);
+      const newtext = tokens.reduce((str, token) => str + token.match, "");
+      return JSON.parse(
+        newtext,
+        options.reviver
+      );
     }
   }
 }
@@ -816,161 +743,321 @@ function stringify(obj) {
   return "null";
 }
 
-// src/stream-handler.ts
-var import_provider_utils = require("@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 functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  if (functionTools.length > 0) return functionTools;
+  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_b = params.providerOptions.toolCallMiddleware) == null ? void 0 : _b.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 [];
+}
+
+// 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 = (0, import_provider_utils.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 (providerOptions && typeof providerOptions === "object") {
+    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
+    return onError ? { onError } : void 0;
+  }
+  return void 0;
+}
+
+// src/utils/coercion.ts
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") return void 0;
+  const t = unwrapped.type;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) if (t.includes(p)) return p;
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  return void 0;
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      const s = value.trim();
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+      if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+        try {
+          const parsed = JSON.parse(s);
+          return coerceBySchema(parsed, void 0);
+        } catch (e) {
+        }
+      }
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "object") {
+      try {
+        let normalized = s.replace(/'/g, '"');
+        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
+        const obj = JSON.parse(normalized);
+        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+          const props = unwrapped.properties;
+          const out = {};
+          for (const [k, v] of Object.entries(obj)) {
+            const propSchema = props ? props[k] : void 0;
+            out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
           }
+          return out;
         }
-        if (currentTextId && hasEmittedTextStart) {
-          controller.enqueue({
-            type: "text-end",
-            id: currentTextId
-          });
-          currentTextId = null;
-          hasEmittedTextStart = false;
+      } catch (e) {
+      }
+    }
+    if (schemaType === "array") {
+      try {
+        const normalized = s.replace(/'/g, '"');
+        const arr = JSON.parse(normalized);
+        if (Array.isArray(arr)) {
+          const u = unwrapped;
+          const prefixItems = Array.isArray(
+            u.prefixItems
+          ) ? u.prefixItems : void 0;
+          const itemsSchema = u.items;
+          if (prefixItems && arr.length === prefixItems.length) {
+            return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+          }
+          return arr.map((v) => coerceBySchema(v, itemsSchema));
         }
-        if (toolCallBuffer.length > 0) {
-          toolCallBuffer.forEach((toolCall) => {
-            try {
-              const parsedToolCall = relaxed_json_exports.parse(toolCall);
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId: (0, import_provider_utils.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)();
-              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
-              });
-            }
-          });
+      } catch (e) {
+        const csv = s.includes("\n") ? s.split(/\n+/) : s.split(/,\s*/);
+        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+        const u = unwrapped;
+        const prefixItems = Array.isArray(
+          u.prefixItems
+        ) ? u.prefixItems : void 0;
+        const itemsSchema = u.items;
+        if (prefixItems && trimmed.length === prefixItems.length) {
+          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
         }
-        controller.enqueue(chunk);
-        return;
-      } else if (chunk.type !== "text-delta") {
-        controller.enqueue(chunk);
-        return;
+        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
       }
-      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 = (0, import_provider_utils.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;
-          }
+    }
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    const out = {};
+    const props = unwrapped.properties;
+    for (const [k, v] of Object.entries(value)) {
+      const propSchema = props ? props[k] : void 0;
+      out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+    }
+    return out;
+  }
+  if (schemaType === "array") {
+    const u = unwrapped;
+    const itemsSchema = u.items;
+    const prefixItems = Array.isArray(
+      u.prefixItems
+    ) ? u.prefixItems : void 0;
+    if (Array.isArray(value)) {
+      if (prefixItems && value.length === prefixItems.length) {
+        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return value.map((v) => coerceBySchema(v, itemsSchema));
+    }
+    if (value && typeof value === "object") {
+      const maybe = value;
+      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
+        const items = maybe.item;
+        const arr = Array.isArray(items) ? items : [items];
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
         }
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
       }
-      do {
-        const nextTag = isToolCall ? toolCallEndTag : toolCallTag;
-        const startIndex = getPotentialStartIndex(buffer, nextTag);
-        if (startIndex == null) {
-          publish(buffer);
-          buffer = "";
-          break;
+      const keys = Object.keys(maybe);
+      if (keys.length === 1) {
+        const singleKey = keys[0];
+        const singleValue = maybe[singleKey];
+        if (Array.isArray(singleValue)) {
+          const coercedArray = singleValue.map(
+            (v) => coerceBySchema(v, itemsSchema)
+          );
+          return coercedArray;
         }
-        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;
+      }
+      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
+        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
         }
-      } while (true);
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
+      }
     }
-  });
+    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      if (prefixItems && prefixItems.length > 0) {
+        return [coerceBySchema(value, prefixItems[0])];
+      }
+      return [coerceBySchema(value, itemsSchema)];
+    }
+  }
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "boolean") {
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+    }
+    if (schemaType === "number" || schemaType === "integer") {
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+    }
+  }
+  return value;
+}
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") return part;
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return {
+    ...part,
+    input: JSON.stringify(coerced != null ? coerced : {})
+  };
+}
+function coerceToolCallInput(part, tools) {
+  return fixToolCallWithSchema(part, tools);
+}
+
+// src/utils/protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
+// src/stream-handler.ts
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
   return {
-    stream: (_a = stream == null ? void 0 : stream.pipeThrough(transformStream)) != null ? _a : new ReadableStream(),
+    stream: stream.pipeThrough(
+      protocol.createStreamParser({
+        tools: getFunctionTools(params),
+        options: {
+          ...extractOnErrorOption(params.providerOptions),
+          ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+        }
+      })
+    ),
     ...rest
   };
 }
 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: (0, import_provider_utils.generateId)(),
@@ -1001,219 +1088,955 @@ async function toolChoiceStream({
   };
 }
 
-// src/tool-call-middleware.ts
-function isToolChoiceActive(params) {
+// src/generate-handler.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  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");
+  if (isToolChoiceActive(params)) {
+    const result2 = await doGenerate();
+    let parsed2 = {};
+    const first = (_a = result2.content) == null ? void 0 : _a[0];
+    if (first && first.type === "text") {
+      try {
+        parsed2 = 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)
+          }
+        );
+        parsed2 = {};
+      }
+    }
+    const toolCall = {
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: parsed2.name || "unknown",
+      input: JSON.stringify(parsed2.arguments || {})
+    };
+    return {
+      ...result2,
+      content: [toolCall]
+    };
+  }
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const parsed = result.content.flatMap((contentItem) => {
+    var _a2;
+    if (contentItem.type !== "text") {
+      return [contentItem];
+    }
+    return protocol.parseGeneratedText({
+      text: contentItem.text,
+      tools: getFunctionTools(params),
+      options: {
+        ...extractOnErrorOption(params.providerOptions),
+        ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
+      }
+    });
+  });
+  const tools = getFunctionTools(params);
+  const newContent = parsed.map(
+    (part) => coerceToolCallInput(part, tools)
+  );
+  return {
+    ...result,
+    content: newContent
+  };
 }
+
+// src/transform-handler.ts
+async function transformParams({
+  params,
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  const systemPrompt = resolvedProtocol.formatTools({
+    tools: functionTools,
+    toolSystemPromptTemplate
+  });
+  const processedPrompt = convertToolPrompt(
+    (_b = params.prompt) != null ? _b : [],
+    resolvedProtocol,
+    extractOnErrorOption(params.providerOptions)
+  );
+  const finalPrompt = ((_c = processedPrompt[0]) == null ? void 0 : _c.role) === "system" ? [
+    {
+      role: "system",
+      content: systemPrompt + "\n\n" + processedPrompt[0].content
+    },
+    ...processedPrompt.slice(1)
+  ] : [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...processedPrompt
+  ];
+  const baseReturnParams = {
+    ...params,
+    prompt: finalPrompt,
+    tools: [],
+    toolChoice: void 0,
+    providerOptions: {
+      ...params.providerOptions || {},
+      toolCallMiddleware: {
+        ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
+        toolNames: functionTools.map((t) => t.name)
+      }
+    }
+  };
+  if (((_d = params.toolChoice) == null ? void 0 : _d.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 (((_e = params.toolChoice) == null ? void 0 : _e.type) === "tool") {
+    const selectedToolName = params.toolChoice.toolName;
+    const providerDefinedMatch = ((_f = params.tools) != null ? _f : []).find((t) => {
+      if (t.type === "function") return false;
+      const anyTool = t;
+      return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
+    });
+    if (providerDefinedMatch) {
+      throw new Error(
+        "Provider-defined tools are not supported by this middleware. Please use custom tools."
+      );
+    }
+    const selectedTool = ((_g = params.tools) != null ? _g : []).find(
+      (t) => t.type === "function" && t.name === selectedToolName
+    );
+    if (!selectedTool) {
+      throw new Error(
+        `Tool with name '${selectedToolName}' not found in params.tools.`
+      );
+    }
+    return {
+      ...baseReturnParams,
+      responseFormat: {
+        type: "json",
+        schema: {
+          type: "object",
+          properties: {
+            name: {
+              const: selectedTool.name
+            },
+            arguments: selectedTool.inputSchema
+          },
+          required: ["name", "arguments"]
+        },
+        name: selectedTool.name,
+        description: 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 (((_h = params.toolChoice) == null ? void 0 : _h.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(functionTools)
+      },
+      providerOptions: {
+        ...baseReturnParams.providerOptions || {},
+        toolCallMiddleware: {
+          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+          toolChoice: { type: "required" }
+        }
+      }
+    };
+  }
+  return baseReturnParams;
+}
+function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+  const processedPrompt = prompt.map((message) => {
+    var _a;
+    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 {
+          const options = extractOnErrorOption(providerOptions);
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+            options,
+            "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+            { content }
+          );
+          newContent.push({
+            type: "text",
+            text: JSON.stringify(content)
+          });
+        }
+      }
+      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 (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 < processedPrompt.length; i++) {
+    const msg = processedPrompt[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) {
+        const joinedText = msg.content.map((c) => c.text).join("\n");
+        if (msg.role === "system") {
+          processedPrompt[i] = {
+            role: "system",
+            content: joinedText
+          };
+        } else if (msg.role === "assistant") {
+          processedPrompt[i] = {
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: joinedText
+              }
+            ]
+          };
+        } else {
+          processedPrompt[i] = {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: joinedText
+              }
+            ]
+          };
+        }
+      }
+    }
+  }
+  for (let i = processedPrompt.length - 1; i > 0; i--) {
+    const current = processedPrompt[i];
+    const prev = processedPrompt[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");
+      processedPrompt[i - 1] = {
+        role: "user",
+        content: [{ type: "text", text: prevContent + "\n" + currentContent }]
+      };
+      processedPrompt.splice(i, 1);
+    }
+  }
+  return processedPrompt;
+}
+
+// src/tool-call-middleware.ts
 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
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
         });
       } else {
-        return normalToolStream({
+        return wrapStream({
+          protocol: resolvedProtocol,
           doStream,
-          toolCallTag,
-          toolCallEndTag
+          doGenerate,
+          params
         });
       }
     },
-    wrapGenerate: async ({ doGenerate, params }) => {
-      const result = await doGenerate();
-      if (result.content.length === 0) {
-        return result;
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({
+      params
+    }) => {
+      return transformParams({
+        protocol: resolvedProtocol,
+        toolSystemPromptTemplate,
+        params
+      });
+    }
+  };
+}
+
+// src/protocols/json-mix-protocol.ts
+var import_provider_utils3 = require("@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 (isToolChoiceActive(params)) {
-        const toolJson = result.content[0].type === "text" ? JSON.parse(result.content[0].text) : {};
-        return {
-          ...result,
-          content: [
-            {
-              type: "tool-call",
-              toolCallType: "function",
-              toolCallId: (0, import_provider_utils2.generateId)(),
-              toolName: toolJson.name || "unknown",
-              input: JSON.stringify(toolJson.arguments || {})
+      if (toolCallJson) {
+        try {
+          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          processedElements.push({
+            type: "tool-call",
+            toolCallId: (0, import_provider_utils3.generateId)(),
+            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 = (0, import_provider_utils3.generateId)();
+              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 = (0, import_provider_utils3.generateId)();
+              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 = (0, import_provider_utils3.generateId)();
+            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 = (0, import_provider_utils3.generateId)();
+              controller.enqueue({ type: "text-start", id: currentTextId });
+              hasEmittedTextStart = true;
             }
-          ]
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: text
+            });
+          }
         };
-      }
-      const toolCallRegex = new RegExp(
-        `${toolCallTag}(.*?)(?:${toolCallEndTag}|$)`,
-        "gs"
-      );
-      const newContent = result.content.flatMap(
-        (contentItem) => {
-          if (contentItem.type !== "text" || !contentItem.text.includes(toolCallTag)) {
-            return [contentItem];
+        let startIndex;
+        while ((startIndex = getPotentialStartIndex(
+          buffer,
+          isInsideToolCall ? toolCallEnd : toolCallStart
+        )) != null) {
+          const tag = isInsideToolCall ? toolCallEnd : toolCallStart;
+          if (startIndex + tag.length > buffer.length) {
+            break;
           }
-          const text = contentItem.text;
-          const processedElements = [];
-          let currentIndex = 0;
-          let match;
-          const parseAndCreateToolCall = (toolCallJson) => {
+          publish(buffer.slice(0, startIndex));
+          buffer = buffer.slice(startIndex + tag.length);
+          if (!isInsideToolCall) {
+            currentToolCallJson = "";
+            isInsideToolCall = true;
+          } else {
             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;
+              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
+              if (currentTextId && hasEmittedTextStart) {
+                controller.enqueue({ type: "text-end", id: currentTextId });
+                currentTextId = null;
+                hasEmittedTextStart = false;
               }
-              return {
+              controller.enqueue({
                 type: "tool-call",
-                toolCallId: (0, import_provider_utils2.generateId)(),
+                toolCallId: (0, import_provider_utils3.generateId)(),
                 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 });
+                input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+              });
+            } catch (e) {
+              const errorId = (0, import_provider_utils3.generateId)();
+              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}`
+                  }
+                );
               }
             }
-            if (toolCallJson) {
-              const toolCallObject = parseAndCreateToolCall(toolCallJson);
-              if (toolCallObject) {
-                processedElements.push(toolCallObject);
+            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
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_fast_xml_parser = require("fast-xml-parser");
+var xmlProtocol = () => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    const toolsForPrompt = (tools || []).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: unwrapJsonSchema(tool.inputSchema)
+    }));
+    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  },
+  formatToolCall(toolCall) {
+    const builder = new import_fast_xml_parser.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 import_fast_xml_parser.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, _c;
+    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
+    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 import_fast_xml_parser.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"];
+          }
+          if (Array.isArray(v)) {
+            val = v.map((item) => {
+              if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                const textVal = item == null ? void 0 : item["#text"];
+                return typeof textVal === "string" ? textVal.trim() : textVal;
+              }
+              return typeof item === "string" ? item.trim() : item;
+            });
+          } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
+            const obj = v;
+            const keys = Object.keys(obj);
+            if (keys.length === 1 && keys[0] === "item") {
+              const itemValue = obj.item;
+              if (Array.isArray(itemValue)) {
+                val = itemValue.map((item) => {
+                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                    const textVal = item == null ? void 0 : item["#text"];
+                    const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
+                    if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
+                      const num = Number(trimmed2);
+                      if (Number.isFinite(num)) return num;
+                    }
+                    return trimmed2;
+                  }
+                  const trimmed = typeof item === "string" ? item.trim() : item;
+                  if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                    const num = Number(trimmed);
+                    if (Number.isFinite(num)) return num;
+                  }
+                  return trimmed;
+                });
               } else {
-                console.warn(
-                  `Could not process tool call, keeping original text: ${match[0]}`
+                const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+                if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                  const num = Number(trimmed);
+                  if (Number.isFinite(num)) {
+                    val = num;
+                  } else {
+                    val = trimmed;
+                  }
+                } else {
+                  val = trimmed;
+                }
+              }
+            } else {
+              const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
+                const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
+                return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+              })();
+              if (isIndexedTuple) {
+                const sortedKeys = keys.sort(
+                  (a, b) => parseInt(a) - parseInt(b)
                 );
-                processedElements.push({ type: "text", text: match[0] });
+                val = sortedKeys.map((key) => {
+                  const item = obj[key];
+                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                    const textVal = item == null ? void 0 : item["#text"];
+                    return typeof textVal === "string" ? textVal.trim() : textVal;
+                  }
+                  return typeof item === "string" ? item.trim() : item;
+                });
+              } else {
+                val = v;
               }
             }
-            currentIndex = endIndex;
-          }
-          if (currentIndex < text.length) {
-            const remainingText = text.substring(currentIndex);
-            if (remainingText.trim()) {
-              processedElements.push({ type: "text", text: remainingText });
-            }
           }
-          return processedElements;
+          args[k] = typeof val === "string" ? val.trim() : val;
         }
-      );
-      return {
-        ...result,
-        content: newContent
-      };
-    },
-    transformParams: async ({ params }) => {
-      var _a, _b, _c, _d;
-      const toolSystemPrompt = convertToolPrompt({
-        paramsPrompt: params.prompt,
-        paramsTools: params.tools,
-        toolSystemPromptTemplate,
-        toolCallTag,
-        toolCallEndTag,
-        toolResponseTag,
-        toolResponseEndTag
-      });
-      const baseReturnParams = {
-        ...params,
-        prompt: toolSystemPrompt,
-        // 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."
-        );
+        const originalSchema = originalSchemas[toolName];
+        const fallbackSchema = (_b = tools.find((t) => t.name === toolName)) == null ? void 0 : _b.inputSchema;
+        const schema = originalSchema || fallbackSchema;
+        const coercedArgs = coerceBySchema(args, schema);
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: (0, import_provider_utils4.generateId)(),
+          toolName,
+          input: JSON.stringify(coercedArgs)
+        });
+      } catch (error) {
+        const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
+        (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, message, { toolCall: match[0], toolName, error });
+        processedElements.push({ type: "text", text: match[0] });
       }
-      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.type === "function" ? tool.name === selectedToolName : tool.id === selectedToolName
-        );
-        if (!selectedTool) {
-          throw new Error(
-            `Tool with name '${selectedToolName}' not found in params.tools.`
-          );
+      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 originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
+    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 = (0, import_provider_utils4.generateId)();
+          controller.enqueue({ type: "text-start", id: currentTextId });
         }
-        if (selectedTool.type === "provider-defined") {
-          throw new Error(
-            "Provider-defined tools are not supported by this middleware. Please use custom tools."
-          );
+        controller.enqueue({
+          type: "text-delta",
+          id: currentTextId,
+          delta: content
+        });
+        if (text === void 0) {
+          buffer = "";
         }
-        return {
-          ...baseReturnParams,
-          responseFormat: {
-            type: "json",
-            schema: {
-              type: "object",
-              properties: {
-                name: {
-                  const: selectedTool.name
-                },
-                arguments: selectedTool.inputSchema
-              },
-              required: ["name", "arguments"]
-            },
-            name: selectedTool.name,
-            description: selectedTool.type === "function" && typeof selectedTool.description === "string" ? selectedTool.description : void 0
-          },
-          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."
-          );
+      if (currentTextId && !text) {
+        controller.enqueue({ type: "text-end", id: currentTextId });
+        currentTextId = null;
+      }
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a, _b;
+        if (chunk.type !== "text-delta") {
+          if (buffer) flushText(controller);
+          controller.enqueue(chunk);
+          return;
         }
-        return {
-          ...baseReturnParams,
-          responseFormat: {
-            type: "json",
-            schema: createDynamicIfThenElseSchema(params.tools)
-          },
-          providerOptions: {
-            toolCallMiddleware: {
-              toolChoice: { type: "required" }
+        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 import_fast_xml_parser.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"];
+                  }
+                  if (Array.isArray(v)) {
+                    val = v.map((item) => {
+                      if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                        const textVal = item == null ? void 0 : item["#text"];
+                        return typeof textVal === "string" ? textVal.trim() : textVal;
+                      }
+                      return typeof item === "string" ? item.trim() : item;
+                    });
+                  } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
+                    const obj = v;
+                    const keys = Object.keys(obj);
+                    if (keys.length === 1 && keys[0] === "item") {
+                      const itemValue = obj.item;
+                      if (Array.isArray(itemValue)) {
+                        val = itemValue.map((item) => {
+                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                            const textVal = item == null ? void 0 : item["#text"];
+                            const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
+                            if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
+                              const num = Number(trimmed2);
+                              if (Number.isFinite(num)) return num;
+                            }
+                            return trimmed2;
+                          }
+                          const trimmed = typeof item === "string" ? item.trim() : item;
+                          if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                            const num = Number(trimmed);
+                            if (Number.isFinite(num)) return num;
+                          }
+                          return trimmed;
+                        });
+                      } else {
+                        const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+                        if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                          const num = Number(trimmed);
+                          if (Number.isFinite(num)) {
+                            val = num;
+                          } else {
+                            val = trimmed;
+                          }
+                        } else {
+                          val = trimmed;
+                        }
+                      }
+                    } else {
+                      const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
+                        const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
+                        return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+                      })();
+                      if (isIndexedTuple) {
+                        const sortedKeys = keys.sort(
+                          (a, b) => parseInt(a) - parseInt(b)
+                        );
+                        val = sortedKeys.map((key) => {
+                          const item = obj[key];
+                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                            const textVal = item == null ? void 0 : item["#text"];
+                            return typeof textVal === "string" ? textVal.trim() : textVal;
+                          }
+                          return typeof item === "string" ? item.trim() : item;
+                        });
+                      } else {
+                        val = v;
+                      }
+                    }
+                  }
+                  args[k] = typeof val === "string" ? val.trim() : val;
+                }
+                const originalSchema = originalSchemas[currentToolCall.name];
+                const fallbackSchema = (_b = tools.find(
+                  (t) => t.name === currentToolCall.name
+                )) == null ? void 0 : _b.inputSchema;
+                const toolSchema = originalSchema || fallbackSchema;
+                const coercedArgs = coerceBySchema(args, toolSchema);
+                flushText(controller);
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: (0, import_provider_utils4.generateId)(),
+                  toolName: currentToolCall.name,
+                  input: JSON.stringify(coercedArgs)
+                });
+              } 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 });
+        }
       }
-      return baseReturnParams;
-    }
-  };
-}
+    });
+  }
+});
+
+// src/protocols/dummy-protocol.ts
+var import_provider_utils5 = require("@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.
@@ -1222,35 +2045,52 @@ 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 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 a function call, return exactly one XML element whose tag name matches the tool's name, and nothing else.
+When an argument is an array, write each item inside a single element on one line separated by commas (or provide a JSON-like list). When an argument is an object, provide a JSON-like value.
+Examples:
+<get_weather>
+<location>
+San Fransisco
+</location>
+</get_weather>`;
+  }
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  coerceBySchema,
   createToolMiddleware,
+  fixToolCallWithSchema,
   gemmaToolMiddleware,
-  hermesToolMiddleware
+  getSchemaType,
+  hermesToolMiddleware,
+  jsonMixProtocol,
+  unwrapJsonSchema,
+  xmlProtocol,
+  xmlToolMiddleware
 });
 //# sourceMappingURL=index.cjs.map