@ai-sdk-tool/parser 3.3.2 → 4.0.0

package/dist/community.cjs

@@ -847,7 +847,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
@@ -856,6 +874,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) {
@@ -863,15 +913,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({
@@ -880,7 +936,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 }
@@ -901,6 +957,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;
@@ -931,44 +1274,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();
@@ -986,42 +1362,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
       }
@@ -1037,6 +1411,7 @@ function processTagMatch(context) {
   } else {
     state.currentToolCallJson = "";
     state.isInsideToolCall = true;
+    state.activeToolInput = null;
   }
 }
 function processBufferTags(context) {
@@ -1059,8 +1434,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);
@@ -1133,13 +1516,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") {
@@ -1155,7 +1539,7 @@ var jsonProtocol = ({
           toolCallEnd,
           options
         });
-        handlePartialTag(state, controller, toolCallStart);
+        handlePartialTag(state, controller, toolCallStart, toolCallEnd);
       }
     });
   },
@@ -1516,6 +1900,13 @@ var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
 var NEWLINE_SPLIT_REGEX = /\n+/;
 var COMMA_SPLIT_REGEX = /,\s*/;
 var DIGIT_KEY_REGEX = /^\d+$/;
+var WHITESPACE_REGEX2 = /\s+/g;
+var HAS_WHITESPACE_REGEX = /\s/;
+var SINGLE_QUOTE = "'";
+var DOUBLE_QUOTE = '"';
+var SNAKE_SEGMENT_REGEX = /_([a-zA-Z0-9])/g;
+var CAMEL_BOUNDARY_REGEX = /([a-z0-9])([A-Z])/g;
+var LEADING_UNDERSCORES_REGEX = /^_+/;
 function unwrapJsonSchema(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -1764,39 +2155,299 @@ function coerceStringToArray(s, unwrapped) {
   }
   return null;
 }
