@ai-sdk-tool/parser 2.1.0 → 2.1.2

package/dist/index.js

@@ -4,7 +4,10 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/tool-call-middleware.ts
+// src/protocols/dummy-protocol.ts
+import { generateId } from "@ai-sdk/provider-utils";
+
+// src/protocols/json-mix-protocol.ts
 import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
 // src/utils/dynamic-tool-schema.ts
@@ -81,6 +84,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, {
@@ -415,7 +423,6 @@ function appendPair(state, obj, key, value) {
 }
 function parsePair(tokens, state, obj) {
   let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
-  let key;
   let value;
   if (token.type !== "string") {
     raiseUnexpected(state, token, "string key");
@@ -465,7 +472,7 @@ function parsePair(tokens, state, obj) {
     }
   }
   checkDuplicates(state, obj, token);
-  key = String(token.value);
+  const key = String(token.value);
   skipColon(tokens, state);
   value = parseAny(tokens, state);
   appendPair(state, obj, key, value);
@@ -636,7 +643,10 @@ function parse(text, optsOrReviver) {
   if (!options.relaxed && !options.warnings && !options.tolerant) {
     if (!options.duplicate) {
     } else {
-      return JSON.parse(text, options.reviver);
+      return JSON.parse(
+        text,
+        options.reviver
+      );
     }
   }
   const lexerToUse = options.relaxed ? lexer : strictLexer;
@@ -656,7 +666,7 @@ function parse(text, optsOrReviver) {
     };
     return parseAny(tokens, state, true);
   } else {
-    const newtext = tokens.reduce((str, token) => {
+    tokens.reduce((str, token) => {
       return str + token.match;
     }, "");
     if (!options.relaxed && !options.warnings && !options.tolerant && options.duplicate) {
@@ -680,8 +690,11 @@ function parse(text, optsOrReviver) {
     } else {
       tokens = lexer(text);
       tokens = stripTrailingComma(tokens);
-      const newtext2 = tokens.reduce((str, token) => str + token.match, "");
-      return JSON.parse(newtext2, options.reviver);
+      const newtext = tokens.reduce((str, token) => str + token.match, "");
+      return JSON.parse(
+        newtext,
+        options.reviver
+      );
     }
   }
 }
@@ -709,22 +722,300 @@ function stringify(obj) {
   return "null";
 }
 
-// src/utils/regex.ts
-function escapeRegExp(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// src/utils/coercion.ts
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") return void 0;
+  const t = unwrapped.type;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) if (t.includes(p)) return p;
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  return void 0;
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      const s = value.trim();
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+      if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+        try {
+          const parsed = JSON.parse(s);
+          return coerceBySchema(parsed, void 0);
+        } catch (e) {
+        }
+      }
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "object") {
+      try {
+        let normalized = s.replace(/'/g, '"');
+        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
+        const obj = JSON.parse(normalized);
+        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+          const props = unwrapped.properties;
+          const out = {};
+          for (const [k, v] of Object.entries(obj)) {
+            const propSchema = props ? props[k] : void 0;
+            out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+          }
+          return out;
+        }
+      } catch (e) {
+      }
+    }
+    if (schemaType === "array") {
+      try {
+        const normalized = s.replace(/'/g, '"');
+        const arr = JSON.parse(normalized);
+        if (Array.isArray(arr)) {
+          const u = unwrapped;
+          const prefixItems = Array.isArray(
+            u.prefixItems
+          ) ? u.prefixItems : void 0;
+          const itemsSchema = u.items;
+          if (prefixItems && arr.length === prefixItems.length) {
+            return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+          }
+          return arr.map((v) => coerceBySchema(v, itemsSchema));
+        }
+      } catch (e) {
+        const csv = s.includes("\n") ? s.split(/\n+/) : s.split(/,\s*/);
+        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+        const u = unwrapped;
+        const prefixItems = Array.isArray(
+          u.prefixItems
+        ) ? u.prefixItems : void 0;
+        const itemsSchema = u.items;
+        if (prefixItems && trimmed.length === prefixItems.length) {
+          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
+        }
+        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
+      }
+    }
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    const out = {};
+    const props = unwrapped.properties;
+    for (const [k, v] of Object.entries(value)) {
+      const propSchema = props ? props[k] : void 0;
+      out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+    }
+    return out;
+  }
+  if (schemaType === "array") {
+    const u = unwrapped;
+    const itemsSchema = u.items;
+    const prefixItems = Array.isArray(
+      u.prefixItems
+    ) ? u.prefixItems : void 0;
+    if (Array.isArray(value)) {
+      if (prefixItems && value.length === prefixItems.length) {
+        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return value.map((v) => coerceBySchema(v, itemsSchema));
+    }
+    if (value && typeof value === "object") {
+      const maybe = value;
+      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
+        const items = maybe.item;
+        const arr = Array.isArray(items) ? items : [items];
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+        }
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
+      }
+      const keys = Object.keys(maybe);
+      if (keys.length === 1) {
+        const singleKey = keys[0];
+        const singleValue = maybe[singleKey];
+        if (Array.isArray(singleValue)) {
+          const coercedArray = singleValue.map(
+            (v) => coerceBySchema(v, itemsSchema)
+          );
+          return coercedArray;
+        }
+      }
+      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
+        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+        }
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
+      }
+    }
+    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      if (prefixItems && prefixItems.length > 0) {
+        return [coerceBySchema(value, prefixItems[0])];
+      }
+      return [coerceBySchema(value, itemsSchema)];
+    }
+  }
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "boolean") {
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+    }
+    if (schemaType === "number" || schemaType === "integer") {
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+    }
+  }
+  return value;
+}
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") return part;
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return {
+    ...part,
+    input: JSON.stringify(coerced != null ? coerced : {})
+  };
+}
+function coerceToolCallInput(part, tools) {
+  return fixToolCallWithSchema(part, tools);
 }
 
