@ai-sdk-tool/parser 3.3.1 → 3.3.3

package/dist/{chunk-7E6UFDFQ.js → chunk-NAQSTPDQ.js}

@@ -1,13 +1,16 @@
 import {
+  escapeRegExp,
   parse as parse2,
   stringify
-} from "./chunk-EW3A6Y7O.js";
+} from "./chunk-CXWS24JX.js";
 import {
   parse
 } from "./chunk-IX4FJELL.js";
 import {
-  coerceBySchema
-} from "./chunk-OUGMLYAW.js";
+  coerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+} from "./chunk-2KK5BDZF.js";
 
 // src/core/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -187,9 +190,11 @@ function generateId() {
   return Math.random().toString(36).substring(2, 15);
 }
 
-// src/core/utils/regex.ts
-function escapeRegExp(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// src/core/utils/protocol-utils.ts
+function addTextSegment(text, processedElements) {
+  if (text.trim()) {
+    processedElements.push({ type: "text", text });
+  }
 }
 
 // src/core/protocols/json-protocol.ts
@@ -218,11 +223,6 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
     processedElements.push({ type: "text", text: fullMatch });
   }
 }
-function addTextSegment(text, processedElements) {
-  if (text.trim()) {
-    processedElements.push({ type: "text", text });
-  }
-}
 function processMatchedToolCall(context) {
   const { match, text, currentIndex, processedElements, options } = context;
   const startIndex = match.index;
@@ -516,9 +516,35 @@ function isTCMProtocolFactory(protocol) {
   return typeof protocol === "function";
 }
 
-// src/core/protocols/xml-protocol.ts
+// src/core/utils/regex-constants.ts
 var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX = /\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) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -799,6 +825,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;
@@ -1088,6 +1210,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 = {
@@ -1121,28 +1264,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;
@@ -1181,6 +1327,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);
@@ -1226,8 +1386,6 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 import YAML from "yaml";
-var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX2 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -1244,11 +1402,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX2.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < gtIdx && NAME_CHAR_RE2.test(text.charAt(p))) {
+      while (p < gtIdx && NAME_CHAR_RE.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1264,11 +1422,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+      while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1277,7 +1435,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -1395,22 +1553,14 @@ function parseYamlContent(yamlContent, options) {
     return null;
   }
 }
-function appendTextPart(processedElements, textPart) {
-  if (textPart.trim()) {
-    processedElements.push({
-      type: "text",
-      text: textPart
-    });
-  }
-}
 function processToolCallMatch(text, tc, currentIndex, processedElements, options) {
   var _a;
   if (tc.startIndex < currentIndex) {
     return currentIndex;
   }
-  appendTextPart(
-    processedElements,
-    text.substring(currentIndex, tc.startIndex)
+  addTextSegment(
+    text.substring(currentIndex, tc.startIndex),
+    processedElements
   );
   const parsedArgs = parseYamlContent(tc.content, options);
   if (parsedArgs !== null) {
@@ -1517,18 +1667,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) {
-        appendTextPart(processedElements, text.substring(currentIndex));
+      if (currentIndex < parseText.length) {
+        addTextSegment(parseText.substring(currentIndex), processedElements);
       }
       return processedElements;
     },
@@ -1624,6 +1788,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);
@@ -1747,17 +1925,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 extractToolNamesFromOriginalTools(originalTools) {
   return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
@@ -1782,23 +1999,337 @@ function hasInputProperty(obj) {
 
 // src/generate-handler.ts
 import { generateId as generateId2 } from "@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.parse(text);
+    return JSON.stringify(value != null ? value : {});
+  } catch (e) {
+    return "{}";
+  }
+}
+function parseToolChoicePayload({
+  text,
+  tools,
+  onError,
+  errorMessage
+}) {
+  let parsed;
+  try {
+    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;
@@ -1812,25 +2343,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: generateId2(),
-    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,
@@ -1845,7 +2385,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: {
@@ -1853,9 +2393,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) {
@@ -1898,12 +2449,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;
@@ -1927,28 +2480,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) {
@@ -2352,19 +2883,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(
@@ -2382,10 +2916,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);
       }
     })
   );
@@ -2396,41 +2931,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: generateId3(),
-        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();
     }
@@ -2441,6 +2971,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) {
@@ -2566,6 +3150,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: {
@@ -2853,7 +3442,6 @@ export {
   logParsedChunk,
   logParsedSummary,
   getPotentialStartIndex,
-  escapeRegExp,
   jsonProtocol,
   isProtocolFactory,
   isTCMProtocolFactory,
@@ -2877,4 +3465,4 @@ export {
   xmlToolMiddleware,
   yamlToolMiddleware
 };
-//# sourceMappingURL=chunk-7E6UFDFQ.js.map
+//# sourceMappingURL=chunk-NAQSTPDQ.js.map