@ax-llm/ax 12.0.0 → 12.0.2

package/index.cjs

@@ -1270,6 +1270,7 @@ var AxBaseAI = class {
     if (chatReq.functions && chatReq.functions.length > 0) {
       functions = chatReq.functions.map((fn2) => this.cleanupFunctionSchema(fn2));
     }
+    validateChatPrompt(chatReq.chatPrompt);
     const req = {
       ...chatReq,
       model,
@@ -1611,6 +1612,31 @@ function setChatResponseEvents(res, span, excludeContentFromTrace) {
     });
   }
 }
+function validateAxMessageArray(values) {
+  for (let i = 0; i < values.length; i++) {
+    const message = values[i];
+    if (!message || typeof message !== "object") {
+      throw new Error(
+        `AxMessage array validation failed: Item at index ${i} is not a valid message object`
+      );
+    }
+    if ("content" in message && typeof message.content === "string" && message.content.trim() === "") {
+      throw new Error(
+        `AxMessage array validation failed: Item at index ${i} has empty content`
+      );
+    }
+  }
+}
+function validateChatPrompt(chatPrompt) {
+  for (let i = 0; i < chatPrompt.length; i++) {
+    const message = chatPrompt[i];
+    if (message && "content" in message && typeof message.content === "string" && message.content.trim() === "") {
+      throw new Error(
+        `Chat prompt validation failed: Message at index ${i} has empty content`
+      );
+    }
+  }
+}
 function validateModels(models) {
   const keys = /* @__PURE__ */ new Set();
   for (const model of models) {
@@ -3387,7 +3413,9 @@ var AxAIGoogleGeminiImpl = class {
     const contents = req.chatPrompt.filter((p) => p.role !== "system").map((msg, i) => {
       switch (msg.role) {
         case "user": {
-          const parts = Array.isArray(msg.content) ? msg.content.map((c, i2) => {
+          const parts = Array.isArray(
+            msg.content
+          ) ? msg.content.map((c, i2) => {
             switch (c.type) {
               case "text":
                 return { text: c.text };
@@ -3448,12 +3476,14 @@ var AxAIGoogleGeminiImpl = class {
             }
           ];
           return {
-            role: "function",
+            role: "model",
             parts
           };
         }
         default:
-          throw new Error("Invalid role");
+          throw new Error(
+            `Invalid role: ${JSON.stringify(msg)} (index: ${i})`
+          );
       }
     });
     let tools = [];
@@ -5629,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,
@@ -5654,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) {
@@ -7785,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`,
@@ -7794,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 {
@@ -8109,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 = [];
@@ -8150,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",
@@ -8196,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;
@@ -8218,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;
@@ -8245,6 +8306,7 @@ var AxSignature = class _AxSignature {
         return parsed;
       });
       this.inputFields = parsedFields;
+      this.invalidateValidationCache();
       this.updateHash();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
@@ -8270,6 +8332,7 @@ var AxSignature = class _AxSignature {
         return parsed;
       });
       this.outputFields = parsedFields;
+      this.invalidateValidationCache();
       this.updateHash();
     } catch (error) {
       if (error instanceof AxSignatureValidationError) {
@@ -8283,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();
@@ -8319,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) => {
@@ -8391,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 = () => {
@@ -8416,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") {
@@ -8548,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(
@@ -8564,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"
         );
       }
     }
@@ -8612,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;
@@ -9185,6 +9282,7 @@ Content: ${result.content}`
     }
     let prompt;
     if (Array.isArray(values)) {
+      validateAxMessageArray(values);
       prompt = this.promptTemplate.render(values, {
         examples: this.examples,
         demos: this.demos