@ai-sdk-tool/parser 3.3.2 → 3.3.3

package/dist/community.cjs

@@ -1516,6 +1516,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,9 +1771,158 @@ function coerceStringToArray(s, unwrapped) {
   }
   return null;
 }
+function getStrictObjectSchemaInfo(unwrapped) {
+  if (getSchemaType(unwrapped) !== "object") {
+    return null;
+  }
+  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 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;
+  }
+  const camelized = trimmed.replace(
+    SNAKE_SEGMENT_REGEX,
+    (_, c) => c.toUpperCase()
+  );
+  return camelized.charAt(0).toLowerCase() + camelized.slice(1);
+}
+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(value)) {
+  for (const [k, v] of Object.entries(normalizedInput)) {
     out[k] = coerceValueForKey(v, k, unwrapped);
   }
   return out;
@@ -1777,6 +1933,109 @@ function coerceArrayToArray(value, prefixItems, itemsSchema) {
   }
   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;
@@ -1788,15 +2047,23 @@ function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
     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 +2093,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 +2191,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 +2233,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 +3264,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 +3434,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 +3772,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 +3913,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 +3966,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,7 +4130,31 @@ 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/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) {
@@ -3869,7 +4258,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 +4271,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 +4300,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 +4437,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 +4571,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;
@@ -4337,6 +4822,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 +4876,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;
@@ -4430,6 +4939,20 @@ var xmlProtocol = (protocolOptions) => {
       return new TransformStream({
         transform(chunk, controller) {
           var _a2;
+          if (chunk.type === "finish") {
+            if (currentToolCall) {
+              const unfinishedContent = `<${currentToolCall.name}>${currentToolCall.content}${buffer}`;
+              flushText(controller, unfinishedContent);
+              buffer = "";
+              currentToolCall = null;
+            } else if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            flushText(controller);
+            controller.enqueue(chunk);
+            return;
+          }
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -4491,7 +5014,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 +5034,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 +5047,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] === "/";
@@ -4756,18 +5279,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;
     },
@@ -4863,6 +5400,20 @@ ${yamlContent}</${toolCall.toolName}>`;
       return new TransformStream({
         transform(chunk, controller) {
           var _a;
+          if (chunk.type === "finish") {
+            if (currentToolCall) {
+              const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
+              flushText(controller, unfinishedContent);
+              buffer = "";
+              currentToolCall = null;
+            } else if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            flushText(controller);
+            controller.enqueue(chunk);
+            return;
+          }
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -4986,17 +5537,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;
@@ -5006,23 +5596,337 @@ function isToolChoiceActive(params) {
 
 // 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: generateId(),
+    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 +5940,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 || {})
+    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 +5982,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 +5990,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 +6046,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 +6077,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) {
@@ -5576,19 +6480,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(
@@ -5606,10 +6513,11 @@ async function wrapStream({
   const v3Stream = coreStream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
+        const normalizedPart = part.type === "tool-call" ? coerceToolCallPart(part, tools) : part;
         if (debugLevel === "stream") {
-          logParsedChunk(part);
+          logParsedChunk(normalizedPart);
         }
-        controller.enqueue(part);
+        controller.enqueue(normalizedPart);
       }
     })
   );
@@ -5620,41 +6528,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 || {})
+        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 +6568,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 +6747,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: {