@ai-sdk-tool/parser 3.2.0 → 3.2.1

package/dist/{chunk-PIUBQRFC.js → chunk-DCK5APVO.js}

@@ -515,10 +515,6 @@ function isTCMProtocolFactory(protocol) {
 import { parse, stringify } from "@ai-sdk-tool/rxml";
 var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX = /\s/;
-var REGEX_ESCAPE_RE = /[.*+?^${}()|[\]\\]/g;
-function escapeRegExp2(value) {
-  return value.replace(REGEX_ESCAPE_RE, "\\$&");
-}
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -683,21 +679,25 @@ function nextTagToken(text, fromPos) {
     nextPos: open.nextPos
   };
 }
-function findNextToolTag(text, searchIndex, startTag, selfTag) {
+function findNextToolTag(text, searchIndex, toolName) {
+  var _a, _b;
+  const startTag = `<${toolName}>`;
   const openIdx = text.indexOf(startTag, searchIndex);
-  const selfIdx = text.indexOf(selfTag, searchIndex);
+  const selfMatch = findSelfClosingTag(text, toolName, searchIndex);
+  const selfIdx = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
   if (openIdx === -1 && selfIdx === -1) {
     return null;
   }
   const isSelfClosing = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx);
   return {
     tagStart: isSelfClosing ? selfIdx : openIdx,
-    isSelfClosing
+    isSelfClosing,
+    tagLength: isSelfClosing ? (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0 : startTag.length
   };
 }
 function findLastCloseTagStart(segment, toolName) {
   const closeTagPattern = new RegExp(
-    `</\\s*${escapeRegExp2(toolName)}\\s*>`,
+    `</\\s*${escapeRegExp(toolName)}\\s*>`,
     "g"
   );
   let closeTagStart = -1;
@@ -711,8 +711,8 @@ function findLastCloseTagStart(segment, toolName) {
   }
   return closeTagStart;
 }
-function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, selfTag) {
-  const endIndex = tagStart + selfTag.length;
+function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, tagLength) {
+  const endIndex = tagStart + tagLength;
   toolCalls.push({
     toolName,
     startIndex: tagStart,
@@ -722,6 +722,24 @@ function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, selfTag) {
   });
   return endIndex;
 }
