@ai-sdk-tool/parser 2.1.1 → 2.1.2

package/dist/index.cjs

@@ -20,22 +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,
-  getSchemaType: () => getSchemaType,
   hermesToolMiddleware: () => hermesToolMiddleware,
   jsonMixProtocol: () => jsonMixProtocol,
-  unwrapJsonSchema: () => unwrapJsonSchema,
-  xmlProtocol: () => xmlProtocol,
+  morphXmlProtocol: () => morphXmlProtocol,
   xmlToolMiddleware: () => xmlToolMiddleware
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/stream-handler.ts
+// src/protocols/dummy-protocol.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
 
+// src/protocols/json-mix-protocol.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+
 // src/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
   let currentSchema = {};
@@ -110,6 +109,11 @@ function getPotentialStartIndex(text, searchedText) {
   return null;
 }
 
+// src/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/utils/relaxed-json.ts
 var relaxed_json_exports = {};
 __export(relaxed_json_exports, {
@@ -743,62 +747,6 @@ function stringify(obj) {
   return "null";
 }
 
-// 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;
-  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;
@@ -1003,506 +951,218 @@ function coerceToolCallInput(part, tools) {
   return fixToolCallWithSchema(part, tools);
 }
 
-// src/utils/protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/utils/debug.ts
+function normalizeBooleanString(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no") {
+    return false;
+  }
+  return void 0;
 }
-
-// src/stream-handler.ts
-async function wrapStream({
-  protocol,
-  doStream,
-  doGenerate,
-  params
-}) {
-  var _a;
-  if (isToolChoiceActive(params)) {
-    return toolChoiceStream({
-      doGenerate,
-      options: extractOnErrorOption(params.providerOptions)
-    });
+function getDebugLevel() {
+  const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW || "off";
+  const envLower = String(envVal).toLowerCase();
+  if (envLower === "stream" || envLower === "parse" || envLower === "off") {
+    return envLower;
   }
-  const { stream, ...rest } = await doStream();
-  return {
-    stream: stream.pipeThrough(
-      protocol.createStreamParser({
-        tools: getFunctionTools(params),
-        options: {
-          ...extractOnErrorOption(params.providerOptions),
-          ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
-        }
-      })
-    ),
-    ...rest
-  };
+  const boolEnv = normalizeBooleanString(envLower);
+  if (boolEnv === true) return "stream";
+  if (envLower === "2") return "parse";
+  return "off";
 }
-async function toolChoiceStream({
-  doGenerate,
-  options
-}) {
-  var _a, _b;
-  const result = await doGenerate();
-  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 = {};
-    }
+function color(code) {
+  return (text) => `\x1B[${code}m${text}\x1B[0m`;
+}
+var cGray = color(90);
+var cYellow = color(33);
+var cCyan = color(36);
+var cBgBlue = color(44);
+var cBgGreen = color(42);
+var cInverse = color(7);
+var cUnderline = color(4);
+var cBold = color(1);
+function safeStringify(value) {
+  try {
+    return `
+${typeof value === "string" ? value : JSON.stringify(value, null, 2)}`;
+  } catch (e) {
+    return String(value);
   }
-  const toolCallChunk = {
-    type: "tool-call",
-    toolCallId: (0, import_provider_utils.generateId)(),
-    toolName: toolJson.name || "unknown",
-    input: JSON.stringify(toolJson.arguments || {})
-  };
-  const finishChunk = {
-    type: "finish",
-    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
-    {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0
-    },
-    finishReason: "tool-calls"
-  };
-  const stream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(toolCallChunk);
-      controller.enqueue(finishChunk);
-      controller.close();
-    }
-  });
-  return {
-    request: (result == null ? void 0 : result.request) || {},
-    response: (result == null ? void 0 : result.response) || {},
-    stream
-  };
 }
-
-// src/generate-handler.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-async function wrapGenerate({
-  protocol,
-  doGenerate,
-  params
+function logRawChunk(part) {
+  console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
+}
+function logParsedChunk(part) {
+  console.log(cGray("[debug:mw:out]"), cCyan(safeStringify(part)));
+}
+function logParsedSummary({
+  toolCalls,
+  originalText
 }) {
-  var _a, _b;
-  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]
-    };
+  if (originalText) {
+    const style = (() => {
+      const envVal = typeof process !== "undefined" && process.env && process.env.DEBUG_PARSER_MW_STYLE || "bg";
+      const normalized = String(envVal).trim().toLowerCase();
+      if (normalized === "inverse" || normalized === "invert")
+        return "inverse";
+      if (normalized === "underline" || normalized === "ul")
+        return "underline";
+      if (normalized === "bold") return "bold";
+      if (normalized === "bg" || normalized === "background")
+        return "bg";
+      const asBool = normalizeBooleanString(normalized);
+      if (asBool === true) return "bg";
+      return "bg";
+    })();
+    const highlight = style === "inverse" ? cInverse : style === "underline" ? cUnderline : style === "bold" ? cBold : style === "bg" ? cBgGreen : cYellow;
+    const rendered = style === "bg" || style === "inverse" || style === "underline" || style === "bold" ? originalText.split(/\r?\n/).map((line) => line.length ? highlight(line) : line).join("\n") : highlight(originalText);
+    console.log(cGray("[debug:mw:origin]"), `
+${rendered}`);
   }
