@ai-sdk-tool/parser 2.1.2 → 2.1.4

package/dist/index.js

@@ -89,9 +89,9 @@ function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/utils/relaxed-json.ts
-var relaxed_json_exports = {};
-__export(relaxed_json_exports, {
+// src/utils/robust-json.ts
+var robust_json_exports = {};
+__export(robust_json_exports, {
   parse: () => parse,
   stringify: () => stringify,
   transform: () => transform
@@ -1013,11 +1013,6 @@ function extractOnErrorOption(providerOptions) {
   return void 0;
 }
 
-// src/utils/protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
 // src/utils/tools.ts
 function isToolChoiceActive(params) {
   var _a, _b, _c;
@@ -1114,7 +1109,7 @@ var jsonMixProtocol = ({
       }
       if (toolCallJson) {
         try {
-          const parsedToolCall = relaxed_json_exports.parse(toolCallJson);
+          const parsedToolCall = robust_json_exports.parse(toolCallJson);
           processedElements.push({
             type: "tool-call",
             toolCallId: generateId2(),
@@ -1237,7 +1232,7 @@ var jsonMixProtocol = ({
             isInsideToolCall = true;
           } else {
             try {
-              const parsedToolCall = relaxed_json_exports.parse(currentToolCallJson);
+              const parsedToolCall = robust_json_exports.parse(currentToolCallJson);
               if (currentTextId && hasEmittedTextStart) {
                 controller.enqueue({ type: "text-end", id: currentTextId });
                 currentTextId = null;
@@ -1299,7 +1294,58 @@ var jsonMixProtocol = ({
 
 // src/protocols/morph-xml-protocol.ts
 import { generateId as generateId3 } from "@ai-sdk/provider-utils";
-import { XMLBuilder, XMLParser } from "fast-xml-parser";
+import {
+  findFirstTopLevelRange,
+  parse as parseXml,
+  RXMLCoercionError,
+  RXMLDuplicateStringTagError,
+  RXMLParseError,
+  stringify as stringify2
+} from "@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 = 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 morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
@@ -1310,7 +1356,6 @@ var morphXmlProtocol = () => ({
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
   formatToolCall(toolCall) {
-    const builder = new XMLBuilder({ format: true, suppressEmptyNode: true });
     let args = {};
     const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
     if (typeof inputValue === "string") {
@@ -1322,145 +1367,63 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    const xmlContent = builder.build({
-      [toolCall.toolName]: args
+    return stringify2(toolCall.toolName, args, {
+      suppressEmptyNode: false,
+      format: false
     });
-    return xmlContent;
   },
   formatToolResponse(toolResult) {
-    const builder = new XMLBuilder({ format: true });
-    const xmlContent = builder.build({
-      tool_response: {
-        tool_name: toolResult.toolName,
-        result: toolResult.output
-      }
+    return stringify2("tool_response", {
+      tool_name: toolResult.toolName,
+      result: toolResult.output
     });
-    return xmlContent;
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a, _b, _c;
+    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 }];
     }
-    const toolNamesPattern = toolNames.map((n) => escapeRegExp(n)).join("|");
-    const toolCallRegex = new RegExp(
-      String.raw`<(${toolNamesPattern})>([\s\S]*?)<\/\1>`,
-      "g"
-    );
     const processedElements = [];
     let currentIndex = 0;
-    let match;
-    while ((match = toolCallRegex.exec(text)) !== null) {
-      const startIndex = match.index;
-      const toolName = match[1];
-      const toolContent = match[2].trim();
-      if (startIndex > currentIndex) {
-        const textSegment = text.substring(currentIndex, startIndex);
+    const toolCalls = findToolCalls(text, toolNames);
+    for (const toolCall of toolCalls) {
+      if (toolCall.startIndex > currentIndex) {
+        const textSegment = text.substring(currentIndex, toolCall.startIndex);
         if (textSegment.trim()) {
           processedElements.push({ type: "text", text: textSegment });
         }
       }
       try {
-        const parser = new XMLParser({
-          ignoreAttributes: false,
-          parseTagValue: false,
-          ignoreDeclaration: true,
-          textNodeName: "#text"
+        const toolSchema = getToolSchema(
+          tools,
+          originalSchemas,
+          toolCall.toolName
+        );
+        const parsed = parseXml(toolCall.content, toolSchema, {
+          onError: options == null ? void 0 : options.onError
         });
-        const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-        const args = {};
-        for (const k of Object.keys(parsedArgs || {})) {
-          const v = parsedArgs[k];
-          let val = v;
-          if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
-            val = v == null ? void 0 : v["#text"];
-          }
-          if (Array.isArray(v)) {
-            val = v.map((item) => {
-              if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                const textVal = item == null ? void 0 : item["#text"];
-                return typeof textVal === "string" ? textVal.trim() : textVal;
-              }
-              return typeof item === "string" ? item.trim() : item;
-            });
-          } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
-            const obj = v;
-            const keys = Object.keys(obj);
-            if (keys.length === 1 && keys[0] === "item") {
-              const itemValue = obj.item;
-              if (Array.isArray(itemValue)) {
-                val = itemValue.map((item) => {
-                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                    const textVal = item == null ? void 0 : item["#text"];
-                    const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
-                    if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
-                      const num = Number(trimmed2);
-                      if (Number.isFinite(num)) return num;
-                    }
-                    return trimmed2;
-                  }
-                  const trimmed = typeof item === "string" ? item.trim() : item;
-                  if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-                    const num = Number(trimmed);
-                    if (Number.isFinite(num)) return num;
-                  }
-                  return trimmed;
-                });
-              } else {
-                const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
-                if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-                  const num = Number(trimmed);
-                  if (Number.isFinite(num)) {
-                    val = num;
-                  } else {
-                    val = trimmed;
-                  }
-                } else {
-                  val = trimmed;
-                }
-              }
-            } else {
-              const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
-                const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
-                return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
-              })();
-              if (isIndexedTuple) {
-                const sortedKeys = keys.sort(
-                  (a, b) => parseInt(a) - parseInt(b)
-                );
-                val = sortedKeys.map((key) => {
-                  const item = obj[key];
-                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                    const textVal = item == null ? void 0 : item["#text"];
-                    return typeof textVal === "string" ? textVal.trim() : textVal;
-                  }
-                  return typeof item === "string" ? item.trim() : item;
-                });
-              } else {
-                val = v;
-              }
-            }
-          }
-          args[k] = typeof val === "string" ? val.trim() : val;
-        }
-        const originalSchema = originalSchemas[toolName];
-        const fallbackSchema = (_b = tools.find((t) => t.name === toolName)) == null ? void 0 : _b.inputSchema;
-        const schema = originalSchema || fallbackSchema;
-        const coercedArgs = coerceBySchema(args, schema);
         processedElements.push({
           type: "tool-call",
           toolCallId: generateId3(),
-          toolName,
-          input: JSON.stringify(coercedArgs)
+          toolName: toolCall.toolName,
+          input: JSON.stringify(parsed)
         });
       } catch (error) {
-        const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
-        (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, message, { toolCall: match[0], toolName, error });
-        processedElements.push({ type: "text", text: match[0] });
+        const originalCallText = text.substring(
+          toolCall.startIndex,
+          toolCall.endIndex
+        );
+        const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
+          toolCall: originalCallText,
+          toolName: toolCall.toolName,
+          error
+        });
+        processedElements.push({ type: "text", text: originalCallText });
       }
-      currentIndex = startIndex + match[0].length;
+      currentIndex = toolCall.endIndex;
     }
     if (currentIndex < text.length) {
       const remainingText = text.substring(currentIndex);
@@ -1499,7 +1462,7 @@ var morphXmlProtocol = () => ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a, _b;
+        var _a;
         if (chunk.type !== "text-delta") {
           if (buffer) flushText(controller);
           controller.enqueue(chunk);
@@ -1514,112 +1477,36 @@ var morphXmlProtocol = () => ({
               const toolContent = buffer.substring(0, endTagIndex);
               buffer = buffer.substring(endTagIndex + endTag.length);
               try {
-                const parser = new XMLParser({
-                  ignoreAttributes: false,
-                  parseTagValue: false,
-                  ignoreDeclaration: true,
-                  textNodeName: "#text"
+                const toolSchema = getToolSchema(
+                  tools,
+                  originalSchemas,
+                  currentToolCall.name
+                );
+                const parsed = parseXml(toolContent, toolSchema, {
+                  onError: options == null ? void 0 : options.onError
                 });
-                const parsedArgs = ((_a = parser.parse(`<root>${toolContent}</root>`)) == null ? void 0 : _a.root) || {};
-                const args = {};
-                for (const k of Object.keys(parsedArgs || {})) {
-                  const v = parsedArgs[k];
-                  let val = v;
-                  if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
-                    val = v == null ? void 0 : v["#text"];
-                  }
-                  if (Array.isArray(v)) {
-                    val = v.map((item) => {
-                      if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                        const textVal = item == null ? void 0 : item["#text"];
-                        return typeof textVal === "string" ? textVal.trim() : textVal;
-                      }
-                      return typeof item === "string" ? item.trim() : item;
-                    });
-                  } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
-                    const obj = v;
-                    const keys = Object.keys(obj);
-                    if (keys.length === 1 && keys[0] === "item") {
-                      const itemValue = obj.item;
-                      if (Array.isArray(itemValue)) {
-                        val = itemValue.map((item) => {
-                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                            const textVal = item == null ? void 0 : item["#text"];
-                            const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
-                            if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
-                              const num = Number(trimmed2);
-                              if (Number.isFinite(num)) return num;
-                            }
-                            return trimmed2;
-                          }
-                          const trimmed = typeof item === "string" ? item.trim() : item;
-                          if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-                            const num = Number(trimmed);
-                            if (Number.isFinite(num)) return num;
-                          }
-                          return trimmed;
-                        });
-                      } else {
-                        const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
-                        if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-                          const num = Number(trimmed);
-                          if (Number.isFinite(num)) {
-                            val = num;
-                          } else {
-                            val = trimmed;
-                          }
-                        } else {
-                          val = trimmed;
-                        }
-                      }
-                    } else {
-                      const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
-                        const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
-                        return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
-                      })();
-                      if (isIndexedTuple) {
-                        const sortedKeys = keys.sort(
-                          (a, b) => parseInt(a) - parseInt(b)
-                        );
-                        val = sortedKeys.map((key) => {
-                          const item = obj[key];
-                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
-                            const textVal = item == null ? void 0 : item["#text"];
-                            return typeof textVal === "string" ? textVal.trim() : textVal;
-                          }
-                          return typeof item === "string" ? item.trim() : item;
-                        });
-                      } else {
-                        val = v;
-                      }
-                    }
-                  }
-                  args[k] = typeof val === "string" ? val.trim() : val;
-                }
-                const originalSchema = originalSchemas[currentToolCall.name];
-                const fallbackSchema = (_b = tools.find(
-                  (t) => t.name === currentToolCall.name
-                )) == null ? void 0 : _b.inputSchema;
-                const toolSchema = originalSchema || fallbackSchema;
-                const coercedArgs = coerceBySchema(args, toolSchema);
                 flushText(controller);
                 controller.enqueue({
                   type: "tool-call",
                   toolCallId: generateId3(),
                   toolName: currentToolCall.name,
-                  input: JSON.stringify(coercedArgs)
+                  input: JSON.stringify(parsed)
                 });
-              } catch (e) {
+              } catch (error) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
-                if (options == null ? void 0 : options.onError) {
-                  options.onError(
-                    "Could not process streaming XML tool call; emitting original text.",
-                    {
-                      toolCall: originalCallText,
-                      toolName: currentToolCall.name
-                    }
-                  );
+                let message = "Could not process streaming XML tool call; emitting original text.";
+                if (error instanceof RXMLDuplicateStringTagError) {
+                  message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof RXMLCoercionError) {
+                  message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof 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, {
+                  toolCall: originalCallText,
+                  toolName: currentToolCall.name,
+                  error
+                });
                 flushText(controller, originalCallText);
               }
               currentToolCall = null;
@@ -1669,18 +1556,15 @@ var morphXmlProtocol = () => ({
   extractToolCallSegments({ text, tools }) {
     const toolNames = tools.map((t) => t.name).filter(Boolean);
     if (toolNames.length === 0) return [];
-    const names = toolNames.map((n) => escapeRegExp(String(n))).join("|");
-    if (!names) return [];
-    const regex = new RegExp(`<(${names})>[\\s\\S]*?<\\/\\1>`, "g");
-    const segments = [];
-    let m;
-    while ((m = regex.exec(text)) != null) {
-      segments.push(m[0]);
-    }
-    return segments;
+    return findToolCalls(text, toolNames).map((tc) => tc.segment);
   }
 });
 
+// src/protocols/tool-call-protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
 // src/generate-handler.ts
 import { generateId as generateId4 } from "@ai-sdk/provider-utils";
 async function wrapGenerate({
@@ -2295,11 +2179,30 @@ San Fransisco
   }
 });
 export {
+  robust_json_exports as RJSON,
+  coerceBySchema,
+  coerceToolCallInput,
+  createDynamicIfThenElseSchema,
   createToolMiddleware,
+  escapeRegExp,
+  extractOnErrorOption,
+  fixToolCallWithSchema,
   gemmaToolMiddleware,
+  getDebugLevel,
+  getFunctionTools,
+  getPotentialStartIndex,
+  getSchemaType,
+  hasInputProperty,
   hermesToolMiddleware,
+  isToolCallContent,
+  isToolChoiceActive,
+  isToolResultPart,
   jsonMixProtocol,
+  logParsedChunk,
+  logParsedSummary,
+  logRawChunk,
   morphXmlProtocol,
+  unwrapJsonSchema,
   xmlToolMiddleware
 };
 //# sourceMappingURL=index.js.map