@ai-sdk-tool/parser 4.1.20 → 4.1.21

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;
@@ -2281,7 +2570,9 @@ function canonicalizeArgumentsProgressInput(progress, toolName, tools) {
     return void 0;
   }
   try {
-    const parsedArguments = parse(progress.argumentsText);
+    const parsedArguments = parse(
+      normalizeJsonStringCtrl(progress.argumentsText)
+    );
     return stringifyToolInputWithSchema({
       toolName,
       args: parsedArguments,
@@ -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*>/;
@@ -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();
@@ -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 void 0;
+  }
+  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 void 0;
+  }
+  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 });
     };
@@ -7465,7 +7950,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 +7964,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 +8427,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 +8507,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 +8527,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 +8559,8 @@ var qwen3CoderProtocol = () => ({
         if (!result.ok && openTag) {
           reportUnfinishedImplicitCallAtFinish(
             controller,
-            callState.raw || openTag + callState.buffer
+            callState.raw || openTag + callState.buffer,
+            callState
           );
         }
       } else {
@@ -8430,26 +8939,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,11 +8992,16 @@ 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 result = parseYamlContent(tc.content);
+  if (!result.ok) {
     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
+      toolCall: originalText,
+      toolName: tc.toolName,
+      toolCallId: generateToolCallId(),
+      dropReason: "malformed-tool-call-body",
+      cause
     });
     processedElements.push({ type: "text", text: originalText });
   } else {
@@ -8493,7 +9009,7 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
       type: "tool-call",
       toolCallId: generateToolCallId(),
       toolName: tc.toolName,
-      input: JSON.stringify(parsedArgs)
+      input: JSON.stringify(result.value)
     });
   }
   return tc.endIndex;
@@ -8616,9 +9132,9 @@ ${yamlContent}</${toolCall.toolName}>`;
       };
       const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
         var _a;
-        const parsedArgs = parseYamlContent(toolContent, options);
+        const result = parseYamlContent(toolContent);
         flushText(controller);
-        if (parsedArgs === null) {
+        if (!result.ok) {
           const original = `<${toolName}>${toolContent}</${toolName}>`;
           const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
           emitFailedToolInputLifecycle({
@@ -8631,12 +9147,16 @@ ${yamlContent}</${toolCall.toolName}>`;
             }
           });
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
-            toolCall: original
+            toolCall: original,
+            toolName,
+            toolCallId,
+            dropReason: "malformed-tool-call-body",
+            cause: yamlFailureCause(result.failure)
           });
         } else {
           const finalInput = stringifyToolInputWithSchema({
             toolName,
-            args: parsedArgs,
+            args: result.value,
             tools
           });
           if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
@@ -8666,9 +9186,9 @@ ${yamlContent}</${toolCall.toolName}>`;
         emitToolInputProgress2(controller, buffer);
         const { name: toolName, toolCallId } = currentToolCall;
         const reconciledBuffer = stripTrailingPartialCloseTag(buffer, toolName);
-        const parsedArgs = parseYamlContent(reconciledBuffer, options);
+        const result = parseYamlContent(reconciledBuffer);
         flushText(controller);
-        if (parsedArgs === null) {
+        if (!result.ok) {
           const unfinishedContent = `<${toolName}>${buffer}`;
           const emitRawFallback = shouldEmitRawToolCallTextOnError(options);
           emitFailedToolInputLifecycle({
@@ -8683,12 +9203,18 @@ ${yamlContent}</${toolCall.toolName}>`;
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
             options,
             "Could not complete streaming YAML tool call at finish.",
-            { toolCall: unfinishedContent }
+            {
+              toolCall: unfinishedContent,
+              toolCallId,
+              toolName,
+              dropReason: "unfinished-tool-call",
+              cause: yamlFailureCause(result.failure)
+            }
           );
         } else {
           const finalInput = stringifyToolInputWithSchema({
             toolName,
-            args: parsedArgs,
+            args: result.value,
             tools
           });
           emitFinalizedToolInputLifecycle({