@ai-sdk-tool/parser 2.1.1 → 2.1.3

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,498 +951,1080 @@ 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
+    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 (((_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."
-      );
+      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] });
+        }
+      }
+      currentIndex = startIndex + match[0].length;
     }
-    return {
-      ...baseReturnParams,
-      responseFormat: {
-        type: "json",
-        schema: createDynamicIfThenElseSchema(functionTools)
-      },
-      providerOptions: {
-        ...baseReturnParams.providerOptions || {},
-        toolCallMiddleware: {
-          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-          toolChoice: { type: "required" }
+    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_utils2.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_utils2.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_utils2.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_utils2.generateId)();
+              controller.enqueue({ type: "text-start", id: currentTextId });
+              hasEmittedTextStart = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: currentTextId,
+              delta: text
+            });
+          }
+        };
+        let startIndex;
+        while ((startIndex = getPotentialStartIndex(
+          buffer,
+          isInsideToolCall ? toolCallEnd : toolCallStart
+        )) != null) {
+          const tag = isInsideToolCall ? toolCallEnd : toolCallStart;
+          if (startIndex + tag.length > buffer.length) {
+            break;
+          }
+          publish(buffer.slice(0, startIndex));
+          buffer = buffer.slice(startIndex + tag.length);
+          if (!isInsideToolCall) {
+            currentToolCallJson = "";
+            isInsideToolCall = true;
+          } else {
+            try {
+              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
+              if (currentTextId && hasEmittedTextStart) {
+                controller.enqueue({ type: "text-end", id: currentTextId });
+                currentTextId = null;
+                hasEmittedTextStart = false;
+              }
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: (0, import_provider_utils2.generateId)(),
+                toolName: parsedToolCall.name,
+                input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+              });
+            } catch (e) {
+              const errorId = (0, import_provider_utils2.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}`
+                  }
+                );
+              }
+            }
+            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 = "";
+          }
         }
       }
-    };
+    });
+  },
+  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;
   }
-  return baseReturnParams;
+});
+
+// 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 WARN_ON_DUPLICATE_STRING_TAGS = true;
+function getToolSchema(tools, originalSchemas, toolName) {
+  var _a;
+  const original = originalSchemas[toolName];
+  if (original) return original;
+  const fallback = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+  return fallback;
 }
-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)
-          });
+function getPropertySchema(toolSchema, key) {
+  const unwrapped = unwrapJsonSchema(toolSchema);
+  if (!unwrapped || typeof unwrapped !== "object") return void 0;
+  const u = unwrapped;
+  const props = u.properties;
+  if (props && Object.prototype.hasOwnProperty.call(props, key)) {
+    return props[key];
+  }
+  return void 0;
+}
+function extractRawInner(xmlContent, tagName) {
+  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
+  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
+  const len = xmlContent.length;
+  const target = tagName;
+  let bestStart = -1;
+  let bestEnd = -1;
+  let bestDepth = Number.POSITIVE_INFINITY;
+  const skipQuoted = (s, i2) => {
+    const quote = s[i2];
+    i2++;
+    while (i2 < s.length) {
+      const ch = s[i2];
+      if (ch === "\\") {
+        i2 += 2;
+        continue;
+      }
+      if (ch === quote) {
+        return i2 + 1;
+      }
+      i2++;
+    }
+    return i2;
+  };
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) return void 0;
+    i = lt + 1;
+    if (i >= len) return void 0;
+    const ch = xmlContent[i];
+    if (ch === "!") {
+      if (xmlContent.startsWith("!--", i + 1)) {
+        const close = xmlContent.indexOf("-->", i + 4);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      if (xmlContent.startsWith("![CDATA[", i + 1)) {
+        const close = xmlContent.indexOf("]]>", i + 9);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      const gt = xmlContent.indexOf(">", i + 1);
+      i = gt === -1 ? len : gt + 1;
+      continue;
+    } else if (ch === "?") {
+      const close = xmlContent.indexOf("?>", i + 1);
+      i = close === -1 ? len : close + 2;
+      continue;
+    } else if (ch === "/") {
+      let j = i + 1;
+      if (j < len && isNameStartChar(xmlContent[j])) {
+        j++;
+        while (j < len && isNameChar(xmlContent[j])) j++;
+      }
+      const gt = xmlContent.indexOf(">", j);
+      i = gt === -1 ? len : gt + 1;
+      depth = Math.max(0, depth - 1);
+      continue;
+    } else {
+      let j = i;
+      if (j < len && isNameStartChar(xmlContent[j])) {
+        j++;
+        while (j < len && isNameChar(xmlContent[j])) j++;
+      }
+      const name = xmlContent.slice(i, j);
+      let k = j;
+      let isSelfClosing = false;
+      while (k < len) {
+        const c = xmlContent[k];
+        if (c === '"' || c === "'") {
+          k = skipQuoted(xmlContent, k);
+          continue;
+        }
+        if (c === ">") {
+          break;
         }
+        if (c === "/" && xmlContent[k + 1] === ">") {
+          isSelfClosing = true;
+          k++;
+          break;
+        }
+        k++;
       }
-      const onlyText = newContent.every((c) => c.type === "text");
-      const condensedAssistant = onlyText ? [
-        {
-          type: "text",
-          text: newContent.map((c) => c.text).join("\n")
+      const tagEnd = k;
+      if (name === target) {
+        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+        if (isSelfClosing) {
+          if (depth < bestDepth) {
+            bestStart = contentStart;
+            bestEnd = contentStart;
+            bestDepth = depth;
+            if (bestDepth === 0) {
+            }
+          }
+        } else {
+          let pos = contentStart;
+          let sameDepth = 1;
+          while (pos < len) {
+            const nextLt = xmlContent.indexOf("<", pos);
+            if (nextLt === -1) break;
+            const nx = nextLt + 1;
+            if (nx >= len) break;
+            const h = xmlContent[nx];
+            if (h === "!") {
+              if (xmlContent.startsWith("!--", nx + 1)) {
+                const close = xmlContent.indexOf("-->", nx + 4);
+                pos = close === -1 ? len : close + 3;
+                continue;
+              }
+              if (xmlContent.startsWith("![CDATA[", nx + 1)) {
+                const close = xmlContent.indexOf("]]>", nx + 9);
+                pos = close === -1 ? len : close + 3;
+                continue;
+              }
+              const gt2 = xmlContent.indexOf(">", nx + 1);
+              pos = gt2 === -1 ? len : gt2 + 1;
+              continue;
+            } else if (h === "?") {
+              const close = xmlContent.indexOf("?>", nx + 1);
+              pos = close === -1 ? len : close + 2;
+              continue;
+            } else if (h === "/") {
+              let t = nx + 1;
+              if (t < len && isNameStartChar(xmlContent[t])) {
+                t++;
+                while (t < len && isNameChar(xmlContent[t])) t++;
+              }
+              const endName = xmlContent.slice(nx + 1, t);
+              const gt2 = xmlContent.indexOf(">", t);
+              if (endName === target) {
+                sameDepth--;
+                if (sameDepth === 0) {
+                  if (depth < bestDepth) {
+                    bestStart = contentStart;
+                    bestEnd = nextLt;
+                    bestDepth = depth;
+                    if (bestDepth === 0) {
+                    }
+                  }
+                  break;
+                }
+              }
+              pos = gt2 === -1 ? len : gt2 + 1;
+              continue;
+            } else {
+              let t = nx;
+              if (t < len && isNameStartChar(xmlContent[t])) {
+                t++;
+                while (t < len && isNameChar(xmlContent[t])) t++;
+              }
+              const startName = xmlContent.slice(nx, t);
+              let u = t;
+              let selfClose = false;
+              while (u < len) {
+                const cu = xmlContent[u];
+                if (cu === '"' || cu === "'") {
+                  u = skipQuoted(xmlContent, u);
+                  continue;
+                }
+                if (cu === ">") break;
+                if (cu === "/" && xmlContent[u + 1] === ">") {
+                  selfClose = true;
+                  u++;
+                  break;
+                }
+                u++;
+              }
+              if (startName === target && !selfClose) {
+                sameDepth++;
+              }
+              pos = xmlContent[u] === ">" ? u + 1 : u + 1;
+              continue;
+            }
+          }
         }
-      ] : newContent;
-      return { role: "assistant", content: condensedAssistant };
+      }
+      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+      depth += isSelfClosing ? 0 : 1;
+      continue;
     }
-    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")
-          }
-        ]
-      };
+  }
+  if (bestStart !== -1) {
+    return xmlContent.slice(bestStart, bestEnd);
+  }
+  return void 0;
+}
+function findFirstTopLevelRange(xmlContent, tagName) {
+  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
+  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
+  const len = xmlContent.length;
+  const target = tagName;
+  const skipQuoted = (s, i2) => {
+    const quote = s[i2];
+    i2++;
+    while (i2 < s.length) {
+      const ch = s[i2];
+      if (ch === "\\") {
+        i2 += 2;
+        continue;
+      }
+      if (ch === quote) return i2 + 1;
+      i2++;
     }
-    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
+    return i2;
+  };
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) return void 0;
+    i = lt + 1;
+    if (i >= len) return void 0;
+    const ch = xmlContent[i];
+    if (ch === "!") {
+      if (xmlContent.startsWith("!--", i + 1)) {
+        const close = xmlContent.indexOf("-->", i + 4);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      if (xmlContent.startsWith("![CDATA[", i + 1)) {
+        const close = xmlContent.indexOf("]]>", i + 9);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      const gt = xmlContent.indexOf(">", i + 1);
+      i = gt === -1 ? len : gt + 1;
+      continue;
+    } else if (ch === "?") {
+      const close = xmlContent.indexOf("?>", i + 1);
+      i = close === -1 ? len : close + 2;
+      continue;
+    } else if (ch === "/") {
+      const gt = xmlContent.indexOf(">", i + 1);
+      i = gt === -1 ? len : gt + 1;
+      depth = Math.max(0, depth - 1);
+      continue;
+    } else {
+      let j = i;
+      if (j < len && isNameStartChar(xmlContent[j])) {
+        j++;
+        while (j < len && isNameChar(xmlContent[j])) j++;
+      }
+      const name = xmlContent.slice(i, j);
+      let k = j;
+      let isSelfClosing = false;
+      while (k < len) {
+        const c = xmlContent[k];
+        if (c === '"' || c === "'") {
+          k = skipQuoted(xmlContent, k);
+          continue;
+        }
+        if (c === ">") break;
+        if (c === "/" && xmlContent[k + 1] === ">") {
+          isSelfClosing = true;
+          k++;
+          break;
+        }
+        k++;
+      }
+      const tagEnd = k;
+      if (depth === 0 && name === target) {
+        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+        if (isSelfClosing) return { start: contentStart, end: contentStart };
+        let pos = contentStart;
+        let sameDepth = 1;
+        while (pos < len) {
+          const nextLt = xmlContent.indexOf("<", pos);
+          if (nextLt === -1) break;
+          const nx = nextLt + 1;
+          if (nx >= len) break;
+          const h = xmlContent[nx];
+          if (h === "!") {
+            if (xmlContent.startsWith("!--", nx + 1)) {
+              const close = xmlContent.indexOf("-->", nx + 4);
+              pos = close === -1 ? len : close + 3;
+              continue;
+            }
+            if (xmlContent.startsWith("![CDATA[", nx + 1)) {
+              const close = xmlContent.indexOf("]]>", nx + 9);
+              pos = close === -1 ? len : close + 3;
+              continue;
+            }
+            const gt2 = xmlContent.indexOf(">", nx + 1);
+            pos = gt2 === -1 ? len : gt2 + 1;
+            continue;
+          } else if (h === "?") {
+            const close = xmlContent.indexOf("?>", nx + 1);
+            pos = close === -1 ? len : close + 2;
+            continue;
+          } else if (h === "/") {
+            let t = nx + 1;
+            if (t < len && isNameStartChar(xmlContent[t])) {
+              t++;
+              while (t < len && isNameChar(xmlContent[t])) t++;
+            }
+            const endName = xmlContent.slice(nx + 1, t);
+            const gt2 = xmlContent.indexOf(">", t);
+            if (endName === target) {
+              sameDepth--;
+              if (sameDepth === 0) {
+                return { start: contentStart, end: nextLt };
               }
-            ]
-          };
-        } else {
-          processedPrompt[i] = {
-            role: "user",
-            content: [
-              {
-                type: "text",
-                text: joinedText
+            }
+            pos = gt2 === -1 ? len : gt2 + 1;
+            continue;
+          } else {
+            let t = nx;
+            if (t < len && isNameStartChar(xmlContent[t])) {
+              t++;
+              while (t < len && isNameChar(xmlContent[t])) t++;
+            }
+            let u = t;
+            let selfClose = false;
+            while (u < len) {
+              const cu = xmlContent[u];
+              if (cu === '"' || cu === "'") {
+                u = skipQuoted(xmlContent, u);
+                continue;
               }
-            ]
-          };
+              if (cu === ">") break;
+              if (cu === "/" && xmlContent[u + 1] === ">") {
+                selfClose = true;
+                u++;
+                break;
+              }
+              u++;
+            }
+            if (!selfClose) {
+            }
+            pos = xmlContent[u] === ">" ? u + 1 : u + 1;
+            continue;
+          }
+        }
+        return void 0;
+      }
+      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+      depth += isSelfClosing ? 0 : 1;
+      continue;
+    }
+  }
+  return void 0;
+}
+function countTagOccurrences(xmlContent, tagName, excludeRanges, skipFirst = true) {
+  const isNameStartChar = (ch) => /[A-Za-z_:]/.test(ch);
+  const isNameChar = (ch) => /[A-Za-z0-9_.:-]/.test(ch);
+  const len = xmlContent.length;
+  const target = tagName;
+  const skipQuoted = (s, i2) => {
+    const quote = s[i2];
+    i2++;
+    while (i2 < s.length) {
+      const ch = s[i2];
+      if (ch === "\\") {
+        i2 += 2;
+        continue;
+      }
+      if (ch === quote) return i2 + 1;
+      i2++;
+    }
+    return i2;
+  };
+  let i = 0;
+  let count = 0;
+  const isExcluded = (pos) => {
+    if (!excludeRanges || excludeRanges.length === 0) return false;
+    for (const r of excludeRanges) {
+      if (pos >= r.start && pos < r.end) return true;
+    }
+    return false;
+  };
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) break;
+    i = lt + 1;
+    if (i >= len) break;
+    const ch = xmlContent[i];
+    if (ch === "!") {
+      if (xmlContent.startsWith("!--", i + 1)) {
+        const close = xmlContent.indexOf("-->", i + 4);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      if (xmlContent.startsWith("![CDATA[", i + 1)) {
+        const close = xmlContent.indexOf("]]>", i + 9);
+        i = close === -1 ? len : close + 3;
+        continue;
+      }
+      const gt = xmlContent.indexOf(">", i + 1);
+      i = gt === -1 ? len : gt + 1;
+      continue;
+    } else if (ch === "?") {
+      const close = xmlContent.indexOf("?>", i + 1);
+      i = close === -1 ? len : close + 2;
+      continue;
+    } else if (ch === "/") {
+      const gt = xmlContent.indexOf(">", i + 1);
+      i = gt === -1 ? len : gt + 1;
+      continue;
+    } else {
+      let j = i;
+      if (j < len && isNameStartChar(xmlContent[j])) {
+        j++;
+        while (j < len && isNameChar(xmlContent[j])) j++;
+      }
+      const name = xmlContent.slice(i, j);
+      let k = j;
+      while (k < len) {
+        const c = xmlContent[k];
+        if (c === '"' || c === "'") {
+          k = skipQuoted(xmlContent, k);
+          continue;
+        }
+        if (c === ">") break;
+        if (c === "/" && xmlContent[k + 1] === ">") {
+          k++;
+          break;
         }
+        k++;
       }
+      if (name === target && !isExcluded(lt)) {
+        if (skipFirst) {
+          skipFirst = false;
+        } else {
+          count++;
+        }
+      }
+      i = k + 1;
+      continue;
     }
   }
-  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;
+  return count;
 }
-
-// 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)
+function processParsedArgs(parsedArgs, toolSchema, toolContent, toolName, options) {
+  var _a, _b, _c;
+  const args = {};
+  let cancelToolCall = false;
+  const stringTypedProps = (() => {
+    const set = /* @__PURE__ */ new Set();
+    const unwrapped = unwrapJsonSchema(toolSchema);
+    if (unwrapped && typeof unwrapped === "object") {
+      const u = unwrapped;
+      const props = u.properties;
+      if (props && typeof props === "object") {
+        for (const key of Object.keys(props)) {
+          const t = getSchemaType(props[key]);
+          if (t === "string") set.add(key);
+        }
+      }
+    }
+    return set;
+  })();
+  for (const k of Object.keys(parsedArgs || {})) {
+    const v = parsedArgs[k];
+    let val = v;
+    const propSchema = getPropertySchema(toolSchema, k);
+    const propType = getSchemaType(propSchema);
+    if (propType === "string" && !Array.isArray(v)) {
+      const excludeRanges = [];
+      for (const other of stringTypedProps) {
+        if (other === k) continue;
+        const range = findFirstTopLevelRange(toolContent, other);
+        if (range) excludeRanges.push(range);
+      }
+      const occurrences = countTagOccurrences(
+        toolContent,
+        k,
+        excludeRanges,
+        true
+      );
+      if (occurrences > 0) {
+        if (WARN_ON_DUPLICATE_STRING_TAGS) {
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+            options,
+            `Duplicate string tags for <${k}> detected; cancelling tool call`,
+            {
+              toolName,
+              toolCall: `<${toolName}>${toolContent}</${toolName}>`
+            }
+          );
+        }
+        cancelToolCall = true;
+        break;
+      }
+      const raw = extractRawInner(toolContent, k);
+      if (typeof raw === "string") {
+        args[k] = raw;
+        continue;
+      }
+    }
+    if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
+      val = v == null ? void 0 : v["#text"];
+    }
+    if (Array.isArray(v)) {
+      if (propType === "string") {
+        const mapped = 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 : String(textVal);
+          }
+          return typeof item === "string" ? item : String(item);
         });
+        if (mapped.length > 1 && WARN_ON_DUPLICATE_STRING_TAGS) {
+          (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+            options,
+            `Duplicate string tags for <${k}> detected; cancelling tool call`,
+            {
+              toolName,
+              toolCall: `<${toolName}>${toolContent}</${toolName}>`
+            }
+          );
+        }
+        if (mapped.length > 1) {
+          cancelToolCall = true;
+          break;
+        } else {
+          args[k] = (_c = mapped[0]) != null ? _c : "";
+          continue;
+        }
       } else {
-        return wrapStream({
-          protocol: resolvedProtocol,
-          doStream,
-          doGenerate,
-          params
+        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;
         });
       }
-    },
-    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
-      protocol: resolvedProtocol,
-      doGenerate,
-      params
-    }),
-    transformParams: async ({
-      params
-    }) => {
-      return transformParams({
-        protocol: resolvedProtocol,
-        toolSystemPromptTemplate,
-        params
-      });
+    } 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) => {
+            let currentVal = item;
+            if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+              currentVal = item == null ? void 0 : item["#text"];
+            }
+            const trimmed = typeof currentVal === "string" ? currentVal.trim() : currentVal;
+            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);
+            val = Number.isFinite(num) ? num : trimmed;
+          } else {
+            val = trimmed;
+          }
+        }
+      } else {
+        let isIndexedTuple = false;
+        if (keys.length > 0 && keys.every((key) => /^\d+$/.test(key))) {
+          const indices = keys.map((k2) => parseInt(k2, 10)).sort((a, b) => a - b);
+          isIndexedTuple = indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+        }
+        if (isIndexedTuple) {
+          const sortedKeys = keys.sort(
+            (a, b) => parseInt(a, 10) - parseInt(b, 10)
+          );
+          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;
+  }
+  return { args, cancelToolCall };
 }
-
-// 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>"
-} = {}) => ({
+var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
+    const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
-      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
-      parameters: tool.inputSchema
+      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 = {};
-    try {
-      args = JSON.parse(toolCall.input);
-    } catch (e) {
-      args = toolCall.input;
+    const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
+    if (typeof inputValue === "string") {
+      try {
+        args = JSON.parse(inputValue);
+      } catch (e) {
+        args = inputValue;
+      }
+    } else {
+      args = inputValue;
     }
-    return `${toolCallStart}${JSON.stringify({
-      name: toolCall.toolName,
-      arguments: args
-    })}${toolCallEnd}`;
+    const xmlContent = builder.build({
+      [toolCall.toolName]: args
+    });
+    return xmlContent;
   },
   formatToolResponse(toolResult) {
-    return `${toolResponseStart}${JSON.stringify({
-      toolName: toolResult.toolName,
-      result: toolResult.output
-    })}${toolResponseEnd}`;
+    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, options }) {
-    var _a;
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
+  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(
-      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
-      "gs"
+      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 toolCallJson = match[1];
+      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 });
         }
       }
-      if (toolCallJson) {
-        try {
-          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+      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 toolSchema = getToolSchema(tools, originalSchemas, toolName);
+        const { args, cancelToolCall } = processParsedArgs(
+          parsedArgs,
+          toolSchema,
+          toolContent,
+          toolName,
+          options
+        );
+        if (cancelToolCall) {
+          const originalCallText = match[0];
+          (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+            options,
+            `Duplicate string tags detected; cancelling tool call`,
+            { toolCall: originalCallText, toolName }
+          );
+          processedElements.push({ type: "text", text: originalCallText });
+        } else {
+          const coercedArgs = coerceBySchema(args, toolSchema);
           processedElements.push({
             type: "tool-call",
             toolCallId: (0, import_provider_utils3.generateId)(),
-            toolName: parsedToolCall.name,
-            input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+            toolName,
+            input: JSON.stringify(coercedArgs)
           });
-        } 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] });
         }
+      } 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] });
       }
       currentIndex = startIndex + match[0].length;
     }
@@ -1506,524 +2036,722 @@ var jsonMixProtocol = ({
     }
     return processedElements;
   },
-  createStreamParser({ tools: _tools, options } = { tools: [] }) {
-    let isInsideToolCall = false;
+  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 currentToolCallJson = "";
+    let currentToolCall = null;
     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;
+    const flushText = (controller, text) => {
+      const content = text != null ? text : buffer;
+      if (content) {
+        if (!currentTextId) {
+          currentTextId = (0, import_provider_utils3.generateId)();
+          controller.enqueue({ type: "text-start", id: currentTextId });
+        }
+        controller.enqueue({
+          type: "text-delta",
+          id: currentTextId,
+          delta: content
+        });
+        if (text === void 0) {
+          buffer = "";
         }
+      }
+      if (currentTextId && !text) {
+        controller.enqueue({ type: "text-end", id: currentTextId });
+        currentTextId = null;
+      }
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
         if (chunk.type !== "text-delta") {
+          if (buffer) flushText(controller);
           controller.enqueue(chunk);
           return;
         }
         buffer += chunk.delta;
-        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;
+        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 toolSchema = getToolSchema(
+                  tools,
+                  originalSchemas,
+                  currentToolCall.name
+                );
+                const { args, cancelToolCall } = processParsedArgs(
+                  parsedArgs,
+                  toolSchema,
+                  toolContent,
+                  currentToolCall.name,
+                  options
+                );
+                if (cancelToolCall) {
+                  const originalCallText = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
+                  if (options == null ? void 0 : options.onError) {
+                    options.onError(
+                      "Duplicate string tags detected; cancelling tool call",
+                      {
+                        toolCall: originalCallText,
+                        toolName: currentToolCall.name
+                      }
+                    );
+                  }
+                  flushText(controller, originalCallText);
+                } else {
+                  const coercedArgs = coerceBySchema(
+                    args,
+                    toolSchema
+                  );
+                  flushText(controller);
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: (0, import_provider_utils3.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;
             }
-            controller.enqueue({
-              type: "text-delta",
-              id: currentTextId,
-              delta: text
-            });
-          }
-        };
-        let startIndex;
-        while ((startIndex = getPotentialStartIndex(
-          buffer,
-          isInsideToolCall ? toolCallEnd : toolCallStart
-        )) != null) {
-          const tag = isInsideToolCall ? toolCallEnd : toolCallStart;
-          if (startIndex + tag.length > buffer.length) {
-            break;
-          }
-          publish(buffer.slice(0, startIndex));
-          buffer = buffer.slice(startIndex + tag.length);
-          if (!isInsideToolCall) {
-            currentToolCallJson = "";
-            isInsideToolCall = true;
           } else {
-            try {
-              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
-              if (currentTextId && hasEmittedTextStart) {
-                controller.enqueue({ type: "text-end", id: currentTextId });
-                currentTextId = null;
-                hasEmittedTextStart = false;
-              }
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId: (0, import_provider_utils3.generateId)(),
-                toolName: parsedToolCall.name,
-                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}`
-                  }
-                );
+            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;
+                }
               }
             }
