@ax-llm/ax 11.0.64 → 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,
@@ -11931,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) {
@@ -13899,6 +14042,7 @@ var AxRAG = class extends AxChainOfThought {
   AxSpanKindValues,
   AxStringUtil,
   AxTestPrompt,
+  ax,
   axAIAnthropicDefaultConfig,
   axAIAnthropicVertexDefaultConfig,
   axAIAzureOpenAIBestConfig,
@@ -13933,6 +14077,7 @@ var AxRAG = class extends AxChainOfThought {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axField,
   axModelInfoAnthropic,
   axModelInfoCohere,
   axModelInfoDeepSeek,