@ai-sdk-tool/parser 3.3.0 → 3.3.2

package/dist/index.d.cts

@@ -3,6 +3,12 @@ import { LanguageModelV3FunctionTool, LanguageModelV3ToolCall, LanguageModelV3Co
 import { ToolResultPart } from '@ai-sdk/provider-utils';
 export { ParseOptions, parse, stringify, transform } from './rjson.cjs';
 
+/**
+ * Options for parsing tool calls and handling errors
+ */
+interface ParserOptions {
+    onError?: (message: string, metadata?: Record<string, unknown>) => void;
+}
 interface TCMProtocol {
     formatTools({ tools, toolSystemPromptTemplate, }: {
         tools: LanguageModelV3FunctionTool[];
@@ -261,4 +267,4 @@ declare function transformParams({ params, protocol, toolSystemPromptTemplate, t
     toolChoice: undefined;
 };
 
-export { type DebugLevel, type OnErrorFn, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };
+export { type DebugLevel, type OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };

package/dist/index.d.ts

@@ -3,6 +3,12 @@ import { LanguageModelV3FunctionTool, LanguageModelV3ToolCall, LanguageModelV3Co
 import { ToolResultPart } from '@ai-sdk/provider-utils';
 export { ParseOptions, parse, stringify, transform } from './rjson.js';
 
+/**
+ * Options for parsing tool calls and handling errors
+ */
+interface ParserOptions {
+    onError?: (message: string, metadata?: Record<string, unknown>) => void;
+}
 interface TCMProtocol {
     formatTools({ tools, toolSystemPromptTemplate, }: {
         tools: LanguageModelV3FunctionTool[];
@@ -261,4 +267,4 @@ declare function transformParams({ params, protocol, toolSystemPromptTemplate, t
     toolChoice: undefined;
 };
 
-export { type DebugLevel, type OnErrorFn, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };
+export { type DebugLevel, type OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };

package/dist/index.js

@@ -3,7 +3,6 @@ import {
   createToolMiddleware,
   decodeOriginalTools,
   encodeOriginalTools,
-  escapeRegExp,
   extractOnErrorOption,
   extractToolNamesFromOriginalTools,
   getDebugLevel,
@@ -28,14 +27,16 @@ import {
   xmlToolMiddleware,
   yamlProtocol,
   yamlToolMiddleware
-} from "./chunk-3QJVNEHE.js";
-import "./chunk-TR2ARLIF.js";
+} from "./chunk-5WKXBBCU.js";
+import {
+  escapeRegExp
+} from "./chunk-ZDBNJWLY.js";
 import {
   parse,
   stringify,
   transform
 } from "./chunk-IX4FJELL.js";
-import "./chunk-DZB6Y354.js";
+import "./chunk-OUGMLYAW.js";
 export {
   createDynamicIfThenElseSchema,
   createToolMiddleware,

package/dist/rxml.cjs

@@ -406,6 +406,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();
@@ -436,13 +583,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) {
   }
@@ -472,10 +613,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;
 }
@@ -492,16 +631,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) {
@@ -561,11 +706,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);
@@ -2101,6 +2250,11 @@ function createIntermediateCall(toolName, rawSegment, schema) {
   };
 }
 
+// src/core/utils/regex.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/rxml/heuristics/xml-defaults.ts
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
@@ -2342,9 +2496,6 @@ function getStringPropertyNames(schema) {
   }
   return names;
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function dedupeSingleTag(xml, key) {
   var _a, _b;
   const escaped = escapeRegExp(key);