@ax-llm/ax 11.0.63 → 11.0.65

package/index.cjs

@@ -124,6 +124,7 @@ __export(index_exports, {
   AxSpanKindValues: () => AxSpanKindValues,
   AxStringUtil: () => AxStringUtil,
   AxTestPrompt: () => AxTestPrompt,
+  ax: () => ax,
   axAIAnthropicDefaultConfig: () => axAIAnthropicDefaultConfig,
   axAIAnthropicVertexDefaultConfig: () => axAIAnthropicVertexDefaultConfig,
   axAIAzureOpenAIBestConfig: () => axAIAzureOpenAIBestConfig,
@@ -158,6 +159,7 @@ __export(index_exports, {
   axAITogetherDefaultConfig: () => axAITogetherDefaultConfig,
   axBaseAIDefaultConfig: () => axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig: () => axBaseAIDefaultCreativeConfig,
+  axField: () => axField,
   axModelInfoAnthropic: () => axModelInfoAnthropic,
   axModelInfoCohere: () => axModelInfoCohere,
   axModelInfoDeepSeek: () => axModelInfoDeepSeek,
@@ -6506,7 +6508,17 @@ var renderOutputFields = (fields) => {
     const name = field.title;
     const type = field.type?.name ? toFieldType(field.type) : "string";
     const requiredMsg = field.isOptional ? `Only include this ${type} field if its value is available` : `This ${type} field must be included`;
-    const description = field.description ? ` ${formatDescription(field.description)}` : "";
+    let description = "";
+    if (field.description && field.description.length > 0) {
+      const value = field.type?.name === "class" ? field.description : formatDescription(field.description);
+      description = ` ${value}`;
+    }
+    if (field.type?.options && field.type.options.length > 0) {
+      if (description.length > 0) {
+        description += `. `;
+      }
+      description += `Allowed values: ${field.type.options.join(", ")}`;
+    }
     return `${name}: (${requiredMsg})${description}`.trim();
   });
   return rows.join("\n");
@@ -6546,7 +6558,7 @@ var toFieldType = (type) => {
       case "json":
         return "JSON object";
       case "class":
-        return `list of classes (match case): ${type.classes?.join(", ")})`;
+        return "classification class";
       case "code":
         return "code";
       default:
@@ -6833,12 +6845,12 @@ var convertValueToType = (field, val, required = false) => {
       return parseLLMFriendlyDateTime(field, val, required);
     case "class":
       const className = val;
-      if (field.type.classes && !field.type.classes.includes(className)) {
+      if (field.type.options && !field.type.options.includes(className)) {
         if (field.isOptional) {
           return;
         }
         throw new Error(
-          `Invalid class '${val}', expected one of the following: ${field.type.classes.join(", ")}`
+          `Invalid class '${val}', expected one of the following: ${field.type.options.join(", ")}`
         );
       }
       return className;
@@ -7617,13 +7629,13 @@ ${pointer}`;
             `Output field "${name}": Expected class names in quotes after "class" type. Example: class "MyClass1, MyClass2"`
           );
         }
-        const classes = classNamesString.split(/[,\s]+/).map((s) => s.trim()).filter((s) => s.length > 0);
-        if (classes.length === 0) {
+        const options = classNamesString.split(/[,\s]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+        if (options.length === 0) {
           throw new Error(
             `Output field "${name}": Empty class list provided. At least one class name is required`
           );
         }
-        type = { name: "class", isArray, classes };
+        type = { name: "class", isArray, options };
       } else {
         try {
           const typeName = this.parseTypeNotClass();
@@ -11921,6 +11933,147 @@ var AxTestPrompt = class {
   }
 };
 
+// dsp/template.ts
+function ax(strings, ...values) {
+  let result = "";
+  for (let i = 0; i < strings.length; i++) {
+    result += strings[i] ?? "";
+    if (i < values.length) {
+      const val = values[i];
+      if (isAxFieldType(val)) {
+        const fieldNameMatch = result.match(/(\w+)\s*:\s*$/);
+        if (fieldNameMatch && (val.isOptional || val.isInternal)) {
+          const fieldName = fieldNameMatch[1];
+          let modifiedFieldName = fieldName;
+          if (val.isOptional) modifiedFieldName += "?";
+          if (val.isInternal) modifiedFieldName += "!";
+          result = result.replace(/(\w+)(\s*:\s*)$/, `${modifiedFieldName}$2`);
+        }
+        const { isOptional: _o, isInternal: _i, ...typeNoFlags } = val;
+        result += convertFieldTypeToString(typeNoFlags);
+      } else if (isAxFieldDescriptor(val)) {
+        result += convertFieldDescriptorToString(val);
+      } else if (typeof val === "string" || val instanceof AxSignature) {
+        result += convertValueToSignatureString(val);
+      } else {
+        throw new Error("Unsupported template interpolation value");
+      }
+    }
+  }
+  return new AxSignature(result);
+}
+function convertValueToSignatureString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isAxFieldType(value)) {
+    return convertFieldTypeToString(value);
+  }
+  if (isAxFieldDescriptor(value)) {
+    return convertFieldDescriptorToString(value);
+  }
+  if (value instanceof AxSignature) {
+    const sigString = value.toString();
+    const arrowIndex = sigString.indexOf(" -> ");
+    if (arrowIndex !== -1) {
+      return sigString.substring(arrowIndex + 4);
+    }
+    return sigString;
+  }
+  throw new Error(`Unsupported template value type: ${typeof value}`);
+}
+function convertFieldTypeToString(fieldType) {
+  let result = fieldType.type;
+  if (fieldType.isArray) {
+    result += "[]";
+  }
+  if (fieldType.options && fieldType.options.length > 0 && fieldType.type === "class") {
+    result += ` "${fieldType.options.join(", ")}"`;
+  }
+  if (fieldType.description) {
+    result += ` "${fieldType.description}"`;
+  }
+  return result;
+}
+function convertFieldDescriptorToString(descriptor) {
+  let result = descriptor.name;
+  if (descriptor.isOptional) {
+    result += "?";
+  }
+  if (descriptor.isInternal) {
+    result += "!";
+  }
+  if (descriptor.type) {
+    result += ":" + convertFieldTypeToString(descriptor.type);
+  }
+  if (descriptor.description && !descriptor.type?.description) {
+    result += ` "${descriptor.description}"`;
+  }
+  return result;
+}
+function isAxFieldType(value) {
+  return value !== null && typeof value === "object" && value !== void 0 && "type" in value && typeof value.type === "string";
+}
+function isAxFieldDescriptor(value) {
+  return value !== null && typeof value === "object" && value !== void 0 && "name" in value && typeof value.name === "string";
+}
+var axField = {
+  string: (desc) => ({
+    type: "string",
+    description: desc
+  }),
+  number: (desc) => ({
+    type: "number",
+    description: desc
+  }),
+  boolean: (desc) => ({
+    type: "boolean",
+    description: desc
+  }),
+  date: (desc) => ({
+    type: "date",
+    description: desc
+  }),
+  datetime: (desc) => ({
+    type: "datetime",
+    description: desc
+  }),
+  json: (desc) => ({
+    type: "json",
+    description: desc
+  }),
+  image: (desc) => ({
+    type: "image",
+    description: desc
+  }),
+  audio: (desc) => ({
+    type: "audio",
+    description: desc
+  }),
+  class: (options, desc) => ({
+    type: "class",
+    options,
+    description: desc
+  }),
+  code: (language, desc) => ({
+    type: "code",
+    options: [language],
+    description: desc
+  }),
+  array: (baseType) => ({
+    ...baseType,
+    isArray: true
+  }),
+  optional: (baseType) => ({
+    ...baseType,
+    isOptional: true
+  }),
+  internal: (baseType) => ({
+    ...baseType,
+    isInternal: true
+  })
+};
+
 // prompts/cot.ts
 var AxChainOfThought = class extends AxGen {
   constructor(signature, options) {
@@ -13889,6 +14042,7 @@ var AxRAG = class extends AxChainOfThought {
   AxSpanKindValues,
   AxStringUtil,
   AxTestPrompt,
+  ax,
   axAIAnthropicDefaultConfig,
   axAIAnthropicVertexDefaultConfig,
   axAIAzureOpenAIBestConfig,
@@ -13923,6 +14077,7 @@ var AxRAG = class extends AxChainOfThought {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axField,
   axModelInfoAnthropic,
   axModelInfoCohere,
   axModelInfoDeepSeek,