@ai-sdk-tool/parser 2.1.4 → 2.1.6

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,24 +17,30 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   RJSON: () => robust_json_exports,
-  coerceBySchema: () => coerceBySchema,
-  coerceToolCallInput: () => coerceToolCallInput,
   createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
   createToolMiddleware: () => createToolMiddleware,
+  decodeOriginalTools: () => decodeOriginalTools,
+  encodeOriginalTools: () => encodeOriginalTools,
   escapeRegExp: () => escapeRegExp,
   extractOnErrorOption: () => extractOnErrorOption,
-  fixToolCallWithSchema: () => fixToolCallWithSchema,
+  extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
   gemmaToolMiddleware: () => gemmaToolMiddleware,
   getDebugLevel: () => getDebugLevel,
-  getFunctionTools: () => getFunctionTools,
   getPotentialStartIndex: () => getPotentialStartIndex,
-  getSchemaType: () => getSchemaType,
   hasInputProperty: () => hasInputProperty,
   hermesToolMiddleware: () => hermesToolMiddleware,
   isToolCallContent: () => isToolCallContent,
@@ -43,7 +51,7 @@ __export(index_exports, {
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
   morphXmlProtocol: () => morphXmlProtocol,
-  unwrapJsonSchema: () => unwrapJsonSchema,
+  originalToolsSchema: () => originalToolsSchema,
   xmlToolMiddleware: () => xmlToolMiddleware
 });
 module.exports = __toCommonJS(index_exports);
@@ -766,210 +774,6 @@ function stringify(obj) {
   return "null";
 }
 
-// src/utils/coercion.ts
-function unwrapJsonSchema(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-  const s = schema;
-  if (s.jsonSchema && typeof s.jsonSchema === "object") {
-    return unwrapJsonSchema(s.jsonSchema);
-  }
-  return schema;
-}
-function getSchemaType(schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") return void 0;
-  const t = unwrapped.type;
-  if (typeof t === "string") return t;
-  if (Array.isArray(t)) {
-    const preferred = [
-      "object",
-      "array",
-      "boolean",
-      "number",
-      "integer",
-      "string"
-    ];
-    for (const p of preferred) if (t.includes(p)) return p;
-  }
-  const s = unwrapped;
-  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
-    return "object";
-  }
-  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
-    return "array";
-  }
-  return void 0;
-}
-function coerceBySchema(value, schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    if (typeof value === "string") {
-      const s = value.trim();
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-        const num = Number(s);
-        if (Number.isFinite(num)) return num;
-      }
-      if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
-        try {
-          const parsed = JSON.parse(s);
-          return coerceBySchema(parsed, void 0);
-        } catch (e) {
-        }
-      }
-    }
-    return value;
-  }
-  const schemaType = getSchemaType(unwrapped);
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "object") {
-      try {
-        let normalized = s.replace(/'/g, '"');
-        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
-        const obj = JSON.parse(normalized);
-        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-          const props = unwrapped.properties;
-          const out = {};
-          for (const [k, v] of Object.entries(obj)) {
-            const propSchema = props ? props[k] : void 0;
-            out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-          }
-          return out;
-        }
-      } catch (e) {
-      }
-    }
-    if (schemaType === "array") {
-      try {
-        const normalized = s.replace(/'/g, '"');
-        const arr = JSON.parse(normalized);
-        if (Array.isArray(arr)) {
-          const u = unwrapped;
-          const prefixItems = Array.isArray(
-            u.prefixItems
-          ) ? u.prefixItems : void 0;
-          const itemsSchema = u.items;
-          if (prefixItems && arr.length === prefixItems.length) {
-            return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-          }
-          return arr.map((v) => coerceBySchema(v, itemsSchema));
-        }
-      } catch (e) {
-        const csv = s.includes("\n") ? s.split(/\n+/) : s.split(/,\s*/);
-        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
-        const u = unwrapped;
-        const prefixItems = Array.isArray(
-          u.prefixItems
-        ) ? u.prefixItems : void 0;
-        const itemsSchema = u.items;
-        if (prefixItems && trimmed.length === prefixItems.length) {
-          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
-        }
-        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
-      }
-    }
-  }
-  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
-    const out = {};
-    const props = unwrapped.properties;
-    for (const [k, v] of Object.entries(value)) {
-      const propSchema = props ? props[k] : void 0;
-      out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-    }
-    return out;
-  }
-  if (schemaType === "array") {
-    const u = unwrapped;
-    const itemsSchema = u.items;
-    const prefixItems = Array.isArray(
-      u.prefixItems
-    ) ? u.prefixItems : void 0;
-    if (Array.isArray(value)) {
-      if (prefixItems && value.length === prefixItems.length) {
-        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
-      }
-      return value.map((v) => coerceBySchema(v, itemsSchema));
-    }
-    if (value && typeof value === "object") {
-      const maybe = value;
-      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
-        const items = maybe.item;
-        const arr = Array.isArray(items) ? items : [items];
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      const keys = Object.keys(maybe);
-      if (keys.length === 1) {
-        const singleKey = keys[0];
-        const singleValue = maybe[singleKey];
-        if (Array.isArray(singleValue)) {
-          const coercedArray = singleValue.map(
-            (v) => coerceBySchema(v, itemsSchema)
-          );
-          return coercedArray;
-        }
-      }
-      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
-        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-    }
-    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      if (prefixItems && prefixItems.length > 0) {
-        return [coerceBySchema(value, prefixItems[0])];
-      }
-      return [coerceBySchema(value, itemsSchema)];
-    }
-  }
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "boolean") {
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-    }
-    if (schemaType === "number" || schemaType === "integer") {
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-        const num = Number(s);
-        if (Number.isFinite(num)) return num;
-      }
-    }
-  }
-  return value;
-}
-function fixToolCallWithSchema(part, tools) {
-  var _a;
-  if (part.type !== "tool-call") return part;
-  const tc = part;
-  let args = {};
-  if (typeof tc.input === "string") {
-    try {
-      args = JSON.parse(tc.input);
-    } catch (e) {
-      return part;
-    }
-  } else if (tc.input && typeof tc.input === "object") {
-    args = tc.input;
-  }
-  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
-  return {
-    ...part,
-    input: JSON.stringify(coerced != null ? coerced : {})
-  };
-}
-function coerceToolCallInput(part, tools) {
-  return fixToolCallWithSchema(part, tools);
-}
-
 // src/utils/debug.ts
 function normalizeBooleanString(value) {
   const normalized = value.trim().toLowerCase();
@@ -1057,33 +861,34 @@ function extractOnErrorOption(providerOptions) {
   return void 0;
 }
 
-// src/utils/tools.ts
+// src/utils/provider-options.ts
+var originalToolsSchema = {
+  encode: encodeOriginalTools,
+  decode: decodeOriginalTools
+};
+function encodeOriginalTools(tools) {
+  return (tools == null ? void 0 : tools.map((t) => ({
+    name: t.name,
+    inputSchema: JSON.stringify(t.inputSchema)
+  }))) || [];
+}
+function decodeOriginalTools(originalTools) {
+  const tools = (originalTools == null ? void 0 : originalTools.map(
+    (t) => ({
+      name: t.name,
+      inputSchema: JSON.parse(t.inputSchema)
+    })
+  )) || [];
+  return tools;
+}
+function extractToolNamesFromOriginalTools(originalTools) {
+  return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
+}
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
   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"));
 }