-// src/utils/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");
+// 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;
 }
-function isToolResultPart(content) {
-  const c = content;
-  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+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 boolEnv = normalizeBooleanString(envLower);
+  if (boolEnv === true) return "stream";
+  if (envLower === "2") return "parse";
+  return "off";
 }
-function hasInputProperty(obj) {
-  return typeof obj === "object" && obj !== null && "input" in obj;
+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);
+  }
+}
+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
+}) {
+  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}`);
+  }
+  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);
+  }
+}
+
+// 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
@@ -735,7 +1026,11 @@ function isToolChoiceActive(params) {
 }
 function getFunctionTools(params) {
   var _a, _b;
-  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_a = params.providerOptions.toolCallMiddleware) == null ? void 0 : _a.toolNames) || [];
+  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"
   ) : [];
@@ -748,436 +1043,101 @@ function getFunctionTools(params) {
       inputSchema: { type: "object" }
     }));
   }
-  return ((_b = params.tools) != null ? _b : []).filter(
-    (t) => t.type === "function"
-  );
+  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/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/stream-handler.ts
-import { generateId } from "@ai-sdk/provider-utils";
-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") {
+// 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 {
-      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)
+      args = JSON.parse(toolCall.input);
+    } catch (e) {
+      args = toolCall.input;
+    }
+    return `${toolCallStart}${JSON.stringify({
+      name: toolCall.toolName,
+      arguments: args
+    })}${toolCallEnd}`;
+  },
+  formatToolResponse(toolResult) {
+    return `${toolResponseStart}${JSON.stringify({
+      toolName: toolResult.toolName,
+      result: toolResult.output
+    })}${toolResponseEnd}`;
+  },
+  parseGeneratedText({ text, options }) {
+    var _a;
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const toolCallRegex = new RegExp(
+      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
+      "gs"
+    );
+    const processedElements = [];
+    let currentIndex = 0;
+    let match;
+    while ((match = toolCallRegex.exec(text)) !== null) {
+      const startIndex = match.index;
+      const toolCallJson = match[1];
+      if (startIndex > currentIndex) {
+        const textSegment = text.substring(currentIndex, startIndex);
+        if (textSegment.trim()) {
+          processedElements.push({ type: "text", text: textSegment });
         }
-      );
-      toolJson = {};
+      }
+      if (toolCallJson) {
+        try {
+          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          processedElements.push({
+            type: "tool-call",
+            toolCallId: generateId2(),
+            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;
     }
-  }
-  const toolCallChunk = {
-    type: "tool-call",
-    toolCallId: 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/tool-call-middleware.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-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)
-        });
-      }
-      const { stream, ...rest } = await doStream();
-      return {
-        stream: stream.pipeThrough(
-          resolvedProtocol.createStreamParser({
-            tools: getFunctionTools(params),
-            options: extractOnErrorOption(params.providerOptions)
-          })
-        ),
-        ...rest
-      };
-    },
-    wrapGenerate: async ({ doGenerate, params }) => {
-      var _a, _b;
-      if (isToolChoiceActive(params)) {
-        const result2 = await doGenerate();
-        let parsed = {};
-        const first = (_a = result2.content) == null ? void 0 : _a[0];
-        if (first && first.type === "text") {
-          try {
-            parsed = JSON.parse(first.text);
-          } catch (error) {
-            const options = extractOnErrorOption(params.providerOptions);
-            (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-              options,
-              "Failed to parse toolChoice JSON from generated model output",
-              {
-                text: first.text,
-                error: error instanceof Error ? error.message : String(error)
-              }
-            );
-            parsed = {};
-          }
-        }
-        return {
-          ...result2,
-          content: [
-            {
-              type: "tool-call",
-              toolCallId: generateId2(),
-              toolName: parsed.name || "unknown",
-              input: JSON.stringify(parsed.arguments || {})
-            }
-          ]
-        };
-      }
-      const result = await doGenerate();
-      if (result.content.length === 0) {
-        return result;
-      }
-      const newContent = result.content.flatMap((contentItem) => {
-        if (contentItem.type !== "text") {
-          return [contentItem];
-        }
-        return resolvedProtocol.parseGeneratedText({
-          text: contentItem.text,
-          tools: getFunctionTools(params),
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      });
-      return {
-        ...result,
-        content: newContent
-      };
-    },
-    transformParams: async ({ params }) => {
-      var _a, _b, _c, _d, _e, _f;
-      const convertToolPrompt = (prompt) => {
-        const processedPrompt2 = prompt.map((message) => {
-          var _a2;
-          if (message.role === "assistant") {
-            const newContent = [];
-            for (const content of message.content) {
-              if (isToolCallContent(content)) {
-                newContent.push({
-                  type: "text",
-                  text: resolvedProtocol.formatToolCall(content)
-                });
-              } else if (content.type === "text") {
-                newContent.push(content);
-              } else if (content.type === "reasoning") {
-                newContent.push(content);
-              } else {
-                const options = extractOnErrorOption(params.providerOptions);
-                (_a2 = options == null ? void 0 : options.onError) == null ? void 0 : _a2.call(
-                  options,
-                  "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
-                  { content }
-                );
-                newContent.push({
-                  type: "text",
-                  text: JSON.stringify(content)
-                });
-              }
-            }
-            const onlyText = newContent.every((c) => c.type === "text");
-            const condensedAssistant = onlyText ? [
-              {
-                type: "text",
-                text: newContent.map((c) => c.text).join("\n")
-              }
-            ] : newContent;
-            return { role: "assistant", content: condensedAssistant };
-          }
-          if (message.role === "tool") {
-            return {
-              role: "user",
-              // Map tool results to text response blocks, then condense into a single text block
-              content: [
-                {
-                  type: "text",
-                  text: message.content.map(
-                    (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
-                      toolResult
-                    )
-                  ).join("\n")
-                }
-              ]
-            };
-          }
-          return message;
-        });
-        for (let i = 0; i < processedPrompt2.length; i++) {
-          const msg = processedPrompt2[i];
-          if (Array.isArray(msg.content)) {
-            const allText = msg.content.every((c) => (c == null ? void 0 : c.type) === "text");
-            if (allText && msg.content.length > 1) {
-              processedPrompt2[i] = {
-                role: msg.role,
-                content: [
-                  {
-                    type: "text",
-                    text: msg.content.map((c) => c.text).join("\n")
-                  }
-                ]
-              };
-            }
-          }
-        }
-        for (let i = processedPrompt2.length - 1; i > 0; i--) {
-          const current = processedPrompt2[i];
-          const prev = processedPrompt2[i - 1];
-          if (current.role === "user" && prev.role === "user") {
-            const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
-            const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
-            processedPrompt2[i - 1] = {
-              role: "user",
-              content: [
-                { type: "text", text: prevContent + "\n" + currentContent }
-              ]
-            };
-            processedPrompt2.splice(i, 1);
-          }
-        }
-        return processedPrompt2;
-      };
-      const functionTools = ((_a = params.tools) != null ? _a : []).filter(
-        (t) => t.type === "function"
-      );
-      const systemPrompt = resolvedProtocol.formatTools({
-        tools: functionTools,
-        toolSystemPromptTemplate
-      });
-      const processedPrompt = convertToolPrompt(params.prompt);
-      const finalPrompt = ((_b = processedPrompt[0]) == null ? void 0 : _b.role) === "system" ? [
-        {
-          role: "system",
-          content: systemPrompt + "\n\n" + processedPrompt[0].content
-        },
-        ...processedPrompt.slice(1)
-      ] : [
-        {
-          role: "system",
-          content: systemPrompt
-        },
-        ...processedPrompt
-      ];
-      const baseReturnParams = {
-        ...params,
-        prompt: 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 (((_c = params.toolChoice) == null ? void 0 : _c.type) === "none") {
-        throw new Error(
-          "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
-        );
-      }
-      if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "tool") {
-        const selectedToolName = params.toolChoice.toolName;
-        const selectedTool = (_e = params.tools) == null ? void 0 : _e.find(
-          (tool) => tool.type === "function" ? tool.name === selectedToolName : tool.id === selectedToolName
-        );
-        if (!selectedTool) {
-          throw new Error(
-            `Tool with name '${selectedToolName}' not found in params.tools.`
-          );
-        }
-        if (selectedTool.type === "provider-defined") {
-          throw new Error(
-            "Provider-defined tools are not supported by this middleware. Please use custom tools."
-          );
-        }
-        return {
-          ...baseReturnParams,
-          responseFormat: {
-            type: "json",
-            schema: {
-              type: "object",
-              properties: {
-                name: {
-                  const: selectedTool.name
-                },
-                arguments: selectedTool.inputSchema
-              },
-              required: ["name", "arguments"]
-            },
-            name: selectedTool.name,
-            description: selectedTool.type === "function" && typeof selectedTool.description === "string" ? selectedTool.description : void 0
-          },
-          providerOptions: {
-            ...baseReturnParams.providerOptions || {},
-            toolCallMiddleware: {
-              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-              toolChoice: params.toolChoice
-            }
-          }
-        };
-      }
-      if (((_f = params.toolChoice) == null ? void 0 : _f.type) === "required") {
-        if (!params.tools || params.tools.length === 0) {
-          throw new Error(
-            "Tool choice type 'required' is set, but no tools are provided in params.tools."
-          );
-        }
-        return {
-          ...baseReturnParams,
-          responseFormat: {
-            type: "json",
-            schema: createDynamicIfThenElseSchema(
-              params.tools.filter((t) => t.type === "function")
-            )
-          },
-          providerOptions: {
-            ...baseReturnParams.providerOptions || {},
-            toolCallMiddleware: {
-              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-              toolChoice: { type: "required" }
-            }
-          }
-        };
-      }
-      return baseReturnParams;
-    }
-  };
-}
-
-// src/protocols/json-mix-protocol.ts
-import { generateId as generateId3 } from "@ai-sdk/provider-utils";
-var jsonMixProtocol = ({
-  toolCallStart = "<tool_call>",
-  toolCallEnd = "</tool_call>",
-  toolResponseStart = "<tool_response>",
-  toolResponseEnd = "</tool_response>"
-} = {}) => ({
-  formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
-      name: tool.name,
-      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
-      parameters: tool.inputSchema
-    }));
-    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
-  },
-  formatToolCall(toolCall) {
-    let args = {};
-    try {
-      args = JSON.parse(toolCall.input);
-    } catch (e) {
-      args = toolCall.input;
-    }
-    return `${toolCallStart}${JSON.stringify({
-      name: toolCall.toolName,
-      arguments: args
-    })}${toolCallEnd}`;
-  },
-  formatToolResponse(toolResult) {
-    return `${toolResponseStart}${JSON.stringify({
-      toolName: toolResult.toolName,
-      result: toolResult.output
-    })}${toolResponseEnd}`;
-  },
-  parseGeneratedText({ text, options }) {
-    var _a;
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
-    const toolCallRegex = new RegExp(
-      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
-      "gs"
-    );
-    const processedElements = [];
-    let currentIndex = 0;
-    let match;
-    while ((match = toolCallRegex.exec(text)) !== null) {
-      const startIndex = match.index;
-      const toolCallJson = match[1];
-      if (startIndex > currentIndex) {
-        const textSegment = text.substring(currentIndex, startIndex);
-        if (textSegment.trim()) {
-          processedElements.push({ type: "text", text: textSegment });
-        }
-      }
-      if (toolCallJson) {
-        try {
-          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
-          processedElements.push({
-            type: "tool-call",
-            toolCallId: generateId3(),
-            toolName: parsedToolCall.name,
-            input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-          });
-        } catch (error) {
-          if (options == null ? void 0 : options.onError) {
-            options.onError(
-              "Could not process JSON tool call, keeping original text.",
-              { toolCall: match[0], error }
-            );
-          }
-          processedElements.push({ type: "text", text: match[0] });
-        }
-      }
-      currentIndex = startIndex + match[0].length;
-    }
-    if (currentIndex < text.length) {
-      const remainingText = text.substring(currentIndex);
-      if (remainingText.trim()) {
-        processedElements.push({ type: "text", text: remainingText });
-      }
+    if (currentIndex < text.length) {
+      const remainingText = text.substring(currentIndex);
+      if (remainingText.trim()) {
+        processedElements.push({ type: "text", text: remainingText });
+      }
     }
     return processedElements;
   },
@@ -1193,7 +1153,7 @@ var jsonMixProtocol = ({
         if (chunk.type === "finish") {
           if (isInsideToolCall && buffer.length > 0) {
             if (!currentTextId) {
-              currentTextId = generateId3();
+              currentTextId = generateId2();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1205,7 +1165,7 @@ var jsonMixProtocol = ({
             buffer = "";
           } else if (!isInsideToolCall && buffer.length > 0) {
             if (!currentTextId) {
-              currentTextId = generateId3();
+              currentTextId = generateId2();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1222,7 +1182,7 @@ var jsonMixProtocol = ({
             hasEmittedTextStart = false;
           }
           if (currentToolCallJson) {
-            const errorId = generateId3();
+            const errorId = generateId2();
             controller.enqueue({ type: "text-start", id: errorId });
             controller.enqueue({
               type: "text-delta",
@@ -1250,7 +1210,7 @@ var jsonMixProtocol = ({
             currentToolCallJson += text;
           } else if (text.length > 0) {
             if (!currentTextId) {
-              currentTextId = generateId3();
+              currentTextId = generateId2();
               controller.enqueue({ type: "text-start", id: currentTextId });
               hasEmittedTextStart = true;
             }
@@ -1285,12 +1245,12 @@ var jsonMixProtocol = ({
               }
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: generateId3(),
+                toolCallId: generateId2(),
                 toolName: parsedToolCall.name,
                 input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
               });
             } catch (e) {
-              const errorId = generateId3();
+              const errorId = generateId2();
               controller.enqueue({ type: "text-start", id: errorId });
               controller.enqueue({
                 type: "text-delta",
@@ -1323,18 +1283,29 @@ var jsonMixProtocol = ({
         }
       }
     });
+  },
+  extractToolCallSegments({ text }) {
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
+    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
+    const segments = [];
+    let m;
+    while ((m = regex.exec(text)) != null) {
+      segments.push(m[0]);
+    }
+    return segments;
   }
 });
 
-// src/protocols/xml-protocol.ts
-import { generateId as generateId4 } from "@ai-sdk/provider-utils";
-import { XMLParser, XMLBuilder } from "fast-xml-parser";
-var xmlProtocol = () => ({
+// src/protocols/morph-xml-protocol.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: tool.inputSchema
+      parameters: unwrapJsonSchema(tool.inputSchema)
     }));
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
@@ -1367,7 +1338,8 @@ var xmlProtocol = () => ({
     return xmlContent;
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a, _b;
+    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 }];
@@ -1405,17 +1377,87 @@ var xmlProtocol = () => ({
           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[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: generateId4(),
+          toolCallId: generateId3(),
           toolName,
-          input: JSON.stringify(args)
+          input: JSON.stringify(coercedArgs)
         });
       } catch (error) {
         const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
-        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, message, { toolCall: match[0], toolName, error });
+        (_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;
@@ -1429,6 +1471,7 @@ var xmlProtocol = () => ({
     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;
@@ -1437,7 +1480,7 @@ var xmlProtocol = () => ({
       const content = text != null ? text : buffer;
       if (content) {
         if (!currentTextId) {
-          currentTextId = generateId4();
+          currentTextId = generateId3();
           controller.enqueue({ type: "text-start", id: currentTextId });
         }
         controller.enqueue({
@@ -1456,7 +1499,7 @@ var xmlProtocol = () => ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a;
+        var _a, _b;
         if (chunk.type !== "text-delta") {
           if (buffer) flushText(controller);
           controller.enqueue(chunk);
@@ -1485,14 +1528,86 @@ var xmlProtocol = () => ({
                   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: generateId4(),
+                  toolCallId: generateId3(),
                   toolName: currentToolCall.name,
-                  input: JSON.stringify(args)
+                  input: JSON.stringify(coercedArgs)
                 });
               } catch (e) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
@@ -1550,11 +1665,578 @@ var xmlProtocol = () => ({
         }
       }
     });
+  },
+  extractToolCallSegments({ text, tools }) {
+    const toolNames = tools.map((t) => t.name).filter(Boolean);
+    if (toolNames.length === 0) return [];
+    const names = toolNames.map((n) => escapeRegExp(String(n))).join("|");
+    if (!names) return [];
+    const regex = new RegExp(`<(${names})>[\\s\\S]*?<\\/\\1>`, "g");
+    const segments = [];
+    let m;
+    while ((m = regex.exec(text)) != null) {
+      segments.push(m[0]);
+    }
+    return segments;
   }
 });
 
-// src/protocols/dummy-protocol.ts
+// src/generate-handler.ts
+import { generateId as generateId4 } from "@ai-sdk/provider-utils";
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  params
+}) {
+  var _a, _b;
+  if (isToolChoiceActive(params)) {
+    const result2 = await doGenerate();
+    let parsed2 = {};
+    const first = (_a = result2.content) == null ? void 0 : _a[0];
+    if (first && first.type === "text") {
+      const debugLevel2 = getDebugLevel();
+      if (debugLevel2 === "parse") {
+        logRawChunk(first.text);
+      }
+      try {
+        parsed2 = JSON.parse(first.text);
+      } catch (error) {
+        const options = extractOnErrorOption(params.providerOptions);
+        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+          options,
+          "Failed to parse toolChoice JSON from generated model output",
+          {
+            text: first.text,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        parsed2 = {};
+      }
+    }
+    const toolCall = {
+      type: "tool-call",
+      toolCallId: generateId4(),
+      toolName: parsed2.name || "unknown",
+      input: JSON.stringify(parsed2.arguments || {})
+    };
+    const debugLevelToolChoice = getDebugLevel();
+    const originText = first && first.type === "text" ? first.text : "";
+    if (debugLevelToolChoice === "parse") {
+      logParsedSummary({ toolCalls: [toolCall], originalText: originText });
+    }
+    return {
+      ...result2,
+      content: [toolCall]
+    };
+  }
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const parsed = result.content.flatMap((contentItem) => {
+    var _a2;
+    if (contentItem.type !== "text") {
+      return [contentItem];
+    }
+    const debugLevel2 = getDebugLevel();
+    if (debugLevel2 === "stream") {
+      logRawChunk(contentItem.text);
+    }
+    return protocol.parseGeneratedText({
+      text: contentItem.text,
+      tools: getFunctionTools(params),
+      options: {
+        ...extractOnErrorOption(params.providerOptions),
+        ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
+      }
+    });
+  });
+  const tools = getFunctionTools(params);
+  const newContent = parsed.map(
+    (part) => coerceToolCallInput(part, tools)
+  );
+  const debugLevel = getDebugLevel();
+  if (debugLevel === "stream") {
+    newContent.forEach((part) => logParsedChunk(part));
+  }
+  if (debugLevel === "parse") {
+    const allText = result.content.filter(
+      (c) => c.type === "text"
+    ).map((c) => c.text).join("\n\n");
+    const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
+    const originalText = segments.join("\n\n");
+    const toolCalls = newContent.filter(
+      (p) => p.type === "tool-call"
+    );
+    logParsedSummary({ toolCalls, originalText });
+  }
+  return {
+    ...result,
+    content: newContent
+  };
+}
+
+// src/stream-handler.ts
 import { generateId as generateId5 } from "@ai-sdk/provider-utils";
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
+  const debugLevel = getDebugLevel();
+  const tools = getFunctionTools(params);
+  const options = {
+    ...extractOnErrorOption(params.providerOptions),
+    ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+  };
+  if (debugLevel === "off") {
+    return {
+      stream: stream.pipeThrough(
+        protocol.createStreamParser({
+          tools,
+          options
+        })
+      ),
+      ...rest
+    };
+  }
+  if (debugLevel === "stream") {
+    const withRawTap2 = stream.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logRawChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    const parsed2 = withRawTap2.pipeThrough(
+      protocol.createStreamParser({
+        tools,
+        options
+      })
+    );
+    const withParsedTap = parsed2.pipeThrough(
+      new TransformStream(
+        {
+          transform(part, controller) {
+            logParsedChunk(part);
+            controller.enqueue(part);
+          }
+        }
+      )
+    );
+    return {
+      stream: withParsedTap,
+      ...rest
+    };
+  }
+  let fullRawText = "";
+  const withRawTap = stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "text-delta") {
+          const delta = part.delta;
+          if (typeof delta === "string" && delta.length > 0) {
+            fullRawText += delta;
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  );
+  const parsed = withRawTap.pipeThrough(
+    protocol.createStreamParser({
+      tools,
+      options
+    })
+  );
+  const withSummary = parsed.pipeThrough(
+    new TransformStream({
+      transform: /* @__PURE__ */ (() => {
+        const parsedToolCalls = [];
+        return (part, controller) => {
+          if (part.type === "tool-call") {
+            parsedToolCalls.push(part);
+          }
+          if (part.type === "finish") {
+            try {
+              const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
+                text: fullRawText,
+                tools
+              }) : [];
+              const origin = segments.join("\n\n");
+              logParsedSummary({
+                toolCalls: parsedToolCalls,
+                originalText: origin
+              });
+            } catch (e) {
+            }
+          }
+          controller.enqueue(part);
+        };
+      })()
+    })
+  );
+  return {
+    stream: withSummary,
+    ...rest
+  };
+}
+async function toolChoiceStream({
+  doGenerate,
+  options
+}) {
+  var _a, _b;
+  const result = await doGenerate();
+  let toolJson = {};
+  if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
+    try {
+      toolJson = JSON.parse(result.content[0].text);
+    } catch (error) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        options,
+        "Failed to parse toolChoice JSON from streamed model output",
+        {
+          text: result.content[0].text,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      toolJson = {};
+    }
+  }
+  const toolCallChunk = {
+    type: "tool-call",
+    toolCallId: generateId5(),
+    toolName: toolJson.name || "unknown",
+    input: JSON.stringify(toolJson.arguments || {})
+  };
+  const finishChunk = {
+    type: "finish",
+    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    },
+    finishReason: "tool-calls"
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(toolCallChunk);
+      controller.enqueue(finishChunk);
+      controller.close();
+    }
+  });
+  const debugLevel = getDebugLevel();
+  const firstText = (result == null ? void 0 : result.content) && result.content[0] && result.content[0].type === "text" && result.content[0].text || "";
+  const streamWithSummary = debugLevel === "parse" ? stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (part.type === "finish") {
+          try {
+            logParsedSummary({
+              toolCalls: [toolCallChunk],
+              originalText: typeof firstText === "string" ? firstText : ""
+            });
+          } catch (e) {
+          }
+        }
+        controller.enqueue(part);
+      }
+    })
+  ) : stream;
+  return {
+    request: (result == null ? void 0 : result.request) || {},
+    response: (result == null ? void 0 : result.response) || {},
+    stream: streamWithSummary
+  };
+}
+
+// src/transform-handler.ts
+async function transformParams({
+  params,
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  const systemPrompt = resolvedProtocol.formatTools({
+    tools: functionTools,
+    toolSystemPromptTemplate
+  });
+  const processedPrompt = convertToolPrompt(
+    (_b = params.prompt) != null ? _b : [],
+    resolvedProtocol,
+    extractOnErrorOption(params.providerOptions)
+  );
+  const finalPrompt = ((_c = processedPrompt[0]) == null ? void 0 : _c.role) === "system" ? [
+    {
+      role: "system",
+      content: systemPrompt + "\n\n" + processedPrompt[0].content
+    },
+    ...processedPrompt.slice(1)
+  ] : [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...processedPrompt
+  ];
+  const baseReturnParams = {
+    ...params,
+    prompt: finalPrompt,
+    tools: [],
+    toolChoice: void 0,
+    providerOptions: {
+      ...params.providerOptions || {},
+      toolCallMiddleware: {
+        ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
+        // INTERNAL: used by the middleware to propagate the names of custom
+        // function tools into downstream handlers (stream/generate) when
+        // providers strip or ignore `params.tools`. Not a stable public API.
+        toolNames: functionTools.map((t) => t.name)
+      }
+    }
+  };
+  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "none") {
+    throw new Error(
+      "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
+    );
+  }
+  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "tool") {
+    const selectedToolName = params.toolChoice.toolName;
+    const providerDefinedMatch = ((_f = params.tools) != null ? _f : []).find((t) => {
+      if (t.type === "function") return false;
+      const anyTool = t;
+      return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
+    });
+    if (providerDefinedMatch) {
+      throw new Error(
+        "Provider-defined tools are not supported by this middleware. Please use custom tools."
+      );
+    }
+    const selectedTool = ((_g = params.tools) != null ? _g : []).find(
+      (t) => t.type === "function" && t.name === selectedToolName
+    );
+    if (!selectedTool) {
+      throw new Error(
+        `Tool with name '${selectedToolName}' not found in params.tools.`
+      );
+    }
+    return {
+      ...baseReturnParams,
+      responseFormat: {
+        type: "json",
+        schema: {
+          type: "object",
+          properties: {
+            name: {
+              const: selectedTool.name
+            },
+            arguments: selectedTool.inputSchema
+          },
+          required: ["name", "arguments"]
+        },
+        name: selectedTool.name,
+        description: typeof selectedTool.description === "string" ? selectedTool.description : void 0
+      },
+      providerOptions: {
+        ...baseReturnParams.providerOptions || {},
+        toolCallMiddleware: {
+          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          toolChoice: params.toolChoice
+        }
+      }
+    };
+  }
+  if (((_h = params.toolChoice) == null ? void 0 : _h.type) === "required") {
+    if (!params.tools || params.tools.length === 0) {
+      throw new Error(
+        "Tool choice type 'required' is set, but no tools are provided in params.tools."
+      );
+    }
+    return {
+      ...baseReturnParams,
+      responseFormat: {
+        type: "json",
+        schema: createDynamicIfThenElseSchema(functionTools)
+      },
+      providerOptions: {
+        ...baseReturnParams.providerOptions || {},
+        toolCallMiddleware: {
+          ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+          // INTERNAL: used by the middleware to activate the tool-choice
+          // fast-path in handlers. Not a stable public API.
+          toolChoice: { type: "required" }
+        }
+      }
+    };
+  }
+  return baseReturnParams;
+}
+function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+  const processedPrompt = prompt.map((message) => {
+    var _a;
+    if (message.role === "assistant") {
+      const newContent = [];
+      for (const content of message.content) {
+        if (isToolCallContent(content)) {
+          newContent.push({
+            type: "text",
+            text: resolvedProtocol.formatToolCall(content)
+          });
+        } else if (content.type === "text") {
+          newContent.push(content);
+        } else if (content.type === "reasoning") {
+          newContent.push(content);
+        } else {
+          const options = extractOnErrorOption(providerOptions);
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+            options,
+            "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+            { content }
+          );
+          newContent.push({
+            type: "text",
+            text: JSON.stringify(content)
+          });
+        }
+      }
+      const onlyText = newContent.every((c) => c.type === "text");
+      const condensedAssistant = onlyText ? [
+        {
+          type: "text",
+          text: newContent.map((c) => c.text).join("\n")
+        }
+      ] : newContent;
+      return { role: "assistant", content: condensedAssistant };
+    }
+    if (message.role === "tool") {
+      return {
+        role: "user",
+        // Map tool results to text response blocks, then condense into a single text block
+        content: [
+          {
+            type: "text",
+            text: message.content.map(
+              (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
+                toolResult
+              )
+            ).join("\n")
+          }
+        ]
+      };
+    }
+    return message;
+  });
+  for (let i = 0; i < processedPrompt.length; i++) {
+    const msg = processedPrompt[i];
+    if (Array.isArray(msg.content)) {
+      const allText = msg.content.every(
+        (c) => (c == null ? void 0 : c.type) === "text"
+      );
+      if (allText && msg.content.length > 1) {
+        const joinedText = msg.content.map((c) => c.text).join("\n");
+        if (msg.role === "system") {
+          processedPrompt[i] = {
+            role: "system",
+            content: joinedText
+          };
+        } else if (msg.role === "assistant") {
+          processedPrompt[i] = {
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: joinedText
+              }
+            ]
+          };
+        } else {
+          processedPrompt[i] = {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: joinedText
+              }
+            ]
+          };
+        }
+      }
+    }
+  }
+  for (let i = processedPrompt.length - 1; i > 0; i--) {
+    const current = processedPrompt[i];
+    const prev = processedPrompt[i - 1];
+    if (current.role === "user" && prev.role === "user") {
+      const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+      const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+      processedPrompt[i - 1] = {
+        role: "user",
+        content: [{ type: "text", text: prevContent + "\n" + currentContent }]
+      };
+      processedPrompt.splice(i, 1);
+    }
+  }
+  return processedPrompt;
+}
+
+// src/tool-call-middleware.ts
+function createToolMiddleware({
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream, doGenerate, params }) => {
+      if (isToolChoiceActive(params)) {
+        return toolChoiceStream({
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
+        });
+      } else {
+        return wrapStream({
+          protocol: resolvedProtocol,
+          doStream,
+          doGenerate,
+          params
+        });
+      }
+    },
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({
+      params
+    }) => {
+      return transformParams({
+        protocol: resolvedProtocol,
+        toolSystemPromptTemplate,
+        params
+      });
+    }
+  };
+}
 
 // src/index.ts
 var gemmaToolMiddleware = createToolMiddleware({
@@ -1562,8 +2244,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```"
     }
@@ -1594,15 +2277,16 @@ 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 KorinAI, a function-calling AI model.
+    return `You are a function calling AI model.
 You are provided with function signatures within <tools></tools> XML tags.
 You may call one or more functions to assist with the user query.
 Don't make assumptions about what values to plug into functions.
 Here are the available tools: <tools>${tools}</tools>
-For each function call return a tool call in an XML tag that matches the tool's name, and nothing else.
-Example KorinAI-style call (text form):
+For a function call, return exactly one XML element whose tag name matches the tool's name, and nothing else.
+When an argument is an array, write each item inside a single element on one line separated by commas (or provide a JSON-like list). When an argument is an object, provide a JSON-like value.
+Examples:
 <get_weather>
 <location>
 San Fransisco
@@ -1615,7 +2299,7 @@ export {
   gemmaToolMiddleware,
   hermesToolMiddleware,
   jsonMixProtocol,
-  xmlProtocol,
+  morphXmlProtocol,
   xmlToolMiddleware
 };
 //# sourceMappingURL=index.js.map