@ai-sdk-tool/parser 3.3.0 → 3.3.2

package/dist/community.js

@@ -1,10 +1,10 @@
 import {
   createToolMiddleware,
   xmlProtocol
-} from "./chunk-3QJVNEHE.js";
-import "./chunk-TR2ARLIF.js";
+} from "./chunk-5WKXBBCU.js";
+import "./chunk-ZDBNJWLY.js";
 import "./chunk-IX4FJELL.js";
-import "./chunk-DZB6Y354.js";
+import "./chunk-OUGMLYAW.js";
 
 // src/community/sijawara.ts
 var sijawaraDetailedXmlToolMiddleware = createToolMiddleware({

package/dist/index.cjs

@@ -908,6 +908,13 @@ function generateId() {
   return Math.random().toString(36).substring(2, 15);
 }
 
+// src/core/utils/protocol-utils.ts
+function addTextSegment(text, processedElements) {
+  if (text.trim()) {
+    processedElements.push({ type: "text", text });
+  }
+}
+
 // src/core/utils/regex.ts
 function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -939,11 +946,6 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
     processedElements.push({ type: "text", text: fullMatch });
   }
 }
-function addTextSegment(text, processedElements) {
-  if (text.trim()) {
-    processedElements.push({ type: "text", text });
-  }
-}
 function processMatchedToolCall(context) {
   const { match, text, currentIndex, processedElements, options } = context;
   const startIndex = match.index;
@@ -1618,6 +1620,153 @@ function getSchemaType(schema) {
   }
   return;
 }
+function schemaAllowsPropertyViaCombinators(s, key, depth) {
+  const anyOfValues = s.anyOf;
+  const oneOfValues = s.oneOf;
+  const allOfValues = s.allOf;
+  let hasCombinator = false;
+  let anyOfAllows = true;
+  let oneOfAllows = true;
+  let allOfAllows = true;
+  if (Array.isArray(anyOfValues)) {
+    hasCombinator = true;
+    anyOfAllows = anyOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(oneOfValues)) {
+    hasCombinator = true;
+    oneOfAllows = oneOfValues.some(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (Array.isArray(allOfValues)) {
+    hasCombinator = true;
+    allOfAllows = allOfValues.every(
+      (sub) => schemaHasProperty(sub, key, depth + 1)
+    );
+  }
+  if (!hasCombinator) {
+    return false;
+  }
+  return anyOfAllows && oneOfAllows && allOfAllows;
+}
+function schemaHasPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] !== false) {
+    return true;
+  }
+  const required = s.required;
+  if (Array.isArray(required) && required.includes(key)) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema !== false);
+}
+function schemaHasPropertyViaAdditional(s) {
+  const additional = s.additionalProperties;
+  if (additional === true || additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return true;
+  }
+  if (Object.hasOwn(s, "additionalProperties")) {
+    return false;
+  }
+  const type = s.type;
+  const isObjectType = type === "object" || Array.isArray(type) && type.includes("object");
+  const hasObjectKeywords = s.properties && typeof s.properties === "object" && !Array.isArray(s.properties) || s.patternProperties && typeof s.patternProperties === "object" && !Array.isArray(s.patternProperties) || Array.isArray(s.required) && s.required.length > 0;
+  return !!(isObjectType || hasObjectKeywords);
+}
+function schemaDisallowsPropertyDirectly(s, key) {
+  const props = s.properties;
+  if (props && typeof props === "object" && !Array.isArray(props) && Object.hasOwn(props, key) && props[key] === false) {
+    return true;
+  }
+  const patternSchemas = getPatternSchemasForKey(s.patternProperties, key);
+  return patternSchemas.some((schema) => schema === false);
+}
+function schemaHasProperty(schema, key, depth = 0) {
+  if (depth > 5) {
+    return true;
+  }
+  const unwrapped = unwrapJsonSchema(schema);
+  if (schemaIsUnconstrained(unwrapped)) {
+    return true;
+  }
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return false;
+  }
+  const s = unwrapped;
+  if (schemaDisallowsPropertyDirectly(s, key)) {
+    return false;
+  }
+  if (schemaHasPropertyDirectly(s, key)) {
+    return true;
+  }
+  if (schemaHasPropertyViaAdditional(s)) {
+    return true;
+  }
+  return schemaAllowsPropertyViaCombinators(s, key, depth);
+}
+function schemaIsUnconstrained(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (unwrapped == null || unwrapped === true) {
+    return true;
+  }
+  if (typeof unwrapped !== "object" || Array.isArray(unwrapped)) {
+    return false;
+  }
+  return Object.keys(unwrapped).length === 0;
+}
+function getPatternSchemasForKey(patternProperties, key) {
+  if (!patternProperties || typeof patternProperties !== "object" || Array.isArray(patternProperties)) {
+    return [];
+  }
+  const schemas = [];
+  for (const [pattern, schema] of Object.entries(
+    patternProperties
+  )) {
+    try {
+      const regex = new RegExp(pattern);
+      if (regex.test(key)) {
+        schemas.push(schema);
+      }
+    } catch (e) {
+    }
+  }
+  return schemas;
+}
+function coerceValueForKey(value, key, unwrapped) {
+  const schemas = [];
+  const props = unwrapped.properties;
+  if (props && Object.hasOwn(props, key)) {
+    schemas.push(props[key]);
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    unwrapped.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    schemas.push(...patternSchemas);
+  }
+  if (schemas.length > 0) {
+    let out = value;
+    for (const schema of schemas) {
+      if (typeof schema === "boolean") {
+        continue;
+      }
+      out = coerceBySchema(out, schema);
+    }
+    return out;
+  }
+  const additional = unwrapped.additionalProperties;
+  if (additional && typeof additional === "object" && !Array.isArray(additional)) {
+    return coerceBySchema(value, additional);
+  }
+  if (additional === true || additional === false) {
+    return value;
+  }
+  return coerceBySchema(value, void 0);
+}
 function coerceStringWithoutSchema(value) {
   const s = value.trim();
   const lower = s.toLowerCase();
@@ -1648,13 +1797,7 @@ function coerceStringToObject(s, unwrapped) {
     normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
     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;
+      return coerceObjectToObject(obj, unwrapped);
     }
   } catch (e) {
   }
