@ai-sdk-tool/parser 4.1.0 → 4.1.2

package/dist/{chunk-O6NWVXQD.js → chunk-X3NZ2YHV.js}

@@ -5,7 +5,7 @@ import {
   parse as parse2,
   stringify,
   unescapeXml
-} from "./chunk-MHZC45AC.js";
+} from "./chunk-D4YULTAO.js";
 import {
   parse
 } from "./chunk-QBZNMO5C.js";
@@ -222,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 });
@@ -260,10 +266,222 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
   };
 }
 
-// src/core/protocols/hermes-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 : {});
 }
@@ -527,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) {
@@ -551,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();
@@ -567,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;
   }
@@ -587,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);
   }
@@ -622,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;
@@ -631,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;
@@ -671,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 = "";
@@ -680,6 +906,7 @@ function handleFinishChunk(state, controller, toolCallStart, options, chunk) {
       controller,
       toolCallStart,
       trailingBuffer,
+      tools,
       options
     );
   } else if (state.buffer.length > 0) {
@@ -688,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();
@@ -711,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);
@@ -763,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
@@ -773,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(
@@ -782,24 +1009,34 @@ 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 = "";
   }
 }
@@ -811,7 +1048,7 @@ var hermesProtocol = ({
     tools,
     toolSystemPromptTemplate
   }) {
-    return toolSystemPromptTemplate(tools || []);
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
   },
   formatToolCall(toolCall) {
     let args = {};
@@ -857,6 +1094,7 @@ var hermesProtocol = ({
     return processedElements;
   },
   createStreamParser({
+    tools,
     options
   }) {
     const state = {
@@ -871,7 +1109,14 @@ var hermesProtocol = ({
       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") {
@@ -885,9 +1130,10 @@ var hermesProtocol = ({
           controller,
           toolCallStart,
           toolCallEnd,
-          options
+          options,
+          tools
         });
-        handlePartialTag(state, controller, toolCallStart, toolCallEnd);
+        handlePartialTag(state, controller, toolCallStart, toolCallEnd, tools);
       }
     });
   },
@@ -909,80 +1155,6 @@ var hermesProtocol = ({
 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) {
@@ -1007,15 +1179,241 @@ ${body}
 </${rootTag}>`;
 }
 
-// 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 shouldEmitRawToolCallTextOnError2(options) {
-  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
-}
-function processToolCall(params) {
+// 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);
@@ -1243,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;
@@ -1292,8 +1760,10 @@ function isStableXmlProgressCandidate(options) {
 }
 function parseXmlContentForStreamProgress({
   toolContent,
+  toolName,
   toolSchema,
-  parseOptions
+  parseOptions,
+  tools
 }) {
   const tryParse = (content) => {
     try {
@@ -1312,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) {
@@ -1331,7 +1823,11 @@ function parseXmlContentForStreamProgress({
       parsed: parsedCandidate,
       toolSchema
     })) {
-      return JSON.stringify(parsedCandidate);
+      return stringifyToolInputWithSchema({
+        toolName,
+        args: parsedCandidate,
+        tools
+      });
     }
     searchEnd = gtIndex;
   }
@@ -1356,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) {
@@ -1486,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*>`,
@@ -1529,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);
@@ -1698,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);
 }
@@ -1748,219 +2175,65 @@ function consumeToolNamePrefix(text, index, toolName) {
     if (text.charAt(i) !== toolName.charAt(nameIndex)) {
       return { index: i, done: false, valid: false };
     }
-    i += 1;
-    nameIndex += 1;
-  }
-  return { index: i, done: nameIndex === toolName.length, valid: true };
-}
-function isSelfClosingSuffixRemainder(text, index) {
-  if (text.charAt(index) !== "/") {
-    return false;
-  }
-  if (index + 1 >= text.length) {
-    return true;
-  }
-  return index + 1 === text.length - 1 && text.charAt(index + 1) === ">";
-}
-function isSelfClosingTagPrefix(suffix, toolName) {
-  let i = consumeWhitespace(suffix, 0);
-  if (i >= suffix.length) {
-    return true;
-  }
-  const nameRemainder = suffix.slice(i);
-  if (toolName.startsWith(nameRemainder)) {
-    return true;
-  }
-  const nameResult = consumeToolNamePrefix(suffix, i, toolName);
-  if (!nameResult.valid) {
-    return false;
-  }
-  i = nameResult.index;
-  if (i >= suffix.length) {
-    return true;
-  }
-  if (!nameResult.done) {
-    return false;
-  }
-  i = consumeWhitespace(suffix, i);
-  if (i >= suffix.length) {
-    return true;
-  }
-  return isSelfClosingSuffixRemainder(suffix, i);
-}
-function findPotentialToolTagStart(buffer, toolNames) {
-  if (toolNames.length === 0 || buffer.length === 0) {
-    return -1;
-  }
-  const lastGt = buffer.lastIndexOf(">");
-  const offset = lastGt === -1 ? 0 : lastGt + 1;
-  const trailing = buffer.slice(offset);
-  for (let i = trailing.length - 1; i >= 0; i -= 1) {
-    if (trailing.charAt(i) !== "<") {
-      continue;
-    }
-    const suffix = trailing.slice(i + 1);
-    for (const name of toolNames) {
-      if (isOpenTagPrefix(suffix, name) || isSelfClosingTagPrefix(suffix, name)) {
-        return offset + i;
-      }
-    }
-  }
-  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
-    };
+    i += 1;
+    nameIndex += 1;
   }