+var selfClosingTagCache = /* @__PURE__ */ new Map();
+function getSelfClosingTagPattern(toolName) {
+  let pattern = selfClosingTagCache.get(toolName);
+  if (!pattern) {
+    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
+    selfClosingTagCache.set(toolName, pattern);
+  }
+  return pattern;
+}
+function findSelfClosingTag(text, toolName, fromIndex) {
+  const pattern = getSelfClosingTagPattern(toolName);
+  pattern.lastIndex = fromIndex;
+  const match = pattern.exec(text);
+  if (!match || match.index === void 0) {
+    return null;
+  }
+  return { index: match.index, length: match[0].length };
+}
 function appendOpenToolCallIfComplete(toolCalls, text, toolName, tagStart, startTag) {
   const contentStart = tagStart + startTag.length;
   const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
@@ -743,10 +761,9 @@ function appendOpenToolCallIfComplete(toolCalls, text, toolName, tagStart, start
 function findToolCallsForName(text, toolName) {
   const toolCalls = [];
   const startTag = `<${toolName}>`;
-  const selfTag = `<${toolName}/>`;
   let searchIndex = 0;
   while (searchIndex < text.length) {
-    const match = findNextToolTag(text, searchIndex, startTag, selfTag);
+    const match = findNextToolTag(text, searchIndex, toolName);
     if (match === null) {
       break;
     }
@@ -756,7 +773,7 @@ function findToolCallsForName(text, toolName) {
         toolName,
         text,
         match.tagStart,
-        selfTag
+        match.tagLength
       );
       continue;
     }
@@ -779,28 +796,114 @@ function findToolCalls(text, toolNames) {
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 function findEarliestToolTag(buffer, toolNames) {
+  var _a, _b;
   let bestIndex = -1;
   let bestName = "";
   let bestSelfClosing = false;
+  let bestTagLength = 0;
   if (toolNames.length > 0) {
     for (const name of toolNames) {
       const openTag = `<${name}>`;
-      const selfTag = `<${name}/>`;
       const idxOpen = buffer.indexOf(openTag);
-      const idxSelf = buffer.indexOf(selfTag);
+      const selfMatch = findSelfClosingTag(buffer, name, 0);
+      const idxSelf = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
       if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
         bestIndex = idxOpen;
         bestName = name;
         bestSelfClosing = false;
+        bestTagLength = openTag.length;
       }
       if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
         bestIndex = idxSelf;
         bestName = name;
         bestSelfClosing = true;
+        bestTagLength = (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0;
       }
     }
   }
-  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+  return {
+    index: bestIndex,
+    name: bestName,
+    selfClosing: bestSelfClosing,
+    tagLength: bestTagLength
+  };
+}
+function isOpenTagPrefix(suffix, toolName) {
+  return `${toolName}>`.startsWith(suffix);
+}
+function consumeWhitespace(text, index) {
+  let i = index;
+  while (i < text.length && WHITESPACE_REGEX.test(text.charAt(i))) {
+    i += 1;
+  }
+  return i;
+}
+function consumeToolNamePrefix(text, index, toolName) {
+  let i = index;
+  let nameIndex = 0;
+  while (i < text.length && nameIndex < toolName.length) {
+    if (text.charAt(i) !== toolName.charAt(nameIndex)) {
+      return { index: i, done: false, valid: false };
+    }
+    i += 1;
+    nameIndex += 1;
+  }
+  return { index: i, done: nameIndex === toolName.length, valid: true };
+}
+function isSelfClosingSuffixRemainder(text, index) {
+  if (text.charAt(index) !== "/") {
+    return false;
+  }
+  if (index + 1 >= text.length) {
+    return true;
+  }
+  return index + 1 === text.length - 1 && text.charAt(index + 1) === ">";
+}
+function isSelfClosingTagPrefix(suffix, toolName) {
+  let i = consumeWhitespace(suffix, 0);
+  if (i >= suffix.length) {
+    return true;
+  }
+  const nameRemainder = suffix.slice(i);
+  if (toolName.startsWith(nameRemainder)) {
+    return true;
+  }
+  const nameResult = consumeToolNamePrefix(suffix, i, toolName);
+  if (!nameResult.valid) {
+    return false;
+  }
+  i = nameResult.index;
+  if (i >= suffix.length) {
+    return true;
+  }
+  if (!nameResult.done) {
+    return false;
+  }
+  i = consumeWhitespace(suffix, i);
+  if (i >= suffix.length) {
+    return true;
+  }
+  return isSelfClosingSuffixRemainder(suffix, i);
+}
+function findPotentialToolTagStart(buffer, toolNames) {
+  if (toolNames.length === 0 || buffer.length === 0) {
+    return -1;
+  }
+  const lastGt = buffer.lastIndexOf(">");
+  const offset = lastGt === -1 ? 0 : lastGt + 1;
+  const trailing = buffer.slice(offset);
+  for (let i = trailing.length - 1; i >= 0; i -= 1) {
+    if (trailing.charAt(i) !== "<") {
+      continue;
+    }
+    const suffix = trailing.slice(i + 1);
+    for (const name of toolNames) {
+      if (isOpenTagPrefix(suffix, name) || isSelfClosingTagPrefix(suffix, name)) {
+        return offset + i;
+      }
+    }
+  }
+  return -1;
 }
 function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
   return (controller, text) => {
@@ -846,7 +949,7 @@ function processToolCallInBuffer(params) {
     parseOptions
   } = params;
   const endTagPattern = new RegExp(
-    `</\\s*${escapeRegExp2(currentToolCall.name)}\\s*>`
+    `</\\s*${escapeRegExp(currentToolCall.name)}\\s*>`
   );
   const endMatch = endTagPattern.exec(buffer);
   if (!endMatch || endMatch.index === void 0) {
@@ -886,18 +989,22 @@ function processNoToolCallInBuffer(params) {
   const {
     index: earliestStartTagIndex,
     name: earliestToolName,
-    selfClosing
+    selfClosing,
+    tagLength
   } = findEarliestToolTag(buffer, toolNames);
   if (earliestStartTagIndex === -1) {
-    const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
-    const tail = Math.max(0, maxTagLen - 1);
-    const safeLen = Math.max(0, buffer.length - tail);
+    const potentialStart = findPotentialToolTagStart(buffer, toolNames);
+    const safeLen = Math.max(
+      0,
+      potentialStart === -1 ? buffer.length : potentialStart
+    );
+    const remaining = buffer.slice(safeLen);
     if (safeLen > 0) {
       flushText(controller, buffer.slice(0, safeLen));
-      setBuffer(buffer.slice(safeLen));
+      setBuffer(remaining);
     }
     return {
-      buffer: buffer.slice(safeLen),
+      buffer: remaining,
       currentToolCall: null,
       shouldBreak: true,
       shouldContinue: false
@@ -905,8 +1012,7 @@ function processNoToolCallInBuffer(params) {
   }
   flushText(controller, buffer.substring(0, earliestStartTagIndex));
   if (selfClosing) {
-    const selfTag = `<${earliestToolName}/>`;
-    const newBuffer2 = buffer.substring(earliestStartTagIndex + selfTag.length);
+    const newBuffer2 = buffer.substring(earliestStartTagIndex + tagLength);
     setBuffer(newBuffer2);
     handleStreamingToolCallEnd({
       toolContent: "",
@@ -1967,29 +2073,230 @@ function formatXmlNode(tagName, value, depth) {
 }
 
 // src/core/prompts/xml-system-prompt.ts
+import dedent from "dedent";
 function xmlSystemPromptTemplate(tools) {
-  const toolsJson = JSON.stringify(tools);
-  return `# Tools
-
-You may call one or more functions to assist with the user query.
-
-You are provided with function signatures within <tools></tools> XML tags:
-<tools>${toolsJson}</tools>
-
-# Rules
-- Use exactly one XML element whose tag name is the function name.
-- Put each parameter as a child element.
-- Values must follow the schema exactly (numbers, arrays, objects, enums \u2192 copy as-is).
-- Do not add or remove functions or parameters.
-- Each required parameter must appear once.
-- Output nothing before or after the function call.
-- After calling a tool, you will receive a response in the format: <tool_response><tool_name>NAME</tool_name><result>RESULT</result></tool_response>. Use this result to answer the user.
-
-# Example
-<get_weather>
-  <location>New York</location>
-  <unit>celsius</unit>
-</get_weather>`;
+  const toolsText = renderToolsForXmlPrompt(tools);
+  const header = dedent`
+    # Tools
+    You may call one or more functions to assist with the user query.
+  `;
+  const definitions = [
+    "You have access to the following functions:",
+    "<tools>",
+    toolsText,
+    "</tools>"
+  ].join("\n");
+  const rules = dedent`
+    <rules>
+    - Use exactly one XML element whose tag name is the function name.
+    - Put each parameter as a child element.
+    - Values must follow the schema exactly (numbers, arrays, objects, enums → copy as-is).
+    - Do not add or remove functions or parameters.
+    - Each required parameter must appear once.
+    - Output nothing before or after the function call.
+    - It is also possible to call multiple types of functions in one turn or to call a single function multiple times.
+    </rules>
+  `;
+  const examples = dedent`
+    For each function call, output the function name and parameter in the following format:
+    <example_function_name>
+      <example_parameter_1>value_1</example_parameter_1>
+      <example_parameter_2>This is the value for the second parameter
+    that can span
+    multiple lines</example_parameter_2>
+    </example_function_name>
+  `;
+  return [header, definitions, rules, examples].join("\n\n");
+}
+var INDENT = "  ";
+function renderToolsForXmlPrompt(tools) {
+  if (!tools.length) {
+    return "none";
+  }
+  return tools.map(renderToolForXmlPrompt).join("\n\n");
+}
+function renderToolForXmlPrompt(tool) {
+  const lines = [`name: ${tool.name}`];
+  if (tool.description) {
+    lines.push(`description: ${tool.description}`);
+  }
+  lines.push("parameters:");
+  const normalizedSchema = normalizeSchema(tool.inputSchema);
+  lines.push(...renderParametersSummary(normalizedSchema, 1));
+  lines.push(`schema: ${stringifySchema(normalizedSchema)}`);
+  return lines.join("\n");
+}
+function normalizeSchema(schema) {
+  if (typeof schema === "string") {
+    try {
+      return JSON.parse(schema);
+    } catch (e) {
+      return { type: "string", const: schema };
+    }
+  }
+  return schema;
+}
+function renderParametersSummary(schema, indentLevel) {
+  var _a, _b;
+  const indent = INDENT.repeat(indentLevel);
+  if (schema === void 0 || schema === null) {
+    return [`${indent}(none)`];
+  }
+  if (schema === true) {
+    return [`${indent}(any)`];
+  }
+  if (schema === false) {
+    return [`${indent}(no valid parameters)`];
+  }
+  if (typeof schema !== "object") {
+    return [`${indent}- value (${String(schema)})`];
+  }
+  const schemaType = [];
+  if (Array.isArray(schema.type)) {
+    schemaType.push(...schema.type);
+  } else if (schema.type) {
+    schemaType.push(schema.type);
+  }
+  const isObjectLike = schemaType.includes("object") || !!schema.properties;
+  if (isObjectLike) {
+    const properties = (_a = schema.properties) != null ? _a : {};
+    const requiredSet = new Set((_b = schema.required) != null ? _b : []);
+    const propertyNames = Object.keys(properties).sort();
+    if (propertyNames.length === 0) {
+      return [`${indent}(no named parameters)`];
+    }
+    const lines = [];
+    for (const propName of propertyNames) {
+      const propSchema = properties[propName];
+      lines.push(
+        renderPropertySummaryLine({
+          indent,
+          propName,
+          propSchema,
+          required: requiredSet.has(propName)
+        })
+      );
+    }
+    return lines.length ? lines : [`${indent}(no parameters)`];
+  }
+  return [`${indent}- value (${summarizeType(schema)})`];
+}
+function renderPropertySummaryLine({
+  indent,
+  propName,
+  propSchema,
+  required
+}) {
+  const typeLabel = summarizeType(propSchema);
+  const requiredLabel = required ? "required" : "optional";
+  const extras = collectPropertyExtras(propSchema);
+  const extraText = extras.length ? ` - ${extras.join("; ")}` : "";
+  return `${indent}- ${propName} (${typeLabel}, ${requiredLabel})${extraText}`;
+}
+function collectPropertyExtras(propSchema) {
+  if (!propSchema || typeof propSchema !== "object") {
+    return [];
+  }
+  const extras = [];
+  if (propSchema.enum) {
+    extras.push(`enum: ${formatEnumForSummary(propSchema.enum)}`);
+  }
+  if (propSchema.default !== void 0) {
+    extras.push(`default: ${formatValue(propSchema.default)}`);
+  }
+  if (propSchema.description) {
+    extras.push(propSchema.description);
+  }
+  return extras;
+}
+function summarizeType(schema) {
+  var _a;
+  if (schema === void 0 || schema === null) {
+    return "unknown";
+  }
+  if (schema === true) {
+    return "any";
+  }
+  if (schema === false) {
+    return "never";
+  }
+  if (typeof schema !== "object") {
+    return String(schema);
+  }
+  const schemaType = schema.type;
+  let baseType = "";
+  if (Array.isArray(schemaType) && schemaType.length) {
+    baseType = schemaType.join(" | ");
+  } else if (typeof schemaType === "string") {
+    baseType = schemaType;
+  } else if (schema.enum) {
+    const inferred = Array.from(
+      new Set(schema.enum.map((value) => typeof value))
+    );
+    if (inferred.length === 1) {
+      baseType = (_a = inferred[0]) != null ? _a : "";
+    }
+  } else if (schema.const !== void 0) {
+    baseType = typeof schema.const;
+  }
+  if (!baseType) {
+    baseType = "any";
+  }
+  if (baseType === "array" && schema.items) {
+    const itemType = Array.isArray(schema.items) ? schema.items.map((item) => summarizeType(item)).join(" | ") : summarizeType(schema.items);
+    return `array<${itemType}>`;
+  }
+  if (baseType === "string" && schema.format) {
+    return `string (${schema.format})`;
+  }
+  return baseType;
+}
+var ENUM_MAX_INLINE = 6;
+var ENUM_PREVIEW_LIMIT = 5;
+function formatEnumForSummary(values) {
+  if (values.length <= ENUM_MAX_INLINE) {
+    return formatValue(values);
+  }
+  const preview = values.slice(0, ENUM_PREVIEW_LIMIT).map((value) => formatValue(value));
+  return `[${preview.join(", ")}, ... (${values.length} total)]`;
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(formatValue).join(", ")}]`;
+  }
+  return JSON.stringify(value);
+}
+function stringifySchema(schema) {
+  if (schema === void 0) {
+    return "null";
+  }
+  return JSON.stringify(stripSchemaKeys(schema));
+}
+function stripSchemaKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stripSchemaKeys(entry));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const cleaned = {};
+    for (const [key, entry] of Object.entries(record)) {
+      if (key === "$schema") {
+        continue;
+      }
+      cleaned[key] = stripSchemaKeys(entry);
+    }
+    return cleaned;
+  }
+  return value;
 }
 
 // src/core/prompts/yaml-system-prompt.ts
@@ -2567,4 +2874,4 @@ export {
   xmlToolMiddleware,
   yamlToolMiddleware
 };
-//# sourceMappingURL=chunk-PIUBQRFC.js.map
+//# sourceMappingURL=chunk-DCK5APVO.js.map