@ai-sdk-tool/parser 4.0.1 → 4.1.1

package/dist/{chunk-DPGORNPB.js → chunk-722D5BGD.js}

@@ -1,16 +1,19 @@
 import {
   escapeRegExp,
+  escapeXmlMinimalAttr,
+  escapeXmlMinimalText,
   parse as parse2,
-  stringify
-} from "./chunk-76E6H46R.js";
+  stringify,
+  unescapeXml
+} from "./chunk-D4YULTAO.js";
 import {
   parse
-} from "./chunk-IX4FJELL.js";
+} from "./chunk-QBZNMO5C.js";
 import {
   coerceBySchema,
   getSchemaType,
   unwrapJsonSchema
-} from "./chunk-DJB4DAZO.js";
+} from "./chunk-GMTE7BY5.js";
 
 // src/core/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -219,6 +222,12 @@ function generateToolCallId() {
 }
 
 // src/core/utils/protocol-utils.ts
+function formatToolsWithPromptTemplate(options) {
+  return options.toolSystemPromptTemplate(options.tools || []);
+}
+function extractToolNames(tools) {
+  return tools.map((tool) => tool.name).filter(Boolean);
+}
 function addTextSegment(text, processedElements) {
   if (text.trim()) {
     processedElements.push({ type: "text", text });
@@ -257,10 +266,222 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
   };
 }
 
-// src/core/protocols/json-protocol.ts
+// src/core/utils/streamed-tool-input-delta.ts
+function emitDelta({
+  controller,
+  id,
+  state,
+  nextInput
+}) {
+  if (!nextInput.startsWith(state.emittedInput)) {
+    return false;
+  }
+  const delta = nextInput.slice(state.emittedInput.length);
+  if (delta.length === 0) {
+    return false;
+  }
+  controller.enqueue({
+    type: "tool-input-delta",
+    id,
+    delta
+  });
+  state.emittedInput = nextInput;
+  return true;
+}
+function toIncompleteJsonPrefix(fullJson) {
+  const trimmed = fullJson.trim();
+  let prefix = trimmed;
+  while (prefix.endsWith("}") || prefix.endsWith("]")) {
+    prefix = prefix.slice(0, -1);
+  }
+  prefix = prefix.trimEnd();
+  if (prefix.endsWith('"')) {
+    prefix = prefix.slice(0, -1);
+  }
+  if (prefix.length === 0) {
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+      return trimmed.startsWith("{") ? "{" : "[";
+    }
+    if (trimmed.startsWith("]")) {
+      return "[";
+    }
+    if (trimmed.startsWith("}")) {
+      return "{";
+    }
+    if (trimmed.startsWith('"')) {
+      return '"';
+    }
+    return "{";
+  }
+  return prefix;
+}
+function emitPrefixDelta(params) {
+  return emitDelta({
+    ...params,
+    nextInput: params.candidate
+  });
+}
+var DEFAULT_TOOL_INPUT_DELTA_CHUNK_CHARS = 512;
+function emitChunkedPrefixDelta(params) {
+  const { maxChunkChars = DEFAULT_TOOL_INPUT_DELTA_CHUNK_CHARS } = params;
+  if (maxChunkChars <= 0) {
+    return emitPrefixDelta(params);
+  }
+  const growth = params.candidate.length - params.state.emittedInput.length;
+  if (growth <= 0) {
+    return false;
+  }
+  if (growth <= maxChunkChars) {
+    return emitPrefixDelta(params);
+  }
+  let emittedAny = false;
+  let cursor = params.state.emittedInput.length + maxChunkChars;
+  while (cursor < params.candidate.length) {
+    const didEmit = emitPrefixDelta({
+      controller: params.controller,
+      id: params.id,
+      state: params.state,
+      candidate: params.candidate.slice(0, cursor)
+    });
+    if (!didEmit) {
+      return emittedAny;
+    }
+    emittedAny = true;
+    cursor += maxChunkChars;
+  }
+  return emitPrefixDelta({
+    controller: params.controller,
+    id: params.id,
+    state: params.state,
+    candidate: params.candidate
+  }) || emittedAny;
+}
+function emitFinalRemainder(params) {
+  var _a;
+  const result = emitDelta({
+    ...params,
+    nextInput: params.finalFullJson
+  });
+  if (!result && params.state.emittedInput.length > 0) {
+    (_a = params.onMismatch) == null ? void 0 : _a.call(
+      params,
+      "Final JSON does not extend emitted tool-input prefix",
+      {
+        emittedLength: params.state.emittedInput.length,
+        finalLength: params.finalFullJson.length
+      }
+    );
+  }
+  return result;
+}
+
+// src/core/utils/tool-call-coercion.ts
+function coerceToolCallInput(toolName, input, tools) {
+  var _a;
+  let args = {};
+  if (typeof input === "string") {
+    try {
+      args = JSON.parse(input);
+    } catch (e) {
+      return;
+    }
+  } else if (input && typeof input === "object") {
+    args = input;
+  } else {
+    return;
+  }
+  const schema = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return JSON.stringify(coerced != null ? coerced : {});
+}
+function coerceToolCallPart(part, tools) {
+  const coercedInput = coerceToolCallInput(part.toolName, part.input, tools);
+  if (coercedInput === void 0) {
+    return part;
+  }
+  return {
+    ...part,
+    input: coercedInput
+  };
+}
+
+// src/core/utils/tool-input-streaming.ts
+function stringifyToolInputWithSchema(options) {
+  var _a;
+  const coerced = coerceToolCallInput(
+    options.toolName,
+    options.args,
+    options.tools
+  );
+  if (coerced !== void 0) {
+    return coerced;
+  }
+  if (options.fallback) {
+    return options.fallback(options.args);
+  }
+  return JSON.stringify((_a = options.args) != null ? _a : {});
+}
+function emitToolInputProgressDelta(options) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "incomplete-json-prefix";
+  const candidate = mode === "full-json" ? options.fullInput : toIncompleteJsonPrefix(options.fullInput);
+  return emitChunkedPrefixDelta({
+    controller: options.controller,
+    id: options.id,
+    state: options.state,
+    candidate
+  });
+}
+function enqueueToolInputEndAndCall(options) {
+  enqueueToolInputEnd({
+    controller: options.controller,
+    id: options.id
+  });
+  options.controller.enqueue({
+    type: "tool-call",
+    toolCallId: options.id,
+    toolName: options.toolName,
+    input: options.input
+  });
+}
+function enqueueToolInputEnd(options) {
+  options.controller.enqueue({
+    type: "tool-input-end",
+    id: options.id
+  });
+}
+function emitFailedToolInputLifecycle(options) {
+  var _a;
+  if (options.endInput !== false) {
+    enqueueToolInputEnd({
+      controller: options.controller,
+      id: options.id
+    });
+  }
+  if (options.emitRawToolCallTextOnError && typeof options.rawToolCallText === "string" && options.rawToolCallText.length > 0) {
+    (_a = options.emitRawText) == null ? void 0 : _a.call(options, options.rawToolCallText);
+  }
+}
+function emitFinalizedToolInputLifecycle(options) {
+  emitFinalRemainder({
+    controller: options.controller,
+    id: options.id,
+    state: options.state,
+    finalFullJson: options.finalInput,
+    onMismatch: options.onMismatch
+  });
+  enqueueToolInputEndAndCall({
+    controller: options.controller,
+    id: options.id,
+    toolName: options.toolName,
+    input: options.finalInput
+  });
+}
 function shouldEmitRawToolCallTextOnError(options) {
   return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
 }
+
+// src/core/protocols/hermes-protocol.ts
 function canonicalizeToolInput(argumentsValue) {
   return JSON.stringify(argumentsValue != null ? argumentsValue : {});
 }