-  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
-    };
+  return { index: i, done: nameIndex === toolName.length, valid: true };
+}
+function isSelfClosingSuffixRemainder(text, index) {
+  if (text.charAt(index) !== "/") {
+    return false;
   }
-  const startTag = `<${earliestToolName}>`;
-  const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
-  setBuffer(newBuffer);
-  return {
-    buffer: newBuffer,
-    currentToolCall: emitToolInputStart(controller, earliestToolName),
-    shouldBreak: false,
-    shouldContinue: true
-  };
+  if (index + 1 >= text.length) {
+    return true;
+  }
+  return index + 1 === text.length - 1 && text.charAt(index + 1) === ">";
 }
-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 isSelfClosingTagPrefix(suffix, toolName) {
+  let i = consumeWhitespace(suffix, 0);
+  if (i >= suffix.length) {
+    return true;
+  }
+  const nameRemainder = suffix.slice(i);
+  if (toolName.startsWith(nameRemainder)) {
+    return true;
+  }
+  const nameResult = consumeToolNamePrefix(suffix, i, toolName);
+  if (!nameResult.valid) {
+    return false;
+  }
+  i = nameResult.index;
+  if (i >= suffix.length) {
+    return true;
+  }
+  if (!nameResult.done) {
+    return false;
+  }
+  i = consumeWhitespace(suffix, i);
+  if (i >= suffix.length) {
+    return true;
+  }
+  return isSelfClosingSuffixRemainder(suffix, i);
+}
+function findPotentialToolTagStart(buffer, toolNames) {
+  if (toolNames.length === 0 || buffer.length === 0) {
+    return -1;
+  }
+  const lastGt = buffer.lastIndexOf(">");
+  const offset = lastGt === -1 ? 0 : lastGt + 1;
+  const trailing = buffer.slice(offset);
+  for (let i = trailing.length - 1; i >= 0; i -= 1) {
+    if (trailing.charAt(i) !== "<") {
+      continue;
+    }
+    const suffix = trailing.slice(i + 1);
+    for (const name of toolNames) {
+      if (isOpenTagPrefix(suffix, name) || isSelfClosingTagPrefix(suffix, name)) {
+        return offset + i;
       }
     }
-  };
+  }
+  return -1;
 }
 function findToolCallsWithFallbacks(text, toolNames) {
   let parseText = text;
@@ -1992,7 +2265,7 @@ var morphXmlProtocol = (protocolOptions) => {
   };
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      return toolSystemPromptTemplate(tools || []);
+      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
     },
     formatToolCall(toolCall) {
       let args = {};
@@ -2010,7 +2283,7 @@ var morphXmlProtocol = (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 }];
       }