-  const result = await doGenerate();
-  if (result.content.length === 0) {
-    return result;
+  if (toolCalls.length > 0) {
+    const styledSummary = safeStringify(toolCalls).split(/\r?\n/).map((line) => line.length ? cBgBlue(line) : line).join("\n");
+    console.log(cGray("[debug:mw:summary]"), styledSummary);
   }
-  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;
+// src/utils/on-error.ts
+function extractOnErrorOption(providerOptions) {
+  var _a;
+  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/protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
+// 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"
   );
-  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 (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" }
+    }));
   }
-  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."
-      );
+  return [];
+}
+
+// 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/protocols/json-mix-protocol.ts
+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;
     }
-    const selectedTool = ((_g = params.tools) != null ? _g : []).find(
-      (t) => t.type === "function" && t.name === selectedToolName
+    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"
     );
-    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" }
+    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 });
         }
       }
-    };
-  }
-  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)
+      if (toolCallJson) {
+        try {
+          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          processedElements.push({
+            type: "tool-call",
+            toolCallId: (0, import_provider_utils2.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] });
         }
       }
-      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 };
+      currentIndex = startIndex + match[0].length;
     }
-    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({
-  protocol,
-  toolSystemPromptTemplate
-}) {
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
-  return {
-    middlewareVersion: "v2",
-    wrapStream: async ({ doStream, doGenerate, params }) => {
-      if (isToolChoiceActive(params)) {
-        return toolChoiceStream({
-          doGenerate,
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      } else {
-        return wrapStream({
-          protocol: resolvedProtocol,
-          doStream,
-          doGenerate,
-          params
-        });
-      }
-    },
-    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 (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 });
-      }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
     }
     return processedElements;
   },