-function getFunctionTools(params) {
-  var _a, _b;
-  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
-    (t) => t.type === "function"
-  );
-  if (functionTools.length > 0) return functionTools;
-  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_b = params.providerOptions.toolCallMiddleware) == null ? void 0 : _b.toolNames) || [];
-  const toStringArray = (val) => Array.isArray(val) ? val.filter(
-    (item) => typeof item === "string"
-  ) : [];
-  const toolNames = toStringArray(rawToolNames);
-  if (toolNames.length > 0) {
-    return toolNames.map((name) => ({
-      type: "function",
-      name,
-      description: "",
-      inputSchema: { type: "object" }
-    }));
-  }
-  return [];
-}
 
 // src/utils/type-guards.ts
 function isToolCallContent(content) {
@@ -1338,57 +1143,13 @@ var jsonMixProtocol = ({
 
 // src/protocols/morph-xml-protocol.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_rxml = require("@ai-sdk-tool/rxml");
-function getToolSchema(tools, originalSchemas, toolName) {
-  var _a;
-  const original = originalSchemas[toolName];
-  if (original) return original;
-  const fallback = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-  return fallback;
-}
-function findToolCalls(text, toolNames) {
-  const toolCalls = [];
-  for (const toolName of toolNames) {
-    let searchIndex = 0;
-    while (searchIndex < text.length) {
-      const startTag = `<${toolName}>`;
-      const tagStart = text.indexOf(startTag, searchIndex);
-      if (tagStart === -1) break;
-      const remainingText = text.substring(tagStart);
-      const range = (0, import_rxml.findFirstTopLevelRange)(remainingText, toolName);
-      if (range) {
-        const contentStart = tagStart + startTag.length;
-        const contentEnd = contentStart + (range.end - range.start);
-        let fullTagEnd = contentEnd + `</${toolName}>`.length;
-        const closeHead = text.indexOf(`</${toolName}`, contentEnd);
-        if (closeHead === contentEnd) {
-          let p = closeHead + 2 + toolName.length;
-          while (p < text.length && /\s/.test(text[p])) p++;
-          if (text[p] === ">") fullTagEnd = p + 1;
-        }
-        const toolContent = text.substring(contentStart, contentEnd);
-        const fullSegment = text.substring(tagStart, fullTagEnd);
-        toolCalls.push({
-          toolName,
-          startIndex: tagStart,
-          endIndex: fullTagEnd,
-          content: toolContent,
-          segment: fullSegment
-        });
-        searchIndex = fullTagEnd;
-      } else {
-        searchIndex = tagStart + startTag.length;
-      }
-    }
-  }
-  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
-}
+var RXML = __toESM(require("@ai-sdk-tool/rxml"), 1);
 var morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: unwrapJsonSchema(tool.inputSchema)
+      parameters: RXML.unwrapJsonSchema(tool.inputSchema)
     }));
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
@@ -1404,20 +1165,19 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    return (0, import_rxml.stringify)(toolCall.toolName, args, {
+    return RXML.stringify(toolCall.toolName, args, {
       suppressEmptyNode: false,
       format: false
     });
   },
   formatToolResponse(toolResult) {
-    return (0, import_rxml.stringify)("tool_response", {
+    return RXML.stringify("tool_response", {
       tool_name: toolResult.toolName,
       result: toolResult.output
     });
   },
   parseGeneratedText({ text, tools, options }) {
     var _a;
-    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
     if (toolNames.length === 0) {
       return [{ type: "text", text }];
@@ -1433,13 +1193,11 @@ var morphXmlProtocol = () => ({
         }
       }
       try {
-        const toolSchema = getToolSchema(
-          tools,
-          originalSchemas,
-          toolCall.toolName
-        );
-        const parsed = (0, import_rxml.parse)(toolCall.content, toolSchema, {
-          onError: options == null ? void 0 : options.onError
+        const toolSchema = getToolSchema(tools, toolCall.toolName);
+        const parsed = RXML.parse(toolCall.content, toolSchema, {
+          onError: options == null ? void 0 : options.onError,
+          // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
+          noChildNodes: []
         });
         processedElements.push({
           type: "tool-call",
@@ -1471,8 +1229,8 @@ var morphXmlProtocol = () => ({
     return processedElements;
   },
   createStreamParser({ tools, options }) {
-    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+    const maxStartTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
     let buffer = "";
     let currentToolCall = null;
     let currentTextId = null;
@@ -1514,13 +1272,11 @@ var morphXmlProtocol = () => ({
               const toolContent = buffer.substring(0, endTagIndex);
               buffer = buffer.substring(endTagIndex + endTag.length);
               try {
-                const toolSchema = getToolSchema(
-                  tools,
-                  originalSchemas,
-                  currentToolCall.name
-                );
-                const parsed = (0, import_rxml.parse)(toolContent, toolSchema, {
-                  onError: options == null ? void 0 : options.onError
+                const toolSchema = getToolSchema(tools, currentToolCall.name);
+                const parsed = RXML.parse(toolContent, toolSchema, {
+                  onError: options == null ? void 0 : options.onError,
+                  // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
+                  noChildNodes: []
                 });
                 flushText(controller);
                 controller.enqueue({
@@ -1532,11 +1288,11 @@ var morphXmlProtocol = () => ({
               } catch (error) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
                 let message = "Could not process streaming XML tool call; emitting original text.";
-                if (error instanceof import_rxml.RXMLDuplicateStringTagError) {
+                if (error instanceof RXML.RXMLDuplicateStringTagError) {
                   message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-                } else if (error instanceof import_rxml.RXMLCoercionError) {
+                } else if (error instanceof RXML.RXMLCoercionError) {
                   message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-                } else if (error instanceof import_rxml.RXMLParseError) {
+                } else if (error instanceof RXML.RXMLParseError) {
                   message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
                 }
                 (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
@@ -1572,6 +1328,14 @@ var morphXmlProtocol = () => ({
               );
               currentToolCall = { name: earliestToolName, content: "" };
             } else {
+              const tail = Math.max(0, maxStartTagLen - 1);
+              const safeLen = Math.max(0, buffer.length - tail);
+              if (safeLen > 0) {
+                const textToFlush = buffer.slice(0, safeLen);
+                flushText(controller, textToFlush);
+                buffer = buffer.slice(safeLen);
+                continue;
+              }
               break;
             }
           }
@@ -1596,6 +1360,48 @@ var morphXmlProtocol = () => ({
     return findToolCalls(text, toolNames).map((tc) => tc.segment);
   }
 });
+function getToolSchema(tools, toolName) {
+  var _a;
+  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+}
+function findToolCalls(text, toolNames) {
+  var _a;
+  const toolCalls = [];
+  for (const toolName of toolNames) {
+    let searchIndex = 0;
+    while (searchIndex < text.length) {
+      const startTag = `<${toolName}>`;
+      const tagStart = text.indexOf(startTag, searchIndex);
+      if (tagStart === -1) break;
+      const remainingText = text.substring(tagStart);
+      const range = RXML.findFirstTopLevelRange(remainingText, toolName);
+      if (range) {
+        const contentStart = tagStart + startTag.length;
+        const contentEnd = contentStart + (range.end - range.start);
+        let fullTagEnd = contentEnd + `</${toolName}>`.length;
+        const closeHead = text.indexOf(`</${toolName}`, contentEnd);
+        if (closeHead === contentEnd) {
+          let p = closeHead + 2 + toolName.length;
+          while (p < text.length && /\s/.test(text[p])) p++;
+          if (text[p] === ">") fullTagEnd = p + 1;
+        }
+        const segment = text.substring(tagStart, fullTagEnd);
+        const content = (_a = RXML.extractRawInner(segment, toolName)) != null ? _a : text.substring(contentStart, contentEnd);
+        toolCalls.push({
+          toolName,
+          startIndex: tagStart,
+          endIndex: fullTagEnd,
+          content,
+          segment
+        });
+        searchIndex = fullTagEnd;
+      } else {
+        searchIndex = tagStart + startTag.length;
+      }
+    }
+  }
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+}
 
 // src/protocols/tool-call-protocol.ts
 function isProtocolFactory(protocol) {
@@ -1604,12 +1410,13 @@ function isProtocolFactory(protocol) {
 
 // src/generate-handler.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var RXML2 = __toESM(require("@ai-sdk-tool/rxml"), 1);
 async function wrapGenerate({
   protocol,
   doGenerate,
   params
 }) {
-  var _a, _b;
+  var _a, _b, _c, _d, _e, _f, _g, _h;
   if (isToolChoiceActive(params)) {
     const result2 = await doGenerate();
     let parsed2 = {};
@@ -1642,7 +1449,16 @@ async function wrapGenerate({
     };
     const debugLevelToolChoice = getDebugLevel();
     const originText = first && first.type === "text" ? first.text : "";
-    if (debugLevelToolChoice === "parse") {
+    const dbg2 = (_d = (_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) == null ? void 0 : _d.debugSummary;
+    if (dbg2) {
+      dbg2.originalText = originText;
+      try {
+        dbg2.toolCalls = JSON.stringify([
+          { toolName: toolCall.toolName, input: toolCall.input }
+        ]);
+      } catch (e) {
+      }
+    } else if (debugLevelToolChoice === "parse") {
       logParsedSummary({ toolCalls: [toolCall], originalText: originText });
     }
     return {
@@ -1650,6 +1466,9 @@ async function wrapGenerate({
       content: [toolCall]
     };
   }
+  const tools = originalToolsSchema.decode(
+    (_f = (_e = params.providerOptions) == null ? void 0 : _e.toolCallMiddleware) == null ? void 0 : _f.originalTools
+  );
   const result = await doGenerate();
   if (result.content.length === 0) {
     return result;
@@ -1665,30 +1484,41 @@ async function wrapGenerate({
     }
     return protocol.parseGeneratedText({
       text: contentItem.text,
-      tools: getFunctionTools(params),
+      tools,
       options: {
         ...extractOnErrorOption(params.providerOptions),
         ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
       }
     });
   });
-  const tools = getFunctionTools(params);
   const newContent = parsed.map(
-    (part) => coerceToolCallInput(part, tools)
+    (part) => fixToolCallWithSchema(part, tools)
   );
   const debugLevel = getDebugLevel();
   if (debugLevel === "stream") {
     newContent.forEach((part) => logParsedChunk(part));
   }
-  if (debugLevel === "parse") {
-    const allText = result.content.filter(
-      (c) => c.type === "text"
-    ).map((c) => c.text).join("\n\n");
-    const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
-    const originalText = segments.join("\n\n");
-    const toolCalls = newContent.filter(
-      (p) => p.type === "tool-call"
-    );
+  const allText = result.content.filter(
+    (c) => c.type === "text"
+  ).map((c) => c.text).join("\n\n");
+  const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
+  const originalText = segments.join("\n\n");
+  const toolCalls = newContent.filter(
+    (p) => p.type === "tool-call"
+  );
+  const dbg = (_h = (_g = params.providerOptions) == null ? void 0 : _g.toolCallMiddleware) == null ? void 0 : _h.debugSummary;
+  if (dbg) {
+    dbg.originalText = originalText;
+    try {
+      dbg.toolCalls = JSON.stringify(
+        toolCalls.map((tc) => ({
+          toolName: tc.toolName,
+          input: tc.input
+        }))
+      );
+    } catch (e) {
+    }
+  } else if (debugLevel === "parse") {
     logParsedSummary({ toolCalls, originalText });
   }
   return {
@@ -1696,6 +1526,27 @@ async function wrapGenerate({
     content: newContent
   };
 }
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") return part;
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = RXML2.coerceBySchema(args, schema);
+  return {
+    ...part,
+    input: JSON.stringify(coerced != null ? coerced : {})
+  };
+}
 
 // src/stream-handler.ts
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
@@ -1705,7 +1556,7 @@ async function wrapStream({
   doGenerate,
   params
 }) {
-  var _a;
+  var _a, _b, _c;
   if (isToolChoiceActive(params)) {
     return toolChoiceStream({
       doGenerate,
@@ -1714,10 +1565,12 @@ async function wrapStream({
   }
   const { stream, ...rest } = await doStream();
   const debugLevel = getDebugLevel();
-  const tools = getFunctionTools(params);
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
   const options = {
     ...extractOnErrorOption(params.providerOptions),
-    ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+    ...(_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware
   };
   if (debugLevel === "off") {
     return {
@@ -1787,6 +1640,7 @@ async function wrapStream({
       transform: /* @__PURE__ */ (() => {
         const parsedToolCalls = [];
         return (part, controller) => {
+          var _a2, _b2;
           if (part.type === "tool-call") {
             parsedToolCalls.push(part);
           }
@@ -1797,10 +1651,27 @@ async function wrapStream({
                 tools
               }) : [];
               const origin = segments.join("\n\n");
-              logParsedSummary({
-                toolCalls: parsedToolCalls,
-                originalText: origin
-              });
+              const dbg = (_b2 = (_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware) == null ? void 0 : _b2.debugSummary;
+              if (dbg) {
+                dbg.originalText = origin;
+                try {
+                  const toolCallParts = parsedToolCalls.filter(
+                    (p) => p.type === "tool-call"
+                  );
+                  dbg.toolCalls = JSON.stringify(
+                    toolCallParts.map((tc) => ({
+                      toolName: tc.toolName,
+                      input: tc.input
+                    }))
+                  );
+                } catch (e) {
+                }
+              } else {
+                logParsedSummary({
+                  toolCalls: parsedToolCalls,
+                  originalText: origin
+                });
+              }
             } catch (e) {
             }
           }
@@ -1926,10 +1797,10 @@ async function transformParams({
       ...params.providerOptions || {},
       toolCallMiddleware: {
         ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
-        // INTERNAL: used by the middleware to propagate the names of custom
-        // function tools into downstream handlers (stream/generate) when
-        // providers strip or ignore `params.tools`. Not a stable public API.
-        toolNames: functionTools.map((t) => t.name)
+        // INTERNAL: used by the middleware so downstream parsers can access
+        // the original tool schemas even if providers strip `params.tools`.
+        // Not a stable public API.
+        originalTools: originalToolsSchema.encode(functionTools)
       }
     }
   };
@@ -2210,7 +2081,7 @@ When an argument is an array, write each item inside a single element on one lin
 Examples:
 <get_weather>
 <location>
-San Fransisco
+San Francisco
 </location>
 </get_weather>`;
   }
@@ -2218,18 +2089,16 @@ San Fransisco
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RJSON,
-  coerceBySchema,
-  coerceToolCallInput,
   createDynamicIfThenElseSchema,
   createToolMiddleware,
+  decodeOriginalTools,
+  encodeOriginalTools,
   escapeRegExp,
   extractOnErrorOption,
-  fixToolCallWithSchema,
+  extractToolNamesFromOriginalTools,
   gemmaToolMiddleware,
   getDebugLevel,
-  getFunctionTools,
   getPotentialStartIndex,
-  getSchemaType,
   hasInputProperty,
   hermesToolMiddleware,
   isToolCallContent,
@@ -2240,7 +2109,7 @@ San Fransisco
   logParsedSummary,
   logRawChunk,
   morphXmlProtocol,
-  unwrapJsonSchema,
+  originalToolsSchema,
   xmlToolMiddleware
 });
 //# sourceMappingURL=index.cjs.map