@@ -524,19 +745,13 @@ function emitToolInputDelta(state, controller, fullInput) {
   if (!active) {
     return;
   }
-  if (!fullInput.startsWith(active.emittedInput)) {
-    return;
-  }
-  const delta = fullInput.slice(active.emittedInput.length);
-  if (delta.length === 0) {
-    return;
-  }
-  controller.enqueue({
-    type: "tool-input-delta",
+  emitToolInputProgressDelta({
+    controller,
     id: active.id,
-    delta
+    state: active,
+    fullInput,
+    mode: "full-json"
   });
-  active.emittedInput = fullInput;
 }
 function closeToolInput(state, controller) {
   if (!state.activeToolInput) {
@@ -548,11 +763,16 @@ function closeToolInput(state, controller) {
   });
   state.activeToolInput = null;
 }
-function emitToolCallFromParsed(state, controller, parsedToolCall) {
+function emitToolCallFromParsed(state, controller, parsedToolCall, tools) {
   var _a, _b, _c, _d;
   closeTextBlock(state, controller);
   const toolName = typeof parsedToolCall.name === "string" ? parsedToolCall.name : (_b = (_a = state.activeToolInput) == null ? void 0 : _a.toolName) != null ? _b : "unknown";
-  const input = canonicalizeToolInput(parsedToolCall.arguments);
+  const input = stringifyToolInputWithSchema({
+    toolName,
+    args: parsedToolCall.arguments,
+    tools,
+    fallback: canonicalizeToolInput
+  });
   ensureToolInputStart(state, controller, toolName);
   emitToolInputDelta(state, controller, input);
   const toolCallId = (_d = (_c = state.activeToolInput) == null ? void 0 : _c.id) != null ? _d : generateToolCallId();
@@ -564,18 +784,23 @@ function emitToolCallFromParsed(state, controller, parsedToolCall) {
     input
   });
 }
-function canonicalizeArgumentsProgressInput(progress) {
+function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
   if (progress.argumentsText === void 0 || !progress.argumentsComplete) {
     return void 0;
   }
   try {
     const parsedArguments = parse(progress.argumentsText);
-    return canonicalizeToolInput(parsedArguments);
+    return stringifyToolInputWithSchema({
+      toolName,
+      args: parsedArguments,
+      tools,
+      fallback: canonicalizeToolInput
+    });
   } catch (e) {
     return void 0;
   }
 }
-function emitToolInputProgress(state, controller) {
+function emitToolInputProgress(state, controller, tools) {
   if (!(state.isInsideToolCall && state.currentToolCallJson)) {
     return;
   }
@@ -584,7 +809,11 @@ function emitToolInputProgress(state, controller) {
     return;
   }
   ensureToolInputStart(state, controller, progress.toolName);
-  const canonicalProgressInput = canonicalizeArgumentsProgressInput(progress);
+  const canonicalProgressInput = canonicalizeArgumentsProgressInput(
+    progress,
+    progress.toolName,
+    tools
+  );
   if (canonicalProgressInput !== void 0) {
     emitToolInputDelta(state, controller, canonicalProgressInput);
   }
@@ -619,7 +848,7 @@ function closeTextBlock(state, controller) {
     state.hasEmittedTextStart = false;
   }
 }
-function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer, options) {
+function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer, tools, options) {
   var _a;
   if (!state.currentToolCallJson && trailingBuffer.length === 0) {
     state.isInsideToolCall = false;
@@ -628,7 +857,7 @@ function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer
   if (state.currentToolCallJson) {
     try {
       const parsedToolCall = parse(state.currentToolCallJson);
-      emitToolCallFromParsed(state, controller, parsedToolCall);
+      emitToolCallFromParsed(state, controller, parsedToolCall, tools);
       state.currentToolCallJson = "";
       state.isInsideToolCall = false;
       return;
@@ -668,7 +897,7 @@ function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer
   state.currentToolCallJson = "";
   state.isInsideToolCall = false;
 }
-function handleFinishChunk(state, controller, toolCallStart, options, chunk) {
+function handleFinishChunk(state, controller, toolCallStart, tools, options, chunk) {
   if (state.isInsideToolCall) {
     const trailingBuffer = state.buffer;
     state.buffer = "";
@@ -677,6 +906,7 @@ function handleFinishChunk(state, controller, toolCallStart, options, chunk) {
       controller,
       toolCallStart,
       trailingBuffer,
+      tools,
       options
     );
   } else if (state.buffer.length > 0) {
@@ -685,11 +915,11 @@ function handleFinishChunk(state, controller, toolCallStart, options, chunk) {
   closeTextBlock(state, controller);
   controller.enqueue(chunk);
 }
-function publishText(text, state, controller) {
+function publishText(text, state, controller, tools) {
   if (state.isInsideToolCall) {
     closeTextBlock(state, controller);
     state.currentToolCallJson += text;
-    emitToolInputProgress(state, controller);
+    emitToolInputProgress(state, controller, tools);
   } else if (text.length > 0) {
     if (!state.currentTextId) {
       state.currentTextId = generateId();
@@ -708,10 +938,10 @@ function publishText(text, state, controller) {
 }
 function emitToolCall(context) {
   var _a;
-  const { state, controller, toolCallStart, toolCallEnd, options } = context;
+  const { state, controller, toolCallStart, toolCallEnd, options, tools } = context;
   try {
     const parsedToolCall = parse(state.currentToolCallJson);
-    emitToolCallFromParsed(state, controller, parsedToolCall);
+    emitToolCallFromParsed(state, controller, parsedToolCall, tools);
   } catch (error) {
     const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
     const shouldEmitRawFallback = shouldEmitRawToolCallTextOnError(options);
@@ -760,7 +990,7 @@ function processTagMatch(context) {
   }
 }
 function processBufferTags(context) {
-  const { state, controller, toolCallStart, toolCallEnd } = context;
+  const { state, controller, toolCallStart, toolCallEnd, tools } = context;
   let startIndex = getPotentialStartIndex(
     state.buffer,
     state.isInsideToolCall ? toolCallEnd : toolCallStart
@@ -770,7 +1000,7 @@ function processBufferTags(context) {
     if (startIndex + tag.length > state.buffer.length) {
       break;
     }
-    publishText(state.buffer.slice(0, startIndex), state, controller);
+    publishText(state.buffer.slice(0, startIndex), state, controller, tools);
     state.buffer = state.buffer.slice(startIndex + tag.length);
     processTagMatch(context);
     startIndex = getPotentialStartIndex(
@@ -779,28 +1009,38 @@ function processBufferTags(context) {
     );
   }
 }
-function handlePartialTag(state, controller, toolCallStart, toolCallEnd) {
+function handlePartialTag(state, controller, toolCallStart, toolCallEnd, tools) {
   if (state.isInsideToolCall) {
     const potentialEndIndex = getPotentialStartIndex(state.buffer, toolCallEnd);
     if (potentialEndIndex != null && potentialEndIndex + toolCallEnd.length > state.buffer.length) {
-      publishText(state.buffer.slice(0, potentialEndIndex), state, controller);
+      publishText(
+        state.buffer.slice(0, potentialEndIndex),
+        state,
+        controller,
+        tools
+      );
       state.buffer = state.buffer.slice(potentialEndIndex);
     } else {
-      publishText(state.buffer, state, controller);
+      publishText(state.buffer, state, controller, tools);
       state.buffer = "";
     }
     return;
   }
   const potentialIndex = getPotentialStartIndex(state.buffer, toolCallStart);
   if (potentialIndex != null && potentialIndex + toolCallStart.length > state.buffer.length) {
-    publishText(state.buffer.slice(0, potentialIndex), state, controller);
+    publishText(
+      state.buffer.slice(0, potentialIndex),
+      state,
+      controller,
+      tools
+    );
     state.buffer = state.buffer.slice(potentialIndex);
   } else {
-    publishText(state.buffer, state, controller);
+    publishText(state.buffer, state, controller, tools);
     state.buffer = "";
   }
 }
-var jsonProtocol = ({
+var hermesProtocol = ({
   toolCallStart = "<tool_call>",
   toolCallEnd = "</tool_call>"
 } = {}) => ({
@@ -808,7 +1048,7 @@ var jsonProtocol = ({
     tools,
     toolSystemPromptTemplate
   }) {
-    return toolSystemPromptTemplate(tools || []);
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
   },
   formatToolCall(toolCall) {
     let args = {};
@@ -854,6 +1094,7 @@ var jsonProtocol = ({
     return processedElements;
   },
   createStreamParser({
+    tools,
     options
   }) {
     const state = {
@@ -868,7 +1109,14 @@ var jsonProtocol = ({
       transform(chunk, controller) {
         var _a;
         if (chunk.type === "finish") {
-          handleFinishChunk(state, controller, toolCallStart, options, chunk);
+          handleFinishChunk(
+            state,
+            controller,
+            toolCallStart,
+            tools,
+            options,
+            chunk
+          );
           return;
         }
         if (chunk.type !== "text-delta") {
@@ -882,9 +1130,10 @@ var jsonProtocol = ({
           controller,
           toolCallStart,
           toolCallEnd,
-          options
+          options,
+          tools
         });
-        handlePartialTag(state, controller, toolCallStart, toolCallEnd);
+        handlePartialTag(state, controller, toolCallStart, toolCallEnd, tools);
       }
     });
   },
@@ -902,92 +1151,10 @@ var jsonProtocol = ({
   }
 });
 
-// src/core/protocols/protocol-interface.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-function isTCMProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
 // src/core/utils/regex-constants.ts
 var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX = /\s/;
 
-// src/core/utils/streamed-tool-input-delta.ts
-function emitDelta({
-  controller,
-  id,
-  state,
-  nextInput
-}) {
-  if (!nextInput.startsWith(state.emittedInput)) {
-    return false;
-  }
-  const delta = nextInput.slice(state.emittedInput.length);
-  if (delta.length === 0) {
-    return false;
-  }
-  controller.enqueue({
-    type: "tool-input-delta",
-    id,
-    delta
-  });
-  state.emittedInput = nextInput;
-  return true;
-}
-function toIncompleteJsonPrefix(fullJson) {
-  const trimmed = fullJson.trim();
-  let prefix = trimmed;
-  while (prefix.endsWith("}") || prefix.endsWith("]")) {
-    prefix = prefix.slice(0, -1);
-  }
-  prefix = prefix.trimEnd();
-  if (prefix.endsWith('"')) {
-    prefix = prefix.slice(0, -1);
-  }
-  if (prefix.length === 0) {
-    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
-      return trimmed.startsWith("{") ? "{" : "[";
-    }
-    if (trimmed.startsWith("]")) {
-      return "[";
-    }
-    if (trimmed.startsWith("}")) {
-      return "{";
-    }
-    if (trimmed.startsWith('"')) {
-      return '"';
-    }
-    return "{";
-  }
-  return prefix;
-}
-function emitPrefixDelta(params) {
-  return emitDelta({
-    ...params,
-    nextInput: params.candidate
-  });
-}
-function emitFinalRemainder(params) {
-  var _a;
-  const result = emitDelta({
-    ...params,
-    nextInput: params.finalFullJson
-  });
-  if (!result && params.state.emittedInput.length > 0) {
-    (_a = params.onMismatch) == null ? void 0 : _a.call(
-      params,
-      "Final JSON does not extend emitted tool-input prefix",
-      {
-        emittedLength: params.state.emittedInput.length,
-        finalLength: params.finalFullJson.length
-      }
-    );
-  }
-  return result;
-}
-
 // src/core/utils/xml-root-repair.ts
 var XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX = /^<([A-Za-z_][A-Za-z0-9_-]*)\s*\r?\n([\s\S]+?)\r?\n\s*\/>\s*$/;
 function tryRepairXmlSelfClosingRootWithBody(rawText, toolNames) {
@@ -1012,18 +1179,244 @@ ${body}
 </${rootTag}>`;
 }
 
-// src/core/protocols/xml-protocol.ts
-function getToolSchema(tools, toolName) {
-  var _a;
-  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-}
-function shouldEmitRawToolCallTextOnError2(options) {
-  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
-}
-function processToolCall(params) {
-  var _a, _b;
-  const { toolCall, tools, options, text, processedElements, parseOptions } = params;
-  const toolSchema = getToolSchema(tools, toolCall.toolName);
+// src/core/utils/xml-tool-tag-scanner.ts
+var selfClosingTagCache = /* @__PURE__ */ new Map();
+function getSelfClosingTagPattern(toolName) {
+  let pattern = selfClosingTagCache.get(toolName);
+  if (!pattern) {
+    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
+    selfClosingTagCache.set(toolName, pattern);
+  }
+  return pattern;
+}
+function findSelfClosingTag(text, toolName, fromIndex) {
+  const pattern = getSelfClosingTagPattern(toolName);
+  pattern.lastIndex = fromIndex;
+  const match = pattern.exec(text);
+  if (!match || match.index === void 0) {
+    return null;
+  }
+  return { index: match.index, length: match[0].length };
+}
+function findNextToolTag(text, searchIndex, toolName) {
+  var _a, _b;
+  const startTag = `<${toolName}>`;
+  const openIdx = text.indexOf(startTag, searchIndex);
+  const selfMatch = findSelfClosingTag(text, toolName, searchIndex);
+  const selfIdx = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
+  if (openIdx === -1 && selfIdx === -1) {
+    return null;
+  }
+  const isSelfClosing = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx);
+  return {
+    tagStart: isSelfClosing ? selfIdx : openIdx,
+    isSelfClosing,
+    tagLength: isSelfClosing ? (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0 : startTag.length
+  };
+}
+function findEarliestToolTag(buffer, toolNames) {
+  var _a, _b;
+  let bestIndex = -1;
+  let bestName = "";
+  let bestSelfClosing = false;
+  let bestTagLength = 0;
+  for (const name of toolNames) {
+    const openTag = `<${name}>`;
+    const idxOpen = buffer.indexOf(openTag);
+    const selfMatch = findSelfClosingTag(buffer, name, 0);
+    const idxSelf = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
+    if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
+      bestIndex = idxOpen;
+      bestName = name;
+      bestSelfClosing = false;
+      bestTagLength = openTag.length;
+    }
+    if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
+      bestIndex = idxSelf;
+      bestName = name;
+      bestSelfClosing = true;
+      bestTagLength = (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0;
+    }
+  }
+  return {
+    index: bestIndex,
+    name: bestName,
+    selfClosing: bestSelfClosing,
+    tagLength: bestTagLength
+  };
+}
+
+// src/core/protocols/morph-xml-stream-state-machine.ts
+function processToolCallInBuffer(params) {
+  const {
+    buffer,
+    currentToolCall,
+    tools,
+    options,
+    controller,
+    flushText,
+    setBuffer,
+    parseOptions,
+    emitToolInputProgress: emitToolInputProgress2,
+    handleStreamingToolCallEnd: handleStreamingToolCallEnd2
+  } = params;
+  const endTagPattern = new RegExp(
+    `</\\s*${escapeRegExp(currentToolCall.name)}\\s*>`
+  );
+  const endMatch = endTagPattern.exec(buffer);
+  if (!endMatch || endMatch.index === void 0) {
+    emitToolInputProgress2(controller, currentToolCall, buffer);
+    return { buffer, currentToolCall, shouldBreak: true };
+  }
+  const endIdx = endMatch.index;
+  const endPos = endIdx + endMatch[0].length;
+  const content = buffer.substring(0, endIdx);
+  emitToolInputProgress2(controller, currentToolCall, content);
+  const remainder = buffer.substring(endPos);
+  setBuffer(remainder);
+  handleStreamingToolCallEnd2({
+    toolContent: content,
+    currentToolCall,
+    tools,
+    options,
+    ctrl: controller,
+    flushText,
+    parseOptions
+  });
+  return {
+    buffer: remainder,
+    currentToolCall: null,
+    shouldBreak: false
+  };
+}
+function processNoToolCallInBuffer(params) {
+  const {
+    buffer,
+    toolNames,
+    controller,
+    flushText,
+    tools,
+    options,
+    parseOptions,
+    setBuffer,
+    emitToolInputStart,
+    findPotentialToolTagStart: findPotentialToolTagStart2,
+    handleStreamingToolCallEnd: handleStreamingToolCallEnd2
+  } = params;
+  const {
+    index: earliestStartTagIndex,
+    name: earliestToolName,
+    selfClosing,
+    tagLength
+  } = findEarliestToolTag(buffer, toolNames);
+  if (earliestStartTagIndex === -1) {
+    const potentialStart = findPotentialToolTagStart2(buffer, toolNames);
+    const safeLen = Math.max(
+      0,
+      potentialStart === -1 ? buffer.length : potentialStart
+    );
+    const remaining = buffer.slice(safeLen);
+    if (safeLen > 0) {
+      flushText(controller, buffer.slice(0, safeLen));
+      setBuffer(remaining);
+    }
+    return {
+      buffer: remaining,
+      currentToolCall: null,
+      shouldBreak: true,
+      shouldContinue: false
+    };
+  }
+  flushText(controller, buffer.substring(0, earliestStartTagIndex));
+  if (selfClosing) {
+    const newBuffer2 = buffer.substring(earliestStartTagIndex + tagLength);
+    setBuffer(newBuffer2);
+    const currentToolCall = emitToolInputStart(controller, earliestToolName);
+    handleStreamingToolCallEnd2({
+      toolContent: "",
+      currentToolCall,
+      tools,
+      options,
+      ctrl: controller,
+      flushText,
+      parseOptions
+    });
+    return {
+      buffer: newBuffer2,
+      currentToolCall: null,
+      shouldBreak: false,
+      shouldContinue: false
+    };
+  }
+  const startTag = `<${earliestToolName}>`;
+  const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
+  setBuffer(newBuffer);
+  return {
+    buffer: newBuffer,
+    currentToolCall: emitToolInputStart(controller, earliestToolName),
+    shouldBreak: false,
+    shouldContinue: true
+  };
+}
+function createProcessBufferHandler(options) {
+  return (controller) => {
+    while (true) {
+      const currentToolCall = options.getCurrentToolCall();
+      if (currentToolCall) {
+        const result = processToolCallInBuffer({
+          buffer: options.getBuffer(),
+          currentToolCall,
+          tools: options.tools,
+          options: options.parserOptions,
+          controller,
+          flushText: options.flushText,
+          setBuffer: options.setBuffer,
+          parseOptions: options.parseOptions,
+          emitToolInputProgress: options.emitToolInputProgress,
+          handleStreamingToolCallEnd: options.handleStreamingToolCallEnd
+        });
+        options.setBuffer(result.buffer);
+        options.setCurrentToolCall(result.currentToolCall);
+        if (result.shouldBreak) {
+          break;
+        }
+      } else {
+        const result = processNoToolCallInBuffer({
+          buffer: options.getBuffer(),
+          toolNames: options.toolNames,
+          controller,
+          flushText: options.flushText,
+          tools: options.tools,
+          options: options.parserOptions,
+          parseOptions: options.parseOptions,
+          setBuffer: options.setBuffer,
+          emitToolInputStart: options.emitToolInputStart,
+          findPotentialToolTagStart: options.findPotentialToolTagStart,
+          handleStreamingToolCallEnd: options.handleStreamingToolCallEnd
+        });
+        options.setBuffer(result.buffer);
+        options.setCurrentToolCall(result.currentToolCall);
+        if (result.shouldBreak) {
+          break;
+        }
+        if (result.shouldContinue) {
+          continue;
+        }
+        break;
+      }
+    }
+  };
+}
+
+// src/core/protocols/morph-xml-protocol.ts
+function getToolSchema(tools, toolName) {
+  var _a;
+  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+}
+function processToolCall(params) {
+  var _a, _b;
+  const { toolCall, tools, options, text, processedElements, parseOptions } = params;
+  const toolSchema = getToolSchema(tools, toolCall.toolName);
   const parseConfig = {
     ...parseOptions != null ? parseOptions : {},
     onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
@@ -1248,6 +1641,76 @@ function schemaAllowsArrayType(schema) {
   }
   return false;
 }
+function schemaAllowsStringType(schema) {
+  if (!schema || typeof schema !== "object") {
+    return false;
+  }
+  const schemaRecord = schema;
+  const typeValue = schemaRecord.type;
+  if (typeValue === "string") {
+    return true;
+  }
+  if (Array.isArray(typeValue) && typeValue.includes("string")) {
+    return true;
+  }
+  const unions = [schemaRecord.anyOf, schemaRecord.oneOf, schemaRecord.allOf];
+  for (const union of unions) {
+    if (!Array.isArray(union)) {
+      continue;
+    }
+    if (union.some((entry) => schemaAllowsStringType(entry))) {
+      return true;
+    }
+  }
+  return false;
+}
+function getObjectSchemaStringPropertyNames(schema) {
+  const propertyNames = getObjectSchemaPropertyNames(schema);
+  if (!propertyNames) {
+    return null;
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const name of propertyNames) {
+    const property = getSchemaObjectProperty(schema, name);
+    if (schemaAllowsStringType(property)) {
+      out.add(name);
+    }
+  }
+  return out;
+}
+function findTrailingUnclosedStringTag(options) {
+  let bestName = null;
+  let bestOpenIndex = -1;
+  for (const name of options.stringPropertyNames) {
+    const openPattern = new RegExp(
+      `<${escapeRegExp(name)}(?:\\s[^>]*)?>`,
+      "gi"
+    );
+    const closePattern = new RegExp(`</\\s*${escapeRegExp(name)}\\s*>`, "gi");
+    let lastOpen = -1;
+    for (const match of options.toolContent.matchAll(openPattern)) {
+      const index = match.index;
+      if (index !== void 0) {
+        lastOpen = index;
+      }
+    }
+    if (lastOpen === -1) {
+      continue;
+    }
+    let lastClose = -1;
+    for (const match of options.toolContent.matchAll(closePattern)) {
+      const index = match.index;
+      if (index !== void 0) {
+        lastClose = index;
+      }
+    }
+    if (lastOpen > lastClose && lastOpen > bestOpenIndex) {
+      bestOpenIndex = lastOpen;
+      bestName = name;
+    }
+  }
+  return bestName;
+}
 function getSchemaObjectProperty(schema, propertyName) {
   if (!schema || typeof schema !== "object") {
     return null;
@@ -1297,8 +1760,10 @@ function isStableXmlProgressCandidate(options) {
 }
 function parseXmlContentForStreamProgress({
   toolContent,
+  toolName,
   toolSchema,
-  parseOptions
+  parseOptions,
+  tools
 }) {
   const tryParse = (content) => {
     try {
@@ -1317,7 +1782,29 @@ function parseXmlContentForStreamProgress({
     parsed: strictFull,
     toolSchema
   })) {
-    return JSON.stringify(strictFull);
+    return stringifyToolInputWithSchema({
+      toolName,
+      args: strictFull,
+      tools
+    });
+  }
+  const stringPropertyNames = getObjectSchemaStringPropertyNames(toolSchema);
+  if (stringPropertyNames && stringPropertyNames.size > 0) {
+    const trailingStringTag = findTrailingUnclosedStringTag({
+      toolContent,
+      stringPropertyNames
+    });
+    if (trailingStringTag) {
+      const repaired = `${toolContent}</${trailingStringTag}>`;
+      const parsedRepaired = tryParse(repaired);
+      if (parsedRepaired !== null) {
+        return stringifyToolInputWithSchema({
+          toolName,
+          args: parsedRepaired,
+          tools
+        });
+      }
+    }
   }
   let searchEnd = toolContent.length;
   while (searchEnd > 0) {
@@ -1336,7 +1823,11 @@ function parseXmlContentForStreamProgress({
       parsed: parsedCandidate,
       toolSchema
     })) {
-      return JSON.stringify(parsedCandidate);
+      return stringifyToolInputWithSchema({
+        toolName,
+        args: parsedCandidate,
+        tools
+      });
     }
     searchEnd = gtIndex;
   }
@@ -1361,37 +1852,35 @@ function handleStreamingToolCallEnd(params) {
   flushText(ctrl);
   try {
     const parsedResult = parse2(toolContent, toolSchema, parseConfig);
-    const finalInput = JSON.stringify(parsedResult);
-    emitFinalRemainder({
+    const finalInput = stringifyToolInputWithSchema({
+      toolName: currentToolCall.name,
+      args: parsedResult,
+      tools
+    });
+    emitFinalizedToolInputLifecycle({
       controller: ctrl,
       id: currentToolCall.toolCallId,
       state: currentToolCall,
-      finalFullJson: finalInput,
-      onMismatch: options == null ? void 0 : options.onError
-    });
-    ctrl.enqueue({
-      type: "tool-input-end",
-      id: currentToolCall.toolCallId
-    });
-    ctrl.enqueue({
-      type: "tool-call",
-      toolCallId: currentToolCall.toolCallId,
       toolName: currentToolCall.name,
-      input: finalInput
+      finalInput,
+      onMismatch: options == null ? void 0 : options.onError
     });
   } catch (error) {
-    ctrl.enqueue({
-      type: "tool-input-end",
-      id: currentToolCall.toolCallId
-    });
     const original = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
+    const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+    emitFailedToolInputLifecycle({
+      controller: ctrl,
+      id: currentToolCall.toolCallId,
+      emitRawToolCallTextOnError: emitRawFallback,
+      rawToolCallText: original,
+      emitRawText: (rawText) => {
+        flushText(ctrl, rawText);
+      }
+    });
     (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "Could not process streaming XML tool call", {
       toolCall: original,
       error
     });
-    if (shouldEmitRawToolCallTextOnError2(options)) {
-      flushText(ctrl, original);
-    }
   }
 }
 function findClosingTagEndFlexible(text, contentStart, toolName) {
@@ -1491,22 +1980,6 @@ function nextTagToken(text, fromPos) {
     nextPos: open.nextPos
   };
 }
-function findNextToolTag(text, searchIndex, toolName) {
-  var _a, _b;
-  const startTag = `<${toolName}>`;
-  const openIdx = text.indexOf(startTag, searchIndex);
-  const selfMatch = findSelfClosingTag(text, toolName, searchIndex);
-  const selfIdx = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
-  if (openIdx === -1 && selfIdx === -1) {
-    return null;
-  }
-  const isSelfClosing = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx);
-  return {
-    tagStart: isSelfClosing ? selfIdx : openIdx,
-    isSelfClosing,
-    tagLength: isSelfClosing ? (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0 : startTag.length
-  };
-}
 function findLastCloseTagStart(segment, toolName) {
   const closeTagPattern = new RegExp(
     `</\\s*${escapeRegExp(toolName)}\\s*>`,
@@ -1534,24 +2007,6 @@ function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, tagLength)
   });
   return endIndex;
 }
-var selfClosingTagCache = /* @__PURE__ */ new Map();
-function getSelfClosingTagPattern(toolName) {
-  let pattern = selfClosingTagCache.get(toolName);
-  if (!pattern) {
-    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
-    selfClosingTagCache.set(toolName, pattern);
-  }
-  return pattern;
-}
-function findSelfClosingTag(text, toolName, fromIndex) {
-  const pattern = getSelfClosingTagPattern(toolName);
-  pattern.lastIndex = fromIndex;
-  const match = pattern.exec(text);
-  if (!match || match.index === void 0) {
-    return null;
-  }
-  return { index: match.index, length: match[0].length };
-}
 function appendOpenToolCallIfComplete(toolCalls, text, toolName, tagStart, startTag) {
   const contentStart = tagStart + startTag.length;
   const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
@@ -1703,39 +2158,6 @@ function findLinePrefixedToolCall(text, toolNames) {
   }
   return best;
 }
-function findEarliestToolTag(buffer, toolNames) {
-  var _a, _b;
-  let bestIndex = -1;
-  let bestName = "";
-  let bestSelfClosing = false;
-  let bestTagLength = 0;
-  if (toolNames.length > 0) {
-    for (const name of toolNames) {
-      const openTag = `<${name}>`;
-      const idxOpen = buffer.indexOf(openTag);
-      const selfMatch = findSelfClosingTag(buffer, name, 0);
-      const idxSelf = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
-      if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
-        bestIndex = idxOpen;
-        bestName = name;
-        bestSelfClosing = false;
-        bestTagLength = openTag.length;
-      }
-      if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
-        bestIndex = idxSelf;
-        bestName = name;
-        bestSelfClosing = true;
-        bestTagLength = (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0;
-      }
-    }
-  }
-  return {
-    index: bestIndex,
-    name: bestName,
-    selfClosing: bestSelfClosing,
-    tagLength: bestTagLength
-  };
-}
 function isOpenTagPrefix(suffix, toolName) {
   return `${toolName}>`.startsWith(suffix);
 }
@@ -1813,160 +2235,6 @@ function findPotentialToolTagStart(buffer, toolNames) {
   }
   return -1;
 }
-function processToolCallInBuffer(params) {
-  const {
-    buffer,
-    currentToolCall,
-    tools,
-    options,
-    controller,
-    flushText,
-    setBuffer,
-    parseOptions,
-    emitToolInputProgress: emitToolInputProgress2
-  } = params;
-  const endTagPattern = new RegExp(
-    `</\\s*${escapeRegExp(currentToolCall.name)}\\s*>`
-  );
-  const endMatch = endTagPattern.exec(buffer);
-  if (!endMatch || endMatch.index === void 0) {
-    emitToolInputProgress2(controller, currentToolCall, buffer);
-    return { buffer, currentToolCall, shouldBreak: true };
-  }
-  const endIdx = endMatch.index;
-  const endPos = endIdx + endMatch[0].length;
-  const content = buffer.substring(0, endIdx);
-  emitToolInputProgress2(controller, currentToolCall, content);
-  const remainder = buffer.substring(endPos);
-  setBuffer(remainder);
-  handleStreamingToolCallEnd({
-    toolContent: content,
-    currentToolCall,
-    tools,
-    options,
-    ctrl: controller,
-    flushText,
-    parseOptions
-  });
-  return {
-    buffer: remainder,
-    currentToolCall: null,
-    shouldBreak: false
-  };
-}
-function processNoToolCallInBuffer(params) {
-  const {
-    buffer,
-    toolNames,
-    controller,
-    flushText,
-    tools,
-    options,
-    parseOptions,
-    setBuffer,
-    emitToolInputStart
-  } = params;
-  const {
-    index: earliestStartTagIndex,
-    name: earliestToolName,
-    selfClosing,
-    tagLength
-  } = findEarliestToolTag(buffer, toolNames);
-  if (earliestStartTagIndex === -1) {
-    const potentialStart = findPotentialToolTagStart(buffer, toolNames);
-    const safeLen = Math.max(
-      0,
-      potentialStart === -1 ? buffer.length : potentialStart
-    );
-    const remaining = buffer.slice(safeLen);
-    if (safeLen > 0) {
-      flushText(controller, buffer.slice(0, safeLen));
-      setBuffer(remaining);
-    }
-    return {
-      buffer: remaining,
-      currentToolCall: null,
-      shouldBreak: true,
-      shouldContinue: false
-    };
-  }
-  flushText(controller, buffer.substring(0, earliestStartTagIndex));
-  if (selfClosing) {
-    const newBuffer2 = buffer.substring(earliestStartTagIndex + tagLength);
-    setBuffer(newBuffer2);
-    const currentToolCall = emitToolInputStart(controller, earliestToolName);
-    handleStreamingToolCallEnd({
-      toolContent: "",
-      currentToolCall,
-      tools,
-      options,
-      ctrl: controller,
-      flushText,
-      parseOptions
-    });
-    return {
-      buffer: newBuffer2,
-      currentToolCall: null,
-      shouldBreak: false,
-      shouldContinue: false
-    };
-  }
-  const startTag = `<${earliestToolName}>`;
-  const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
-  setBuffer(newBuffer);
-  return {
-    buffer: newBuffer,
-    currentToolCall: emitToolInputStart(controller, earliestToolName),
-    shouldBreak: false,
-    shouldContinue: true
-  };
-}
-function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, parseOptions, emitToolInputProgress2, emitToolInputStart) {
-  return (controller) => {
-    while (true) {
-      const currentToolCall = getCurrentToolCall();
-      if (currentToolCall) {
-        const result = processToolCallInBuffer({
-          buffer: getBuffer(),
-          currentToolCall,
-          tools,
-          options,
-          controller,
-          flushText,
-          setBuffer,
-          parseOptions,
-          emitToolInputProgress: emitToolInputProgress2
-        });
-        setBuffer(result.buffer);
-        setCurrentToolCall(result.currentToolCall);
-        if (result.shouldBreak) {
-          break;
-        }
-      } else {
-        const result = processNoToolCallInBuffer({
-          buffer: getBuffer(),
-          toolNames,
-          controller,
-          flushText,
-          tools,
-          options,
-          parseOptions,
-          setBuffer,
-          emitToolInputStart
-        });
-        setBuffer(result.buffer);
-        setCurrentToolCall(result.currentToolCall);
-        if (result.shouldBreak) {
-          break;
-        }
-        if (result.shouldContinue) {
-          continue;
-        }
-        break;
-      }
-    }
-  };
-}
 function findToolCallsWithFallbacks(text, toolNames) {
   let parseText = text;
   let toolCalls = findToolCalls(parseText, toolNames);
@@ -1988,7 +2256,7 @@ function findToolCallsWithFallbacks(text, toolNames) {
   }
   return { parseText, toolCalls };
 }
-var xmlProtocol = (protocolOptions) => {
+var morphXmlProtocol = (protocolOptions) => {
   var _a;
   const parseOptions = {
     repair: true,
@@ -1997,7 +2265,7 @@ var xmlProtocol = (protocolOptions) => {
   };
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      return toolSystemPromptTemplate(tools || []);
+      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
     },
     formatToolCall(toolCall) {
       let args = {};
@@ -2015,7 +2283,7 @@ var xmlProtocol = (protocolOptions) => {
       });
     },
     parseGeneratedText({ text, tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      const toolNames = extractToolNames(tools);
       if (toolNames.length === 0) {
         return [{ type: "text", text }];
       }
@@ -2051,7 +2319,7 @@ var xmlProtocol = (protocolOptions) => {
       return processedElements;
     },
     createStreamParser({ tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      const toolNames = extractToolNames(tools);
       let buffer = "";
       let currentToolCall = null;
       let currentTextId = null;
@@ -2072,6 +2340,7 @@ var xmlProtocol = (protocolOptions) => {
           name: toolName,
           toolCallId: generateToolCallId(),
           emittedInput: "",
+          lastProgressContentLength: null,
           lastProgressGtIndex: null,
           lastProgressFullInput: null
         };
@@ -2084,7 +2353,8 @@ var xmlProtocol = (protocolOptions) => {
       };
       const emitToolInputProgress2 = (controller, toolCall, toolContent) => {
         const progressGtIndex = toolContent.lastIndexOf(">");
-        if (toolCall.lastProgressGtIndex === progressGtIndex) {
+        const progressContentLength = toolContent.length;
+        if (toolCall.lastProgressGtIndex === progressGtIndex && toolCall.lastProgressContentLength === progressContentLength) {
           const cached = toolCall.lastProgressFullInput;
           if (cached == null) {
             return;
@@ -2092,22 +2362,24 @@ var xmlProtocol = (protocolOptions) => {
           if (cached === "{}" && toolContent.trim().length === 0) {
             return;
           }
-          const prefixCandidate2 = toIncompleteJsonPrefix(cached);
-          emitPrefixDelta({
+          emitToolInputProgressDelta({
             controller,
             id: toolCall.toolCallId,
             state: toolCall,
-            candidate: prefixCandidate2
+            fullInput: cached
           });
           return;
         }
         const toolSchema = getToolSchema(tools, toolCall.name);
         const fullInput = parseXmlContentForStreamProgress({
           toolContent,
+          toolName: toolCall.name,
           toolSchema,
-          parseOptions
+          parseOptions,
+          tools
         });
         toolCall.lastProgressGtIndex = progressGtIndex;
+        toolCall.lastProgressContentLength = progressContentLength;
         toolCall.lastProgressFullInput = fullInput;
         if (fullInput == null) {
           return;
@@ -2115,12 +2387,11 @@ var xmlProtocol = (protocolOptions) => {
         if (fullInput === "{}" && toolContent.trim().length === 0) {
           return;
         }
-        const prefixCandidate = toIncompleteJsonPrefix(fullInput);
-        emitPrefixDelta({
+        emitToolInputProgressDelta({
           controller,
           id: toolCall.toolCallId,
           state: toolCall,
-          candidate: prefixCandidate
+          fullInput
         });
       };
       const finalizeUnclosedToolCall = (controller) => {
@@ -2142,59 +2413,59 @@ var xmlProtocol = (protocolOptions) => {
             );
           }
           const parsedResult = parse2(buffer, toolSchema, parseConfig);
-          const finalInput = JSON.stringify(parsedResult);
-          emitFinalRemainder({
+          const finalInput = stringifyToolInputWithSchema({
+            toolName: currentToolCall.name,
+            args: parsedResult,
+            tools
+          });
+          emitFinalizedToolInputLifecycle({
             controller,
             id: currentToolCall.toolCallId,
             state: currentToolCall,
-            finalFullJson: finalInput,
-            onMismatch: options == null ? void 0 : options.onError
-          });
-          controller.enqueue({
-            type: "tool-input-end",
-            id: currentToolCall.toolCallId
-          });
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId: currentToolCall.toolCallId,
             toolName: currentToolCall.name,
-            input: finalInput
+            finalInput,
+            onMismatch: options == null ? void 0 : options.onError
           });
         } catch (error) {
-          controller.enqueue({
-            type: "tool-input-end",
-            id: currentToolCall.toolCallId
-          });
           const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
+          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+          emitFailedToolInputLifecycle({
+            controller,
+            id: currentToolCall.toolCallId,
+            emitRawToolCallTextOnError: emitRawFallback,
+            rawToolCallText: unfinishedContent,
+            emitRawText: (rawText) => {
+              flushText(controller, rawText);
+            }
+          });
           (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
             options,
             "Could not complete streaming XML tool call at finish.",
             { toolCall: unfinishedContent, error }
           );
-          if (shouldEmitRawToolCallTextOnError2(options)) {
-            flushText(controller, unfinishedContent);
-          }
         }
         buffer = "";
         currentToolCall = null;
       };
-      const processBuffer = createProcessBufferHandler(
-        () => buffer,
-        (newBuffer) => {
+      const processBuffer = createProcessBufferHandler({
+        getBuffer: () => buffer,
+        setBuffer: (newBuffer) => {
           buffer = newBuffer;
         },
-        () => currentToolCall,
-        (newToolCall) => {
+        getCurrentToolCall: () => currentToolCall,
+        setCurrentToolCall: (newToolCall) => {
           currentToolCall = newToolCall;
         },
         tools,
-        options,
+        parserOptions: options,
         toolNames,
         flushText,
         parseOptions,
-        emitToolInputProgress2,
-        emitToolInputStart
-      );
+        emitToolInputProgress: emitToolInputProgress2,
+        emitToolInputStart,
+        findPotentialToolTagStart,
+        handleStreamingToolCallEnd
+      });
       return new TransformStream({
         // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Stateful stream parsing requires branching over chunk lifecycle and parser states.
         transform(chunk, controller) {
@@ -2230,41 +2501,1950 @@ var xmlProtocol = (protocolOptions) => {
             flushText(controller, buffer);
             buffer = "";
           }
-          if (currentTextId && hasEmittedTextStart) {
-            controller.enqueue({
-              type: "text-end",
-              id: currentTextId
-            });
-            hasEmittedTextStart = false;
-            currentTextId = null;
+          if (currentTextId && hasEmittedTextStart) {
+            controller.enqueue({
+              type: "text-end",
+              id: currentTextId
+            });
+            hasEmittedTextStart = false;
+            currentTextId = null;
+          }
+        }
+      });
+    },
+    extractToolCallSegments({ text, tools }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [];
+      }
+      return findToolCalls(text, toolNames).map((tc) => tc.segment);
+    }
+  };
+};
+
+// src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+var isTCMProtocolFactory = isProtocolFactory;
+
+// src/core/protocols/qwen3coder-stream-call-content.ts
+function consumeToolNameTag(options) {
+  var _a, _b, _c, _d;
+  if (options.callState.toolName) {
+    return options.work;
+  }
+  const match = options.nameTagRe.exec(options.work);
+  if (!match) {
+    return options.work;
+  }
+  const value = options.normalizeXmlTextValue((_a = match[2]) != null ? _a : "");
+  if (value.trim().length > 0) {
+    options.callState.toolName = value;
+  }
+  const start = (_b = match.index) != null ? _b : 0;
+  const consumedLength = (_d = (_c = match[0]) == null ? void 0 : _c.length) != null ? _d : 0;
+  const nextWork = options.work.slice(0, start) + options.work.slice(start + consumedLength);
+  options.maybeEmitToolInputStart();
+  return nextWork;
+}
+function consumeSingleParamTag(options) {
+  var _a;
+  const parsed = options.parseParamTagAt(
+    options.work,
+    options.lower,
+    options.lt,
+    {
+      allowEndOfString: options.allowEndOfString,
+      callEndTagNameLower: options.callState.endTagName
+    }
+  );
+  if (!parsed) {
+    return {
+      nextIndex: options.lt + 1,
+      nextLastKept: options.lastKept,
+      shouldStop: false
+    };
+  }
+  if (parsed.kind === "partial") {
+    if (parsed.name !== void 0) {
+      options.callState.partialParam = {
+        name: parsed.name,
+        value: (_a = parsed.value) != null ? _a : ""
+      };
+    }
+    return {
+      nextIndex: options.lt + 1,
+      nextLastKept: options.lastKept,
+      shouldStop: true
+    };
+  }
+  options.callState.partialParam = null;
+  options.mergeParamValue(options.callState.args, parsed.name, parsed.value);
+  return {
+    keepSlice: options.work.slice(options.lastKept, parsed.start),
+    nextIndex: parsed.end,
+    nextLastKept: parsed.end,
+    shouldStop: false
+  };
+}
+function consumeParamTags(options) {
+  const lower = options.work.toLowerCase();
+  let index = 0;
+  let lastKept = 0;
+  let pieces = null;
+  while (true) {
+    const lt = lower.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const step = consumeSingleParamTag({
+      allowEndOfString: options.allowEndOfString,
+      callState: options.callState,
+      lower,
+      lt,
+      work: options.work,
+      lastKept,
+      parseParamTagAt: options.parseParamTagAt,
+      mergeParamValue: options.mergeParamValue
+    });
+    if (step.keepSlice !== void 0) {
+      pieces != null ? pieces : pieces = [];
+      pieces.push(step.keepSlice);
+    }
+    index = step.nextIndex;
+    lastKept = step.nextLastKept;
+    if (step.shouldStop) {
+      break;
+    }
+  }
+  options.maybeEmitToolInputStart();
+  if (!pieces) {
+    return options.work;
+  }
+  pieces.push(options.work.slice(lastKept));
+  return pieces.join("");
+}
+function parseCallContent(options) {
+  let work = options.content;
+  work = consumeToolNameTag({
+    callState: options.callState,
+    work,
+    nameTagRe: options.nameTagRe,
+    normalizeXmlTextValue: options.normalizeXmlTextValue,
+    maybeEmitToolInputStart: options.maybeEmitToolInputStart
+  });
+  work = consumeParamTags({
+    callState: options.callState,
+    work,
+    allowEndOfString: options.allowEndOfString,
+    parseParamTagAt: options.parseParamTagAt,
+    mergeParamValue: options.mergeParamValue,
+    maybeEmitToolInputStart: options.maybeEmitToolInputStart
+  });
+  options.maybeEmitToolInputStart();
+  options.maybeEmitToolInputProgress();
+  return work;
+}
+
+// src/core/protocols/qwen3coder-protocol.ts
+var TOOL_CALL_OPEN_RE = /<tool_call\b[^>]*>/i;
+var TOOL_CALL_CLOSE_RE = /<\/tool_call\s*>/i;
+var TOOL_CALL_CLOSE_TRAILING_RE = /<\/tool_call\s*>\s*$/i;
+var TOOL_CALL_BLOCK_RE = /<tool_call\b[^>]*>[\s\S]*?<\/tool_call\s*>/gi;
+var LEADING_CALL_CLOSE_TAG_RE = /^\s*<\s*\/\s*(?:tool_call|function|call|tool|invoke)\s*>/i;
+var CALL_BLOCK_RE = /<(call|function|tool|invoke)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+var QWEN3CODER_TOOL_PARSER_PARAM_TAG_NAMES = /* @__PURE__ */ new Set([
+  "parameter",
+  "param",
+  "argument",
+  "arg"
+]);
+var QWEN3CODER_TOOL_PARSER_CALL_TAG_NAMES = /* @__PURE__ */ new Set([
+  "function",
+  "call",
+  "tool",
+  "invoke",
+  "tool_call"
+]);
+var CALL_SHORTHAND_VALUE_RE = /^<\s*(call|function|tool|invoke)\b\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+))/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b[^>]*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_TOOL_CALL_CLOSE_TAG_RE = /<\s*\/\s*tool_call\s*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE = /<\s*(?!\/)\s*(name|tool_name|parameter|param|argument|arg)\b/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_NAME_TAG_RE = /<\s*(name|tool_name)\b[^>]*>([\s\S]*?)<\s*\/\s*\1\s*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE = /\/\s*>$/;
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "	" || ch === "\f";
+}
+function skipAsciiWhitespace(text, index) {
+  var _a;
+  let i = index;
+  while (i < text.length && isAsciiWhitespace((_a = text[i]) != null ? _a : "")) {
+    i += 1;
+  }
+  return i;
+}
+function stripLeadingToolCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const start = skipAsciiWhitespace(out, 0);
+    const trimmed = out.slice(start);
+    const match = TOOL_CALL_CLOSE_RE.exec(trimmed);
+    if (!match || match.index !== 0 || !match[0]) {
+      return out;
+    }
+    out = out.slice(start + match[0].length);
+  }
+}
+function stripTrailingToolCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const next = out.replace(TOOL_CALL_CLOSE_TRAILING_RE, "");
+    if (next === out) {
+      return out;
+    }
+    out = next;
+  }
+}
+function isTagBoundaryChar(ch) {
+  return ch === "" || isAsciiWhitespace(ch) || ch === ">" || ch === "/";
+}
+function findTagEndIndex(text, startIndex) {
+  var _a;
+  let quote = null;
+  for (let i = startIndex; i < text.length; i += 1) {
+    const ch = (_a = text[i]) != null ? _a : "";
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") {
+      return i;
+    }
+  }
+  return null;
+}
+function parseShorthandValue(openTag, tagNameLower) {
+  var _a, _b;
+  let i = 1;
+  i = skipAsciiWhitespace(openTag, i);
+  if (!openTag.toLowerCase().startsWith(tagNameLower, i)) {
+    return null;
+  }
+  i += tagNameLower.length;
+  i = skipAsciiWhitespace(openTag, i);
+  if (openTag[i] !== "=") {
+    return null;
+  }
+  i += 1;
+  i = skipAsciiWhitespace(openTag, i);
+  const quote = (_a = openTag[i]) != null ? _a : "";
+  if (quote === '"' || quote === "'") {
+    const end = openTag.indexOf(quote, i + 1);
+    if (end === -1) {
+      return null;
+    }
+    return openTag.slice(i + 1, end);
+  }
+  const start = i;
+  while (i < openTag.length) {
+    const ch = (_b = openTag[i]) != null ? _b : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/") {
+      break;
+    }
+    i += 1;
+  }
+  const value = openTag.slice(start, i);
+  return value.length > 0 ? value : null;
+}
+function parseQwen3CoderToolParserParamName(openTag, tagNameLower) {
+  const shorthand = parseShorthandValue(openTag, tagNameLower);
+  if (shorthand != null) {
+    return unescapeXml(shorthand);
+  }
+  return getAttributeValue(openTag, "name");
+}
+function getCdataSectionNextIndex(textLower, startIndex) {
+  if (!textLower.startsWith("<![cdata[", startIndex)) {
+    return startIndex;
+  }
+  const cdataEnd = textLower.indexOf("]]>", startIndex + "<![cdata[".length);
+  if (cdataEnd === -1) {
+    return null;
+  }
+  return cdataEnd + 3;
+}
+function parseMatchingTagHeader(textLower, lt, tagNameLower) {
+  var _a;
+  let i = skipAsciiWhitespace(textLower, lt + 1);
+  const isClosing = textLower[i] === "/";
+  if (isClosing) {
+    i += 1;
+    i = skipAsciiWhitespace(textLower, i);
+  }
+  if (!textLower.startsWith(tagNameLower, i)) {
+    return null;
+  }
+  const afterName = i + tagNameLower.length;
+  const boundary = (_a = textLower[afterName]) != null ? _a : "";
+  const validBoundary = isClosing ? isTagBoundaryChar(boundary) : isTagBoundaryChar(boundary) || boundary === "=";
+  if (boundary && !validBoundary) {
+    return null;
+  }
+  return { isClosing, afterName };
+}
+function isSelfClosingXmlTag(textLower, lt, gt) {
+  return textLower.slice(lt, gt + 1).trimEnd().endsWith("/>");
+}
+function findClosingTagEnd(textLower, startIndex, tagNameLower) {
+  let depth = 1;
+  let index = startIndex;
+  while (true) {
+    const lt = textLower.indexOf("<", index);
+    if (lt === -1) {
+      return null;
+    }
+    const cdataNextIndex = getCdataSectionNextIndex(textLower, lt);
+    if (cdataNextIndex == null) {
+      return null;
+    }
+    if (cdataNextIndex !== lt) {
+      index = cdataNextIndex;
+      continue;
+    }
+    const header = parseMatchingTagHeader(textLower, lt, tagNameLower);
+    if (!header) {
+      index = lt + 1;
+      continue;
+    }
+    const gt = textLower.indexOf(">", header.afterName);
+    if (gt === -1) {
+      return null;
+    }
+    if (header.isClosing) {
+      depth -= 1;
+      if (depth === 0) {
+        return { start: lt, end: gt + 1 };
+      }
+      index = gt + 1;
+      continue;
+    }
+    const isSelfClosing = isSelfClosingXmlTag(textLower, lt, gt);
+    if (!isSelfClosing) {
+      depth += 1;
+    }
+    index = gt + 1;
+  }
+}
+function findClosingTagStartWithBoundary(lowerText, valueStart, tagNameLower, allowEndOfStringBoundary) {
+  var _a;
+  const needle = `</${tagNameLower}`;
+  let searchIndex = valueStart;
+  while (searchIndex < lowerText.length) {
+    const found = lowerText.indexOf(needle, searchIndex);
+    if (found === -1) {
+      return -1;
+    }
+    const nextChar = (_a = lowerText[found + needle.length]) != null ? _a : "";
+    if (nextChar === "" && !allowEndOfStringBoundary) {
+      searchIndex = found + needle.length;
+      continue;
+    }
+    if (isTagBoundaryChar(nextChar)) {
+      return found;
+    }
+    searchIndex = found + needle.length;
+  }
+  return -1;
+}
+function toSupportedCallEndTagName(tagNameLower) {
+  var _a;
+  const normalized = (_a = tagNameLower == null ? void 0 : tagNameLower.trim().toLowerCase()) != null ? _a : "";
+  if (!normalized) {
+    return null;
+  }
+  return QWEN3CODER_TOOL_PARSER_CALL_TAG_NAMES.has(normalized) ? normalized : null;
+}
+function findUnclosedParamBoundaryIndex(lowerText, valueStart, callEndTagNameLower, allowEndOfString) {
+  const normalizedCallEndTag = toSupportedCallEndTagName(callEndTagNameLower);
+  const callCloseIndex = normalizedCallEndTag ? findClosingTagStartWithBoundary(
+    lowerText,
+    valueStart,
+    normalizedCallEndTag,
+    allowEndOfString
+  ) : findClosingTagStartWithBoundary(
+    lowerText,
+    valueStart,
+    "function",
+    allowEndOfString
+  );
+  const indices = [
+    lowerText.indexOf("<parameter", valueStart),
+    lowerText.indexOf("<param", valueStart),
+    lowerText.indexOf("<argument", valueStart),
+    lowerText.indexOf("<arg", valueStart),
+    callCloseIndex,
+    findClosingTagStartWithBoundary(
+      lowerText,
+      valueStart,
+      "tool_call",
+      allowEndOfString
+    ),
+    lowerText.indexOf("<function", valueStart)
+  ].filter((index) => index !== -1);
+  if (indices.length === 0) {
+    return null;
+  }
+  return Math.min(...indices);
+}
+function parseQwen3CoderToolParserParamTagNameLower(lowerText, startIndex) {
+  var _a;
+  let i = skipAsciiWhitespace(lowerText, startIndex + 1);
+  if (i >= lowerText.length) {
+    return { kind: "partial" };
+  }
+  if (lowerText[i] === "/") {
+    return null;
+  }
+  const nameStart = i;
+  while (i < lowerText.length) {
+    const ch = (_a = lowerText[i]) != null ? _a : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/" || ch === "=") {
+      break;
+    }
+    i += 1;
+  }
+  const tagNameLower = lowerText.slice(nameStart, i);
+  if (!QWEN3CODER_TOOL_PARSER_PARAM_TAG_NAMES.has(tagNameLower)) {
+    return null;
+  }
+  return { kind: "match", tagNameLower };
+}
+function parseQwen3CoderToolParserUnclosedParamValue(options) {
+  var _a;
+  const valueStart = options.openEnd + 1;
+  const boundaryIndex = findUnclosedParamBoundaryIndex(
+    options.lowerText,
+    valueStart,
+    (_a = options.callEndTagNameLower) != null ? _a : null,
+    options.allowEndOfString
+  );
+  if (boundaryIndex == null) {
+    if (!options.allowEndOfString) {
+      const rawProgressValue = options.text.slice(valueStart);
+      return {
+        kind: "partial",
+        start: options.startIndex,
+        openEnd: options.openEnd,
+        name: options.paramName,
+        value: rawProgressValue ? normalizeXmlTextValue(rawProgressValue) : ""
+      };
+    }
+    const rawValue2 = options.text.slice(valueStart);
+    return {
+      kind: "match",
+      start: options.startIndex,
+      end: options.text.length,
+      name: options.paramName,
+      value: rawValue2 ? normalizeXmlTextValue(rawValue2) : ""
+    };
+  }
+  const rawValue = options.text.slice(valueStart, boundaryIndex);
+  return {
+    kind: "match",
+    start: options.startIndex,
+    end: boundaryIndex,
+    name: options.paramName,
+    value: rawValue ? normalizeXmlTextValue(rawValue) : ""
+  };
+}
+function parseQwen3CoderToolParserParamTagAt(text, lowerText, startIndex, options) {
+  var _a;
+  const tagNameParse = parseQwen3CoderToolParserParamTagNameLower(
+    lowerText,
+    startIndex
+  );
+  if (!tagNameParse) {
+    return null;
+  }
+  if (tagNameParse.kind === "partial") {
+    return { kind: "partial", start: startIndex, openEnd: null };
+  }
+  const tagNameLower = tagNameParse.tagNameLower;
+  const openEnd = findTagEndIndex(text, startIndex);
+  if (openEnd == null) {
+    return { kind: "partial", start: startIndex, openEnd: null };
+  }
+  const openTag = text.slice(startIndex, openEnd + 1);
+  const paramNameRaw = parseQwen3CoderToolParserParamName(
+    openTag,
+    tagNameLower
+  );
+  const paramName = (_a = paramNameRaw == null ? void 0 : paramNameRaw.trim()) != null ? _a : "";
+  if (paramName.length === 0) {
+    return null;
+  }
+  const selfClosing = openTag.trimEnd().endsWith("/>");
+  if (selfClosing) {
+    return {
+      kind: "match",
+      start: startIndex,
+      end: openEnd + 1,
+      name: paramName,
+      value: ""
+    };
+  }
+  const valueStart = openEnd + 1;
+  const close = findClosingTagEnd(lowerText, valueStart, tagNameLower);
+  if (!close) {
+    return parseQwen3CoderToolParserUnclosedParamValue({
+      text,
+      lowerText,
+      startIndex,
+      openEnd,
+      paramName,
+      allowEndOfString: (options == null ? void 0 : options.allowEndOfString) === true,
+      callEndTagNameLower: options == null ? void 0 : options.callEndTagNameLower
+    });
+  }
+  const rawValue = text.slice(openEnd + 1, close.start);
+  return {
+    kind: "match",
+    start: startIndex,
+    end: close.end,
+    name: paramName,
+    value: rawValue ? normalizeXmlTextValue(rawValue) : ""
+  };
+}
+function normalizeXmlTextValue(raw) {
+  let out = raw.trim();
+  if (out.startsWith("<![CDATA[") && out.endsWith("]]>")) {
+    out = out.slice("<![CDATA[".length, -"]]>".length).trim();
+  }
+  return unescapeXml(out);
+}
+function getOpeningTag(xml) {
+  const gt = xml.indexOf(">");
+  if (gt === -1) {
+    return null;
+  }
+  return xml.slice(0, gt + 1);
+}
+var attrValueRegExpCache = /* @__PURE__ */ new Map();
+function getAttributeValue(openTag, attrName) {
+  var _a;
+  let re = attrValueRegExpCache.get(attrName);
+  if (!re) {
+    re = new RegExp(
+      `\\b${escapeRegExp(attrName)}\\s*=\\s*(["'])([\\s\\S]*?)\\1`,
+      "i"
+    );
+    attrValueRegExpCache.set(attrName, re);
+  }
+  const match = re.exec(openTag);
+  if (!match) {
+    return null;
+  }
+  return unescapeXml((_a = match[2]) != null ? _a : "");
+}
+function getShorthandValue(openTag) {
+  var _a, _b;
+  const match = CALL_SHORTHAND_VALUE_RE.exec(openTag);
+  if (!match) {
+    return null;
+  }
+  const value = (_b = (_a = match[2]) != null ? _a : match[3]) != null ? _b : match[4];
+  if (!value) {
+    return null;
+  }
+  return unescapeXml(value);
+}
+function extractFirstTagText(xml, tagName) {
+  var _a;
+  const lower = xml.toLowerCase();
+  const tagLower = tagName.toLowerCase();
+  let index = 0;
+  while (true) {
+    const lt = lower.indexOf("<", index);
+    if (lt === -1) {
+      return null;
+    }
+    const i = skipAsciiWhitespace(lower, lt + 1);
+    if (i >= lower.length || lower[i] === "/") {
+      index = lt + 1;
+      continue;
+    }
+    if (!lower.startsWith(tagLower, i)) {
+      index = lt + 1;
+      continue;
+    }
+    const afterName = i + tagLower.length;
+    const boundary = (_a = lower[afterName]) != null ? _a : "";
+    if (boundary && !isTagBoundaryChar(boundary)) {
+      index = lt + 1;
+      continue;
+    }
+    const openEnd = findTagEndIndex(xml, lt);
+    if (openEnd == null) {
+      return null;
+    }
+    const contentStart = openEnd + 1;
+    const close = findClosingTagEnd(lower, contentStart, tagLower);
+    if (!close) {
+      return null;
+    }
+    return normalizeXmlTextValue(xml.slice(contentStart, close.start));
+  }
+}
+function extractToolCallInnerXml(segment) {
+  const openMatch = TOOL_CALL_OPEN_RE.exec(segment);
+  const closeMatch = TOOL_CALL_CLOSE_RE.exec(segment);
+  if (!(openMatch && closeMatch)) {
+    return null;
+  }
+  const openIndex = openMatch.index;
+  const openTag = openMatch[0];
+  const openEnd = openIndex + openTag.length;
+  const closeIndex = segment.toLowerCase().lastIndexOf("</tool_call");
+  if (closeIndex === -1) {
+    return null;
+  }
+  const closeGt = segment.indexOf(">", closeIndex);
+  if (closeGt === -1) {
+    return null;
+  }
+  return {
+    outerOpenTag: openTag,
+    inner: segment.slice(openEnd, closeIndex)
+  };
+}
+function mergeParamValue(args, key, value) {
+  const existing = args[key];
+  if (existing === void 0) {
+    args[key] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  args[key] = [existing, value];
+}
+function mergeArgsWithPartialParam(args, partialParam) {
+  if (!partialParam) {
+    return args;
+  }
+  const existing = args[partialParam.name];
+  if (existing === void 0) {
+    return {
+      ...args,
+      [partialParam.name]: partialParam.value
+    };
+  }
+  if (Array.isArray(existing)) {
+    return {
+      ...args,
+      [partialParam.name]: [...existing, partialParam.value]
+    };
+  }
+  return {
+    ...args,
+    [partialParam.name]: [existing, partialParam.value]
+  };
+}
+function extractParameters(xml, options) {
+  var _a;
+  const args = {};
+  const lower = xml.toLowerCase();
+  let index = 0;
+  while (true) {
+    const lt = lower.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const parsed = parseQwen3CoderToolParserParamTagAt(xml, lower, lt, {
+      allowEndOfString: true,
+      callEndTagNameLower: options == null ? void 0 : options.callEndTagNameLower
+    });
+    if (!parsed) {
+      index = lt + 1;
+      continue;
+    }
+    if (parsed.kind === "match") {
+      mergeParamValue(args, parsed.name, parsed.value);
+      index = parsed.end;
+      continue;
+    }
+    index = ((_a = parsed.openEnd) != null ? _a : lt) + 1;
+  }
+  return args;
+}
+function parseSingleFunctionCallXml(xml, fallbackToolName) {
+  var _a, _b, _c;
+  const openingTag = getOpeningTag(xml);
+  const toolNameAttr = openingTag ? getAttributeValue(openingTag, "name") : null;
+  const shorthandName = openingTag ? getShorthandValue(openingTag) : null;
+  const toolName = (_c = (_b = (_a = toolNameAttr != null ? toolNameAttr : shorthandName) != null ? _a : extractFirstTagText(xml, "name")) != null ? _b : extractFirstTagText(xml, "tool_name")) != null ? _c : fallbackToolName;
+  const callEndTagNameLower = toSupportedCallEndTagName(
+    openingTag ? getOpenTagNameLower(openingTag) : null
+  );
+  if (!toolName || toolName.trim().length === 0) {
+    return null;
+  }
+  return {
+    toolName,
+    args: extractParameters(xml, { callEndTagNameLower })
+  };
+}
+function findImplicitCallOpenIndices(lowerText) {
+  var _a;
+  const indices = [];
+  let index = 0;
+  while (true) {
+    const lt = lowerText.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const i = skipAsciiWhitespace(lowerText, lt + 1);
+    if (i >= lowerText.length) {
+      break;
+    }
+    if (lowerText[i] === "/") {
+      index = lt + 1;
+      continue;
+    }
+    const tagNames = ["call", "function", "tool", "invoke"];
+    for (const tagName of tagNames) {
+      if (!lowerText.startsWith(tagName, i)) {
+        continue;
+      }
+      const after = i + tagName.length;
+      const boundary = (_a = lowerText[after]) != null ? _a : "";
+      if (boundary && !isTagBoundaryChar(boundary) && boundary !== "=") {
+        continue;
+      }
+      indices.push(lt);
+      break;
+    }
+    index = lt + 1;
+  }
+  return indices;
+}
+function splitImplicitCallBlocks(xml) {
+  var _a, _b;
+  const lower = xml.toLowerCase();
+  const starts = findImplicitCallOpenIndices(lower);
+  if (starts.length === 0) {
+    return [];
+  }
+  const blocks = [];
+  for (let i = 0; i < starts.length; i += 1) {
+    const start = (_a = starts[i]) != null ? _a : 0;
+    const end = (_b = starts[i + 1]) != null ? _b : xml.length;
+    blocks.push(xml.slice(start, end));
+  }
+  return blocks;
+}
+function stripLeadingCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const match = LEADING_CALL_CLOSE_TAG_RE.exec(out);
+    if (!match) {
+      return out;
+    }
+    out = out.slice(match[0].length);
+  }
+}
+function getOpenTagNameLower(openTag) {
+  var _a;
+  const lowerOpenTag = openTag.toLowerCase();
+  const lt = lowerOpenTag.indexOf("<");
+  if (lt === -1) {
+    return null;
+  }
+  let i = skipAsciiWhitespace(lowerOpenTag, lt + 1);
+  if (i >= lowerOpenTag.length || lowerOpenTag[i] === "/") {
+    return null;
+  }
+  const start = i;
+  while (i < lowerOpenTag.length) {
+    const ch = (_a = lowerOpenTag[i]) != null ? _a : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/" || ch === "=") {
+      break;
+    }
+    i += 1;
+  }
+  const tagName = lowerOpenTag.slice(start, i);
+  return tagName.length > 0 ? tagName : null;
+}
+function splitImplicitCallAndTail(callBlock) {
+  var _a;
+  const openingTag = getOpeningTag(callBlock);
+  const openingTagName = toSupportedCallEndTagName(
+    openingTag ? getOpenTagNameLower(openingTag) : null
+  );
+  const lowerCallBlock = callBlock.toLowerCase();
+  let consumed = 0;
+  if (openingTag) {
+    consumed = openingTag.length;
+    if (openingTagName) {
+      const close = findClosingTagEnd(lowerCallBlock, consumed, openingTagName);
+      if (close) {
+        consumed = Math.max(consumed, close.end);
+      }
+    }
+  }
+  let index = 0;
+  while (true) {
+    const lt = lowerCallBlock.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const parsed = parseQwen3CoderToolParserParamTagAt(
+      callBlock,
+      lowerCallBlock,
+      lt,
+      {
+        allowEndOfString: true,
+        callEndTagNameLower: openingTagName
+      }
+    );
+    if (!parsed) {
+      index = lt + 1;
+      continue;
+    }
+    if (parsed.kind === "partial") {
+      index = ((_a = parsed.openEnd) != null ? _a : lt) + 1;
+      continue;
+    }
+    consumed = Math.max(consumed, parsed.end);
+    index = parsed.end;
+  }
+  const clamped = Math.max(0, Math.min(consumed, callBlock.length));
+  return {
+    callContent: callBlock.slice(0, clamped),
+    trailingText: callBlock.slice(clamped)
+  };
+}
+function parseQwen3CoderToolParserCallBlocks(blocks, outerNameAttr) {
+  const calls = [];
+  for (const block of blocks) {
+    const parsed = parseSingleFunctionCallXml(block, outerNameAttr);
+    if (!parsed) {
+      return null;
+    }
+    calls.push(parsed);
+  }
+  return calls;
+}
+function parseQwen3CoderToolParserClosedMatches(inner, outerNameAttr) {
+  var _a, _b;
+  const callBlockMatches = Array.from(inner.matchAll(CALL_BLOCK_RE));
+  if (callBlockMatches.length === 0) {
+    return void 0;
+  }
+  const closedBlocks = [];
+  let lastClosedEnd = 0;
+  for (const match of callBlockMatches) {
+    const callBlock = (_a = match[0]) != null ? _a : "";
+    const startIndex = (_b = match.index) != null ? _b : -1;
+    if (!callBlock || startIndex < 0) {
+      continue;
+    }
+    closedBlocks.push(callBlock);
+    lastClosedEnd = startIndex + callBlock.length;
+  }
+  const closedCalls = parseQwen3CoderToolParserCallBlocks(
+    closedBlocks,
+    outerNameAttr
+  );
+  if (!closedCalls) {
+    return null;
+  }
+  const trailingInner = inner.slice(lastClosedEnd);
+  if (trailingInner.trim().length === 0) {
+    return closedCalls;
+  }
+  const trailingBlocks = splitImplicitCallBlocks(trailingInner).filter(
+    (b) => b.trim().length > 0
+  );
+  if (trailingBlocks.length === 0) {
+    return closedCalls;
+  }
+  const trailingCalls = parseQwen3CoderToolParserCallBlocks(
+    trailingBlocks,
+    outerNameAttr
+  );
+  if (!trailingCalls) {
+    return closedCalls;
+  }
+  return closedCalls.concat(trailingCalls);
+}
+function parseQwen3CoderToolParserToolCallSegment(segment) {
+  var _a;
+  const extracted = extractToolCallInnerXml(segment);
+  if (!extracted) {
+    return null;
+  }
+  const { inner, outerOpenTag } = extracted;
+  const outerNameAttr = getAttributeValue(outerOpenTag, "name");
+  const closedCalls = parseQwen3CoderToolParserClosedMatches(
+    inner,
+    outerNameAttr
+  );
+  if (closedCalls) {
+    return closedCalls;
+  }
+  if (closedCalls === null) {
+    return null;
+  }
+  const implicitBlocks = splitImplicitCallBlocks(inner).filter(
+    (b) => b.trim().length > 0
+  );
+  if (implicitBlocks.length > 0) {
+    return parseQwen3CoderToolParserCallBlocks(implicitBlocks, outerNameAttr);
+  }
+  const single = (_a = parseSingleFunctionCallXml(inner, outerNameAttr)) != null ? _a : parseSingleFunctionCallXml(segment, outerNameAttr);
+  if (!single) {
+    return null;
+  }
+  return [single];
+}
+function parseToolCallInput(input) {
+  if (input == null) {
+    return {};
+  }
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return input;
+  }
+}
+function toQwen3CoderToolParserParamText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function appendQwen3CoderToolParserParameter(lines, key, value) {
+  const nameAttr = escapeXmlMinimalAttr(key, '"');
+  const text = escapeXmlMinimalText(toQwen3CoderToolParserParamText(value));
+  lines.push(`    <parameter="${nameAttr}">${text}</parameter>`);
+}
+function appendQwen3CoderToolParserArgs(lines, args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    for (const [key, value] of Object.entries(args)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          appendQwen3CoderToolParserParameter(lines, key, item);
+        }
+      } else {
+        appendQwen3CoderToolParserParameter(lines, key, value);
+      }
+    }
+    return;
+  }
+  if (args !== void 0 && args !== null && args !== "") {
+    appendQwen3CoderToolParserParameter(lines, "input", args);
+  }
+}
+var qwen3CoderProtocol = () => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
+  },
+  formatToolCall(toolCall) {
+    const args = parseToolCallInput(toolCall.input);
+    const lines = ["<tool_call>"];
+    lines.push(
+      `  <function="${escapeXmlMinimalAttr(toolCall.toolName, '"')}">`
+    );
+    appendQwen3CoderToolParserArgs(lines, args);
+    lines.push("  </function>");
+    lines.push("</tool_call>");
+    return lines.join("\n");
+  },
+  parseGeneratedText({ text, tools, options }) {
+    const processedElements = [];
+    const emitToolCalls = (calls) => {
+      for (const call of calls) {
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: generateToolCallId(),
+          toolName: call.toolName,
+          input: stringifyToolInputWithSchema({
+            tools,
+            toolName: call.toolName,
+            args: call.args
+          })
+        });
+      }
+    };
+    const pushText = (value) => {
+      if (value.length === 0) {
+        return;
+      }
+      processedElements.push({ type: "text", text: value });
+    };
+    const tryEmitToolCallSegment = (segment, fallbackText = segment) => {
+      var _a;
+      const parsedCalls = parseQwen3CoderToolParserToolCallSegment(segment);
+      if (!parsedCalls) {
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+          options,
+          "Could not process Qwen3CoderToolParser XML tool call; keeping original text.",
+          { toolCall: fallbackText }
+        );
+        processedElements.push({ type: "text", text: fallbackText });
+        return false;
+      }
+      emitToolCalls(parsedCalls);
+      return true;
+    };
+    const emitWrapperlessCallParseFailureAsText = (raw) => {
+      var _a;
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        "Could not process Qwen3CoderToolParser <function> call; keeping original text.",
+        { toolCall: raw }
+      );
+      processedElements.push({ type: "text", text: raw });
+    };
+    const tryParseCallBlocksWithoutWrapperByImplicitStarts = (sourceText, starts) => {
+      var _a, _b;
+      let index = 0;
+      for (let i = 0; i < starts.length; i += 1) {
+        const startIndex = (_a = starts[i]) != null ? _a : -1;
+        if (startIndex < 0) {
+          continue;
+        }
+        const endIndex = (_b = starts[i + 1]) != null ? _b : sourceText.length;
+        pushText(
+          stripTrailingToolCallCloseTags(
+            stripLeadingToolCallCloseTags(sourceText.slice(index, startIndex))
+          )
+        );
+        const full = sourceText.slice(startIndex, endIndex);
+        const { callContent, trailingText } = splitImplicitCallAndTail(full);
+        const parsed = parseSingleFunctionCallXml(callContent, null);
+        if (parsed) {
+          emitToolCalls([parsed]);
+          pushText(
+            stripTrailingToolCallCloseTags(
+              stripLeadingToolCallCloseTags(trailingText)
+            )
+          );
+        } else {
+          emitWrapperlessCallParseFailureAsText(full);
+        }
+        index = endIndex;
+      }
+      pushText(
+        stripTrailingToolCallCloseTags(
+          stripLeadingToolCallCloseTags(sourceText.slice(index))
+        )
+      );
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapperByMatches = (sourceText, matches) => {
+      var _a;
+      let index = 0;
+      for (const match of matches) {
+        const full = match[0];
+        const startIndex = (_a = match.index) != null ? _a : -1;
+        if (!full || startIndex < 0) {
+          continue;
+        }
+        pushText(
+          stripTrailingToolCallCloseTags(
+            stripLeadingToolCallCloseTags(sourceText.slice(index, startIndex))
+          )
+        );
+        const parsed = parseSingleFunctionCallXml(full, null);
+        if (parsed) {
+          emitToolCalls([parsed]);
+        } else {
+          emitWrapperlessCallParseFailureAsText(full);
+        }
+        index = startIndex + full.length;
+      }
+      const trailing = sourceText.slice(index);
+      const trailingStarts = findImplicitCallOpenIndices(
+        trailing.toLowerCase()
+      );
+      if (trailingStarts.length > 0) {
+        return tryParseCallBlocksWithoutWrapperByImplicitStarts(
+          trailing,
+          trailingStarts
+        );
+      }
+      pushText(
+        stripTrailingToolCallCloseTags(stripLeadingToolCallCloseTags(trailing))
+      );
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapperText = (sourceText) => {
+      const matches = Array.from(sourceText.matchAll(CALL_BLOCK_RE));
+      if (matches.length > 0) {
+        return tryParseCallBlocksWithoutWrapperByMatches(sourceText, matches);
+      }
+      const starts = findImplicitCallOpenIndices(sourceText.toLowerCase());
+      if (starts.length === 0) {
+        return false;
+      }
+      return tryParseCallBlocksWithoutWrapperByImplicitStarts(
+        sourceText,
+        starts
+      );
+    };
+    const pushTextOrParseWrapperlessCalls = (segment) => {
+      if (segment.length === 0) {
+        return;
+      }
+      if (!tryParseCallBlocksWithoutWrapperText(segment)) {
+        pushText(segment);
+      }
+    };
+    const handleCompleteToolCallRemainder = (remainder) => {
+      if (!remainder) {
+        return;
+      }
+      const lowerRemainder = remainder.toLowerCase();
+      const trailingIndex = lowerRemainder.indexOf("<tool_call");
+      if (trailingIndex === -1) {
+        pushTextOrParseWrapperlessCalls(remainder);
+        return;
+      }
+      pushTextOrParseWrapperlessCalls(remainder.slice(0, trailingIndex));
+      const trailing = remainder.slice(trailingIndex);
+      const synthetic = TOOL_CALL_CLOSE_RE.test(trailing) ? trailing : `${trailing}</tool_call>`;
+      tryEmitToolCallSegment(synthetic, trailing);
+    };
+    const tryParseCompleteToolCallBlocks = () => {
+      var _a;
+      const matches = Array.from(text.matchAll(TOOL_CALL_BLOCK_RE));
+      if (matches.length === 0) {
+        return false;
+      }
+      let index = 0;
+      for (const match of matches) {
+        const full = match[0];
+        const startIndex = (_a = match.index) != null ? _a : -1;
+        if (!full || startIndex < 0) {
+          continue;
+        }
+        pushTextOrParseWrapperlessCalls(text.slice(index, startIndex));
+        tryEmitToolCallSegment(full);
+        index = startIndex + full.length;
+      }
+      handleCompleteToolCallRemainder(text.slice(index));
+      return true;
+    };
+    const tryParseIncompleteToolCall = () => {
+      const lowerText = text.toLowerCase();
+      const startIndex = lowerText.indexOf("<tool_call");
+      if (startIndex === -1) {
+        return false;
+      }
+      pushTextOrParseWrapperlessCalls(text.slice(0, startIndex));
+      const trailing = text.slice(startIndex);
+      const synthetic = TOOL_CALL_CLOSE_RE.test(trailing) ? trailing : `${trailing}</tool_call>`;
+      tryEmitToolCallSegment(synthetic, trailing);
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapper = () => {
+      return tryParseCallBlocksWithoutWrapperText(text);
+    };
+    const tryParseSingleFunctionCall = () => {
+      const lowerText = text.toLowerCase();
+      const startIndex = lowerText.indexOf("<function");
+      if (startIndex === -1) {
+        return false;
+      }
+      pushText(stripTrailingToolCallCloseTags(text.slice(0, startIndex)));
+      const trailing = stripLeadingToolCallCloseTags(text.slice(startIndex));
+      const parsed = parseSingleFunctionCallXml(trailing, null);
+      if (!parsed) {
+        processedElements.push({ type: "text", text: trailing });
+        return true;
+      }
+      emitToolCalls([parsed]);
+      return true;
+    };
+    if (tryParseCompleteToolCallBlocks()) {
+      return processedElements;
+    }
+    if (tryParseIncompleteToolCall()) {
+      return processedElements;
+    }
+    if (tryParseCallBlocksWithoutWrapper()) {
+      return processedElements;
+    }
+    if (tryParseSingleFunctionCall()) {
+      return processedElements;
+    }
+    return [{ type: "text", text }];
+  },
+  extractToolCallSegments({ text }) {
+    return Array.from(text.matchAll(TOOL_CALL_BLOCK_RE)).map((m) => m[0]).filter((s) => Boolean(s));
+  },
+  createStreamParser({ tools, options }) {
+    const toolCallStartPrefixLower = "<tool_call";
+    const implicitCallPrefixesLower = [
+      "<function",
+      "<call",
+      "<tool",
+      "<invoke"
+    ];
+    let buffer = "";
+    let toolCall = null;
+    let implicitCall = null;
+    let implicitCallOpenTag = null;
+    let currentTextId = null;
+    let hasEmittedTextStart = false;
+    const flushText = createFlushTextHandler(
+      () => currentTextId,
+      (id) => {
+        currentTextId = id;
+      },
+      () => hasEmittedTextStart,
+      (value) => {
+        hasEmittedTextStart = value;
+      }
+    );
+    const maybeEmitToolInputStart = (controller, callState) => {
+      if (callState.hasEmittedStart) {
+        return;
+      }
+      const toolName = callState.toolName;
+      if (!toolName || toolName.trim().length === 0) {
+        return;
+      }
+      flushText(controller);
+      controller.enqueue({
+        type: "tool-input-start",
+        id: callState.toolCallId,
+        toolName
+      });
+      callState.hasEmittedStart = true;
+    };
+    const maybeEmitToolInputProgress = (controller, callState) => {
+      if (!callState.hasEmittedStart) {
+        return;
+      }
+      const toolName = callState.toolName;
+      if (!toolName) {
+        return;
+      }
+      const argsForProgress = mergeArgsWithPartialParam(
+        callState.args,
+        callState.partialParam
+      );
+      const fullInput = stringifyToolInputWithSchema({
+        tools,
+        toolName,
+        args: argsForProgress
+      });
+      if (fullInput === "{}") {
+        return;
+      }
+      emitToolInputProgressDelta({
+        controller,
+        id: callState.toolCallId,
+        state: callState,
+        fullInput
+      });
+    };
+    const finalizeCall = (controller, callState, fallbackToolName, rawToolCallText = null) => {
+      var _a, _b;
+      const resolvedToolName = (_a = callState.toolName) != null ? _a : fallbackToolName;
+      if (!resolvedToolName || resolvedToolName.trim().length === 0) {
+        const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
+        emitFailedToolInputLifecycle({
+          controller,
+          id: callState.toolCallId,
+          endInput: callState.hasEmittedStart,
+          emitRawToolCallTextOnError: shouldEmitRaw,
+          rawToolCallText,
+          emitRawText: (rawText) => {
+            flushText(controller, rawText);
+          }
+        });
+        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+          options,
+          shouldEmitRaw && rawToolCallText ? "Could not resolve Qwen3CoderToolParser tool name for tool call; emitting original text." : "Could not resolve Qwen3CoderToolParser tool name for tool call",
+          {
+            toolCallId: callState.toolCallId,
+            toolCall: rawToolCallText
+          }
+        );
+        return false;
+      }
+      callState.toolName = resolvedToolName;
+      maybeEmitToolInputStart(controller, callState);
+      maybeEmitToolInputProgress(controller, callState);
+      const finalInput = stringifyToolInputWithSchema({
+        tools,
+        toolName: resolvedToolName,
+        args: callState.args
+      });
+      emitFinalizedToolInputLifecycle({
+        controller,
+        id: callState.toolCallId,
+        state: callState,
+        toolName: resolvedToolName,
+        finalInput,
+        onMismatch: options == null ? void 0 : options.onError
+      });
+      return true;
+    };
+    const parseStreamingCallContent = (controller, callState, content, allowEndOfString) => parseCallContent({
+      callState,
+      content,
+      allowEndOfString,
+      nameTagRe: QWEN3CODER_TOOL_PARSER_STREAM_NAME_TAG_RE,
+      normalizeXmlTextValue,
+      parseParamTagAt: parseQwen3CoderToolParserParamTagAt,
+      mergeParamValue,
+      maybeEmitToolInputStart: () => {
+        maybeEmitToolInputStart(controller, callState);
+      },
+      maybeEmitToolInputProgress: () => {
+        maybeEmitToolInputProgress(controller, callState);
+      }
+    });
+    const closeTagCache = /* @__PURE__ */ new Map();
+    const getCloseTagPattern = (endTagName) => {
+      const cached = closeTagCache.get(endTagName);
+      if (cached) {
+        return cached;
+      }
+      const created = new RegExp(
+        `<\\s*\\/\\s*${escapeRegExp(endTagName)}\\s*>`,
+        "i"
+      );
+      closeTagCache.set(endTagName, created);
+      return created;
+    };
+    const getNextCallStartInBuffer = (callState) => {
+      var _a;
+      if (callState.endTagName === "tool_call") {
+        return -1;
+      }
+      const match = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(
+        callState.buffer
+      );
+      return (_a = match == null ? void 0 : match.index) != null ? _a : -1;
+    };
+    const finalizeStreamingCall = (controller, callState, fallbackToolName, remainder) => {
+      const rawToolCallText = remainder.length > 0 && callState.raw.endsWith(remainder) ? callState.raw.slice(0, -remainder.length) : callState.raw;
+      const ok = finalizeCall(
+        controller,
+        callState,
+        fallbackToolName,
+        rawToolCallText
+      );
+      if (ok && toolCall) {
+        toolCall.emittedToolCallCount += 1;
+      }
+    };
+    const consumeCallAtNextBoundary = (controller, callState, fallbackToolName, nextCallStart) => {
+      const beforeNextCall = callState.buffer.slice(0, nextCallStart);
+      const afterNextCall = callState.buffer.slice(nextCallStart);
+      callState.buffer = parseStreamingCallContent(
+        controller,
+        callState,
+        beforeNextCall,
+        true
+      );
+      finalizeStreamingCall(
+        controller,
+        callState,
+        fallbackToolName,
+        afterNextCall
+      );
+      return { done: true, remainder: afterNextCall };
+    };
+    const consumeCall = (controller, callState, incoming, fallbackToolName) => {
+      var _a, _b, _c;
+      callState.buffer += incoming;
+      callState.raw += incoming;
+      const closeMatch = getCloseTagPattern(callState.endTagName).exec(
+        callState.buffer
+      );
+      const closeStart = (_a = closeMatch == null ? void 0 : closeMatch.index) != null ? _a : -1;
+      const nextCallStart = getNextCallStartInBuffer(callState);
+      const shouldCloseAtNextBoundary = nextCallStart !== -1 && (closeStart === -1 || nextCallStart < closeStart);
+      if (shouldCloseAtNextBoundary) {
+        return consumeCallAtNextBoundary(
+          controller,
+          callState,
+          fallbackToolName,
+          nextCallStart
+        );
+      }
+      if (!closeMatch) {
+        callState.buffer = parseStreamingCallContent(
+          controller,
+          callState,
+          callState.buffer,
+          false
+        );
+        return { done: false, remainder: "" };
+      }
+      const closeEnd = closeStart + ((_c = (_b = closeMatch[0]) == null ? void 0 : _b.length) != null ? _c : 0);
+      const beforeClose = callState.buffer.slice(0, closeStart);
+      const afterClose = callState.buffer.slice(closeEnd);
+      parseStreamingCallContent(controller, callState, beforeClose, true);
+      callState.buffer = "";
+      finalizeStreamingCall(
+        controller,
+        callState,
+        fallbackToolName,
+        afterClose
+      );
+      return { done: true, remainder: afterClose };
+    };
+    const finalizeCallAtFinish = (controller, callState, fallbackToolName) => {
+      callState.buffer = parseStreamingCallContent(
+        controller,
+        callState,
+        callState.buffer,
+        true
+      );
+      const trailingText = stripLeadingCallCloseTags(callState.buffer);
+      callState.buffer = "";
+      const ok = finalizeCall(controller, callState, fallbackToolName, null);
+      return {
+        ok,
+        trailingText
+      };
+    };
+    const flushSafeTextPrefix = (controller) => {
+      const lower = buffer.toLowerCase();
+      const potentialIndices = [
+        getPotentialStartIndex(lower, toolCallStartPrefixLower),
+        ...implicitCallPrefixesLower.map(
+          (prefix) => getPotentialStartIndex(lower, prefix)
+        )
+      ].filter((value) => value != null);
+      const potentialIndex = potentialIndices.length > 0 ? Math.min(...potentialIndices) : null;
+      if (potentialIndex == null) {
+        if (buffer.length > 0) {
+          flushText(controller, buffer);
+          buffer = "";
+        }
+        return;
+      }
+      if (potentialIndex > 0) {
+        flushText(controller, buffer.slice(0, potentialIndex));
+        buffer = buffer.slice(potentialIndex);
+      }
+    };
+    const stripLeadingToolCallCloseTagsFromBuffer = () => {
+      if (!buffer) {
+        return;
+      }
+      const stripped = stripLeadingToolCallCloseTags(buffer);
+      if (stripped !== buffer) {
+        buffer = stripped;
+      }
+    };
+    const startToolCallIfPresent = (_controller) => {
+      if (toolCall) {
+        return;
+      }
+      if (implicitCall) {
+        return;
+      }
+      const lower = buffer.toLowerCase();
+      const startIndex = getPotentialStartIndex(
+        lower,
+        toolCallStartPrefixLower
+      );
+      if (startIndex == null || startIndex !== 0) {
+        return;
+      }
+      const gtIndex = buffer.indexOf(">");
+      if (gtIndex === -1) {
+        return;
+      }
+      const openTag = buffer.slice(0, gtIndex + 1);
+      if (!TOOL_CALL_OPEN_RE.test(openTag)) {
+        return;
+      }
+      toolCall = {
+        outerOpenTag: openTag,
+        outerNameAttr: getAttributeValue(openTag, "name"),
+        raw: openTag,
+        mode: "unknown",
+        innerBuffer: "",
+        activeCall: null,
+        emittedToolCallCount: 0
+      };
+      const remainder = buffer.slice(gtIndex + 1);
+      buffer = "";
+      if (remainder.length > 0) {
+        toolCall.raw += remainder;
+        toolCall.innerBuffer += remainder;
+      }
+    };
+    const startImplicitCallIfPresent = (controller) => {
+      var _a, _b, _c, _d;
+      if (toolCall || implicitCall) {
+        return;
+      }
+      const match = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(buffer);
+      const startIndex = (_a = match == null ? void 0 : match.index) != null ? _a : -1;
+      const openTag = (_b = match == null ? void 0 : match[0]) != null ? _b : "";
+      const callTagName = ((_c = match == null ? void 0 : match[1]) != null ? _c : "").toLowerCase();
+      if (!match || startIndex !== 0 || !openTag || !callTagName) {
+        return;
+      }
+      const inlineToolName = (_d = getAttributeValue(openTag, "name")) != null ? _d : getShorthandValue(openTag);
+      if (!inlineToolName || inlineToolName.trim().length === 0) {
+        return;
+      }
+      const selfClosing = QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE.test(openTag);
+      buffer = buffer.slice(openTag.length);
+      const newCall = {
+        endTagName: callTagName,
+        toolCallId: generateToolCallId(),
+        toolName: inlineToolName,
+        hasEmittedStart: false,
+        partialParam: null,
+        emittedInput: "",
+        raw: openTag,
+        args: {},
+        buffer: ""
+      };
+      maybeEmitToolInputStart(controller, newCall);
+      if (selfClosing) {
+        finalizeCall(controller, newCall, inlineToolName, newCall.raw);
+        return;
+      }
+      implicitCall = newCall;
+      implicitCallOpenTag = openTag;
+    };
+    const processImplicitCall = (controller) => {
+      while (implicitCall) {
+        const callState = implicitCall;
+        const { done, remainder } = consumeCall(
+          controller,
+          callState,
+          buffer,
+          null
+        );
+        buffer = "";
+        if (!done) {
+          return;
+        }
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        if (remainder.length > 0) {
+          buffer = remainder;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        startToolCallIfPresent(controller);
+        if (toolCall) {
+          processToolCall2(controller);
+          return;
+        }
+        startImplicitCallIfPresent(controller);
+      }
+    };
+    const drainStarts = (controller) => {
+      while (true) {
+        if (toolCall || implicitCall) {
+          return;
+        }
+        const before = buffer;
+        startToolCallIfPresent(controller);
+        if (toolCall) {
+          processToolCall2(controller);
+          return;
+        }
+        startImplicitCallIfPresent(controller);
+        if (implicitCall) {
+          processImplicitCall(controller);
+          return;
+        }
+        if (buffer === before) {
+          return;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+      }
+    };
+    const processToolCall2 = (controller) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      while (toolCall) {
+        if (toolCall.mode === "unknown") {
+          const callMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE.exec(
+            toolCall.innerBuffer
+          );
+          const signalMatch = QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE.exec(
+            toolCall.innerBuffer
+          );
+          if (callMatch && (!signalMatch || ((_a = callMatch.index) != null ? _a : 0) < ((_b = signalMatch.index) != null ? _b : 0))) {
+            toolCall.mode = "multi";
+          } else if (signalMatch) {
+            toolCall.mode = "single";
+            const activeCall = {
+              endTagName: "tool_call",
+              toolCallId: generateToolCallId(),
+              toolName: toolCall.outerNameAttr,
+              hasEmittedStart: false,
+              partialParam: null,
+              emittedInput: "",
+              raw: toolCall.outerOpenTag,
+              args: {},
+              buffer: ""
+            };
+            toolCall.activeCall = activeCall;
+            if (toolCall.outerNameAttr) {
+              maybeEmitToolInputStart(controller, activeCall);
+            }
+          } else {
+            return;
+          }
+        }
+        if (toolCall.mode === "single") {
+          const callState = toolCall.activeCall;
+          if (!callState) {
+            return;
+          }
+          const { done, remainder } = consumeCall(
+            controller,
+            callState,
+            toolCall.innerBuffer,
+            toolCall.outerNameAttr
+          );
+          toolCall.innerBuffer = "";
+          if (!done) {
+            return;
+          }
+          toolCall = null;
+          if (remainder.length > 0) {
+            buffer = remainder + buffer;
+          }
+          flushSafeTextPrefix(controller);
+          startToolCallIfPresent(controller);
+          continue;
+        }
+        if (toolCall.mode === "multi") {
+          if (toolCall.activeCall) {
+            const callState = toolCall.activeCall;
+            const { done, remainder } = consumeCall(
+              controller,
+              callState,
+              toolCall.innerBuffer,
+              toolCall.outerNameAttr
+            );
+            toolCall.innerBuffer = "";
+            if (!done) {
+              return;
+            }
+            toolCall.activeCall = null;
+            toolCall.innerBuffer = remainder;
+            continue;
+          }
+          const closeMatch = QWEN3CODER_TOOL_PARSER_STREAM_TOOL_CALL_CLOSE_TAG_RE.exec(
+            toolCall.innerBuffer
+          );
+          const callOpenMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(
+            toolCall.innerBuffer
+          );
+          if (!(closeMatch || callOpenMatch)) {
+            return;
+          }
+          const closeIndex = (_c = closeMatch == null ? void 0 : closeMatch.index) != null ? _c : -1;
+          const callIndex = (_d = callOpenMatch == null ? void 0 : callOpenMatch.index) != null ? _d : -1;
+          const hasClose = closeIndex !== -1;
+          const hasCall = callIndex !== -1;
+          const chooseClose = hasClose && (!hasCall || closeIndex < callIndex);
+          const nextIndex = chooseClose ? closeIndex : callIndex;
+          if (nextIndex > 0) {
+            toolCall.innerBuffer = toolCall.innerBuffer.slice(nextIndex);
+          }
+          if (chooseClose) {
+            const matchLen = (_f = (_e = closeMatch == null ? void 0 : closeMatch[0]) == null ? void 0 : _e.length) != null ? _f : 0;
+            const remainder = toolCall.innerBuffer.slice(matchLen);
+            toolCall = null;
+            if (remainder.length > 0) {
+              buffer = remainder + buffer;
+            }
+            flushSafeTextPrefix(controller);
+            startToolCallIfPresent(controller);
+            continue;
+          }
+          if (!callOpenMatch) {
+            return;
+          }
+          const openTag = (_g = callOpenMatch[0]) != null ? _g : "";
+          const callTagName = ((_h = callOpenMatch[1]) != null ? _h : "").toLowerCase();
+          const rest = toolCall.innerBuffer.slice(openTag.length);
+          const selfClosing = QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE.test(openTag);
+          if (selfClosing) {
+            const toolNameAttr2 = (_j = (_i = getAttributeValue(openTag, "name")) != null ? _i : getShorthandValue(openTag)) != null ? _j : toolCall.outerNameAttr;
+            const immediateCall = {
+              endTagName: callTagName,
+              toolCallId: generateToolCallId(),
+              toolName: toolNameAttr2,
+              hasEmittedStart: false,
+              partialParam: null,
+              emittedInput: "",
+              raw: openTag,
+              args: {},
+              buffer: ""
+            };
+            const ok = finalizeCall(
+              controller,
+              immediateCall,
+              toolNameAttr2,
+              immediateCall.raw
+            );
+            if (ok) {
+              toolCall.emittedToolCallCount += 1;
+            }
+            toolCall.innerBuffer = rest;
+            continue;
+          }
+          const toolNameAttr = (_k = getAttributeValue(openTag, "name")) != null ? _k : getShorthandValue(openTag);
+          const newCall = {
+            endTagName: callTagName,
+            toolCallId: generateToolCallId(),
+            toolName: toolNameAttr,
+            hasEmittedStart: false,
+            partialParam: null,
+            emittedInput: "",
+            raw: openTag,
+            args: {},
+            buffer: ""
+          };
+          if (toolNameAttr) {
+            maybeEmitToolInputStart(controller, newCall);
+          }
+          toolCall.activeCall = newCall;
+          toolCall.innerBuffer = rest;
+        }
+      }
+    };
+    const reportUnfinishedToolCallAtFinish = (controller, rawToolCall) => {
+      var _a;
+      const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser XML tool call at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser XML tool call at finish.",
+        { toolCall: rawToolCall }
+      );
+      if (shouldEmitRaw) {
+        flushText(controller, rawToolCall);
+      }
+    };
+    const reportUnfinishedImplicitCallAtFinish = (controller, rawCallText) => {
+      var _a;
+      const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser call block at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser call block at finish.",
+        { toolCall: rawCallText }
+      );
+      if (shouldEmitRaw) {
+        flushText(controller, rawCallText);
+      }
+    };
+    const handleFinish = (controller) => {
+      var _a, _b;
+      if (toolCall) {
+        processToolCall2(controller);
+        if (toolCall) {
+          if (toolCall.mode === "unknown") {
+            const callMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE.exec(
+              toolCall.innerBuffer
+            );
+            const signalMatch = QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE.exec(
+              toolCall.innerBuffer
+            );
+            if (callMatch && (!signalMatch || ((_a = callMatch.index) != null ? _a : 0) < ((_b = signalMatch.index) != null ? _b : 0))) {
+              toolCall.mode = "multi";
+            } else if (signalMatch) {
+              toolCall.mode = "single";
+              toolCall.activeCall = {
+                endTagName: "tool_call",
+                toolCallId: generateToolCallId(),
+                toolName: toolCall.outerNameAttr,
+                hasEmittedStart: false,
+                partialParam: null,
+                emittedInput: "",
+                raw: toolCall.outerOpenTag,
+                args: {},
+                buffer: ""
+              };
+            }
+          }
+          if (toolCall.mode === "single" && toolCall.activeCall) {
+            toolCall.activeCall.buffer += toolCall.innerBuffer;
+            toolCall.innerBuffer = "";
+            const result = finalizeCallAtFinish(
+              controller,
+              toolCall.activeCall,
+              toolCall.outerNameAttr
+            );
+            if (result.ok) {
+              toolCall.emittedToolCallCount += 1;
+            }
+            const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
+            if (shouldFlushTrailingText && result.trailingText.length > 0) {
+              flushText(controller, result.trailingText);
+            }
+            if (!result.ok && toolCall.emittedToolCallCount === 0) {
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+            }
+          } else if (toolCall.mode === "multi") {
+            if (toolCall.activeCall) {
+              const result = finalizeCallAtFinish(
+                controller,
+                toolCall.activeCall,
+                toolCall.outerNameAttr
+              );
+              if (result.ok) {
+                toolCall.emittedToolCallCount += 1;
+              }
+              const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
+              if (shouldFlushTrailingText && result.trailingText.length > 0) {
+                flushText(controller, result.trailingText);
+              }
+              if (!result.ok && toolCall.emittedToolCallCount === 0) {
+                reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+              }
+              toolCall.activeCall = null;
+            } else if (toolCall.emittedToolCallCount === 0) {
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+            }
+          } else {
+            reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
           }
+          toolCall = null;
         }
-      });
-    },
-    extractToolCallSegments({ text, tools }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
-      if (toolNames.length === 0) {
-        return [];
       }
-      return findToolCalls(text, toolNames).map((tc) => tc.segment);
-    }
-  };
-};
+      if (implicitCall) {
+        const callState = implicitCall;
+        const openTag = implicitCallOpenTag;
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        const result = finalizeCallAtFinish(controller, callState, null);
+        const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
+        if (shouldFlushTrailingText && result.trailingText.length > 0) {
+          flushText(controller, result.trailingText);
+        }
+        if (!result.ok && openTag) {
+          reportUnfinishedImplicitCallAtFinish(
+            controller,
+            callState.raw || openTag + callState.buffer
+          );
+        }
+      } else {
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        drainStarts(controller);
+      }
+      if (buffer.length > 0) {
+        flushText(controller, buffer);
+        buffer = "";
+      }
+      flushText(controller);
+    };
+    const handlePassthroughChunk = (controller, chunk) => {
+      if (!toolCall && buffer) {
+        flushText(controller, buffer);
+        buffer = "";
+      }
+      controller.enqueue(chunk);
+    };
+    const handleTextDeltaChunk = (controller, delta) => {
+      if (toolCall) {
+        toolCall.raw += delta;
+        toolCall.innerBuffer += delta;
+        processToolCall2(controller);
+        return;
+      }
+      if (implicitCall) {
+        const callState = implicitCall;
+        const { done, remainder } = consumeCall(
+          controller,
+          callState,
+          delta,
+          null
+        );
+        if (!done) {
+          return;
+        }
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        if (remainder.length > 0) {
+          buffer = remainder + buffer;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        drainStarts(controller);
+        return;
+      }
+      buffer += delta;
+      stripLeadingToolCallCloseTagsFromBuffer();
+      flushSafeTextPrefix(controller);
+      drainStarts(controller);
+    };
+    const handleTransformChunk = (controller, chunk) => {
+      if (chunk.type === "finish") {
+        handleFinish(controller);
+        controller.enqueue(chunk);
+        return;
+      }
+      if (chunk.type !== "text-delta") {
+        handlePassthroughChunk(controller, chunk);
+        return;
+      }
+      const delta = chunk.delta;
+      if (!delta) {
+        return;
+      }
+      handleTextDeltaChunk(controller, delta);
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        handleTransformChunk(controller, chunk);
+      },
+      flush(controller) {
+        handleFinish(controller);
+      }
+    });
+  }
+});
+var uiTarsXmlProtocol = qwen3CoderProtocol;
+var Qwen3CoderToolParser = qwen3CoderProtocol;
 
-// src/core/protocols/yaml-protocol.ts
+// src/core/protocols/yaml-xml-protocol.ts
 import YAML from "yaml";
-function shouldEmitRawToolCallTextOnError3(options) {
-  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
-}
-var selfClosingTagCache2 = /* @__PURE__ */ new Map();
-function getSelfClosingTagPattern2(toolName) {
-  let pattern = selfClosingTagCache2.get(toolName);
-  if (!pattern) {
-    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
-    selfClosingTagCache2.set(toolName, pattern);
-  }
-  return pattern;
-}
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 var INCOMPLETE_MAPPING_TAIL_RE = /^[^:[\]{}-][^:]*:\s*$/;
 var INCOMPLETE_SEQUENCE_TAIL_RE = /^-\s*$/;
@@ -2452,7 +4632,7 @@ function stabilizeParsedValueForStreamProgress(value, source) {
   }
   return trimTrailingNewlineInUnknown(value);
 }
-function findClosingTagEnd(text, contentStart, toolName) {
+function findClosingTagEnd2(text, contentStart, toolName) {
   let pos = contentStart;
   let depth = 1;
   while (pos < text.length) {
@@ -2512,34 +4692,19 @@ function findClosingTagEnd(text, contentStart, toolName) {
   }
   return -1;
 }
-function findEarliestTagPosition(openIdx, selfIdx) {
-  const hasSelf = selfIdx !== -1;
-  const hasOpen = openIdx !== -1;
-  if (hasSelf && (!hasOpen || selfIdx < openIdx)) {
-    return { tagStart: selfIdx, isSelfClosing: true };
-  }
-  return { tagStart: openIdx, isSelfClosing: false };
-}
 function collectToolCallsForName(text, toolName) {
   const toolCalls = [];
   let searchIndex = 0;
   const startTag = `<${toolName}>`;
-  const selfTagRegex = getSelfClosingTagPattern2(toolName);
   while (searchIndex < text.length) {
-    const openIdx = text.indexOf(startTag, searchIndex);
-    selfTagRegex.lastIndex = searchIndex;
-    const selfMatch = selfTagRegex.exec(text);
-    const selfIdx = selfMatch ? selfMatch.index : -1;
-    const selfTagLength = selfMatch ? selfMatch[0].length : 0;
-    if (openIdx === -1 && selfIdx === -1) {
+    const match = findNextToolTag(text, searchIndex, toolName);
+    if (match === null) {
       break;
     }
-    const { tagStart, isSelfClosing } = findEarliestTagPosition(
-      openIdx,
-      selfIdx
-    );
+    const tagStart = match.tagStart;
+    const isSelfClosing = match.isSelfClosing;
     if (isSelfClosing) {
-      const endIndex = tagStart + selfTagLength;
+      const endIndex = tagStart + match.tagLength;
       toolCalls.push({
         toolName,
         startIndex: tagStart,
@@ -2550,7 +4715,7 @@ function collectToolCallsForName(text, toolName) {
       continue;
     }
     const contentStart = tagStart + startTag.length;
-    const fullTagEnd = findClosingTagEnd(text, contentStart, toolName);
+    const fullTagEnd = findClosingTagEnd2(text, contentStart, toolName);
     if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
       const endTag = `</${toolName}>`;
       const endTagStart = fullTagEnd - endTag.length;
@@ -2645,38 +4810,6 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
   }
   return tc.endIndex;
 }
-function findEarliestToolTag2(buffer, toolNames) {
-  let bestIndex = -1;
-  let bestName = "";
-  let bestSelfClosing = false;
-  let bestTagLength = 0;
-  for (const name of toolNames) {
-    const openTag = `<${name}>`;
-    const selfTagRegex = getSelfClosingTagPattern2(name);
-    const idxOpen = buffer.indexOf(openTag);
-    selfTagRegex.lastIndex = 0;
-    const selfMatch = selfTagRegex.exec(buffer);
-    const idxSelf = selfMatch ? selfMatch.index : -1;
-    if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
-      bestIndex = idxOpen;
-      bestName = name;
-      bestSelfClosing = false;
-      bestTagLength = openTag.length;
-    }
-    if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
-      bestIndex = idxSelf;
-      bestName = name;
-      bestSelfClosing = true;
-      bestTagLength = selfMatch ? selfMatch[0].length : 0;
-    }
-  }
-  return {
-    index: bestIndex,
-    name: bestName,
-    selfClosing: bestSelfClosing,
-    tagLength: bestTagLength
-  };
-}
 function stripTrailingPartialCloseTag(content, toolName) {
   const closeTag = `</${toolName}>`;
   const lastLineBreakIndex = Math.max(
@@ -2700,10 +4833,10 @@ function stripTrailingPartialCloseTag(content, toolName) {
   )}${preservedLeadingWhitespace}`;
   return contentWithoutPartial.trimEnd();
 }
-var yamlProtocol = (_protocolOptions) => {
+var yamlXmlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      return toolSystemPromptTemplate(tools || []);
+      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
     },
     formatToolCall(toolCall) {
       let args = {};
@@ -2719,7 +4852,7 @@ var yamlProtocol = (_protocolOptions) => {
 ${yamlContent}</${toolCall.toolName}>`;
     },
     parseGeneratedText({ text, tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      const toolNames = extractToolNames(tools);
       if (toolNames.length === 0) {
         return [{ type: "text", text }];
       }
@@ -2755,7 +4888,7 @@ ${yamlContent}</${toolCall.toolName}>`;
       return processedElements;
     },
     createStreamParser({ tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      const toolNames = extractToolNames(tools);
       let buffer = "";
       let currentToolCall = null;
       let currentTextId = null;
@@ -2778,16 +4911,19 @@ ${yamlContent}</${toolCall.toolName}>`;
         if (parsedArgs === null) {
           return;
         }
-        const fullInput = JSON.stringify(parsedArgs);
+        const fullInput = stringifyToolInputWithSchema({
+          toolName: currentToolCall.name,
+          args: parsedArgs,
+          tools
+        });
         if (fullInput === "{}" && toolContent.trim().length === 0) {
           return;
         }
-        const prefixCandidate = toIncompleteJsonPrefix(fullInput);
-        emitPrefixDelta({
+        emitToolInputProgressDelta({
           controller,
           id: currentToolCall.toolCallId,
           state: currentToolCall,
-          candidate: prefixCandidate
+          fullInput
         });
       };
       const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
@@ -2795,38 +4931,43 @@ ${yamlContent}</${toolCall.toolName}>`;
         const parsedArgs = parseYamlContent(toolContent, options);
         flushText(controller);
         if (parsedArgs !== null) {
-          const finalInput = JSON.stringify(parsedArgs);
+          const finalInput = stringifyToolInputWithSchema({
+            toolName,
+            args: parsedArgs,
+            tools
+          });
           if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
-            emitFinalRemainder({
+            emitFinalizedToolInputLifecycle({
               controller,
               id: toolCallId,
               state: currentToolCall,
-              finalFullJson: finalInput,
+              toolName,
+              finalInput,
               onMismatch: options == null ? void 0 : options.onError
             });
+          } else {
+            enqueueToolInputEndAndCall({
+              controller,
+              id: toolCallId,
+              toolName,
+              input: finalInput
+            });
           }
-          controller.enqueue({
-            type: "tool-input-end",
-            id: toolCallId
-          });
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            input: finalInput
-          });
         } else {
-          controller.enqueue({
-            type: "tool-input-end",
-            id: toolCallId
-          });
           const original = `<${toolName}>${toolContent}</${toolName}>`;
+          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+          emitFailedToolInputLifecycle({
+            controller,
+            id: toolCallId,
+            emitRawToolCallTextOnError: emitRawFallback,
+            rawToolCallText: original,
+            emitRawText: (rawText) => {
+              flushText(controller, rawText);
+            }
+          });
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
             toolCall: original
           });
-          if (shouldEmitRawToolCallTextOnError3(options)) {
-            flushText(controller, original);
-          }
         }
       };
       const finalizeUnclosedToolCall = (controller) => {
@@ -2840,38 +4981,36 @@ ${yamlContent}</${toolCall.toolName}>`;
         const parsedArgs = parseYamlContent(reconciledBuffer, options);
         flushText(controller);
         if (parsedArgs !== null) {
-          const finalInput = JSON.stringify(parsedArgs);
-          emitFinalRemainder({
+          const finalInput = stringifyToolInputWithSchema({
+            toolName,
+            args: parsedArgs,
+            tools
+          });
+          emitFinalizedToolInputLifecycle({
             controller,
             id: toolCallId,
             state: currentToolCall,
-            finalFullJson: finalInput,
-            onMismatch: options == null ? void 0 : options.onError
-          });
-          controller.enqueue({
-            type: "tool-input-end",
-            id: toolCallId
-          });
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId,
             toolName,
-            input: finalInput
+            finalInput,
+            onMismatch: options == null ? void 0 : options.onError
           });
         } else {
-          controller.enqueue({
-            type: "tool-input-end",
-            id: toolCallId
-          });
           const unfinishedContent = `<${toolName}>${buffer}`;
+          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+          emitFailedToolInputLifecycle({
+            controller,
+            id: toolCallId,
+            emitRawToolCallTextOnError: emitRawFallback,
+            rawToolCallText: unfinishedContent,
+            emitRawText: (rawText) => {
+              flushText(controller, rawText);
+            }
+          });
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
             options,
             "Could not complete streaming YAML tool call at finish.",
             { toolCall: unfinishedContent }
           );
-          if (shouldEmitRawToolCallTextOnError3(options)) {
-            flushText(controller, unfinishedContent);
-          }
         }
         buffer = "";
         currentToolCall = null;
@@ -2948,7 +5087,7 @@ ${yamlContent}</${toolCall.toolName}>`;
               break;
             }
           } else {
-            const { index, name, selfClosing, tagLength } = findEarliestToolTag2(
+            const { index, name, selfClosing, tagLength } = findEarliestToolTag(
               buffer,
               toolNames
             );
@@ -3145,9 +5284,38 @@ function decodeOriginalTools(originalTools, options) {
   }
   return decodedTools;
 }
+function decodeOriginalToolsFromProviderOptions(providerOptions, options) {
+  var _a;
+  return decodeOriginalTools(
+    (_a = providerOptions == null ? void 0 : providerOptions.toolCallMiddleware) == null ? void 0 : _a.originalTools,
+    options
+  );
+}
 function extractToolNamesFromOriginalTools(originalTools) {
   return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getToolCallMiddlewareOptions(providerOptions) {
+  if (!isRecord(providerOptions)) {
+    return {};
+  }
+  const toolCallMiddleware = providerOptions.toolCallMiddleware;
+  if (!isRecord(toolCallMiddleware)) {
+    return {};
+  }
+  return toolCallMiddleware;
+}
+function mergeToolCallMiddlewareOptions(providerOptions, overrides) {
+  return {
+    ...isRecord(providerOptions) ? providerOptions : {},
+    toolCallMiddleware: {
+      ...getToolCallMiddlewareOptions(providerOptions),
+      ...overrides
+    }
+  };
+}
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
@@ -3167,7 +5335,7 @@ function hasInputProperty(obj) {
 }
 
 // src/core/utils/generated-text-json-recovery.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function safeStringify2(value) {
@@ -3323,7 +5491,7 @@ function toRecoveredParts(text, candidate, toolCallPart) {
   return out;
 }
 function parseAsToolPayload(payload, tools) {
-  if (!isRecord(payload)) {
+  if (!isRecord2(payload)) {
     return null;
   }
   const toolName = typeof payload.name === "string" && payload.name.trim().length > 0 ? payload.name.trim() : null;
@@ -3334,7 +5502,7 @@ function parseAsToolPayload(payload, tools) {
     return null;
   }
   const rawArgs = Object.hasOwn(payload, "arguments") ? payload.arguments : {};
-  if (!isRecord(rawArgs)) {
+  if (!isRecord2(rawArgs)) {
     return null;
   }
   return {
@@ -3344,14 +5512,14 @@ function parseAsToolPayload(payload, tools) {
 }
 function isLikelyArgumentsShapeForTool(args, tool) {
   const unwrapped = unwrapJsonSchema(tool.inputSchema);
-  if (!isRecord(unwrapped)) {
+  if (!isRecord2(unwrapped)) {
     return false;
   }
   if (getSchemaType(unwrapped) !== "object") {
     return false;
   }
   const properties = unwrapped.properties;
-  if (!isRecord(properties)) {
+  if (!isRecord2(properties)) {
     return false;
   }
   const keys = Object.keys(args);
@@ -3371,11 +5539,11 @@ function parseAsArgumentsOnly(payload, tools) {
   if (tools.length !== 1) {
     return null;
   }
-  if (!isRecord(payload)) {
+  if (!isRecord2(payload)) {
     return null;
   }
   const hasNameEnvelope = Object.hasOwn(payload, "name") && typeof payload.name === "string" && payload.name.length > 0;
-  const hasArgumentsEnvelope = Object.hasOwn(payload, "arguments") && (typeof payload.arguments === "string" || isRecord(payload.arguments));
+  const hasArgumentsEnvelope = Object.hasOwn(payload, "arguments") && (typeof payload.arguments === "string" || isRecord2(payload.arguments));
   if (hasNameEnvelope || hasArgumentsEnvelope) {
     return null;
   }
@@ -3410,36 +5578,6 @@ function recoverToolCallFromJsonCandidates(text, tools) {
   return null;
 }
 
-// src/core/utils/tool-call-coercion.ts
-function coerceToolCallInput(toolName, input, tools) {
-  var _a;
-  let args = {};
-  if (typeof input === "string") {
-    try {
-      args = JSON.parse(input);
-    } catch (e) {
-      return;
-    }
-  } else if (input && typeof input === "object") {
-    args = input;
-  } else {
-    return;
-  }
-  const schema = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
-  return JSON.stringify(coerced != null ? coerced : {});
-}
-function coerceToolCallPart(part, tools) {
-  const coercedInput = coerceToolCallInput(part.toolName, part.input, tools);
-  if (coercedInput === void 0) {
-    return part;
-  }
-  return {
-    ...part,
-    input: coercedInput
-  };
-}
-
 // src/core/utils/tool-choice.ts
 function ensureNonEmptyToolName(name) {
   if (typeof name !== "string") {
@@ -3494,6 +5632,30 @@ function parseToolChoicePayload({
     input: coercedInput != null ? coercedInput : safeStringify3(rawArgs)
   };
 }
+function resolveToolChoiceSelection({
+  text,
+  tools,
+  onError,
+  errorMessage
+}) {
+  if (typeof text !== "string") {
+    return {
+      toolName: "unknown",
+      input: "{}",
+      originText: ""
+    };
+  }
+  const parsed = parseToolChoicePayload({
+    text,
+    tools,
+    onError,
+    errorMessage
+  });
+  return {
+    ...parsed,
+    originText: text
+  };
+}
 
 // src/generate-handler.ts
 function logDebugSummary(debugSummary, toolCall, originText) {
@@ -3513,29 +5675,23 @@ async function handleToolChoice(doGenerate, params, tools) {
   var _a, _b, _c, _d;
   const result = await doGenerate();
   const first = (_a = result.content) == null ? void 0 : _a[0];
+  const firstText = (first == null ? void 0 : first.type) === "text" ? first.text : void 0;
   const onError = (_b = extractOnErrorOption(params.providerOptions)) == null ? void 0 : _b.onError;
-  let toolName = "unknown";
-  let input = "{}";
-  if (first && first.type === "text") {
-    if (getDebugLevel() === "parse") {
-      logRawChunk(first.text);
-    }
-    const parsed = parseToolChoicePayload({
-      text: first.text,
-      tools,
-      onError,
-      errorMessage: "Failed to parse toolChoice JSON from generated model output"
-    });
-    toolName = parsed.toolName;
-    input = parsed.input;
+  if (typeof firstText === "string" && getDebugLevel() === "parse") {
+    logRawChunk(firstText);
   }
+  const { toolName, input, originText } = resolveToolChoiceSelection({
+    text: firstText,
+    tools,
+    onError,
+    errorMessage: "Failed to parse toolChoice JSON from generated model output"
+  });
   const toolCall = {
     type: "tool-call",
     toolCallId: generateToolCallId(),
     toolName,
     input
   };
-  const originText = first && first.type === "text" ? first.text : "";
   const debugSummary = (_d = (_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) == null ? void 0 : _d.debugSummary;
   logDebugSummary(debugSummary, toolCall, originText);
   return {
@@ -3556,7 +5712,7 @@ function parseContent(content, protocol, tools, providerOptions) {
       tools,
       options: {
         ...extractOnErrorOption(providerOptions),
-        ...providerOptions == null ? void 0 : providerOptions.toolCallMiddleware
+        ...getToolCallMiddlewareOptions(providerOptions)
       }
     });
     const hasToolCall = parsedByProtocol.some(
@@ -3614,10 +5770,9 @@ async function wrapGenerate({
   doGenerate,
   params
 }) {
-  var _a, _b;
   const onError = extractOnErrorOption(params.providerOptions);
-  const tools = originalToolsSchema.decode(
-    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools,
+  const tools = decodeOriginalToolsFromProviderOptions(
+    params.providerOptions,
     onError
   );
   if (isToolChoiceActive(params)) {
@@ -3647,23 +5802,147 @@ async function wrapGenerate({
   };
 }
 
-// src/core/prompts/hermes-system-prompt.ts
-function hermesSystemPromptTemplate(tools) {
-  const toolsJson = JSON.stringify(tools);
-  return `You are a function calling AI model.
-You are provided with function signatures within <tools></tools> XML tags.
-You may call one or more functions to assist with the user query.
-Don't make assumptions about what values to plug into functions.
-Here are the available tools: <tools>${toolsJson}</tools>
-Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
-For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
-<tool_call>
-{"name": "<function-name>", "arguments": <args-dict>}
-</tool_call>`;
+// src/core/prompts/shared/text-part.ts
+function toTextPart(text, providerOptions) {
+  if (providerOptions === void 0) {
+    return {
+      type: "text",
+      text
+    };
+  }
+  return {
+    type: "text",
+    text,
+    providerOptions
+  };
 }
 
-// src/core/prompts/tool-response.ts
-function unwrapToolResult(result) {
+// src/core/prompts/shared/tool-result-normalizer.ts
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getMediaKindFromMediaType(mediaType) {
+  if (mediaType.startsWith("image/")) {
+    return "image";
+  }
+  if (mediaType.startsWith("audio/")) {
+    return "audio";
+  }
+  if (mediaType.startsWith("video/")) {
+    return "video";
+  }
+  return "file";
+}
+function getContentPartMediaKind(part) {
+  const contentPart = isMapping(part) ? part : void 0;
+  const type = contentPart == null ? void 0 : contentPart.type;
+  switch (type) {
+    case "image-data":
+    case "image-url":
+    case "image-file-id":
+      return "image";
+    case "file-data":
+    case "file-url":
+    case "file-id": {
+      const mediaType = contentPart == null ? void 0 : contentPart.mediaType;
+      if (typeof mediaType === "string") {
+        return getMediaKindFromMediaType(mediaType);
+      }
+      return "file";
+    }
+    case "media": {
+      const mediaType = contentPart == null ? void 0 : contentPart.mediaType;
+      if (typeof mediaType === "string") {
+        return getMediaKindFromMediaType(mediaType);
+      }
+      return "file";
+    }
+    default:
+      return null;
+  }
+}
+function shouldPassRawByStrategy(mediaKind, strategy) {
+  var _a;
+  const mode = getMediaMode(strategy);
+  if (mode === "raw") {
+    return true;
+  }
+  if (mode === "placeholder") {
+    return false;
+  }
+  if (mode === "model") {
+    return false;
+  }
+  return ((_a = strategy == null ? void 0 : strategy.capabilities) == null ? void 0 : _a[mediaKind]) === true;
+}
+function getMediaMode(strategy) {
+  var _a;
+  return (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+}
+function shouldPassRawContent(contentParts, strategy) {
+  const mode = getMediaMode(strategy);
+  if (mode === "raw") {
+    return true;
+  }
+  if (mode === "placeholder") {
+    return false;
+  }
+  if (mode === "model") {
+    return false;
+  }
+  let hasSupportedMediaContent = false;
+  for (const part of contentParts) {
+    const mediaKind = getContentPartMediaKind(part);
+    if (!mediaKind) {
+      continue;
+    }
+    hasSupportedMediaContent = true;
+    if (!shouldPassRawByStrategy(mediaKind, strategy)) {
+      return false;
+    }
+  }
+  return hasSupportedMediaContent;
+}
+function formatIdPlaceholder(label, fileId) {
+  const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+  return `[${label}: ${displayId}]`;
+}
+function formatContentPartPlaceholder(part) {
+  var _a;
+  const contentPart = part;
+  switch (contentPart.type) {
+    case "text":
+      return (_a = contentPart.text) != null ? _a : "";
+    case "image-data":
+      return `[Image: ${contentPart.mediaType}]`;
+    case "image-url":
+      return `[Image URL: ${contentPart.url}]`;
+    case "image-file-id": {
+      const fileId = contentPart.fileId;
+      return formatIdPlaceholder("Image ID", fileId);
+    }
+    case "file-data": {
+      const filePart = contentPart;
+      if (filePart.filename) {
+        return `[File: ${filePart.filename} (${filePart.mediaType})]`;
+      }
+      return `[File: ${filePart.mediaType}]`;
+    }
+    case "file-url":
+      return `[File URL: ${contentPart.url}]`;
+    case "file-id": {
+      const fileId = contentPart.fileId;
+      return formatIdPlaceholder("File ID", fileId);
+    }
+    case "media":
+      return `[Media: ${contentPart.mediaType}]`;
+    case "custom":
+      return "[Custom content]";
+    default:
+      return "[Unknown content]";
+  }
+}
+function unwrapToolResult(result, mediaStrategy) {
   var _a, _b;
   switch (result.type) {
     case "text":
@@ -3679,43 +5958,11 @@ function unwrapToolResult(result) {
     case "error-json":
       return `[Error: ${JSON.stringify(result.value)}]`;
     case "content": {
-      return result.value.map((part) => {
-        var _a2;
-        const contentPart = part;
-        switch (contentPart.type) {
-          case "text":
-            return (_a2 = contentPart.text) != null ? _a2 : "";
-          case "image-data":
-            return `[Image: ${contentPart.mediaType}]`;
-          case "image-url":
-            return `[Image URL: ${contentPart.url}]`;
-          case "image-file-id": {
-            const fileId = contentPart.fileId;
-            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
-            return `[Image ID: ${displayId}]`;
-          }
-          case "file-data": {
-            const filePart = contentPart;
-            if (filePart.filename) {
-              return `[File: ${filePart.filename} (${filePart.mediaType})]`;
-            }
-            return `[File: ${filePart.mediaType}]`;
-          }
-          case "file-url":
-            return `[File URL: ${contentPart.url}]`;
-          case "file-id": {
-            const fileId = contentPart.fileId;
-            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
-            return `[File ID: ${displayId}]`;
-          }
-          case "media":
-            return `[Media: ${contentPart.mediaType}]`;
-          case "custom":
-            return "[Custom content]";
-          default:
-            return "[Unknown content]";
-        }
-      }).join("\n");
+      const parts = result.value;
+      if (shouldPassRawContent(parts, mediaStrategy)) {
+        return parts;
+      }
+      return parts.map(formatContentPartPlaceholder).join("\n");
     }
     default: {
       const _exhaustive = result;
@@ -3723,58 +5970,89 @@ function unwrapToolResult(result) {
     }
   }
 }
-function formatToolResponseAsJsonInXml(toolResult) {
-  const unwrappedResult = unwrapToolResult(toolResult.output);
+
+// src/core/prompts/hermes-prompt.ts
+function formatToolResponseAsHermesWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
   return `<tool_response>${JSON.stringify({
-    toolName: toolResult.toolName,
-    result: unwrappedResult
+    name: toolResult.toolName,
+    content: unwrappedResult
   })}</tool_response>`;
 }
-function formatToolResponseAsXml(toolResult) {
-  const unwrappedResult = unwrapToolResult(toolResult.output);
-  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
-  const resultLines = formatXmlNode("result", unwrappedResult, 1);
-  return [
-    "<tool_response>",
-    `  ${toolNameXml}`,
-    ...resultLines,
-    "</tool_response>"
-  ].join("\n");
+function formatToolResponseAsHermes(toolResult) {
+  return formatToolResponseAsHermesWithOptions(toolResult);
 }
-function formatXmlNode(tagName, value, depth) {
-  const indent = "  ".repeat(depth);
-  if (value === null || value === void 0) {
-    return [`${indent}<${tagName}></${tagName}>`];
+function jsonSchemaToPythonType(schema) {
+  const type = schema.type;
+  if (type === "string") {
+    return "str";
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  if (type === "number") {
+    return "float";
   }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return [`${indent}<${tagName}></${tagName}>`];
+  if (type === "integer") {
+    return "int";
+  }
+  if (type === "boolean") {
+    return "bool";
+  }
+  if (type === "array") {
+    const items = schema.items;
+    if (items) {
+      return `list[${jsonSchemaToPythonType(items)}]`;
     }
-    const lines2 = [`${indent}<${tagName}>`];
-    for (const item of value) {
-      lines2.push(...formatXmlNode("item", item, depth + 1));
+    return "list[Any]";
+  }
+  if (type === "object") {
+    const additionalProperties = schema.additionalProperties;
+    if (additionalProperties) {
+      return `dict[str, ${jsonSchemaToPythonType(additionalProperties)}]`;
     }
-    lines2.push(`${indent}</${tagName}>`);
-    return lines2;
+    return "dict";
   }
-  const entries = Object.entries(value);
-  if (entries.length === 0) {
-    return [`${indent}<${tagName}></${tagName}>`];
+  if (Array.isArray(type)) {
+    return `Union[${type.map((t) => jsonSchemaToPythonType({ type: t })).join(",")}]`;
   }
-  const lines = [`${indent}<${tagName}>`];
-  for (const [key, entryValue] of entries) {
-    lines.push(...formatXmlNode(key, entryValue, depth + 1));
+  return "Any";
+}
+function renderToolDefinition(tool) {
+  var _a, _b;
+  const schema = tool.inputSchema;
+  const properties = schema.properties;
+  const paramSignature = properties ? Object.entries(properties).map(([name, field]) => `${name}: ${jsonSchemaToPythonType(field)}`).join(", ") : "";
+  const desc = (_a = tool.description) != null ? _a : "";
+  let description = `${tool.name}(${paramSignature}) - ${desc}
+
+`;
+  if (properties && Object.keys(properties).length > 0) {
+    description += "    Args:\n";
+    for (const [paramName, paramFields] of Object.entries(properties)) {
+      const paramDesc = (_b = paramFields.description) != null ? _b : "";
+      description += `        ${paramName}(${jsonSchemaToPythonType(paramFields)}): ${paramDesc.trim()}
+`;
+    }
   }
-  lines.push(`${indent}</${tagName}>`);
-  return lines;
+  const parametersJson = JSON.stringify(schema);
+  const descJson = JSON.stringify(description);
+  const nameJson = JSON.stringify(tool.name);
+  return `{"type": "function", "function": {"name": ${nameJson}, "description": ${descJson}, "parameters": ${parametersJson}}}`;
+}
+function hermesSystemPromptTemplate(tools) {
+  const toolsRendered = tools.map(renderToolDefinition).join("\n");
+  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> ${toolsRendered} </tools>
+Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
 }
 
-// src/core/prompts/xml-system-prompt.ts
+// src/core/prompts/morph-xml-prompt.ts
 import dedent from "dedent";
-function xmlSystemPromptTemplate(tools) {
+function morphXmlSystemPromptTemplate(tools) {
   const toolsText = renderToolsForXmlPrompt(tools);
   const header = dedent`
     # Tools
@@ -3998,9 +6276,202 @@ function stripSchemaKeys(value) {
   }
   return value;
 }
+function formatXmlNode(tagName, value, depth) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${indent}<${tagName}></${tagName}>`];
+    }
+    const lines2 = [`${indent}<${tagName}>`];
+    for (const item of value) {
+      lines2.push(...formatXmlNode("item", item, depth + 1));
+    }
+    lines2.push(`${indent}</${tagName}>`);
+    return lines2;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  const lines = [`${indent}<${tagName}>`];
+  for (const [key, entryValue] of entries) {
+    lines.push(...formatXmlNode(key, entryValue, depth + 1));
+  }
+  lines.push(`${indent}</${tagName}>`);
+  return lines;
+}
+function morphFormatToolResponseAsXmlWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
+  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
+  const resultLines = formatXmlNode("result", unwrappedResult, 1);
+  return [
+    "<tool_response>",
+    `  ${toolNameXml}`,
+    ...resultLines,
+    "</tool_response>"
+  ].join("\n");
+}
+function morphFormatToolResponseAsXml(toolResult) {
+  return morphFormatToolResponseAsXmlWithOptions(toolResult);
+}
+
+// src/core/prompts/qwen3coder-prompt.ts
+var QWEN3CODER_TOOL_HEADER = "# Tools\n\nYou have access to the following functions:\n\n";
+var QWEN3CODER_TOOL_CALL_INSTRUCTIONS = "\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>";
+var XML_PROMPT_TAG_NAME_RE = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSequence(value) {
+  return Array.isArray(value);
+}
+function toJinjaString(value) {
+  if (value === void 0) {
+    return "";
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function toJinjaTrimmedString(value) {
+  return toJinjaString(value).trim();
+}
+function toEscapedXmlText(value) {
+  return escapeXmlMinimalText(toJinjaString(value));
+}
+function toEscapedTrimmedXmlText(value) {
+  return escapeXmlMinimalText(toJinjaTrimmedString(value));
+}
+function renderXmlPromptField(key, escapedValue) {
+  if (XML_PROMPT_TAG_NAME_RE.test(key)) {
+    return `
+<${key}>${escapedValue}</${key}>`;
+  }
+  return `
+<property name="${escapeXmlMinimalAttr(
+    key,
+    '"'
+  )}">${escapedValue}</property>`;
+}
+function renderExtraKeys(jsonDict, handledKeys) {
+  if (!isMapping2(jsonDict)) {
+    return "";
+  }
+  const handled = new Set(handledKeys);
+  let out = "";
+  for (const [jsonKey, jsonValue] of Object.entries(jsonDict)) {
+    if (handled.has(jsonKey)) {
+      continue;
+    }
+    const renderedValue = isMapping2(jsonValue) || isSequence(jsonValue) ? JSON.stringify(jsonValue) : toJinjaString(jsonValue);
+    out += renderXmlPromptField(jsonKey, escapeXmlMinimalText(renderedValue));
+  }
+  return out;
+}
+function normalizeInputSchema(inputSchema) {
+  if (typeof inputSchema !== "string") {
+    return inputSchema;
+  }
+  try {
+    return JSON.parse(inputSchema);
+  } catch (e) {
+    return inputSchema;
+  }
+}
+function normalizeTool(rawTool) {
+  return {
+    name: rawTool.name,
+    description: rawTool.description,
+    parameters: normalizeInputSchema(rawTool.inputSchema)
+  };
+}
+function renderParameter(paramName, paramFieldsRaw) {
+  const paramFields = isMapping2(paramFieldsRaw) ? paramFieldsRaw : void 0;
+  let out = "\n<parameter>";
+  out += `
+<name>${toEscapedXmlText(paramName)}</name>`;
+  if ((paramFields == null ? void 0 : paramFields.type) !== void 0) {
+    out += `
+<type>${toEscapedXmlText(paramFields.type)}</type>`;
+  }
+  if ((paramFields == null ? void 0 : paramFields.description) !== void 0) {
+    out += `
+<description>${toEscapedTrimmedXmlText(paramFields.description)}</description>`;
+  }
+  out += renderExtraKeys(paramFieldsRaw, ["name", "type", "description"]);
+  out += "\n</parameter>";
+  return out;
+}
+function renderTool(tool) {
+  let out = `
+<function>
+<name>${toEscapedXmlText(tool.name)}</name>`;
+  if (tool.description !== void 0) {
+    out += `
+<description>${toEscapedTrimmedXmlText(tool.description)}</description>`;
+  }
+  out += "\n<parameters>";
+  const parameters = tool.parameters;
+  if (isMapping2(parameters) && isMapping2(parameters.properties)) {
+    for (const [paramName, paramFieldsRaw] of Object.entries(
+      parameters.properties
+    )) {
+      out += renderParameter(paramName, paramFieldsRaw);
+    }
+  }
+  out += renderExtraKeys(parameters, ["type", "properties"]);
+  out += "\n</parameters>";
+  out += renderExtraKeys(tool, ["type", "name", "description", "parameters"]);
+  out += "\n</function>";
+  return out;
+}
+function qwen3coderSystemPromptTemplate(tools) {
+  if (!tools.length) {
+    return "";
+  }
+  let out = `${QWEN3CODER_TOOL_HEADER}<tools>`;
+  for (const tool of tools) {
+    out += renderTool(normalizeTool(tool));
+  }
+  out += "\n</tools>";
+  out += QWEN3CODER_TOOL_CALL_INSTRUCTIONS;
+  return out;
+}
+function stringifyToolResponseContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function formatToolResponseAsQwen3CoderXmlWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
+  const content = stringifyToolResponseContent(unwrappedResult);
+  return `<tool_response>
+${content}
+</tool_response>`;
+}
+function formatToolResponseAsQwen3CoderXml(toolResult) {
+  return formatToolResponseAsQwen3CoderXmlWithOptions(toolResult);
+}
 
-// src/core/prompts/yaml-system-prompt.ts
-function yamlSystemPromptTemplate(tools, includeMultilineExample = true) {
+// src/core/prompts/yaml-xml-prompt.ts
+function yamlXmlSystemPromptTemplate(tools, includeMultilineExample = true) {
   const toolsJson = JSON.stringify(tools);
   const multilineExample = includeMultilineExample ? `
 
@@ -4039,6 +6510,9 @@ unit: celsius
 - Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
 - If a task requires multiple function calls, make ALL of them at once.`;
 }
+function formatToolResponseAsYaml(toolResult) {
+  return morphFormatToolResponseAsXml(toolResult);
+}
 
 // src/stream-handler.ts
 async function wrapStream({
@@ -4047,10 +6521,9 @@ async function wrapStream({
   doGenerate,
   params
 }) {
-  var _a, _b, _c;
   const onErrorOptions = extractOnErrorOption(params.providerOptions);
-  const tools = originalToolsSchema.decode(
-    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools,
+  const tools = decodeOriginalToolsFromProviderOptions(
+    params.providerOptions,
     onErrorOptions
   );
   if (isToolChoiceActive(params)) {
@@ -4064,7 +6537,7 @@ async function wrapStream({
   const debugLevel = getDebugLevel();
   const options = {
     ...onErrorOptions,
-    ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
+    ...getToolCallMiddlewareOptions(params.providerOptions)
   };
   const coreStream = stream.pipeThrough(
     new TransformStream(
@@ -4114,18 +6587,14 @@ async function toolChoiceStream({
   var _a;
   const normalizedTools = Array.isArray(tools) ? tools : [];
   const result = await doGenerate();
-  let toolName = "unknown";
-  let input = "{}";
-  if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
-    const parsed = parseToolChoicePayload({
-      text: result.content[0].text,
-      tools: normalizedTools,
-      onError: options == null ? void 0 : options.onError,
-      errorMessage: "Failed to parse toolChoice JSON from streamed model output"
-    });
-    toolName = parsed.toolName;
-    input = parsed.input;
-  }
+  const first = (_a = result == null ? void 0 : result.content) == null ? void 0 : _a[0];
+  const firstText = (first == null ? void 0 : first.type) === "text" ? first.text : void 0;
+  const { toolName, input } = resolveToolChoiceSelection({
+    text: firstText,
+    tools: normalizedTools,
+    onError: options == null ? void 0 : options.onError,
+    errorMessage: "Failed to parse toolChoice JSON from streamed model output"
+  });
   const stream = new ReadableStream({
     start(controller) {
       controller.enqueue({
@@ -4203,8 +6672,108 @@ function normalizeUsage(usage) {
   return ZERO_USAGE;
 }
 
+// src/core/prompts/shared/assistant-tool-calls-to-text.ts
+function assistantToolCallsToTextContent(options) {
+  var _a, _b;
+  const newContent = [];
+  for (const item of options.content) {
+    switch (item.type) {
+      case "tool-call":
+        newContent.push({
+          type: "text",
+          text: options.protocol.formatToolCall(item)
+        });
+        break;
+      case "text":
+      case "reasoning":
+        newContent.push(item);
+        break;
+      default:
+        (_b = (_a = options.conversionOptions) == null ? void 0 : _a.onError) == null ? void 0 : _b.call(
+          _a,
+          "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+          { content: item }
+        );
+        newContent.push({
+          type: "text",
+          text: JSON.stringify(item)
+        });
+    }
+  }
+  if (!newContent.every((entry) => entry.type === "text")) {
+    return newContent;
+  }
+  return [
+    {
+      type: "text",
+      text: newContent.map((entry) => entry.text).join("\n")
+    }
+  ];
+}
+
+// src/core/prompts/shared/tool-role-to-user-message.ts
+function formatApprovalResponse(part) {
+  const status = part.approved ? "Approved" : "Denied";
+  const reason = part.reason ? `: ${part.reason}` : "";
+  return `[Tool Approval ${status}${reason}]`;
+}
+function normalizeTemplateResult(result) {
+  if (typeof result === "string") {
+    return [toTextPart(result)];
+  }
+  return result;
+}
+function appendSection(target, section) {
+  if (section.length === 0) {
+    return;
+  }
+  if (target.length > 0) {
+    target.push(toTextPart("\n"));
+  }
+  target.push(...section);
+}
+function mergeAdjacentTextParts(parts) {
+  const merged = [];
+  for (const part of parts) {
+    const last = merged.at(-1);
+    const canMergeTextParts = part.type === "text" && (last == null ? void 0 : last.type) === "text" && part.providerOptions === void 0 && last.providerOptions === void 0;
+    if (canMergeTextParts) {
+      last.text += part.text;
+      continue;
+    }
+    merged.push(part);
+  }
+  return merged;
+}
+function toolRoleContentToUserTextMessage(options) {
+  const toolResultParts = options.toolContent.filter(
+    (part) => part.type === "tool-result"
+  );
+  const approvalResponseParts = options.toolContent.filter(
+    (part) => part.type === "tool-approval-response"
+  );
+  const sections = [];
+  for (const toolResult of toolResultParts) {
+    const result = options.toolResponsePromptTemplate(toolResult);
+    appendSection(sections, normalizeTemplateResult(result));
+  }
+  for (const approvalResponse of approvalResponseParts) {
+    appendSection(sections, [
+      toTextPart(formatApprovalResponse(approvalResponse))
+    ]);
+  }
+  const normalizedSections = sections.length > 0 ? sections : [toTextPart("")];
+  return {
+    role: "user",
+    content: mergeAdjacentTextParts(normalizedSections)
+  };
+}
+
 // src/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
+  if (systemPrompt.trim().length === 0) {
+    return processedPrompt;
+  }
   const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
   if (systemIndex !== -1) {
     const existing = processedPrompt[systemIndex].content;
@@ -4254,13 +6823,9 @@ function buildBaseReturnParams(params, finalPrompt, functionTools) {
     prompt: finalPrompt,
     tools: [],
     toolChoice: void 0,
-    providerOptions: {
-      ...params.providerOptions || {},
-      toolCallMiddleware: {
-        ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
-        originalTools: originalToolsSchema.encode(functionTools)
-      }
-    }
+    providerOptions: mergeToolCallMiddlewareOptions(params.providerOptions, {
+      originalTools: originalToolsSchema.encode(functionTools)
+    })
   };
 }
 function findProviderDefinedTool(tools, selectedToolName) {
@@ -4312,13 +6877,10 @@ function handleToolChoiceTool(params, baseReturnParams) {
       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 || {},
-        ...params.toolChoice ? { toolChoice: params.toolChoice } : {}
-      }
-    }
+    providerOptions: mergeToolCallMiddlewareOptions(
+      baseReturnParams.providerOptions,
+      params.toolChoice ? { toolChoice: params.toolChoice } : {}
+    )
   };
 }
 function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
@@ -4338,13 +6900,12 @@ function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
       type: "json",
       schema: createDynamicIfThenElseSchema(functionTools)
     },
-    providerOptions: {
-      ...baseReturnParams.providerOptions || {},
-      toolCallMiddleware: {
-        ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+    providerOptions: mergeToolCallMiddlewareOptions(
+      baseReturnParams.providerOptions,
+      {
         toolChoice: { type: "required" }
       }
-    }
+    )
   };
 }
 function transformParams({
@@ -4400,94 +6961,30 @@ function transformParams({
   }
   return baseReturnParams;
 }
-function processAssistantContent(content, resolvedProtocol, providerOptions) {
-  var _a;
-  const newContent = [];
-  for (const item of content) {
-    switch (item.type) {
-      case "tool-call":
-        newContent.push({
-          type: "text",
-          text: resolvedProtocol.formatToolCall(item)
-        });
-        break;
-      case "text":
-      case "reasoning":
-        newContent.push(item);
-        break;
-      default: {
-        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: item }
-        );
-        newContent.push({
-          type: "text",
-          text: JSON.stringify(item)
-        });
-      }
-    }
-  }
-  const onlyText = newContent.every((c) => c.type === "text");
-  return onlyText ? [
-    {
-      type: "text",
-      text: newContent.map((c) => c.text).join("\n")
-    }
-  ] : newContent;
-}
-function formatApprovalResponse(part) {
-  const status = part.approved ? "Approved" : "Denied";
-  const reason = part.reason ? `: ${part.reason}` : "";
-  return `[Tool Approval ${status}${reason}]`;
-}
-function processToolMessage(toolResults, approvalResponses, toolResponsePromptTemplate) {
-  const resultTexts = toolResults.map((toolResult) => {
-    return toolResponsePromptTemplate(toolResult);
-  });
-  const approvalTexts = approvalResponses.map(formatApprovalResponse);
-  const allTexts = [...resultTexts, ...approvalTexts];
-  return {
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: allTexts.join("\n")
-      }
-    ]
-  };
-}
 function processMessage(message, resolvedProtocol, providerOptions, toolResponsePromptTemplate) {
   if (message.role === "assistant") {
-    const condensedContent = processAssistantContent(
-      message.content,
-      resolvedProtocol,
-      providerOptions
-    );
+    const condensedContent = assistantToolCallsToTextContent({
+      content: message.content,
+      protocol: resolvedProtocol,
+      conversionOptions: {
+        onError: providerOptions == null ? void 0 : providerOptions.onError
+      }
+    });
     return {
       role: "assistant",
       content: condensedContent
     };
   }
   if (message.role === "tool") {
-    const toolContent = message.content;
-    const toolResultParts = toolContent.filter(
-      (part) => part.type === "tool-result"
-    );
-    const approvalResponseParts = toolContent.filter(
-      (part) => part.type === "tool-approval-response"
-    );
     if (!toolResponsePromptTemplate) {
       throw new Error(
         'toolResponsePromptTemplate is required when processing messages with role "tool". This parameter is optional for other roles but is required here so tool-result content can be converted into a prompt. Ensure your middleware or transform configuration passes a toolResponsePromptTemplate when tool message processing is enabled.'
       );
     }
-    return processToolMessage(
-      toolResultParts,
-      approvalResponseParts,
+    return toolRoleContentToUserTextMessage({
+      toolContent: message.content,
       toolResponsePromptTemplate
-    );
+    });
   }
   return message;
 }
@@ -4538,6 +7035,9 @@ function mergeConsecutiveUserMessages(processedPrompt) {
     const current = processedPrompt[i];
     const prev = processedPrompt[i - 1];
     if (current.role === "user" && prev.role === "user") {
+      if (!(isAllTextContent(prev.content) && isAllTextContent(current.content))) {
+        continue;
+      }
       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] = {
@@ -4597,19 +7097,24 @@ function createToolMiddleware({
 
 // src/preconfigured-middleware.ts
 var hermesToolMiddleware = createToolMiddleware({
-  protocol: jsonProtocol({}),
+  protocol: hermesProtocol(),
   toolSystemPromptTemplate: hermesSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsJsonInXml
+  toolResponsePromptTemplate: formatToolResponseAsHermes
+});
+var qwen3CoderToolMiddleware = createToolMiddleware({
+  protocol: qwen3CoderProtocol,
+  toolSystemPromptTemplate: qwen3coderSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsQwen3CoderXml
 });
-var xmlToolMiddleware = createToolMiddleware({
-  protocol: xmlProtocol({}),
-  toolSystemPromptTemplate: xmlSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsXml
+var morphXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol({}),
+  toolSystemPromptTemplate: morphXmlSystemPromptTemplate,
+  toolResponsePromptTemplate: morphFormatToolResponseAsXml
 });
-var yamlToolMiddleware = createToolMiddleware({
-  protocol: yamlProtocol({}),
-  toolSystemPromptTemplate: yamlSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsXml
+var yamlXmlToolMiddleware = createToolMiddleware({
+  protocol: yamlXmlProtocol({}),
+  toolSystemPromptTemplate: yamlXmlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsYaml
 });
 
 export {
@@ -4619,27 +7124,35 @@ export {
   logParsedChunk,
   logParsedSummary,
   getPotentialStartIndex,
-  jsonProtocol,
+  hermesProtocol,
+  morphXmlProtocol,
   isProtocolFactory,
   isTCMProtocolFactory,
-  xmlProtocol,
-  yamlProtocol,
+  qwen3CoderProtocol,
+  uiTarsXmlProtocol,
+  Qwen3CoderToolParser,
+  yamlXmlProtocol,
   createDynamicIfThenElseSchema,
   extractOnErrorOption,
   originalToolsSchema,
   encodeOriginalTools,
   decodeOriginalTools,
+  decodeOriginalToolsFromProviderOptions,
   extractToolNamesFromOriginalTools,
+  getToolCallMiddlewareOptions,
+  mergeToolCallMiddlewareOptions,
   isToolChoiceActive,
   isToolResultPart,
   hasInputProperty,
   wrapGenerate,
+  morphFormatToolResponseAsXml,
   wrapStream,
   toolChoiceStream,
   transformParams,
   createToolMiddleware,
   hermesToolMiddleware,
-  xmlToolMiddleware,
-  yamlToolMiddleware
+  qwen3CoderToolMiddleware,
+  morphXmlToolMiddleware,
+  yamlXmlToolMiddleware
 };
-//# sourceMappingURL=chunk-DPGORNPB.js.map
+//# sourceMappingURL=chunk-722D5BGD.js.map