@ax-llm/ax 12.0.7 → 12.0.9

package/index.cjs

@@ -81,6 +81,7 @@ __export(index_exports, {
   AxAssertionError: () => AxAssertionError,
   AxBalancer: () => AxBalancer,
   AxBaseAI: () => AxBaseAI,
+  AxBaseOptimizer: () => AxBaseOptimizer,
   AxBootstrapFewShot: () => AxBootstrapFewShot,
   AxChainOfThought: () => AxChainOfThought,
   AxDB: () => AxDB,
@@ -90,6 +91,7 @@ __export(index_exports, {
   AxDBMemory: () => AxDBMemory,
   AxDBPinecone: () => AxDBPinecone,
   AxDBWeaviate: () => AxDBWeaviate,
+  AxDefaultCostTracker: () => AxDefaultCostTracker,
   AxDefaultQueryRewriter: () => AxDefaultQueryRewriter,
   AxDefaultResultReranker: () => AxDefaultResultReranker,
   AxDockerSession: () => AxDockerSession,
@@ -159,6 +161,10 @@ __export(index_exports, {
   axAITogetherDefaultConfig: () => axAITogetherDefaultConfig,
   axBaseAIDefaultConfig: () => axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig: () => axBaseAIDefaultCreativeConfig,
+  axCreateDefaultLogger: () => axCreateDefaultLogger,
+  axCreateDefaultTextLogger: () => axCreateDefaultTextLogger,
+  axCreateOptimizerLogger: () => axCreateOptimizerLogger,
+  axDefaultOptimizerLogger: () => axDefaultOptimizerLogger,
   axGlobals: () => axGlobals,
   axModelInfoAnthropic: () => axModelInfoAnthropic,
   axModelInfoCohere: () => axModelInfoCohere,
@@ -494,6 +500,17 @@ var AxAIServiceAuthenticationError = class extends AxAIServiceError {
     this.name = this.constructor.name;
   }
 };
+async function safeReadResponseBody(response) {
+  try {
+    if (response.headers.get("content-type")?.includes("application/json")) {
+      return await response.json();
+    }
+    const clonedResponse = response.clone();
+    return await clonedResponse.text();
+  } catch (e) {
+    return `[ReadableStream - read failed: ${e.message}]`;
+  }
+}
 function calculateRetryDelay(attempt, config) {
   const delay = Math.min(
     config.maxDelayMs,
@@ -587,9 +604,15 @@ var apiCall = async (api, json) => {
       });
       clearTimeout(timeoutId);
       if (res.status === 401 || res.status === 403) {
-        throw new AxAIServiceAuthenticationError(apiUrl.href, json, res.body, {
-          metrics
-        });
+        const responseBody = await safeReadResponseBody(res);
+        throw new AxAIServiceAuthenticationError(
+          apiUrl.href,
+          json,
+          responseBody,
+          {
+            metrics
+          }
+        );
       }
       if (res.status >= 400 && shouldRetry(new Error(), res.status, attempt, retryConfig)) {
         const delay = calculateRetryDelay(attempt, retryConfig);
@@ -607,12 +630,13 @@ var apiCall = async (api, json) => {
         continue;
       }
       if (res.status >= 400) {
+        const responseBody = await safeReadResponseBody(res);
         throw new AxAIServiceStatusError(
           res.status,
           res.statusText,
           apiUrl.href,
           json,
-          res.body,
+          responseBody,
           { metrics }
         );
       }
@@ -710,7 +734,7 @@ var apiCall = async (api, json) => {
                     error,
                     apiUrl.href,
                     json,
-                    res.body,
+                    "[ReadableStream - consumed during streaming]",
                     {
                       streamMetrics
                     }
@@ -839,12 +863,12 @@ var ColorLog = class {
   }
 };
 
-// ai/debug.ts
+// dsp/loggers.ts
 var colorLog = new ColorLog();
 var defaultOutput = (message) => {
   process.stdout.write(message);
 };
-var createDefaultLogger = (output = defaultOutput) => {
+var axCreateDefaultLogger = (output = defaultOutput) => {
   return (message, options) => {
     const tags = options?.tags ?? [];
     let formattedMessage = message;
@@ -853,12 +877,44 @@ var createDefaultLogger = (output = defaultOutput) => {
     } else if (tags.includes("success") || tags.includes("responseContent")) {
       formattedMessage = colorLog.greenBright(formattedMessage);
     } else if (tags.includes("functionName")) {
-      formattedMessage = colorLog.whiteBright(formattedMessage);
-    } else if (tags.includes("functionArg") || tags.includes("systemContent") || tags.includes("assistantContent")) {
+      if (tags.includes("firstFunction")) {
+        formattedMessage = `
+${colorLog.whiteBright(formattedMessage)}`;
+      } else {
+        formattedMessage = `${colorLog.whiteBright(formattedMessage)}`;
+      }
+    } else if (tags.includes("systemContent") || tags.includes("assistantContent")) {
       formattedMessage = colorLog.blueBright(formattedMessage);
     } else if (tags.includes("warning") || tags.includes("discovery")) {
       formattedMessage = colorLog.yellow(formattedMessage);
+    } else if (tags.includes("functionArg")) {
+      formattedMessage = "";
+    }
+    if (tags.includes("responseStart") || tags.includes("systemStart") || tags.includes("userStart")) {
+      formattedMessage = `
+${formattedMessage}`;
+    } else if (tags.includes("responseEnd") || tags.includes("systemEnd") || tags.includes("userEnd")) {
+      formattedMessage = `${formattedMessage}
+`;
+    } else if (tags.includes("assistantStart")) {
+      formattedMessage = `
+${formattedMessage}
+`;
+    } else if (tags.includes("error")) {
+      formattedMessage = `
+${formattedMessage}
+`;
+    } else if (tags.includes("functionEnd")) {
+      formattedMessage = `
+`;
     }
+    output(formattedMessage);
+  };
+};
+var axCreateDefaultTextLogger = (output = defaultOutput) => {
+  return (message, options) => {
+    const tags = options?.tags ?? [];
+    let formattedMessage = message;
     if (tags.includes("responseStart") || tags.includes("systemStart") || tags.includes("userStart")) {
       formattedMessage = `
 ${formattedMessage}`;
@@ -880,7 +936,137 @@ ${formattedMessage}
     output(formattedMessage);
   };
 };
-var defaultLogger = createDefaultLogger();
+var axCreateOptimizerLogger = (output = (msg) => process.stdout.write(msg)) => {
+  const baseLogger = axCreateDefaultLogger(output);
+  let isFirstPhase = true;
+  return (message, options) => {
+    const tags = options?.tags ?? [];
+    let formattedMessage = message;
+    if (tags.includes("optimizer")) {
+      if (tags.includes("start")) {
+        const trialsMatch = message.match(/with (\d+) trials?/) || message.match(/(\d+) trials?/);
+        const optimizerMatch = message.match(
+          /(MIPROv2|BootstrapFewshot|[A-Z][a-zA-Z]+)/
+        );
+        const optimizerName = optimizerMatch ? optimizerMatch[1] : "Optimizer";
+        if (trialsMatch && trialsMatch[1]) {
+          formattedMessage = `
+\u250C\u2500 ${optimizerName} optimization (${trialsMatch[1]} trials)
+`;
+        } else {
+          formattedMessage = `
+\u250C\u2500 ${optimizerName} optimization
+`;
+        }
+        isFirstPhase = true;
+      } else if (tags.includes("config")) {
+        if (message.includes("examples") && message.includes("training")) {
+          const match = message.match(
+            /(\d+) examples for training and (\d+) for validation/
+          ) || message.match(/(\d+) training.*?(\d+) validation/);
+          if (match && match[1] && match[2]) {
+            formattedMessage = `\u2502  Dataset: ${match[1]} training, ${match[2]} validation
+`;
+          } else {
+            const simpleMatch = message.match(/(\d+) examples/);
+            if (simpleMatch && simpleMatch[1]) {
+              formattedMessage = `\u2502  Dataset: ${simpleMatch[1]} examples
+`;
+            }
+          }
+        } else if (message.includes("teacher")) {
+          formattedMessage = `\u2502  Using teacher model
+`;
+        } else {
+          formattedMessage = `\u2502  ${message}
+`;
+        }
+      } else if (tags.includes("phase")) {
+        if (isFirstPhase) {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+          isFirstPhase = false;
+        } else {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+        }
+      } else if (tags.includes("result")) {
+        if (message.includes("Generated") || message.includes("Selected")) {
+          const match = message.match(/(\d+)/);
+          if (match && match[1]) {
+            formattedMessage = `\u2502  \u2713 ${message}
+`;
+          } else {
+            formattedMessage = `\u2502  \u2713 ${message}
+`;
+          }
+        } else if (message.includes("configuration")) {
+          formattedMessage = `\u2502  Applied best configuration
+`;
+        } else {
+          formattedMessage = `\u2502  ${message}
+`;
+        }
+      } else if (tags.includes("progress")) {
+        formattedMessage = `\u2502  ${message}
+`;
+      } else if (tags.includes("complete")) {
+        const scoreMatch = message.match(/(score|performance):\s*([\d.]+)/);
+        if (scoreMatch && scoreMatch[2]) {
+          const score = parseFloat(scoreMatch[2]);
+          const percentage = score <= 1 ? (score * 100).toFixed(1) + "%" : score.toFixed(3);
+          formattedMessage = `\u251C\u2500 Complete! Best: ${percentage}
+`;
+        } else if (message.includes("Bootstrap")) {
+          formattedMessage = `\u251C\u2500 ${message}
+`;
+        } else {
+          formattedMessage = `\u251C\u2500 Optimization complete
+`;
+        }
+      } else if (tags.includes("checkpoint")) {
+        if (message.includes("Resuming")) {
+          formattedMessage = `\u2502  ${message}
+`;
+        } else {
+          const match = message.match(/checkpoint:\s*(.+)/) || message.match(/Saved\s+(.+)/);
+          if (match && match[1]) {
+            formattedMessage = `\u2514\u2500 Saved: ${match[1]}
+`;
+          } else {
+            formattedMessage = `\u2514\u2500 Checkpoint saved
+`;
+          }
+        }
+      }
+    } else if (tags.includes("discovery")) {
+      if (message.includes("Found") && message.includes("examples")) {
+        const match = message.match(/Found (\d+)/);
+        if (match && match[1]) {
+          formattedMessage = `\u2502  Found ${match[1]} examples
+`;
+        }
+      }
+    }
+    if (tags.includes("error")) {
+      formattedMessage = `
+\u2717 ${message}
+`;
+    } else if (tags.includes("warning")) {
+      formattedMessage = `
+\u26A0 ${message}
+`;
+    } else if (tags.includes("success") && !tags.includes("optimizer")) {
+      formattedMessage = `\u2713 ${message}
+`;
+    }
+    baseLogger(formattedMessage, options);
+  };
+};
+var axDefaultOptimizerLogger = axCreateOptimizerLogger();
+
+// ai/debug.ts
+var defaultLogger = axCreateDefaultLogger();
 var formatChatMessage = (msg, hideContent, hideSystemPrompt) => {
   switch (msg.role) {
     case "system":
@@ -957,9 +1143,14 @@ var logResponseResult = (r, logger = defaultLogger) => {
   if (r.functionCalls && r.functionCalls.length > 0) {
     for (const [i, f2] of r.functionCalls.entries()) {
       if (f2.function.name) {
-        logger(`[${i + 1}] ${f2.function.name}`, {
-          tags: ["functionName"]
-        });
+        const tags = ["functionName"];
+        if (i === 0) {
+          tags.push("firstFunction");
+        }
+        if (r.functionCalls.length > 1) {
+          tags.push("multipleFunctions");
+        }
+        logger(`[${i + 1}] ${f2.function.name}`, { tags });
       }
       if (f2.function.params) {
         const params = typeof f2.function.params === "string" ? f2.function.params : JSON.stringify(f2.function.params, null, 2);
@@ -1630,6 +1821,16 @@ function validateAxMessageArray(values) {
 function validateChatPrompt(chatPrompt) {
   for (let i = 0; i < chatPrompt.length; i++) {
     const message = chatPrompt[i];
+    if (message && "functionCalls" in message && Array.isArray(message.functionCalls) && message.functionCalls.length === 0) {
+      throw new Error(
+        `Chat prompt validation failed: Message at index ${i} has empty functionCalls`
+      );
+    }
+    if (message && "content" in message && Array.isArray(message.content) && message.content.length === 0) {
+      throw new Error(
+        `Chat prompt validation failed: Message at index ${i} has empty content`
+      );
+    }
     if (message && "content" in message && typeof message.content === "string" && message.content.trim() === "") {
       throw new Error(
         `Chat prompt validation failed: Message at index ${i} has empty content`
@@ -5953,9 +6154,11 @@ var updateProgressBar = (current, total, success, elapsedTime, msg, progressBarW
   const emptyBarLength = progressBarWidth - filledBarLength;
   const filledBar = colorLog3.blueBright("\u2588".repeat(filledBarLength));
   const emptyBar = " ".repeat(emptyBarLength);
-  const itemsPerSecond = elapsedTime > 0 ? (current / elapsedTime).toFixed(2) : "0.00";
+  const successRate = total > 0 ? (success / total * 100).toFixed(1) : "0.0";
+  const friendlyMsg = msg.includes("Running MIPROv2 optimization") ? "Testing prompt variations" : msg.includes("Tuning Prompt") ? "Generating training examples" : msg;
   process.stdout.write(
-    `\r${msg}: ${current} / ${total} (${colorLog3.yellow(percentage)}%): 100%|${filledBar}${emptyBar}| Success: ${success}/${total} [${colorLog3.red(elapsedTime.toFixed(2))}, ${itemsPerSecond}it/s]`
+    `\u2502  ${friendlyMsg}: ${current}/${total} (${colorLog3.yellow(percentage)}%) |${filledBar}${emptyBar}| Success rate: ${colorLog3.greenBright(successRate)}%
+`
   );
 };
 var validateValue = (field, value) => {
@@ -6162,19 +6365,15 @@ function matchesContent(content, prefix, startIndex = 0, prefixCache = globalPre
   if (!prefixCache.get(prefix)) {
     prefixCache.set(prefix, prefixes);
   }
-  const contentEnd = content.slice(
-    Math.max(startIndex, content.length - prefix.length)
-  );
-  for (let i = 0; i < prefixes.length - 1; i++) {
+  let longestPartialMatch = -1;
+  for (let i = prefixes.length - 1; i >= 0; i--) {
     const partialPrefix = prefixes[i];
-    if (partialPrefix === "\n" || partialPrefix === ":") {
-      continue;
-    }
-    if (partialPrefix && contentEnd.endsWith(partialPrefix)) {
-      return -2;
+    if (content.endsWith(partialPrefix)) {
+      longestPartialMatch = i;
+      break;
     }
   }
-  return -1;
+  return longestPartialMatch >= 0 ? -2 : -1;
 }
 var formatTime = (ms) => {
   const seconds = Math.floor(ms / 1e3);
@@ -6197,11 +6396,10 @@ var updateDetailedProgress = (roundIndex, current, total, elapsedTime, example,
   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}]`;
+  let output = `Training round ${roundIndex + 1}/${configInfo.maxRounds}: ${current}/${total} (${percentage}%) [${formattedTime}, ETA: ${eta}]`;
   const successRate = stats.totalCalls > 0 ? stats.successfulDemos / stats.totalCalls * 100 : 0;
-  output += ` | Success: ${stats.successfulDemos}/${stats.totalCalls} (${successRate.toFixed(1)}%)`;
+  output += ` | Success rate: ${successRate.toFixed(1)}% (${stats.successfulDemos}/${stats.totalCalls})`;
   if (configInfo.verboseMode || configInfo.debugMode) {
     if (configInfo.costMonitoring) {
       output += `
@@ -6327,7 +6525,7 @@ ${outputFields}`);
       content: systemContent
     };
     if (Array.isArray(values)) {
-      let userMessages = [];
+      let messages = [];
       const history = values;
       for (const [index, message] of history.entries()) {
         let content;
@@ -6347,7 +6545,7 @@ ${outputFields}`);
           );
         }
         if (message.role === "user") {
-          userMessages.push({ role: "user", content });
+          messages.push({ role: "user", content });
           continue;
         }
         if (message.role !== "assistant") {
@@ -6358,9 +6556,9 @@ ${outputFields}`);
             "Assistant message cannot contain non-text content like images, files,etc"
           );
         }
-        userMessages.push({ role: "assistant", content });
+        messages.push({ role: "assistant", content });
       }
-      return [systemPrompt, ...userMessages];
+      return [systemPrompt, ...messages];
     }
     const userContent = this.renderSingleValueUserContent(
       values,
@@ -6813,9 +7011,9 @@ var formatDateWithTimezone = (date) => {
 };
 
 // dsp/extract.ts
-var extractValues = (sig, values, content) => {
+var extractValues = (sig, values, content, strictMode = false) => {
   const xstate = { extractedFields: [], streamedIndex: {}, s: -1 };
-  streamingExtractValues(sig, values, xstate, content);
+  streamingExtractValues(sig, values, xstate, content, strictMode);
   streamingExtractFinalValue(sig, values, xstate, content);
   for (const field of sig.getOutputFields()) {
     if (field.isInternal) {
@@ -6823,10 +7021,9 @@ var extractValues = (sig, values, content) => {
     }
   }
 };
-var checkMissingRequiredFields = (xstate, values, currentIndex) => {
+var checkMissingRequiredFields = (xstate, values, outputFields) => {
   const missingFields = [];
-  for (let i = 0; i < currentIndex; i++) {
-    const field = xstate.extractedFields[i];
+  for (const field of outputFields) {
     if (field && !field.isOptional && values[field.name] === void 0) {
       missingFields.push(field);
     }
@@ -6838,23 +7035,34 @@ var checkMissingRequiredFields = (xstate, values, currentIndex) => {
     });
   }
 };
-var streamingExtractValues = (sig, values, xstate, content, streamingValidation = false) => {
+var streamingExtractValues = (sig, values, xstate, content, strictMode = false) => {
   const fields = sig.getOutputFields();
+  let expectedField;
   for (const [index, field] of fields.entries()) {
+    if (index === xstate.currFieldIndex) {
+      continue;
+    }
     if (field.name in values) {
       continue;
     }
     const isFirst = xstate.extractedFields.length === 0;
     const prefix = (isFirst ? "" : "\n") + field.title + ":";
     let e = matchesContent(content, prefix, xstate.s);
+    let prefixLen = prefix.length;
     switch (e) {
       case -1:
-        if (streamingValidation && values.length == 0 && !field.isOptional) {
+        if (!strictMode && fields.length === 1 && xstate.currField === void 0) {
+          prefixLen = 0;
+          e = 0;
+          break;
+        }
+        if (xstate.currField === void 0 && !field.isOptional) {
           throw new ValidationError({
-            message: "Required field not found",
+            message: "Expected (Required) field not found",
             fields: [field]
           });
         }
+        expectedField = field.isOptional ? void 0 : field;
         continue;
       // Field is not found, continue to the next field
       case -2:
@@ -6867,7 +7075,12 @@ var streamingExtractValues = (sig, values, xstate, content, streamingValidation
         xstate.inBlock = true;
         return true;
     }
-    let prefixLen = prefix.length;
+    if (expectedField && expectedField.name !== field.name) {
+      throw new ValidationError({
+        message: "Expected (Required) field not found",
+        fields: [expectedField]
+      });
+    }
     if (xstate.currField) {
       const val = content.substring(xstate.s, e).trim();
       const parsedValue = validateAndParseFieldValue(xstate.currField, val);
@@ -6880,7 +7093,6 @@ var streamingExtractValues = (sig, values, xstate, content, streamingValidation
         xstate.prevFields = [{ field: xstate.currField, s: xstate.s, e }];
       }
     }
-    checkMissingRequiredFields(xstate, values, index);
     xstate.s = e + prefixLen;
     xstate.currField = field;
     xstate.currFieldIndex = index;
@@ -6900,8 +7112,7 @@ var streamingExtractFinalValue = (sig, values, xstate, content) => {
       values[xstate.currField.name] = parsedValue;
     }
   }
-  const sigFields = sig.getOutputFields();
-  checkMissingRequiredFields(xstate, values, sigFields.length);
+  checkMissingRequiredFields(xstate, values, sig.getOutputFields());
 };
 var convertValueToType = (field, val, required = false) => {
   switch (field.type?.name) {
@@ -7538,8 +7749,9 @@ var AxInstanceRegistry = class {
     this.reg.add(instance);
   }
   *[Symbol.iterator]() {
-    for (const key of this.reg) {
-      yield key;
+    const items = Array.from(this.reg);
+    for (let i = 0; i < items.length; i++) {
+      yield items[i];
     }
   }
 };
@@ -8477,7 +8689,7 @@ var AxSignature = class _AxSignature {
       this.getOutputFields().forEach((field) => {
         validateField(field, "output");
       });
-      this.sigHash = (0, import_crypto3.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(JSON.stringify(this.inputFields)).update(JSON.stringify(this.outputFields)).digest("hex");
       this.sigString = renderSignature(
         this.description,
         this.inputFields,
@@ -8798,7 +9010,7 @@ var AxProgramWithSignature = class {
     this.signature.validate();
     this.sigHash = this.signature?.hash();
     this.children = new AxInstanceRegistry();
-    this.key = { id: this.constructor.name };
+    this.key = { id: this.signature.hash() };
   }
   getSignature() {
     return this.signature;
@@ -8818,8 +9030,8 @@ var AxProgramWithSignature = class {
   }
   setId(id) {
     this.key = { id, custom: true };
-    for (const child of this.children) {
-      child.setParentId(id);
+    for (const child of Array.from(this.children)) {
+      child?.setParentId(id);
     }
   }
   setParentId(parentId) {
@@ -8832,8 +9044,8 @@ var AxProgramWithSignature = class {
     if (!("programId" in examples)) {
       return;
     }
-    for (const child of this.children) {
-      child.setExamples(examples, options);
+    for (const child of Array.from(this.children)) {
+      child?.setExamples(examples, options);
     }
   }
   _setExamples(examples, options) {
@@ -8866,30 +9078,37 @@ var AxProgramWithSignature = class {
     if (this.trace) {
       traces.push({ trace: this.trace, programId: this.key.id });
     }
-    for (const child of this.children) {
-      const _traces = child.getTraces();
-      traces = [...traces, ..._traces];
+    for (const child of Array.from(this.children)) {
+      const _traces = child?.getTraces();
+      traces = [...traces, ..._traces ?? []];
     }
     return traces;
   }
   getUsage() {
     let usage = [...this.usage ?? []];
-    for (const child of this.children) {
-      const cu = child.getUsage();
-      usage = [...usage, ...cu];
+    for (const child of Array.from(this.children)) {
+      const cu = child?.getUsage();
+      usage = [...usage, ...cu ?? []];
     }
     return mergeProgramUsage(usage);
   }
   resetUsage() {
     this.usage = [];
-    for (const child of this.children) {
-      child.resetUsage();
+    for (const child of Array.from(this.children)) {
+      child?.resetUsage();
     }
   }
   setDemos(demos) {
+    const hasChildren = Array.from(this.children).length > 0;
+    const hasMatchingDemo = demos.some((demo) => demo.programId === this.key.id);
+    if (hasChildren && !hasMatchingDemo) {
+      throw new Error(
+        `Program with id '${this.key.id}' has children but no matching programId found in demos`
+      );
+    }
     this.demos = demos.filter((v) => v.programId === this.key.id).map((v) => v.traces).flat();
-    for (const child of this.children) {
-      child.setDemos(demos);
+    for (const child of Array.from(this.children)) {
+      child?.setDemos(demos);
     }
   }
 };
@@ -8917,8 +9136,8 @@ var AxProgram = class {
   }
   setId(id) {
     this.key = { id, custom: true };
-    for (const child of this.children) {
-      child.setParentId(id);
+    for (const child of Array.from(this.children)) {
+      child?.setParentId(id);
     }
   }
   setParentId(parentId) {
@@ -8930,8 +9149,8 @@ var AxProgram = class {
     if (!("programId" in examples)) {
       return;
     }
-    for (const child of this.children) {
-      child.setExamples(examples, options);
+    for (const child of Array.from(this.children)) {
+      child?.setExamples(examples, options);
     }
   }
   getTraces() {
@@ -8939,29 +9158,36 @@ var AxProgram = class {
     if (this.trace) {
       traces.push({ trace: this.trace, programId: this.key.id });
     }
-    for (const child of this.children) {
-      const _traces = child.getTraces();
-      traces = [...traces, ..._traces];
+    for (const child of Array.from(this.children)) {
+      const _traces = child?.getTraces();
+      traces = [...traces, ..._traces ?? []];
     }
     return traces;
   }
   getUsage() {
     let usage = [...this.usage ?? []];
-    for (const child of this.children) {
-      const cu = child.getUsage();
-      usage = [...usage, ...cu];
+    for (const child of Array.from(this.children)) {
+      const cu = child?.getUsage();
+      usage = [...usage, ...cu ?? []];
     }
     return mergeProgramUsage(usage);
   }
   resetUsage() {
     this.usage = [];
-    for (const child of this.children) {
-      child.resetUsage();
+    for (const child of Array.from(this.children)) {
+      child?.resetUsage();
     }
   }
   setDemos(demos) {
-    for (const child of this.children) {
-      child.setDemos(demos);
+    const hasChildren = Array.from(this.children).length > 0;
+    const hasMatchingDemo = demos.some((demo) => demo.programId === this.key.id);
+    if (hasChildren && !hasMatchingDemo) {
+      throw new Error(
+        `Program with id '${this.key.id}' has children but no matching programId found in demos`
+      );
+    }
+    for (const child of Array.from(this.children)) {
+      child?.setDemos(demos);
     }
   }
 };
@@ -9089,7 +9315,7 @@ var AxGen = class extends AxProgramWithSignature {
     traceContext
   }) {
     const { sessionId, traceId, functions: _functions } = options ?? {};
-    const fastFail = options?.fastFail ?? this.options?.fastFail;
+    const strictMode = options?.strictMode ?? false;
     const model = options.model;
     const functions = _functions?.map((f2) => "toFunction" in f2 ? f2.toFunction() : f2)?.flat();
     const res = await this.forwardSendRequest({
@@ -9108,7 +9334,7 @@ var AxGen = class extends AxProgramWithSignature {
         traceId,
         sessionId,
         functions,
-        fastFail,
+        strictMode,
         span
       });
       this.getLogger(ai, options)?.("", { tags: ["responseEnd"] });
@@ -9121,7 +9347,8 @@ var AxGen = class extends AxProgramWithSignature {
         traceId,
         sessionId,
         functions,
-        span
+        span,
+        strictMode
       });
     }
   }
@@ -9133,10 +9360,9 @@ var AxGen = class extends AxProgramWithSignature {
     sessionId,
     traceId,
     functions,
-    fastFail,
+    strictMode,
     span
   }) {
-    const streamingValidation = fastFail ?? ai.getFeatures(model).functionCot !== true;
     const functionCalls = [];
     this.values = {};
     const xstate = {
@@ -9187,7 +9413,7 @@ var AxGen = class extends AxProgramWithSignature {
           this.values,
           xstate,
           content,
-          streamingValidation
+          strictMode
         );
         if (skip) {
           continue;
@@ -9288,7 +9514,8 @@ Content: ${content}`
     sessionId,
     traceId,
     functions,
-    span
+    span,
+    strictMode
   }) {
     this.values = {};
     let results = res.results ?? [];
@@ -9322,7 +9549,7 @@ Content: ${content}`
         if (result.thought && result.thought.length > 0) {
           this.values[this.thoughtFieldName] = result.thought;
         }
-        extractValues(this.signature, this.values, result.content);
+        extractValues(this.signature, this.values, result.content, strictMode);
         await assertAssertions(this.asserts, this.values);
         if (this.fieldProcessors.length) {
           await processFieldProcessors(
@@ -9494,8 +9721,7 @@ Content: ${result.content}`
       ...options?.thinkingTokenBudget ? { thinking_token_budget: options.thinkingTokenBudget } : {},
       ...options?.showThoughts ? { show_thoughts: options.showThoughts } : {},
       ...options?.maxSteps ? { max_steps: options.maxSteps } : {},
-      ...options?.maxRetries ? { max_retries: options.maxRetries } : {},
-      ...options?.fastFail ? { fast_fail: options.fastFail } : {}
+      ...options?.maxRetries ? { max_retries: options.maxRetries } : {}
     };
     const traceLabel = options.traceLabel ?? this.options?.traceLabel;
     const spanName = traceLabel ? `${traceLabel} (AxGen)` : "AxGen";
@@ -9689,7 +9915,9 @@ var AxAgent = class {
       description: definition ?? description
     });
     for (const agent of agents ?? []) {
-      this.program.register(agent);
+      this.program.register(
+        agent
+      );
     }
     this.name = name;
     this.func = {
@@ -10193,98 +10421,825 @@ function validateModels2(services) {
   }
 }
 
-// db/base.ts
-var import_api23 = require("@opentelemetry/api");
-var AxDBBase = class {
-  name;
-  fetch;
-  tracer;
-  _upsert;
-  _batchUpsert;
-  _query;
-  constructor({
-    name,
-    fetch: fetch2,
-    tracer
-  }) {
-    this.name = name;
-    this.fetch = fetch2;
-    this.tracer = tracer;
+// dsp/optimizer.ts
+var AxDefaultCostTracker = class {
+  tokenUsage = {};
+  totalTokens = 0;
+  // Configuration options
+  costPerModel;
+  maxCost;
+  maxTokens;
+  constructor(options) {
+    this.costPerModel = options?.costPerModel ?? {};
+    this.maxCost = options?.maxCost;
+    this.maxTokens = options?.maxTokens;
   }
-  async upsert(req, update) {
-    if (!this._upsert) {
-      throw new Error("upsert() not implemented");
-    }
-    if (!this.tracer) {
-      return await this._upsert(req, update);
-    }
-    return await this.tracer.startActiveSpan(
-      "DB Upsert Request",
-      {
-        kind: import_api23.SpanKind.SERVER,
-        attributes: {
-          [axSpanAttributes.DB_SYSTEM]: this.name,
-          [axSpanAttributes.DB_OPERATION_NAME]: "upsert",
-          [axSpanAttributes.DB_TABLE]: req.table,
-          [axSpanAttributes.DB_NAMESPACE]: req.namespace,
-          [axSpanAttributes.DB_OPERATION_NAME]: update ? "update" : "insert"
-        }
-      },
-      async (span) => {
-        try {
-          return await this._upsert(req, update, { span });
-        } finally {
-          span.end();
-        }
-      }
-    );
+  trackTokens(count, model) {
+    this.tokenUsage[model] = (this.tokenUsage[model] || 0) + count;
+    this.totalTokens += count;
   }
-  async batchUpsert(req, update) {
-    if (!this._batchUpsert) {
-      throw new Error("batchUpsert() not implemented");
+  getCurrentCost() {
+    let totalCost = 0;
+    for (const [model, tokens] of Object.entries(this.tokenUsage)) {
+      const costPer1K = this.costPerModel[model] || 1e-3;
+      totalCost += tokens / 1e3 * costPer1K;
     }
-    if (req.length == 0) {
-      throw new Error("Batch request is empty");
+    return totalCost;
+  }
+  getTokenUsage() {
+    return { ...this.tokenUsage };
+  }
+  getTotalTokens() {
+    return this.totalTokens;
+  }
+  isLimitReached() {
+    if (this.maxTokens !== void 0 && this.totalTokens >= this.maxTokens) {
+      return true;
     }
-    if (!req[0]) {
-      throw new Error("Batch request is invalid first element is undefined");
+    if (this.maxCost !== void 0) {
+      const currentCost = this.getCurrentCost();
+      if (currentCost >= this.maxCost) {
+        return true;
+      }
     }
-    if (!this.tracer) {
-      return await this._batchUpsert(req, update);
+    return false;
+  }
+  reset() {
+    this.tokenUsage = {};
+    this.totalTokens = 0;
+  }
+};
+var AxBaseOptimizer = class {
+  // Common AxOptimizerArgs fields
+  studentAI;
+  teacherAI;
+  examples;
+  validationSet;
+  targetScore;
+  minSuccessRate;
+  onProgress;
+  onEarlyStop;
+  costTracker;
+  seed;
+  // Checkpointing fields
+  checkpointSave;
+  checkpointLoad;
+  checkpointInterval;
+  resumeFromCheckpoint;
+  // Logging fields
+  logger;
+  verbose;
+  // Checkpoint state
+  currentRound = 0;
+  scoreHistory = [];
+  configurationHistory = [];
+  // Common optimization statistics
+  stats;
+  constructor(args) {
+    if (args.examples.length === 0) {
+      throw new Error("No examples found");
     }
-    return await this.tracer.startActiveSpan(
-      "DB Batch Upsert Request",
-      {
-        kind: import_api23.SpanKind.SERVER,
-        attributes: {
-          [axSpanAttributes.DB_SYSTEM]: this.name,
-          [axSpanAttributes.DB_OPERATION_NAME]: "upsert",
-          [axSpanAttributes.DB_TABLE]: req[0].table,
-          [axSpanAttributes.DB_NAMESPACE]: req[0].namespace,
-          [axSpanAttributes.DB_OPERATION_NAME]: update ? "update" : "insert"
-        }
+    this.studentAI = args.studentAI;
+    this.teacherAI = args.teacherAI;
+    this.examples = args.examples;
+    this.validationSet = args.validationSet;
+    this.targetScore = args.targetScore;
+    this.minSuccessRate = args.minSuccessRate;
+    this.onProgress = args.onProgress;
+    this.onEarlyStop = args.onEarlyStop;
+    this.seed = args.seed;
+    this.checkpointSave = args.checkpointSave;
+    this.checkpointLoad = args.checkpointLoad;
+    this.checkpointInterval = args.checkpointInterval ?? 10;
+    this.resumeFromCheckpoint = args.resumeFromCheckpoint;
+    this.logger = args.logger;
+    this.verbose = args.verbose;
+    const costTracker = new AxDefaultCostTracker({
+      maxTokens: 1e6
+    });
+    this.costTracker = args.costTracker ?? costTracker;
+    this.stats = this.initializeStats();
+  }
+  /**
+   * Initialize the optimization statistics structure
+   */
+  initializeStats() {
+    return {
+      totalCalls: 0,
+      successfulDemos: 0,
+      estimatedTokenUsage: 0,
+      earlyStopped: false,
+      resourceUsage: {
+        totalTokens: 0,
+        totalTime: 0,
+        avgLatencyPerEval: 0,
+        costByModel: {}
       },
-      async (span) => {
-        try {
-          return await this._batchUpsert(req, update, { span });
-        } finally {
-          span.end();
-        }
+      convergenceInfo: {
+        converged: false,
+        finalImprovement: 0,
+        stagnationRounds: 0,
+        convergenceThreshold: 0.01
       }
-    );
+    };
   }
-  async query(req) {
-    if (!this._query) {
-      throw new Error("query() not implemented");
+  /**
+   * Set up reproducible random seed if provided
+   */
+  setupRandomSeed() {
+    if (this.seed !== void 0) {
+      Math.random = (() => {
+        let seed = this.seed;
+        return () => {
+          seed = (seed * 9301 + 49297) % 233280;
+          return seed / 233280;
+        };
+      })();
     }
-    if (!this.tracer) {
-      return await this._query(req);
+  }
+  /**
+   * Check if optimization should stop early due to cost limits
+   */
+  checkCostLimits() {
+    return this.costTracker?.isLimitReached() ?? false;
+  }
+  /**
+   * Check if target score has been reached
+   */
+  checkTargetScore(currentScore) {
+    return this.targetScore !== void 0 && currentScore >= this.targetScore;
+  }
+  /**
+   * Update resource usage statistics
+   */
+  updateResourceUsage(startTime, tokensUsed = 0) {
+    this.stats.resourceUsage.totalTime = Date.now() - startTime;
+    this.stats.resourceUsage.totalTokens += tokensUsed;
+    if (this.stats.totalCalls > 0) {
+      this.stats.resourceUsage.avgLatencyPerEval = this.stats.resourceUsage.totalTime / this.stats.totalCalls;
     }
-    return await this.tracer.startActiveSpan(
-      "DB Query Request",
-      {
-        kind: import_api23.SpanKind.SERVER,
-        attributes: {
+  }
+  /**
+   * Trigger early stopping with appropriate callbacks
+   */
+  triggerEarlyStopping(reason, bestScoreRound) {
+    this.stats.earlyStopped = true;
+    this.stats.earlyStopping = {
+      bestScoreRound,
+      patienceExhausted: reason.includes("improvement"),
+      reason
+    };
+    if (this.onEarlyStop) {
+      this.onEarlyStop(reason, this.stats);
+    }
+  }
+  /**
+   * Get the validation set, with fallback to a split of examples
+   */
+  getValidationSet(options) {
+    return options?.overrideValidationSet || this.validationSet || this.examples.slice(0, Math.floor(this.examples.length * 0.2));
+  }
+  /**
+   * Get the AI service to use for a specific task, preferring teacher when available
+   * @param preferTeacher Whether to prefer teacher AI over student AI
+   * @param options Optional compile options that may override teacher AI
+   * @returns The appropriate AI service to use
+   */
+  getAIService(preferTeacher = false, options) {
+    if (preferTeacher && options?.overrideTeacherAI) {
+      return options.overrideTeacherAI;
+    }
+    if (preferTeacher && this.teacherAI) {
+      return this.teacherAI;
+    }
+    return this.studentAI;
+  }
+  /**
+   * Check if teacher AI is available (including overrides)
+   * @param options Optional compile options that may override teacher AI
+   * @returns True if teacher AI is configured or overridden
+   */
+  hasTeacherAI(options) {
+    return options?.overrideTeacherAI !== void 0 || this.teacherAI !== void 0;
+  }
+  /**
+   * Get teacher AI if available, otherwise return student AI
+   * @param options Optional compile options that may override teacher AI
+   * @returns Teacher AI if available, otherwise student AI
+   */
+  getTeacherOrStudentAI(options) {
+    return options?.overrideTeacherAI || this.teacherAI || this.studentAI;
+  }
+  /**
+   * Execute a task with teacher AI if available, otherwise use student AI
+   * @param task Function that takes an AI service and returns a promise
+   * @param preferTeacher Whether to prefer teacher AI (default: true)
+   * @param options Optional compile options that may override teacher AI
+   * @returns Result of the task execution
+   */
+  async executeWithTeacher(task, preferTeacher = true, options) {
+    const ai = this.getAIService(preferTeacher, options);
+    return await task(ai);
+  }
+  /**
+   * Get current optimization statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset optimizer state for reuse with different programs
+   */
+  reset() {
+    this.stats = this.initializeStats();
+    this.costTracker?.reset();
+    this.currentRound = 0;
+    this.scoreHistory = [];
+    this.configurationHistory = [];
+  }
+  /**
+   * Basic program validation that can be extended by concrete optimizers
+   */
+  validateProgram(program) {
+    const issues = [];
+    const suggestions = [];
+    if (!("forward" in program) || typeof program.forward !== "function") {
+      issues.push("Program must have a forward method");
+    }
+    if (this.examples.length < 2) {
+      issues.push("Need at least 2 examples for optimization");
+      suggestions.push("Provide more training examples");
+    }
+    const valSetSize = this.getValidationSet().length;
+    if (valSetSize < 1) {
+      issues.push("Validation set is empty");
+      suggestions.push("Provide examples or a validation set");
+    }
+    return {
+      isValid: issues.length === 0,
+      issues,
+      suggestions
+    };
+  }
+  /**
+   * Multi-objective optimization using Pareto frontier
+   * Default implementation that leverages the single-objective compile method
+   * @param program The program to optimize
+   * @param metricFn Multi-objective metric function that returns multiple scores
+   * @param options Optional configuration options
+   * @returns Pareto optimization result with frontier of non-dominated solutions
+   */
+  async compilePareto(program, metricFn, options) {
+    const startTime = Date.now();
+    if (options?.verbose) {
+      this.getLogger(options)?.(
+        "Starting Pareto optimization using base implementation",
+        { tags: ["discovery"] }
+      );
+      this.getLogger(options)?.(
+        "This will run multiple single-objective optimizations",
+        { tags: ["discovery"] }
+      );
+    }
+    const solutions = await this.generateWeightedSolutions(
+      program,
+      metricFn,
+      options
+    );
+    const constraintSolutions = await this.generateConstraintSolutions(
+      program,
+      metricFn,
+      options
+    );
+    const allSolutions = [...solutions, ...constraintSolutions];
+    if (options?.verbose) {
+      this.getLogger(options)?.(
+        `Generated ${allSolutions.length} candidate solutions`,
+        { tags: ["discovery"] }
+      );
+    }
+    const paretoFront = this.findParetoFrontier(allSolutions);
+    const hypervolume = this.calculateHypervolume(paretoFront);
+    if (options?.verbose) {
+      this.getLogger(options)?.(
+        `Found ${paretoFront.length} non-dominated solutions`,
+        { tags: ["discovery"] }
+      );
+      this.getLogger(options)?.(
+        `Hypervolume: ${hypervolume?.toFixed(4) || "N/A"}`,
+        { tags: ["discovery"] }
+      );
+    }
+    this.updateResourceUsage(startTime);
+    this.stats.convergenceInfo.converged = true;
+    const bestScore = paretoFront.length > 0 ? Math.max(
+      ...paretoFront.map((sol) => Math.max(...Object.values(sol.scores)))
+    ) : 0;
+    return {
+      demos: paretoFront.length > 0 ? [...paretoFront[0].demos] : void 0,
+      stats: this.stats,
+      bestScore,
+      paretoFront,
+      hypervolume,
+      paretoFrontSize: paretoFront.length,
+      finalConfiguration: {
+        paretoFrontSize: paretoFront.length,
+        hypervolume,
+        strategy: "weighted_combinations_and_constraints",
+        numSolutions: allSolutions.length
+      }
+    };
+  }
+  /**
+   * Generate solutions using different weighted combinations of objectives
+   */
+  async generateWeightedSolutions(program, metricFn, options) {
+    const solutions = [];
+    const sampleExample = this.examples[0];
+    const samplePrediction = await program.forward(
+      this.studentAI,
+      sampleExample
+    );
+    const sampleScores = await metricFn({
+      prediction: samplePrediction,
+      example: sampleExample
+    });
+    const objectives = Object.keys(sampleScores);
+    if (options?.verbose) {
+      this.getLogger(options)?.(
+        `Detected objectives: ${objectives.join(", ")}`,
+        { tags: ["discovery"] }
+      );
+    }
+    const weightCombinations = this.generateWeightCombinations(objectives);
+    for (let i = 0; i < weightCombinations.length; i++) {
+      const weights = weightCombinations[i];
+      if (options?.verbose) {
+        this.getLogger(options)?.(
+          `Optimizing with weights: ${JSON.stringify(weights)}`,
+          { tags: ["discovery"] }
+        );
+      }
+      const weightedMetric = async ({ prediction, example }) => {
+        const scores = await metricFn({ prediction, example });
+        let weightedScore = 0;
+        for (const [objective, score] of Object.entries(scores)) {
+          weightedScore += score * (weights[objective] || 0);
+        }
+        return weightedScore;
+      };
+      try {
+        const result = await this.compile(program, weightedMetric, {
+          ...options,
+          verbose: false
+          // Suppress inner optimization logs
+        });
+        const scores = await this.evaluateWithMultiObjective(
+          program,
+          result,
+          metricFn
+        );
+        solutions.push({
+          scores,
+          demos: result.demos,
+          configuration: {
+            ...result.finalConfiguration,
+            weights,
+            strategy: "weighted_combination"
+          }
+        });
+      } catch (error) {
+        if (options?.verbose) {
+          this.getLogger(options)?.(
+            `Failed optimization with weights ${JSON.stringify(weights)}: ${error}`,
+            { tags: ["warning"] }
+          );
+        }
+        continue;
+      }
+    }
+    return solutions;
+  }
+  /**
+   * Generate solutions using constraint-based optimization
+   */
+  async generateConstraintSolutions(program, metricFn, options) {
+    const solutions = [];
+    const sampleExample = this.examples[0];
+    const samplePrediction = await program.forward(
+      this.studentAI,
+      sampleExample
+    );
+    const sampleScores = await metricFn({
+      prediction: samplePrediction,
+      example: sampleExample
+    });
+    const objectives = Object.keys(sampleScores);
+    for (const primaryObjective of objectives) {
+      if (options?.verbose) {
+        this.getLogger(options)?.(
+          `Optimizing ${primaryObjective} with constraints on other objectives`,
+          { tags: ["discovery"] }
+        );
+      }
+      const constraintMetric = async ({ prediction, example }) => {
+        const scores = await metricFn({ prediction, example });
+        const primaryScore = scores[primaryObjective] || 0;
+        let penalty = 0;
+        for (const [objective, score] of Object.entries(scores)) {
+          if (objective !== primaryObjective) {
+            if (score < 0.3) {
+              penalty += (0.3 - score) * 2;
+            }
+          }
+        }
+        return primaryScore - penalty;
+      };
+      try {
+        const result = await this.compile(program, constraintMetric, {
+          ...options,
+          verbose: false
+        });
+        const scores = await this.evaluateWithMultiObjective(
+          program,
+          result,
+          metricFn
+        );
+        solutions.push({
+          scores,
+          demos: result.demos,
+          configuration: {
+            ...result.finalConfiguration,
+            primaryObjective,
+            strategy: "constraint_based"
+          }
+        });
+      } catch (error) {
+        if (options?.verbose) {
+          this.getLogger(options)?.(
+            `Failed constraint optimization for ${primaryObjective}: ${error}`,
+            { tags: ["warning"] }
+          );
+        }
+        continue;
+      }
+    }
+    return solutions;
+  }
+  /**
+   * Generate different weight combinations for objectives
+   */
+  generateWeightCombinations(objectives) {
+    const combinations = [];
+    for (const objective of objectives) {
+      const weights = {};
+      for (const obj of objectives) {
+        weights[obj] = obj === objective ? 1 : 0;
+      }
+      combinations.push(weights);
+    }
+    const equalWeights = {};
+    for (const objective of objectives) {
+      equalWeights[objective] = 1 / objectives.length;
+    }
+    combinations.push(equalWeights);
+    if (objectives.length === 2) {
+      const [obj1, obj2] = objectives;
+      for (let w1 = 0.1; w1 <= 0.9; w1 += 0.2) {
+        const w2 = 1 - w1;
+        combinations.push({ [obj1]: w1, [obj2]: w2 });
+      }
+    }
+    if (objectives.length === 3) {
+      const [obj1, obj2, obj3] = objectives;
+      combinations.push(
+        { [obj1]: 0.5, [obj2]: 0.3, [obj3]: 0.2 },
+        { [obj1]: 0.3, [obj2]: 0.5, [obj3]: 0.2 },
+        { [obj1]: 0.2, [obj2]: 0.3, [obj3]: 0.5 }
+      );
+    }
+    return combinations;
+  }
+  /**
+   * Evaluate a single-objective result with multi-objective metrics
+   */
+  async evaluateWithMultiObjective(program, result, metricFn) {
+    const valSet = this.getValidationSet();
+    const allScores = {};
+    const testProgram = { ...program };
+    if (result.demos && "setDemos" in testProgram) {
+      ;
+      testProgram.setDemos(result.demos);
+    }
+    const evalSet = valSet.slice(0, Math.min(5, valSet.length));
+    for (const example of evalSet) {
+      try {
+        const prediction = await testProgram.forward(
+          this.studentAI,
+          example
+        );
+        const scores = await metricFn({ prediction, example });
+        for (const [objective, score] of Object.entries(scores)) {
+          if (!allScores[objective]) {
+            allScores[objective] = [];
+          }
+          allScores[objective].push(score);
+        }
+      } catch {
+        continue;
+      }
+    }
+    const avgScores = {};
+    for (const [objective, scores] of Object.entries(allScores)) {
+      avgScores[objective] = scores.length > 0 ? scores.reduce((sum, score) => sum + score, 0) / scores.length : 0;
+    }
+    return avgScores;
+  }
+  /**
+   * Find the Pareto frontier from a set of solutions
+   */
+  findParetoFrontier(solutions) {
+    const paretoFront = [];
+    for (let i = 0; i < solutions.length; i++) {
+      const solutionA = solutions[i];
+      let isDominated = false;
+      let dominatedCount = 0;
+      for (let j = 0; j < solutions.length; j++) {
+        if (i === j) continue;
+        const solutionB = solutions[j];
+        if (this.dominates(solutionB.scores, solutionA.scores)) {
+          isDominated = true;
+          break;
+        }
+        if (this.dominates(solutionA.scores, solutionB.scores)) {
+          dominatedCount++;
+        }
+      }
+      if (!isDominated) {
+        paretoFront.push({
+          demos: solutionA.demos || [],
+          scores: solutionA.scores,
+          configuration: solutionA.configuration,
+          dominatedSolutions: dominatedCount
+        });
+      }
+    }
+    return paretoFront;
+  }
+  /**
+   * Check if solution A dominates solution B
+   * A dominates B if A is better or equal in all objectives and strictly better in at least one
+   */
+  dominates(scoresA, scoresB) {
+    const objectives = Object.keys(scoresA);
+    let atLeastAsGood = true;
+    let strictlyBetter = false;
+    for (const objective of objectives) {
+      const scoreA = scoresA[objective] || 0;
+      const scoreB = scoresB[objective] || 0;
+      if (scoreA < scoreB) {
+        atLeastAsGood = false;
+        break;
+      }
+      if (scoreA > scoreB) {
+        strictlyBetter = true;
+      }
+    }
+    return atLeastAsGood && strictlyBetter;
+  }
+  /**
+   * Calculate hypervolume of the Pareto frontier
+   * Simplified implementation using reference point at origin
+   */
+  calculateHypervolume(paretoFront) {
+    if (paretoFront.length === 0) return void 0;
+    const firstSolution = paretoFront[0];
+    const objectives = Object.keys(firstSolution.scores);
+    if (objectives.length === 2) {
+      const [obj1, obj2] = objectives;
+      let hypervolume = 0;
+      const sortedSolutions = [...paretoFront].sort(
+        (a, b) => (b.scores[obj1] || 0) - (a.scores[obj1] || 0)
+      );
+      let prevScore2 = 0;
+      for (const solution of sortedSolutions) {
+        const score1 = solution.scores[obj1] || 0;
+        const score2 = solution.scores[obj2] || 0;
+        hypervolume += score1 * (score2 - prevScore2);
+        prevScore2 = Math.max(prevScore2, score2);
+      }
+      return hypervolume;
+    }
+    return void 0;
+  }
+  /**
+   * Save current optimization state to checkpoint
+   */
+  async saveCheckpoint(optimizerType, optimizerConfig, bestScore, bestConfiguration, optimizerState = {}, options) {
+    const saveFn = options?.overrideCheckpointSave || this.checkpointSave;
+    if (!saveFn) return void 0;
+    const checkpoint = {
+      version: "1.0.0",
+      timestamp: Date.now(),
+      optimizerType,
+      optimizerConfig,
+      currentRound: this.currentRound,
+      totalRounds: this.stats.resourceUsage.totalTime > 0 ? this.currentRound : 0,
+      bestScore,
+      bestConfiguration,
+      scoreHistory: [...this.scoreHistory],
+      configurationHistory: [...this.configurationHistory],
+      stats: { ...this.stats },
+      optimizerState,
+      examples: this.examples,
+      validationSet: this.validationSet
+    };
+    return await saveFn(checkpoint);
+  }
+  /**
+   * Load optimization state from checkpoint
+   */
+  async loadCheckpoint(checkpointId, options) {
+    const loadFn = options?.overrideCheckpointLoad || this.checkpointLoad;
+    if (!loadFn) return null;
+    return await loadFn(checkpointId);
+  }
+  /**
+   * Restore optimizer state from checkpoint
+   */
+  restoreFromCheckpoint(checkpoint) {
+    this.currentRound = checkpoint.currentRound;
+    this.scoreHistory = [...checkpoint.scoreHistory];
+    this.configurationHistory = [...checkpoint.configurationHistory];
+    this.stats = { ...checkpoint.stats };
+  }
+  /**
+   * Check if checkpoint should be saved
+   */
+  shouldSaveCheckpoint(round, options) {
+    const interval = options?.overrideCheckpointInterval || this.checkpointInterval;
+    return interval !== void 0 && round % interval === 0;
+  }
+  /**
+   * Update optimization progress and handle checkpointing
+   */
+  async updateOptimizationProgress(round, score, configuration, optimizerType, optimizerConfig, bestScore, bestConfiguration, optimizerState = {}, options) {
+    this.currentRound = round;
+    this.scoreHistory.push(score);
+    this.configurationHistory.push(configuration);
+    if (this.shouldSaveCheckpoint(round, options)) {
+      await this.saveCheckpoint(
+        optimizerType,
+        optimizerConfig,
+        bestScore,
+        bestConfiguration,
+        optimizerState,
+        options
+      );
+    }
+  }
+  /**
+   * Save final checkpoint on completion
+   */
+  async saveFinalCheckpoint(optimizerType, optimizerConfig, bestScore, bestConfiguration, optimizerState = {}, options) {
+    if (options?.saveCheckpointOnComplete !== false) {
+      await this.saveCheckpoint(
+        optimizerType,
+        optimizerConfig,
+        bestScore,
+        bestConfiguration,
+        { ...optimizerState, final: true },
+        options
+      );
+    }
+  }
+  /**
+   * Get the logger function with fallback hierarchy:
+   * 1. Explicit logger passed to optimizer
+   * 2. Logger from student AI service
+   * 3. Default optimizer logger
+   * 4. undefined if verbose is false
+   */
+  getLogger(options) {
+    const isVerbose = this.isLoggingEnabled(options);
+    if (!isVerbose) {
+      return void 0;
+    }
+    if (this.logger) {
+      return this.logger;
+    }
+    try {
+      const aiLogger = this.studentAI.getLogger();
+      if (aiLogger) {
+        return aiLogger;
+      }
+    } catch {
+    }
+    return axDefaultOptimizerLogger;
+  }
+  /**
+   * Check if logging is enabled based on verbose settings
+   */
+  isLoggingEnabled(options) {
+    if (options?.verbose !== void 0) {
+      return options.verbose;
+    }
+    return this.verbose ?? true;
+  }
+};
+
+// db/base.ts
+var import_api23 = require("@opentelemetry/api");
+var AxDBBase = class {
+  name;
+  fetch;
+  tracer;
+  _upsert;
+  _batchUpsert;
+  _query;
+  constructor({
+    name,
+    fetch: fetch2,
+    tracer
+  }) {
+    this.name = name;
+    this.fetch = fetch2;
+    this.tracer = tracer;
+  }
+  async upsert(req, update) {
+    if (!this._upsert) {
+      throw new Error("upsert() not implemented");
+    }
+    if (!this.tracer) {
+      return await this._upsert(req, update);
+    }
+    return await this.tracer.startActiveSpan(
+      "DB Upsert Request",
+      {
+        kind: import_api23.SpanKind.SERVER,
+        attributes: {
+          [axSpanAttributes.DB_SYSTEM]: this.name,
+          [axSpanAttributes.DB_OPERATION_NAME]: "upsert",
+          [axSpanAttributes.DB_TABLE]: req.table,
+          [axSpanAttributes.DB_NAMESPACE]: req.namespace,
+          [axSpanAttributes.DB_OPERATION_NAME]: update ? "update" : "insert"
+        }
+      },
+      async (span) => {
+        try {
+          return await this._upsert(req, update, { span });
+        } finally {
+          span.end();
+        }
+      }
+    );
+  }
+  async batchUpsert(req, update) {
+    if (!this._batchUpsert) {
+      throw new Error("batchUpsert() not implemented");
+    }
+    if (req.length == 0) {
+      throw new Error("Batch request is empty");
+    }
+    if (!req[0]) {
+      throw new Error("Batch request is invalid first element is undefined");
+    }
+    if (!this.tracer) {
+      return await this._batchUpsert(req, update);
+    }
+    return await this.tracer.startActiveSpan(
+      "DB Batch Upsert Request",
+      {
+        kind: import_api23.SpanKind.SERVER,
+        attributes: {
+          [axSpanAttributes.DB_SYSTEM]: this.name,
+          [axSpanAttributes.DB_OPERATION_NAME]: "upsert",
+          [axSpanAttributes.DB_TABLE]: req[0].table,
+          [axSpanAttributes.DB_NAMESPACE]: req[0].namespace,
+          [axSpanAttributes.DB_OPERATION_NAME]: update ? "update" : "insert"
+        }
+      },
+      async (span) => {
+        try {
+          return await this._batchUpsert(req, update, { span });
+        } finally {
+          span.end();
+        }
+      }
+    );
+  }
+  async query(req) {
+    if (!this._query) {
+      throw new Error("query() not implemented");
+    }
+    if (!this.tracer) {
+      return await this._query(req);
+    }
+    return await this.tracer.startActiveSpan(
+      "DB Query Request",
+      {
+        kind: import_api23.SpanKind.SERVER,
+        attributes: {
           [axSpanAttributes.DB_SYSTEM]: this.name,
           [axSpanAttributes.DB_OPERATION_NAME]: "upsert",
           [axSpanAttributes.DB_TABLE]: req.table,
@@ -11652,52 +12607,31 @@ var AxMCPStreambleHTTPTransport = class {
 };
 
 // dsp/optimizers/bootstrapFewshot.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) {
-      throw new Error("No examples found");
-    }
-    const bootstrapOptions = options;
-    this.maxRounds = bootstrapOptions?.maxRounds ?? 3;
-    this.maxDemos = bootstrapOptions?.maxDemos ?? 4;
-    this.maxExamples = bootstrapOptions?.maxExamples ?? 16;
-    this.batchSize = bootstrapOptions?.batchSize ?? 1;
-    this.earlyStoppingPatience = bootstrapOptions?.earlyStoppingPatience ?? 0;
-    this.costMonitoring = bootstrapOptions?.costMonitoring ?? false;
-    this.maxTokensPerGeneration = bootstrapOptions?.maxTokensPerGeneration ?? 0;
-    this.verboseMode = bootstrapOptions?.verboseMode ?? true;
-    this.debugMode = bootstrapOptions?.debugMode ?? false;
-    this.ai = ai;
-    this.teacherAI = bootstrapOptions?.teacherAI;
-    this.program = program;
-    this.examples = examples;
-  }
-  async compileRound(roundIndex, metricFn, options) {
+var AxBootstrapFewShot = class extends AxBaseOptimizer {
+  maxRounds;
+  maxDemos;
+  maxExamples;
+  batchSize;
+  earlyStoppingPatience;
+  costMonitoring;
+  maxTokensPerGeneration;
+  verboseMode;
+  debugMode;
+  traces = [];
+  constructor(args) {
+    super(args);
+    const options = args.options || {};
+    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;
+  }
+  async compileRound(program, roundIndex, metricFn, options) {
     const st = (/* @__PURE__ */ new Date()).getTime();
     const maxDemos = options?.maxDemos ?? this.maxDemos;
     const aiOpt = {
@@ -11720,20 +12654,20 @@ var AxBootstrapFewShot = class {
           continue;
         }
         const exList = examples.filter((e) => e !== ex);
-        this.program.setExamples(exList);
-        const aiService = this.teacherAI || this.ai;
+        program.setExamples(exList);
+        const aiService = this.getTeacherOrStudentAI();
         this.stats.totalCalls++;
         let res;
         let error;
         try {
-          res = await this.program.forward(aiService, ex, aiOpt);
+          res = await program.forward(aiService, ex, aiOpt);
           if (this.costMonitoring) {
             this.stats.estimatedTokenUsage += JSON.stringify(ex).length / 4 + JSON.stringify(res).length / 4;
           }
-          const score = metricFn({ prediction: res, example: ex });
+          const score = await metricFn({ prediction: res, example: ex });
           const success = score >= 0.5;
           if (success) {
-            this.traces = [...this.traces, ...this.program.getTraces()];
+            this.traces = [...this.traces, ...program.getTraces()];
             this.stats.successfulDemos++;
           }
         } catch (err) {
@@ -11784,54 +12718,73 @@ var AxBootstrapFewShot = class {
       if (!this.stats.earlyStopping) {
         this.stats.earlyStopping = {
           bestScoreRound: improvement > 0 ? roundIndex : 0,
-          patienceExhausted: false
+          patienceExhausted: false,
+          reason: "No improvement detected"
         };
       } 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;
+        this.stats.earlyStopping.reason = `No improvement for ${this.earlyStoppingPatience} rounds`;
         if (this.verboseMode || this.debugMode) {
-          console.log(
-            `
-Early stopping triggered after ${roundIndex + 1} rounds. No improvement for ${this.earlyStoppingPatience} rounds.`
+          this.getLogger()?.(
+            `Early stopping after ${roundIndex + 1} rounds (no improvement for ${this.earlyStoppingPatience} rounds)`,
+            { tags: ["optimizer", "warning"] }
           );
         }
         return;
       }
     }
   }
-  async compile(metricFn, options) {
-    const compileOptions = options;
-    const maxRounds = compileOptions?.maxRounds ?? this.maxRounds;
+  async compile(program, metricFn, options) {
+    const maxRounds = options?.maxIterations ?? this.maxRounds;
     this.traces = [];
-    this.stats = {
-      totalCalls: 0,
-      successfulDemos: 0,
-      estimatedTokenUsage: 0,
-      earlyStopped: false
-    };
+    this.reset();
+    if (this.verboseMode || this.debugMode) {
+      this.getLogger()?.(
+        `Starting BootstrapFewshot optimization with ${maxRounds} rounds`,
+        { tags: ["optimizer", "start"] }
+      );
+      this.getLogger()?.(
+        `Using ${this.examples.length} examples, max ${this.maxDemos} demos`,
+        { tags: ["optimizer", "config"] }
+      );
+    }
     for (let i = 0; i < maxRounds; i++) {
-      await this.compileRound(i, metricFn, compileOptions);
+      await this.compileRound(program, i, metricFn, options);
       if (this.stats.earlyStopped) {
         break;
       }
     }
     if (this.traces.length === 0) {
       throw new Error(
-        "No demonstrations found. Either provider more examples or improve the existing ones."
+        "No demonstrations found. Either provide more examples or improve the existing ones."
       );
     }
     const demos = groupTracesByKeys(this.traces);
+    let bestScore = 0;
+    if (this.traces.length > 0) {
+      bestScore = this.stats.successfulDemos / Math.max(1, this.stats.totalCalls);
+    }
+    if (this.verboseMode || this.debugMode) {
+      this.getLogger()?.(
+        `Bootstrap complete. Generated ${demos.length} demos with ${bestScore.toFixed(3)} success rate`,
+        { tags: ["optimizer", "complete"] }
+      );
+    }
     return {
       demos,
-      stats: this.stats
+      stats: this.stats,
+      bestScore,
+      finalConfiguration: {
+        maxRounds: this.maxRounds,
+        maxDemos: this.maxDemos,
+        batchSize: this.batchSize,
+        successRate: bestScore
+      }
     };
   }
-  // Get optimization statistics
-  getStats() {
-    return this.stats;
-  }
 };
 function groupTracesByKeys(programTraces) {
   const groupedTraces = /* @__PURE__ */ new Map();
@@ -11846,9 +12799,12 @@ function groupTracesByKeys(programTraces) {
     }
   }
   const programDemosArray = [];
-  for (const [programId, traces] of groupedTraces.entries()) {
-    programDemosArray.push({ traces, programId });
-  }
+  groupedTraces.forEach((traces, programId) => {
+    programDemosArray.push({
+      traces,
+      programId
+    });
+  });
   return programDemosArray;
 }
 var randomSample = (array, n) => {
@@ -11867,10 +12823,8 @@ var randomSample = (array, n) => {
 };
 
 // dsp/optimizers/miproV2.ts
-var AxMiPRO = class {
-  ai;
-  program;
-  examples;
+var AxMiPRO = class extends AxBaseOptimizer {
+  // MiPRO-specific options
   maxBootstrappedDemos;
   maxLabeledDemos;
   numCandidates;
@@ -11884,52 +12838,33 @@ var AxMiPRO = class {
   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
-      }
-    });
+  bayesianOptimization;
+  acquisitionFunction;
+  explorationWeight;
+  constructor(args) {
+    super(args);
+    const options = args.options || {};
+    this.numCandidates = options.numCandidates ?? 5;
+    this.initTemperature = options.initTemperature ?? 0.7;
+    this.maxBootstrappedDemos = options.maxBootstrappedDemos ?? 3;
+    this.maxLabeledDemos = options.maxLabeledDemos ?? 4;
+    this.numTrials = options.numTrials ?? 30;
+    this.minibatch = options.minibatch ?? true;
+    this.minibatchSize = options.minibatchSize ?? 25;
+    this.minibatchFullEvalSteps = options.minibatchFullEvalSteps ?? 10;
+    this.programAwareProposer = options.programAwareProposer ?? true;
+    this.dataAwareProposer = options.dataAwareProposer ?? true;
+    this.viewDataBatchSize = options.viewDataBatchSize ?? 10;
+    this.tipAwareProposer = options.tipAwareProposer ?? true;
+    this.fewshotAwareProposer = options.fewshotAwareProposer ?? true;
+    this.earlyStoppingTrials = options.earlyStoppingTrials ?? 5;
+    this.minImprovementThreshold = options.minImprovementThreshold ?? 0.01;
+    this.bayesianOptimization = options.bayesianOptimization ?? false;
+    this.acquisitionFunction = options.acquisitionFunction ?? "expected_improvement";
+    this.explorationWeight = options.explorationWeight ?? 0.1;
+    this.stats.convergenceInfo.convergenceThreshold = this.minImprovementThreshold;
   }
   /**
    * Configures the optimizer for light, medium, or heavy optimization
@@ -11973,123 +12908,62 @@ var AxMiPRO = class {
     ];
   }
   /**
-   * Generates instruction candidates for each predictor in the program
+   * Generates instruction candidates using the teacher model if available
+   * @param options Optional compile options that may override teacher AI
    * @returns Array of generated instruction candidates
    */
-  async proposeInstructionCandidates() {
+  async proposeInstructionCandidates(options) {
     const instructions = [];
-    let programContext = "";
-    if (this.programAwareProposer) {
-      programContext = await this.generateProgramSummary();
-    }
-    let dataContext = "";
-    if (this.dataAwareProposer) {
-      dataContext = await this.generateDataSummary();
-    }
+    const aiToUse = this.getTeacherOrStudentAI(options);
     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
+        candidateIndex: i,
+        ai: aiToUse
       });
       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 "";
+    const baseInstructions = [
+      "Analyze the input carefully and provide a detailed response.",
+      "Think step by step and provide a clear answer.",
+      "Consider all aspects of the input before responding.",
+      "Provide a concise but comprehensive response.",
+      "Focus on accuracy and clarity in your response."
+    ];
+    let instruction = baseInstructions[candidateIndex % baseInstructions.length] || baseInstructions[0];
+    if (tip) {
+      instruction = `${instruction} ${tip}`;
     }
-    return response.results[0]?.content || "";
+    return instruction;
   }
   /**
    * Bootstraps few-shot examples for the program
    */
-  async bootstrapFewShotExamples(metricFn) {
-    if (this.verbose) {
-      console.log("Bootstrapping few-shot examples...");
+  async bootstrapFewShotExamples(program, metricFn) {
+    if (this.isLoggingEnabled()) {
+      this.getLogger()?.("Bootstrapping few-shot examples...", {
+        tags: ["optimizer", "phase"]
+      });
     }
-    const result = await this.bootstrapper.compile(metricFn, {
+    const bootstrapper = new AxBootstrapFewShot({
+      studentAI: this.studentAI,
+      examples: this.examples,
+      options: {
+        maxDemos: this.maxBootstrappedDemos,
+        maxRounds: 3,
+        verboseMode: this.isLoggingEnabled()
+      }
+    });
+    const result = await bootstrapper.compile(program, metricFn, {
       maxDemos: this.maxBootstrappedDemos
     });
     return result.demos || [];
@@ -12113,109 +12987,111 @@ ${dataContext}
     return selectedExamples;
   }
   /**
-   * Runs Bayesian optimization to find the best combination of few-shot examples and instructions
+   * Runs 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 = {
+  async runOptimization(program, bootstrappedDemos, labeledExamples, instructions, valset, metricFn, options) {
+    let bestConfig = {
       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] || "";
+    let bestScore = 0;
+    let stagnationRounds = 0;
+    const scoreHistory = [];
+    let startRound = 0;
+    if (this.resumeFromCheckpoint) {
+      const checkpoint = await this.loadCheckpoint(
+        this.resumeFromCheckpoint,
+        options
+      );
+      if (checkpoint && checkpoint.optimizerType === "MiPRO") {
+        if (this.isLoggingEnabled(options)) {
+          this.getLogger(options)?.(
+            `Resuming from checkpoint at round ${checkpoint.currentRound}`,
+            { tags: ["optimizer", "checkpoint"] }
+          );
+        }
+        this.restoreFromCheckpoint(checkpoint);
+        startRound = checkpoint.currentRound;
+        bestScore = checkpoint.bestScore;
+        bestConfig = checkpoint.bestConfiguration || bestConfig;
+        stagnationRounds = checkpoint.stats.convergenceInfo?.stagnationRounds || 0;
+      }
+    }
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Running optimization trials (${this.numTrials} total)`,
+        { tags: ["optimizer", "phase"] }
+      );
+    }
+    for (let i = startRound; i < this.numTrials; i++) {
       const config = {
-        instruction: instructionValue,
-        bootstrappedDemos: Math.floor(
-          Math.random() * (bootstrappedDemos.length + 1)
+        instruction: instructions[i % instructions.length] || instructions[0] || "",
+        bootstrappedDemos: Math.min(
+          Math.floor(Math.random() * (bootstrappedDemos.length + 1)),
+          this.maxBootstrappedDemos
         ),
-        labeledExamples: Math.floor(
-          Math.random() * (labeledExamples.length + 1)
+        labeledExamples: Math.min(
+          Math.floor(Math.random() * (labeledExamples.length + 1)),
+          this.maxLabeledDemos
         )
       };
-      configs.push(config);
-    }
-    for (let i = 0; i < configs.length; i++) {
-      const config = configs[i];
-      if (!config) continue;
       const score = await this.evaluateConfig(
+        program,
         config,
         bootstrappedDemos,
         labeledExamples,
         valset,
-        metricFn,
-        i
+        metricFn
       );
-      evaluatedConfigs.push({ config, score });
-      if (score > bestScore) {
+      scoreHistory.push(score);
+      const improvement = score - bestScore;
+      if (improvement > this.minImprovementThreshold) {
         bestScore = score;
         bestConfig = config;
-        if (this.verbose) {
-          console.log(
-            `New best configuration found with score ${bestScore} (exploration phase)`
+        stagnationRounds = 0;
+        if (this.isLoggingEnabled(options)) {
+          this.getLogger(options)?.(
+            `Trial ${i + 1}/${this.numTrials}: New best score ${bestScore.toFixed(3)}`,
+            { tags: ["optimizer", "progress"] }
           );
         }
+      } else {
+        stagnationRounds++;
       }
-      updateProgressBar(
+      await this.updateOptimizationProgress(
         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
+        score,
+        config,
+        "MiPRO",
+        this.getConfiguration(),
+        bestScore,
+        bestConfig,
+        {
+          stagnationRounds,
+          bootstrappedDemos: bootstrappedDemos.length,
+          labeledExamples: labeledExamples.length,
+          instructions: instructions.length
+        },
+        options
       );
-      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;
+      if (this.onProgress) {
+        this.onProgress({
+          round: i + 1,
+          totalRounds: this.numTrials,
+          currentScore: score,
+          bestScore,
+          tokensUsed: this.stats.resourceUsage.totalTokens,
+          timeElapsed: Date.now(),
+          successfulExamples: this.stats.successfulDemos,
+          totalExamples: this.examples.length,
+          currentConfiguration: config,
+          convergenceInfo: {
+            improvement,
+            stagnationRounds,
+            isConverging: stagnationRounds < this.earlyStoppingTrials
           }
-        } else {
-          lastBestScore = bestScore;
-          trialsWithoutImprovement = 0;
-        }
+        });
       }
       updateProgressBar(
         i + 1,
@@ -12225,290 +13101,309 @@ ${dataContext}
         "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 (this.checkCostLimits()) {
+        this.triggerEarlyStopping("Cost limit reached", i + 1);
+        break;
       }
-    }
-    if (!bestConfig) {
-      if (this.verbose) {
-        console.warn(
-          "Optimization failed to find any valid configurations, using default fallback configuration"
+      if (stagnationRounds >= this.earlyStoppingTrials) {
+        this.triggerEarlyStopping(
+          `No improvement for ${this.earlyStoppingTrials} trials`,
+          i - stagnationRounds + 1
         );
+        break;
       }
-      bestConfig = defaultConfig;
-      try {
-        bestScore = await this.evaluateConfig(
-          bestConfig,
-          bootstrappedDemos,
-          labeledExamples,
-          valset,
-          metricFn,
-          this.numTrials - 1
+      if (this.checkTargetScore(bestScore)) {
+        this.triggerEarlyStopping(
+          `Target score ${this.targetScore} reached`,
+          i + 1
         );
-      } catch (err) {
-        if (this.verbose) {
-          console.error("Error evaluating default configuration:", err);
-        }
-        bestScore = 0;
+        break;
       }
     }
+    this.stats.convergenceInfo.stagnationRounds = stagnationRounds;
+    this.stats.convergenceInfo.finalImprovement = scoreHistory.length > 1 ? bestScore - scoreHistory[0] : 0;
+    this.stats.convergenceInfo.converged = stagnationRounds < this.earlyStoppingTrials;
     return { bestConfig, bestScore };
   }
-  /**
-   * Evaluates a configuration on the validation set
-   */
-  async evaluateConfig(config, bootstrappedDemos, labeledExamples, valset, metricFn, trialIndex) {
+  async evaluateConfig(program, config, bootstrappedDemos, labeledExamples, valset, metricFn) {
+    const testProgram = { ...program };
     this.applyConfigToProgram(
-      this.program,
+      testProgram,
       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 sumOfScores = 0;
+    let totalScore = 0;
+    let count = 0;
+    const evalSet = valset.slice(0, Math.min(5, valset.length));
     for (const example of evalSet) {
       try {
-        const prediction = await this.program.forward(this.ai, example);
-        const score = metricFn({ prediction, example });
-        sumOfScores += score;
-      } catch (err) {
-        if (this.verbose) {
-          console.error("Error evaluating example:", err);
-        }
-      }
-    }
-    if (evalSet.length === 0) return 0;
-    return sumOfScores / 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 sumOfScores = 0;
-    for (const example of valset) {
-      try {
-        const prediction = await this.program.forward(this.ai, example);
-        const score = metricFn({ prediction, example });
-        sumOfScores += score;
-      } catch (err) {
-        if (this.verbose) {
-          console.error("Error evaluating example:", err);
-        }
+        const prediction = await testProgram.forward(
+          this.studentAI,
+          example
+        );
+        const score = await metricFn({ prediction, example });
+        totalScore += score;
+        count++;
+        this.stats.totalCalls++;
+      } catch {
+        continue;
       }
     }
-    if (valset.length === 0) return 0;
-    return sumOfScores / 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
-    };
+    return count > 0 ? totalScore / count : 0;
   }
-  /**
-   * Applies a configuration to a program instance
-   */
   applyConfigToProgram(program, config, bootstrappedDemos, labeledExamples) {
-    this.setInstructionToProgram(program, config.instruction);
-    if (config.bootstrappedDemos > 0) {
+    if (program.setInstruction) {
+      program.setInstruction(config.instruction);
+    }
+    if (config.bootstrappedDemos > 0 && program.setDemos) {
       program.setDemos(bootstrappedDemos.slice(0, config.bootstrappedDemos));
     }
-    if (config.labeledExamples > 0) {
+    if (config.labeledExamples > 0 && program.setExamples) {
       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 optimization result
    */
-  async compile(metricFn, options) {
+  async compile(program, metricFn, options) {
+    const startTime = Date.now();
+    this.setupRandomSeed();
     const miproOptions = options;
     if (miproOptions?.auto) {
       this.configureAuto(miproOptions.auto);
     }
-    const trainset = this.examples;
-    const valset = miproOptions?.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`
+    const valset = this.getValidationSet(options) || (miproOptions?.valset ?? this.examples.slice(0, Math.floor(this.examples.length * 0.2)));
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Starting MIPROv2 optimization with ${this.numTrials} trials`,
+        { tags: ["optimizer", "start"] }
       );
-    }
-    if (miproOptions?.teacher) {
-      if (this.verbose) {
-        console.log("Using provided teacher to assist with bootstrapping");
+      this.getLogger(options)?.(
+        `Using ${this.examples.length} examples for training and ${valset.length} for validation`,
+        { tags: ["optimizer", "config"] }
+      );
+      if (this.teacherAI) {
+        this.getLogger(options)?.(
+          "Using separate teacher model for instruction generation",
+          { tags: ["optimizer", "config"] }
+        );
       }
-      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`
+      bootstrappedDemos = await this.bootstrapFewShotExamples(program, metricFn);
+      if (this.isLoggingEnabled(options)) {
+        this.getLogger(options)?.(
+          `Generated ${bootstrappedDemos.length} bootstrapped demonstrations`,
+          { tags: ["optimizer", "result"] }
         );
       }
     }
     let labeledExamples = [];
     if (this.maxLabeledDemos > 0) {
       labeledExamples = this.selectLabeledExamples();
-      if (this.verbose) {
-        console.log(
-          `Selected ${labeledExamples.length} labeled examples from training set`
+      if (this.isLoggingEnabled(options)) {
+        this.getLogger(options)?.(
+          `Selected ${labeledExamples.length} labeled examples from training set`,
+          { tags: ["optimizer", "result"] }
         );
       }
     }
-    const instructions = await this.proposeInstructionCandidates();
-    if (this.verbose) {
-      console.log(`Generated ${instructions.length} instruction candidates`);
+    const instructions = await this.proposeInstructionCandidates(options);
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Generated ${instructions.length} instruction candidates`,
+        { tags: ["optimizer", "result"] }
+      );
+      if (this.hasTeacherAI(options)) {
+        this.getLogger(options)?.(
+          "Using teacher AI for instruction generation",
+          { tags: ["optimizer", "config"] }
+        );
+      }
     }
-    const { bestConfig, bestScore } = await this.runBayesianOptimization(
+    const { bestConfig, bestScore } = await this.runOptimization(
+      program,
       bootstrappedDemos,
       labeledExamples,
       instructions,
       valset,
-      metricFn
+      metricFn,
+      options
     );
-    if (this.verbose) {
-      console.log(`Optimization complete. Best score: ${bestScore}`);
-      console.log(`Best configuration: ${JSON.stringify(bestConfig)}`);
+    if (this.isLoggingEnabled(options)) {
+      this.getLogger(options)?.(
+        `Optimization complete. Best score: ${bestScore}`,
+        { tags: ["optimizer", "complete"] }
+      );
+      this.getLogger(options)?.(
+        `Best configuration: ${JSON.stringify(bestConfig)}`,
+        { tags: ["optimizer", "result"] }
+      );
     }
-    this.applyConfigToProgram(
-      this.program,
+    if (this.checkTargetScore(bestScore)) {
+      this.triggerEarlyStopping(
+        `Target score ${this.targetScore} reached with score ${bestScore}`,
+        this.numTrials
+      );
+    }
+    let signature;
+    if ("getSignature" in program && typeof program.getSignature === "function") {
+      signature = program.getSignature();
+    } else {
+      signature = "input -> output";
+    }
+    const optimizedGen = new AxGen(signature);
+    this.applyConfigToAxGen(
+      optimizedGen,
       bestConfig,
       bootstrappedDemos,
       labeledExamples
     );
+    this.updateResourceUsage(startTime);
+    this.stats.convergenceInfo.converged = true;
+    this.stats.convergenceInfo.finalImprovement = bestScore;
+    await this.saveFinalCheckpoint(
+      "MiPRO",
+      this.getConfiguration(),
+      bestScore,
+      bestConfig,
+      {
+        bootstrappedDemos: bootstrappedDemos.length,
+        labeledExamples: labeledExamples.length,
+        instructions: instructions.length,
+        optimizedGen: !!optimizedGen
+      },
+      options
+    );
     return {
-      program: this.program,
-      demos: bootstrappedDemos
+      demos: bootstrappedDemos,
+      stats: this.stats,
+      bestScore,
+      optimizedGen,
+      finalConfiguration: {
+        instruction: bestConfig.instruction,
+        bootstrappedDemos: bestConfig.bootstrappedDemos,
+        labeledExamples: bestConfig.labeledExamples,
+        numCandidates: this.numCandidates,
+        numTrials: this.numTrials
+      }
     };
   }
   /**
-   * Get optimization statistics from the internal bootstrapper
-   * @returns Optimization statistics or undefined if not available
+   * Applies a configuration to an AxGen instance
    */
-  getStats() {
-    return this.bootstrapper.getStats();
+  applyConfigToAxGen(axgen, config, bootstrappedDemos, labeledExamples) {
+    if ("setInstruction" in axgen && typeof axgen.setInstruction === "function") {
+      axgen.setInstruction(config.instruction);
+    }
+    if (config.bootstrappedDemos > 0) {
+      axgen.setDemos(bootstrappedDemos.slice(0, config.bootstrappedDemos));
+    }
+    if (config.labeledExamples > 0) {
+      axgen.setExamples(
+        labeledExamples.slice(
+          0,
+          config.labeledExamples
+        )
+      );
+    }
+  }
+  /**
+   * Get optimizer-specific configuration
+   * @returns Current optimizer configuration
+   */
+  getConfiguration() {
+    return {
+      numCandidates: this.numCandidates,
+      initTemperature: this.initTemperature,
+      maxBootstrappedDemos: this.maxBootstrappedDemos,
+      maxLabeledDemos: this.maxLabeledDemos,
+      numTrials: this.numTrials,
+      minibatch: this.minibatch,
+      minibatchSize: this.minibatchSize,
+      minibatchFullEvalSteps: this.minibatchFullEvalSteps,
+      programAwareProposer: this.programAwareProposer,
+      dataAwareProposer: this.dataAwareProposer,
+      tipAwareProposer: this.tipAwareProposer,
+      fewshotAwareProposer: this.fewshotAwareProposer,
+      earlyStoppingTrials: this.earlyStoppingTrials,
+      minImprovementThreshold: this.minImprovementThreshold,
+      bayesianOptimization: this.bayesianOptimization,
+      acquisitionFunction: this.acquisitionFunction,
+      explorationWeight: this.explorationWeight
+    };
+  }
+  /**
+   * Update optimizer configuration
+   * @param config New configuration to merge with existing
+   */
+  updateConfiguration(config) {
+    if (config.numCandidates !== void 0) {
+      this.numCandidates = config.numCandidates;
+    }
+    if (config.initTemperature !== void 0) {
+      this.initTemperature = config.initTemperature;
+    }
+    if (config.maxBootstrappedDemos !== void 0) {
+      this.maxBootstrappedDemos = config.maxBootstrappedDemos;
+    }
+    if (config.maxLabeledDemos !== void 0) {
+      this.maxLabeledDemos = config.maxLabeledDemos;
+    }
+    if (config.numTrials !== void 0) {
+      this.numTrials = config.numTrials;
+    }
+    if (config.minibatch !== void 0) {
+      this.minibatch = config.minibatch;
+    }
+    if (config.minibatchSize !== void 0) {
+      this.minibatchSize = config.minibatchSize;
+    }
+    if (config.earlyStoppingTrials !== void 0) {
+      this.earlyStoppingTrials = config.earlyStoppingTrials;
+    }
+    if (config.minImprovementThreshold !== void 0) {
+      this.minImprovementThreshold = config.minImprovementThreshold;
+    }
+  }
+  /**
+   * Reset optimizer state for reuse with different programs
+   */
+  reset() {
+    super.reset();
+    this.stats.convergenceInfo.convergenceThreshold = this.minImprovementThreshold;
+  }
+  /**
+   * Validate that the optimizer can handle the given program
+   * @param program Program to validate
+   * @returns Validation result with any issues found
+   */
+  validateProgram(program) {
+    const result = super.validateProgram(program);
+    if (this.examples.length < this.maxBootstrappedDemos + this.maxLabeledDemos) {
+      result.issues.push(
+        `Not enough examples: need at least ${this.maxBootstrappedDemos + this.maxLabeledDemos}, got ${this.examples.length}`
+      );
+      result.suggestions.push(
+        "Reduce maxBootstrappedDemos or maxLabeledDemos, or provide more examples"
+      );
+    }
+    const valSetSize = this.getValidationSet().length;
+    if (valSetSize < 5) {
+      result.issues.push(
+        "Validation set too small for reliable MiPRO optimization"
+      );
+      result.suggestions.push(
+        "Provide more examples or a larger validation set"
+      );
+    }
+    return {
+      isValid: result.issues.length === 0,
+      issues: result.issues,
+      suggestions: result.suggestions
+    };
   }
 };
 
@@ -12755,7 +13650,7 @@ var AxTestPrompt = class {
         throw new Error("Invalid example");
       }
       const res = await this.program.forward(this.ai, ex);
-      const score = metricFn({ prediction: res, example: ex });
+      const score = await metricFn({ prediction: res, example: ex });
       sumOfScores += score;
       const et = (/* @__PURE__ */ new Date()).getTime() - st;
       updateProgressBar(i, total, sumOfScores, et, "Testing Prompt", 30);
@@ -14789,7 +15684,6 @@ var AxRAG = class extends AxChainOfThought {
     );
     this.genQuery = new AxGen(qsig);
     this.queryFn = queryFn;
-    this.register(this.genQuery);
   }
   async forward(ai, values, options) {
     let question;
@@ -14867,6 +15761,7 @@ var AxRAG = class extends AxChainOfThought {
   AxAssertionError,
   AxBalancer,
   AxBaseAI,
+  AxBaseOptimizer,
   AxBootstrapFewShot,
   AxChainOfThought,
   AxDB,
@@ -14876,6 +15771,7 @@ var AxRAG = class extends AxChainOfThought {
   AxDBMemory,
   AxDBPinecone,
   AxDBWeaviate,
+  AxDefaultCostTracker,
   AxDefaultQueryRewriter,
   AxDefaultResultReranker,
   AxDockerSession,
@@ -14945,6 +15841,10 @@ var AxRAG = class extends AxChainOfThought {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axCreateDefaultLogger,
+  axCreateDefaultTextLogger,
+  axCreateOptimizerLogger,
+  axDefaultOptimizerLogger,
   axGlobals,
   axModelInfoAnthropic,
   axModelInfoCohere,