@ax-llm/ax 11.0.50 → 11.0.51

package/index.cjs

@@ -172,6 +172,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // ai/base.ts
+var import_crypto2 = __toESM(require("crypto"), 1);
 var import_api2 = require("@opentelemetry/api");
 
 // trace/trace.ts
@@ -239,6 +240,7 @@ var AxSpanKindValues = /* @__PURE__ */ ((AxSpanKindValues2) => {
 })(AxSpanKindValues || {});
 
 // util/apicall.ts
+var import_crypto = __toESM(require("crypto"), 1);
 var import_web3 = require("stream/web");
 var import_api = require("@opentelemetry/api");
 
@@ -379,7 +381,7 @@ var AxAIServiceError = class extends Error {
     this.responseBody = responseBody;
     this.name = this.constructor.name;
     this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    this.errorId = crypto.randomUUID();
+    this.errorId = import_crypto.default.randomUUID();
     this.context = context3;
     this.stack = this.toString();
   }
@@ -500,7 +502,7 @@ var apiCall = async (api, json) => {
   const baseUrl = new URL(process.env["PROXY"] ?? api.url);
   const apiPath = `${[baseUrl.pathname, api.name].filter(Boolean).join("/").replace(/\/+/g, "/")}${baseUrl.search}`;
   const apiUrl = new URL(apiPath, baseUrl);
-  const requestId = crypto.randomUUID();
+  const requestId = import_crypto.default.randomUUID();
   if (api.validateRequest) {
     const isValid = await api.validateRequest(json);
     if (!isValid) {
@@ -913,7 +915,7 @@ var AxBaseAI = class {
     this.tracer = options.tracer;
     this.modelInfo = modelInfo;
     this.models = models;
-    this.id = crypto.randomUUID();
+    this.id = import_crypto2.default.randomUUID();
     const model = this.getModel(defaults.model) ?? defaults.model;
     const embedModel = this.getEmbedModel(defaults.embedModel) ?? defaults.embedModel;
     this.defaults = { model, embedModel };
@@ -2262,6 +2264,9 @@ var AxAIOpenAIImpl = class {
     }
     if (config.thinkingTokenBudget) {
       switch (config.thinkingTokenBudget) {
+        case "none":
+          reqValue.reasoning_effort = void 0;
+          break;
         case "minimal":
           reqValue.reasoning_effort = "low";
           break;
@@ -3323,6 +3328,9 @@ var AxAIGoogleGeminiImpl = class {
     }
     if (config.thinkingTokenBudget) {
       switch (config.thinkingTokenBudget) {
+        case "none":
+          thinkingConfig.thinkingBudget = 0;
+          break;
         case "minimal":
           thinkingConfig.thinkingBudget = 200;
           break;
@@ -5914,16 +5922,20 @@ var AxPromptTemplate = class {
   sig;
   fieldTemplates;
   task;
-  constructor(sig, functions, fieldTemplates) {
+  thoughtFieldName;
+  functions;
+  constructor(sig, options, fieldTemplates) {
     this.sig = sig;
     this.fieldTemplates = fieldTemplates;
+    this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
+    this.functions = options?.functions;
     const task = [];
     const inArgs = renderDescFields(this.sig.getInputFields());
     const outArgs = renderDescFields(this.sig.getOutputFields());
     task.push(
       `You will be provided with the following fields: ${inArgs}. Your task is to generate new fields: ${outArgs}.`
     );
-    const funcs = functions?.map((f) => "toFunction" in f ? f.toFunction() : f)?.flat();
+    const funcs = this.functions?.map((f) => "toFunction" in f ? f.toFunction() : f)?.flat();
     const funcList = funcs?.map((fn) => `- \`${fn.name}\`: ${formatDescription(fn.description)}`).join("\n");
     if (funcList && funcList.length > 0) {
       task.push(`## Available Functions
@@ -5958,7 +5970,6 @@ ${outputFields}`);
       ...this.renderExamples(examples)
     ] : [];
     const renderedDemos = demos ? this.renderDemos(demos) : [];
-    const completion = this.renderInputFields(values);
     const allTextExamples = renderedExamples.every((v) => v.type === "text");
     const allTextDemos = renderedDemos.every((v) => v.type === "text");
     const examplesInSystemPrompt = allTextExamples && allTextDemos;
@@ -5978,14 +5989,73 @@ ${outputFields}`);
       role: "system",
       content: systemContent
     };
-    const promptList = examplesInSystemPrompt ? completion : [...renderedExamples, ...renderedDemos, ...completion];
-    const prompt = promptList.filter((v) => v !== void 0);
-    const userContent = prompt.every((v) => v.type === "text") ? prompt.map((v) => v.text).join("\n") : prompt.reduce(combineConsecutiveStrings("\n"), []);
-    const userPrompt = {
-      role: "user",
-      content: userContent
-    };
-    return [systemPrompt, userPrompt];
+    let userMessages = [];
+    if (Array.isArray(values)) {
+      const history = values;
+      let lastRole = void 0;
+      for (const message of history) {
+        let messageContent = "";
+        if (message.role === "user") {
+          const userMsgParts = this.renderInputFields(
+            message.values
+            // Cast message.values (AxGenIn) to T (which extends AxGenIn)
+          );
+          messageContent = userMsgParts.map((part) => part.type === "text" ? part.text : "").join("").trim();
+        } else if (message.role === "assistant") {
+          const assistantValues = message.values;
+          let assistantContentParts = [];
+          const outputFields = this.sig.getOutputFields();
+          for (const field of outputFields) {
+            const value = assistantValues[field.name];
+            if (value !== void 0 && value !== null && (typeof value === "string" ? value !== "" : true)) {
+              const renderedValue = processValue(field, value);
+              assistantContentParts.push(`${field.name}: ${renderedValue}`);
+            } else {
+              const isThoughtField = field.name === this.thoughtFieldName;
+              if (!field.isOptional && !field.isInternal && !isThoughtField) {
+                throw new Error(
+                  `Value for output field '${field.name}' ('${field.title}') is required in assistant message history but was not found or was empty.`
+                );
+              }
+            }
+          }
+          messageContent = assistantContentParts.join("\n");
+        }
+        if (messageContent) {
+          if (lastRole === message.role && userMessages.length > 0) {
+            const lastMessage = userMessages[userMessages.length - 1];
+            if (lastMessage) {
+              lastMessage.content += "\n" + messageContent;
+            }
+          } else {
+            if (message.role === "user") {
+              userMessages.push({ role: "user", content: messageContent });
+            } else if (message.role === "assistant") {
+              userMessages.push({ role: "assistant", content: messageContent });
+            }
+          }
+          lastRole = message.role;
+        }
+      }
+    } else {
+      const currentValues = values;
+      const completion = this.renderInputFields(currentValues);
+      const promptList = examplesInSystemPrompt ? completion : [...renderedExamples, ...renderedDemos, ...completion];
+      const promptFilter = promptList.filter((v) => v !== void 0);
+      let userContent;
+      if (promptFilter.every((v) => v.type === "text")) {
+        userContent = promptFilter.map((v) => v.text).join("\n");
+      } else {
+        userContent = promptFilter.map((part) => {
+          if (part.type === "text") return part.text;
+          if (part.type === "image") return "[IMAGE]";
+          if (part.type === "audio") return "[AUDIO]";
+          return "";
+        }).join("\n").trim();
+      }
+      userMessages.push({ role: "user", content: userContent });
+    }
+    return [systemPrompt, ...userMessages];
   };
   renderExtraFields = (extraFields) => {
     const prompt = [];
@@ -6029,8 +6099,8 @@ ${outputFields}`);
   renderExamples = (data) => {
     const list = [];
     for (const [index, item] of data.entries()) {
-      const renderedInputItem = this.sig.getInputFields().map((field) => this.renderInField(field, item, true)).filter((v) => v !== void 0).flat();
-      const renderedOutputItem = this.sig.getOutputFields().map((field) => this.renderInField(field, item, true)).filter((v) => v !== void 0).flat();
+      const renderedInputItem = this.sig.getInputFields().map((field) => this.renderInField(field, item)).filter((v) => v !== void 0).flat();
+      const renderedOutputItem = this.sig.getOutputFields().map((field) => this.renderInField(field, item)).filter((v) => v !== void 0).flat();
       if (renderedOutputItem.length === 0) {
         throw new Error(
           `Output fields are required in examples: index: ${index}, data: ${JSON.stringify(item)}`
@@ -6056,7 +6126,7 @@ ${outputFields}`);
     const list = [];
     const fields = [...this.sig.getInputFields(), ...this.sig.getOutputFields()];
     for (const item of data) {
-      const renderedItem = fields.map((field) => this.renderInField(field, item, true)).filter((v) => v !== void 0).flat();
+      const renderedItem = fields.map((field) => this.renderInField(field, item)).filter((v) => v !== void 0).flat();
       renderedItem.slice(0, -1).forEach((v) => {
         if ("text" in v) {
           v.text = v.text + "\n";
@@ -6076,11 +6146,8 @@ ${outputFields}`);
     });
     return renderedItems;
   };
-  renderInField = (field, values, skipMissing) => {
+  renderInField = (field, values) => {
     const value = values[field.name];
-    if (skipMissing && !value) {
-      return;
-    }
     if (isEmptyValue(field, value)) {
       return;
     }
@@ -6117,20 +6184,20 @@ ${outputFields}`);
         }
         result = result.concat(
           value.map((v) => {
-            v = validateImage(v);
+            const validated = validateImage(v);
             return {
               type: "image",
-              mimeType: v.mimeType,
-              image: v.data
+              mimeType: validated.mimeType,
+              image: validated.data
             };
           })
         );
       } else {
-        const v = validateImage(value);
+        const validated = validateImage(value);
         result.push({
           type: "image",
-          mimeType: v.mimeType,
-          image: v.data
+          mimeType: validated.mimeType,
+          image: validated.data
         });
       }
       return result;
@@ -6153,24 +6220,24 @@ ${outputFields}`);
       ];
       if (field.type.isArray) {
         if (!Array.isArray(value)) {
-          throw new Error("Image field value must be an array.");
+          throw new Error("Audio field value must be an array.");
         }
         result = result.concat(
           value.map((v) => {
-            v = validateAudio(v);
+            const validated = validateAudio(v);
             return {
               type: "audio",
-              format: v.format ?? "wav",
-              data: v.data
+              format: validated.format ?? "wav",
+              data: validated.data
             };
           })
         );
       } else {
-        const v = validateAudio(value);
+        const validated = validateAudio(value);
         result.push({
           type: "audio",
-          format: v.format ?? "wav",
-          data: v.data
+          format: validated.format ?? "wav",
+          data: validated.data
         });
       }
       return result;
@@ -6270,7 +6337,7 @@ var isEmptyValue = (field, value) => {
     return false;
   }
   if (!value || (Array.isArray(value) || typeof value === "string") && value.length === 0) {
-    if (field.isOptional) {
+    if (field.isOptional || field.isInternal) {
       return true;
     }
     throw new Error(`Value for input field '${field.name}' is required.`);
@@ -7010,7 +7077,7 @@ var AxInstanceRegistry = class {
 };
 
 // dsp/sig.ts
-var import_crypto = require("crypto");
+var import_crypto3 = require("crypto");
 
 // dsp/parser.ts
 var SignatureParser = class {
@@ -7452,7 +7519,7 @@ var AxSignature = class _AxSignature {
         throw new Error("Image type is not supported in output fields.");
       }
     });
-    this.sigHash = (0, import_crypto.createHash)("sha256").update(this.description ?? "").update(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
+    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,
@@ -7724,12 +7791,18 @@ var AxGen = class extends AxProgramWithSignature {
   streamingFieldProcessors = [];
   values = {};
   excludeContentFromTrace = false;
+  thoughtFieldName;
   constructor(signature, options) {
     super(signature, { description: options?.description });
     this.options = options;
+    this.thoughtFieldName = options?.thoughtFieldName ?? "thought";
+    const promptTemplateOptions = {
+      functions: options?.functions,
+      thoughtFieldName: this.thoughtFieldName
+    };
     this.promptTemplate = new (options?.promptTemplate ?? AxPromptTemplate)(
       this.signature,
-      options?.functions
+      promptTemplateOptions
     );
     this.asserts = this.options?.asserts ?? [];
     this.streamingAsserts = this.options?.streamingAsserts ?? [];
@@ -7901,7 +7974,9 @@ var AxGen = class extends AxProgramWithSignature {
         );
       } else if (result.content && result.content.length > 0) {
         if (result.thought && result.thought.length > 0) {
-          yield { thought: result.thought };
+          yield {
+            [this.thoughtFieldName]: result.thought
+          };
         }
         content += result.content;
         mem.updateResult(
@@ -7943,8 +8018,10 @@ var AxGen = class extends AxProgramWithSignature {
         );
         await assertAssertions(this.asserts, this.values);
       } else if (result.thought && result.thought.length > 0) {
-        this.values.thought = this.values.thought ?? "" + result.thought;
-        yield { thought: result.thought };
+        this.values[this.thoughtFieldName] = (this.values[this.thoughtFieldName] ?? "") + result.thought;
+        yield {
+          [this.thoughtFieldName]: result.thought
+        };
       }
       if (result.finishReason === "length") {
         throw new Error(
@@ -8044,7 +8121,7 @@ Content: ${content}`
         }
       } else if (result.content) {
         if (result.thought && result.thought.length > 0) {
-          this.values.thought = result.thought;
+          this.values[this.thoughtFieldName] = result.thought;
         }
         extractValues(this.signature, this.values, result.content);
         await assertAssertions(this.asserts, this.values);
@@ -8081,16 +8158,29 @@ Content: ${result.content}`
     const mem = options.mem ?? this.options?.mem ?? new AxMemory(1e4, memOptions);
     let err;
     if (options?.functions && options.functions.length > 0) {
-      const promptTemplate = this.options?.promptTemplate ?? AxPromptTemplate;
-      this.promptTemplate = new promptTemplate(
+      const promptTemplateClass = this.options?.promptTemplate ?? AxPromptTemplate;
+      const currentPromptTemplateOptions = {
+        functions: options.functions,
+        thoughtFieldName: this.thoughtFieldName
+      };
+      this.promptTemplate = new promptTemplateClass(
         this.signature,
-        options.functions
+        currentPromptTemplateOptions
       );
     }
-    const prompt = this.promptTemplate.render(values, {
-      examples: this.examples,
-      demos: this.demos
-    });
+    let prompt;
+    if (Array.isArray(values)) {
+      prompt = this.promptTemplate.render(values, {
+        examples: this.examples,
+        demos: this.demos
+      });
+    } else {
+      prompt = this.promptTemplate.render(values, {
+        // Cast if necessary
+        examples: this.examples,
+        demos: this.demos
+      });
+    }
     mem.add(prompt, options?.sessionId);
     multiStepLoop: for (let n = 0; n < maxSteps; n++) {
       const firstStep = n === 0;
@@ -8952,7 +9042,8 @@ var AxBootstrapFewShot = class {
           if (this.costMonitoring) {
             this.stats.estimatedTokenUsage += JSON.stringify(ex).length / 4 + JSON.stringify(res).length / 4;
           }
-          const success = metricFn({ prediction: res, example: ex });
+          const score = metricFn({ prediction: res, example: ex });
+          const success = score >= 0.5;
           if (success) {
             this.traces = [...this.traces, ...this.program.getTraces()];
             this.stats.successfulDemos++;
@@ -10940,19 +11031,20 @@ ${dataContext}
       }
       evalSet = minibatchEvalSet;
     }
-    let correctCount = 0;
+    let sumOfScores = 0;
     for (const example of evalSet) {
       try {
         const prediction = await this.program.forward(this.ai, example);
-        const correct = metricFn({ prediction, example });
-        if (correct) correctCount++;
+        const score = metricFn({ prediction, example });
+        sumOfScores += score;
       } catch (err) {
         if (this.verbose) {
           console.error("Error evaluating example:", err);
         }
       }
     }
-    return correctCount / evalSet.length;
+    if (evalSet.length === 0) return 0;
+    return sumOfScores / evalSet.length;
   }
   /**
    * Run full evaluation on the entire validation set
@@ -10964,19 +11056,20 @@ ${dataContext}
       bootstrappedDemos,
       labeledExamples
     );
-    let fullCorrectCount = 0;
+    let sumOfScores = 0;
     for (const example of valset) {
       try {
         const prediction = await this.program.forward(this.ai, example);
-        const correct = metricFn({ prediction, example });
-        if (correct) fullCorrectCount++;
+        const score = metricFn({ prediction, example });
+        sumOfScores += score;
       } catch (err) {
         if (this.verbose) {
           console.error("Error evaluating example:", err);
         }
       }
     }
-    return fullCorrectCount / valset.length;
+    if (valset.length === 0) return 0;
+    return sumOfScores / valset.length;
   }
   /**
    * Implements a Bayesian-inspired selection of the next configuration to try
@@ -11148,10 +11241,11 @@ ${dataContext}
 };
 
 // ai/mock/api.ts
+var import_crypto4 = __toESM(require("crypto"), 1);
 var AxMockAIService = class {
   constructor(config = {}) {
     this.config = config;
-    this.config.id = this.config.id ?? crypto.randomUUID();
+    this.config.id = this.config.id ?? import_crypto4.default.randomUUID();
   }
   metrics = {
     latency: {
@@ -11362,27 +11456,26 @@ var AxTestPrompt = class {
   async run(metricFn) {
     const st = (/* @__PURE__ */ new Date()).getTime();
     const total = this.examples.length;
-    let successCount = 0;
+    let sumOfScores = 0;
     for (let i = 0; i < total; i++) {
       const ex = this.examples[i];
       if (!ex) {
         throw new Error("Invalid example");
       }
       const res = await this.program.forward(this.ai, ex);
-      const success = metricFn({ prediction: res, example: ex });
-      if (success) {
-        successCount++;
-      }
+      const score = metricFn({ prediction: res, example: ex });
+      sumOfScores += score;
       const et = (/* @__PURE__ */ new Date()).getTime() - st;
-      updateProgressBar(i, total, successCount, et, "Testing Prompt", 30);
+      updateProgressBar(i, total, sumOfScores, et, "Testing Prompt", 30);
     }
+    const averageScore = total > 0 ? sumOfScores / total : 0;
     console.log(
       "\nPerformance: ",
-      successCount,
+      sumOfScores,
       "/",
       total,
-      "Accuracy: ",
-      successCount / total,
+      "Average Score: ",
+      averageScore,
       "\n"
     );
   }
@@ -11396,7 +11489,8 @@ var AxChainOfThought = class extends AxGen {
     sig.setOutputFields([
       {
         name: "reason",
-        description
+        description,
+        isInternal: options?.setVisibleReasoning !== true
       },
       ...sig.getOutputFields()
     ]);
@@ -12725,7 +12819,7 @@ function normalizeText(s) {
   return s.toLowerCase();
 }
 function emScore(prediction, groundTruth) {
-  return normalizeText(prediction) === normalizeText(groundTruth);
+  return normalizeText(prediction) === normalizeText(groundTruth) ? 1 : 0;
 }
 function f1Score(prediction, groundTruth) {
   const predictionTokens = normalizeText(prediction).split(" ");
@@ -12765,12 +12859,12 @@ var AxEvalUtil = {
 };
 
 // ../../node_modules/uuid/dist/esm-node/rng.js
-var import_crypto2 = __toESM(require("crypto"));
+var import_crypto5 = __toESM(require("crypto"));
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
-    import_crypto2.default.randomFillSync(rnds8Pool);
+    import_crypto5.default.randomFillSync(rnds8Pool);
     poolPtr = 0;
   }
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -12786,9 +12880,9 @@ function unsafeStringify(arr, offset = 0) {
 }
 
 // ../../node_modules/uuid/dist/esm-node/native.js
-var import_crypto3 = __toESM(require("crypto"));
+var import_crypto6 = __toESM(require("crypto"));
 var native_default = {
-  randomUUID: import_crypto3.default.randomUUID
+  randomUUID: import_crypto6.default.randomUUID
 };
 
 // ../../node_modules/uuid/dist/esm-node/v4.js