@ai-sdk-tool/parser 3.3.3 → 4.0.0

package/dist/index.cjs

@@ -905,7 +905,25 @@ function getPotentialStartIndex(text, searchedText) {
 
 // src/core/utils/id.ts
 function generateId() {
-  return Math.random().toString(36).substring(2, 15);
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 13);
+}
+var TOOL_CALL_ID_PREFIX = "call_";
+var TOOL_CALL_ID_BODY_LENGTH = 24;
+var TOOL_CALL_ID_ALPHANUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomAlphaNumeric(length) {
+  var _a;
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (let i = 0; i < length; i += 1) {
+    const byte = bytes[i];
+    const index = (byte != null ? byte : 0) % TOOL_CALL_ID_ALPHANUM.length;
+    out += (_a = TOOL_CALL_ID_ALPHANUM[index]) != null ? _a : "0";
+  }
+  return out;
+}
+function generateToolCallId() {
+  return `${TOOL_CALL_ID_PREFIX}${randomAlphaNumeric(TOOL_CALL_ID_BODY_LENGTH)}`;
 }
 
 // src/core/utils/protocol-utils.ts
@@ -914,6 +932,38 @@ function addTextSegment(text, processedElements) {
     processedElements.push({ type: "text", text });
   }
 }
+function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
+  return (controller, text) => {
+    const content = text;
+    if (content) {
+      if (!getCurrentTextId()) {
+        const newId = generateId();
+        setCurrentTextId(newId);
+        controller.enqueue({
+          type: "text-start",
+          id: newId
+        });
+        setHasEmittedTextStart(true);
+      }
+      controller.enqueue({
+        type: "text-delta",
+        id: getCurrentTextId(),
+        delta: content
+      });
+    }
+    const currentTextId = getCurrentTextId();
+    if (currentTextId && !text) {
+      if (getHasEmittedTextStart()) {
+        controller.enqueue({
+          type: "text-end",
+          id: currentTextId
+        });
+        setHasEmittedTextStart(false);
+      }
+      setCurrentTextId(null);
+    }
+  };
+}
 
 // src/core/utils/regex.ts
 function escapeRegExp(literal) {
@@ -921,15 +971,21 @@ function escapeRegExp(literal) {
 }
 
 // src/core/protocols/json-protocol.ts
+function shouldEmitRawToolCallTextOnError(options) {
+  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+}
+function canonicalizeToolInput(argumentsValue) {
+  return JSON.stringify(argumentsValue != null ? argumentsValue : {});
+}
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
-  var _a, _b;
+  var _a;
   try {
     const parsedToolCall = parse(toolCallJson);
     processedElements.push({
       type: "tool-call",
-      toolCallId: generateId(),
+      toolCallId: generateToolCallId(),
       toolName: parsedToolCall.name,
-      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
+      input: canonicalizeToolInput(parsedToolCall.arguments)
     });
   } catch (error) {
     logParseFailure({
@@ -938,7 +994,7 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
       snippet: fullMatch,
       error
     });
-    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+    (_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 }
@@ -959,6 +1015,293 @@ function processMatchedToolCall(context) {
   }
   return startIndex + match[0].length;
 }
+var WHITESPACE_JSON_REGEX = /\s/;
+function skipJsonWhitespace(text, fromIndex) {
+  let index = fromIndex;
+  while (index < text.length && WHITESPACE_JSON_REGEX.test(text[index])) {
+    index += 1;
+  }
+  return index;
+}
+function findTopLevelPropertyValueStart(text, property) {
+  const objectStart = skipJsonWhitespace(text, 0);
+  if (objectStart >= text.length || text.charAt(objectStart) !== "{") {
+    return null;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+  for (let index = objectStart; index < text.length; index += 1) {
+    const char = text.charAt(index);
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaping = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (char !== '"') {
+      continue;
+    }
+    if (depth !== 1) {
+      inString = true;
+      continue;
+    }
+    const keyStart = index + 1;
+    let keyEnd = keyStart;
+    let keyEscaped = false;
+    while (keyEnd < text.length) {
+      const keyChar = text.charAt(keyEnd);
+      if (keyEscaped) {
+        keyEscaped = false;
+      } else if (keyChar === "\\") {
+        keyEscaped = true;
+      } else if (keyChar === '"') {
+        break;
+      }
+      keyEnd += 1;
+    }
+    if (keyEnd >= text.length || text.charAt(keyEnd) !== '"') {
+      return null;
+    }
+    const key = text.slice(keyStart, keyEnd);
+    let valueCursor = skipJsonWhitespace(text, keyEnd + 1);
+    if (valueCursor >= text.length || text.charAt(valueCursor) !== ":") {
+      index = keyEnd;
+      continue;
+    }
+    valueCursor = skipJsonWhitespace(text, valueCursor + 1);
+    if (key === property) {
+      return valueCursor < text.length ? valueCursor : null;
+    }
+    index = valueCursor - 1;
+  }
+  return null;
+}
+function extractTopLevelStringProperty(text, property) {
+  const valueStart = findTopLevelPropertyValueStart(text, property);
+  if (valueStart == null || valueStart >= text.length) {
+    return void 0;
+  }
+  if (text.charAt(valueStart) !== '"') {
+    return void 0;
+  }
+  let valueEnd = valueStart + 1;
+  let escaped = false;
+  while (valueEnd < text.length) {
+    const char = text.charAt(valueEnd);
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === '"') {
+      return text.slice(valueStart + 1, valueEnd);
+    }
+    valueEnd += 1;
+  }
+  return void 0;
+}
+function extractJsonValueSlice(text, valueStart) {
+  if (valueStart >= text.length) {
+    return null;
+  }
+  const first = text.charAt(valueStart);
+  if (first === "{" || first === "[") {
+    const stack = [first];
+    let inString = false;
+    let escaped = false;
+    for (let index2 = valueStart + 1; index2 < text.length; index2 += 1) {
+      const char = text.charAt(index2);
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        continue;
+      }
+      if (char === "{" || char === "[") {
+        stack.push(char);
+        continue;
+      }
+      if (char === "}" || char === "]") {
+        const open = stack.at(-1);
+        if (open === "{" && char === "}" || open === "[" && char === "]") {
+          stack.pop();
+          if (stack.length === 0) {
+            return {
+              text: text.slice(valueStart, index2 + 1),
+              complete: true
+            };
+          }
+        }
+      }
+    }
+    return {
+      text: text.slice(valueStart),
+      complete: false
+    };
+  }
+  if (first === '"') {
+    let escaped = false;
+    for (let index2 = valueStart + 1; index2 < text.length; index2 += 1) {
+      const char = text.charAt(index2);
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        return {
+          text: text.slice(valueStart, index2 + 1),
+          complete: true
+        };
+      }
+    }
+    return {
+      text: text.slice(valueStart),
+      complete: false
+    };
+  }
+  let index = valueStart;
+  while (index < text.length) {
+    const char = text.charAt(index);
+    if (char === "," || char === "}" || WHITESPACE_JSON_REGEX.test(char)) {
+      break;
+    }
+    index += 1;
+  }
+  return {
+    text: text.slice(valueStart, index),
+    complete: index < text.length
+  };
+}
+function extractStreamingToolCallProgress(toolCallJson) {
+  var _a;
+  const toolName = extractTopLevelStringProperty(toolCallJson, "name");
+  const argsValueStart = findTopLevelPropertyValueStart(
+    toolCallJson,
+    "arguments"
+  );
+  if (argsValueStart == null) {
+    return {
+      toolName,
+      argumentsText: void 0,
+      argumentsComplete: false
+    };
+  }
+  const argsSlice = extractJsonValueSlice(toolCallJson, argsValueStart);
+  return {
+    toolName,
+    argumentsText: argsSlice == null ? void 0 : argsSlice.text,
+    argumentsComplete: (_a = argsSlice == null ? void 0 : argsSlice.complete) != null ? _a : false
+  };
+}
+function ensureToolInputStart(state, controller, toolName) {
+  if (!state.activeToolInput) {
+    const id = generateToolCallId();
+    state.activeToolInput = {
+      id,
+      toolName,
+      emittedInput: ""
+    };
+    controller.enqueue({
+      type: "tool-input-start",
+      id,
+      toolName
+    });
+  }
+}
+function emitToolInputDelta(state, controller, fullInput) {
+  const active = state.activeToolInput;
+  if (!active) {
+    return;
+  }
+  if (!fullInput.startsWith(active.emittedInput)) {
+    return;
+  }
+  const delta = fullInput.slice(active.emittedInput.length);
+  if (delta.length === 0) {
+    return;
+  }
+  controller.enqueue({
+    type: "tool-input-delta",
+    id: active.id,
+    delta
+  });
+  active.emittedInput = fullInput;
+}
+function closeToolInput(state, controller) {
+  if (!state.activeToolInput) {
+    return;
+  }
+  controller.enqueue({
+    type: "tool-input-end",
+    id: state.activeToolInput.id
+  });
+  state.activeToolInput = null;
+}
+function emitToolCallFromParsed(state, controller, parsedToolCall) {
+  var _a, _b, _c, _d;
+  closeTextBlock(state, controller);
+  const toolName = typeof parsedToolCall.name === "string" ? parsedToolCall.name : (_b = (_a = state.activeToolInput) == null ? void 0 : _a.toolName) != null ? _b : "unknown";
+  const input = canonicalizeToolInput(parsedToolCall.arguments);
+  ensureToolInputStart(state, controller, toolName);
+  emitToolInputDelta(state, controller, input);
+  const toolCallId = (_d = (_c = state.activeToolInput) == null ? void 0 : _c.id) != null ? _d : generateToolCallId();
+  closeToolInput(state, controller);
+  controller.enqueue({
+    type: "tool-call",
+    toolCallId,
+    toolName,
+    input
+  });
+}
+function canonicalizeArgumentsProgressInput(progress) {
+  if (progress.argumentsText === void 0 || !progress.argumentsComplete) {
+    return void 0;
+  }
+  try {
+    const parsedArguments = parse(progress.argumentsText);
+    return canonicalizeToolInput(parsedArguments);
+  } catch (e) {
+    return void 0;
+  }
+}
+function emitToolInputProgress(state, controller) {
+  if (!(state.isInsideToolCall && state.currentToolCallJson)) {
+    return;
+  }
+  const progress = extractStreamingToolCallProgress(state.currentToolCallJson);
+  if (!progress.toolName) {
+    return;
+  }
+  ensureToolInputStart(state, controller, progress.toolName);
+  const canonicalProgressInput = canonicalizeArgumentsProgressInput(progress);
+  if (canonicalProgressInput !== void 0) {
+    emitToolInputDelta(state, controller, canonicalProgressInput);
+  }
+}
 function flushBuffer(state, controller, toolCallStart) {
   if (state.buffer.length === 0) {
     return;
@@ -989,44 +1332,77 @@ function closeTextBlock(state, controller) {
     state.hasEmittedTextStart = false;
   }
 }
-function emitIncompleteToolCall(state, controller, toolCallStart) {
-  if (!state.currentToolCallJson) {
+function emitIncompleteToolCall(state, controller, toolCallStart, trailingBuffer, options) {
+  var _a;
+  if (!state.currentToolCallJson && trailingBuffer.length === 0) {
+    state.isInsideToolCall = false;
     return;
   }
+  if (state.currentToolCallJson) {
+    try {
+      const parsedToolCall = parse(state.currentToolCallJson);
+      emitToolCallFromParsed(state, controller, parsedToolCall);
+      state.currentToolCallJson = "";
+      state.isInsideToolCall = false;
+      return;
+    } catch (e) {
+    }
+  }
+  const rawToolCallContent = `${state.currentToolCallJson}${trailingBuffer}`;
+  const errorContent = `${toolCallStart}${rawToolCallContent}`;
+  const shouldEmitRawFallback = shouldEmitRawToolCallTextOnError(options);
   logParseFailure({
     phase: "stream",
-    reason: "Incomplete streaming tool call segment emitted as text",
-    snippet: `${toolCallStart}${state.currentToolCallJson}`
-  });
-  const errorId = generateId();
-  const errorContent = `${toolCallStart}${state.currentToolCallJson}`;
-  controller.enqueue({
-    type: "text-start",
-    id: errorId
-  });
-  controller.enqueue({
-    type: "text-delta",
-    id: errorId,
-    delta: errorContent
-  });
-  controller.enqueue({
-    type: "text-end",
-    id: errorId
+    reason: shouldEmitRawFallback ? "Incomplete streaming tool call segment emitted as text" : "Incomplete streaming tool call segment suppressed without raw text fallback",
+    snippet: errorContent
   });
+  if (shouldEmitRawFallback) {
+    const errorId = generateId();
+    controller.enqueue({
+      type: "text-start",
+      id: errorId
+    });
+    controller.enqueue({
+      type: "text-delta",
+      id: errorId,
+      delta: errorContent
+    });
+    controller.enqueue({
+      type: "text-end",
+      id: errorId
+    });
+  }
+  closeToolInput(state, controller);
+  (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.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 }
+  );
   state.currentToolCallJson = "";
+  state.isInsideToolCall = false;
 }
-function handleFinishChunk(state, controller, toolCallStart, chunk) {
-  if (state.buffer.length > 0) {
+function handleFinishChunk(state, controller, toolCallStart, options, chunk) {
+  if (state.isInsideToolCall) {
+    const trailingBuffer = state.buffer;
+    state.buffer = "";
+    emitIncompleteToolCall(
+      state,
+      controller,
+      toolCallStart,
+      trailingBuffer,
+      options
+    );
+  } else if (state.buffer.length > 0) {
     flushBuffer(state, controller, toolCallStart);
   }
   closeTextBlock(state, controller);
-  emitIncompleteToolCall(state, controller, toolCallStart);
   controller.enqueue(chunk);
 }
 function publishText(text, state, controller) {
   if (state.isInsideToolCall) {
     closeTextBlock(state, controller);
     state.currentToolCallJson += text;
+    emitToolInputProgress(state, controller);
   } else if (text.length > 0) {
     if (!state.currentTextId) {
       state.currentTextId = generateId();
@@ -1044,42 +1420,40 @@ function publishText(text, state, controller) {
   }
 }
 function emitToolCall(context) {
-  var _a, _b;
+  var _a;
   const { state, controller, toolCallStart, toolCallEnd, options } = context;
   try {
     const parsedToolCall = parse(state.currentToolCallJson);
-    closeTextBlock(state, controller);
-    controller.enqueue({
-      type: "tool-call",
-      toolCallId: generateId(),
-      toolName: parsedToolCall.name,
-      input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
-    });
+    emitToolCallFromParsed(state, controller, parsedToolCall);
   } catch (error) {
+    const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
+    const shouldEmitRawFallback = shouldEmitRawToolCallTextOnError(options);
     logParseFailure({
       phase: "stream",
       reason: "Failed to parse streaming tool call JSON segment",
-      snippet: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`,
+      snippet: errorContent,
       error
     });
-    const errorId = generateId();
-    const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
-    controller.enqueue({
-      type: "text-start",
-      id: errorId
-    });
-    controller.enqueue({
-      type: "text-delta",
-      id: errorId,
-      delta: errorContent
-    });
-    controller.enqueue({
-      type: "text-end",
-      id: errorId
-    });
-    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+    if (shouldEmitRawFallback) {
+      const errorId = generateId();
+      controller.enqueue({
+        type: "text-start",
+        id: errorId
+      });
+      controller.enqueue({
+        type: "text-delta",
+        id: errorId,
+        delta: errorContent
+      });
+      controller.enqueue({
+        type: "text-end",
+        id: errorId
+      });
+    }
+    closeToolInput(state, controller);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
       options,
-      "Could not process streaming JSON tool call; emitting original text.",
+      shouldEmitRawFallback ? "Could not process streaming JSON tool call; emitting original text." : "Could not process streaming JSON tool call.",
       {
         toolCall: errorContent
       }
@@ -1095,6 +1469,7 @@ function processTagMatch(context) {
   } else {
     state.currentToolCallJson = "";
     state.isInsideToolCall = true;
+    state.activeToolInput = null;
   }
 }
 function processBufferTags(context) {
@@ -1117,8 +1492,16 @@ function processBufferTags(context) {
     );
   }
 }
-function handlePartialTag(state, controller, toolCallStart) {
+function handlePartialTag(state, controller, toolCallStart, toolCallEnd) {
   if (state.isInsideToolCall) {
+    const potentialEndIndex = getPotentialStartIndex(state.buffer, toolCallEnd);
+    if (potentialEndIndex != null && potentialEndIndex + toolCallEnd.length > state.buffer.length) {
+      publishText(state.buffer.slice(0, potentialEndIndex), state, controller);
+      state.buffer = state.buffer.slice(potentialEndIndex);
+    } else {
+      publishText(state.buffer, state, controller);
+      state.buffer = "";
+    }
     return;
   }
   const potentialIndex = getPotentialStartIndex(state.buffer, toolCallStart);
@@ -1191,13 +1574,14 @@ var jsonProtocol = ({
       buffer: "",
       currentToolCallJson: "",
       currentTextId: null,
-      hasEmittedTextStart: false
+      hasEmittedTextStart: false,
+      activeToolInput: null
     };
     return new TransformStream({
       transform(chunk, controller) {
         var _a;
         if (chunk.type === "finish") {
-          handleFinishChunk(state, controller, toolCallStart, chunk);
+          handleFinishChunk(state, controller, toolCallStart, options, chunk);
           return;
         }
         if (chunk.type !== "text-delta") {
@@ -1213,7 +1597,7 @@ var jsonProtocol = ({
           toolCallEnd,
           options
         });
-        handlePartialTag(state, controller, toolCallStart);
+        handlePartialTag(state, controller, toolCallStart, toolCallEnd);
       }
     });
   },
@@ -4193,35 +4577,112 @@ function parse3(xml, schema, options = {}) {
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX5 = /\s/;
 
-// src/core/utils/xml-root-repair.ts
-var XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX = /^<([A-Za-z_][A-Za-z0-9_-]*)\s*\r?\n([\s\S]+?)\r?\n\s*\/>\s*$/;
-function tryRepairXmlSelfClosingRootWithBody(rawText, toolNames) {
-  const trimmed = rawText.trim();
-  if (trimmed.length === 0) {
-    return null;
+// src/core/utils/streamed-tool-input-delta.ts
+function emitDelta({
+  controller,
+  id,
+  state,
+  nextInput
+}) {
+  if (!nextInput.startsWith(state.emittedInput)) {
+    return false;
   }
-  const match = trimmed.match(XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX);
-  if (!match) {
-    return null;
+  const delta = nextInput.slice(state.emittedInput.length);
+  if (delta.length === 0) {
+    return false;
   }
-  const rootTag = match[1];
-  if (!toolNames.includes(rootTag)) {
-    return null;
+  controller.enqueue({
+    type: "tool-input-delta",
+    id,
+    delta
+  });
+  state.emittedInput = nextInput;
+  return true;
+}
+function toIncompleteJsonPrefix(fullJson) {
+  const trimmed = fullJson.trim();
+  let prefix = trimmed;
+  while (prefix.endsWith("}") || prefix.endsWith("]")) {
+    prefix = prefix.slice(0, -1);
   }
-  const body = match[2].trimEnd();
-  if (body.trim().length === 0 || body.includes(`</${rootTag}>`)) {
-    return null;
+  prefix = prefix.trimEnd();
+  if (prefix.endsWith('"')) {
+    prefix = prefix.slice(0, -1);
   }
-  return `<${rootTag}>
-${body}
-</${rootTag}>`;
-}
-
+  if (prefix.length === 0) {
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+      return trimmed.startsWith("{") ? "{" : "[";
+    }
+    if (trimmed.startsWith("]")) {
+      return "[";
+    }
+    if (trimmed.startsWith("}")) {
+      return "{";
+    }
+    if (trimmed.startsWith('"')) {
+      return '"';
+    }
+    return "{";
+  }
+  return prefix;
+}
+function emitPrefixDelta(params) {
+  return emitDelta({
+    ...params,
+    nextInput: params.candidate
+  });
+}
+function emitFinalRemainder(params) {
+  var _a;
+  const result = emitDelta({
+    ...params,
+    nextInput: params.finalFullJson
+  });
+  if (!result && params.state.emittedInput.length > 0) {
+    (_a = params.onMismatch) == null ? void 0 : _a.call(
+      params,
+      "Final JSON does not extend emitted tool-input prefix",
+      {
+        emittedLength: params.state.emittedInput.length,
+        finalLength: params.finalFullJson.length
+      }
+    );
+  }
+  return result;
+}
+
+// src/core/utils/xml-root-repair.ts
+var XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX = /^<([A-Za-z_][A-Za-z0-9_-]*)\s*\r?\n([\s\S]+?)\r?\n\s*\/>\s*$/;
+function tryRepairXmlSelfClosingRootWithBody(rawText, toolNames) {
+  const trimmed = rawText.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const match = trimmed.match(XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX);
+  if (!match) {
+    return null;
+  }
+  const rootTag = match[1];
+  if (!toolNames.includes(rootTag)) {
+    return null;
+  }
+  const body = match[2].trimEnd();
+  if (body.trim().length === 0 || body.includes(`</${rootTag}>`)) {
+    return null;
+  }
+  return `<${rootTag}>
+${body}
+</${rootTag}>`;
+}
+
 // src/core/protocols/xml-protocol.ts
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
 }
+function shouldEmitRawToolCallTextOnError2(options) {
+  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+}
 function processToolCall(params) {
   var _a, _b;
   const { toolCall, tools, options, text, processedElements, parseOptions } = params;
@@ -4234,7 +4695,7 @@ function processToolCall(params) {
     const parsed = parse3(toolCall.content, toolSchema, parseConfig);
     processedElements.push({
       type: "tool-call",
-      toolCallId: generateId(),
+      toolCallId: generateToolCallId(),
       toolName: toolCall.toolName,
       input: JSON.stringify(parsed)
     });
@@ -4251,6 +4712,299 @@ function processToolCall(params) {
     processedElements.push({ type: "text", text: originalCallText });
   }
 }
+function parseXmlTagName(rawTagBody) {
+  let index = 0;
+  while (index < rawTagBody.length && WHITESPACE_REGEX5.test(rawTagBody[index])) {
+    index += 1;
+  }
+  const nameStart = index;
+  while (index < rawTagBody.length && NAME_CHAR_RE2.test(rawTagBody.charAt(index))) {
+    index += 1;
+  }
+  return rawTagBody.slice(nameStart, index);
+}
+function consumeXmlSpecialSection(fragment, ltIndex) {
+  if (fragment.startsWith("<!--", ltIndex)) {
+    const commentEnd = fragment.indexOf("-->", ltIndex + 4);
+    return commentEnd === -1 ? { kind: "incomplete" } : { kind: "consumed", nextPos: commentEnd + 3 };
+  }
+  if (fragment.startsWith("<![CDATA[", ltIndex)) {
+    const cdataEnd = fragment.indexOf("]]>", ltIndex + 9);
+    return cdataEnd === -1 ? { kind: "incomplete" } : { kind: "consumed", nextPos: cdataEnd + 3 };
+  }
+  if (fragment.startsWith("<?", ltIndex)) {
+    const processingEnd = fragment.indexOf("?>", ltIndex + 2);
+    return processingEnd === -1 ? { kind: "incomplete" } : { kind: "consumed", nextPos: processingEnd + 2 };
+  }
+  if (fragment.startsWith("<!", ltIndex)) {
+    const declarationEnd = fragment.indexOf(">", ltIndex + 2);
+    return declarationEnd === -1 ? { kind: "incomplete" } : { kind: "consumed", nextPos: declarationEnd + 1 };
+  }
+  return { kind: "none" };
+}
+function parseXmlTagToken(fragment, ltIndex) {
+  const gtIndex = fragment.indexOf(">", ltIndex + 1);
+  if (gtIndex === -1) {
+    return null;
+  }
+  const tagBody = fragment.slice(ltIndex + 1, gtIndex).trim();
+  if (tagBody.length === 0) {
+    return null;
+  }
+  if (tagBody.startsWith("/")) {
+    const closeName = parseXmlTagName(tagBody.slice(1));
+    if (closeName.length === 0) {
+      return null;
+    }
+    return { kind: "close", name: closeName, nextPos: gtIndex + 1 };
+  }
+  const selfClosing = tagBody.endsWith("/");
+  const openBody = selfClosing ? tagBody.slice(0, -1).trimEnd() : tagBody;
+  const openName = parseXmlTagName(openBody);
+  if (openName.length === 0) {
+    return null;
+  }
+  return {
+    kind: "open",
+    name: openName,
+    selfClosing,
+    nextPos: gtIndex + 1
+  };
+}
+function analyzeXmlFragmentForProgress(fragment) {
+  const stack = [];
+  const topLevelTagNames = [];
+  let position = 0;
+  while (position < fragment.length) {
+    const ltIndex = fragment.indexOf("<", position);
+    if (ltIndex === -1) {
+      break;
+    }
+    const special = consumeXmlSpecialSection(fragment, ltIndex);
+    if (special.kind === "incomplete") {
+      return null;
+    }
+    if (special.kind === "consumed") {
+      position = special.nextPos;
+      continue;
+    }
+    const token = parseXmlTagToken(fragment, ltIndex);
+    if (token === null) {
+      return null;
+    }
+    if (token.kind === "close") {
+      const openName = stack.pop();
+      if (!openName || openName !== token.name) {
+        return null;
+      }
+      position = token.nextPos;
+      continue;
+    }
+    if (stack.length === 0) {
+      topLevelTagNames.push(token.name);
+    }
+    if (!token.selfClosing) {
+      stack.push(token.name);
+    }
+    position = token.nextPos;
+  }
+  if (stack.length > 0) {
+    return null;
+  }
+  return { topLevelTagNames };
+}
+function scanXmlFragmentTopLevelTextStep(options) {
+  const { fragment, position, stack } = options;
+  const ltIndex = fragment.indexOf("<", position);
+  if (ltIndex === -1) {
+    const trailingText = fragment.slice(position);
+    return {
+      kind: "done",
+      value: stack.length === 0 && trailingText.trim().length > 0
+    };
+  }
+  const textBetweenTags = fragment.slice(position, ltIndex);
+  if (stack.length === 0 && textBetweenTags.trim().length > 0) {
+    return { kind: "found" };
+  }
+  const special = consumeXmlSpecialSection(fragment, ltIndex);
+  if (special.kind === "incomplete") {
+    return { kind: "invalid" };
+  }
+  if (special.kind === "consumed") {
+    return { kind: "next", nextPos: special.nextPos };
+  }
+  const token = parseXmlTagToken(fragment, ltIndex);
+  if (token === null) {
+    return { kind: "invalid" };
+  }
+  if (token.kind === "close") {
+    const openName = stack.pop();
+    if (!openName || openName !== token.name) {
+      return { kind: "invalid" };
+    }
+  } else if (!token.selfClosing) {
+    stack.push(token.name);
+  }
+  return { kind: "next", nextPos: token.nextPos };
+}
+function hasNonWhitespaceTopLevelText(fragment) {
+  if (!fragment.includes("<")) {
+    return fragment.trim().length > 0;
+  }
+  const stack = [];
+  let position = 0;
+  while (position < fragment.length) {
+    const step = scanXmlFragmentTopLevelTextStep({ fragment, position, stack });
+    if (step.kind === "found") {
+      return true;
+    }
+    if (step.kind === "invalid") {
+      return false;
+    }
+    if (step.kind === "done") {
+      return step.value;
+    }
+    position = step.nextPos;
+  }
+  return false;
+}
+function getObjectSchemaPropertyNames(schema) {
+  if (!schema || typeof schema !== "object") {
+    return null;
+  }
+  const schemaObject = schema;
+  const typeValue = schemaObject.type;
+  if (typeValue != null) {
+    const isObjectType = typeValue === "object" || Array.isArray(typeValue) && typeValue.includes("object");
+    if (!isObjectType) {
+      return null;
+    }
+  }
+  if (!schemaObject.properties || typeof schemaObject.properties !== "object") {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    Object.keys(schemaObject.properties)
+  );
+}
+function schemaAllowsArrayType(schema) {
+  if (!schema || typeof schema !== "object") {
+    return false;
+  }
+  const schemaRecord = schema;
+  const typeValue = schemaRecord.type;
+  if (typeValue === "array") {
+    return true;
+  }
+  if (Array.isArray(typeValue) && typeValue.includes("array")) {
+    return true;
+  }
+  const unions = [schemaRecord.anyOf, schemaRecord.oneOf, schemaRecord.allOf];
+  for (const union of unions) {
+    if (!Array.isArray(union)) {
+      continue;
+    }
+    if (union.some((entry) => schemaAllowsArrayType(entry))) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSchemaObjectProperty(schema, propertyName) {
+  if (!schema || typeof schema !== "object") {
+    return null;
+  }
+  const schemaObject = schema;
+  const properties = schemaObject.properties;
+  if (!properties || typeof properties !== "object") {
+    return null;
+  }
+  const property = properties[propertyName];
+  if (!property) {
+    return null;
+  }
+  return property;
+}
+function isStableXmlProgressCandidate(options) {
+  const { candidate, parsed, toolSchema } = options;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return false;
+  }
+  const structure = analyzeXmlFragmentForProgress(candidate);
+  if (!structure) {
+    return false;
+  }
+  const schemaProperties = getObjectSchemaPropertyNames(toolSchema);
+  if (!schemaProperties || schemaProperties.size === 0) {
+    return false;
+  }
+  const parsedObject = parsed;
+  const uniqueTopLevelTags = new Set(structure.topLevelTagNames);
+  for (const tagName of uniqueTopLevelTags) {
+    if (!schemaProperties.has(tagName)) {
+      continue;
+    }
+    const schemaProperty = getSchemaObjectProperty(toolSchema, tagName);
+    if (schemaProperty && schemaAllowsArrayType(schemaProperty) && !Array.isArray(parsedObject[tagName])) {
+      return false;
+    }
+  }
+  if (structure.topLevelTagNames.length === 1) {
+    const onlyTopLevelTag = structure.topLevelTagNames[0];
+    if (!schemaProperties || schemaProperties.size === 0 || !schemaProperties.has(onlyTopLevelTag)) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseXmlContentForStreamProgress({
+  toolContent,
+  toolSchema,
+  parseOptions
+}) {
+  const tryParse = (content) => {
+    try {
+      return parse3(content, toolSchema, {
+        ...parseOptions != null ? parseOptions : {},
+        repair: false,
+        onError: void 0
+      });
+    } catch (e) {
+      return null;
+    }
+  };
+  const strictFull = tryParse(toolContent);
+  if (strictFull !== null && isStableXmlProgressCandidate({
+    candidate: toolContent,
+    parsed: strictFull,
+    toolSchema
+  })) {
+    return JSON.stringify(strictFull);
+  }
+  let searchEnd = toolContent.length;
+  while (searchEnd > 0) {
+    const gtIndex = toolContent.lastIndexOf(">", searchEnd - 1);
+    if (gtIndex === -1) {
+      break;
+    }
+    const candidate = toolContent.slice(0, gtIndex + 1);
+    if (!analyzeXmlFragmentForProgress(candidate)) {
+      searchEnd = gtIndex;
+      continue;
+    }
+    const parsedCandidate = tryParse(candidate);
+    if (parsedCandidate !== null && isStableXmlProgressCandidate({
+      candidate,
+      parsed: parsedCandidate,
+      toolSchema
+    })) {
+      return JSON.stringify(parsedCandidate);
+    }
+    searchEnd = gtIndex;
+  }
+  return null;
+}
 function handleStreamingToolCallEnd(params) {
   var _a, _b;
   const {
@@ -4270,19 +5024,37 @@ function handleStreamingToolCallEnd(params) {
   flushText(ctrl);
   try {
     const parsedResult = parse3(toolContent, toolSchema, parseConfig);
+    const finalInput = JSON.stringify(parsedResult);
+    emitFinalRemainder({
+      controller: ctrl,
+      id: currentToolCall.toolCallId,
+      state: currentToolCall,
+      finalFullJson: finalInput,
+      onMismatch: options == null ? void 0 : options.onError
+    });
+    ctrl.enqueue({
+      type: "tool-input-end",
+      id: currentToolCall.toolCallId
+    });
     ctrl.enqueue({
       type: "tool-call",
-      toolCallId: generateId(),
+      toolCallId: currentToolCall.toolCallId,
       toolName: currentToolCall.name,
-      input: JSON.stringify(parsedResult)
+      input: finalInput
     });
   } catch (error) {
+    ctrl.enqueue({
+      type: "tool-input-end",
+      id: currentToolCall.toolCallId
+    });
     const original = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
     (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "Could not process streaming XML tool call", {
       toolCall: original,
       error
     });
-    flushText(ctrl, original);
+    if (shouldEmitRawToolCallTextOnError2(options)) {
+      flushText(ctrl, original);
+    }
   }
 }
 function findClosingTagEndFlexible(text, contentStart, toolName) {
@@ -4704,38 +5476,6 @@ function findPotentialToolTagStart(buffer, toolNames) {
   }
   return -1;
 }
-function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
-  return (controller, text) => {
-    const content = text;
-    if (content) {
-      if (!getCurrentTextId()) {
-        const newId = generateId();
-        setCurrentTextId(newId);
-        controller.enqueue({
-          type: "text-start",
-          id: newId
-        });
-        setHasEmittedTextStart(true);
-      }
-      controller.enqueue({
-        type: "text-delta",
-        id: getCurrentTextId(),
-        delta: content
-      });
-    }
-    const currentTextId = getCurrentTextId();
-    if (currentTextId && !text) {
-      if (getHasEmittedTextStart()) {
-        controller.enqueue({
-          type: "text-end",
-          id: currentTextId
-        });
-        setHasEmittedTextStart(false);
-      }
-      setCurrentTextId(null);
-    }
-  };
-}
 function processToolCallInBuffer(params) {
   const {
     buffer,
@@ -4745,18 +5485,21 @@ function processToolCallInBuffer(params) {
     controller,
     flushText,
     setBuffer,
-    parseOptions
+    parseOptions,
+    emitToolInputProgress: emitToolInputProgress2
   } = params;
   const endTagPattern = new RegExp(
     `</\\s*${escapeRegExp(currentToolCall.name)}\\s*>`
   );
   const endMatch = endTagPattern.exec(buffer);
   if (!endMatch || endMatch.index === void 0) {
+    emitToolInputProgress2(controller, currentToolCall, buffer);
     return { buffer, currentToolCall, shouldBreak: true };
   }
   const endIdx = endMatch.index;
   const endPos = endIdx + endMatch[0].length;
   const content = buffer.substring(0, endIdx);
+  emitToolInputProgress2(controller, currentToolCall, content);
   const remainder = buffer.substring(endPos);
   setBuffer(remainder);
   handleStreamingToolCallEnd({
@@ -4783,7 +5526,8 @@ function processNoToolCallInBuffer(params) {
     tools,
     options,
     parseOptions,
-    setBuffer
+    setBuffer,
+    emitToolInputStart
   } = params;
   const {
     index: earliestStartTagIndex,
@@ -4813,9 +5557,10 @@ function processNoToolCallInBuffer(params) {
   if (selfClosing) {
     const newBuffer2 = buffer.substring(earliestStartTagIndex + tagLength);
     setBuffer(newBuffer2);
+    const currentToolCall = emitToolInputStart(controller, earliestToolName);
     handleStreamingToolCallEnd({
       toolContent: "",
-      currentToolCall: { name: earliestToolName, content: "" },
+      currentToolCall,
       tools,
       options,
       ctrl: controller,
@@ -4834,12 +5579,12 @@ function processNoToolCallInBuffer(params) {
   setBuffer(newBuffer);
   return {
     buffer: newBuffer,
-    currentToolCall: { name: earliestToolName, content: "" },
+    currentToolCall: emitToolInputStart(controller, earliestToolName),
     shouldBreak: false,
     shouldContinue: true
   };
 }
-function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, parseOptions) {
+function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, parseOptions, emitToolInputProgress2, emitToolInputStart) {
   return (controller) => {
     while (true) {
       const currentToolCall = getCurrentToolCall();
@@ -4852,7 +5597,8 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           controller,
           flushText,
           setBuffer,
-          parseOptions
+          parseOptions,
+          emitToolInputProgress: emitToolInputProgress2
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -4868,7 +5614,8 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           tools,
           options,
           parseOptions,
-          setBuffer
+          setBuffer,
+          emitToolInputStart
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -4982,6 +5729,118 @@ var xmlProtocol = (protocolOptions) => {
           hasEmittedTextStart = value;
         }
       );
+      const emitToolInputStart = (controller, toolName) => {
+        flushText(controller);
+        const next = {
+          name: toolName,
+          toolCallId: generateToolCallId(),
+          emittedInput: "",
+          lastProgressGtIndex: null,
+          lastProgressFullInput: null
+        };
+        controller.enqueue({
+          type: "tool-input-start",
+          id: next.toolCallId,
+          toolName
+        });
+        return next;
+      };
+      const emitToolInputProgress2 = (controller, toolCall, toolContent) => {
+        const progressGtIndex = toolContent.lastIndexOf(">");
+        if (toolCall.lastProgressGtIndex === progressGtIndex) {
+          const cached = toolCall.lastProgressFullInput;
+          if (cached == null) {
+            return;
+          }
+          if (cached === "{}" && toolContent.trim().length === 0) {
+            return;
+          }
+          const prefixCandidate2 = toIncompleteJsonPrefix(cached);
+          emitPrefixDelta({
+            controller,
+            id: toolCall.toolCallId,
+            state: toolCall,
+            candidate: prefixCandidate2
+          });
+          return;
+        }
+        const toolSchema = getToolSchema(tools, toolCall.name);
+        const fullInput = parseXmlContentForStreamProgress({
+          toolContent,
+          toolSchema,
+          parseOptions
+        });
+        toolCall.lastProgressGtIndex = progressGtIndex;
+        toolCall.lastProgressFullInput = fullInput;
+        if (fullInput == null) {
+          return;
+        }
+        if (fullInput === "{}" && toolContent.trim().length === 0) {
+          return;
+        }
+        const prefixCandidate = toIncompleteJsonPrefix(fullInput);
+        emitPrefixDelta({
+          controller,
+          id: toolCall.toolCallId,
+          state: toolCall,
+          candidate: prefixCandidate
+        });
+      };
+      const finalizeUnclosedToolCall = (controller) => {
+        var _a2, _b;
+        if (!currentToolCall) {
+          return;
+        }
+        emitToolInputProgress2(controller, currentToolCall, buffer);
+        const parseConfig = {
+          ...parseOptions,
+          onError: (_a2 = options == null ? void 0 : options.onError) != null ? _a2 : parseOptions == null ? void 0 : parseOptions.onError
+        };
+        const toolSchema = getToolSchema(tools, currentToolCall.name);
+        flushText(controller);
+        try {
+          if (hasNonWhitespaceTopLevelText(buffer)) {
+            throw new Error(
+              "Cannot reconcile unclosed XML tool call with top-level plain text."
+            );
+          }
+          const parsedResult = parse3(buffer, toolSchema, parseConfig);
+          const finalInput = JSON.stringify(parsedResult);
+          emitFinalRemainder({
+            controller,
+            id: currentToolCall.toolCallId,
+            state: currentToolCall,
+            finalFullJson: finalInput,
+            onMismatch: options == null ? void 0 : options.onError
+          });
+          controller.enqueue({
+            type: "tool-input-end",
+            id: currentToolCall.toolCallId
+          });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId: currentToolCall.toolCallId,
+            toolName: currentToolCall.name,
+            input: finalInput
+          });
+        } catch (error) {
+          controller.enqueue({
+            type: "tool-input-end",
+            id: currentToolCall.toolCallId
+          });
+          const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
+          (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+            options,
+            "Could not complete streaming XML tool call at finish.",
+            { toolCall: unfinishedContent, error }
+          );
+          if (shouldEmitRawToolCallTextOnError2(options)) {
+            flushText(controller, unfinishedContent);
+          }
+        }
+        buffer = "";
+        currentToolCall = null;
+      };
       const processBuffer = createProcessBufferHandler(
         () => buffer,
         (newBuffer) => {
@@ -4995,17 +5854,17 @@ var xmlProtocol = (protocolOptions) => {
         options,
         toolNames,
         flushText,
-        parseOptions
+        parseOptions,
+        emitToolInputProgress2,
+        emitToolInputStart
       );
       return new TransformStream({
+        // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Stateful stream parsing requires branching over chunk lifecycle and parser states.
         transform(chunk, controller) {
           var _a2;
           if (chunk.type === "finish") {
             if (currentToolCall) {
-              const unfinishedContent = `<${currentToolCall.name}>${currentToolCall.content}${buffer}`;
-              flushText(controller, unfinishedContent);
-              buffer = "";
-              currentToolCall = null;
+              finalizeUnclosedToolCall(controller);
             } else if (buffer) {
               flushText(controller, buffer);
               buffer = "";
@@ -5015,7 +5874,8 @@ var xmlProtocol = (protocolOptions) => {
             return;
           }
           if (chunk.type !== "text-delta") {
-            if (buffer) {
+            if (currentToolCall) {
+            } else if (buffer) {
               flushText(controller, buffer);
               buffer = "";
             }
@@ -5028,10 +5888,7 @@ var xmlProtocol = (protocolOptions) => {
         },
         flush(controller) {
           if (currentToolCall) {
-            const unfinishedContent = `<${currentToolCall.name}>${currentToolCall.content || ""}${buffer}`;
-            flushText(controller, unfinishedContent);
-            buffer = "";
-            currentToolCall = null;
+            finalizeUnclosedToolCall(controller);
           } else if (buffer) {
             flushText(controller, buffer);
             buffer = "";
@@ -5059,7 +5916,205 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
+function shouldEmitRawToolCallTextOnError3(options) {
+  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+}
+var selfClosingTagCache2 = /* @__PURE__ */ new Map();
+function getSelfClosingTagPattern2(toolName) {
+  let pattern = selfClosingTagCache2.get(toolName);
+  if (!pattern) {
+    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
+    selfClosingTagCache2.set(toolName, pattern);
+  }
+  return pattern;
+}
 var LEADING_WHITESPACE_RE = /^(\s*)/;
+var INCOMPLETE_MAPPING_TAIL_RE = /^[^:[\]{}-][^:]*:\s*$/;
+var INCOMPLETE_SEQUENCE_TAIL_RE = /^-\s*$/;
+var BLOCK_SCALAR_KEY_RE = /:\s*[|>][-+0-9]*\s*$/;
+var PLAIN_MAPPING_VALUE_RE = /^[^:[\]{}-][^:]*:\s*(.+)$/;
+var PLAIN_SEQUENCE_VALUE_RE = /^-\s+(.+)$/;
+function normalizeYamlContent(yamlContent) {
+  let normalized = yamlContent;
+  if (normalized.startsWith("\n")) {
+    normalized = normalized.slice(1);
+  }
+  const lines = normalized.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return { normalized: "", nonEmptyLines };
+  }
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = line.match(LEADING_WHITESPACE_RE);
+      return match ? match[1].length : 0;
+    })
+  );
+  if (minIndent > 0) {
+    normalized = lines.map((line) => line.slice(minIndent)).join("\n");
+  }
+  return { normalized, nonEmptyLines };
+}
+function parseYamlDocumentAsMapping(normalized) {
+  try {
+    const doc = import_yaml.default.parseDocument(normalized);
+    const errors = doc.errors.map((e) => e.message);
+    const result = doc.toJSON();
+    if (result === null) {
+      return { value: {}, errors };
+    }
+    if (typeof result !== "object" || Array.isArray(result)) {
+      return { value: null, errors };
+    }
+    return { value: result, errors };
+  } catch (error) {
+    return {
+      value: null,
+      errors: [
+        error instanceof Error ? error.message : "Unknown YAML parsing error"
+      ]
+    };
+  }
+}
+function getLastMeaningfulLineInfo(input) {
+  var _a;
+  const lines = input.split("\n");
+  let index = lines.length - 1;
+  while (index >= 0) {
+    const raw = (_a = lines[index]) != null ? _a : "";
+    const trimmed = raw.trim();
+    if (trimmed.length > 0 && !trimmed.startsWith("#")) {
+      return {
+        index,
+        raw,
+        trimmed,
+        indent: raw.length - raw.trimStart().length
+      };
+    }
+    index -= 1;
+  }
+  return null;
+}
+function dropLastMeaningfulLine(input) {
+  const lineInfo = getLastMeaningfulLineInfo(input);
+  if (!lineInfo) {
+    return null;
+  }
+  return input.split("\n").slice(0, lineInfo.index).join("\n").trimEnd();
+}
+function hasIncompleteMappingTail(normalized) {
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return INCOMPLETE_MAPPING_TAIL_RE.test(lineInfo.trimmed);
+}
+function hasIncompleteSequenceTail(normalized) {
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return INCOMPLETE_SEQUENCE_TAIL_RE.test(lineInfo.trimmed);
+}
+function hasSplitNestedKeyTail(normalized) {
+  var _a;
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  const { trimmed, indent, index } = lineInfo;
+  if (indent === 0) {
+    return false;
+  }
+  if (trimmed.startsWith("#") || trimmed.startsWith("-") || trimmed.includes(":")) {
+    return false;
+  }
+  const lines = normalized.split("\n");
+  let parentIndex = index - 1;
+  while (parentIndex >= 0) {
+    const parentRaw = (_a = lines[parentIndex]) != null ? _a : "";
+    const parentTrimmed = parentRaw.trim();
+    if (parentTrimmed.length === 0 || parentTrimmed.startsWith("#")) {
+      parentIndex -= 1;
+      continue;
+    }
+    const parentIndent = parentRaw.length - parentRaw.trimStart().length;
+    if (parentIndent >= indent) {
+      parentIndex -= 1;
+      continue;
+    }
+    if (!parentTrimmed.endsWith(":")) {
+      return false;
+    }
+    if (BLOCK_SCALAR_KEY_RE.test(parentTrimmed)) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function extractTrailingPlainScalarValue(line) {
+  var _a;
+  if (BLOCK_SCALAR_KEY_RE.test(line)) {
+    return null;
+  }
+  const mappingMatch = line.match(PLAIN_MAPPING_VALUE_RE);
+  const sequenceMatch = line.match(PLAIN_SEQUENCE_VALUE_RE);
+  const value = (_a = mappingMatch == null ? void 0 : mappingMatch[1]) != null ? _a : sequenceMatch == null ? void 0 : sequenceMatch[1];
+  if (!value) {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  if (trimmedValue.length === 0) {
+    return null;
+  }
+  if (trimmedValue.startsWith('"') || trimmedValue.startsWith("'")) {
+    return null;
+  }
+  if (trimmedValue.startsWith("{") || trimmedValue.startsWith("[") || trimmedValue.startsWith("|") || trimmedValue.startsWith(">")) {
+    return null;
+  }
+  return trimmedValue;
+}
+function hasUnterminatedPlainScalarTail(normalized) {
+  if (normalized.endsWith("\n")) {
+    return false;
+  }
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return extractTrailingPlainScalarValue(lineInfo.trimmed) != null;
+}
+function hasUnstableProgressTail(normalized) {
+  return hasIncompleteMappingTail(normalized) || hasIncompleteSequenceTail(normalized) || hasSplitNestedKeyTail(normalized) || hasUnterminatedPlainScalarTail(normalized);
+}
+function trimTrailingNewlineInUnknown(value) {
+  if (typeof value === "string") {
+    if (value.endsWith("\n")) {
+      return value.slice(0, -1);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => trimTrailingNewlineInUnknown(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        trimTrailingNewlineInUnknown(item)
+      ])
+    );
+  }
+  return value;
+}
+function stabilizeParsedValueForStreamProgress(value, source) {
+  if (source.endsWith("\n")) {
+    return value;
+  }
+  return trimTrailingNewlineInUnknown(value);
+}
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
   let depth = 1;
@@ -5131,7 +6186,7 @@ function findEarliestTagPosition(openIdx, selfIdx) {
 function collectToolCallsForName(text, toolName) {
   const toolCalls = [];
   let searchIndex = 0;
-  const selfTagRegex = new RegExp(`<${toolName}\\s*/>`, "g");
+  const selfTagRegex = getSelfClosingTagPattern2(toolName);
   while (searchIndex < text.length) {
     const startTag = `<${toolName}>`;
     const openIdx = text.indexOf(startTag, searchIndex);
@@ -5183,47 +6238,48 @@ function findToolCalls2(text, toolNames) {
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 function parseYamlContent(yamlContent, options) {
-  var _a, _b, _c;
-  let normalized = yamlContent;
-  if (normalized.startsWith("\n")) {
-    normalized = normalized.slice(1);
-  }
-  const lines = normalized.split("\n");
-  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  var _a, _b;
+  const { normalized, nonEmptyLines } = normalizeYamlContent(yamlContent);
   if (nonEmptyLines.length === 0) {
     return {};
   }
-  const minIndent = Math.min(
-    ...nonEmptyLines.map((line) => {
-      const match = line.match(LEADING_WHITESPACE_RE);
-      return match ? match[1].length : 0;
-    })
-  );
-  if (minIndent > 0) {
-    normalized = lines.map((line) => line.slice(minIndent)).join("\n");
+  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;
   }
-  try {
-    const doc = import_yaml.default.parseDocument(normalized);
-    if (doc.errors && doc.errors.length > 0) {
-      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "YAML parse error", {
-        errors: doc.errors.map((e) => e.message)
-      });
-      return null;
+  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 parsed.value;
+}
+function parseYamlContentForStreamProgress(yamlContent) {
+  const { normalized, nonEmptyLines } = normalizeYamlContent(yamlContent);
+  if (nonEmptyLines.length === 0) {
+    return {};
+  }
+  let candidate = normalized;
+  while (true) {
+    const parsed = parseYamlDocumentAsMapping(candidate);
+    if (parsed.errors.length === 0 && !hasUnstableProgressTail(candidate)) {
+      if (candidate.trim().length === 0 && normalized.trim().length > 0) {
+        return null;
+      }
+      return stabilizeParsedValueForStreamProgress(parsed.value, candidate);
     }
-    const result = doc.toJSON();
-    if (result === null) {
-      return {};
+    const truncated = dropLastMeaningfulLine(candidate);
+    if (truncated == null) {
+      return null;
     }
-    if (typeof result !== "object" || Array.isArray(result)) {
-      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "YAML content must be a key-value mapping", {
-        got: typeof result
-      });
+    if (truncated === candidate) {
       return null;
     }
-    return result;
-  } catch (error) {
-    (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, "Failed to parse YAML content", { error });
-    return null;
+    candidate = truncated;
   }
 }
 function processToolCallMatch(text, tc, currentIndex, processedElements, options) {
@@ -5239,7 +6295,7 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
   if (parsedArgs !== null) {
     processedElements.push({
       type: "tool-call",
-      toolCallId: generateId(),
+      toolCallId: generateToolCallId(),
       toolName: tc.toolName,
       input: JSON.stringify(parsedArgs)
     });
@@ -5252,38 +6308,6 @@ function processToolCallMatch(text, tc, currentIndex, processedElements, options
   }
   return tc.endIndex;
 }
-function createFlushTextHandler2(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
-  return (controller, text) => {
-    const content = text;
-    if (content) {
-      if (!getCurrentTextId()) {
-        const newId = generateId();
-        setCurrentTextId(newId);
-        controller.enqueue({
-          type: "text-start",
-          id: newId
-        });
-        setHasEmittedTextStart(true);
-      }
-      controller.enqueue({
-        type: "text-delta",
-        id: getCurrentTextId(),
-        delta: content
-      });
-    }
-    const currentTextId = getCurrentTextId();
-    if (currentTextId && !text) {
-      if (getHasEmittedTextStart()) {
-        controller.enqueue({
-          type: "text-end",
-          id: currentTextId
-        });
-        setHasEmittedTextStart(false);
-      }
-      setCurrentTextId(null);
-    }
-  };
-}
 function findEarliestToolTag2(buffer, toolNames) {
   let bestIndex = -1;
   let bestName = "";
@@ -5291,8 +6315,9 @@ function findEarliestToolTag2(buffer, toolNames) {
   let bestTagLength = 0;
   for (const name of toolNames) {
     const openTag = `<${name}>`;
-    const selfTagRegex = new RegExp(`<${name}\\s*/>`);
+    const selfTagRegex = getSelfClosingTagPattern2(name);
     const idxOpen = buffer.indexOf(openTag);
+    selfTagRegex.lastIndex = 0;
     const selfMatch = selfTagRegex.exec(buffer);
     const idxSelf = selfMatch ? selfMatch.index : -1;
     if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
@@ -5315,6 +6340,29 @@ function findEarliestToolTag2(buffer, toolNames) {
     tagLength: bestTagLength
   };
 }
+function stripTrailingPartialCloseTag(content, toolName) {
+  const closeTag = `</${toolName}>`;
+  const lastLineBreakIndex = Math.max(
+    content.lastIndexOf("\n"),
+    content.lastIndexOf("\r")
+  );
+  const lineStartIndex = lastLineBreakIndex === -1 ? 0 : lastLineBreakIndex + 1;
+  const trailingLine = content.slice(lineStartIndex);
+  const trimmedTrailingLine = trailingLine.trim();
+  if (trimmedTrailingLine.length === 0 || !trimmedTrailingLine.startsWith("</") || trimmedTrailingLine === closeTag || !closeTag.startsWith(trimmedTrailingLine)) {
+    return content;
+  }
+  const leadingWhitespaceLength = trailingLine.length - trailingLine.trimStart().length;
+  const preservedLeadingWhitespace = trailingLine.slice(
+    0,
+    leadingWhitespaceLength
+  );
+  const contentWithoutPartial = `${content.slice(
+    0,
+    lineStartIndex
+  )}${preservedLeadingWhitespace}`;
+  return contentWithoutPartial.trimEnd();
+}
 var yamlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
@@ -5375,7 +6423,7 @@ ${yamlContent}</${toolCall.toolName}>`;
       let currentToolCall = null;
       let currentTextId = null;
       let hasEmittedTextStart = false;
-      const flushText = createFlushTextHandler2(
+      const flushText = createFlushTextHandler(
         () => currentTextId,
         (newId) => {
           currentTextId = newId;
@@ -5385,33 +6433,128 @@ ${yamlContent}</${toolCall.toolName}>`;
           hasEmittedTextStart = value;
         }
       );
-      const processToolCallEnd = (controller, toolContent, toolName) => {
+      const emitToolInputProgress2 = (controller, toolContent) => {
+        if (!currentToolCall) {
+          return;
+        }
+        const parsedArgs = parseYamlContentForStreamProgress(toolContent);
+        if (parsedArgs === null) {
+          return;
+        }
+        const fullInput = JSON.stringify(parsedArgs);
+        if (fullInput === "{}" && toolContent.trim().length === 0) {
+          return;
+        }
+        const prefixCandidate = toIncompleteJsonPrefix(fullInput);
+        emitPrefixDelta({
+          controller,
+          id: currentToolCall.toolCallId,
+          state: currentToolCall,
+          candidate: prefixCandidate
+        });
+      };
+      const processToolCallEnd = (controller, toolContent, toolName, toolCallId) => {
         var _a;
         const parsedArgs = parseYamlContent(toolContent, options);
         flushText(controller);
         if (parsedArgs !== null) {
+          const finalInput = JSON.stringify(parsedArgs);
+          if (currentToolCall && currentToolCall.toolCallId === toolCallId) {
+            emitFinalRemainder({
+              controller,
+              id: toolCallId,
+              state: currentToolCall,
+              finalFullJson: finalInput,
+              onMismatch: options == null ? void 0 : options.onError
+            });
+          }
+          controller.enqueue({
+            type: "tool-input-end",
+            id: toolCallId
+          });
           controller.enqueue({
             type: "tool-call",
-            toolCallId: generateId(),
+            toolCallId,
             toolName,
-            input: JSON.stringify(parsedArgs)
+            input: finalInput
           });
         } else {
+          controller.enqueue({
+            type: "tool-input-end",
+            id: toolCallId
+          });
           const original = `<${toolName}>${toolContent}</${toolName}>`;
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
             toolCall: original
           });
-          flushText(controller, original);
+          if (shouldEmitRawToolCallTextOnError3(options)) {
+            flushText(controller, original);
+          }
         }
       };
+      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 finalInput = JSON.stringify(parsedArgs);
+          emitFinalRemainder({
+            controller,
+            id: toolCallId,
+            state: currentToolCall,
+            finalFullJson: finalInput,
+            onMismatch: options == null ? void 0 : options.onError
+          });
+          controller.enqueue({
+            type: "tool-input-end",
+            id: toolCallId
+          });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: finalInput
+          });
+        } else {
+          controller.enqueue({
+            type: "tool-input-end",
+            id: toolCallId
+          });
+          const unfinishedContent = `<${toolName}>${buffer}`;
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+            options,
+            "Could not complete streaming YAML tool call at finish.",
+            { toolCall: unfinishedContent }
+          );
+          if (shouldEmitRawToolCallTextOnError3(options)) {
+            flushText(controller, unfinishedContent);
+          }
+        }
+        buffer = "";
+        currentToolCall = null;
+      };
       const handlePendingToolCall = (controller, endTag, toolName) => {
+        var _a;
         const endIdx = buffer.indexOf(endTag);
         if (endIdx === -1) {
+          emitToolInputProgress2(controller, buffer);
           return false;
         }
         const content = buffer.substring(0, endIdx);
+        emitToolInputProgress2(controller, content);
         buffer = buffer.substring(endIdx + endTag.length);
-        processToolCallEnd(controller, content, toolName);
+        processToolCallEnd(
+          controller,
+          content,
+          toolName,
+          (_a = currentToolCall == null ? void 0 : currentToolCall.toolCallId) != null ? _a : generateToolCallId()
+        );
         currentToolCall = null;
         return true;
       };
@@ -5428,13 +6571,35 @@ ${yamlContent}</${toolCall.toolName}>`;
         if (tagIndex > 0) {
           flushText(controller, buffer.substring(0, tagIndex));
         }
+        flushText(controller);
         if (selfClosing) {
           buffer = buffer.substring(tagIndex + tagLength);
-          processToolCallEnd(controller, "", tagName);
+          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.substring(tagIndex + startTag.length);
-          currentToolCall = { name: tagName, content: "" };
+          currentToolCall = {
+            name: tagName,
+            toolCallId: generateToolCallId(),
+            emittedInput: ""
+          };
+          controller.enqueue({
+            type: "tool-input-start",
+            id: currentToolCall.toolCallId,
+            toolName: tagName
+          });
         }
       };
       const processBuffer = (controller) => {
@@ -5463,10 +6628,7 @@ ${yamlContent}</${toolCall.toolName}>`;
           var _a;
           if (chunk.type === "finish") {
             if (currentToolCall) {
-              const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
-              flushText(controller, unfinishedContent);
-              buffer = "";
-              currentToolCall = null;
+              finalizeUnclosedToolCall(controller);
             } else if (buffer) {
               flushText(controller, buffer);
               buffer = "";
@@ -5476,7 +6638,7 @@ ${yamlContent}</${toolCall.toolName}>`;
             return;
           }
           if (chunk.type !== "text-delta") {
-            if (buffer) {
+            if (!currentToolCall && buffer) {
               flushText(controller, buffer);
               buffer = "";
             }
@@ -5489,10 +6651,7 @@ ${yamlContent}</${toolCall.toolName}>`;
         },
         flush(controller) {
           if (currentToolCall) {
-            const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
-            flushText(controller, unfinishedContent);
-            buffer = "";
-            currentToolCall = null;
+            finalizeUnclosedToolCall(controller);
           } else if (buffer) {
             flushText(controller, buffer);
             buffer = "";
@@ -5670,9 +6829,6 @@ function hasInputProperty(obj) {
   return typeof obj === "object" && obj !== null && "input" in obj;
 }
 
-// src/generate-handler.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-
 // src/core/utils/generated-text-json-recovery.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5811,7 +6967,7 @@ function mergeJsonCandidatesByStart(tagged, codeBlocks, balanced) {
 function toToolCallPart(candidate) {
   return {
     type: "tool-call",
-    toolCallId: generateId(),
+    toolCallId: generateToolCallId(),
     toolName: candidate.toolName,
     input: candidate.input
   };
@@ -6038,7 +7194,7 @@ async function handleToolChoice(doGenerate, params, tools) {
   }
   const toolCall = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils.generateId)(),
+    toolCallId: generateToolCallId(),
     toolName,
     input
   };
@@ -6548,7 +7704,6 @@ unit: celsius
 }
 
 // src/stream-handler.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
 async function wrapStream({
   protocol,
   doStream,
@@ -6586,10 +7741,22 @@ async function wrapStream({
       }
     )
   ).pipeThrough(protocol.createStreamParser({ tools, options }));
+  let seenToolCall = false;
   const v3Stream = coreStream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
-        const normalizedPart = part.type === "tool-call" ? coerceToolCallPart(part, tools) : part;
+        let normalizedPart = part.type === "tool-call" ? coerceToolCallPart(part, tools) : part;
+        if (normalizedPart.type === "tool-call") {
+          seenToolCall = true;
+        }
+        if (normalizedPart.type === "finish" && seenToolCall && normalizedPart.finishReason.unified === "stop") {
+          normalizedPart = {
+            ...normalizedPart,
+            finishReason: normalizeToolCallsFinishReason(
+              normalizedPart.finishReason
+            )
+          };
+        }
         if (debugLevel === "stream") {
           logParsedChunk(normalizedPart);
         }
@@ -6626,7 +7793,7 @@ async function toolChoiceStream({
     start(controller) {
       controller.enqueue({
         type: "tool-call",
-        toolCallId: (0, import_provider_utils2.generateId)(),
+        toolCallId: generateToolCallId(),
         toolName,
         input
       });