-            currentToolCallJson = "";
-            isInsideToolCall = false;
+            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;
+            }
           }
         }
-        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 = "";
-          }
+      },
+      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 });
         }
       }
     });
+  },
+  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/xml-protocol.ts
+// src/generate-handler.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") {
+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 {
-        args = JSON.parse(inputValue);
-      } catch (e) {
-        args = inputValue;
+        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 = {};
       }
-    } 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
+    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
       }
     });
-    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 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 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 });
+    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);
       }
-      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"];
+    })
+  );
+  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 (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;
-              }
+          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) {
             }
           }
-          args[k] = typeof val === "string" ? val.trim() : val;
+          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)
         }
-        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] });
-      }
-      currentIndex = startIndex + match[0].length;
+      );
+      toolJson = {};
     }
-    if (currentIndex < text.length) {
-      const remainingText = text.substring(currentIndex);
-      if (remainingText.trim()) {
-        processedElements.push({ type: "text", text: remainingText });
-      }
+  }
+  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();
     }
-    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 });
+  });
+  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({
-          type: "text-delta",
-          id: currentTextId,
-          delta: content
-        });
-        if (text === void 0) {
-          buffer = "";
+        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 (currentTextId && !text) {
-        controller.enqueue({ type: "text-end", id: currentTextId });
-        currentTextId = null;
+    };
+  }
+  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 new TransformStream({
-      transform(chunk, controller) {
-        var _a, _b;
-        if (chunk.type !== "text-delta") {
-          if (buffer) flushText(controller);
-          controller.enqueue(chunk);
-          return;
+  }
+  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)
+          });
         }
-        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);
+      }
+      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
               }
-              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;
-                }
+            ]
+          };
+        } else {
+          processedPrompt[i] = {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: joinedText
               }
-            }
-            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 });
+            ]
+          };
         }
       }
-    });
+    }
   }
-});
+  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/protocols/dummy-protocol.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+// 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 +2759,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 +2792,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 +2811,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