@ai-sdk-tool/parser 4.1.20 → 4.1.22

package/dist/index.cjs

@@ -988,11 +988,6 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
   };
 }
 
-// src/core/utils/regex.ts
-function escapeRegExp(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 // src/core/utils/streamed-tool-input-delta.ts
 function emitDelta({
   controller,
@@ -1974,13 +1969,312 @@ function shouldEmitRawToolCallTextOnError(options) {
 }
 
 // src/core/protocols/hermes-protocol.ts
+var RJSON_IDENTIFIER_CHAR_REGEX = /[$a-zA-Z0-9_\-+.*?!|&%^/#\\]/;
+var RJSON_NUMBER_TOKEN_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function validateNonEmptyDelimiters(toolCallStart, toolCallEnd) {
+  if (toolCallStart.length === 0) {
+    throw new TypeError("hermesProtocol toolCallStart must not be empty");
+  }
+  if (toolCallEnd.length === 0) {
+    throw new TypeError("hermesProtocol toolCallEnd must not be empty");
+  }
+  return {};
+}
+function isRjsonIdentifierChar(ch) {
+  return ch != null && RJSON_IDENTIFIER_CHAR_REGEX.test(ch);
+}
+function isRjsonPropertyLikeDelimiter(startTag) {
+  const key = startTag.endsWith(":") ? startTag.slice(0, -1) : "";
+  return key.length > 0 && [...key].every((ch) => isRjsonIdentifierChar(ch));
+}
+function previousRjsonToken(json, index, minIndex = 0) {
+  let start = index - 1;
+  while (start >= minIndex && isRjsonIdentifierChar(json[start])) {
+    start -= 1;
+  }
+  return json.slice(start + 1, index);
+}
+function previousTokenAllowsComment(json, index, minIndex = 0) {
+  const previous = previousRjsonToken(json, index, minIndex);
+  if (previous.length === 0) {
+    return true;
+  }
+  return RJSON_NUMBER_TOKEN_REGEX.test(previous) || previous === "true" || previous === "false" || previous === "null";
+}
+function startsRjsonComment(json, index, minIndex = 0) {
+  if (!(json[index] === "/" && json[index + 1] === "/" || json[index] === "/" && json[index + 1] === "*")) {
+    return false;
+  }
+  if (index > minIndex && isRjsonIdentifierChar(json[index - 1])) {
+    return previousTokenAllowsComment(json, index, minIndex);
+  }
+  return true;
+}
+function hasNestedStartBoundary(segment, startIndex) {
+  const previous = segment[startIndex - 1];
+  return previous == null || WHITESPACE_JSON_REGEX.test(previous) || previous === "}";
+}
+function isLikelyNestedToolCallStart(segment, startIndex, startTag) {
+  if (isRjsonPropertyLikeDelimiter(startTag)) {
+    return false;
+  }
+  const jsonStart = skipJsonWhitespace(segment, startIndex + startTag.length);
+  return segment[jsonStart] === "{" && hasNestedStartBoundary(segment, startIndex);
+}
+function findToolCallBoundaryOutsideRjsonSyntax(text, scanFrom, startTag, endTag) {
+  let quote = null;
+  let esc = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let lineCommentSawEndTag = false;
+  let blockCommentSawEndTag = false;
+  let nestedStartIndex = null;
+  for (let index = scanFrom; index < text.length; index += 1) {
+    const ch = text[index];
+    if (esc) {
+      esc = false;
+      continue;
+    }
+    if (quote !== null) {
+      if (ch === "\\") {
+        esc = true;
+        continue;
+      }
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") {
+        inLineComment = false;
+        lineCommentSawEndTag = false;
+        continue;
+      }
+      if (text.startsWith(endTag, index)) {
+        lineCommentSawEndTag = true;
+        index += endTag.length - 1;
+        continue;
+      }
+      if (lineCommentSawEndTag && text.startsWith(startTag, index) && text[skipJsonWhitespace(text, index + startTag.length)] === "{") {
+        nestedStartIndex = index;
+        inLineComment = false;
+        lineCommentSawEndTag = false;
+        index += startTag.length - 1;
+        continue;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && text[index + 1] === "/") {
+        inBlockComment = false;
+        blockCommentSawEndTag = false;
+        index += 1;
+        continue;
+      }
+      if (text.startsWith(endTag, index)) {
+        blockCommentSawEndTag = true;
+        index += endTag.length - 1;
+        continue;
+      }
+      if (blockCommentSawEndTag && text.startsWith(startTag, index) && text[skipJsonWhitespace(text, index + startTag.length)] === "{") {
+        nestedStartIndex = index;
+        inBlockComment = false;
+        blockCommentSawEndTag = false;
+        index += startTag.length - 1;
+        continue;
+      }
+      continue;
+    }
+    if (startsRjsonComment(text, index, scanFrom)) {
+      if (text[index + 1] === "/") {
+        inLineComment = true;
+        lineCommentSawEndTag = false;
+        index += 1;
+        continue;
+      }
+      if (text[index + 1] === "*") {
+        inBlockComment = true;
+        blockCommentSawEndTag = false;
+        index += 1;
+        continue;
+      }
+    }
+    if (text.startsWith(endTag, index)) {
+      return nestedStartIndex == null ? { kind: "end", endIdx: index } : { kind: "nested", endIdx: index, nestedStartIndex };
+    }
+    if (nestedStartIndex == null && text.startsWith(startTag, index) && isLikelyNestedToolCallStart(text, index, startTag)) {
+      nestedStartIndex = index;
+      index += startTag.length - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+    }
+  }
+  return null;
+}
+function findNextToolCallSpan(text, searchFrom, startTag, endTag) {
+  const startIdx = text.indexOf(startTag, searchFrom);
+  if (startIdx === -1) {
+    return null;
+  }
+  const jsonStart = startIdx + startTag.length;
+  const boundary = findToolCallBoundaryOutsideRjsonSyntax(
+    text,
+    jsonStart,
+    startTag,
+    endTag
+  );
+  if (boundary == null) {
+    return { startIdx, found: false };
+  }
+  if (boundary.kind === "nested") {
+    return { startIdx, found: false };
+  }
+  return { startIdx, found: true, jsonStart, endIdx: boundary.endIdx };
+}
 function canonicalizeToolInput(argumentsValue) {
   return JSON.stringify(argumentsValue != null ? argumentsValue : {});
 }
+var CHAR_CODE_BACKSLASH = 92;
+var CHAR_CODE_QUOTE = 34;
+var CHAR_CODE_LF = 10;
+var CHAR_CODE_CR = 13;
+var CHAR_CODE_TAB = 9;
+var CHAR_CODE_SLASH = 47;
+var CHAR_CODE_STAR = 42;
+var CHAR_CODE_CONTROL_UPPER = 31;
+var CHAR_CODE_SINGLE_QUOTE = 39;
+function hasControlCharInString(json) {
+  let quote = null;
+  let esc = false;
+  for (let i = 0; i < json.length; i += 1) {
+    const code = json.charCodeAt(i);
+    if (esc) {
+      esc = false;
+      if (code <= CHAR_CODE_CONTROL_UPPER) {
+        return true;
+      }
+      continue;
+    }
+    if (quote !== null && code === CHAR_CODE_BACKSLASH) {
+      esc = true;
+      continue;
+    }
+    if (quote !== null) {
+      if (code === quote) {
+        quote = null;
+        continue;
+      }
+      if (code <= CHAR_CODE_CONTROL_UPPER) {
+        return true;
+      }
+      continue;
+    }
+    if (code === CHAR_CODE_SLASH && json.charCodeAt(i + 1) === CHAR_CODE_SLASH) {
+      i += 2;
+      while (i < json.length && json.charCodeAt(i) !== CHAR_CODE_LF && json.charCodeAt(i) !== CHAR_CODE_CR) {
+        i += 1;
+      }
+      continue;
+    }
+    if (code === CHAR_CODE_SLASH && json.charCodeAt(i + 1) === CHAR_CODE_STAR) {
+      i += 2;
+      while (i + 1 < json.length && !(json.charCodeAt(i) === CHAR_CODE_STAR && json.charCodeAt(i + 1) === CHAR_CODE_SLASH)) {
+        i += 1;
+      }
+      i += 1;
+      continue;
+    }
+    if (code === CHAR_CODE_QUOTE || code === CHAR_CODE_SINGLE_QUOTE) {
+      quote = code;
+    }
+  }
+  return false;
+}
+function normalizeJsonStringCtrl(json) {
+  if (!hasControlCharInString(json)) {
+    return json;
+  }
+  const parts = [];
+  let chunkStart = 0;
+  let quote = null;
+  let esc = false;
+  const flushUpTo = (end) => {
+    if (chunkStart < end) {
+      parts.push(json.slice(chunkStart, end));
+    }
+  };
+  const escapeForCode = (code) => {
+    switch (code) {
+      case CHAR_CODE_LF:
+        return "\\n";
+      case CHAR_CODE_CR:
+        return "\\r";
+      case CHAR_CODE_TAB:
+        return "\\t";
+      default:
+        return `\\u${code.toString(16).padStart(4, "0")}`;
+    }
+  };
+  for (let i = 0; i < json.length; i += 1) {
+    const code = json.charCodeAt(i);
+    if (esc) {
+      esc = false;
+      if (code <= CHAR_CODE_CONTROL_UPPER) {
+        flushUpTo(i - 1);
+        parts.push(escapeForCode(code));
+        chunkStart = i + 1;
+      }
+      continue;
+    }
+    if (quote !== null && code === CHAR_CODE_BACKSLASH) {
+      esc = true;
+      continue;
+    }
+    if (quote !== null) {
+      if (code === quote) {
+        quote = null;
+        continue;
+      }
+      if (code <= CHAR_CODE_CONTROL_UPPER) {
+        flushUpTo(i);
+        parts.push(escapeForCode(code));
+        chunkStart = i + 1;
+      }
+      continue;
+    }
+    if (code === CHAR_CODE_SLASH && json.charCodeAt(i + 1) === CHAR_CODE_SLASH) {
+      i += 2;
+      while (i < json.length && json.charCodeAt(i) !== CHAR_CODE_LF && json.charCodeAt(i) !== CHAR_CODE_CR) {
+        i += 1;
+      }
+      continue;
+    }
+    if (code === CHAR_CODE_SLASH && json.charCodeAt(i + 1) === CHAR_CODE_STAR) {
+      i += 2;
+      while (i + 1 < json.length && !(json.charCodeAt(i) === CHAR_CODE_STAR && json.charCodeAt(i + 1) === CHAR_CODE_SLASH)) {
+        i += 1;
+      }
+      i += 1;
+      continue;
+    }
+    if (code === CHAR_CODE_QUOTE || code === CHAR_CODE_SINGLE_QUOTE) {
+      quote = code;
+    }
+  }
+  if (chunkStart < json.length) {
+    parts.push(json.slice(chunkStart));
+  }
+  return parts.join("");
+}
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a;
   try {
-    const parsedToolCall = parse(toolCallJson);
+    const parsedToolCall = parse(
+      normalizeJsonStringCtrl(toolCallJson)
+    );
     processedElements.push({
       type: "tool-call",
       toolCallId: generateToolCallId(),
@@ -1988,6 +2282,8 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
       input: canonicalizeToolInput(parsedToolCall.arguments)
     });
   } catch (error) {
+    const salvagedToolName = extractStreamingToolCallProgress(toolCallJson).toolName;
+    const salvagedToolCallId = generateToolCallId();
     logParseFailure({
       phase: "generated-text",
       reason: "Failed to parse tool call JSON segment",
@@ -1997,24 +2293,17 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
     (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
       options,
       "Could not process JSON tool call, keeping original text.",
-      { toolCall: fullMatch, error }
+      {
+        toolCall: fullMatch,
+        error,
+        toolName: salvagedToolName,
+        toolCallId: salvagedToolCallId,
+        dropReason: "malformed-tool-call-body"
+      }
     );
     processedElements.push({ type: "text", text: fullMatch });
   }
 }
-function processMatchedToolCall(context) {
-  const { match, text, currentIndex, processedElements, options } = context;
-  const startIndex = match.index;
-  const toolCallJson = match[1];
-  if (startIndex > currentIndex) {
-    const textSegment = text.slice(currentIndex, startIndex);
-    addTextSegment(textSegment, processedElements);
-  }
-  if (toolCallJson) {
-    processToolCallJson(toolCallJson, match[0], processedElements, options);
-  }
-  return startIndex + match[0].length;
-}
 var WHITESPACE_JSON_REGEX = /\s/;
 function skipJsonWhitespace(text, fromIndex) {
   let index = fromIndex;
@@ -2096,10 +2385,10 @@ function findTopLevelPropertyValueStart(text, property) {
 function extractTopLevelStringProperty(text, property) {
   const valueStart = findTopLevelPropertyValueStart(text, property);
   if (valueStart == null || valueStart >= text.length) {
-    return void 0;
+    return;
   }
   if (text.charAt(valueStart) !== '"') {
-    return void 0;
+    return;
   }
   let valueEnd = valueStart + 1;
   let escaped = false;
@@ -2114,7 +2403,7 @@ function extractTopLevelStringProperty(text, property) {
     }
     valueEnd += 1;
   }
-  return void 0;
+  return;
 }
 function extractJsonValueSlice(text, valueStart) {
   if (valueStart >= text.length) {
@@ -2278,10 +2567,12 @@ function emitToolCallFromParsed(state, controller, parsedToolCall, tools) {
 }
 function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
   if (progress.argumentsText === void 0 || !progress.argumentsComplete) {
-    return void 0;
+    return;
   }
   try {
-    const parsedArguments = parse(progress.argumentsText);
+    const parsedArguments = parse(
+      normalizeJsonStringCtrl(progress.argumentsText)
+    );
     return stringifyToolInputWithSchema({
       toolName,
       args: parsedArguments,
@@ -2289,7 +2580,7 @@ function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
       fallback: canonicalizeToolInput
     });
   } catch (e) {
-    return void 0;
+    return;
   }
 }
 function emitToolInputProgress(state, controller, tools) {
@@ -2341,14 +2632,16 @@ function closeTextBlock(state, controller) {
   }
 }
 function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer, tools, options) {
-  var _a;
+  var _a, _b, _c, _d;
   if (!state.currentToolCallJson && trailingBuffer.length === 0) {
     state.isInsideToolCall = false;
     return;
   }
   if (state.currentToolCallJson) {
     try {
-      const parsedToolCall = parse(state.currentToolCallJson);
+      const parsedToolCall = parse(
+        normalizeJsonStringCtrl(state.currentToolCallJson)
+      );
       emitToolCallFromParsed(state, controller, parsedToolCall, tools);
       state.currentToolCallJson = "";
       state.isInsideToolCall = false;
@@ -2380,11 +2673,19 @@ function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer
       id: errorId
     });
   }
+  const streamingToolCallId = (_b = (_a = state.activeToolInput) == null ? void 0 : _a.id) != null ? _b : generateToolCallId();
+  const streamingToolName = (_c = state.activeToolInput) == null ? void 0 : _c.toolName;
   closeToolInput(state, controller);
-  (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+  const toolName = streamingToolName != null ? streamingToolName : state.currentToolCallJson ? extractStreamingToolCallProgress(state.currentToolCallJson).toolName : void 0;
+  (_d = options == null ? void 0 : options.onError) == null ? void 0 : _d.call(
     options,
     shouldEmitRawFallback ? "Could not complete streaming JSON tool call at finish; emitting original text." : "Could not complete streaming JSON tool call at finish.",
-    { toolCall: errorContent }
+    {
+      toolCall: errorContent,
+      toolCallId: streamingToolCallId,
+      toolName,
+      dropReason: "unfinished-tool-call"
+    }
   );
   state.currentToolCallJson = "";
   state.isInsideToolCall = false;
@@ -2429,14 +2730,18 @@ function publishText(text, state, controller, tools) {
   }
 }
 function emitToolCall(context) {
-  var _a;
+  var _a, _b, _c, _d, _e;
   const { state, controller, toolCallStart, toolCallEnd, options, tools } = context;
   try {
-    const parsedToolCall = parse(state.currentToolCallJson);
+    const parsedToolCall = parse(
+      normalizeJsonStringCtrl(state.currentToolCallJson)
+    );
     emitToolCallFromParsed(state, controller, parsedToolCall, tools);
   } catch (error) {
     const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
     const shouldEmitRawFallback = shouldEmitRawToolCallTextOnError(options);
+    const streamingToolCallId = (_b = (_a = state.activeToolInput) == null ? void 0 : _a.id) != null ? _b : generateToolCallId();
+    const streamingToolName = (_d = (_c = state.activeToolInput) == null ? void 0 : _c.toolName) != null ? _d : extractStreamingToolCallProgress(state.currentToolCallJson).toolName;
     logParseFailure({
       phase: "stream",
       reason: "Failed to parse streaming tool call JSON segment",
@@ -2460,11 +2765,15 @@ function emitToolCall(context) {
       });
     }
     closeToolInput(state, controller);
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+    (_e = options == null ? void 0 : options.onError) == null ? void 0 : _e.call(
       options,
       shouldEmitRawFallback ? "Could not process streaming JSON tool call; emitting original text." : "Could not process streaming JSON tool call.",
       {
-        toolCall: errorContent
+        toolCall: errorContent,
+        error,
+        toolCallId: streamingToolCallId,
+        toolName: streamingToolName,
+        dropReason: "malformed-tool-call-body"
       }
     );
   }
@@ -2481,24 +2790,118 @@ function processTagMatch(context) {
     state.activeToolInput = null;
   }
 }
-function processBufferTags(context) {
+function recoverNestedStreamingToolCall(options) {
+  var _a, _b, _c, _d;
+  const { context, jsonSoFar, nestedStartIndex, startIndex, tag } = options;
+  const {
+    state,
+    controller,
+    toolCallStart,
+    toolCallEnd,
+    options: parserOptions
+  } = context;
+  const droppedToolCall = `${toolCallStart}${jsonSoFar.slice(
+    0,
+    nestedStartIndex
+  )}`;
+  const shouldEmitRawFallback = shouldEmitRawToolCallTextOnError(parserOptions);
+  const streamingToolCallId = (_a = state.activeToolInput) == null ? void 0 : _a.id;
+  const streamingToolName = (_c = (_b = state.activeToolInput) == null ? void 0 : _b.toolName) != null ? _c : extractStreamingToolCallProgress(jsonSoFar.slice(0, nestedStartIndex)).toolName;
+  logParseFailure({
+    phase: "stream",
+    reason: "Abandoning malformed streaming tool call before nested start tag",
+    snippet: droppedToolCall
+  });
+  if (shouldEmitRawFallback) {
+    const errorId = generateId();
+    controller.enqueue({
+      type: "text-start",
+      id: errorId
+    });
+    controller.enqueue({
+      type: "text-delta",
+      id: errorId,
+      delta: droppedToolCall
+    });
+    controller.enqueue({
+      type: "text-end",
+      id: errorId
+    });
+  }
+  closeToolInput(state, controller);
+  (_d = parserOptions == null ? void 0 : parserOptions.onError) == null ? void 0 : _d.call(
+    parserOptions,
+    shouldEmitRawFallback ? "Could not process malformed streaming JSON tool call before nested start; emitting original text." : "Could not process malformed streaming JSON tool call before nested start.",
+    {
+      toolCall: droppedToolCall,
+      toolCallId: streamingToolCallId,
+      toolName: streamingToolName,
+      dropReason: "malformed-nested-tool-call"
+    }
+  );
+  state.currentToolCallJson = "";
+  state.isInsideToolCall = false;
+  state.buffer = jsonSoFar.slice(nestedStartIndex) + toolCallEnd + state.buffer.slice(startIndex + tag.length);
+  return getPotentialStartIndex(state.buffer, toolCallStart);
+}
+function processInsideToolCallBoundary(context) {
   const { state, controller, toolCallStart, toolCallEnd, tools } = context;
-  let startIndex = getPotentialStartIndex(
-    state.buffer,
-    state.isInsideToolCall ? toolCallEnd : toolCallStart
+  const currentLength = state.currentToolCallJson.length;
+  const combined = state.currentToolCallJson + state.buffer;
+  const boundary = findToolCallBoundaryOutsideRjsonSyntax(
+    combined,
+    0,
+    toolCallStart,
+    toolCallEnd
+  );
+  if (boundary == null) {
+    return false;
+  }
+  const relativeEndIndex = boundary.endIdx - currentLength;
+  if (relativeEndIndex < 0) {
+    return false;
+  }
+  if (boundary.kind === "nested") {
+    recoverNestedStreamingToolCall({
+      context,
+      jsonSoFar: combined.slice(0, boundary.endIdx),
+      nestedStartIndex: boundary.nestedStartIndex,
+      startIndex: relativeEndIndex,
+      tag: toolCallEnd
+    });
+    return true;
+  }
+  publishText(
+    state.buffer.slice(0, relativeEndIndex),
+    state,
+    controller,
+    tools
   );
+  state.buffer = state.buffer.slice(relativeEndIndex + toolCallEnd.length);
+  processTagMatch(context);
+  return true;
+}
+function processBufferTags(context) {
+  const { state, controller, toolCallStart, tools } = context;
+  while (state.isInsideToolCall) {
+    if (!processInsideToolCallBoundary(context)) {
+      return;
+    }
+  }
+  let startIndex = getPotentialStartIndex(state.buffer, toolCallStart);
   while (startIndex != null) {
-    const tag = state.isInsideToolCall ? toolCallEnd : toolCallStart;
-    if (startIndex + tag.length > state.buffer.length) {
+    if (startIndex + toolCallStart.length > state.buffer.length) {
       break;
     }
     publishText(state.buffer.slice(0, startIndex), state, controller, tools);
-    state.buffer = state.buffer.slice(startIndex + tag.length);
+    state.buffer = state.buffer.slice(startIndex + toolCallStart.length);
     processTagMatch(context);
-    startIndex = getPotentialStartIndex(
-      state.buffer,
-      state.isInsideToolCall ? toolCallEnd : toolCallStart
-    );
+    while (state.isInsideToolCall) {
+      if (!processInsideToolCallBoundary(context)) {
+        return;
+      }
+    }
+    startIndex = getPotentialStartIndex(state.buffer, toolCallStart);
   }
 }
 function handlePartialTag(state, controller, toolCallStart, toolCallEnd, tools) {
@@ -2536,6 +2939,7 @@ var hermesProtocol = ({
   toolCallStart = "<tool_call>",
   toolCallEnd = "</tool_call>"
 } = {}) => ({
+  ...validateNonEmptyDelimiters(toolCallStart, toolCallEnd),
   formatTools({
     tools,
     toolSystemPromptTemplate
@@ -2560,24 +2964,42 @@ var hermesProtocol = ({
     text,
     options
   }) {
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
-    const toolCallRegex = new RegExp(
-      `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
-      "gs"
-    );
     const processedElements = [];
     let currentIndex = 0;
-    let match = toolCallRegex.exec(text);
-    while (match !== null) {
-      currentIndex = processMatchedToolCall({
-        match,
+    let searchFrom = 0;
+    while (searchFrom < text.length) {
+      const span = findNextToolCallSpan(
         text,
-        currentIndex,
-        processedElements,
-        options
-      });
-      match = toolCallRegex.exec(text);
+        searchFrom,
+        toolCallStart,
+        toolCallEnd
+      );
+      if (span === null) {
+        break;
+      }
+      if (!span.found) {
+        const skipTo = span.startIdx + toolCallStart.length;
+        if (skipTo > currentIndex) {
+          addTextSegment(text.slice(currentIndex, skipTo), processedElements);
+          currentIndex = skipTo;
+        }
+        searchFrom = skipTo;
+        continue;
+      }
+      const toolCallJson = text.slice(span.jsonStart, span.endIdx);
+      const fullMatch = text.slice(
+        span.startIdx,
+        span.endIdx + toolCallEnd.length
+      );
+      if (span.startIdx > currentIndex) {
+        addTextSegment(
+          text.slice(currentIndex, span.startIdx),
+          processedElements
+        );
+      }
+      processToolCallJson(toolCallJson, fullMatch, processedElements, options);
+      currentIndex = span.endIdx + toolCallEnd.length;
+      searchFrom = currentIndex;
     }
     if (currentIndex < text.length) {
       const remainingText = text.slice(currentIndex);
@@ -2630,14 +3052,26 @@ var hermesProtocol = ({
     });
   },
   extractToolCallSegments({ text }) {
-    const startEsc = escapeRegExp(toolCallStart);
-    const endEsc = escapeRegExp(toolCallEnd);
-    const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
     const segments = [];
-    let m = regex.exec(text);
-    while (m != null) {
-      segments.push(m[0]);
-      m = regex.exec(text);
+    let searchFrom = 0;
+    while (searchFrom < text.length) {
+      const span = findNextToolCallSpan(
+        text,
+        searchFrom,
+        toolCallStart,
+        toolCallEnd
+      );
+      if (span === null) {
+        break;
+      }
+      if (!span.found) {
+        searchFrom = span.startIdx + toolCallStart.length;
+        continue;
+      }
+      segments.push(
+        text.slice(span.startIdx, span.endIdx + toolCallEnd.length)
+      );
+      searchFrom = span.endIdx + toolCallEnd.length;
     }
     return segments;
   }
@@ -4485,6 +4919,11 @@ function createIntermediateCall(toolName, rawSegment, schema) {
   };
 }
 
+// src/core/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/rxml/heuristics/xml-defaults.ts
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
@@ -4696,7 +5135,7 @@ function handleOpeningTagSegment(src, lt, out, stack) {
 function extractSchemaProperties(schema) {
   const unwrapped = unwrapJsonSchema(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
-    return void 0;
+    return;
   }
   return unwrapped.properties;
 }
@@ -5128,7 +5567,13 @@ function processToolCall(params) {
     (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
       options,
       `Could not process XML tool call: ${toolCall.toolName}`,
-      { toolCall: originalCallText, error }
+      {
+        toolCall: originalCallText,
+        error,
+        toolName: toolCall.toolName,
+        toolCallId: generateToolCallId(),
+        dropReason: "malformed-tool-call-body"
+      }
     );
     processedElements.push({ type: "text", text: originalCallText });
   }
@@ -5570,7 +6015,10 @@ function handleStreamingToolCallEnd(params) {
     });
     (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "Could not process streaming XML tool call", {
       toolCall: original,
-      error
+      error,
+      toolName: currentToolCall.name,
+      toolCallId: currentToolCall.toolCallId,
+      dropReason: "malformed-tool-call-body"
     });
   }
 }
@@ -6132,7 +6580,13 @@ var morphXmlProtocol = (protocolOptions) => {
           (_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 }
+            {
+              toolCall: unfinishedContent,
+              toolCallId: currentToolCall.toolCallId,
+              toolName: currentToolCall.name,
+              dropReason: "unfinished-tool-call",
+              error
+            }
           );
         }
         buffer = "";
@@ -6358,7 +6812,8 @@ var QWEN3CODER_TOOL_PARSER_CALL_TAG_NAMES = /* @__PURE__ */ new Set([
   "invoke",
   "tool_call"
 ]);
-var CALL_SHORTHAND_VALUE_RE = /^<\s*(call|function|tool|invoke)\b\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+))/i;
+var CALL_SHORTHAND_VALUE_RE = /^<\s*(call|function|tool|invoke)\b\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/<]+))/i;
+var NESTED_CALL_SHORTHAND_VALUE_RE = /<\s*(?:call|function|tool|invoke)\b\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/<]+))/i;
 var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b/i;
 var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b[^>]*>/i;
 var QWEN3CODER_TOOL_PARSER_STREAM_TOOL_CALL_CLOSE_TAG_RE = /<\s*\/\s*tool_call\s*>/i;
@@ -6757,6 +7212,12 @@ function getShorthandValue(openTag) {
   }
   return unescapeXml(value);
 }
+function extractShorthandToolNameFromRaw(rawText) {
+  var _a, _b;
+  const match = NESTED_CALL_SHORTHAND_VALUE_RE.exec(rawText);
+  const value = (_b = (_a = match == null ? void 0 : match[1]) != null ? _a : match == null ? void 0 : match[2]) != null ? _b : match == null ? void 0 : match[3];
+  return value ? unescapeXml(value) : null;
+}
 function extractFirstTagText(xml, tagName) {
   var _a;
   const lower = xml.toLowerCase();
@@ -7039,7 +7500,7 @@ function parseQwen3CoderToolParserClosedMatches(inner, outerNameAttr) {
   var _a, _b;
   const callBlockMatches = Array.from(inner.matchAll(CALL_BLOCK_RE));
   if (callBlockMatches.length === 0) {
-    return void 0;
+    return;
   }
   const closedBlocks = [];
   let lastClosedEnd = 0;
@@ -7078,6 +7539,20 @@ function parseQwen3CoderToolParserClosedMatches(inner, outerNameAttr) {
   }
   return closedCalls.concat(trailingCalls);
 }
+var QWEN3CODER_TOOL_NAME_SALVAGE_REGEX = /<(?:function|call|tool|invoke)(?:\s*=\s*"([^"]+)"|\s*=\s*'([^']+)'|\s*=\s*([^\s>/]+)|\s+name\s*=\s*"([^"]+)"|\s+name\s*=\s*'([^']+)')|<(?:name|tool_name)\b[^>]*>([\s\S]*?)<\s*\/\s*(?:name|tool_name)\s*>/i;
+function extractQwen3CoderToolNameFromMarkup(markup) {
+  var _a, _b, _c, _d, _e;
+  const match = markup.match(QWEN3CODER_TOOL_NAME_SALVAGE_REGEX);
+  if (!match) {
+    return;
+  }
+  const name = (_e = (_d = (_c = (_b = (_a = match[1]) != null ? _a : match[2]) != null ? _b : match[3]) != null ? _c : match[4]) != null ? _d : match[5]) != null ? _e : match[6];
+  if (!name) {
+    return;
+  }
+  const trimmed = name.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 function parseQwen3CoderToolParserToolCallSegment(segment) {
   var _a;
   const extracted = extractToolCallInnerXml(segment);
@@ -7202,7 +7677,12 @@ var qwen3CoderProtocol = () => ({
         (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
           options,
           "Could not process Qwen3CoderToolParser XML tool call; keeping original text.",
-          { toolCall: fallbackText }
+          {
+            toolCall: fallbackText,
+            toolName: extractQwen3CoderToolNameFromMarkup(segment),
+            toolCallId: generateToolCallId(),
+            dropReason: "malformed-tool-call-body"
+          }
         );
         processedElements.push({ type: "text", text: fallbackText });
         return false;
@@ -7215,7 +7695,12 @@ var qwen3CoderProtocol = () => ({
       (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
         options,
         "Could not process Qwen3CoderToolParser <function> call; keeping original text.",
-        { toolCall: raw }
+        {
+          toolCall: raw,
+          toolName: extractQwen3CoderToolNameFromMarkup(raw),
+          toolCallId: generateToolCallId(),
+          dropReason: "malformed-tool-call-body"
+        }
       );
       processedElements.push({ type: "text", text: raw });
     };
@@ -7361,9 +7846,7 @@ var qwen3CoderProtocol = () => ({
       tryEmitToolCallSegment(synthetic, trailing);
       return true;
     };
-    const tryParseCallBlocksWithoutWrapper = () => {
-      return tryParseCallBlocksWithoutWrapperText(text);
-    };
+    const tryParseCallBlocksWithoutWrapper = () => tryParseCallBlocksWithoutWrapperText(text);
     const tryParseSingleFunctionCall = () => {
       const lowerText = text.toLowerCase();
       const startIndex = lowerText.indexOf("<function");
@@ -7465,7 +7948,7 @@ var qwen3CoderProtocol = () => ({
       });
     };
     const finalizeCall = (controller, callState, fallbackToolName, rawToolCallText = null) => {
-      var _a, _b;
+      var _a, _b, _c, _d;
       const resolvedToolName = (_a = callState.toolName) != null ? _a : fallbackToolName;
       if (!resolvedToolName || resolvedToolName.trim().length === 0) {
         const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
@@ -7479,12 +7962,14 @@ var qwen3CoderProtocol = () => ({
             flushText(controller, rawText);
           }
         });
-        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        (_d = options == null ? void 0 : options.onError) == null ? void 0 : _d.call(
           options,
           shouldEmitRaw && rawToolCallText ? "Could not resolve Qwen3CoderToolParser tool name for tool call; emitting original text." : "Could not resolve Qwen3CoderToolParser tool name for tool call",
           {
             toolCallId: callState.toolCallId,
-            toolCall: rawToolCallText
+            toolCall: rawToolCallText,
+            toolName: (_c = (_b = callState.toolName) != null ? _b : fallbackToolName) != null ? _c : void 0,
+            dropReason: "unresolved-tool-name"
           }
         );
         return false;
@@ -7940,25 +8425,36 @@ var qwen3CoderProtocol = () => ({
         }
       }
     };
-    const reportUnfinishedToolCallAtFinish = (controller, rawToolCall) => {
-      var _a;
+    const reportUnfinishedToolCallAtFinish = (controller, rawToolCall, metadata = {}) => {
+      var _a, _b;
       const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
-      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+      const toolName = (_a = metadata.toolName) != null ? _a : extractShorthandToolNameFromRaw(rawToolCall);
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
         options,
         shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser XML tool call at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser XML tool call at finish.",
-        { toolCall: rawToolCall }
+        {
+          toolCall: rawToolCall,
+          ...metadata.toolCallId ? { toolCallId: metadata.toolCallId } : {},
+          ...toolName ? { toolName } : {},
+          dropReason: "unfinished-tool-call"
+        }
       );
       if (shouldEmitRaw) {
         flushText(controller, rawToolCall);
       }
     };
-    const reportUnfinishedImplicitCallAtFinish = (controller, rawCallText) => {
+    const reportUnfinishedImplicitCallAtFinish = (controller, rawCallText, callState) => {
       var _a;
       const shouldEmitRaw = shouldEmitRawToolCallTextOnError(options);
       (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
         options,
         shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser call block at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser call block at finish.",
-        { toolCall: rawCallText }
+        {
+          toolCall: rawCallText,
+          toolCallId: callState.toolCallId,
+          ...callState.toolName ? { toolName: callState.toolName } : {},
+          dropReason: "unfinished-tool-call"
+        }
       );
       if (shouldEmitRaw) {
         flushText(controller, rawCallText);
@@ -8009,7 +8505,10 @@ var qwen3CoderProtocol = () => ({
               flushText(controller, result.trailingText);
             }
             if (!result.ok && toolCall.emittedToolCallCount === 0) {
-              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw, {
+                toolCallId: toolCall.activeCall.toolCallId,
+                ...toolCall.activeCall.toolName ? { toolName: toolCall.activeCall.toolName } : {}
+              });
             }
           } else if (toolCall.mode === "multi") {
             if (toolCall.activeCall) {
@@ -8026,14 +8525,21 @@ var qwen3CoderProtocol = () => ({
                 flushText(controller, result.trailingText);
               }
               if (!result.ok && toolCall.emittedToolCallCount === 0) {
-                reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+                reportUnfinishedToolCallAtFinish(controller, toolCall.raw, {
+                  toolCallId: toolCall.activeCall.toolCallId,
+                  ...toolCall.activeCall.toolName ? { toolName: toolCall.activeCall.toolName } : {}
+                });
               }
               toolCall.activeCall = null;
             } else if (toolCall.emittedToolCallCount === 0) {
-              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw, {
+                toolName: toolCall.outerNameAttr
+              });
             }
           } else {
-            reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+            reportUnfinishedToolCallAtFinish(controller, toolCall.raw, {
+              toolName: toolCall.outerNameAttr
+            });
           }
           toolCall = null;
         }
@@ -8051,7 +8557,8 @@ var qwen3CoderProtocol = () => ({
         if (!result.ok && openTag) {
           reportUnfinishedImplicitCallAtFinish(
             controller,
-            callState.raw || openTag + callState.buffer
+            callState.raw || openTag + callState.buffer,
+            callState
           );
         }
       } else {
@@ -8430,26 +8937,28 @@ function findToolCalls2(text, toolNames) {
   );
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
-function parseYamlContent(yamlContent, options) {
-  var _a, _b;
+function yamlFailureCause(failure) {
+  if (failure.kind === "yaml-parse-error") {
+    return { kind: "yaml-parse-error", errors: failure.errors };
+  }
+  return { kind: "yaml-non-mapping" };
+}
+function parseYamlContent(yamlContent) {
   const { normalized, nonEmptyLines } = normalizeYamlContent(yamlContent);
   if (nonEmptyLines.length === 0) {
-    return {};
+    return { ok: true, value: {} };
   }
   const parsed = parseYamlDocumentAsMapping(normalized);
   if (parsed.errors.length > 0) {
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "YAML parse error", {
-      errors: parsed.errors
-    });
-    return null;
+    return {
+      ok: false,
+      failure: { kind: "yaml-parse-error", errors: parsed.errors }
+    };
   }
   if (parsed.value === null) {
-    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "YAML content must be a key-value mapping", {
-      got: "non-mapping"
-    });
-    return null;
+    return { ok: false, failure: { kind: "yaml-non-mapping" } };
   }
-  return parsed.value;
+  return { ok: true, value: parsed.value };
 }
 function parseYamlContentForStreamProgress(yamlContent) {
   const { normalized, nonEmptyLines } = normalizeYamlContent(yamlContent);
@@ -8481,20 +8990,25 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
     return currentIndex;
   }
   addTextSegment(text.slice(currentIndex, tc.startIndex), processedElements);
-  const parsedArgs = parseYamlContent(tc.content, options);
-  if (parsedArgs === null) {
-    const originalText = text.slice(tc.startIndex, tc.endIndex);
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse YAML tool call", {
-      toolCall: originalText
-    });
-    processedElements.push({ type: "text", text: originalText });
-  } else {
+  const result = parseYamlContent(tc.content);
+  if (result.ok) {
     processedElements.push({
       type: "tool-call",
       toolCallId: generateToolCallId(),
       toolName: tc.toolName,
-      input: JSON.stringify(parsedArgs)
+      input: JSON.stringify(result.value)
     });
+  } else {
+    const originalText = text.slice(tc.startIndex, tc.endIndex);
+    const cause = yamlFailureCause(result.failure);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse YAML tool call", {
+      toolCall: originalText,
+      toolName: tc.toolName,
+      toolCallId: generateToolCallId(),
+      dropReason: "malformed-tool-call-body",
+      cause
+    });
+    processedElements.push({ type: "text", text: originalText });
   }
   return tc.endIndex;
 }
@@ -8521,327 +9035,335 @@ function stripTrailingPartialCloseTag(content, toolName) {
   )}${preservedLeadingWhitespace}`;
   return contentWithoutPartial.trimEnd();
 }
-var yamlXmlProtocol = (_protocolOptions) => {
-  return {
-    formatTools({ tools, toolSystemPromptTemplate }) {
-      return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
-    },
-    formatToolCall(toolCall) {
-      let args = {};
-      if (toolCall.input != null) {
-        try {
-          args = JSON.parse(toolCall.input);
-        } catch (e) {
-          args = { value: toolCall.input };
-        }
+var yamlXmlProtocol = (_protocolOptions) => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    return formatToolsWithPromptTemplate({ tools, toolSystemPromptTemplate });
+  },
+  formatToolCall(toolCall) {
+    let args = {};
+    if (toolCall.input != null) {
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = { value: toolCall.input };
       }
-      const yamlContent = import_yaml.default.stringify(args);
-      return `<${toolCall.toolName}>
+    }
+    const yamlContent = import_yaml.default.stringify(args);
+    return `<${toolCall.toolName}>
 ${yamlContent}</${toolCall.toolName}>`;
-    },
-    parseGeneratedText({ text, tools, options }) {
-      const toolNames = extractToolNames(tools);
-      if (toolNames.length === 0) {
-        return [{ type: "text", text }];
-      }
-      const processedElements = [];
-      let currentIndex = 0;
-      let parseText = text;
-      let toolCalls = findToolCalls2(parseText, toolNames);
-      if (toolCalls.length === 0) {
-        const repaired = tryRepairXmlSelfClosingRootWithBody(
-          parseText,
-          toolNames
-        );
-        if (repaired) {
-          const repairedCalls = findToolCalls2(repaired, toolNames);
-          if (repairedCalls.length > 0) {
-            parseText = repaired;
-            toolCalls = repairedCalls;
-          }
+  },
+  parseGeneratedText({ text, tools, options }) {
+    const toolNames = extractToolNames(tools);
+    if (toolNames.length === 0) {
+      return [{ type: "text", text }];
+    }
+    const processedElements = [];
+    let currentIndex = 0;
+    let parseText = text;
+    let toolCalls = findToolCalls2(parseText, toolNames);
+    if (toolCalls.length === 0) {
+      const repaired = tryRepairXmlSelfClosingRootWithBody(
+        parseText,
+        toolNames
+      );
+      if (repaired) {
+        const repairedCalls = findToolCalls2(repaired, toolNames);
+        if (repairedCalls.length > 0) {
+          parseText = repaired;
+          toolCalls = repairedCalls;
         }
       }
-      for (const tc of toolCalls) {
-        currentIndex = processToolCallMatch(
-          parseText,
-          tc,
-          currentIndex,
-          processedElements,
-          options
-        );
+    }
+    for (const tc of toolCalls) {
+      currentIndex = processToolCallMatch(
+        parseText,
+        tc,
+        currentIndex,
+        processedElements,
+        options
+      );
+    }
+    if (currentIndex < parseText.length) {
+      addTextSegment(parseText.slice(currentIndex), processedElements);
+    }
+    return processedElements;
+  },
+  createStreamParser({ tools, options }) {
+    const toolNames = extractToolNames(tools);
+    let buffer = "";
+    let currentToolCall = null;
+    let currentTextId = null;
+    let hasEmittedTextStart = false;
+    const flushText = createFlushTextHandler(
+      () => currentTextId,
+      (newId) => {
+        currentTextId = newId;
+      },
+      () => hasEmittedTextStart,
+      (value) => {
+        hasEmittedTextStart = value;
       }
-      if (currentIndex < parseText.length) {
-        addTextSegment(parseText.slice(currentIndex), processedElements);
+    );
+    const emitToolInputProgress2 = (controller, toolContent) => {
+      if (!currentToolCall) {
+        return;
       }
-      return processedElements;
-    },
-    createStreamParser({ tools, options }) {
-      const toolNames = extractToolNames(tools);
-      let buffer = "";
-      let currentToolCall = null;
-      let currentTextId = null;
-      let hasEmittedTextStart = false;
-      const flushText = createFlushTextHandler(
-        () => currentTextId,
-        (newId) => {
-          currentTextId = newId;
-        },
-        () => hasEmittedTextStart,
-        (value) => {
-          hasEmittedTextStart = value;
-        }
-      );
-      const emitToolInputProgress2 = (controller, toolContent) => {
-        if (!currentToolCall) {
-          return;
-        }
-        const parsedArgs = parseYamlContentForStreamProgress(toolContent);
-        if (parsedArgs === null) {
-          return;
-        }
-        const fullInput = stringifyToolInputWithSchema({
-          toolName: currentToolCall.name,
-          args: parsedArgs,
+      const parsedArgs = parseYamlContentForStreamProgress(toolContent);
+      if (parsedArgs === null) {
+        return;
+      }
+      const fullInput = stringifyToolInputWithSchema({
+        toolName: currentToolCall.name,
+        args: parsedArgs,
+        tools
+      });
+      if (fullInput === "{}" && toolContent.trim().length === 0) {
+        return;
+      }
+      emitToolInputProgressDelta({
+        controller,
+        id: currentToolCall.toolCallId,
+        state: currentToolCall,
+        fullInput
+      });
+    };
+    const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
+      var _a;
+      const result = parseYamlContent(toolContent);
+      flushText(controller);
+      if (result.ok) {
+        const finalInput = stringifyToolInputWithSchema({
+          toolName,
+          args: result.value,
           tools
         });
-        if (fullInput === "{}" && toolContent.trim().length === 0) {
-          return;
-        }
-        emitToolInputProgressDelta({
-          controller,
-          id: currentToolCall.toolCallId,
-          state: currentToolCall,
-          fullInput
-        });
-      };
-      const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
-        var _a;
-        const parsedArgs = parseYamlContent(toolContent, options);
-        flushText(controller);
-        if (parsedArgs === null) {
-          const original = `<${toolName}>${toolContent}</${toolName}>`;
-          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
-          emitFailedToolInputLifecycle({
+        if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
+          emitFinalizedToolInputLifecycle({
             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
-          });
-        } else {
-          const finalInput = stringifyToolInputWithSchema({
+            state: currentToolCall,
             toolName,
-            args: parsedArgs,
-            tools
-          });
-          if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
-            emitFinalizedToolInputLifecycle({
-              controller,
-              id: toolCallId,
-              state: currentToolCall,
-              toolName,
-              finalInput,
-              onMismatch: options == null ? void 0 : options.onError
-            });
-          } else {
-            enqueueToolInputEndAndCall({
-              controller,
-              id: toolCallId,
-              toolName,
-              input: finalInput
-            });
-          }
-        }
-      };
-      const finalizeUnclosedToolCall = (controller) => {
-        var _a;
-        if (!currentToolCall) {
-          return;
-        }
-        emitToolInputProgress2(controller, buffer);
-        const { name: toolName, toolCallId } = currentToolCall;
-        const reconciledBuffer = stripTrailingPartialCloseTag(buffer, toolName);
-        const parsedArgs = parseYamlContent(reconciledBuffer, options);
-        flushText(controller);
-        if (parsedArgs === null) {
-          const unfinishedContent = `<${toolName}>${buffer}`;
-          const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
-          emitFailedToolInputLifecycle({
-            controller,
-            id: toolCallId,
-            emitRawToolCallTextOnError: emitRawFallback,
-            rawToolCallText: unfinishedContent,
-            emitRawText: (rawText) => {
-              flushText(controller, rawText);
-            }
+            finalInput,
+            onMismatch: options == null ? void 0 : options.onError
           });
-          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-            options,
-            "Could not complete streaming YAML tool call at finish.",
-            { toolCall: unfinishedContent }
-          );
         } else {
-          const finalInput = stringifyToolInputWithSchema({
-            toolName,
-            args: parsedArgs,
-            tools
-          });
-          emitFinalizedToolInputLifecycle({
+          enqueueToolInputEndAndCall({
             controller,
             id: toolCallId,
-            state: currentToolCall,
             toolName,
-            finalInput,
-            onMismatch: options == null ? void 0 : options.onError
+            input: finalInput
           });
         }
-        buffer = "";
-        currentToolCall = null;
-      };
-      const handlePendingToolCall = (controller, endTag, toolName) => {
-        var _a;
-        const endIdx = buffer.indexOf(endTag);
-        if (endIdx === -1) {
-          emitToolInputProgress2(controller, buffer);
-          return false;
-        }
-        const content = buffer.slice(0, endIdx);
-        emitToolInputProgress2(controller, content);
-        buffer = buffer.slice(endIdx + endTag.length);
-        processToolCallEnd(
+      } else {
+        const original = `<${toolName}>${toolContent}</${toolName}>`;
+        const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
+        emitFailedToolInputLifecycle({
           controller,
-          content,
+          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,
           toolName,
-          (_a = currentToolCall == null ? void 0 : currentToolCall.toolCallId) != null ? _a : generateToolCallId()
+          toolCallId,
+          dropReason: "malformed-tool-call-body",
+          cause: yamlFailureCause(result.failure)
+        });
+      }
+    };
+    const finalizeUnclosedToolCall = (controller) => {
+      var _a;
+      if (!currentToolCall) {
+        return;
+      }
+      emitToolInputProgress2(controller, buffer);
+      const { name: toolName, toolCallId } = currentToolCall;
+      const reconciledBuffer = stripTrailingPartialCloseTag(buffer, toolName);
+      const result = parseYamlContent(reconciledBuffer);
+      flushText(controller);
+      if (result.ok) {
+        const finalInput = stringifyToolInputWithSchema({
+          toolName,
+          args: result.value,
+          tools
+        });
+        emitFinalizedToolInputLifecycle({
+          controller,
+          id: toolCallId,
+          state: currentToolCall,
+          toolName,
+          finalInput,
+          onMismatch: options == null ? void 0 : options.onError
+        });
+      } else {
+        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,
+            toolCallId,
+            toolName,
+            dropReason: "unfinished-tool-call",
+            cause: yamlFailureCause(result.failure)
+          }
         );
+      }
+      buffer = "";
+      currentToolCall = null;
+    };
+    const handlePendingToolCall = (controller, endTag, toolName) => {
+      var _a;
+      const endIdx = buffer.indexOf(endTag);
+      if (endIdx === -1) {
+        emitToolInputProgress2(controller, buffer);
+        return false;
+      }
+      const content = buffer.slice(0, endIdx);
+      emitToolInputProgress2(controller, content);
+      buffer = buffer.slice(endIdx + endTag.length);
+      processToolCallEnd(
+        controller,
+        content,
+        toolName,
+        (_a = currentToolCall == null ? void 0 : currentToolCall.toolCallId) != null ? _a : generateToolCallId()
+      );
+      currentToolCall = null;
+      return true;
+    };
+    const flushSafeText = (controller) => {
+      const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
+      const tail = Math.max(0, maxTagLen - 1);
+      const safeLen = Math.max(0, buffer.length - tail);
+      if (safeLen > 0) {
+        flushText(controller, buffer.slice(0, safeLen));
+        buffer = buffer.slice(safeLen);
+      }
+    };
+    const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
+      if (tagIndex > 0) {
+        flushText(controller, buffer.slice(0, tagIndex));
+      }
+      flushText(controller);
+      if (selfClosing) {
+        buffer = buffer.slice(tagIndex + tagLength);
+        const toolCallId = generateToolCallId();
+        currentToolCall = {
+          name: tagName,
+          toolCallId,
+          emittedInput: ""
+        };
+        controller.enqueue({
+          type: "tool-input-start",
+          id: toolCallId,
+          toolName: tagName
+        });
+        processToolCallEnd(controller, "", tagName, toolCallId);
         currentToolCall = null;
-        return true;
-      };
-      const flushSafeText = (controller) => {
-        const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
-        const tail = Math.max(0, maxTagLen - 1);
-        const safeLen = Math.max(0, buffer.length - tail);
-        if (safeLen > 0) {
-          flushText(controller, buffer.slice(0, safeLen));
-          buffer = buffer.slice(safeLen);
-        }
-      };
-      const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
-        if (tagIndex > 0) {
-          flushText(controller, buffer.slice(0, tagIndex));
-        }
-        flushText(controller);
-        if (selfClosing) {
-          buffer = buffer.slice(tagIndex + tagLength);
-          const toolCallId = generateToolCallId();
-          currentToolCall = {
-            name: tagName,
-            toolCallId,
-            emittedInput: ""
-          };
-          controller.enqueue({
-            type: "tool-input-start",
-            id: toolCallId,
-            toolName: tagName
-          });
-          processToolCallEnd(controller, "", tagName, toolCallId);
-          currentToolCall = null;
+      } else {
+        const startTag = `<${tagName}>`;
+        buffer = buffer.slice(tagIndex + startTag.length);
+        currentToolCall = {
+          name: tagName,
+          toolCallId: generateToolCallId(),
+          emittedInput: ""
+        };
+        controller.enqueue({
+          type: "tool-input-start",
+          id: currentToolCall.toolCallId,
+          toolName: tagName
+        });
+      }
+    };
+    const processBuffer = (controller) => {
+      while (true) {
+        if (currentToolCall) {
+          const toolName = currentToolCall.name;
+          const endTag = `</${toolName}>`;
+          if (!handlePendingToolCall(controller, endTag, toolName)) {
+            break;
+          }
         } else {
-          const startTag = `<${tagName}>`;
-          buffer = buffer.slice(tagIndex + startTag.length);
-          currentToolCall = {
-            name: tagName,
-            toolCallId: generateToolCallId(),
-            emittedInput: ""
-          };
-          controller.enqueue({
-            type: "tool-input-start",
-            id: currentToolCall.toolCallId,
-            toolName: tagName
-          });
-        }
-      };
-      const processBuffer = (controller) => {
-        while (true) {
-          if (currentToolCall) {
-            const toolName = currentToolCall.name;
-            const endTag = `</${toolName}>`;
-            if (!handlePendingToolCall(controller, endTag, toolName)) {
-              break;
-            }
-          } else {
-            const { index, name, selfClosing, tagLength } = findEarliestToolTag(
-              buffer,
-              toolNames
-            );
-            if (index === -1) {
-              flushSafeText(controller);
-              break;
-            }
-            handleNewToolTag(controller, index, name, selfClosing, tagLength);
+          const { index, name, selfClosing, tagLength } = findEarliestToolTag(
+            buffer,
+            toolNames
+          );
+          if (index === -1) {
+            flushSafeText(controller);
+            break;
           }
+          handleNewToolTag(controller, index, name, selfClosing, tagLength);
         }
-      };
-      return new TransformStream({
-        transform(chunk, controller) {
-          var _a;
-          if (chunk.type === "finish") {
-            if (currentToolCall) {
-              finalizeUnclosedToolCall(controller);
-            } else if (buffer) {
-              flushText(controller, buffer);
-              buffer = "";
-            }
-            flushText(controller);
-            controller.enqueue(chunk);
-            return;
-          }
-          if (chunk.type !== "text-delta") {
-            if (!currentToolCall && buffer) {
-              flushText(controller, buffer);
-              buffer = "";
-            }
-            controller.enqueue(chunk);
-            return;
-          }
-          const textContent = (_a = chunk.delta) != null ? _a : "";
-          buffer += textContent;
-          processBuffer(controller);
-        },
-        flush(controller) {
+      }
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        var _a;
+        if (chunk.type === "finish") {
           if (currentToolCall) {
             finalizeUnclosedToolCall(controller);
           } else if (buffer) {
             flushText(controller, buffer);
             buffer = "";
           }
-          if (currentTextId && hasEmittedTextStart) {
-            controller.enqueue({
-              type: "text-end",
-              id: currentTextId
-            });
-            hasEmittedTextStart = false;
-            currentTextId = null;
+          flushText(controller);
+          controller.enqueue(chunk);
+          return;
+        }
+        if (chunk.type !== "text-delta") {
+          if (!currentToolCall && buffer) {
+            flushText(controller, buffer);
+            buffer = "";
           }
+          controller.enqueue(chunk);
+          return;
+        }
+        const textContent = (_a = chunk.delta) != null ? _a : "";
+        buffer += textContent;
+        processBuffer(controller);
+      },
+      flush(controller) {
+        if (currentToolCall) {
+          finalizeUnclosedToolCall(controller);
+        } else if (buffer) {
+          flushText(controller, buffer);
+          buffer = "";
+        }
+        if (currentTextId && hasEmittedTextStart) {
+          controller.enqueue({
+            type: "text-end",
+            id: currentTextId
+          });
+          hasEmittedTextStart = false;
+          currentTextId = null;
         }
-      });
-    },
-    extractToolCallSegments({ text, tools }) {
-      const toolNames = tools.map((t) => t.name).filter(Boolean);
-      if (toolNames.length === 0) {
-        return [];
       }
-      return findToolCalls2(text, toolNames).map(
-        (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
-      );
+    });
+  },
+  extractToolCallSegments({ text, tools }) {
+    const toolNames = tools.map((t) => t.name).filter(Boolean);
+    if (toolNames.length === 0) {
+      return [];
     }
-  };
-};
+    return findToolCalls2(text, toolNames).map(
+      (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
+    );
+  }
+});
 
 // src/core/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
@@ -9037,7 +9559,7 @@ function parseJsonCandidate(candidateText) {
   try {
     return parse(candidateText);
   } catch (e) {
-    return void 0;
+    return;
   }
 }
 function extractCodeBlockCandidates(text) {