@ax-llm/ax 12.0.1 → 12.0.2

package/index.cjs

@@ -5659,10 +5659,15 @@ var MemoryImpl = class {
     name,
     functionCalls
   }) {
-    if (!content && (!functionCalls || functionCalls.length === 0)) {
+    const isContentEmpty = typeof content === "string" && content.trim() === "";
+    if (isContentEmpty && (!functionCalls || functionCalls.length === 0)) {
       return;
     }
-    this.addMemory({ content, name, role: "assistant", functionCalls });
+    if (isContentEmpty) {
+      this.addMemory({ name, role: "assistant", functionCalls });
+    } else {
+      this.addMemory({ content, name, role: "assistant", functionCalls });
+    }
   }
   addResult({
     content,
@@ -5684,7 +5689,7 @@ var MemoryImpl = class {
     if (!lastItem || lastItem.chat.role !== "assistant") {
       this.addResultMessage({ content, name, functionCalls });
     } else {
-      if ("content" in lastItem.chat && content) {
+      if ("content" in lastItem.chat && typeof content === "string" && content.trim() !== "") {
         lastItem.chat.content = content;
       }
       if ("name" in lastItem.chat && name) {
@@ -7815,7 +7820,7 @@ var SignatureParser = class {
             'Add class names in quotes. Example: class "positive, negative, neutral"'
           );
         }
-        const options = classNamesString.split(/[,\s]+/).map((s2) => s2.trim()).filter((s2) => s2.length > 0);
+        const options = classNamesString.split(/[,|]/).map((s2) => s2.trim()).filter((s2) => s2.length > 0);
         if (options.length === 0) {
           throw new SignatureValidationError(
             `Output field "${name}": Empty class list provided`,
@@ -7824,24 +7829,6 @@ var SignatureParser = class {
             'Provide at least one class option. Example: "positive, negative"'
           );
         }
-        if (options.length === 1) {
-          throw new SignatureValidationError(
-            `Output field "${name}": Class type needs at least 2 options`,
-            this.position,
-            this.getErrorContext(),
-            'Add more class options or use "string" type instead. Example: "positive, negative, neutral"'
-          );
-        }
-        for (const option of options) {
-          if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(option)) {
-            throw new SignatureValidationError(
-              `Output field "${name}": Invalid class option "${option}"`,
-              this.position,
-              this.getErrorContext(),
-              "Class options must start with a letter and contain only letters, numbers, underscores, or hyphens"
-            );
-          }
-        }
         type = { name: "class", isArray, options };
       } else {
         try {
@@ -8139,6 +8126,8 @@ var AxSignature = class _AxSignature {
   outputFields;
   sigHash;
   sigString;
+  // Validation caching - stores hash when validation last passed
+  validatedAtHash;
   constructor(signature) {
     if (!signature) {
       this.inputFields = [];
@@ -8180,6 +8169,9 @@ var AxSignature = class _AxSignature {
       );
       this.sigHash = signature.hash();
       this.sigString = signature.toString();
+      if (signature.validatedAtHash === this.sigHash) {
+        this.validatedAtHash = this.sigHash;
+      }
     } else {
       throw new AxSignatureValidationError(
         "Invalid signature argument type",
@@ -8226,14 +8218,34 @@ var AxSignature = class _AxSignature {
       );
     }
     this.description = desc;
+    this.invalidateValidationCache();
     this.updateHash();
   };
   addInputField = (field) => {
     try {
       const parsedField = this.parseField(field);
       validateField(parsedField, "input");
+      for (const existingField of this.inputFields) {
+        if (existingField.name === parsedField.name) {
+          throw new AxSignatureValidationError(
+            `Duplicate input field name: "${parsedField.name}"`,
+            parsedField.name,
+            "Each field name must be unique within the signature"
+          );
+        }
+      }
+      for (const outputField of this.outputFields) {
+        if (outputField.name === parsedField.name) {
+          throw new AxSignatureValidationError(
+            `Field name "${parsedField.name}" appears in both inputs and outputs`,
+            parsedField.name,
+            "Use different names for input and output fields to avoid confusion"
+          );
+        }
+      }
       this.inputFields.push(parsedField);
-      this.updateHash();
+      this.invalidateValidationCache();
+      this.updateHashLight();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
         throw error;
@@ -8248,8 +8260,27 @@ var AxSignature = class _AxSignature {
     try {
       const parsedField = this.parseField(field);
       validateField(parsedField, "output");
+      for (const existingField of this.outputFields) {
+        if (existingField.name === parsedField.name) {
+          throw new AxSignatureValidationError(
+            `Duplicate output field name: "${parsedField.name}"`,
+            parsedField.name,
+            "Each field name must be unique within the signature"
+          );
+        }
+      }
+      for (const inputField of this.inputFields) {
+        if (inputField.name === parsedField.name) {
+          throw new AxSignatureValidationError(
+            `Field name "${parsedField.name}" appears in both inputs and outputs`,
+            parsedField.name,
+            "Use different names for input and output fields to avoid confusion"
+          );
+        }
+      }
       this.outputFields.push(parsedField);
-      this.updateHash();
+      this.invalidateValidationCache();
+      this.updateHashLight();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
         throw error;
@@ -8275,6 +8306,7 @@ var AxSignature = class _AxSignature {
         return parsed;
       });
       this.inputFields = parsedFields;
+      this.invalidateValidationCache();
       this.updateHash();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
@@ -8300,6 +8332,7 @@ var AxSignature = class _AxSignature {
         return parsed;
       });
       this.outputFields = parsedFields;
+      this.invalidateValidationCache();
       this.updateHash();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
@@ -8313,6 +8346,9 @@ var AxSignature = class _AxSignature {
   getInputFields = () => this.inputFields;
   getOutputFields = () => this.outputFields;
   getDescription = () => this.description;
+  invalidateValidationCache = () => {
+    this.validatedAtHash = void 0;
+  };
   toTitle = (name) => {
     let result = name.replace(/_/g, " ");
     result = result.replace(/([A-Z]|[0-9]+)/g, " $1").trim();
@@ -8349,6 +8385,30 @@ var AxSignature = class _AxSignature {
     };
     return schema;
   };
+  updateHashLight = () => {
+    try {
+      this.getInputFields().forEach((field) => {
+        validateField(field, "input");
+      });
+      this.getOutputFields().forEach((field) => {
+        validateField(field, "output");
+      });
+      this.sigHash = (0, import_crypto3.createHash)("sha256").update(this.description ?? "").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
+      this.sigString = renderSignature(
+        this.description,
+        this.inputFields,
+        this.outputFields
+      );
+      return [this.sigHash, this.sigString];
+    } catch (error) {
+      if (error instanceof AxSignatureValidationError) {
+        throw error;
+      }
+      throw new AxSignatureValidationError(
+        `Signature validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  };
   updateHash = () => {
     try {
       this.getInputFields().forEach((field) => {
@@ -8421,6 +8481,19 @@ var AxSignature = class _AxSignature {
       );
     }
   }
+  validate = () => {
+    if (this.validatedAtHash === this.sigHash) {
+      return true;
+    }
+    try {
+      this.updateHash();
+      this.validatedAtHash = this.sigHash;
+      return true;
+    } catch (error) {
+      this.validatedAtHash = void 0;
+      throw error;
+    }
+  };
   hash = () => this.sigHash;
   toString = () => this.sigString;
   toJSON = () => {
@@ -8446,7 +8519,7 @@ function renderField(field) {
       result += "[]";
     }
     if (field.type.name === "class" && field.type.options) {
-      result += ` "${field.type.options.join(", ")}"`;
+      result += ` "${field.type.options.join(" | ")}"`;
     }
   }
   if (field.description && field.type?.name !== "class") {
@@ -8578,13 +8651,6 @@ function validateFieldType(field, context3) {
         'Provide class options. Example: class "positive, negative, neutral"'
       );
     }
-    if (type.options.length === 1) {
-      throw new AxSignatureValidationError(
-        "Class type needs at least 2 options",
-        field.name,
-        'Add more class options or use "string" type instead'
-      );
-    }
     for (const option of type.options) {
       if (!option || option.trim().length === 0) {
         throw new AxSignatureValidationError(
@@ -8594,11 +8660,11 @@ function validateFieldType(field, context3) {
         );
       }
       const trimmedOption = option.trim();
-      if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(trimmedOption)) {
+      if (trimmedOption.includes(",") || trimmedOption.includes("|")) {
         throw new AxSignatureValidationError(
           `Invalid class option "${trimmedOption}"`,
           field.name,
-          "Class options must start with a letter and contain only letters, numbers, underscores, or hyphens"
+          "Class options cannot contain commas (,) or pipes (|) as they are used to separate options"
         );
       }
     }
@@ -8642,12 +8708,13 @@ var AxProgramWithSignature = class {
   children;
   constructor(signature, options) {
     this.signature = new AxSignature(signature);
-    this.sigHash = this.signature?.hash();
-    this.children = new AxInstanceRegistry();
-    this.key = { id: this.constructor.name };
     if (options?.description) {
       this.signature.setDescription(options.description);
     }
+    this.signature.validate();
+    this.sigHash = this.signature?.hash();
+    this.children = new AxInstanceRegistry();
+    this.key = { id: this.constructor.name };
   }
   getSignature() {
     return this.signature;