@@ -2046,7 +2319,7 @@ var morphXmlProtocol = (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;
@@ -2067,6 +2340,7 @@ var morphXmlProtocol = (protocolOptions) => {
           name: toolName,
           toolCallId: generateToolCallId(),
           emittedInput: "",
+          lastProgressContentLength: null,
           lastProgressGtIndex: null,
           lastProgressFullInput: null
         };
@@ -2079,7 +2353,8 @@ var morphXmlProtocol = (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;
@@ -2087,22 +2362,24 @@ var morphXmlProtocol = (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;
@@ -2110,12 +2387,11 @@ var morphXmlProtocol = (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) => {
@@ -2137,59 +2413,59 @@ var morphXmlProtocol = (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) {
@@ -2250,44 +2526,128 @@ var morphXmlProtocol = (protocolOptions) => {
 function isProtocolFactory(protocol) {
   return typeof protocol === "function";
 }
-function isTCMProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
+var isTCMProtocolFactory = isProtocolFactory;
 
-// src/core/utils/tool-call-coercion.ts
-function coerceToolCallInput(toolName, input, tools) {
+// 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;
-  let args = {};
-  if (typeof input === "string") {
-    try {
-      args = JSON.parse(input);
-    } catch (e) {
-      return;
+  const parsed = options.parseParamTagAt(
+    options.work,
+    options.lower,
+    options.lt,
+    {
+      allowEndOfString: options.allowEndOfString,
+      callEndTagNameLower: options.callState.endTagName
     }
-  } else if (input && typeof input === "object") {
-    args = input;
-  } else {
-    return;
+  );
+  if (!parsed) {
+    return {
+      nextIndex: options.lt + 1,
+      nextLastKept: options.lastKept,
+      shouldStop: false
+    };
   }
-  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;
+  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 {
-    ...part,
-    input: coercedInput
+    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
-function shouldEmitRawToolCallTextOnError3(options) {
-  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
-}
 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;
@@ -2578,10 +2938,13 @@ function parseQwen3CoderToolParserUnclosedParamValue(options) {
   );
   if (boundaryIndex == null) {
     if (!options.allowEndOfString) {
+      const rawProgressValue = options.text.slice(valueStart);
       return {
         kind: "partial",
         start: options.startIndex,
-        openEnd: options.openEnd
+        openEnd: options.openEnd,
+        name: options.paramName,
+        value: rawProgressValue ? normalizeXmlTextValue(rawProgressValue) : ""
       };
     }
     const rawValue2 = options.text.slice(valueStart);
@@ -2774,6 +3137,28 @@ function mergeParamValue(args, key, value) {
   }
   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 = {};
@@ -3042,14 +3427,6 @@ function parseToolCallInput(input) {
     return input;
   }
 }
-function stringifyToolInputWithSchema(options) {
-  const coerced = coerceToolCallInput(
-    options.toolName,
-    options.args,
-    options.tools
-  );
-  return coerced != null ? coerced : JSON.stringify(options.args);
-}
 function toQwen3CoderToolParserParamText(value) {
   if (typeof value === "string") {
     return value;
@@ -3092,7 +3469,7 @@ function appendQwen3CoderToolParserArgs(lines, args) {
 }
 var qwen3CoderProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
-    return toolSystemPromptTemplate(tools || []);
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
   },
   formatToolCall(toolCall) {
     const args = parseToolCallInput(toolCall.input);
@@ -3353,7 +3730,6 @@ var qwen3CoderProtocol = () => ({
         hasEmittedTextStart = value;
       }
     );
-    const removeSlice = (text, start, end) => text.slice(0, start) + text.slice(end);
     const maybeEmitToolInputStart = (controller, callState) => {
       if (callState.hasEmittedStart) {
         return;
@@ -3378,27 +3754,40 @@ var qwen3CoderProtocol = () => ({
       if (!toolName) {
         return;
       }
+      const argsForProgress = mergeArgsWithPartialParam(
+        callState.args,
+        callState.partialParam
+      );
       const fullInput = stringifyToolInputWithSchema({
         tools,
         toolName,
-        args: callState.args
+        args: argsForProgress
       });
       if (fullInput === "{}") {
         return;
       }
-      const prefixCandidate = toIncompleteJsonPrefix(fullInput);
-      emitPrefixDelta({
+      emitToolInputProgressDelta({
         controller,
         id: callState.toolCallId,
         state: callState,
-        candidate: prefixCandidate
+        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 = shouldEmitRawToolCallTextOnError3(options);
+        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",
@@ -3406,109 +3795,42 @@ var qwen3CoderProtocol = () => ({
             toolCallId: callState.toolCallId,
             toolCall: rawToolCallText
           }
-        );
-        if (callState.hasEmittedStart) {
-          controller.enqueue({
-            type: "tool-input-end",
-            id: callState.toolCallId
-          });
-        }
-        if (shouldEmitRaw && rawToolCallText) {
-          flushText(controller, rawToolCallText);
-        }
-        return false;
-      }
-      callState.toolName = resolvedToolName;
-      maybeEmitToolInputStart(controller, callState);
-      maybeEmitToolInputProgress(controller, callState);
-      const finalInput = stringifyToolInputWithSchema({
-        tools,
-        toolName: resolvedToolName,
-        args: callState.args
-      });
-      emitFinalRemainder({
-        controller,
-        id: callState.toolCallId,
-        state: callState,
-        finalFullJson: finalInput,
-        onMismatch: options == null ? void 0 : options.onError
-      });
-      controller.enqueue({
-        type: "tool-input-end",
-        id: callState.toolCallId
-      });
-      controller.enqueue({
-        type: "tool-call",
-        toolCallId: callState.toolCallId,
-        toolName: resolvedToolName,
-        input: finalInput
-      });
-      return true;
-    };
-    const consumeToolNameTag = (controller, callState, work) => {
-      var _a, _b, _c, _d;
-      if (callState.toolName) {
-        return work;
-      }
-      const match = QWEN3CODER_TOOL_PARSER_STREAM_NAME_TAG_RE.exec(work);
-      if (!match) {
-        return work;
-      }
-      const value = normalizeXmlTextValue((_a = match[2]) != null ? _a : "");
-      if (value.trim().length > 0) {
-        callState.toolName = value;
-      }
-      const start = (_b = match.index) != null ? _b : 0;
-      const nextWork = removeSlice(
-        work,
-        start,
-        start + ((_d = (_c = match[0]) == null ? void 0 : _c.length) != null ? _d : 0)
-      );
-      maybeEmitToolInputStart(controller, callState);
-      return nextWork;
-    };
-    const consumeParamTags = (controller, callState, work, allowEndOfString) => {
-      const lower = work.toLowerCase();
-      let index = 0;
-      let lastKept = 0;
-      let pieces = null;
-      while (true) {
-        const lt = lower.indexOf("<", index);
-        if (lt === -1) {
-          break;
-        }
-        const parsed = parseQwen3CoderToolParserParamTagAt(work, lower, lt, {
-          allowEndOfString,
-          callEndTagNameLower: callState.endTagName
-        });
-        if (!parsed) {
-          index = lt + 1;
-          continue;
-        }
-        if (parsed.kind === "partial") {
-          break;
-        }
-        mergeParamValue(callState.args, parsed.name, parsed.value);
-        pieces != null ? pieces : pieces = [];
-        pieces.push(work.slice(lastKept, parsed.start));
-        lastKept = parsed.end;
-        index = parsed.end;
-      }
-      maybeEmitToolInputStart(controller, callState);
-      if (!pieces) {
-        return work;
+        );
+        return false;
       }
-      pieces.push(work.slice(lastKept));
-      return pieces.join("");
-    };
-    const parseCallContent = (controller, callState, content, allowEndOfString) => {
-      let work = content;
-      work = consumeToolNameTag(controller, callState, work);
-      work = consumeParamTags(controller, callState, work, allowEndOfString);
+      callState.toolName = resolvedToolName;
       maybeEmitToolInputStart(controller, callState);
       maybeEmitToolInputProgress(controller, callState);
-      return work;
+      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);
@@ -3547,7 +3869,7 @@ var qwen3CoderProtocol = () => ({
     const consumeCallAtNextBoundary = (controller, callState, fallbackToolName, nextCallStart) => {
       const beforeNextCall = callState.buffer.slice(0, nextCallStart);
       const afterNextCall = callState.buffer.slice(nextCallStart);
-      callState.buffer = parseCallContent(
+      callState.buffer = parseStreamingCallContent(
         controller,
         callState,
         beforeNextCall,
@@ -3580,7 +3902,7 @@ var qwen3CoderProtocol = () => ({
         );
       }
       if (!closeMatch) {
-        callState.buffer = parseCallContent(
+        callState.buffer = parseStreamingCallContent(
           controller,
           callState,
           callState.buffer,
@@ -3591,7 +3913,7 @@ var qwen3CoderProtocol = () => ({
       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);
-      parseCallContent(controller, callState, beforeClose, true);
+      parseStreamingCallContent(controller, callState, beforeClose, true);
       callState.buffer = "";
       finalizeStreamingCall(
         controller,
@@ -3602,7 +3924,7 @@ var qwen3CoderProtocol = () => ({
       return { done: true, remainder: afterClose };
     };
     const finalizeCallAtFinish = (controller, callState, fallbackToolName) => {
-      callState.buffer = parseCallContent(
+      callState.buffer = parseStreamingCallContent(
         controller,
         callState,
         callState.buffer,
@@ -3708,6 +4030,7 @@ var qwen3CoderProtocol = () => ({
         toolCallId: generateToolCallId(),
         toolName: inlineToolName,
         hasEmittedStart: false,
+        partialParam: null,
         emittedInput: "",
         raw: openTag,
         args: {},
@@ -3791,6 +4114,7 @@ var qwen3CoderProtocol = () => ({
               toolCallId: generateToolCallId(),
               toolName: toolCall.outerNameAttr,
               hasEmittedStart: false,
+              partialParam: null,
               emittedInput: "",
               raw: toolCall.outerOpenTag,
               args: {},
@@ -3887,6 +4211,7 @@ var qwen3CoderProtocol = () => ({
               toolCallId: generateToolCallId(),
               toolName: toolNameAttr2,
               hasEmittedStart: false,
+              partialParam: null,
               emittedInput: "",
               raw: openTag,
               args: {},
@@ -3910,6 +4235,7 @@ var qwen3CoderProtocol = () => ({
             toolCallId: generateToolCallId(),
             toolName: toolNameAttr,
             hasEmittedStart: false,
+            partialParam: null,
             emittedInput: "",
             raw: openTag,
             args: {},
@@ -3925,7 +4251,7 @@ var qwen3CoderProtocol = () => ({
     };
     const reportUnfinishedToolCallAtFinish = (controller, rawToolCall) => {
       var _a;
-      const shouldEmitRaw = shouldEmitRawToolCallTextOnError3(options);
+      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.",
@@ -3937,7 +4263,7 @@ var qwen3CoderProtocol = () => ({
     };
     const reportUnfinishedImplicitCallAtFinish = (controller, rawCallText) => {
       var _a;
-      const shouldEmitRaw = shouldEmitRawToolCallTextOnError3(options);
+      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.",
@@ -3968,6 +4294,7 @@ var qwen3CoderProtocol = () => ({
                 toolCallId: generateToolCallId(),
                 toolName: toolCall.outerNameAttr,
                 hasEmittedStart: false,
+                partialParam: null,
                 emittedInput: "",
                 raw: toolCall.outerOpenTag,
                 args: {},
@@ -3986,7 +4313,7 @@ var qwen3CoderProtocol = () => ({
             if (result.ok) {
               toolCall.emittedToolCallCount += 1;
             }
-            const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+            const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
             if (shouldFlushTrailingText && result.trailingText.length > 0) {
               flushText(controller, result.trailingText);
             }
@@ -4003,7 +4330,7 @@ var qwen3CoderProtocol = () => ({
               if (result.ok) {
                 toolCall.emittedToolCallCount += 1;
               }
-              const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+              const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
               if (shouldFlushTrailingText && result.trailingText.length > 0) {
                 flushText(controller, result.trailingText);
               }
@@ -4026,7 +4353,7 @@ var qwen3CoderProtocol = () => ({
         implicitCall = null;
         implicitCallOpenTag = null;
         const result = finalizeCallAtFinish(controller, callState, null);
-        const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+        const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError(options);
         if (shouldFlushTrailingText && result.trailingText.length > 0) {
           flushText(controller, result.trailingText);
         }
@@ -4118,18 +4445,6 @@ var Qwen3CoderToolParser = qwen3CoderProtocol;
 
 // src/core/protocols/yaml-xml-protocol.ts
 import YAML from "yaml";
-function shouldEmitRawToolCallTextOnError4(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*$/;
@@ -4377,34 +4692,19 @@ function findClosingTagEnd2(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,
@@ -4510,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(
@@ -4568,7 +4836,7 @@ function stripTrailingPartialCloseTag(content, toolName) {
 var yamlXmlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      return toolSystemPromptTemplate(tools || []);
+      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
     },
     formatToolCall(toolCall) {
       let args = {};
@@ -4584,7 +4852,7 @@ var yamlXmlProtocol = (_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 }];
       }
@@ -4620,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;
@@ -4643,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) => {
@@ -4660,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 (shouldEmitRawToolCallTextOnError4(options)) {
-            flushText(controller, original);
-          }
         }
       };
       const finalizeUnclosedToolCall = (controller) => {
@@ -4705,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 (shouldEmitRawToolCallTextOnError4(options)) {
-            flushText(controller, unfinishedContent);
-          }
         }
         buffer = "";
         currentToolCall = null;
@@ -4813,7 +5087,7 @@ ${yamlContent}</${toolCall.toolName}>`;
               break;
             }
           } else {
-            const { index, name, selfClosing, tagLength } = findEarliestToolTag2(
+            const { index, name, selfClosing, tagLength } = findEarliestToolTag(
               buffer,
               toolNames
             );
@@ -5010,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;
@@ -5032,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) {
@@ -5188,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;
@@ -5199,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 {
@@ -5209,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);
@@ -5236,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;
   }
@@ -5329,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) {
@@ -5348,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 {
@@ -5391,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(
@@ -5449,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)) {
@@ -5482,6 +5802,21 @@ async function wrapGenerate({
   };
 }
 
+// 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/shared/tool-result-normalizer.ts
 function isMapping(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5527,8 +5862,8 @@ function getContentPartMediaKind(part) {
   }
 }
 function shouldPassRawByStrategy(mediaKind, strategy) {
-  var _a, _b;
-  const mode = (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+  var _a;
+  const mode = getMediaMode(strategy);
   if (mode === "raw") {
     return true;
   }
@@ -5538,11 +5873,14 @@ function shouldPassRawByStrategy(mediaKind, strategy) {
   if (mode === "model") {
     return false;
   }
-  return ((_b = strategy == null ? void 0 : strategy.capabilities) == null ? void 0 : _b[mediaKind]) === true;
+  return ((_a = strategy == null ? void 0 : strategy.capabilities) == null ? void 0 : _a[mediaKind]) === true;
 }
-function shouldPassRawContent(contentParts, strategy) {
+function getMediaMode(strategy) {
   var _a;
-  const mode = (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+  return (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+}
+function shouldPassRawContent(contentParts, strategy) {
+  const mode = getMediaMode(strategy);
   if (mode === "raw") {
     return true;
   }
@@ -5565,6 +5903,10 @@ function shouldPassRawContent(contentParts, strategy) {
   }
   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;
@@ -5577,8 +5919,7 @@ function formatContentPartPlaceholder(part) {
       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}]`;
+      return formatIdPlaceholder("Image ID", fileId);
     }
     case "file-data": {
       const filePart = contentPart;
@@ -5591,8 +5932,7 @@ function formatContentPartPlaceholder(part) {
       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}]`;
+      return formatIdPlaceholder("File ID", fileId);
     }
     case "media":
       return `[Media: ${contentPart.mediaType}]`;
@@ -5714,6 +6054,7 @@ For each function call return a json object with function name and arguments wit
 import dedent from "dedent";
 function morphXmlSystemPromptTemplate(tools) {
   const toolsText = renderToolsForXmlPrompt(tools);
+  const inputExamplesText = renderInputExamplesForXmlPrompt(tools);
   const header = dedent`
     # Tools
     You may call one or more functions to assist with the user query.
@@ -5728,7 +6069,7 @@ function morphXmlSystemPromptTemplate(tools) {
     <rules>
     - Use exactly one XML element whose tag name is the function name.
     - Put each parameter as a child element.
-    - Values must follow the schema exactly (numbers, arrays, objects, enums → copy as-is).
+    - Values must follow the schema exactly (numbers, arrays, objects, enums -> copy as-is).
     - Do not add or remove functions or parameters.
     - Each required parameter must appear once.
     - Output nothing before or after the function call.
@@ -5744,7 +6085,7 @@ function morphXmlSystemPromptTemplate(tools) {
     multiple lines</example_parameter_2>
     </example_function_name>
   `;
-  return [header, definitions, rules, examples].join("\n\n");
+  return [header, definitions, rules, examples, inputExamplesText].filter((section) => section.trim().length > 0).join("\n\n");
 }
 var INDENT = "  ";
 function renderToolsForXmlPrompt(tools) {
@@ -5764,6 +6105,67 @@ function renderToolForXmlPrompt(tool) {
   lines.push(`schema: ${stringifySchema(normalizedSchema)}`);
   return lines.join("\n");
 }
+function getToolInputExamples(tool) {
+  const inputExamples = tool.inputExamples;
+  if (!Array.isArray(inputExamples)) {
+    return [];
+  }
+  return inputExamples.filter(
+    (example) => typeof example === "object" && example !== null && "input" in example && example.input !== void 0
+  );
+}
+function safeStringifyInputExample(input, sourceError) {
+  try {
+    const serialized = JSON.stringify(input);
+    return serialized != null ? serialized : "null";
+  } catch (stringifyError) {
+    let reason = "";
+    if (sourceError instanceof Error) {
+      reason = sourceError.message;
+    } else if (stringifyError instanceof Error) {
+      reason = stringifyError.message;
+    }
+    return reason.length > 0 ? `[unserializable input: ${reason}]` : "[unserializable input]";
+  }
+}
+function renderMorphXmlInputExample(toolName, input) {
+  try {
+    return stringify(toolName, input, {
+      suppressEmptyNode: false,
+      format: true,
+      minimalEscaping: true
+    });
+  } catch (error) {
+    const fallbackContent = safeStringifyInputExample(input, error);
+    const escapedFallback = escapeXmlMinimalText(fallbackContent);
+    return `<${toolName}>${escapedFallback}</${toolName}>`;
+  }
+}
+function renderInputExamplesForXmlPrompt(tools) {
+  const renderedTools = tools.map((tool) => {
+    const inputExamples = getToolInputExamples(tool);
+    if (inputExamples.length === 0) {
+      return "";
+    }
+    const renderedExamples = inputExamples.map((example, index) => {
+      const xml = renderMorphXmlInputExample(tool.name, example.input);
+      return `Example ${index + 1}:
+${xml}`;
+    }).join("\n\n");
+    return `Tool: ${tool.name}
+${renderedExamples}`;
+  }).filter((text) => text.length > 0).join("\n\n");
+  if (renderedTools.length === 0) {
+    return "";
+  }
+  return [
+    "# Input Examples",
+    "Treat these as canonical tool-call patterns.",
+    "Reuse the closest structure and nesting, change only values, and do not invent parameters.",
+    "Do not copy example values unless they match the user's request.",
+    renderedTools
+  ].join("\n\n");
+}
 function normalizeSchema(schema) {
   if (typeof schema === "string") {
     try {
@@ -5984,45 +6386,6 @@ function morphFormatToolResponseAsXml(toolResult) {
   return morphFormatToolResponseAsXmlWithOptions(toolResult);
 }
 
-// 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/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>";
@@ -6220,10 +6583,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)) {
@@ -6237,7 +6599,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(
@@ -6287,18 +6649,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({
@@ -6376,18 +6734,51 @@ 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 toTextPart(text) {
-  return {
-    type: "text",
-    text
-  };
-}
 function normalizeTemplateResult(result) {
   if (typeof result === "string") {
     return [toTextPart(result)];
@@ -6494,13 +6885,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) {
@@ -6552,13 +6939,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) {
@@ -6578,13 +6962,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({
@@ -6816,7 +7199,10 @@ export {
   originalToolsSchema,
   encodeOriginalTools,
   decodeOriginalTools,
+  decodeOriginalToolsFromProviderOptions,
   extractToolNamesFromOriginalTools,
+  getToolCallMiddlewareOptions,
+  mergeToolCallMiddlewareOptions,
   isToolChoiceActive,
   isToolResultPart,
   hasInputProperty,
@@ -6831,4 +7217,4 @@ export {
   morphXmlToolMiddleware,
   yamlXmlToolMiddleware
 };
-//# sourceMappingURL=chunk-O6NWVXQD.js.map
+//# sourceMappingURL=chunk-X3NZ2YHV.js.map