@nexface/tools 0.1.13-alpha.4 → 0.1.13-alpha.5

package/dist/shared/schema.js

@@ -3,8 +3,17 @@ const types = new Set(["object", "array", "string", "number", "integer", "boolea
 const counts = ["minLength", "maxLength", "minItems", "maxItems"];
 const bounds = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"];
 const keywords = new Set([
-    "type", "description", "properties", "required", "items", "enum", "additionalProperties",
-    ...counts, ...bounds, "pattern", "uniqueItems",
+    "type",
+    "description",
+    "properties",
+    "required",
+    "items",
+    "enum",
+    "additionalProperties",
+    ...counts,
+    ...bounds,
+    "pattern",
+    "uniqueItems",
 ]);
 const checkedSchemas = new WeakSet();
 const patterns = new WeakMap();
@@ -24,7 +33,9 @@ function assertJson(value, path, ancestors = new Set()) {
         invalid(path, "must be JSON-compatible.");
     if (ancestors.has(value))
         invalid(path, "must not contain circular references.");
-    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    if (!Array.isArray(value) &&
+        Object.getPrototypeOf(value) !== Object.prototype &&
+        Object.getPrototypeOf(value) !== null) {
         invalid(path, "must be a plain JSON object.");
     }
     if (Object.getOwnPropertySymbols(value).length)
@@ -85,7 +96,8 @@ function assertSchema(value, path) {
             invalid(`${path}.${key}`, "must be a non-negative integer.");
     }
     for (const key of bounds) {
-        if (value[key] !== undefined && (typeof value[key] !== "number" || !Number.isFinite(value[key])))
+        if (value[key] !== undefined &&
+            (typeof value[key] !== "number" || !Number.isFinite(value[key])))
             invalid(`${path}.${key}`, "must be a finite number.");
     }
     if (value.pattern !== undefined) {
@@ -95,7 +107,8 @@ function assertSchema(value, path) {
     }
     if (value.enum !== undefined && (!Array.isArray(value.enum) || value.enum.length === 0))
         invalid(`${path}.enum`, "must be a non-empty array.");
-    if (Array.isArray(value.enum) && value.enum.some((item, index, entries) => entries.slice(0, index).some((other) => jsonEqual(item, other))))
+    if (Array.isArray(value.enum) &&
+        value.enum.some((item, index, entries) => entries.slice(0, index).some((other) => jsonEqual(item, other))))
         invalid(`${path}.enum`, "must contain unique values.");
     if (value.properties !== undefined) {
         if (value.type !== "object" || !isRecord(value.properties))
@@ -104,7 +117,10 @@ function assertSchema(value, path) {
             assertSchema(property, `${path}.properties.${name}`);
     }
     if (value.required !== undefined) {
-        if (value.type !== "object" || !Array.isArray(value.required) || value.required.some((name) => typeof name !== "string") || new Set(value.required).size !== value.required.length)
+        if (value.type !== "object" ||
+            !Array.isArray(value.required) ||
+            value.required.some((name) => typeof name !== "string") ||
+            new Set(value.required).size !== value.required.length)
             invalid(`${path}.required`, "must contain unique property names.");
         const properties = value.properties;
         if (value.required.some((name) => !properties || !Object.hasOwn(properties, name)))
@@ -118,7 +134,7 @@ function assertSchema(value, path) {
 }
 export function assertAgentToolInputSchema(value, path = "inputSchema") {
     if (!isRecord(value) || value.type !== "object")
-        invalid(path, 'root type must be object.');
+        invalid(path, "root type must be object.");
     if (checkedSchemas.has(value))
         return;
     const frozen = assertJson(value, path);
@@ -130,21 +146,29 @@ function jsonEqual(left, right) {
     if (left === right)
         return true;
     if (Array.isArray(left) && Array.isArray(right))
-        return left.length === right.length && left.every((item, index) => jsonEqual(item, right[index]));
+        return (left.length === right.length && left.every((item, index) => jsonEqual(item, right[index])));
     if (!isRecord(left) || !isRecord(right))
         return false;
     const keys = Object.keys(left);
-    return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && jsonEqual(left[key], right[key]));
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && jsonEqual(left[key], right[key])));
 }
 function typeMatches(schema, value) {
     switch (schema.type) {
-        case undefined: return true;
-        case "null": return value === null;
-        case "array": return Array.isArray(value);
-        case "object": return isRecord(value);
-        case "integer": return typeof value === "number" && Number.isInteger(value);
-        case "number": return typeof value === "number" && Number.isFinite(value);
-        default: return typeof value === schema.type;
+        case undefined:
+            return true;
+        case "null":
+            return value === null;
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return isRecord(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        default:
+            return typeof value === schema.type;
     }
 }
 export function validateAgentToolInput(schema, value, path = "input") {
@@ -177,7 +201,8 @@ export function validateAgentToolInput(schema, value, path = "input") {
             errors.push(`${path} must have at least ${schema.minItems} items.`);
         if (schema.maxItems !== undefined && value.length > schema.maxItems)
             errors.push(`${path} must have at most ${schema.maxItems} items.`);
-        if (schema.uniqueItems && value.some((item, index) => value.slice(0, index).some((other) => jsonEqual(item, other))))
+        if (schema.uniqueItems &&
+            value.some((item, index) => value.slice(0, index).some((other) => jsonEqual(item, other))))
             errors.push(`${path} must contain unique items.`);
         if (schema.items)
             value.forEach((item, index) => errors.push(...validateAgentToolInput(schema.items, item, `${path}[${index}]`)));
@@ -188,7 +213,9 @@ export function validateAgentToolInput(schema, value, path = "input") {
                 errors.push(`${path}.${key} is required.`);
         }
         for (const [key, item] of Object.entries(value)) {
-            const property = schema.properties && Object.hasOwn(schema.properties, key) ? schema.properties[key] : undefined;
+            const property = schema.properties && Object.hasOwn(schema.properties, key)
+                ? schema.properties[key]
+                : undefined;
             if (property)
                 errors.push(...validateAgentToolInput(property, item, `${path}.${key}`));
             else if (schema.additionalProperties === false)