-function coerceObjectToObject(value, unwrapped) {
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    out[k] = coerceValueForKey(v, k, unwrapped);
+function getStrictObjectSchemaInfo(unwrapped) {
+  if (getSchemaType(unwrapped) !== "object") {
+    return null;
   }
-  return out;
+  if (unwrapped.additionalProperties !== false) {
+    return null;
+  }
+  const properties = unwrapped.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const required = Array.isArray(unwrapped.required) ? unwrapped.required.filter(
+    (value) => typeof value === "string" && value.length > 0
+  ) : [];
+  const patternProps = unwrapped.patternProperties;
+  const patternProperties = patternProps && typeof patternProps === "object" && !Array.isArray(patternProps) ? patternProps : void 0;
+  return {
+    properties: propertyMap,
+    required,
+    patternProperties
+  };
 }
-function coerceArrayToArray(value, prefixItems, itemsSchema) {
-  if (prefixItems && value.length === prefixItems.length) {
-    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+function isSingularPluralPair(left, right) {
+  return left.length > 1 && right.length > 1 && (left === `${right}s` || right === `${left}s`);
+}
+function snakeToCamel(value) {
+  const trimmed = value.replace(LEADING_UNDERSCORES_REGEX, "");
+  if (trimmed.length === 0) {
+    return value;
   }
-  return value.map((v) => coerceBySchema(v, itemsSchema));
+  const camelized = trimmed.replace(
+    SNAKE_SEGMENT_REGEX,
+    (_, c) => c.toUpperCase()
+  );
+  return camelized.charAt(0).toLowerCase() + camelized.slice(1);
 }
-function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
-  if (Object.hasOwn(maybe, "item")) {
-    const items = maybe.item;
-    const arr = Array.isArray(items) ? items : [items];
-    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+function camelToSnake(value) {
+  return value.replace(CAMEL_BOUNDARY_REGEX, "$1_$2").toLowerCase();
+}
+function isCaseStylePair(targetKey, sourceKey) {
+  if (targetKey === sourceKey) {
+    return false;
+  }
+  const sourceLooksSnake = sourceKey.includes("_");
+  const targetLooksSnake = targetKey.includes("_");
+  if (sourceLooksSnake && snakeToCamel(sourceKey) === targetKey) {
+    return true;
+  }
+  if (!sourceLooksSnake && targetLooksSnake && camelToSnake(sourceKey) === targetKey) {
+    return true;
+  }
+  return false;
+}
+function isUnexpectedKey(key, schemaInfo) {
+  if (Object.hasOwn(schemaInfo.properties, key)) {
+    return false;
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    schemaInfo.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    return patternSchemas.every((schema) => schema === false);
+  }
+  return true;
+}
+function computeMissingAndUnexpectedKeys(input, schemaInfo) {
+  const missingRequired = schemaInfo.required.filter(
+    (key) => !Object.hasOwn(input, key)
+  );
+  const unexpectedKeys = Object.keys(input).filter(
+    (key) => isUnexpectedKey(key, schemaInfo)
+  );
+  return { missingRequired, unexpectedKeys };
+}
+function applySingularPluralRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isSingularPluralPair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (getSchemaType(schemaInfo.properties[targetKey]) !== "array") {
+    return null;
+  }
+  if (!Array.isArray(input[sourceKey])) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyCaseStyleRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isCaseStylePair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyStrictRequiredKeyRename(input, unwrapped) {
+  const schemaInfo = getStrictObjectSchemaInfo(unwrapped);
+  if (!schemaInfo) {
+    return input;
+  }
+  const singularPlural = applySingularPluralRequiredKeyRename(
+    input,
+    schemaInfo
+  );
+  if (singularPlural) {
+    return singularPlural;
+  }
+  const caseStyle = applyCaseStyleRequiredKeyRename(input, schemaInfo);
+  if (caseStyle) {
+    return caseStyle;
+  }
+  return input;
+}
+function coerceObjectToObject(value, unwrapped) {
+  const normalizedInput = applyStrictRequiredKeyRename(value, unwrapped);
+  const out = {};
+  for (const [k, v] of Object.entries(normalizedInput)) {
+    out[k] = coerceValueForKey(v, k, unwrapped);
+  }
+  return out;
+}
+function coerceArrayToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && value.length === prefixItems.length) {
+    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+  }
+  return value.map((v) => coerceBySchema(v, itemsSchema));
+}
+function isPrimitiveSchemaType(schemaType) {
+  return schemaType === "string" || schemaType === "number" || schemaType === "integer" || schemaType === "boolean";
+}
+function isPrimitiveMatchForSchemaType(value, schemaType) {
+  if (schemaType === "string") {
+    return typeof value === "string";
+  }
+  if (schemaType === "number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (schemaType === "integer") {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+  }
+  return typeof value === "boolean";
+}
+function coercePrimitiveWrappedObject(value, itemsSchema) {
+  const schemaType = getSchemaType(itemsSchema);
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(singleValue, itemsSchema);
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
+function coerceParallelArraysObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (prefixItems && prefixItems.length > 0) {
+    return null;
+  }
+  const unwrappedItems = unwrapJsonSchema(itemsSchema);
+  if (!unwrappedItems || typeof unwrappedItems !== "object" || Array.isArray(unwrappedItems)) {
+    return null;
+  }
+  const itemSchema = unwrappedItems;
+  if (getSchemaType(itemSchema) !== "object") {
+    return null;
+  }
+  if (itemSchema.additionalProperties !== false) {
+    return null;
+  }
+  const properties = itemSchema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const entries = Object.entries(maybe);
+  if (entries.length < 2) {
+    return null;
+  }
+  if (!entries.every(([, value]) => Array.isArray(value))) {
+    return null;
+  }
+  if (!entries.every(([key]) => Object.hasOwn(propertyMap, key))) {
+    return null;
+  }
+  if (!entries.every(([key]) => {
+    const schemaType = getSchemaType(propertyMap[key]);
+    return schemaType !== "array" && schemaType !== "object";
+  })) {
+    return null;
+  }
+  const lengths = [
+    ...new Set(entries.map(([, value]) => value.length))
+  ];
+  if (lengths.length !== 1) {
+    return null;
+  }
+  const length = lengths[0];
+  if (length < 2) {
+    return null;
+  }
+  const zipped = [];
+  for (let index = 0; index < length; index += 1) {
+    const item = {};
+    for (const [key, value] of entries) {
+      item[key] = value[index];
+    }
+    zipped.push(item);
+  }
+  return coerceArrayToArray(zipped, prefixItems, itemsSchema);
+}
+function coerceSingleKeyObjectToArray(singleValue, itemsSchema) {
+  if (Array.isArray(singleValue)) {
+    return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+  }
+  if (singleValue && typeof singleValue === "object") {
+    const primitiveWrapped = coercePrimitiveWrappedObject(
+      singleValue,
+      itemsSchema
+    );
+    if (primitiveWrapped !== null) {
+      return [primitiveWrapped];
+    }
+    return [coerceBySchema(singleValue, itemsSchema)];
+  }
+  return null;
+}
+function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (Object.hasOwn(maybe, "item")) {
+    const items = maybe.item;
+    const arr = Array.isArray(items) ? items : [items];
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
   const keys = Object.keys(maybe);
   if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
     const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
+  const parallelArrays = coerceParallelArraysObjectToArray(
+    maybe,
+    prefixItems,
+    itemsSchema
+  );
+  if (parallelArrays !== null) {
+    return parallelArrays;
+  }
   if (keys.length === 1) {
     const singleKey = keys[0];
     if (!(schemaIsUnconstrained(itemsSchema) || schemaHasProperty(itemsSchema, singleKey))) {
-      const singleValue = maybe[singleKey];
-      if (Array.isArray(singleValue)) {
-        return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      if (singleValue && typeof singleValue === "object") {
-        return [coerceBySchema(singleValue, itemsSchema)];
+      const result = coerceSingleKeyObjectToArray(
+        maybe[singleKey],
+        itemsSchema
+      );
+      if (result !== null) {
+        return result;
       }
     }
   }
@@ -1826,6 +2477,86 @@ function coerceStringToPrimitive(s, schemaType) {
   }
   return null;
 }
+function coercePrimitiveToString(value, schemaType) {
+  if (schemaType !== "string") {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function coerceStringByEnumWhitespace(rawValue, unwrapped) {
+  const enumValues = unwrapped.enum;
+  if (!Array.isArray(enumValues) || enumValues.length === 0) {
+    return null;
+  }
+  if (!enumValues.every((item) => typeof item === "string")) {
+    return null;
+  }
+  const normalizedEnumValues = enumValues;
+  if (normalizedEnumValues.includes(rawValue)) {
+    return null;
+  }
+  const unquoted = unwrapMatchingQuotes(rawValue);
+  if (unquoted !== null) {
+    const exactMatches = normalizedEnumValues.filter(
+      (item) => item === unquoted
+    );
+    if (exactMatches.length === 1) {
+      return exactMatches[0];
+    }
+  }
+  const candidates = [rawValue, unquoted].filter(
+    (item) => item !== null
+  );
+  for (const candidate of candidates) {
+    if (!HAS_WHITESPACE_REGEX.test(candidate)) {
+      continue;
+    }
+    const normalizedInput = candidate.replace(WHITESPACE_REGEX2, "");
+    const matches = normalizedEnumValues.filter(
+      (item) => item.replace(WHITESPACE_REGEX2, "") === normalizedInput
+    );
+    if (matches.length === 1) {
+      return matches[0];
+    }
+  }
+  return null;
+}
+function unwrapMatchingQuotes(value) {
+  if (value.length < 2) {
+    return null;
+  }
+  const first = value[0];
+  const last = value.at(-1);
+  const isQuote = (first === SINGLE_QUOTE || first === DOUBLE_QUOTE) && first === last;
+  if (!isQuote) {
+    return null;
+  }
+  return value.slice(1, -1);
+}
+function coerceObjectToPrimitive(value, schemaType, fullSchema) {
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(
+    singleValue,
+    fullSchema != null ? fullSchema : { type: schemaType }
+  );
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
 function coerceStringValue(value, schemaType, u) {
   const s = value.trim();
   if (schemaType === "object") {
@@ -1844,6 +2575,10 @@ function coerceStringValue(value, schemaType, u) {
   if (primitiveResult !== null) {
     return primitiveResult;
   }
+  const enumWhitespaceCanonical = coerceStringByEnumWhitespace(s, u);
+  if (enumWhitespaceCanonical !== null) {
+    return enumWhitespaceCanonical;
+  }
   return value;
 }
 function coerceArrayValue(value, prefixItems, itemsSchema) {
@@ -1882,9 +2617,23 @@ function coerceBySchema(value, schema) {
   if (typeof value === "string") {
     return coerceStringValue(value, schemaType, u);
   }
+  const primitiveString = coercePrimitiveToString(value, schemaType);
+  if (primitiveString !== null) {
+    return primitiveString;
+  }
   if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
     return coerceObjectToObject(value, u);
   }
+  if (value && typeof value === "object" && !Array.isArray(value) && isPrimitiveSchemaType(schemaType)) {
+    const primitiveResult = coerceObjectToPrimitive(
+      value,
+      schemaType,
+      u
+    );
+    if (primitiveResult !== null) {
+      return primitiveResult;
+    }
+  }
   if (schemaType === "array") {
     const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
     const itemsSchema = u.items;
@@ -2899,7 +3648,7 @@ var XMLTokenizer = class {
 };
 
 // src/rxml/core/parser.ts
-var WHITESPACE_REGEX2 = /\s/;
+var WHITESPACE_REGEX3 = /\s/;
 var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 var DIGIT_KEY_REGEX2 = /^\d+$/;
 function getTopLevelStringProps(s) {
@@ -3069,7 +3818,7 @@ function parse2(xmlInner, schema, options = {}) {
         const closeHead = s.indexOf(`</${rootName}`, range.end);
         if (closeHead === range.end) {
           let p = closeHead + 2 + rootName.length;
-          while (p < s.length && WHITESPACE_REGEX2.test(s[p])) {
+          while (p < s.length && WHITESPACE_REGEX3.test(s[p])) {
             p += 1;
           }
           if (s[p] === ">") {
@@ -3407,7 +4156,7 @@ function createIntermediateCall(toolName, rawSegment, schema) {
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
 var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
-var WHITESPACE_REGEX3 = /\s/;
+var WHITESPACE_REGEX4 = /\s/;
 var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
 var NAME_START_CHAR_RE = /[A-Za-z_:]/;
 var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
@@ -3548,7 +4297,7 @@ function balanceTags(xml) {
 }
 function skipWs(s, p, len) {
   let idx = p;
-  while (idx < len && WHITESPACE_REGEX3.test(s[idx])) {
+  while (idx < len && WHITESPACE_REGEX4.test(s[idx])) {
     idx += 1;
   }
   return idx;
@@ -3601,7 +4350,7 @@ function handleOpeningTagSegment(src, lt, out, stack) {
     return len;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX3.test(src[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX4.test(src[r])) {
     r -= 1;
   }
   const selfClosing = src[r] === "/";
@@ -3765,13 +4514,114 @@ function parse3(xml, schema, options = {}) {
 
 // src/core/utils/regex-constants.ts
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX4 = /\s/;
+var WHITESPACE_REGEX5 = /\s/;
+
+// src/core/utils/streamed-tool-input-delta.ts
+function emitDelta({
+  controller,
+  id,
+  state,
+  nextInput
+}) {
+  if (!nextInput.startsWith(state.emittedInput)) {
+    return false;
+  }
+  const delta = nextInput.slice(state.emittedInput.length);
+  if (delta.length === 0) {
+    return false;
+  }
+  controller.enqueue({
+    type: "tool-input-delta",
+    id,
+    delta
+  });
+  state.emittedInput = nextInput;
+  return true;
+}
+function toIncompleteJsonPrefix(fullJson) {
+  const trimmed = fullJson.trim();
+  let prefix = trimmed;
+  while (prefix.endsWith("}") || prefix.endsWith("]")) {
+    prefix = prefix.slice(0, -1);
+  }
+  prefix = prefix.trimEnd();
+  if (prefix.endsWith('"')) {
+    prefix = prefix.slice(0, -1);
+  }
+  if (prefix.length === 0) {
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+      return trimmed.startsWith("{") ? "{" : "[";
+    }
+    if (trimmed.startsWith("]")) {
+      return "[";
+    }
+    if (trimmed.startsWith("}")) {
+      return "{";
+    }
+    if (trimmed.startsWith('"')) {
+      return '"';
+    }
+    return "{";
+  }
+  return prefix;
+}
+function emitPrefixDelta(params) {
+  return emitDelta({
+    ...params,
+    nextInput: params.candidate
+  });
+}
+function emitFinalRemainder(params) {
+  var _a;
+  const result = emitDelta({
+    ...params,
+    nextInput: params.finalFullJson
+  });
+  if (!result && params.state.emittedInput.length > 0) {
+    (_a = params.onMismatch) == null ? void 0 : _a.call(
+      params,
+      "Final JSON does not extend emitted tool-input prefix",
+      {
+        emittedLength: params.state.emittedInput.length,
+        finalLength: params.finalFullJson.length
+      }
+    );
+  }
+  return result;
+}
+
+// src/core/utils/xml-root-repair.ts
+var XML_SELF_CLOSING_ROOT_WITH_BODY_REGEX = /^<([A-Za-z_][A-Za-z0-9_-]*)\s*\r?\n([\s\S]+?)\r?\n\s*\/>\s*$/;
+function tryRepairXmlSelfClosingRootWithBody(rawText, toolNames) {
+  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;
@@ -3784,7 +4634,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)
     });
@@ -3801,60 +4651,371 @@ function processToolCall(params) {
     processedElements.push({ type: "text", text: originalCallText });
   }
 }
-function handleStreamingToolCallEnd(params) {
-  var _a, _b;
-  const {
-    toolContent,
-    currentToolCall,
-    tools,
-    options,
-    ctrl,
-    flushText,
-    parseOptions
-  } = params;
-  const toolSchema = getToolSchema(tools, currentToolCall.name);
-  const parseConfig = {
-    ...parseOptions != null ? parseOptions : {},
-    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
-  };
-  flushText(ctrl);
-  try {
-    const parsedResult = parse3(toolContent, toolSchema, parseConfig);
-    ctrl.enqueue({
-      type: "tool-call",
-      toolCallId: generateId(),
-      toolName: currentToolCall.name,
-      input: JSON.stringify(parsedResult)
-    });
-  } catch (error) {
-    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);
+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 findClosingTagEndFlexible(text, contentStart, toolName) {
-  let pos = contentStart;
-  let depth = 1;
-  while (pos < text.length) {
-    const tok = nextTagToken(text, pos);
-    if (tok.kind === "eof") {
-      break;
-    }
-    const result = updateDepthWithToken(tok, toolName, depth);
-    depth = result.depth;
-    if (result.closedAt !== void 0) {
-      return result.closedAt;
-    }
-    pos = tok.nextPos;
+function consumeXmlSpecialSection(fragment, ltIndex) {
+  if (fragment.startsWith("<!--", ltIndex)) {
+    const commentEnd = fragment.indexOf("-->", ltIndex + 4);
+    return commentEnd === -1 ? { kind: "incomplete" } : { kind: "consumed", nextPos: commentEnd + 3 };
   }
-  return -1;
+  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 skipSpecialSegment(text, lt) {
-  const next = text[lt + 1];
-  if (next === "!" || next === "?") {
+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 {
+    toolContent,
+    currentToolCall,
+    tools,
+    options,
+    ctrl,
+    flushText,
+    parseOptions
+  } = params;
+  const toolSchema = getToolSchema(tools, currentToolCall.name);
+  const parseConfig = {
+    ...parseOptions != null ? parseOptions : {},
+    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
+  };
+  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: currentToolCall.toolCallId,
+      toolName: currentToolCall.name,
+      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
+    });
+    if (shouldEmitRawToolCallTextOnError2(options)) {
+      flushText(ctrl, original);
+    }
+  }
+}
+function findClosingTagEndFlexible(text, contentStart, toolName) {
+  let pos = contentStart;
+  let depth = 1;
+  while (pos < text.length) {
+    const tok = nextTagToken(text, pos);
+    if (tok.kind === "eof") {
+      break;
+    }
+    const result = updateDepthWithToken(tok, toolName, depth);
+    depth = result.depth;
+    if (result.closedAt !== void 0) {
+      return result.closedAt;
+    }
+    pos = tok.nextPos;
+  }
+  return -1;
+}
+function skipSpecialSegment(text, lt) {
+  const next = text[lt + 1];
+  if (next === "!" || next === "?") {
     const gt = text.indexOf(">", lt + 1);
     if (gt !== -1) {
       return gt + 1;
@@ -3869,7 +5030,7 @@ function consumeClosingTag(text, lt) {
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX5.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
@@ -3882,7 +5043,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX5.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -3911,7 +5072,7 @@ function nextTagToken(text, fromPos) {
   if (next === "/") {
     const closing = consumeClosingTag(text, lt);
     let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
+    while (p < text.length && WHITESPACE_REGEX5.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
@@ -4048,6 +5209,102 @@ function findToolCalls(text, toolNames) {
   }
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
+function handleSpecialToken(depth) {
+  return { depth, lastCompleteEnd: -1, shouldBreak: false };
+}
+function handleOpenToken(token, depth, lastCompleteEnd) {
+  if (token.selfClosing) {
+    return {
+      depth,
+      lastCompleteEnd: depth === 0 ? token.nextPos : lastCompleteEnd,
+      shouldBreak: false
+    };
+  }
+  return { depth: depth + 1, lastCompleteEnd, shouldBreak: false };
+}
+function handleCloseToken(token, depth) {
+  if (depth <= 0) {
+    return { depth, lastCompleteEnd: -1, shouldBreak: true };
+  }
+  const newDepth = depth - 1;
+  return {
+    depth: newDepth,
+    lastCompleteEnd: newDepth === 0 ? token.nextPos : -1,
+    shouldBreak: false
+  };
+}
+function findLinePrefixedXmlBodyEnd(text, bodyStartIndex) {
+  let cursor = bodyStartIndex;
+  let depth = 0;
+  let lastCompleteEnd = -1;
+  while (cursor < text.length) {
+    if (depth === 0) {
+      cursor = consumeWhitespace(text, cursor);
+      if (cursor >= text.length || text.charAt(cursor) !== "<") {
+        break;
+      }
+    }
+    const token = nextTagToken(text, cursor);
+    if (token.kind === "eof") {
+      break;
+    }
+    let result;
+    if (token.kind === "special") {
+      result = handleSpecialToken(depth);
+    } else if (token.kind === "open") {
+      result = handleOpenToken(token, depth, lastCompleteEnd);
+    } else {
+      result = handleCloseToken(token, depth);
+    }
+    depth = result.depth;
+    if (result.lastCompleteEnd !== -1) {
+      lastCompleteEnd = result.lastCompleteEnd;
+    }
+    if (result.shouldBreak) {
+      break;
+    }
+    cursor = token.nextPos;
+  }
+  return lastCompleteEnd;
+}
+function findLinePrefixedToolCall(text, toolNames) {
+  var _a;
+  let best = null;
+  for (const toolName of toolNames) {
+    const linePattern = new RegExp(
+      `(^|\\n)[\\t ]*${escapeRegExp(toolName)}[\\t ]*:?[\\t ]*(?:\\r?\\n|$)`,
+      "g"
+    );
+    let match = linePattern.exec(text);
+    while (match !== null) {
+      const prefix = (_a = match[1]) != null ? _a : "";
+      const startIndex = match.index + prefix.length;
+      const contentStart = consumeWhitespace(text, linePattern.lastIndex);
+      if (contentStart >= text.length || text.charAt(contentStart) !== "<") {
+        match = linePattern.exec(text);
+        continue;
+      }
+      const contentEnd = findLinePrefixedXmlBodyEnd(text, contentStart);
+      if (contentEnd === -1 || contentEnd <= contentStart) {
+        match = linePattern.exec(text);
+        continue;
+      }
+      const content = text.slice(contentStart, contentEnd);
+      const candidate = {
+        toolName,
+        startIndex,
+        endIndex: contentEnd,
+        content,
+        segment: text.slice(startIndex, contentEnd)
+      };
+      if (best === null || candidate.startIndex < best.startIndex) {
+        best = candidate;
+      }
+      break;
+    }
+  }
+  return best;
+}
 function findEarliestToolTag(buffer, toolNames) {
   var _a, _b;
   let bestIndex = -1;
@@ -4086,7 +5343,7 @@ function isOpenTagPrefix(suffix, toolName) {
 }
 function consumeWhitespace(text, index) {
   let i = index;
-  while (i < text.length && WHITESPACE_REGEX4.test(text.charAt(i))) {
+  while (i < text.length && WHITESPACE_REGEX5.test(text.charAt(i))) {
     i += 1;
   }
   return i;
@@ -4158,38 +5415,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,
@@ -4199,18 +5424,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({
@@ -4237,7 +5465,8 @@ function processNoToolCallInBuffer(params) {
     tools,
     options,
     parseOptions,
-    setBuffer
+    setBuffer,
+    emitToolInputStart
   } = params;
   const {
     index: earliestStartTagIndex,
@@ -4267,9 +5496,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,
@@ -4288,12 +5518,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();
@@ -4306,7 +5536,8 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           controller,
           flushText,
           setBuffer,
-          parseOptions
+          parseOptions,
+          emitToolInputProgress: emitToolInputProgress2
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -4322,7 +5553,8 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           tools,
           options,
           parseOptions,
-          setBuffer
+          setBuffer,
+          emitToolInputStart
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -4337,6 +5569,27 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
     }
   };
 }
+function findToolCallsWithFallbacks(text, toolNames) {
+  let parseText = text;
+  let toolCalls = findToolCalls(parseText, toolNames);
+  if (toolCalls.length === 0) {
+    const fallbackToolCall = findLinePrefixedToolCall(parseText, toolNames);
+    if (fallbackToolCall !== null) {
+      toolCalls.push(fallbackToolCall);
+    }
+  }
+  if (toolCalls.length === 0) {
+    const repaired = tryRepairXmlSelfClosingRootWithBody(parseText, toolNames);
+    if (repaired) {
+      const repairedCalls = findToolCalls(repaired, toolNames);
+      if (repairedCalls.length > 0) {
+        parseText = repaired;
+        toolCalls = repairedCalls;
+      }
+    }
+  }
+  return { parseText, toolCalls };
+}
 var xmlProtocol = (protocolOptions) => {
   var _a;
   const parseOptions = {
@@ -4370,28 +5623,31 @@ var xmlProtocol = (protocolOptions) => {
       }
       const processedElements = [];
       let currentIndex = 0;
-      const toolCalls = findToolCalls(text, toolNames);
+      const { parseText, toolCalls } = findToolCallsWithFallbacks(
+        text,
+        toolNames
+      );
       for (const tc of toolCalls) {
         if (tc.startIndex > currentIndex) {
           processedElements.push({
             type: "text",
-            text: text.substring(currentIndex, tc.startIndex)
+            text: parseText.substring(currentIndex, tc.startIndex)
           });
         }
         processToolCall({
           toolCall: tc,
           tools,
           options,
-          text,
+          text: parseText,
           processedElements,
           parseOptions
         });
         currentIndex = tc.endIndex;
       }
-      if (currentIndex < text.length) {
+      if (currentIndex < parseText.length) {
         processedElements.push({
           type: "text",
-          text: text.substring(currentIndex)
+          text: parseText.substring(currentIndex)
         });
       }
       return processedElements;
@@ -4412,8 +5668,120 @@ var xmlProtocol = (protocolOptions) => {
           hasEmittedTextStart = value;
         }
       );
-      const processBuffer = createProcessBufferHandler(
-        () => buffer,
+      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) => {
           buffer = newBuffer;
         },
@@ -4425,13 +5793,28 @@ 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) {
+              finalizeUnclosedToolCall(controller);
+            } else if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            flushText(controller);
+            controller.enqueue(chunk);
+            return;
+          }
           if (chunk.type !== "text-delta") {
-            if (buffer) {
+            if (currentToolCall) {
+            } else if (buffer) {
               flushText(controller, buffer);
               buffer = "";
             }
@@ -4444,10 +5827,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 = "";
@@ -4475,7 +5855,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;
@@ -4491,7 +6069,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX4.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX5.test(text[p])) {
         p++;
       }
       const nameStart = p;
@@ -4511,7 +6089,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX5.test(text[p])) {
         p++;
       }
       const nameStart = p;
@@ -4524,7 +6102,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX5.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -4547,7 +6125,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);
@@ -4599,47 +6177,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) {
@@ -4655,7 +6234,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)
     });
@@ -4668,38 +6247,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 = "";
@@ -4707,8 +6254,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)) {
@@ -4731,6 +6279,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 }) {
@@ -4756,18 +6327,32 @@ ${yamlContent}</${toolCall.toolName}>`;
       }
       const processedElements = [];
       let currentIndex = 0;
-      const toolCalls = findToolCalls2(text, toolNames);
+      let parseText = text;
+      let toolCalls = findToolCalls2(parseText, toolNames);
+      if (toolCalls.length === 0) {
+        const repaired = tryRepairXmlSelfClosingRootWithBody(
+          parseText,
+          toolNames
+        );
+        if (repaired) {
+          const repairedCalls = findToolCalls2(repaired, toolNames);
+          if (repairedCalls.length > 0) {
+            parseText = repaired;
+            toolCalls = repairedCalls;
+          }
+        }
+      }
       for (const tc of toolCalls) {
         currentIndex = processToolCallMatch(
-          text,
+          parseText,
           tc,
           currentIndex,
           processedElements,
           options
         );
       }
-      if (currentIndex < text.length) {
-        addTextSegment(text.substring(currentIndex), processedElements);
+      if (currentIndex < parseText.length) {
+        addTextSegment(parseText.substring(currentIndex), processedElements);
       }
       return processedElements;
     },
@@ -4777,7 +6362,7 @@ ${yamlContent}</${toolCall.toolName}>`;
       let currentToolCall = null;
       let currentTextId = null;
       let hasEmittedTextStart = false;
-      const flushText = createFlushTextHandler2(
+      const flushText = createFlushTextHandler(
         () => currentTextId,
         (newId) => {
           currentTextId = newId;
@@ -4787,33 +6372,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;
       };
@@ -4830,13 +6510,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) => {
@@ -4863,8 +6565,19 @@ ${yamlContent}</${toolCall.toolName}>`;
       return new TransformStream({
         transform(chunk, controller) {
           var _a;
+          if (chunk.type === "finish") {
+            if (currentToolCall) {
+              finalizeUnclosedToolCall(controller);
+            } else if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            flushText(controller);
+            controller.enqueue(chunk);
+            return;
+          }
           if (chunk.type !== "text-delta") {
-            if (buffer) {
+            if (!currentToolCall && buffer) {
               flushText(controller, buffer);
               buffer = "";
             }
@@ -4877,10 +6590,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 = "";
@@ -4986,17 +6696,56 @@ function encodeOriginalTools(tools) {
     inputSchema: JSON.stringify(t.inputSchema)
   }))) || [];
 }
-function decodeOriginalTools(originalTools) {
+function decodeOriginalTools(originalTools, options) {
+  var _a, _b, _c;
   if (!originalTools) {
     return [];
   }
-  return originalTools.map(
-    (t) => ({
-      type: "function",
-      name: t.name,
-      inputSchema: JSON.parse(t.inputSchema)
-    })
-  );
+  const decodedTools = [];
+  for (const [index, tool] of originalTools.entries()) {
+    if (!tool || typeof tool.name !== "string") {
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Invalid originalTools entry: missing tool name", {
+        index,
+        tool
+      });
+      continue;
+    }
+    if (typeof tool.inputSchema !== "string") {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        options,
+        "Invalid originalTools entry: inputSchema must be a string",
+        {
+          index,
+          toolName: tool.name
+        }
+      );
+      continue;
+    }
+    try {
+      decodedTools.push({
+        type: "function",
+        name: tool.name,
+        inputSchema: JSON.parse(tool.inputSchema)
+      });
+    } catch (error) {
+      (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(
+        options,
+        "Failed to decode originalTools input schema, using permissive fallback schema",
+        {
+          index,
+          toolName: tool.name,
+          inputSchema: tool.inputSchema,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      decodedTools.push({
+        type: "function",
+        name: tool.name,
+        inputSchema: { type: "object" }
+      });
+    }
+  }
+  return decodedTools;
 }
 function isToolChoiceActive(params) {
   var _a, _b, _c;
@@ -5004,25 +6753,336 @@ function isToolChoiceActive(params) {
   return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
 }
 
-// src/generate-handler.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-function parseToolChoiceJson(text, providerOptions) {
+// src/core/utils/generated-text-json-recovery.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeStringify2(value) {
+  try {
+    return JSON.stringify(value != null ? value : {});
+  } catch (e) {
+    return "{}";
+  }
+}
+function parseJsonCandidate(candidateText) {
+  try {
+    return parse(candidateText);
+  } catch (e) {
+    return void 0;
+  }
+}
+function extractCodeBlockCandidates(text) {
+  var _a, _b;
+  const codeBlockRegex = /```(?:json|yaml|xml)?\s*([\s\S]*?)```/gi;
+  const candidates = [];
+  let match;
+  while (true) {
+    match = codeBlockRegex.exec(text);
+    if (!match) {
+      break;
+    }
+    const body = (_a = match[1]) == null ? void 0 : _a.trim();
+    if (body) {
+      const startIndex = (_b = match.index) != null ? _b : 0;
+      const endIndex = startIndex + match[0].length;
+      candidates.push({
+        text: body,
+        startIndex,
+        endIndex
+      });
+    }
+  }
+  return candidates;
+}
+function scanJsonChar(state, char) {
+  if (state.inString) {
+    if (state.escaping) {
+      return { ...state, escaping: false };
+    }
+    if (char === "\\") {
+      return { ...state, escaping: true };
+    }
+    if (char === '"') {
+      return { ...state, inString: false };
+    }
+    return state;
+  }
+  if (char === '"') {
+    return { ...state, inString: true };
+  }
+  if (char === "{") {
+    return { ...state, depth: state.depth + 1 };
+  }
+  if (char === "}") {
+    return { ...state, depth: Math.max(0, state.depth - 1) };
+  }
+  return state;
+}
+function extractBalancedJsonObjects(text) {
+  const maxCandidateLength = 1e4;
+  const candidates = [];
+  let state = { depth: 0, inString: false, escaping: false };
+  let currentStart = null;
+  let ignoreCurrent = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (!state.inString && char === "{" && state.depth === 0) {
+      currentStart = index;
+      ignoreCurrent = false;
+    }
+    state = scanJsonChar(state, char);
+    if (currentStart !== null && !ignoreCurrent && index - currentStart + 1 > maxCandidateLength) {
+      ignoreCurrent = true;
+    }
+    if (!state.inString && char === "}" && state.depth === 0) {
+      if (currentStart !== null && !ignoreCurrent) {
+        const endIndex = index + 1;
+        const candidate = text.slice(currentStart, endIndex);
+        if (candidate.length > 1) {
+          candidates.push({
+            text: candidate,
+            startIndex: currentStart,
+            endIndex
+          });
+        }
+      }
+      currentStart = null;
+      ignoreCurrent = false;
+    }
+  }
+  return candidates;
+}
+function extractTaggedToolCallCandidates(rawText) {
+  var _a, _b;
+  const toolCallRegex = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  const candidates = [];
+  let match;
+  while (true) {
+    match = toolCallRegex.exec(rawText);
+    if (!match) {
+      break;
+    }
+    const body = (_a = match[1]) == null ? void 0 : _a.trim();
+    if (!body) {
+      continue;
+    }
+    const startIndex = (_b = match.index) != null ? _b : 0;
+    const endIndex = startIndex + match[0].length;
+    candidates.push({
+      text: body,
+      startIndex,
+      endIndex
+    });
+  }
+  return candidates;
+}
+function extractJsonLikeCandidates(rawText) {
+  return mergeJsonCandidatesByStart(
+    extractTaggedToolCallCandidates(rawText),
+    extractCodeBlockCandidates(rawText),
+    extractBalancedJsonObjects(rawText)
+  );
+}
+function mergeJsonCandidatesByStart(tagged, codeBlocks, balanced) {
+  return [...tagged, ...codeBlocks, ...balanced].sort(
+    (a, b) => a.startIndex !== b.startIndex ? a.startIndex - b.startIndex : b.endIndex - a.endIndex
+  );
+}
+function toToolCallPart(candidate) {
+  return {
+    type: "tool-call",
+    toolCallId: generateToolCallId(),
+    toolName: candidate.toolName,
+    input: candidate.input
+  };
+}
+function toRecoveredParts(text, candidate, toolCallPart) {
+  const out = [];
+  const prefix = text.slice(0, candidate.startIndex);
+  if (prefix.length > 0) {
+    out.push({ type: "text", text: prefix });
+  }
+  out.push(toolCallPart);
+  const suffix = text.slice(candidate.endIndex);
+  if (suffix.length > 0) {
+    out.push({ type: "text", text: suffix });
+  }
+  return out;
+}
+function parseAsToolPayload(payload, tools) {
+  if (!isRecord(payload)) {
+    return null;
+  }
+  const toolName = typeof payload.name === "string" && payload.name.trim().length > 0 ? payload.name.trim() : null;
+  if (!toolName) {
+    return null;
+  }
+  if (!tools.some((tool) => tool.name === toolName)) {
+    return null;
+  }
+  const rawArgs = Object.hasOwn(payload, "arguments") ? payload.arguments : {};
+  if (!isRecord(rawArgs)) {
+    return null;
+  }
+  return {
+    toolName,
+    input: safeStringify2(rawArgs)
+  };
+}
+function isLikelyArgumentsShapeForTool(args, tool) {
+  const unwrapped = unwrapJsonSchema(tool.inputSchema);
+  if (!isRecord(unwrapped)) {
+    return false;
+  }
+  if (getSchemaType(unwrapped) !== "object") {
+    return false;
+  }
+  const properties = unwrapped.properties;
+  if (!isRecord(properties)) {
+    return false;
+  }
+  const keys = Object.keys(args);
+  if (keys.length === 0) {
+    return false;
+  }
+  const knownKeys = keys.filter((key) => Object.hasOwn(properties, key));
+  if (knownKeys.length === 0) {
+    return false;
+  }
+  if (unwrapped.additionalProperties === false && knownKeys.length !== keys.length) {
+    return false;
+  }
+  return true;
+}
+function parseAsArgumentsOnly(payload, tools) {
+  if (tools.length !== 1) {
+    return null;
+  }
+  if (!isRecord(payload)) {
+    return null;
+  }
+  const hasNameEnvelope = Object.hasOwn(payload, "name") && typeof payload.name === "string" && payload.name.length > 0;
+  const hasArgumentsEnvelope = Object.hasOwn(payload, "arguments") && (typeof payload.arguments === "string" || isRecord(payload.arguments));
+  if (hasNameEnvelope || hasArgumentsEnvelope) {
+    return null;
+  }
+  const tool = tools[0];
+  if (!isLikelyArgumentsShapeForTool(payload, tool)) {
+    return null;
+  }
+  return {
+    toolName: tool.name,
+    input: safeStringify2(payload)
+  };
+}
+function recoverToolCallFromJsonCandidates(text, tools) {
+  if (tools.length === 0) {
+    return null;
+  }
+  const jsonCandidates = extractJsonLikeCandidates(text);
+  for (const jsonCandidate of jsonCandidates) {
+    const parsed = parseJsonCandidate(jsonCandidate.text);
+    if (parsed === void 0) {
+      continue;
+    }
+    const toolPayload = parseAsToolPayload(parsed, tools);
+    if (toolPayload) {
+      return toRecoveredParts(text, jsonCandidate, toToolCallPart(toolPayload));
+    }
+    const argsPayload = parseAsArgumentsOnly(parsed, tools);
+    if (argsPayload) {
+      return toRecoveredParts(text, jsonCandidate, toToolCallPart(argsPayload));
+    }
+  }
+  return null;
+}
+
+// src/core/utils/tool-call-coercion.ts
+function coerceToolCallInput(toolName, input, tools) {
   var _a;
+  let args = {};
+  if (typeof input === "string") {
+    try {
+      args = JSON.parse(input);
+    } catch (e) {
+      return;
+    }
+  } else if (input && typeof input === "object") {
+    args = input;
+  } else {
+    return;
+  }
+  const schema = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return JSON.stringify(coerced != null ? coerced : {});
+}
+function coerceToolCallPart(part, tools) {
+  const coercedInput = coerceToolCallInput(part.toolName, part.input, tools);
+  if (coercedInput === void 0) {
+    return part;
+  }
+  return {
+    ...part,
+    input: coercedInput
+  };
+}
+
+// src/core/utils/tool-choice.ts
+function ensureNonEmptyToolName(name) {
+  if (typeof name !== "string") {
+    return "unknown";
+  }
+  const trimmed = name.trim();
+  return trimmed.length > 0 ? trimmed : "unknown";
+}
+function safeStringify3(value) {
+  try {
+    return JSON.stringify(value != null ? value : {});
+  } catch (e) {
+    return "{}";
+  }
+}
+function parseToolChoicePayload({
+  text,
+  tools,
+  onError,
+  errorMessage
+}) {
+  let parsed;
   try {
-    return JSON.parse(text);
+    parsed = JSON.parse(text);
   } catch (error) {
-    const options = extractOnErrorOption(providerOptions);
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-      options,
-      "Failed to parse toolChoice JSON from generated model output",
-      {
-        text,
-        error: error instanceof Error ? error.message : String(error)
-      }
-    );
-    return {};
+    onError == null ? void 0 : onError(errorMessage, {
+      text,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { toolName: "unknown", input: "{}" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    onError == null ? void 0 : onError("toolChoice JSON payload must be an object", {
+      parsedType: typeof parsed,
+      parsed
+    });
+    return { toolName: "unknown", input: "{}" };
+  }
+  const payload = parsed;
+  const toolName = ensureNonEmptyToolName(payload.name);
+  const rawArgs = Object.hasOwn(payload, "arguments") ? payload.arguments : {};
+  if (rawArgs == null || typeof rawArgs !== "object" || Array.isArray(rawArgs)) {
+    onError == null ? void 0 : onError("toolChoice arguments must be a JSON object", {
+      toolName,
+      arguments: rawArgs
+    });
+    return { toolName, input: "{}" };
   }
+  const coercedInput = coerceToolCallInput(toolName, rawArgs, tools);
+  return {
+    toolName,
+    input: coercedInput != null ? coercedInput : safeStringify3(rawArgs)
+  };
 }
+
+// src/generate-handler.ts
 function logDebugSummary(debugSummary, toolCall, originText) {
   if (debugSummary) {
     debugSummary.originalText = originText;
@@ -5036,25 +7096,34 @@ function logDebugSummary(debugSummary, toolCall, originText) {
     logParsedSummary({ toolCalls: [toolCall], originalText: originText });
   }
 }
-async function handleToolChoice(doGenerate, params) {
-  var _a, _b, _c;
+async function handleToolChoice(doGenerate, params, tools) {
+  var _a, _b, _c, _d;
   const result = await doGenerate();
   const first = (_a = result.content) == null ? void 0 : _a[0];
-  let parsed = {};
+  const onError = (_b = extractOnErrorOption(params.providerOptions)) == null ? void 0 : _b.onError;
+  let toolName = "unknown";
+  let input = "{}";
   if (first && first.type === "text") {
     if (getDebugLevel() === "parse") {
       logRawChunk(first.text);
     }
-    parsed = parseToolChoiceJson(first.text, params.providerOptions);
+    const parsed = parseToolChoicePayload({
+      text: first.text,
+      tools,
+      onError,
+      errorMessage: "Failed to parse toolChoice JSON from generated model output"
+    });
+    toolName = parsed.toolName;
+    input = parsed.input;
   }
   const toolCall = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils.generateId)(),
-    toolName: parsed.name || "unknown",
-    input: JSON.stringify(parsed.arguments || {})
+    toolCallId: generateToolCallId(),
+    toolName,
+    input
   };
   const originText = first && first.type === "text" ? first.text : "";
-  const debugSummary = (_c = (_b = params.providerOptions) == null ? void 0 : _b.toolCallMiddleware) == null ? void 0 : _c.debugSummary;
+  const debugSummary = (_d = (_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) == null ? void 0 : _d.debugSummary;
   logDebugSummary(debugSummary, toolCall, originText);
   return {
     ...result,
@@ -5069,7 +7138,7 @@ function parseContent(content, protocol, tools, providerOptions) {
     if (getDebugLevel() === "stream") {
       logRawChunk(contentItem.text);
     }
-    return protocol.parseGeneratedText({
+    const parsedByProtocol = protocol.parseGeneratedText({
       text: contentItem.text,
       tools,
       options: {
@@ -5077,9 +7146,20 @@ function parseContent(content, protocol, tools, providerOptions) {
         ...providerOptions == null ? void 0 : providerOptions.toolCallMiddleware
       }
     });
+    const hasToolCall = parsedByProtocol.some(
+      (part) => part.type === "tool-call"
+    );
+    if (hasToolCall) {
+      return parsedByProtocol;
+    }
+    const recoveredFromJson = recoverToolCallFromJsonCandidates(
+      contentItem.text,
+      tools
+    );
+    return recoveredFromJson != null ? recoveredFromJson : parsedByProtocol;
   });
   return parsed.map(
-    (part) => fixToolCallWithSchema(part, tools)
+    (part) => part.type === "tool-call" ? coerceToolCallPart(part, tools) : part
   );
 }
 function logParsedContent(content) {
@@ -5122,12 +7202,14 @@ async function wrapGenerate({
   params
 }) {
   var _a, _b;
-  if (isToolChoiceActive(params)) {
-    return handleToolChoice(doGenerate, params);
-  }
+  const onError = extractOnErrorOption(params.providerOptions);
   const tools = originalToolsSchema.decode(
-    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools,
+    onError
   );
+  if (isToolChoiceActive(params)) {
+    return handleToolChoice(doGenerate, params, tools);
+  }
   const result = await doGenerate();
   if (result.content.length === 0) {
     return result;
@@ -5151,28 +7233,6 @@ async function wrapGenerate({
     content: newContent
   };
 }
-function fixToolCallWithSchema(part, tools) {
-  var _a;
-  if (part.type !== "tool-call") {
-    return part;
-  }
-  let args = {};
-  if (typeof part.input === "string") {
-    try {
-      args = JSON.parse(part.input);
-    } catch (e) {
-      return part;
-    }
-  } else if (part.input && typeof part.input === "object") {
-    args = part.input;
-  }
-  const schema = (_a = tools.find((t) => t.name === part.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
-  return {
-    ...part,
-    input: JSON.stringify(coerced != null ? coerced : {})
-  };
-}
 
 // src/core/prompts/hermes-system-prompt.ts
 function hermesSystemPromptTemplate(tools) {
@@ -5568,7 +7628,6 @@ unit: celsius
 }
 
 // src/stream-handler.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
 async function wrapStream({
   protocol,
   doStream,
@@ -5576,19 +7635,22 @@ async function wrapStream({
   params
 }) {
   var _a, _b, _c;
+  const onErrorOptions = extractOnErrorOption(params.providerOptions);
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools,
+    onErrorOptions
+  );
   if (isToolChoiceActive(params)) {
     return toolChoiceStream({
       doGenerate,
-      options: extractOnErrorOption(params.providerOptions)
+      tools,
+      options: onErrorOptions
     });
   }
   const { stream, ...rest } = await doStream();
   const debugLevel = getDebugLevel();
-  const tools = originalToolsSchema.decode(
-    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
-  );
   const options = {
-    ...extractOnErrorOption(params.providerOptions),
+    ...onErrorOptions,
     ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
   };
   const coreStream = stream.pipeThrough(
@@ -5603,13 +7665,26 @@ async function wrapStream({
       }
     )
   ).pipeThrough(protocol.createStreamParser({ tools, options }));
+  let seenToolCall = false;
   const v3Stream = coreStream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
+        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(part);
+          logParsedChunk(normalizedPart);
         }
-        controller.enqueue(part);
+        controller.enqueue(normalizedPart);
       }
     })
   );
@@ -5620,41 +7695,36 @@ async function wrapStream({
 }
 async function toolChoiceStream({
   doGenerate,
+  tools,
   options
 }) {
-  var _a, _b;
+  var _a;
+  const normalizedTools = Array.isArray(tools) ? tools : [];
   const result = await doGenerate();
-  let toolJson = {};
+  let toolName = "unknown";
+  let input = "{}";
   if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
-    try {
-      toolJson = JSON.parse(result.content[0].text);
-    } catch (error) {
-      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-        options,
-        "Failed to parse toolChoice JSON from streamed model output",
-        {
-          text: result.content[0].text,
-          error: error instanceof Error ? error.message : String(error)
-        }
-      );
-      toolJson = {};
-    }
+    const parsed = parseToolChoicePayload({
+      text: result.content[0].text,
+      tools: normalizedTools,
+      onError: options == null ? void 0 : options.onError,
+      errorMessage: "Failed to parse toolChoice JSON from streamed model output"
+    });
+    toolName = parsed.toolName;
+    input = parsed.input;
   }
   const stream = new ReadableStream({
     start(controller) {
       controller.enqueue({
         type: "tool-call",
-        toolCallId: (0, import_provider_utils2.generateId)(),
-        toolName: toolJson.name || "unknown",
-        input: JSON.stringify(toolJson.arguments || {})
+        toolCallId: generateToolCallId(),
+        toolName,
+        input
       });
       controller.enqueue({
         type: "finish",
-        usage: (result == null ? void 0 : result.usage) || {
-          inputTokens: 0,
-          outputTokens: 0
-        },
-        finishReason: "tool-calls"
+        usage: normalizeUsage(result == null ? void 0 : result.usage),
+        finishReason: normalizeToolCallsFinishReason(result == null ? void 0 : result.finishReason)
       });
       controller.close();
     }
@@ -5665,6 +7735,60 @@ async function toolChoiceStream({
     stream
   };
 }
+var ZERO_USAGE = {
+  inputTokens: {
+    total: 0,
+    noCache: void 0,
+    cacheRead: void 0,
+    cacheWrite: void 0
+  },
+  outputTokens: {
+    total: 0,
+    text: void 0,
+    reasoning: void 0
+  }
+};
+function normalizeToolCallsFinishReason(finishReason) {
+  let raw = "tool-calls";
+  if (typeof finishReason === "string") {
+    raw = finishReason;
+  } else if (finishReason && typeof finishReason === "object" && "raw" in finishReason && typeof finishReason.raw === "string") {
+    raw = finishReason.raw;
+  } else if (finishReason && typeof finishReason === "object" && "unified" in finishReason && typeof finishReason.unified === "string") {
+    raw = finishReason.unified;
+  }
+  return {
+    unified: "tool-calls",
+    raw
+  };
+}
+function normalizeUsage(usage) {
+  if (!usage || typeof usage !== "object") {
+    return ZERO_USAGE;
+  }
+  const usageRecord = usage;
+  const input = usageRecord.inputTokens;
+  const output = usageRecord.outputTokens;
+  if (input && typeof input === "object" && output && typeof output === "object") {
+    return usage;
+  }
+  if (typeof input === "number" && typeof output === "number") {
+    return {
+      inputTokens: {
+        total: input,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: output,
+        text: void 0,
+        reasoning: void 0
+      }
+    };
+  }
+  return ZERO_USAGE;
+}
 
 // src/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
@@ -5790,6 +7914,11 @@ function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
       "Tool choice type 'required' is set, but no tools are provided in params.tools."
     );
   }
+  if (functionTools.length === 0) {
+    throw new Error(
+      "Tool choice type 'required' is set, but no function tools are provided. Provider-defined tools are not supported by this middleware."
+    );
+  }
   return {
     ...baseReturnParams,
     responseFormat: {