@ax-llm/ax 11.0.55 → 11.0.56

package/index.cjs

@@ -6892,6 +6892,9 @@ function getFieldProcessingMessage(field, resultText) {
 var validateJSONSchema = (schema) => {
   const errors = [];
   const validateSchemaObject = (schema2, path = "") => {
+    if (!schema2 || typeof schema2 !== "object") {
+      return;
+    }
     const validTypes = [
       "array",
       "integer",
@@ -6901,38 +6904,155 @@ var validateJSONSchema = (schema) => {
       "null",
       "object"
     ];
+    if (schema2.anyOf && Array.isArray(schema2.anyOf)) {
+      if (schema2.anyOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "anyOf array is empty",
+          fix: "Add at least one schema to the anyOf array",
+          example: 'anyOf: [{ type: "string" }, { type: "null" }]'
+        });
+      }
+      schema2.anyOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}anyOf[${index}].`);
+      });
+      return;
+    }
+    if (schema2.oneOf && Array.isArray(schema2.oneOf)) {
+      if (schema2.oneOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "oneOf array is empty",
+          fix: "Add at least one schema to the oneOf array",
+          example: 'oneOf: [{ type: "string" }, { type: "number" }]'
+        });
+      }
+      schema2.oneOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}oneOf[${index}].`);
+      });
+      return;
+    }
+    if (schema2.allOf && Array.isArray(schema2.allOf)) {
+      if (schema2.allOf.length === 0) {
+        errors.push({
+          path: path || "root",
+          issue: "allOf array is empty",
+          fix: "Add at least one schema to the allOf array",
+          example: 'allOf: [{ type: "object" }, { properties: { name: { type: "string" } } }]'
+        });
+      }
+      schema2.allOf.forEach((subSchema, index) => {
+        validateSchemaObject(subSchema, `${path}allOf[${index}].`);
+      });
+      return;
+    }
+    if (!schema2.type) {
+      return;
+    }
     if (!validTypes.includes(schema2.type)) {
-      errors.push(`Invalid type '${schema2.type}' at ${path || "root"}`);
+      errors.push({
+        path: path || "root",
+        issue: `Invalid type '${schema2.type}'`,
+        fix: `Change type to one of: ${validTypes.join(", ")}`,
+        example: `{ type: "string" } or { type: "object" }`
+      });
       return;
     }
-    if (schema2.type === "object" && schema2.properties) {
-      if (typeof schema2.properties !== "object" || Array.isArray(schema2.properties)) {
-        errors.push(`Invalid properties object at ${path || "root"}`);
-      } else {
-        for (const key in schema2.properties) {
-          const value = schema2.properties[key];
-          if (typeof value !== "object") {
-            errors.push(`Invalid schema object at ${path}${key}`);
-            continue;
+    if (schema2.type === "object") {
+      if (schema2.properties) {
+        if (typeof schema2.properties !== "object" || Array.isArray(schema2.properties)) {
+          errors.push({
+            path: path || "root",
+            issue: "properties must be an object, not an array or primitive",
+            fix: "Change properties to be an object with property names as keys",
+            example: 'properties: { name: { type: "string" }, age: { type: "number" } }'
+          });
+        } else {
+          for (const key in schema2.properties) {
+            const value = schema2.properties[key];
+            if (value === void 0 || value === null) {
+              continue;
+            }
+            if (typeof value !== "object") {
+              errors.push({
+                path: `${path}${key}`,
+                issue: `Property schema must be an object, got ${typeof value}`,
+                fix: "Define the property as a proper schema object",
+                example: `${key}: { type: "string", description: "..." }`
+              });
+              continue;
+            }
+            validateSchemaObject(value, `${path}${key}.`);
           }
-          validateSchemaObject(value, `${path}${key}.`);
         }
       }
-      if (schema2.required && !Array.isArray(schema2.required)) {
-        errors.push(`'required' should be an array at ${path || "root"}`);
+      if (schema2.required) {
+        if (!Array.isArray(schema2.required)) {
+          errors.push({
+            path: path || "root",
+            issue: `'required' must be an array, got ${typeof schema2.required}`,
+            fix: "Change required to be an array of property names",
+            example: 'required: ["name", "email"] instead of required: "name,email"'
+          });
+        } else if (schema2.required.length === 0) {
+        } else {
+          if (schema2.properties) {
+            for (const requiredProp of schema2.required) {
+              if (typeof requiredProp !== "string") {
+                errors.push({
+                  path: `${path}required`,
+                  issue: `Required property names must be strings, got ${typeof requiredProp}`,
+                  fix: "Ensure all items in required array are strings",
+                  example: 'required: ["name", "email"] not required: [123, "email"]'
+                });
+              } else if (!(requiredProp in schema2.properties)) {
+                errors.push({
+                  path: `${path}required`,
+                  issue: `Required property '${requiredProp}' is not defined in properties`,
+                  fix: `Either add '${requiredProp}' to properties or remove it from required`,
+                  example: `properties: { ${requiredProp}: { type: "string" } }`
+                });
+              }
+            }
+          }
+        }
       }
     }
-    if (schema2.type === "array" && schema2.items) {
-      if (typeof schema2.items !== "object") {
-        errors.push(`Invalid items schema at ${path || "root"}`);
-      } else {
-        validateSchemaObject(schema2.items, `${path}items.`);
+    if (schema2.type === "array") {
+      if (schema2.items) {
+        if (typeof schema2.items !== "object") {
+          errors.push({
+            path: `${path}items`,
+            issue: `Array items schema must be an object, got ${typeof schema2.items}`,
+            fix: "Define items as a proper schema object",
+            example: 'items: { type: "string" } or items: { type: "object", properties: {...} }'
+          });
+        } else {
+          validateSchemaObject(schema2.items, `${path}items.`);
+        }
       }
     }
   };
   validateSchemaObject(schema);
   if (errors.length > 0) {
-    throw new Error(errors.join("; "));
+    const errorMessage = [
+      "JSON Schema validation failed:",
+      "",
+      ...errors.map((error, index) => {
+        const parts = [
+          `${index + 1}. Path: ${error.path}`,
+          `   Issue: ${error.issue}`,
+          `   Fix: ${error.fix}`
+        ];
+        if (error.example) {
+          parts.push(`   Example: ${error.example}`);
+        }
+        return parts.join("\n");
+      }),
+      "",
+      "Please fix these issues and try again."
+    ].join("\n");
+    throw new Error(errorMessage);
   }
 };