@ax-llm/ax 11.0.54 → 11.0.56

package/index.cjs

@@ -5979,15 +5979,11 @@ var AxPromptTemplate = class {
   task;
   thoughtFieldName;
   functions;
-  strictExamples;
-  optionalOutputFields;
   constructor(sig, options, fieldTemplates) {
     this.sig = sig;
     this.fieldTemplates = fieldTemplates;
     this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
     this.functions = options?.functions;
-    this.strictExamples = options?.strictExamples ?? false;
-    this.optionalOutputFields = options?.optionalOutputFields ?? [];
     const task = [];
     const inArgs = renderDescFields(this.sig.getInputFields());
     const outArgs = renderDescFields(this.sig.getOutputFields());
@@ -6157,33 +6153,22 @@ ${outputFields}`);
   };
   renderExamples = (data) => {
     const list = [];
-    const inputExampleContext = {
-      isExample: true,
-      strictExamples: this.strictExamples,
-      optionalOutputFields: this.optionalOutputFields,
-      isInputField: true
-    };
-    const outputExampleContext = {
-      isExample: true,
-      strictExamples: this.strictExamples,
-      optionalOutputFields: this.optionalOutputFields,
-      isInputField: false
+    const exampleContext = {
+      isExample: true
     };
     for (const [index, item] of data.entries()) {
-      const renderedInputItem = this.sig.getInputFields().map((field) => this.renderInField(field, item, inputExampleContext)).filter((v) => v !== void 0).flat();
-      const outputFields = this.sig.getOutputFields();
-      const renderedOutputItem = outputFields.map((field) => this.renderInField(field, item, outputExampleContext)).filter((v) => v !== void 0).flat();
-      if (renderedOutputItem.length === 0) {
-        const missingFields = outputFields.filter((field) => !item[field.name]);
-        const allMissingFieldsAreOptional = missingFields.every(
-          (field) => this.optionalOutputFields.includes(field.name)
-        );
-        if (!allMissingFieldsAreOptional) {
-          throw new Error(
-            `Output fields are required in examples: index: ${index}, data: ${JSON.stringify(item)}`
-          );
-        }
-      }
+      const renderedInputItem = this.sig.getInputFields().map(
+        (field) => this.renderInField(field, item, {
+          ...exampleContext,
+          isInputField: true
+        })
+      ).filter((v) => v !== void 0).flat();
+      const renderedOutputItem = this.sig.getOutputFields().map(
+        (field) => this.renderInField(field, item, {
+          ...exampleContext,
+          isInputField: false
+        })
+      ).filter((v) => v !== void 0).flat();
       const renderedItem = [...renderedInputItem, ...renderedOutputItem];
       if (index > 0 && renderedItem.length > 0 && renderedItem[0]?.type === "text") {
         list.push({ type: "text", text: "---\n\n" });
@@ -6204,20 +6189,19 @@ ${outputFields}`);
     const list = [];
     const inputFields = this.sig.getInputFields();
     const outputFields = this.sig.getOutputFields();
+    const demoContext = {
+      isExample: true
+    };
     for (const item of data) {
       const inputRenderedItems = inputFields.map(
         (field) => this.renderInField(field, item, {
-          isExample: true,
-          strictExamples: this.strictExamples,
-          optionalOutputFields: this.optionalOutputFields,
+          ...demoContext,
           isInputField: true
         })
       ).filter((v) => v !== void 0).flat();
       const outputRenderedItems = outputFields.map(
         (field) => this.renderInField(field, item, {
-          isExample: true,
-          strictExamples: this.strictExamples,
-          optionalOutputFields: this.optionalOutputFields,
+          ...demoContext,
           isInputField: false
         })
       ).filter((v) => v !== void 0).flat();
@@ -6433,24 +6417,9 @@ var isEmptyValue = (field, value, context3) => {
   }
   if (!value || (Array.isArray(value) || typeof value === "string") && value.length === 0) {
     if (context3?.isExample) {
-      const isInputField = context3?.isInputField ?? true;
-      if (isInputField) {
-        if (!context3?.strictExamples) {
-          return true;
-        } else {
-          if (field.isOptional || field.isInternal) {
-            return true;
-          }
-          throw new Error(`Value for input field '${field.name}' is required.`);
-        }
-      } else {
-        if (field.isOptional || field.isInternal || context3?.optionalOutputFields?.includes(field.name)) {
-          return true;
-        }
-        throw new Error(`Value for output field '${field.name}' is required.`);
-      }
+      return true;
     }
-    if (field.isOptional || field.isInternal || context3?.optionalOutputFields?.includes(field.name)) {
+    if (field.isOptional || field.isInternal) {
       return true;
     }
     const fieldType = context3?.isInputField !== false ? "input" : "output";
@@ -6923,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",
@@ -6932,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);
   }
 };
 
@@ -7781,7 +7870,7 @@ var AxProgramWithSignature = class {
         const res = {};
         for (const f of fields) {
           const value = e[f.name];
-          if (value) {
+          if (value !== void 0) {
             validateValue(f, value);
             res[f.name] = value;
           }
@@ -7914,9 +8003,7 @@ var AxGen = class extends AxProgramWithSignature {
     this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
     const promptTemplateOptions = {
       functions: options?.functions,
-      thoughtFieldName: this.thoughtFieldName,
-      strictExamples: options?.strictExamples,
-      optionalOutputFields: options?.optionalOutputFields
+      thoughtFieldName: this.thoughtFieldName
     };
     this.promptTemplate = new (options?.promptTemplate ?? AxPromptTemplate)(
       this.signature,
@@ -8280,9 +8367,7 @@ Content: ${result.content}`
       const promptTemplateClass = this.options?.promptTemplate ?? AxPromptTemplate;
       const currentPromptTemplateOptions = {
         functions: options.functions,
-        thoughtFieldName: this.thoughtFieldName,
-        strictExamples: this.options?.strictExamples,
-        optionalOutputFields: this.options?.optionalOutputFields
+        thoughtFieldName: this.thoughtFieldName
       };
       this.promptTemplate = new promptTemplateClass(
         this.signature,
@@ -8470,19 +8555,6 @@ Content: ${result.content}`
   }
   setExamples(examples, options) {
     super.setExamples(examples, options);
-    if (options?.optionalOutputFields) {
-      const promptTemplateClass = this.options?.promptTemplate ?? AxPromptTemplate;
-      const currentPromptTemplateOptions = {
-        functions: this.functions,
-        thoughtFieldName: this.thoughtFieldName,
-        strictExamples: this.options?.strictExamples,
-        optionalOutputFields: options.optionalOutputFields
-      };
-      this.promptTemplate = new promptTemplateClass(
-        this.signature,
-        currentPromptTemplateOptions
-      );
-    }
   }
 };
 var AxGenerateError = class extends Error {