@ai-sdk-tool/parser 2.1.2 → 2.1.4

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 Woonggi Min (https://github.com/minpeter)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -127,3 +127,7 @@ See `examples/parser-core/src/*` for runnable demos (streaming/non‑streaming,
   - `toolNames`: internal propagation of custom tool names.
   - `toolChoice`: internal fast‑path activation for required/specific tool modes.
 - Transform details: `transformParams` injects a system message built from protocol `formatTools` and clears `tools` since many providers strip/ignore them.
+
+## License
+
+Licensed under Apache License 2.0. See the repository `LICENSE`. Include the `NOTICE` file in distributions.

package/dist/index.cjs

@@ -20,11 +20,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  RJSON: () => robust_json_exports,
+  coerceBySchema: () => coerceBySchema,
+  coerceToolCallInput: () => coerceToolCallInput,
+  createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
   createToolMiddleware: () => createToolMiddleware,
+  escapeRegExp: () => escapeRegExp,
+  extractOnErrorOption: () => extractOnErrorOption,
+  fixToolCallWithSchema: () => fixToolCallWithSchema,
   gemmaToolMiddleware: () => gemmaToolMiddleware,
+  getDebugLevel: () => getDebugLevel,
+  getFunctionTools: () => getFunctionTools,
+  getPotentialStartIndex: () => getPotentialStartIndex,
+  getSchemaType: () => getSchemaType,
+  hasInputProperty: () => hasInputProperty,
   hermesToolMiddleware: () => hermesToolMiddleware,
+  isToolCallContent: () => isToolCallContent,
+  isToolChoiceActive: () => isToolChoiceActive,
+  isToolResultPart: () => isToolResultPart,
   jsonMixProtocol: () => jsonMixProtocol,
+  logParsedChunk: () => logParsedChunk,
+  logParsedSummary: () => logParsedSummary,
+  logRawChunk: () => logRawChunk,
   morphXmlProtocol: () => morphXmlProtocol,
+  unwrapJsonSchema: () => unwrapJsonSchema,
   xmlToolMiddleware: () => xmlToolMiddleware
 });
 module.exports = __toCommonJS(index_exports);
@@ -114,9 +133,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
@@ -1038,11 +1057,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;
@@ -1139,7 +1153,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: (0, import_provider_utils2.generateId)(),
@@ -1262,7 +1276,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;
@@ -1324,7 +1338,51 @@ var jsonMixProtocol = ({
 
 // src/protocols/morph-xml-protocol.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_fast_xml_parser = require("fast-xml-parser");
+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 morphXmlProtocol = () => ({
   formatTools({ tools, toolSystemPromptTemplate }) {
     const toolsForPrompt = (tools || []).map((tool) => ({
@@ -1335,7 +1393,6 @@ var morphXmlProtocol = () => ({
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
   formatToolCall(toolCall) {
-    const builder = new import_fast_xml_parser.XMLBuilder({ format: true, suppressEmptyNode: true });
     let args = {};
     const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
     if (typeof inputValue === "string") {
@@ -1347,145 +1404,63 @@ var morphXmlProtocol = () => ({
     } else {
       args = inputValue;
     }
-    const xmlContent = builder.build({
-      [toolCall.toolName]: args
+    return (0, import_rxml.stringify)(toolCall.toolName, args, {
+      suppressEmptyNode: false,
+      format: false
     });
-    return xmlContent;
   },
   formatToolResponse(toolResult) {
-    const builder = new import_fast_xml_parser.XMLBuilder({ format: true });
-    const xmlContent = builder.build({
-      tool_response: {
-        tool_name: toolResult.toolName,
-        result: toolResult.output
-      }
+    return (0, import_rxml.stringify)("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 import_fast_xml_parser.XMLParser({
-          ignoreAttributes: false,
-          parseTagValue: false,
-          ignoreDeclaration: true,
-          textNodeName: "#text"
+        const toolSchema = getToolSchema(
+          tools,
+          originalSchemas,
+          toolCall.toolName
+        );
+        const parsed = (0, import_rxml.parse)(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: (0, import_provider_utils3.generateId)(),
-          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);
@@ -1524,7 +1499,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);
@@ -1539,112 +1514,36 @@ var morphXmlProtocol = () => ({
               const toolContent = buffer.substring(0, endTagIndex);
               buffer = buffer.substring(endTagIndex + endTag.length);
               try {
-                const parser = new import_fast_xml_parser.XMLParser({
-                  ignoreAttributes: false,
-                  parseTagValue: false,
-                  ignoreDeclaration: true,
-                  textNodeName: "#text"
+                const toolSchema = getToolSchema(
+                  tools,
+                  originalSchemas,
+                  currentToolCall.name
+                );
+                const parsed = (0, import_rxml.parse)(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: (0, import_provider_utils3.generateId)(),
                   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 import_rxml.RXMLDuplicateStringTagError) {
+                  message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof import_rxml.RXMLCoercionError) {
+                  message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+                } else if (error instanceof import_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, {
+                  toolCall: originalCallText,
+                  toolName: currentToolCall.name,
+                  error
+                });
                 flushText(controller, originalCallText);
               }
               currentToolCall = null;
@@ -1694,18 +1593,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
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
 async function wrapGenerate({
@@ -2321,11 +2217,30 @@ San Fransisco
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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.cjs.map