@ax-llm/ax 11.0.50 → 11.0.51

package/index.js

@@ -1,4 +1,5 @@
 // ai/base.ts
+import crypto2 from "crypto";
 import { context, SpanKind } from "@opentelemetry/api";
 
 // trace/trace.ts
@@ -66,6 +67,7 @@ var AxSpanKindValues = /* @__PURE__ */ ((AxSpanKindValues2) => {
 })(AxSpanKindValues || {});
 
 // util/apicall.ts
+import crypto from "crypto";
 import {
   ReadableStream as ReadableStream2,
   TextDecoderStream as TextDecoderStreamNative,
@@ -748,7 +750,7 @@ var AxBaseAI = class {
     this.tracer = options.tracer;
     this.modelInfo = modelInfo;
     this.models = models;
-    this.id = crypto.randomUUID();
+    this.id = crypto2.randomUUID();
     const model = this.getModel(defaults.model) ?? defaults.model;
     const embedModel = this.getEmbedModel(defaults.embedModel) ?? defaults.embedModel;
     this.defaults = { model, embedModel };
@@ -2097,6 +2099,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;
@@ -3158,6 +3163,9 @@ var AxAIGoogleGeminiImpl = class {
     }
     if (config.thinkingTokenBudget) {
       switch (config.thinkingTokenBudget) {
+        case "none":
+          thinkingConfig.thinkingBudget = 0;
+          break;
         case "minimal":
           thinkingConfig.thinkingBudget = 200;
           break;
@@ -5753,16 +5761,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
@@ -5797,7 +5809,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;
@@ -5817,14 +5828,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 = [];
@@ -5868,8 +5938,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)}`
@@ -5895,7 +5965,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";
@@ -5915,11 +5985,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;
     }
@@ -5956,20 +6023,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;
@@ -5992,24 +6059,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;
@@ -6109,7 +6176,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.`);
@@ -7563,12 +7630,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 ?? [];
@@ -7740,7 +7813,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(
@@ -7782,8 +7857,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(
@@ -7883,7 +7960,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);
@@ -7920,16 +7997,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;
@@ -8791,7 +8881,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++;
@@ -10779,19 +10870,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
@@ -10803,19 +10895,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
@@ -10987,10 +11080,11 @@ ${dataContext}
 };
 
 // ai/mock/api.ts
+import crypto3 from "crypto";
 var AxMockAIService = class {
   constructor(config = {}) {
     this.config = config;
-    this.config.id = this.config.id ?? crypto.randomUUID();
+    this.config.id = this.config.id ?? crypto3.randomUUID();
   }
   metrics = {
     latency: {
@@ -11201,27 +11295,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"
     );
   }
@@ -11235,7 +11328,8 @@ var AxChainOfThought = class extends AxGen {
     sig.setOutputFields([
       {
         name: "reason",
-        description
+        description,
+        isInternal: options?.setVisibleReasoning !== true
       },
       ...sig.getOutputFields()
     ]);
@@ -12564,7 +12658,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(" ");
@@ -12604,12 +12698,12 @@ var AxEvalUtil = {
 };
 
 // ../../node_modules/uuid/dist/esm-node/rng.js
-import crypto2 from "crypto";
+import crypto4 from "crypto";
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
-    crypto2.randomFillSync(rnds8Pool);
+    crypto4.randomFillSync(rnds8Pool);
     poolPtr = 0;
   }
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -12625,9 +12719,9 @@ function unsafeStringify(arr, offset = 0) {
 }
 
 // ../../node_modules/uuid/dist/esm-node/native.js
-import crypto3 from "crypto";
+import crypto5 from "crypto";
 var native_default = {
-  randomUUID: crypto3.randomUUID
+  randomUUID: crypto5.randomUUID
 };
 
 // ../../node_modules/uuid/dist/esm-node/v4.js