@dexto/core 1.8.3 → 1.8.4

package/dist/tools/tool-call-metadata.js

@@ -22,17 +22,129 @@ const META_SCHEMA = {
   additionalProperties: true
 };
 const META_KEY = "__meta";
-function wrapToolParametersSchema(parameters) {
-  if (parameters.type !== "object" || !parameters.properties) {
-    return parameters;
+const FORBIDDEN_TOP_LEVEL_SCHEMA_KEYS = ["oneOf", "anyOf", "allOf", "enum", "not"];
+function hasForbiddenTopLevelSchemaKey(parameters) {
+  return FORBIDDEN_TOP_LEVEL_SCHEMA_KEYS.some((key) => key in parameters);
+}
+function readObjectAlternatives(parameters) {
+  const alternatives = parameters.oneOf ?? parameters.anyOf;
+  if (!Array.isArray(alternatives)) {
+    return [];
+  }
+  return alternatives.filter(
+    (alternative) => alternative !== true && alternative !== false && alternative.type === "object"
+  );
+}
+function readRequiredPropertyNames(schema) {
+  return new Set(
+    Array.isArray(schema.required) ? schema.required.filter((propertyName) => typeof propertyName === "string") : []
+  );
+}
+function intersectRequiredProperties(alternatives) {
+  if (alternatives.length === 0) {
+    return void 0;
+  }
+  const requiredSets = alternatives.map(readRequiredPropertyNames);
+  const first = requiredSets[0];
+  if (first === void 0) {
+    return void 0;
+  }
+  const rest = requiredSets.slice(1);
+  const required = [...first].filter(
+    (propertyName) => rest.every((requiredProperties) => requiredProperties.has(propertyName))
+  );
+  return required.length === 0 ? void 0 : required;
+}
+function valuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function mergeEnumValues(values) {
+  const merged = [];
+  for (const value of values) {
+    if (!merged.some((existing) => valuesEqual(existing, value))) {
+      merged.push(value);
+    }
+  }
+  return merged;
+}
+function readEnumValues(schema) {
+  if (schema.const !== void 0) {
+    return [schema.const];
+  }
+  return Array.isArray(schema.enum) ? schema.enum : void 0;
+}
+function mergePropertySchema(current, next) {
+  if (current === void 0 || current === false) {
+    return next;
+  }
+  if (current === true || next === true) {
+    return {};
+  }
+  if (next === false) {
+    return current;
   }
-  if (META_KEY in parameters.properties) {
+  if (valuesEqual(current, next)) {
+    return current;
+  }
+  const currentEnum = readEnumValues(current);
+  const nextEnum = readEnumValues(next);
+  if (currentEnum !== void 0 && nextEnum !== void 0) {
+    return { enum: mergeEnumValues([...currentEnum, ...nextEnum]) };
+  }
+  if (current.type !== void 0 && valuesEqual(current.type, next.type)) {
+    return { type: current.type };
+  }
+  return {};
+}
+function flattenObjectUnionSchema(parameters) {
+  const alternatives = readObjectAlternatives(parameters);
+  if (alternatives.length === 0) {
+    return void 0;
+  }
+  const properties = {};
+  const required = intersectRequiredProperties(alternatives);
+  for (const alternative of alternatives) {
+    const alternativeProperties = alternative.properties ?? {};
+    for (const [propertyName, propertySchema] of Object.entries(alternativeProperties)) {
+      properties[propertyName] = mergePropertySchema(
+        properties[propertyName],
+        propertySchema
+      );
+    }
+  }
+  return {
+    ...parameters.description === void 0 ? {} : { description: parameters.description },
+    type: "object",
+    properties,
+    ...required === void 0 ? {} : { required },
+    additionalProperties: true
+  };
+}
+function normalizeToolParametersSchema(parameters) {
+  if (parameters.type === "object" && !hasForbiddenTopLevelSchemaKey(parameters)) {
     return parameters;
   }
+  const flattened = flattenObjectUnionSchema(parameters);
+  if (flattened !== void 0) {
+    return flattened;
+  }
+  return {
+    type: "object",
+    additionalProperties: true
+  };
+}
+function wrapToolParametersSchema(parameters) {
+  const normalized = normalizeToolParametersSchema(parameters);
+  if (!normalized.properties) {
+    return normalized;
+  }
+  if (META_KEY in normalized.properties) {
+    return normalized;
+  }
   return {
-    ...parameters,
+    ...normalized,
     properties: {
-      ...parameters.properties,
+      ...normalized.properties,
       [META_KEY]: META_SCHEMA
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/core",
-  "version": "1.8.3",
+  "version": "1.8.4",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -157,7 +157,7 @@
     "nanoid": "^5.1.6",
     "winston": "^3.17.0",
     "yaml": "^2.8.3",
-    "@dexto/llm": "1.8.3"
+    "@dexto/llm": "1.8.4"
   },
   "devDependencies": {
     "@opentelemetry/instrumentation-http": "^0.210.0",