@@ -1684,10 +1827,8 @@ function coerceStringToArray(s, unwrapped) {
 }
 function coerceObjectToObject(value, unwrapped) {
   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);
+    out[k] = coerceValueForKey(v, k, unwrapped);
   }
   return out;
 }
@@ -1704,16 +1845,22 @@ function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
   const keys = Object.keys(maybe);
-  if (keys.length === 1) {
-    const singleValue = maybe[keys[0]];
-    if (Array.isArray(singleValue)) {
-      return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-    }
-  }
   if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
     const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
+  if (keys.length === 1) {
+    const singleKey = keys[0];
+    if (!(schemaIsUnconstrained(itemsSchema) || schemaHasProperty(itemsSchema, singleKey))) {
+      const singleValue = maybe[singleKey];
+      if (Array.isArray(singleValue)) {
+        return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+      }
+      if (singleValue && typeof singleValue === "object") {
+        return [coerceBySchema(singleValue, itemsSchema)];
+      }
+    }
+  }
   return null;
 }
 function coercePrimitiveToArray(value, prefixItems, itemsSchema) {
@@ -1773,11 +1920,15 @@ function coerceArrayValue(value, prefixItems, itemsSchema) {
     if (result !== null) {
       return result;
     }
+    if (getSchemaType(itemsSchema) === "array") {
+      return [value];
+    }
+    return [coerceBySchema(value, itemsSchema)];
   }
   if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
     return coercePrimitiveToArray(value, prefixItems, itemsSchema);
   }
-  return value;
+  return [value];
 }
 function coerceBySchema(value, schema) {
   const unwrapped = unwrapJsonSchema(schema);
@@ -3554,12 +3705,9 @@ function getStringPropertyNames(schema) {
   }
   return names;
 }
-function escapeRegExp2(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function dedupeSingleTag(xml, key) {
   var _a, _b;
-  const escaped = escapeRegExp2(key);
+  const escaped = escapeRegExp(key);
   const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
   const matches = Array.from(xml.matchAll(re));
   if (matches.length <= 1) {
@@ -3676,9 +3824,11 @@ function parse3(xml, schema, options = {}) {
   throw new RXMLParseError("Failed to parse XML with repair heuristics", error);
 }
 
-// src/core/protocols/xml-protocol.ts
+// src/core/utils/regex-constants.ts
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX4 = /\s/;
+
+// src/core/protocols/xml-protocol.ts
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -4386,8 +4536,6 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
-var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX5 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -4404,11 +4552,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX5.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX4.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < gtIdx && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < gtIdx && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -4424,11 +4572,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX5.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < text.length && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -4437,7 +4585,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX5.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -4555,22 +4703,14 @@ function parseYamlContent(yamlContent, options) {
     return null;
   }
 }
-function appendTextPart(processedElements, textPart) {
-  if (textPart.trim()) {
-    processedElements.push({
-      type: "text",
-      text: textPart
-    });
-  }
-}
 function processToolCallMatch(text, tc, currentIndex, processedElements, options) {
   var _a;
   if (tc.startIndex < currentIndex) {
     return currentIndex;
   }
-  appendTextPart(
-    processedElements,
-    text.substring(currentIndex, tc.startIndex)
+  addTextSegment(
+    text.substring(currentIndex, tc.startIndex),
+    processedElements
   );
   const parsedArgs = parseYamlContent(tc.content, options);
   if (parsedArgs !== null) {
@@ -4688,7 +4828,7 @@ ${yamlContent}</${toolCall.toolName}>`;
         );
       }
       if (currentIndex < text.length) {
-        appendTextPart(processedElements, text.substring(currentIndex));
+        addTextSegment(text.substring(currentIndex), processedElements);
       }
       return processedElements;
     },