@ax-llm/ax 11.0.26 → 11.0.28

package/index.cjs

@@ -85,6 +85,7 @@ __export(index_exports, {
   AxDefaultResultReranker: () => AxDefaultResultReranker,
   AxDockerSession: () => AxDockerSession,
   AxEmbeddingAdapter: () => AxEmbeddingAdapter,
+  AxEvalUtil: () => AxEvalUtil,
   AxFunctionError: () => AxFunctionError,
   AxFunctionProcessor: () => AxFunctionProcessor,
   AxGen: () => AxGen,
@@ -97,6 +98,7 @@ __export(index_exports, {
   AxMCPHTTPTransport: () => AxMCPHTTPTransport,
   AxMCPStdioTransport: () => AxMCPStdioTransport,
   AxMemory: () => AxMemory,
+  AxMiPRO: () => AxMiPRO,
   AxMockAIService: () => AxMockAIService,
   AxMultiServiceRouter: () => AxMultiServiceRouter,
   AxProgram: () => AxProgram,
@@ -108,7 +110,48 @@ __export(index_exports, {
   AxSimpleClassifier: () => AxSimpleClassifier,
   AxSimpleClassifierClass: () => AxSimpleClassifierClass,
   AxSpanKindValues: () => AxSpanKindValues,
-  AxTestPrompt: () => AxTestPrompt
+  AxStringUtil: () => AxStringUtil,
+  AxTestPrompt: () => AxTestPrompt,
+  axAIAnthropicDefaultConfig: () => axAIAnthropicDefaultConfig,
+  axAIAzureOpenAIBestConfig: () => axAIAzureOpenAIBestConfig,
+  axAIAzureOpenAICreativeConfig: () => axAIAzureOpenAICreativeConfig,
+  axAIAzureOpenAIDefaultConfig: () => axAIAzureOpenAIDefaultConfig,
+  axAIAzureOpenAIFastConfig: () => axAIAzureOpenAIFastConfig,
+  axAICohereCreativeConfig: () => axAICohereCreativeConfig,
+  axAICohereDefaultConfig: () => axAICohereDefaultConfig,
+  axAIDeepSeekCodeConfig: () => axAIDeepSeekCodeConfig,
+  axAIDeepSeekDefaultConfig: () => axAIDeepSeekDefaultConfig,
+  axAIGoogleGeminiDefaultConfig: () => axAIGoogleGeminiDefaultConfig,
+  axAIGoogleGeminiDefaultCreativeConfig: () => axAIGoogleGeminiDefaultCreativeConfig,
+  axAIHuggingFaceCreativeConfig: () => axAIHuggingFaceCreativeConfig,
+  axAIHuggingFaceDefaultConfig: () => axAIHuggingFaceDefaultConfig,
+  axAIMistralBestConfig: () => axAIMistralBestConfig,
+  axAIMistralDefaultConfig: () => axAIMistralDefaultConfig,
+  axAIOllamaDefaultConfig: () => axAIOllamaDefaultConfig,
+  axAIOllamaDefaultCreativeConfig: () => axAIOllamaDefaultCreativeConfig,
+  axAIOpenAIBestConfig: () => axAIOpenAIBestConfig,
+  axAIOpenAICreativeConfig: () => axAIOpenAICreativeConfig,
+  axAIOpenAIDefaultConfig: () => axAIOpenAIDefaultConfig,
+  axAIOpenAIFastConfig: () => axAIOpenAIFastConfig,
+  axAIRekaBestConfig: () => axAIRekaBestConfig,
+  axAIRekaCreativeConfig: () => axAIRekaCreativeConfig,
+  axAIRekaDefaultConfig: () => axAIRekaDefaultConfig,
+  axAIRekaFastConfig: () => axAIRekaFastConfig,
+  axAITogetherDefaultConfig: () => axAITogetherDefaultConfig,
+  axBaseAIDefaultConfig: () => axBaseAIDefaultConfig,
+  axBaseAIDefaultCreativeConfig: () => axBaseAIDefaultCreativeConfig,
+  axModelInfoAnthropic: () => axModelInfoAnthropic,
+  axModelInfoCohere: () => axModelInfoCohere,
+  axModelInfoDeepSeek: () => axModelInfoDeepSeek,
+  axModelInfoGoogleGemini: () => axModelInfoGoogleGemini,
+  axModelInfoGroq: () => axModelInfoGroq,
+  axModelInfoHuggingFace: () => axModelInfoHuggingFace,
+  axModelInfoMistral: () => axModelInfoMistral,
+  axModelInfoOpenAI: () => axModelInfoOpenAI,
+  axModelInfoReka: () => axModelInfoReka,
+  axModelInfoTogether: () => axModelInfoTogether,
+  axSpanAttributes: () => axSpanAttributes,
+  axSpanEvents: () => axSpanEvents
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -151,6 +194,9 @@ var axSpanAttributes = {
   DB_QUERY_RESULT_VECTOR: "db.query.result.vector",
   DB_QUERY_RESULT_DOCUMENT: "db.query.result.document"
 };
+var axSpanEvents = {
+  LLM_PROMPT: "gen_ai.prompt"
+};
 var AxLLMRequestTypeValues = /* @__PURE__ */ ((AxLLMRequestTypeValues2) => {
   AxLLMRequestTypeValues2["COMPLETION"] = "completion";
   AxLLMRequestTypeValues2["CHAT"] = "chat";
@@ -806,6 +852,12 @@ var axBaseAIDefaultConfig = () => structuredClone({
   topK: 40,
   topP: 0.9
 });
+var axBaseAIDefaultCreativeConfig = () => structuredClone({
+  maxTokens: 2e3,
+  temperature: 0.4,
+  topP: 0.7,
+  frequencyPenalty: 0.2
+});
 var AxBaseAI = class {
   constructor(aiImpl, {
     name,
@@ -1847,6 +1899,19 @@ var axAIOpenAIDefaultConfig = () => structuredClone({
   embedModel: "text-embedding-3-small" /* TextEmbedding3Small */,
   ...axBaseAIDefaultConfig()
 });
+var axAIOpenAIBestConfig = () => structuredClone({
+  ...axAIOpenAIDefaultConfig(),
+  model: "gpt-4o" /* GPT4O */
+});
+var axAIOpenAICreativeConfig = () => structuredClone({
+  model: "gpt-4o" /* GPT4O */,
+  embedModel: "text-embedding-3-small" /* TextEmbedding3Small */,
+  ...axBaseAIDefaultCreativeConfig()
+});
+var axAIOpenAIFastConfig = () => ({
+  ...axAIOpenAIDefaultConfig(),
+  model: "gpt-4o-mini" /* GPT4OMini */
+});
 var AxAIOpenAIImpl = class {
   constructor(config, streamingUsage, dimensions) {
     this.config = config;
@@ -2152,6 +2217,9 @@ var AxAIOpenAI = class extends AxAIOpenAIBase {
 
 // ai/azure-openai/api.ts
 var axAIAzureOpenAIDefaultConfig = axAIOpenAIDefaultConfig;
+var axAIAzureOpenAICreativeConfig = axAIOpenAICreativeConfig;
+var axAIAzureOpenAIFastConfig = axAIOpenAIFastConfig;
+var axAIAzureOpenAIBestConfig = axAIOpenAIBestConfig;
 var AxAIAzureOpenAI = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -2268,6 +2336,11 @@ var axAICohereDefaultConfig = () => structuredClone({
   embedModel: "embed-english-v3.0" /* EmbedEnglishV30 */,
   ...axBaseAIDefaultConfig()
 });
+var axAICohereCreativeConfig = () => structuredClone({
+  model: "command-r" /* CommandR */,
+  embedModel: "embed-english-v3.0" /* EmbedEnglishV30 */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAICohereImpl = class {
   constructor(config) {
     this.config = config;
@@ -2544,6 +2617,10 @@ var axAIDeepSeekDefaultConfig = () => structuredClone({
   model: "deepseek-chat" /* DeepSeekChat */,
   ...axBaseAIDefaultConfig()
 });
+var axAIDeepSeekCodeConfig = () => structuredClone({
+  model: "deepseek-coder" /* DeepSeekCoder */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIDeepSeek = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -2691,6 +2768,12 @@ var axAIGoogleGeminiDefaultConfig = () => structuredClone({
   safetySettings,
   ...axBaseAIDefaultConfig()
 });
+var axAIGoogleGeminiDefaultCreativeConfig = () => structuredClone({
+  model: "gemini-2.0-flash" /* Gemini20Flash */,
+  embedModel: "text-embedding-004" /* TextEmbedding004 */,
+  safetySettings,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIGoogleGeminiImpl = class {
   constructor(config, isVertex, endpointId, apiKey, options) {
     this.config = config;
@@ -3202,6 +3285,10 @@ var axAIHuggingFaceDefaultConfig = () => structuredClone({
   model: "meta-llama/Llama-2-70b-chat-hf" /* MetaLlama270BChatHF */,
   ...axBaseAIDefaultConfig()
 });
+var axAIHuggingFaceCreativeConfig = () => structuredClone({
+  model: "meta-llama/Llama-2-70b-chat-hf" /* MetaLlama270BChatHF */,
+  ...axBaseAIDefaultCreativeConfig()
+});
 var AxAIHuggingFaceImpl = class {
   constructor(config) {
     this.config = config;
@@ -3383,6 +3470,10 @@ var axAIMistralDefaultConfig = () => structuredClone({
   model: "mistral-small-latest" /* MistralSmall */,
   ...axBaseAIDefaultConfig()
 });
+var axAIMistralBestConfig = () => structuredClone({
+  ...axAIMistralDefaultConfig(),
+  model: "mistral-large-latest" /* MistralLarge */
+});
 var AxAIMistral = class extends AxAIOpenAIBase {
   constructor({
     apiKey,
@@ -3415,6 +3506,11 @@ var axAIOllamaDefaultConfig = () => structuredClone({
   model: "nous-hermes2",
   embedModel: "all-minilm"
 });
+var axAIOllamaDefaultCreativeConfig = () => structuredClone({
+  ...axBaseAIDefaultCreativeConfig(),
+  model: "nous-hermes2",
+  embedModel: "all-minilm"
+});
 var AxAIOllama = class extends AxAIOpenAIBase {
   constructor({
     apiKey = "not-set",
@@ -3474,6 +3570,18 @@ var axAIRekaDefaultConfig = () => structuredClone({
   model: "reka-core" /* RekaCore */,
   ...axBaseAIDefaultConfig()
 });
+var axAIRekaBestConfig = () => structuredClone({
+  ...axAIRekaDefaultConfig(),
+  model: "reka-core" /* RekaCore */
+});
+var axAIRekaCreativeConfig = () => structuredClone({
+  model: "reka-core" /* RekaCore */,
+  ...axBaseAIDefaultCreativeConfig()
+});
+var axAIRekaFastConfig = () => ({
+  ...axAIRekaDefaultConfig(),
+  model: "reka-flash" /* RekaFlash */
+});
 var AxAIRekaImpl = class {
   constructor(config) {
     this.config = config;
@@ -4678,16 +4786,19 @@ var validateValue = (field, value) => {
 };
 function mergeProgramUsage(usages) {
   const usageMap = {};
-  usages.forEach((usage) => {
+  for (const usage of usages) {
     const key = `${usage.ai}:${usage.model}`;
     if (!usageMap[key]) {
       usageMap[key] = { ...usage };
-      return;
+      continue;
     }
-    usageMap[key].promptTokens += usage.promptTokens;
-    usageMap[key].completionTokens += usage.completionTokens;
-    usageMap[key].totalTokens += usage.totalTokens;
-  });
+    const currentUsage = usageMap[key];
+    if (currentUsage) {
+      currentUsage.promptTokens += usage.promptTokens;
+      currentUsage.completionTokens += usage.completionTokens;
+      currentUsage.totalTokens += usage.totalTokens;
+    }
+  }
   return Object.values(usageMap);
 }
 var parseMarkdownList = (input) => {
@@ -4708,7 +4819,6 @@ var parseMarkdownList = (input) => {
     } else if (numberedListRegex.test(trimmedLine)) {
       list.push(trimmedLine.replace(numberedListRegex, "").trim());
     } else if (list.length === 0) {
-      continue;
     } else {
       throw new Error("Could not parse markdown list: mixed content detected");
     }
@@ -4781,12 +4891,72 @@ function matchesContent(content, prefix, startIndex = 0, prefixCache = globalPre
   );
   for (let i = 0; i < prefixes.length - 1; i++) {
     const partialPrefix = prefixes[i];
-    if (contentEnd.endsWith(partialPrefix)) {
+    if (partialPrefix && contentEnd.endsWith(partialPrefix)) {
       return -2;
     }
   }
   return -1;
 }
+var formatTime = (ms) => {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+};
+var calculateETA = (current, total, elapsedMs) => {
+  if (current === 0) return "calculating...";
+  const msPerItem = elapsedMs / current;
+  const remainingItems = total - current;
+  const etaMs = msPerItem * remainingItems;
+  return formatTime(etaMs);
+};
+var updateDetailedProgress = (roundIndex, current, total, elapsedTime, example, stats, configInfo, result, error) => {
+  process.stdout.write("\r\x1B[K");
+  const percentage = (current / total * 100).toFixed(1);
+  const formattedTime = formatTime(elapsedTime);
+  const itemsPerSecond = elapsedTime > 0 ? (current / elapsedTime * 1e3).toFixed(2) : "0.00";
+  const eta = calculateETA(current, total, elapsedTime);
+  let output = `Round ${roundIndex + 1}/${configInfo.maxRounds}: ${current}/${total} (${percentage}%) [${formattedTime}, ${itemsPerSecond} it/s, ETA: ${eta}]`;
+  const successRate = stats.totalCalls > 0 ? stats.successfulDemos / stats.totalCalls * 100 : 0;
+  output += ` | Success: ${stats.successfulDemos}/${stats.totalCalls} (${successRate.toFixed(1)}%)`;
+  if (configInfo.verboseMode || configInfo.debugMode) {
+    if (configInfo.costMonitoring) {
+      output += `
+  Tokens: ~${stats.estimatedTokenUsage.toLocaleString()} total`;
+    }
+    output += `
+  Batch: ${Math.floor(current / configInfo.batchSize) + 1}/${Math.ceil(total / configInfo.batchSize)}`;
+    if (configInfo.earlyStoppingPatience > 0 && stats.earlyStopping) {
+      output += `
+  Best round: ${stats.earlyStopping.bestScoreRound + 1}, Patience: ${configInfo.earlyStoppingPatience}`;
+    }
+  }
+  if (configInfo.debugMode) {
+    const exampleKeys = Object.keys(example).map((k) => {
+      const valueStr = JSON.stringify(example[k]);
+      const truncated = valueStr.length > 30 ? `${valueStr.substring(0, 30)}...` : valueStr;
+      return `${k}: ${truncated}`;
+    }).join(", ");
+    output += `
+  Example: {${exampleKeys}}`;
+    if (error) {
+      output += `
+  ERROR: ${error.message}`;
+    } else if (result) {
+      const resultStr = JSON.stringify(result);
+      const truncatedResult = resultStr.length > 50 ? `${resultStr.substring(0, 50)}...` : resultStr;
+      output += `
+  Result: ${truncatedResult}`;
+    }
+    output += `
+  Temperature: ${(0.7 + 1e-3 * current).toFixed(3)}`;
+  }
+  console.log(output);
+};
 
 // dsp/program.ts
 var AxProgramWithSignature = class {
@@ -5028,7 +5198,7 @@ ${outputFields}`);
     demos
   }) => {
     const renderedExamples = examples ? [
-      { type: "text", text: "## Examples:\n" },
+      { type: "text", text: "\n\n## Examples\n" },
       ...this.renderExamples(examples)
     ] : [];
     const renderedDemos = demos ? this.renderDemos(demos) : [];
@@ -5111,6 +5281,9 @@ ${outputFields}`);
         );
       }
       const renderedItem = [...renderedInputItem, ...renderedOutputItem];
+      if (index > 0 && renderedItem.length > 0 && renderedItem[0]?.type === "text") {
+        list.push({ type: "text", text: "---\n\n" });
+      }
       renderedItem.forEach((v) => {
         if ("text" in v) {
           v.text = v.text + "\n";
@@ -5294,10 +5467,7 @@ var processValue = (field, value) => {
   if (typeof value === "string") {
     return value;
   }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  return JSON.stringify(value);
+  return JSON.stringify(value, null, 2);
 };
 var toFieldType = (type) => {
   const baseType = (() => {
@@ -7038,60 +7208,147 @@ function validateModels2(services) {
 // dsp/optimize.ts
 var AxBootstrapFewShot = class {
   ai;
+  teacherAI;
   program;
   examples;
   maxRounds;
   maxDemos;
   maxExamples;
+  batchSize;
+  earlyStoppingPatience;
+  costMonitoring;
+  maxTokensPerGeneration;
+  verboseMode;
+  debugMode;
   traces = [];
+  stats = {
+    totalCalls: 0,
+    successfulDemos: 0,
+    estimatedTokenUsage: 0,
+    earlyStopped: false
+  };
   constructor({
     ai,
     program,
     examples = [],
     options
   }) {
-    if (examples.length == 0) {
+    if (examples.length === 0) {
       throw new Error("No examples found");
     }
     this.maxRounds = options?.maxRounds ?? 3;
     this.maxDemos = options?.maxDemos ?? 4;
     this.maxExamples = options?.maxExamples ?? 16;
+    this.batchSize = options?.batchSize ?? 1;
+    this.earlyStoppingPatience = options?.earlyStoppingPatience ?? 0;
+    this.costMonitoring = options?.costMonitoring ?? false;
+    this.maxTokensPerGeneration = options?.maxTokensPerGeneration ?? 0;
+    this.verboseMode = options?.verboseMode ?? true;
+    this.debugMode = options?.debugMode ?? false;
     this.ai = ai;
+    this.teacherAI = options?.teacherAI;
     this.program = program;
     this.examples = examples;
   }
   async compileRound(roundIndex, metricFn, options) {
     const st = (/* @__PURE__ */ new Date()).getTime();
     const maxDemos = options?.maxDemos ?? this.maxDemos;
-    const aiOpt = { modelConfig: { temperature: 0.7 } };
+    const aiOpt = {
+      modelConfig: {
+        temperature: 0.7
+      }
+    };
+    if (this.maxTokensPerGeneration > 0) {
+      aiOpt.modelConfig.max_tokens = this.maxTokensPerGeneration;
+    }
     const examples = randomSample(this.examples, this.maxExamples);
-    for (let i = 0; i < examples.length; i++) {
+    const previousSuccessCount = this.traces.length;
+    for (let i = 0; i < examples.length; i += this.batchSize) {
       if (i > 0) {
         aiOpt.modelConfig.temperature = 0.7 + 1e-3 * i;
       }
-      const ex = examples[i];
-      if (!ex) {
-        throw new Error("Invalid example");
-      }
-      const exList = [...examples.slice(0, i), ...examples.slice(i + 1)];
-      this.program.setExamples(exList);
-      const res = await this.program.forward(this.ai, ex, aiOpt);
-      const success = metricFn({ prediction: res, example: ex });
-      if (success) {
-        this.traces = [...this.traces, ...this.program.getTraces()];
+      const batch = examples.slice(i, i + this.batchSize);
+      for (const ex of batch) {
+        if (!ex) {
+          continue;
+        }
+        const exList = examples.filter((e) => e !== ex);
+        this.program.setExamples(exList);
+        const aiService = this.teacherAI || this.ai;
+        this.stats.totalCalls++;
+        let res;
+        let error;
+        try {
+          res = await this.program.forward(aiService, ex, aiOpt);
+          if (this.costMonitoring) {
+            this.stats.estimatedTokenUsage += JSON.stringify(ex).length / 4 + JSON.stringify(res).length / 4;
+          }
+          const success = metricFn({ prediction: res, example: ex });
+          if (success) {
+            this.traces = [...this.traces, ...this.program.getTraces()];
+            this.stats.successfulDemos++;
+          }
+        } catch (err) {
+          error = err;
+          res = {};
+        }
+        const current = i + examples.length * roundIndex + (batch.indexOf(ex) + 1);
+        const total = examples.length * this.maxRounds;
+        const et = (/* @__PURE__ */ new Date()).getTime() - st;
+        if (this.verboseMode || this.debugMode) {
+          const configInfo = {
+            maxRounds: this.maxRounds,
+            batchSize: this.batchSize,
+            earlyStoppingPatience: this.earlyStoppingPatience,
+            costMonitoring: this.costMonitoring,
+            verboseMode: this.verboseMode,
+            debugMode: this.debugMode
+          };
+          updateDetailedProgress(
+            roundIndex,
+            current,
+            total,
+            et,
+            ex,
+            this.stats,
+            configInfo,
+            res,
+            error
+          );
+        } else {
+          updateProgressBar(
+            current,
+            total,
+            this.traces.length,
+            et,
+            "Tuning Prompt",
+            30
+          );
+        }
+        if (this.traces.length >= maxDemos) {
+          return;
+        }
       }
-      const current = i + examples.length * roundIndex;
-      const total = examples.length * this.maxRounds;
-      const et = (/* @__PURE__ */ new Date()).getTime() - st;
-      updateProgressBar(
-        current,
-        total,
-        this.traces.length,
-        et,
-        "Tuning Prompt",
-        30
-      );
-      if (this.traces.length > maxDemos) {
+    }
+    if (this.earlyStoppingPatience > 0) {
+      const newSuccessCount = this.traces.length;
+      const improvement = newSuccessCount - previousSuccessCount;
+      if (!this.stats.earlyStopping) {
+        this.stats.earlyStopping = {
+          bestScoreRound: improvement > 0 ? roundIndex : 0,
+          patienceExhausted: false
+        };
+      } else if (improvement > 0) {
+        this.stats.earlyStopping.bestScoreRound = roundIndex;
+      } else if (roundIndex - this.stats.earlyStopping.bestScoreRound >= this.earlyStoppingPatience) {
+        this.stats.earlyStopping.patienceExhausted = true;
+        this.stats.earlyStopped = true;
+        if (this.verboseMode || this.debugMode) {
+          console.log(
+            `
+Early stopping triggered after ${roundIndex + 1} rounds. No improvement for ${this.earlyStoppingPatience} rounds.`
+          );
+        }
         return;
       }
     }
@@ -7099,8 +7356,17 @@ var AxBootstrapFewShot = class {
   async compile(metricFn, options) {
     const maxRounds = options?.maxRounds ?? this.maxRounds;
     this.traces = [];
+    this.stats = {
+      totalCalls: 0,
+      successfulDemos: 0,
+      estimatedTokenUsage: 0,
+      earlyStopped: false
+    };
     for (let i = 0; i < maxRounds; i++) {
       await this.compileRound(i, metricFn, options);
+      if (this.stats.earlyStopped) {
+        break;
+      }
     }
     if (this.traces.length === 0) {
       throw new Error(
@@ -7108,22 +7374,32 @@ var AxBootstrapFewShot = class {
       );
     }
     const demos = groupTracesByKeys(this.traces);
-    return demos;
+    return {
+      demos,
+      stats: this.stats
+    };
+  }
+  // Get optimization statistics
+  getStats() {
+    return this.stats;
   }
 };
 function groupTracesByKeys(programTraces) {
   const groupedTraces = /* @__PURE__ */ new Map();
   for (const programTrace of programTraces) {
     if (groupedTraces.has(programTrace.programId)) {
-      groupedTraces.get(programTrace.programId).push(programTrace.trace);
+      const traces = groupedTraces.get(programTrace.programId);
+      if (traces) {
+        traces.push(programTrace.trace);
+      }
     } else {
       groupedTraces.set(programTrace.programId, [programTrace.trace]);
     }
   }
   const programDemosArray = [];
-  groupedTraces.forEach((traces, programId) => {
+  for (const [programId, traces] of groupedTraces.entries()) {
     programDemosArray.push({ traces, programId });
-  });
+  }
   return programDemosArray;
 }
 var randomSample = (array, n) => {
@@ -8243,6 +8519,639 @@ var AxJSInterpreter = class {
   }
 };
 
+// dsp/mipro.ts
+var AxMiPRO = class {
+  ai;
+  program;
+  examples;
+  maxBootstrappedDemos;
+  maxLabeledDemos;
+  numCandidates;
+  initTemperature;
+  numTrials;
+  minibatch;
+  minibatchSize;
+  minibatchFullEvalSteps;
+  programAwareProposer;
+  dataAwareProposer;
+  viewDataBatchSize;
+  tipAwareProposer;
+  fewshotAwareProposer;
+  seed;
+  verbose;
+  bootstrapper;
+  earlyStoppingTrials;
+  minImprovementThreshold;
+  constructor({
+    ai,
+    program,
+    examples = [],
+    options
+  }) {
+    if (examples.length === 0) {
+      throw new Error("No examples found");
+    }
+    const miproOptions = options || {};
+    this.numCandidates = miproOptions.numCandidates ?? 5;
+    this.initTemperature = miproOptions.initTemperature ?? 0.7;
+    this.maxBootstrappedDemos = miproOptions.maxBootstrappedDemos ?? 3;
+    this.maxLabeledDemos = miproOptions.maxLabeledDemos ?? 4;
+    this.numTrials = miproOptions.numTrials ?? 30;
+    this.minibatch = miproOptions.minibatch ?? true;
+    this.minibatchSize = miproOptions.minibatchSize ?? 25;
+    this.minibatchFullEvalSteps = miproOptions.minibatchFullEvalSteps ?? 10;
+    this.programAwareProposer = miproOptions.programAwareProposer ?? true;
+    this.dataAwareProposer = miproOptions.dataAwareProposer ?? true;
+    this.viewDataBatchSize = miproOptions.viewDataBatchSize ?? 10;
+    this.tipAwareProposer = miproOptions.tipAwareProposer ?? true;
+    this.fewshotAwareProposer = miproOptions.fewshotAwareProposer ?? true;
+    this.seed = miproOptions.seed;
+    this.verbose = miproOptions.verbose ?? false;
+    this.earlyStoppingTrials = miproOptions.earlyStoppingTrials ?? 5;
+    this.minImprovementThreshold = miproOptions.minImprovementThreshold ?? 0.01;
+    this.ai = ai;
+    this.program = program;
+    this.examples = examples;
+    this.bootstrapper = new AxBootstrapFewShot({
+      ai,
+      program,
+      examples,
+      options: {
+        maxDemos: this.maxBootstrappedDemos,
+        maxRounds: 3,
+        // Default, or adjust based on your needs
+        verboseMode: this.verbose
+      }
+    });
+  }
+  /**
+   * Configures the optimizer for light, medium, or heavy optimization
+   * @param level The optimization level: "light", "medium", or "heavy"
+   */
+  configureAuto(level) {
+    switch (level) {
+      case "light":
+        this.numCandidates = 3;
+        this.numTrials = 10;
+        this.minibatch = true;
+        this.minibatchSize = 20;
+        break;
+      case "medium":
+        this.numCandidates = 5;
+        this.numTrials = 20;
+        this.minibatch = true;
+        this.minibatchSize = 25;
+        break;
+      case "heavy":
+        this.numCandidates = 7;
+        this.numTrials = 30;
+        this.minibatch = true;
+        this.minibatchSize = 30;
+        break;
+    }
+  }
+  /**
+   * Generates creative tips for instruction generation
+   */
+  generateTips() {
+    return [
+      "Be very specific and detailed in your instructions.",
+      "Focus on step-by-step reasoning in your instructions.",
+      "Provide clear constraints and guidelines in your instructions.",
+      "Keep your instructions concise and to the point.",
+      "Emphasize accuracy and precision in your instructions.",
+      "Include examples of good outputs in your instructions.",
+      "Focus on handling edge cases in your instructions.",
+      "Explicitly outline the reasoning process in your instructions."
+    ];
+  }
+  /**
+   * Generates instruction candidates for each predictor in the program
+   * @returns Array of generated instruction candidates
+   */
+  async proposeInstructionCandidates() {
+    const instructions = [];
+    let programContext = "";
+    if (this.programAwareProposer) {
+      programContext = await this.generateProgramSummary();
+    }
+    let dataContext = "";
+    if (this.dataAwareProposer) {
+      dataContext = await this.generateDataSummary();
+    }
+    const tips = this.tipAwareProposer ? this.generateTips() : [];
+    for (let i = 0; i < this.numCandidates; i++) {
+      const tipIndex = tips.length > 0 ? i % tips.length : -1;
+      const tipToUse = tipIndex >= 0 ? tips[tipIndex] : "";
+      const instruction = await this.generateInstruction({
+        programContext,
+        dataContext,
+        tip: tipToUse,
+        candidateIndex: i
+      });
+      instructions.push(instruction);
+    }
+    return instructions;
+  }
+  /**
+   * Generates a summary of the program structure for instruction proposal
+   */
+  async generateProgramSummary() {
+    const prompt = `Summarize the following program structure. Focus on the signatures, 
+      input/output fields, and the purpose of each component. Identify key components 
+      that might benefit from better instructions.`;
+    const programStr = JSON.stringify(this.program);
+    const response = await this.ai.chat({
+      chatPrompt: [
+        { role: "system", content: prompt },
+        { role: "user", content: programStr }
+      ],
+      modelConfig: { temperature: 0.2 }
+    });
+    if (response instanceof ReadableStream) {
+      return "";
+    }
+    return response.results[0]?.content || "";
+  }
+  /**
+   * Generates a summary of the dataset for instruction proposal
+   */
+  async generateDataSummary() {
+    const sampleSize = Math.min(this.viewDataBatchSize, this.examples.length);
+    const sample = this.examples.slice(0, sampleSize);
+    const prompt = `Analyze the following dataset examples and provide a summary 
+      of key patterns, input-output relationships, and any specific challenges 
+      the data presents. Focus on what makes a good answer and what patterns should
+      be followed.`;
+    const dataStr = JSON.stringify(sample);
+    const response = await this.ai.chat({
+      chatPrompt: [
+        { role: "system", content: prompt },
+        { role: "user", content: dataStr }
+      ],
+      modelConfig: { temperature: 0.2 }
+    });
+    if (response instanceof ReadableStream) {
+      return "";
+    }
+    return response.results[0]?.content || "";
+  }
+  /**
+   * Generates a specific instruction candidate
+   */
+  async generateInstruction({
+    programContext,
+    dataContext,
+    tip,
+    candidateIndex
+  }) {
+    const prompt = `Create a high-quality instruction for an AI model performing the task described below.
+    
+    ${programContext ? `PROGRAM CONTEXT:
+${programContext}
+
+` : ""}
+    ${dataContext ? `DATA CONTEXT:
+${dataContext}
+
+` : ""}
+    ${tip ? `STYLE TIP: ${tip}
+
+` : ""}
+    
+    Your task is to craft a clear, effective instruction that will help the AI model generate
+    accurate outputs for this task. Instruction #${candidateIndex + 1}/${this.numCandidates}.
+    
+    The instruction should be detailed enough to guide the model but not overly prescriptive
+    or restrictive. Focus on what makes a good response rather than listing exact steps.
+    
+    INSTRUCTION:`;
+    const response = await this.ai.chat({
+      chatPrompt: [{ role: "user", content: prompt }],
+      modelConfig: { temperature: 0.7 + 0.1 * candidateIndex }
+    });
+    if (response instanceof ReadableStream) {
+      return "";
+    }
+    return response.results[0]?.content || "";
+  }
+  /**
+   * Bootstraps few-shot examples for the program
+   */
+  async bootstrapFewShotExamples(metricFn) {
+    if (this.verbose) {
+      console.log("Bootstrapping few-shot examples...");
+    }
+    const result = await this.bootstrapper.compile(metricFn, {
+      maxDemos: this.maxBootstrappedDemos
+    });
+    return result.demos;
+  }
+  /**
+   * Selects labeled examples directly from the training set
+   */
+  selectLabeledExamples() {
+    const selectedExamples = [];
+    const indices = /* @__PURE__ */ new Set();
+    while (indices.size < this.maxLabeledDemos && indices.size < this.examples.length) {
+      const idx = Math.floor(Math.random() * this.examples.length);
+      if (!indices.has(idx)) {
+        indices.add(idx);
+        const example = this.examples[idx];
+        if (example) {
+          selectedExamples.push(example);
+        }
+      }
+    }
+    return selectedExamples;
+  }
+  /**
+   * Runs Bayesian optimization to find the best combination of few-shot examples and instructions
+   */
+  async runBayesianOptimization(bootstrappedDemos, labeledExamples, instructions, valset, metricFn) {
+    let bestConfig = null;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    const evaluatedConfigs = [];
+    const defaultConfig = {
+      instruction: instructions[0] || "",
+      bootstrappedDemos: Math.min(1, bootstrappedDemos.length),
+      labeledExamples: Math.min(1, labeledExamples.length)
+    };
+    let trialsWithoutImprovement = 0;
+    let lastBestScore = Number.NEGATIVE_INFINITY;
+    const initialExplorationTrials = Math.min(
+      10,
+      Math.floor(this.numTrials / 3)
+    );
+    const configs = [];
+    for (let i = 0; i < initialExplorationTrials; i++) {
+      const instructionIndex = Math.floor(Math.random() * instructions.length);
+      const instructionValue = instructions[instructionIndex] || "";
+      const config = {
+        instruction: instructionValue,
+        bootstrappedDemos: Math.floor(
+          Math.random() * (bootstrappedDemos.length + 1)
+        ),
+        labeledExamples: Math.floor(
+          Math.random() * (labeledExamples.length + 1)
+        )
+      };
+      configs.push(config);
+    }
+    for (let i = 0; i < configs.length; i++) {
+      const config = configs[i];
+      if (!config) continue;
+      const score = await this.evaluateConfig(
+        config,
+        bootstrappedDemos,
+        labeledExamples,
+        valset,
+        metricFn,
+        i
+      );
+      evaluatedConfigs.push({ config, score });
+      if (score > bestScore) {
+        bestScore = score;
+        bestConfig = config;
+        if (this.verbose) {
+          console.log(
+            `New best configuration found with score ${bestScore} (exploration phase)`
+          );
+        }
+      }
+      updateProgressBar(
+        i + 1,
+        this.numTrials,
+        Math.round(bestScore * 100),
+        0,
+        "Running MIPROv2 optimization",
+        30
+      );
+    }
+    for (let i = configs.length; i < this.numTrials; i++) {
+      const nextConfig = this.selectNextConfiguration(
+        evaluatedConfigs,
+        bootstrappedDemos.length,
+        labeledExamples.length,
+        instructions
+      );
+      const score = await this.evaluateConfig(
+        nextConfig,
+        bootstrappedDemos,
+        labeledExamples,
+        valset,
+        metricFn,
+        i
+      );
+      evaluatedConfigs.push({ config: nextConfig, score });
+      if (score > bestScore) {
+        bestScore = score;
+        bestConfig = nextConfig;
+        if (this.verbose) {
+          console.log(
+            `New best configuration found with score ${bestScore} (exploitation phase)`
+          );
+        }
+        trialsWithoutImprovement = 0;
+        lastBestScore = bestScore;
+      } else {
+        if (bestScore - lastBestScore < this.minImprovementThreshold) {
+          trialsWithoutImprovement++;
+          if (trialsWithoutImprovement >= this.earlyStoppingTrials) {
+            if (this.verbose) {
+              console.log(
+                `Early stopping triggered after ${i + 1} trials. No improvement for ${trialsWithoutImprovement} trials.`
+              );
+            }
+            break;
+          }
+        } else {
+          lastBestScore = bestScore;
+          trialsWithoutImprovement = 0;
+        }
+      }
+      updateProgressBar(
+        i + 1,
+        this.numTrials,
+        Math.round(bestScore * 100),
+        0,
+        "Running MIPROv2 optimization",
+        30
+      );
+      if (this.minibatch && i > 0 && (i + 1) % this.minibatchFullEvalSteps === 0 && bestConfig) {
+        if (this.verbose) {
+          console.log(
+            `Running full evaluation on best configuration at trial ${i + 1}`
+          );
+        }
+        const fullScore = await this.fullEvaluation(
+          bestConfig,
+          bootstrappedDemos,
+          labeledExamples,
+          valset,
+          metricFn
+        );
+        if (this.verbose) {
+          console.log(`Full evaluation score: ${fullScore}`);
+        }
+        bestScore = fullScore;
+      }
+    }
+    if (!bestConfig) {
+      if (this.verbose) {
+        console.warn(
+          "Optimization failed to find any valid configurations, using default fallback configuration"
+        );
+      }
+      bestConfig = defaultConfig;
+      try {
+        bestScore = await this.evaluateConfig(
+          bestConfig,
+          bootstrappedDemos,
+          labeledExamples,
+          valset,
+          metricFn,
+          this.numTrials - 1
+        );
+      } catch (err) {
+        if (this.verbose) {
+          console.error("Error evaluating default configuration:", err);
+        }
+        bestScore = 0;
+      }
+    }
+    return { bestConfig, bestScore };
+  }
+  /**
+   * Evaluates a configuration on the validation set
+   */
+  async evaluateConfig(config, bootstrappedDemos, labeledExamples, valset, metricFn, trialIndex) {
+    this.applyConfigToProgram(
+      this.program,
+      config,
+      bootstrappedDemos,
+      labeledExamples
+    );
+    let evalSet = valset;
+    if (this.minibatch) {
+      const startIdx = trialIndex * this.minibatchSize % valset.length;
+      const minibatchEvalSet = [];
+      for (let j = 0; j < this.minibatchSize; j++) {
+        const idx = (startIdx + j) % valset.length;
+        const example = valset[idx];
+        if (example) {
+          minibatchEvalSet.push(example);
+        }
+      }
+      evalSet = minibatchEvalSet;
+    }
+    let correctCount = 0;
+    for (const example of evalSet) {
+      try {
+        const prediction = await this.program.forward(this.ai, example);
+        const correct = metricFn({ prediction, example });
+        if (correct) correctCount++;
+      } catch (err) {
+        if (this.verbose) {
+          console.error("Error evaluating example:", err);
+        }
+      }
+    }
+    return correctCount / evalSet.length;
+  }
+  /**
+   * Run full evaluation on the entire validation set
+   */
+  async fullEvaluation(config, bootstrappedDemos, labeledExamples, valset, metricFn) {
+    this.applyConfigToProgram(
+      this.program,
+      config,
+      bootstrappedDemos,
+      labeledExamples
+    );
+    let fullCorrectCount = 0;
+    for (const example of valset) {
+      try {
+        const prediction = await this.program.forward(this.ai, example);
+        const correct = metricFn({ prediction, example });
+        if (correct) fullCorrectCount++;
+      } catch (err) {
+        if (this.verbose) {
+          console.error("Error evaluating example:", err);
+        }
+      }
+    }
+    return fullCorrectCount / valset.length;
+  }
+  /**
+   * Implements a Bayesian-inspired selection of the next configuration to try
+   * This is a simplified version using Upper Confidence Bound (UCB) strategy
+   */
+  selectNextConfiguration(evaluatedConfigs, maxBootstrappedDemos, maxLabeledExamples, instructions) {
+    if (evaluatedConfigs.length < 5) {
+      const instructionIndex = Math.floor(Math.random() * instructions.length);
+      return {
+        instruction: instructions[instructionIndex] || "",
+        bootstrappedDemos: Math.floor(
+          Math.random() * (maxBootstrappedDemos + 1)
+        ),
+        labeledExamples: Math.floor(Math.random() * (maxLabeledExamples + 1))
+      };
+    }
+    const sortedConfigs = [...evaluatedConfigs].sort(
+      (a, b) => b.score - a.score
+    );
+    const topConfigs = sortedConfigs.slice(0, Math.min(3, sortedConfigs.length));
+    const meanBootstrappedDemos = topConfigs.reduce((sum, c) => sum + c.config.bootstrappedDemos, 0) / topConfigs.length;
+    const meanLabeledExamples = topConfigs.reduce((sum, c) => sum + c.config.labeledExamples, 0) / topConfigs.length;
+    const popularInstructions = topConfigs.map((c) => c.config.instruction);
+    const explorationFactor = Math.max(
+      0.2,
+      1 - evaluatedConfigs.length / this.numTrials
+    );
+    let newBootstrappedDemos;
+    let newLabeledExamples;
+    let newInstruction;
+    if (Math.random() < 0.7) {
+      newBootstrappedDemos = Math.min(
+        maxBootstrappedDemos,
+        Math.max(
+          0,
+          Math.round(
+            meanBootstrappedDemos + (Math.random() * 2 - 1) * explorationFactor * 2
+          )
+        )
+      );
+    } else {
+      newBootstrappedDemos = Math.floor(
+        Math.random() * (maxBootstrappedDemos + 1)
+      );
+    }
+    if (Math.random() < 0.7) {
+      newLabeledExamples = Math.min(
+        maxLabeledExamples,
+        Math.max(
+          0,
+          Math.round(
+            meanLabeledExamples + (Math.random() * 2 - 1) * explorationFactor * 2
+          )
+        )
+      );
+    } else {
+      newLabeledExamples = Math.floor(Math.random() * (maxLabeledExamples + 1));
+    }
+    if (Math.random() < 0.7 && popularInstructions.length > 0) {
+      const idx = Math.floor(Math.random() * popularInstructions.length);
+      newInstruction = popularInstructions[idx] || "";
+    } else {
+      const idx = Math.floor(Math.random() * instructions.length);
+      newInstruction = instructions[idx] || "";
+    }
+    return {
+      instruction: newInstruction,
+      bootstrappedDemos: newBootstrappedDemos,
+      labeledExamples: newLabeledExamples
+    };
+  }
+  /**
+   * Applies a configuration to a program instance
+   */
+  applyConfigToProgram(program, config, bootstrappedDemos, labeledExamples) {
+    this.setInstructionToProgram(program, config.instruction);
+    if (config.bootstrappedDemos > 0) {
+      program.setDemos(bootstrappedDemos.slice(0, config.bootstrappedDemos));
+    }
+    if (config.labeledExamples > 0) {
+      program.setExamples(labeledExamples.slice(0, config.labeledExamples));
+    }
+  }
+  /**
+   * Sets instruction to a program
+   * Note: Workaround since setInstruction may not be available directly
+   */
+  setInstructionToProgram(program, instruction) {
+    const programWithInstruction = program;
+    programWithInstruction.setInstruction?.(instruction);
+  }
+  /**
+   * The main compile method to run MIPROv2 optimization
+   * @param metricFn Evaluation metric function
+   * @param options Optional configuration options
+   * @returns The optimized program
+   */
+  async compile(metricFn, options) {
+    if (options?.auto) {
+      this.configureAuto(options.auto);
+    }
+    const trainset = this.examples;
+    const valset = options?.valset || this.examples.slice(0, Math.floor(this.examples.length * 0.8));
+    if (this.verbose) {
+      console.log(`Starting MIPROv2 optimization with ${this.numTrials} trials`);
+      console.log(
+        `Using ${trainset.length} examples for training and ${valset.length} for validation`
+      );
+    }
+    if (options?.teacher) {
+      if (this.verbose) {
+        console.log("Using provided teacher to assist with bootstrapping");
+      }
+      const bootstrapperWithTeacher = new AxBootstrapFewShot({
+        ai: this.ai,
+        program: this.program,
+        examples: this.examples,
+        options: {
+          maxDemos: this.maxBootstrappedDemos,
+          maxRounds: 3,
+          verboseMode: this.verbose,
+          teacherAI: this.ai
+          // Use the same AI but with the teacher program
+        }
+      });
+      this.bootstrapper = bootstrapperWithTeacher;
+    }
+    let bootstrappedDemos = [];
+    if (this.maxBootstrappedDemos > 0) {
+      bootstrappedDemos = await this.bootstrapFewShotExamples(metricFn);
+      if (this.verbose) {
+        console.log(
+          `Generated ${bootstrappedDemos.length} bootstrapped demonstrations`
+        );
+      }
+    }
+    let labeledExamples = [];
+    if (this.maxLabeledDemos > 0) {
+      labeledExamples = this.selectLabeledExamples();
+      if (this.verbose) {
+        console.log(
+          `Selected ${labeledExamples.length} labeled examples from training set`
+        );
+      }
+    }
+    const instructions = await this.proposeInstructionCandidates();
+    if (this.verbose) {
+      console.log(`Generated ${instructions.length} instruction candidates`);
+    }
+    const { bestConfig, bestScore } = await this.runBayesianOptimization(
+      bootstrappedDemos,
+      labeledExamples,
+      instructions,
+      valset,
+      metricFn
+    );
+    if (this.verbose) {
+      console.log(`Optimization complete. Best score: ${bestScore}`);
+      console.log(`Best configuration: ${JSON.stringify(bestConfig)}`);
+    }
+    this.applyConfigToProgram(
+      this.program,
+      bestConfig,
+      bootstrappedDemos,
+      labeledExamples
+    );
+    return this.program;
+  }
+};
+
 // ai/mock/api.ts
 var AxMockAIService = class {
   constructor(config = {}) {
@@ -8551,7 +9460,7 @@ var batchArray = (arr, size) => {
   }
   return chunkedArr;
 };
-var axStringUtil = {
+var AxStringUtil = {
   trimNonAlphaNum,
   splitIntoTwo,
   dedup,
@@ -8570,7 +9479,7 @@ var AxDefaultResultReranker = class extends AxGen {
   forward = async (ai, input, options) => {
     const { rankedItems } = await super.forward(ai, input, options);
     const sortedIndexes = rankedItems.map((item) => {
-      const { id: index } = axStringUtil.extractIdAndText(item);
+      const { id: index } = AxStringUtil.extractIdAndText(item);
       return index;
     });
     const sortedItems = input.items.map((_, index) => {
@@ -8625,6 +9534,1230 @@ var AxEmbeddingAdapter = class {
   }
 };
 
+// dsp/stopwords.ts
+var stopwords = /* @__PURE__ */ new Set([
+  "0o",
+  "0s",
+  "3a",
+  "3b",
+  "3d",
+  "6b",
+  "6o",
+  "a",
+  "a1",
+  "a2",
+  "a3",
+  "a4",
+  "ab",
+  "able",
+  "about",
+  "above",
+  "abst",
+  "ac",
+  "accordance",
+  "according",
+  "accordingly",
+  "across",
+  "act",
+  "actually",
+  "ad",
+  "added",
+  "adj",
+  "ae",
+  "af",
+  "affected",
+  "affecting",
+  "affects",
+  "after",
+  "afterwards",
+  "ag",
+  "again",
+  "against",
+  "ah",
+  "ain",
+  "ain't",
+  "aj",
+  "al",
+  "all",
+  "allow",
+  "allows",
+  "almost",
+  "alone",
+  "along",
+  "already",
+  "also",
+  "although",
+  "always",
+  "am",
+  "among",
+  "amongst",
+  "amoungst",
+  "amount",
+  "an",
+  "and",
+  "announce",
+  "another",
+  "any",
+  "anybody",
+  "anyhow",
+  "anymore",
+  "anyone",
+  "anything",
+  "anyway",
+  "anyways",
+  "anywhere",
+  "ao",
+  "ap",
+  "apart",
+  "apparently",
+  "appear",
+  "appreciate",
+  "appropriate",
+  "approximately",
+  "ar",
+  "are",
+  "aren",
+  "arent",
+  "aren't",
+  "arise",
+  "around",
+  "as",
+  "a's",
+  "aside",
+  "ask",
+  "asking",
+  "associated",
+  "at",
+  "au",
+  "auth",
+  "av",
+  "available",
+  "aw",
+  "away",
+  "awfully",
+  "ax",
+  "ay",
+  "az",
+  "b",
+  "b1",
+  "b2",
+  "b3",
+  "ba",
+  "back",
+  "bc",
+  "bd",
+  "be",
+  "became",
+  "because",
+  "become",
+  "becomes",
+  "becoming",
+  "been",
+  "before",
+  "beforehand",
+  "begin",
+  "beginning",
+  "beginnings",
+  "begins",
+  "behind",
+  "being",
+  "believe",
+  "below",
+  "beside",
+  "besides",
+  "best",
+  "better",
+  "between",
+  "beyond",
+  "bi",
+  "bill",
+  "biol",
+  "bj",
+  "bk",
+  "bl",
+  "bn",
+  "both",
+  "bottom",
+  "bp",
+  "br",
+  "brief",
+  "briefly",
+  "bs",
+  "bt",
+  "bu",
+  "but",
+  "bx",
+  "by",
+  "c",
+  "c1",
+  "c2",
+  "c3",
+  "ca",
+  "call",
+  "came",
+  "can",
+  "cannot",
+  "cant",
+  "can't",
+  "cause",
+  "causes",
+  "cc",
+  "cd",
+  "ce",
+  "certain",
+  "certainly",
+  "cf",
+  "cg",
+  "ch",
+  "changes",
+  "ci",
+  "cit",
+  "cj",
+  "cl",
+  "clearly",
+  "cm",
+  "c'mon",
+  "cn",
+  "co",
+  "com",
+  "come",
+  "comes",
+  "con",
+  "concerning",
+  "consequently",
+  "consider",
+  "considering",
+  "contain",
+  "containing",
+  "contains",
+  "corresponding",
+  "could",
+  "couldn",
+  "couldnt",
+  "couldn't",
+  "course",
+  "cp",
+  "cq",
+  "cr",
+  "cry",
+  "cs",
+  "c's",
+  "ct",
+  "cu",
+  "currently",
+  "cv",
+  "cx",
+  "cy",
+  "cz",
+  "d",
+  "d2",
+  "da",
+  "date",
+  "dc",
+  "dd",
+  "de",
+  "definitely",
+  "describe",
+  "described",
+  "despite",
+  "detail",
+  "df",
+  "di",
+  "did",
+  "didn",
+  "didn't",
+  "different",
+  "dj",
+  "dk",
+  "dl",
+  "do",
+  "does",
+  "doesn",
+  "doesn't",
+  "doing",
+  "don",
+  "done",
+  "don't",
+  "down",
+  "downwards",
+  "dp",
+  "dr",
+  "ds",
+  "dt",
+  "du",
+  "due",
+  "during",
+  "dx",
+  "dy",
+  "e",
+  "e2",
+  "e3",
+  "ea",
+  "each",
+  "ec",
+  "ed",
+  "edu",
+  "ee",
+  "ef",
+  "effect",
+  "eg",
+  "ei",
+  "eight",
+  "eighty",
+  "either",
+  "ej",
+  "el",
+  "eleven",
+  "else",
+  "elsewhere",
+  "em",
+  "empty",
+  "en",
+  "end",
+  "ending",
+  "enough",
+  "entirely",
+  "eo",
+  "ep",
+  "eq",
+  "er",
+  "es",
+  "especially",
+  "est",
+  "et",
+  "et-al",
+  "etc",
+  "eu",
+  "ev",
+  "even",
+  "ever",
+  "every",
+  "everybody",
+  "everyone",
+  "everything",
+  "everywhere",
+  "ex",
+  "exactly",
+  "example",
+  "except",
+  "ey",
+  "f",
+  "f2",
+  "fa",
+  "far",
+  "fc",
+  "few",
+  "ff",
+  "fi",
+  "fifteen",
+  "fifth",
+  "fify",
+  "fill",
+  "find",
+  "fire",
+  "first",
+  "five",
+  "fix",
+  "fj",
+  "fl",
+  "fn",
+  "fo",
+  "followed",
+  "following",
+  "follows",
+  "for",
+  "former",
+  "formerly",
+  "forth",
+  "forty",
+  "found",
+  "four",
+  "fr",
+  "from",
+  "front",
+  "node:fs",
+  "ft",
+  "fu",
+  "full",
+  "further",
+  "furthermore",
+  "fy",
+  "g",
+  "ga",
+  "gave",
+  "ge",
+  "get",
+  "gets",
+  "getting",
+  "gi",
+  "give",
+  "given",
+  "gives",
+  "giving",
+  "gj",
+  "gl",
+  "go",
+  "goes",
+  "going",
+  "gone",
+  "got",
+  "gotten",
+  "gr",
+  "greetings",
+  "gs",
+  "gy",
+  "h",
+  "h2",
+  "h3",
+  "had",
+  "hadn",
+  "hadn't",
+  "happens",
+  "hardly",
+  "has",
+  "hasn",
+  "hasnt",
+  "hasn't",
+  "have",
+  "haven",
+  "haven't",
+  "having",
+  "he",
+  "hed",
+  "he'd",
+  "he'll",
+  "hello",
+  "help",
+  "hence",
+  "her",
+  "here",
+  "hereafter",
+  "hereby",
+  "herein",
+  "heres",
+  "here's",
+  "hereupon",
+  "hers",
+  "herself",
+  "hes",
+  "he's",
+  "hh",
+  "hi",
+  "hid",
+  "him",
+  "himself",
+  "his",
+  "hither",
+  "hj",
+  "ho",
+  "home",
+  "hopefully",
+  "how",
+  "howbeit",
+  "however",
+  "how's",
+  "hr",
+  "hs",
+  "http",
+  "hu",
+  "hundred",
+  "hy",
+  "i",
+  "i2",
+  "i3",
+  "i4",
+  "i6",
+  "i7",
+  "i8",
+  "ia",
+  "ib",
+  "ibid",
+  "ic",
+  "id",
+  "i'd",
+  "ie",
+  "if",
+  "ig",
+  "ignored",
+  "ih",
+  "ii",
+  "ij",
+  "il",
+  "i'll",
+  "im",
+  "i'm",
+  "immediate",
+  "immediately",
+  "importance",
+  "important",
+  "in",
+  "inasmuch",
+  "inc",
+  "indeed",
+  "index",
+  "indicate",
+  "indicated",
+  "indicates",
+  "information",
+  "inner",
+  "insofar",
+  "instead",
+  "interest",
+  "into",
+  "invention",
+  "inward",
+  "io",
+  "ip",
+  "iq",
+  "ir",
+  "is",
+  "isn",
+  "isn't",
+  "it",
+  "itd",
+  "it'd",
+  "it'll",
+  "its",
+  "it's",
+  "itself",
+  "iv",
+  "i've",
+  "ix",
+  "iy",
+  "iz",
+  "j",
+  "jj",
+  "jr",
+  "js",
+  "jt",
+  "ju",
+  "just",
+  "k",
+  "ke",
+  "keep",
+  "keeps",
+  "kept",
+  "kg",
+  "kj",
+  "km",
+  "know",
+  "known",
+  "knows",
+  "ko",
+  "l",
+  "l2",
+  "la",
+  "largely",
+  "last",
+  "lately",
+  "later",
+  "latter",
+  "latterly",
+  "lb",
+  "lc",
+  "le",
+  "least",
+  "les",
+  "less",
+  "lest",
+  "let",
+  "lets",
+  "let's",
+  "lf",
+  "like",
+  "liked",
+  "likely",
+  "line",
+  "little",
+  "lj",
+  "ll",
+  "ll",
+  "ln",
+  "lo",
+  "look",
+  "looking",
+  "looks",
+  "los",
+  "lr",
+  "ls",
+  "lt",
+  "ltd",
+  "m",
+  "m2",
+  "ma",
+  "made",
+  "mainly",
+  "make",
+  "makes",
+  "many",
+  "may",
+  "maybe",
+  "me",
+  "mean",
+  "means",
+  "meantime",
+  "meanwhile",
+  "merely",
+  "mg",
+  "might",
+  "mightn",
+  "mightn't",
+  "mill",
+  "million",
+  "mine",
+  "miss",
+  "ml",
+  "mn",
+  "mo",
+  "more",
+  "moreover",
+  "most",
+  "mostly",
+  "move",
+  "mr",
+  "mrs",
+  "ms",
+  "mt",
+  "mu",
+  "much",
+  "mug",
+  "must",
+  "mustn",
+  "mustn't",
+  "my",
+  "myself",
+  "model",
+  "n",
+  "n2",
+  "na",
+  "name",
+  "namely",
+  "nay",
+  "nc",
+  "nd",
+  "ne",
+  "near",
+  "nearly",
+  "necessarily",
+  "necessary",
+  "need",
+  "needn",
+  "needn't",
+  "needs",
+  "neither",
+  "never",
+  "nevertheless",
+  "new",
+  "next",
+  "ng",
+  "ni",
+  "nine",
+  "ninety",
+  "nj",
+  "nl",
+  "nn",
+  "no",
+  "nobody",
+  "non",
+  "none",
+  "nonetheless",
+  "noone",
+  "nor",
+  "normally",
+  "nos",
+  "not",
+  "noted",
+  "nothing",
+  "novel",
+  "now",
+  "nowhere",
+  "nr",
+  "ns",
+  "nt",
+  "ny",
+  "o",
+  "oa",
+  "ob",
+  "obtain",
+  "obtained",
+  "obviously",
+  "oc",
+  "od",
+  "of",
+  "off",
+  "often",
+  "og",
+  "oh",
+  "oi",
+  "oj",
+  "ok",
+  "okay",
+  "ol",
+  "old",
+  "om",
+  "omitted",
+  "on",
+  "once",
+  "one",
+  "ones",
+  "only",
+  "onto",
+  "oo",
+  "op",
+  "oq",
+  "or",
+  "ord",
+  "os",
+  "ot",
+  "other",
+  "others",
+  "otherwise",
+  "ou",
+  "ought",
+  "our",
+  "ours",
+  "ourselves",
+  "out",
+  "outside",
+  "over",
+  "overall",
+  "ow",
+  "owing",
+  "own",
+  "ox",
+  "oz",
+  "p",
+  "p1",
+  "p2",
+  "p3",
+  "page",
+  "pagecount",
+  "pages",
+  "par",
+  "part",
+  "particular",
+  "particularly",
+  "pas",
+  "past",
+  "pc",
+  "pd",
+  "pe",
+  "per",
+  "perhaps",
+  "pf",
+  "ph",
+  "pi",
+  "pj",
+  "pk",
+  "pl",
+  "placed",
+  "please",
+  "plus",
+  "pm",
+  "pn",
+  "po",
+  "poorly",
+  "possible",
+  "possibly",
+  "potentially",
+  "pp",
+  "pq",
+  "pr",
+  "predominantly",
+  "present",
+  "presumably",
+  "previously",
+  "primarily",
+  "probably",
+  "promptly",
+  "proud",
+  "provides",
+  "ps",
+  "pt",
+  "pu",
+  "put",
+  "py",
+  "q",
+  "qj",
+  "qu",
+  "que",
+  "quickly",
+  "quite",
+  "qv",
+  "r",
+  "r2",
+  "ra",
+  "ran",
+  "rather",
+  "rc",
+  "rd",
+  "re",
+  "readily",
+  "really",
+  "reasonably",
+  "recent",
+  "recently",
+  "ref",
+  "refs",
+  "regarding",
+  "regardless",
+  "regards",
+  "related",
+  "relatively",
+  "research",
+  "research-articl",
+  "respectively",
+  "resulted",
+  "resulting",
+  "results",
+  "rf",
+  "rh",
+  "ri",
+  "right",
+  "rj",
+  "rl",
+  "rm",
+  "rn",
+  "ro",
+  "rq",
+  "rr",
+  "rs",
+  "rt",
+  "ru",
+  "run",
+  "rv",
+  "ry",
+  "s",
+  "s2",
+  "sa",
+  "said",
+  "same",
+  "saw",
+  "say",
+  "saying",
+  "says",
+  "sc",
+  "sd",
+  "se",
+  "sec",
+  "second",
+  "secondly",
+  "section",
+  "see",
+  "seeing",
+  "seem",
+  "seemed",
+  "seeming",
+  "seems",
+  "seen",
+  "self",
+  "selves",
+  "sensible",
+  "sent",
+  "serious",
+  "seriously",
+  "seven",
+  "several",
+  "sf",
+  "shall",
+  "shan",
+  "shan't",
+  "she",
+  "shed",
+  "she'd",
+  "she'll",
+  "shes",
+  "she's",
+  "should",
+  "shouldn",
+  "shouldn't",
+  "should've",
+  "show",
+  "showed",
+  "shown",
+  "showns",
+  "shows",
+  "si",
+  "side",
+  "significant",
+  "significantly",
+  "similar",
+  "similarly",
+  "since",
+  "sincere",
+  "six",
+  "sixty",
+  "sj",
+  "sl",
+  "slightly",
+  "sm",
+  "sn",
+  "so",
+  "some",
+  "somebody",
+  "somehow",
+  "someone",
+  "somethan",
+  "something",
+  "sometime",
+  "sometimes",
+  "somewhat",
+  "somewhere",
+  "soon",
+  "sorry",
+  "sp",
+  "specifically",
+  "specified",
+  "specify",
+  "specifying",
+  "sq",
+  "sr",
+  "ss",
+  "st",
+  "still",
+  "stop",
+  "strongly",
+  "sub",
+  "substantially",
+  "successfully",
+  "such",
+  "sufficiently",
+  "suggest",
+  "sup",
+  "sure",
+  "sy",
+  "system",
+  "sz",
+  "t",
+  "t1",
+  "t2",
+  "t3",
+  "take",
+  "taken",
+  "taking",
+  "tb",
+  "tc",
+  "td",
+  "te",
+  "tell",
+  "ten",
+  "tends",
+  "tf",
+  "th",
+  "than",
+  "thank",
+  "thanks",
+  "thanx",
+  "that",
+  "that'll",
+  "thats",
+  "that's",
+  "that've",
+  "the",
+  "their",
+  "theirs",
+  "them",
+  "themselves",
+  "then",
+  "thence",
+  "there",
+  "thereafter",
+  "thereby",
+  "thered",
+  "therefore",
+  "therein",
+  "there'll",
+  "thereof",
+  "therere",
+  "theres",
+  "there's",
+  "thereto",
+  "thereupon",
+  "there've",
+  "these",
+  "they",
+  "theyd",
+  "they'd",
+  "they'll",
+  "theyre",
+  "they're",
+  "they've",
+  "thickv",
+  "thin",
+  "think",
+  "third",
+  "this",
+  "thorough",
+  "thoroughly",
+  "those",
+  "thou",
+  "though",
+  "thoughh",
+  "thousand",
+  "three",
+  "throug",
+  "through",
+  "throughout",
+  "thru",
+  "thus",
+  "ti",
+  "til",
+  "tip",
+  "tj",
+  "tl",
+  "tm",
+  "tn",
+  "to",
+  "together",
+  "too",
+  "took",
+  "top",
+  "toward",
+  "towards",
+  "tp",
+  "tq",
+  "tr",
+  "tried",
+  "tries",
+  "truly",
+  "try",
+  "trying",
+  "ts",
+  "t's",
+  "tt",
+  "tv",
+  "twelve",
+  "twenty",
+  "twice",
+  "two",
+  "tx",
+  "u",
+  "u201d",
+  "ue",
+  "ui",
+  "uj",
+  "uk",
+  "um",
+  "un",
+  "under",
+  "unfortunately",
+  "unless",
+  "unlike",
+  "unlikely",
+  "until",
+  "unto",
+  "uo",
+  "up",
+  "upon",
+  "ups",
+  "ur",
+  "us",
+  "use",
+  "used",
+  "useful",
+  "usefully",
+  "usefulness",
+  "uses",
+  "using",
+  "usually",
+  "ut",
+  "v",
+  "va",
+  "value",
+  "various",
+  "vd",
+  "ve",
+  "ve",
+  "very",
+  "via",
+  "viz",
+  "vj",
+  "vo",
+  "vol",
+  "vols",
+  "volumtype",
+  "vq",
+  "vs",
+  "vt",
+  "vu",
+  "w",
+  "wa",
+  "want",
+  "wants",
+  "was",
+  "wasn",
+  "wasnt",
+  "wasn't",
+  "way",
+  "we",
+  "wed",
+  "we'd",
+  "welcome",
+  "well",
+  "we'll",
+  "well-b",
+  "went",
+  "were",
+  "we're",
+  "weren",
+  "werent",
+  "weren't",
+  "we've",
+  "what",
+  "whatever",
+  "what'll",
+  "whats",
+  "what's",
+  "when",
+  "whence",
+  "whenever",
+  "when's",
+  "where",
+  "whereafter",
+  "whereas",
+  "whereby",
+  "wherein",
+  "wheres",
+  "where's",
+  "whereupon",
+  "wherever",
+  "whether",
+  "which",
+  "while",
+  "whim",
+  "whither",
+  "who",
+  "whod",
+  "whoever",
+  "whole",
+  "who'll",
+  "whom",
+  "whomever",
+  "whos",
+  "who's",
+  "whose",
+  "why",
+  "why's",
+  "wi",
+  "widely",
+  "will",
+  "willing",
+  "wish",
+  "with",
+  "within",
+  "without",
+  "wo",
+  "won",
+  "wonder",
+  "wont",
+  "won't",
+  "words",
+  "world",
+  "would",
+  "wouldn",
+  "wouldnt",
+  "wouldn't",
+  "www",
+  "x",
+  "x1",
+  "x2",
+  "x3",
+  "xf",
+  "xi",
+  "xj",
+  "xk",
+  "xl",
+  "xn",
+  "xo",
+  "xs",
+  "xt",
+  "xv",
+  "xx",
+  "y",
+  "y2",
+  "yes",
+  "yet",
+  "yj",
+  "yl",
+  "you",
+  "youd",
+  "you'd",
+  "you'll",
+  "your",
+  "youre",
+  "you're",
+  "yours",
+  "yourself",
+  "yourselves",
+  "you've",
+  "yr",
+  "ys",
+  "yt",
+  "z",
+  "zero",
+  "zi",
+  "zz",
+  "task"
+]);
+
+// dsp/eval.ts
+function filterTokens(tokens, exclusions) {
+  return tokens.filter((token) => !exclusions.has(token));
+}
+function countTokens(tokens) {
+  const counter = {};
+  for (const token of tokens) {
+    counter[token] = (counter[token] || 0) + 1;
+  }
+  return counter;
+}
+function normalizeText(s) {
+  s = s.normalize("NFD");
+  s = s.replace(/\b(a|an|the)\b/g, " ");
+  s = s.split(/\s+/).join(" ");
+  s = s.replace(/[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]/g, "");
+  return s.toLowerCase();
+}
+function emScore(prediction, groundTruth) {
+  return normalizeText(prediction) === normalizeText(groundTruth);
+}
+function f1Score(prediction, groundTruth) {
+  const predictionTokens = normalizeText(prediction).split(" ");
+  const groundTruthTokens = normalizeText(groundTruth).split(" ");
+  const predictionCounts = countTokens(predictionTokens);
+  const groundTruthCounts = countTokens(groundTruthTokens);
+  let numSame = 0;
+  for (const token in predictionCounts) {
+    const v1 = predictionCounts[token] ?? 0;
+    const v2 = groundTruthCounts[token] ?? 0;
+    numSame += Math.min(v1, v2);
+  }
+  if (numSame === 0) {
+    return 0;
+  }
+  const precision = numSame / predictionTokens.length;
+  const recall = numSame / groundTruthTokens.length;
+  return 2 * precision * recall / (precision + recall);
+}
+function novelF1ScoreOptimized(history, prediction, groundTruth, returnRecall = false) {
+  const historyTokens = normalizeText(history).split(" ");
+  let predictionTokens = normalizeText(prediction).split(" ");
+  let groundTruthTokens = normalizeText(groundTruth).split(" ");
+  const exclusions = /* @__PURE__ */ new Set([...stopwords, ...historyTokens]);
+  predictionTokens = filterTokens(predictionTokens, exclusions);
+  groundTruthTokens = filterTokens(groundTruthTokens, exclusions);
+  const numSame = 0;
+  const precision = numSame / predictionTokens.length;
+  const recall = numSame / groundTruthTokens.length;
+  const f1 = 2 * precision * recall / (precision + recall);
+  return returnRecall ? recall : f1;
+}
+var AxEvalUtil = {
+  emScore,
+  f1Score,
+  novelF1ScoreOptimized
+};
+
 // ../../node_modules/uuid/dist/esm-node/rng.js
 var import_crypto2 = __toESM(require("crypto"));
 var rnds8Pool = new Uint8Array(256);
@@ -9121,7 +11254,7 @@ var AxRAG = class extends AxChainOfThought {
         options
       );
       const val = await this.queryFn(query);
-      context = axStringUtil.dedup([...context, val]);
+      context = AxStringUtil.dedup([...context, val]);
     }
     return super.forward(ai, { context, question }, options);
   }
@@ -9183,6 +11316,7 @@ var AxRAG = class extends AxChainOfThought {
   AxDefaultResultReranker,
   AxDockerSession,
   AxEmbeddingAdapter,
+  AxEvalUtil,
   AxFunctionError,
   AxFunctionProcessor,
   AxGen,
@@ -9195,6 +11329,7 @@ var AxRAG = class extends AxChainOfThought {
   AxMCPHTTPTransport,
   AxMCPStdioTransport,
   AxMemory,
+  AxMiPRO,
   AxMockAIService,
   AxMultiServiceRouter,
   AxProgram,
@@ -9206,6 +11341,47 @@ var AxRAG = class extends AxChainOfThought {
   AxSimpleClassifier,
   AxSimpleClassifierClass,
   AxSpanKindValues,
-  AxTestPrompt
+  AxStringUtil,
+  AxTestPrompt,
+  axAIAnthropicDefaultConfig,
+  axAIAzureOpenAIBestConfig,
+  axAIAzureOpenAICreativeConfig,
+  axAIAzureOpenAIDefaultConfig,
+  axAIAzureOpenAIFastConfig,
+  axAICohereCreativeConfig,
+  axAICohereDefaultConfig,
+  axAIDeepSeekCodeConfig,
+  axAIDeepSeekDefaultConfig,
+  axAIGoogleGeminiDefaultConfig,
+  axAIGoogleGeminiDefaultCreativeConfig,
+  axAIHuggingFaceCreativeConfig,
+  axAIHuggingFaceDefaultConfig,
+  axAIMistralBestConfig,
+  axAIMistralDefaultConfig,
+  axAIOllamaDefaultConfig,
+  axAIOllamaDefaultCreativeConfig,
+  axAIOpenAIBestConfig,
+  axAIOpenAICreativeConfig,
+  axAIOpenAIDefaultConfig,
+  axAIOpenAIFastConfig,
+  axAIRekaBestConfig,
+  axAIRekaCreativeConfig,
+  axAIRekaDefaultConfig,
+  axAIRekaFastConfig,
+  axAITogetherDefaultConfig,
+  axBaseAIDefaultConfig,
+  axBaseAIDefaultCreativeConfig,
+  axModelInfoAnthropic,
+  axModelInfoCohere,
+  axModelInfoDeepSeek,
+  axModelInfoGoogleGemini,
+  axModelInfoGroq,
+  axModelInfoHuggingFace,
+  axModelInfoMistral,
+  axModelInfoOpenAI,
+  axModelInfoReka,
+  axModelInfoTogether,
+  axSpanAttributes,
+  axSpanEvents
 });
 //# sourceMappingURL=index.cjs.map