@@ -1518,7 +1178,7 @@ var jsonMixProtocol = ({
         if (chunk.type === "finish") {
           if (isInsideToolCall && buffer.length > 0) {
             if (!currentTextId) {
-              currentTextId = (0, import_provider_utils3.generateId)();
+              currentTextId = (0, import_provider_utils2.generateId)();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1530,7 +1190,7 @@ var jsonMixProtocol = ({
             buffer = "";
           } else if (!isInsideToolCall && buffer.length > 0) {
             if (!currentTextId) {
-              currentTextId = (0, import_provider_utils3.generateId)();
+              currentTextId = (0, import_provider_utils2.generateId)();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1547,7 +1207,7 @@ var jsonMixProtocol = ({
             hasEmittedTextStart = false;
           }
           if (currentToolCallJson) {
-            const errorId = (0, import_provider_utils3.generateId)();
+            const errorId = (0, import_provider_utils2.generateId)();
             controller.enqueue({ type: "text-start", id: errorId });
             controller.enqueue({
               type: "text-delta",
@@ -1575,7 +1235,7 @@ var jsonMixProtocol = ({
             currentToolCallJson += text;
           } else if (text.length > 0) {
             if (!currentTextId) {
-              currentTextId = (0, import_provider_utils3.generateId)();
+              currentTextId = (0, import_provider_utils2.generateId)();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1610,12 +1270,12 @@ var jsonMixProtocol = ({
               }
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: (0, import_provider_utils3.generateId)(),
+                toolCallId: (0, import_provider_utils2.generateId)(),
                 toolName: parsedToolCall.name,
                 input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
               });
             } catch (e) {
-              const errorId = (0, import_provider_utils3.generateId)();
+              const errorId = (0, import_provider_utils2.generateId)();
               controller.enqueue({ type: "text-start", id: errorId });
               controller.enqueue({
                 type: "text-delta",
@@ -1648,13 +1308,24 @@ var jsonMixProtocol = ({
         }
       }
     });
+  },
+  extractToolCallSegments({ text }) {
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
+    const segments = [];
+    let m;
+    while ((m = regex.exec(text)) != null) {
+      segments.push(m[0]);
+    }
+    return segments;
   }
 });
 
-// src/protocols/xml-protocol.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+// src/protocols/morph-xml-protocol.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 var import_fast_xml_parser = require("fast-xml-parser");
-var xmlProtocol = () => ({
+var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
@@ -1805,7 +1476,7 @@ var xmlProtocol = () => ({
         const coercedArgs = coerceBySchema(args, schema);
         processedElements.push({
           type: "tool-call",
-          toolCallId: (0, import_provider_utils4.generateId)(),
+          toolCallId: (0, import_provider_utils3.generateId)(),
           toolName,
           input: JSON.stringify(coercedArgs)
         });
@@ -1834,7 +1505,7 @@ var xmlProtocol = () => ({
       const content = text != null ? text : buffer;
       if (content) {
         if (!currentTextId) {
-          currentTextId = (0, import_provider_utils4.generateId)();
+          currentTextId = (0, import_provider_utils3.generateId)();
           controller.enqueue({ type: "text-start", id: currentTextId });
         }
         controller.enqueue({
@@ -1959,7 +1630,7 @@ var xmlProtocol = () => ({
                 flushText(controller);
                 controller.enqueue({
                   type: "tool-call",
-                  toolCallId: (0, import_provider_utils4.generateId)(),
+                  toolCallId: (0, import_provider_utils3.generateId)(),
                   toolName: currentToolCall.name,
                   input: JSON.stringify(coercedArgs)
                 });
@@ -2019,11 +1690,578 @@ var xmlProtocol = () => ({
         }
       }
     });
+  },
+  extractToolCallSegments({ text, tools }) {
+    const toolNames = tools.map((t) => t.name).filter(Boolean);
+    if (toolNames.length === 0) return [];
+    const names = toolNames.map((n) => escapeRegExp(String(n))).join("|");
+    if (!names) return [];
+    const regex = new RegExp(`<(${names})>[\\s\\S]*?<\\/\\1>`, "g");
+    const segments = [];
+    let m;
+    while ((m = regex.exec(text)) != null) {
+      segments.push(m[0]);
+    }
+    return segments;
   }
 });
 
-// src/protocols/dummy-protocol.ts
+// src/generate-handler.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  params
+}) {
+  var _a, _b;
+  if (isToolChoiceActive(params)) {
+    const result2 = await doGenerate();
+    let parsed2 = {};
+    const first = (_a = result2.content) == null ? void 0 : _a[0];
+    if (first && first.type === "text") {
+      const debugLevel2 = getDebugLevel();
+      if (debugLevel2 === "parse") {
+        logRawChunk(first.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_utils4.generateId)(),
+      toolName: parsed2.name || "unknown",
+      input: JSON.stringify(parsed2.arguments || {})
+    };
+    const debugLevelToolChoice = getDebugLevel();
+    const originText = first && first.type === "text" ? first.text : "";
+    if (debugLevelToolChoice === "parse") {
+      logParsedSummary({ toolCalls: [toolCall], originalText: originText });
+    }
+    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];
+    }
+    const debugLevel2 = getDebugLevel();
+    if (debugLevel2 === "stream") {
+      logRawChunk(contentItem.text);
+    }
+    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)
+  );
+  const debugLevel = getDebugLevel();
+  if (debugLevel === "stream") {
+    newContent.forEach((part) => logParsedChunk(part));
+  }
+  if (debugLevel === "parse") {
+    const allText = result.content.filter(
+      (c) => c.type === "text"
+    ).map((c) => c.text).join("\n\n");
+    const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
+    const originalText = segments.join("\n\n");
+    const toolCalls = newContent.filter(
+      (p) => p.type === "tool-call"
+    );
+    logParsedSummary({ toolCalls, originalText });
+  }
+  return {
+    ...result,
+    content: newContent
+  };
+}
+
+// src/stream-handler.ts
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
+  const debugLevel = getDebugLevel();
+  const tools = getFunctionTools(params);
+  const options = {
+    ...extractOnErrorOption(params.providerOptions),
+    ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+  };
+  if (debugLevel === "off") {
+    return {
+      stream: stream.pipeThrough(
+        protocol.createStreamParser({
+          tools,
+          options
+        })
+      ),
+      ...rest
+    };
+  }
+  if (debugLevel === "stream") {
+    const withRawTap2 = stream.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logRawChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    const parsed2 = withRawTap2.pipeThrough(
+      protocol.createStreamParser({
+        tools,
+        options
+      })
+    );
+    const withParsedTap = parsed2.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logParsedChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    return {
+      stream: withParsedTap,
+      ...rest
+    };
+  }
+  let fullRawText = "";
+  const withRawTap = stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "text-delta") {
+          const delta = part.delta;
+          if (typeof delta === "string" && delta.length > 0) {
+            fullRawText += delta;
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  );
+  const parsed = withRawTap.pipeThrough(
+    protocol.createStreamParser({
+      tools,
+      options
+    })
+  );
+  const withSummary = parsed.pipeThrough(
+    new TransformStream({
+      transform: /* @__PURE__ */ (() => {
+        const parsedToolCalls = [];
+        return (part, controller) => {
+          if (part.type === "tool-call") {
+            parsedToolCalls.push(part);
+          }
+          if (part.type === "finish") {
+            try {
+              const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
+                text: fullRawText,
+                tools
+              }) : [];
+              const origin = segments.join("\n\n");
+              logParsedSummary({
+                toolCalls: parsedToolCalls,
+                originalText: origin
+              });
+            } catch (e) {
+            }
+          }
+          controller.enqueue(part);
+        };
+      })()
+    })
+  );
+  return {
+    stream: withSummary,
+    ...rest
+  };
+}
+async function toolChoiceStream({
+  doGenerate,
+  options
+}) {
+  var _a, _b;
+  const result = await doGenerate();
+  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_utils5.generateId)(),
+    toolName: toolJson.name || "unknown",
+    input: JSON.stringify(toolJson.arguments || {})
+  };
+  const finishChunk = {
+    type: "finish",
+    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    },
+    finishReason: "tool-calls"
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(toolCallChunk);
+      controller.enqueue(finishChunk);
+      controller.close();
+    }
+  });
+  const debugLevel = getDebugLevel();
+  const firstText = (result == null ? void 0 : result.content) && result.content[0] && result.content[0].type === "text" && result.content[0].text || "";
+  const streamWithSummary = debugLevel === "parse" ? stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "finish") {
+          try {
+            logParsedSummary({
+              toolCalls: [toolCallChunk],
+              originalText: typeof firstText === "string" ? firstText : ""
+            });
+          } catch (e) {
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  ) : stream;
+  return {
+    request: (result == null ? void 0 : result.request) || {},
+    response: (result == null ? void 0 : result.response) || {},
+    stream: streamWithSummary
+  };
+}
+
+// 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 || {},
+        // INTERNAL: used by the middleware to propagate the names of custom
+        // function tools into downstream handlers (stream/generate) when
+        // providers strip or ignore `params.tools`. Not a stable public API.
+        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 || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          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 || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          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({
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream, doGenerate, params }) => {
+      if (isToolChoiceActive(params)) {
+        return toolChoiceStream({
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
+        });
+      } else {
+        return wrapStream({
+          protocol: resolvedProtocol,
+          doStream,
+          doGenerate,
+          params
+        });
+      }
+    },
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({
+      params
+    }) => {
+      return transformParams({
+        protocol: resolvedProtocol,
+        toolSystemPromptTemplate,
+        params
+      });
+    }
+  };
+}
 
 // src/index.ts
 var gemmaToolMiddleware = createToolMiddleware({
@@ -2031,8 +2269,9 @@ var gemmaToolMiddleware = createToolMiddleware({
     // Customize the tool call delimiters to use markdown code fences
     {
       toolCallStart: "```tool_call\n",
-      toolCallEnd: "\n``",
-      // two backticks are more common in gemma output @
+      // TODO: Support specifying multiple possible tags,
+      // e.g., for gemma, it would be nice to be able to set both `` and ``` at the same time.
+      toolCallEnd: "\n```",
       toolResponseStart: "```tool_response\n",
       toolResponseEnd: "\n```"
     }
@@ -2063,7 +2302,7 @@ For each function call return a json object with function name and arguments wit
   }
 });
 var xmlToolMiddleware = createToolMiddleware({
-  protocol: xmlProtocol,
+  protocol: morphXmlProtocol,
   toolSystemPromptTemplate(tools) {
     return `You are a function calling AI model.
 You are provided with function signatures within <tools></tools> XML tags.
@@ -2082,15 +2321,11 @@ San Fransisco
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  coerceBySchema,
   createToolMiddleware,
-  fixToolCallWithSchema,
   gemmaToolMiddleware,
-  getSchemaType,
   hermesToolMiddleware,
   jsonMixProtocol,
-  unwrapJsonSchema,
-  xmlProtocol,
+  morphXmlProtocol,
   xmlToolMiddleware
 });
 //# sourceMappingURL=index.cjs.map