@ax-llm/ax 12.0.20 → 12.0.21

package/index.js

@@ -1032,6 +1032,27 @@ var logResponseDelta = (delta, logger = defaultLogger) => {
 };
 
 // ai/metrics.ts
+var sanitizeLabels = (labels) => {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(labels)) {
+    if (value !== void 0 && value !== null) {
+      const stringValue = String(value);
+      sanitized[key] = stringValue.length > 100 ? stringValue.substring(0, 100) : stringValue;
+    }
+  }
+  return sanitized;
+};
+var globalAIMetricsInstruments;
+var getOrCreateAIMetricsInstruments = (meter) => {
+  if (globalAIMetricsInstruments) {
+    return globalAIMetricsInstruments;
+  }
+  if (meter) {
+    globalAIMetricsInstruments = createMetricsInstruments(meter);
+    return globalAIMetricsInstruments;
+  }
+  return void 0;
+};
 var createMetricsInstruments = (meter) => {
   return {
     latencyHistogram: meter.createHistogram("ax_llm_request_duration_ms", {
@@ -1132,12 +1153,17 @@ var createMetricsInstruments = (meter) => {
   };
 };
 var recordLatencyMetric = (instruments, type, duration, aiService, model) => {
-  if (instruments.latencyHistogram) {
-    instruments.latencyHistogram.record(duration, {
-      operation: type,
-      ai_service: aiService,
-      ...model ? { model } : {}
-    });
+  try {
+    if (instruments.latencyHistogram) {
+      const labels = sanitizeLabels({
+        operation: type,
+        ai_service: aiService,
+        ...model ? { model } : {}
+      });
+      instruments.latencyHistogram.record(duration, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record latency metric:", error);
   }
 };
 var recordLatencyStatsMetrics = (instruments, type, meanLatency, p95Latency, p99Latency, aiService, model) => {
@@ -1157,12 +1183,17 @@ var recordLatencyStatsMetrics = (instruments, type, meanLatency, p95Latency, p99
   }
 };
 var recordErrorMetric = (instruments, type, aiService, model) => {
-  if (instruments.errorCounter) {
-    instruments.errorCounter.add(1, {
-      operation: type,
-      ai_service: aiService,
-      ...model ? { model } : {}
-    });
+  try {
+    if (instruments.errorCounter) {
+      const labels = sanitizeLabels({
+        operation: type,
+        ai_service: aiService,
+        ...model ? { model } : {}
+      });
+      instruments.errorCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record error metric:", error);
   }
 };
 var recordErrorRateMetric = (instruments, type, errorRate, aiService, model) => {
@@ -1185,21 +1216,25 @@ var recordRequestMetric = (instruments, type, aiService, model) => {
   }
 };
 var recordTokenMetric = (instruments, type, tokens, aiService, model) => {
-  const labels = {
-    ai_service: aiService,
-    ...model ? { model } : {}
-  };
-  if (instruments.tokenCounter) {
-    instruments.tokenCounter.add(tokens, {
-      token_type: type,
-      ...labels
+  try {
+    const labels = sanitizeLabels({
+      ai_service: aiService,
+      ...model ? { model } : {}
     });
-  }
-  if (type === "input" && instruments.inputTokenCounter) {
-    instruments.inputTokenCounter.add(tokens, labels);
-  }
-  if (type === "output" && instruments.outputTokenCounter) {
-    instruments.outputTokenCounter.add(tokens, labels);
+    if (instruments.tokenCounter) {
+      instruments.tokenCounter.add(tokens, {
+        token_type: type,
+        ...labels
+      });
+    }
+    if (type === "input" && instruments.inputTokenCounter) {
+      instruments.inputTokenCounter.add(tokens, labels);
+    }
+    if (type === "output" && instruments.outputTokenCounter) {
+      instruments.outputTokenCounter.add(tokens, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record token metric:", error);
   }
 };
 var recordStreamingRequestMetric = (instruments, type, isStreaming, aiService, model) => {
@@ -1358,7 +1393,6 @@ var AxBaseAI = class {
       throw new Error("No model defined");
     }
     this.setOptions(options);
-    this.initializeMetricsInstruments();
     if (models) {
       validateModels(models);
     }
@@ -1373,8 +1407,6 @@ var AxBaseAI = class {
   models;
   abortSignal;
   logger = defaultLogger2;
-  // OpenTelemetry metrics instruments
-  metricsInstruments;
   modelInfo;
   modelUsage;
   embedModelUsage;
@@ -1416,10 +1448,8 @@ var AxBaseAI = class {
       }
     }
   };
-  initializeMetricsInstruments() {
-    if (this.meter) {
-      this.metricsInstruments = createMetricsInstruments(this.meter);
-    }
+  getMetricsInstruments() {
+    return getOrCreateAIMetricsInstruments(this.meter);
   }
   setName(name) {
     this.name = name;
@@ -1443,7 +1473,6 @@ var AxBaseAI = class {
     this.excludeContentFromTrace = options.excludeContentFromTrace;
     this.abortSignal = options.abortSignal;
     this.logger = options.logger ?? defaultLogger2;
-    this.initializeMetricsInstruments();
   }
   getOptions() {
     return {
@@ -1516,17 +1545,12 @@ var AxBaseAI = class {
     metrics.mean = metrics.samples.reduce((a, b) => a + b, 0) / metrics.samples.length;
     metrics.p95 = this.calculatePercentile(metrics.samples, 95);
     metrics.p99 = this.calculatePercentile(metrics.samples, 99);
-    if (this.metricsInstruments) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
       const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
-      recordLatencyMetric(
-        this.metricsInstruments,
-        type,
-        duration,
-        this.name,
-        model
-      );
+      recordLatencyMetric(metricsInstruments, type, duration, this.name, model);
       recordLatencyStatsMetrics(
-        this.metricsInstruments,
+        metricsInstruments,
         type,
         metrics.mean,
         metrics.p95,
@@ -1544,14 +1568,15 @@ var AxBaseAI = class {
       metrics.count++;
     }
     metrics.rate = metrics.count / metrics.total;
-    if (this.metricsInstruments) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
       const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
-      recordRequestMetric(this.metricsInstruments, type, this.name, model);
+      recordRequestMetric(metricsInstruments, type, this.name, model);
       if (isError) {
-        recordErrorMetric(this.metricsInstruments, type, this.name, model);
+        recordErrorMetric(metricsInstruments, type, this.name, model);
       }
       recordErrorRateMetric(
-        this.metricsInstruments,
+        metricsInstruments,
         type,
         metrics.rate,
         this.name,
@@ -1561,11 +1586,12 @@ var AxBaseAI = class {
   }
   // Method to record token usage metrics
   recordTokenUsage(modelUsage) {
-    if (this.metricsInstruments && modelUsage?.tokens) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments && modelUsage?.tokens) {
       const { promptTokens, completionTokens, totalTokens, thoughtsTokens } = modelUsage.tokens;
       if (promptTokens) {
         recordTokenMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           "input",
           promptTokens,
           this.name,
@@ -1574,7 +1600,7 @@ var AxBaseAI = class {
       }
       if (completionTokens) {
         recordTokenMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           "output",
           completionTokens,
           this.name,
@@ -1583,7 +1609,7 @@ var AxBaseAI = class {
       }
       if (totalTokens) {
         recordTokenMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           "total",
           totalTokens,
           this.name,
@@ -1592,7 +1618,7 @@ var AxBaseAI = class {
       }
       if (thoughtsTokens) {
         recordTokenMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           "thoughts",
           thoughtsTokens,
           this.name,
@@ -1699,11 +1725,12 @@ var AxBaseAI = class {
   }
   // Helper method to record function call metrics
   recordFunctionCallMetrics(functionCalls, model) {
-    if (!this.metricsInstruments || !functionCalls) return;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (!metricsInstruments || !functionCalls) return;
     for (const call of functionCalls) {
       if (call && typeof call === "object" && "function" in call && call.function && typeof call.function === "object" && "name" in call.function) {
         recordFunctionCallMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           call.function.name,
           void 0,
           // latency would need to be tracked separately
@@ -1715,26 +1742,29 @@ var AxBaseAI = class {
   }
   // Helper method to record timeout metrics
   recordTimeoutMetric(type) {
-    if (this.metricsInstruments) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
       const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
-      recordTimeoutMetric(this.metricsInstruments, type, this.name, model);
+      recordTimeoutMetric(metricsInstruments, type, this.name, model);
     }
   }
   // Helper method to record abort metrics
   recordAbortMetric(type) {
-    if (this.metricsInstruments) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
       const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
-      recordAbortMetric(this.metricsInstruments, type, this.name, model);
+      recordAbortMetric(metricsInstruments, type, this.name, model);
     }
   }
   // Comprehensive method to record all chat-related metrics
   recordChatMetrics(req, options, result) {
-    if (!this.metricsInstruments) return;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (!metricsInstruments) return;
     const model = this.lastUsedChatModel;
     const modelConfig = this.lastUsedModelConfig;
     const isStreaming = modelConfig?.stream ?? false;
     recordStreamingRequestMetric(
-      this.metricsInstruments,
+      metricsInstruments,
       "chat",
       isStreaming,
       this.name,
@@ -1742,21 +1772,16 @@ var AxBaseAI = class {
     );
     const { hasImages, hasAudio } = this.detectMultimodalContent(req);
     recordMultimodalRequestMetric(
-      this.metricsInstruments,
+      metricsInstruments,
       hasImages,
       hasAudio,
       this.name,
       model
     );
     const promptLength = this.calculatePromptLength(req);
-    recordPromptLengthMetric(
-      this.metricsInstruments,
-      promptLength,
-      this.name,
-      model
-    );
+    recordPromptLengthMetric(metricsInstruments, promptLength, this.name, model);
     recordModelConfigMetrics(
-      this.metricsInstruments,
+      metricsInstruments,
       modelConfig?.temperature,
       modelConfig?.maxTokens,
       this.name,
@@ -1764,7 +1789,7 @@ var AxBaseAI = class {
     );
     if (options?.thinkingTokenBudget && this.modelUsage?.tokens?.thoughtsTokens) {
       recordThinkingBudgetUsageMetric(
-        this.metricsInstruments,
+        metricsInstruments,
         this.modelUsage.tokens.thoughtsTokens,
         this.name,
         model
@@ -1772,7 +1797,7 @@ var AxBaseAI = class {
     }
     const requestSize = this.calculateRequestSize(req);
     recordRequestSizeMetric(
-      this.metricsInstruments,
+      metricsInstruments,
       "chat",
       requestSize,
       this.name,
@@ -1782,7 +1807,7 @@ var AxBaseAI = class {
       const chatResponse = result;
       const responseSize = this.calculateResponseSize(chatResponse);
       recordResponseSizeMetric(
-        this.metricsInstruments,
+        metricsInstruments,
         "chat",
         responseSize,
         this.name,
@@ -1804,7 +1829,7 @@ var AxBaseAI = class {
       );
       if (contextUsage > 0) {
         recordContextWindowUsageMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           contextUsage,
           this.name,
           model
@@ -1816,7 +1841,7 @@ var AxBaseAI = class {
       );
       if (estimatedCost > 0) {
         recordEstimatedCostMetric(
-          this.metricsInstruments,
+          metricsInstruments,
           "chat",
           estimatedCost,
           this.name,
@@ -1827,11 +1852,12 @@ var AxBaseAI = class {
   }
   // Comprehensive method to record all embed-related metrics
   recordEmbedMetrics(req, result) {
-    if (!this.metricsInstruments) return;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (!metricsInstruments) return;
     const model = this.lastUsedEmbedModel;
     const requestSize = this.calculateRequestSize(req);
     recordRequestSizeMetric(
-      this.metricsInstruments,
+      metricsInstruments,
       "embed",
       requestSize,
       this.name,
@@ -1839,7 +1865,7 @@ var AxBaseAI = class {
     );
     const responseSize = this.calculateResponseSize(result);
     recordResponseSizeMetric(
-      this.metricsInstruments,
+      metricsInstruments,
       "embed",
       responseSize,
       this.name,
@@ -1848,7 +1874,7 @@ var AxBaseAI = class {
     const estimatedCost = this.estimateCostByName(model, result.modelUsage);
     if (estimatedCost > 0) {
       recordEstimatedCostMetric(
-        this.metricsInstruments,
+        metricsInstruments,
         "embed",
         estimatedCost,
         this.name,
@@ -8522,196 +8548,691 @@ function createFunctionConfig(functionList, definedFunctionCall, firstStep) {
   return { functions, functionCall };
 }
 
-// dsp/processResponse.ts
-import "stream/web";
-
-// ai/util.ts
-function mergeFunctionCalls(functionCalls, functionCallDeltas) {
-  for (const _fc of functionCallDeltas) {
-    const fc = functionCalls.find((fc2) => fc2.id === _fc.id);
-    if (fc) {
-      if (typeof _fc.function.name == "string" && _fc.function.name.length > 0) {
-        fc.function.name += _fc.function.name;
-      }
-      if (typeof _fc.function.params == "string" && _fc.function.params.length > 0) {
-        fc.function.params += _fc.function.params;
-      }
-      if (typeof _fc.function.params == "object") {
-        fc.function.params = _fc.function.params;
-      }
-    } else {
-      functionCalls.push(_fc);
-    }
+// dsp/metrics.ts
+var axDefaultMetricsConfig = {
+  enabled: true,
+  enabledCategories: [
+    "generation",
+    "streaming",
+    "functions",
+    "errors",
+    "performance"
+  ],
+  maxLabelLength: 100,
+  samplingRate: 1
+};
+var globalGenMetricsInstruments;
+var getOrCreateGenMetricsInstruments = (meter) => {
+  if (globalGenMetricsInstruments) {
+    return globalGenMetricsInstruments;
   }
-}
-
-// dsp/sig.ts
-import { createHash } from "crypto";
-
-// dsp/parser.ts
-var SignatureValidationError = class extends Error {
-  constructor(message, position, context3, suggestion) {
-    super(message);
-    this.position = position;
-    this.context = context3;
-    this.suggestion = suggestion;
-    this.name = "SignatureValidationError";
+  const activeMeter = meter ?? axGlobals.meter;
+  if (activeMeter) {
+    globalGenMetricsInstruments = createGenMetricsInstruments(activeMeter);
+    return globalGenMetricsInstruments;
   }
+  return void 0;
 };
-var SignatureParser = class {
-  input;
-  position;
-  currentFieldName = null;
-  currentSection = "description";
-  constructor(input) {
-    this.input = input.trim();
-    this.position = 0;
-    if (!this.input) {
-      throw new SignatureValidationError(
-        "Empty signature provided",
-        0,
-        "",
-        'A signature must contain at least input and output fields separated by "->". Example: "userQuery:string -> aiResponse:string"'
-      );
-    }
+var axCheckMetricsHealth = () => {
+  const issues = [];
+  if (!axGlobals.meter) {
+    issues.push("Global meter not initialized");
   }
-  parse() {
-    try {
-      this.skipWhitespace();
-      const optionalDesc = this.parseParsedString();
-      this.skipWhitespace();
-      this.currentSection = "inputs";
-      const inputs = this.parseFieldList(
-        this.parseInputField.bind(this),
-        "input"
-      );
-      this.skipWhitespace();
-      if (this.position >= this.input.length) {
-        throw new SignatureValidationError(
-          "Incomplete signature: Missing output section",
-          this.position,
-          this.getErrorContext(),
-          'Add "->" followed by output fields. Example: "-> responseText:string"'
-        );
+  if (!globalGenMetricsInstruments && axGlobals.meter) {
+    issues.push("Metrics instruments not created despite available meter");
+  }
+  return {
+    healthy: issues.length === 0,
+    issues
+  };
+};
+var createGenMetricsInstruments = (meter) => {
+  return {
+    // Generation flow metrics
+    // Note: Histogram buckets should be configured at the exporter level
+    // Recommended buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000] ms
+    generationLatencyHistogram: meter.createHistogram(
+      "ax_gen_generation_duration_ms",
+      {
+        description: "End-to-end duration of AxGen generation requests",
+        unit: "ms"
       }
-      this.expectArrow();
-      this.skipWhitespace();
-      if (this.position >= this.input.length) {
-        throw new SignatureValidationError(
-          'Incomplete signature: No output fields specified after "->"',
-          this.position,
-          this.getErrorContext(),
-          'Add at least one output field. Example: "-> responseText:string"'
-        );
+    ),
+    generationRequestsCounter: meter.createCounter(
+      "ax_gen_generation_requests_total",
+      {
+        description: "Total number of AxGen generation requests"
       }
-      this.currentSection = "outputs";
-      const outputs = this.parseFieldList(
-        this.parseOutputField.bind(this),
-        "output"
-      );
-      this.skipWhitespace();
-      if (this.position < this.input.length) {
-        const remaining = this.input.slice(this.position);
-        throw new SignatureValidationError(
-          `Unexpected content after signature: "${remaining}"`,
-          this.position,
-          this.getErrorContext(),
-          "Remove any extra content after the output fields"
-        );
+    ),
+    generationErrorsCounter: meter.createCounter(
+      "ax_gen_generation_errors_total",
+      {
+        description: "Total number of failed AxGen generations"
       }
-      this.validateParsedSignature({
-        desc: optionalDesc?.trim(),
-        inputs,
-        outputs
-      });
-      return {
-        desc: optionalDesc?.trim(),
-        inputs,
-        outputs
-      };
-    } catch (error) {
-      if (error instanceof SignatureValidationError) {
-        throw error;
+    ),
+    // Multi-step flow metrics
+    multiStepGenerationsCounter: meter.createCounter(
+      "ax_gen_multistep_generations_total",
+      {
+        description: "Total number of generations that required multiple steps"
       }
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new SignatureValidationError(
-        errorMessage,
-        this.position,
-        this.getErrorContext()
-      );
-    }
-  }
-  validateParsedSignature(signature) {
-    const inputNames = /* @__PURE__ */ new Set();
-    for (const field of signature.inputs) {
-      if (inputNames.has(field.name)) {
-        throw new SignatureValidationError(
-          `Duplicate input field name: "${field.name}"`,
-          0,
-          "",
-          "Each field name must be unique within the signature"
-        );
+    ),
+    stepsPerGenerationHistogram: meter.createHistogram(
+      "ax_gen_steps_per_generation",
+      {
+        description: "Number of steps taken per generation"
       }
-      inputNames.add(field.name);
-    }
-    const outputNames = /* @__PURE__ */ new Set();
-    for (const field of signature.outputs) {
-      if (outputNames.has(field.name)) {
-        throw new SignatureValidationError(
-          `Duplicate output field name: "${field.name}"`,
-          0,
-          "",
-          "Each field name must be unique within the signature"
-        );
+    ),
+    maxStepsReachedCounter: meter.createCounter(
+      "ax_gen_max_steps_reached_total",
+      {
+        description: "Total number of generations that hit max steps limit"
       }
-      outputNames.add(field.name);
-    }
-    for (const outputField of signature.outputs) {
-      if (inputNames.has(outputField.name)) {
-        throw new SignatureValidationError(
-          `Field name "${outputField.name}" appears in both inputs and outputs`,
-          0,
-          "",
-          "Use different names for input and output fields to avoid confusion"
-        );
+    ),
+    // Error correction metrics
+    validationErrorsCounter: meter.createCounter(
+      "ax_gen_validation_errors_total",
+      {
+        description: "Total number of validation errors encountered"
       }
-    }
-    if (signature.inputs.length === 0) {
-      throw new SignatureValidationError(
-        "Signature must have at least one input field",
-        0,
-        "",
-        'Add an input field before "->". Example: "userInput:string -> ..."'
-      );
-    }
-    if (signature.outputs.length === 0) {
-      throw new SignatureValidationError(
-        "Signature must have at least one output field",
-        0,
-        "",
-        'Add an output field after "->". Example: "... -> responseText:string"'
-      );
-    }
-  }
-  getErrorContext() {
-    const start = Math.max(0, this.position - 25);
-    const end = Math.min(this.input.length, this.position + 25);
-    const before = this.input.slice(start, this.position);
-    const after = this.input.slice(this.position, end);
-    const pointer = " ".repeat(before.length) + "^";
-    const lines = [
-      `Position ${this.position} in signature:`,
-      `"${before}${after}"`,
-      ` ${pointer}`
-    ];
-    return lines.join("\n");
-  }
-  parseFieldList(parseFieldFn, section) {
-    const fields = [];
-    this.skipWhitespace();
-    if (this.position >= this.input.length) {
-      throw new SignatureValidationError(
-        `Empty ${section} section: Expected at least one field`,
+    ),
+    assertionErrorsCounter: meter.createCounter(
+      "ax_gen_assertion_errors_total",
+      {
+        description: "Total number of assertion errors encountered"
+      }
+    ),
+    errorCorrectionAttemptsHistogram: meter.createHistogram(
+      "ax_gen_error_correction_attempts",
+      {
+        description: "Number of error correction attempts per generation"
+      }
+    ),
+    errorCorrectionSuccessCounter: meter.createCounter(
+      "ax_gen_error_correction_success_total",
+      {
+        description: "Total number of successful error corrections"
+      }
+    ),
+    errorCorrectionFailureCounter: meter.createCounter(
+      "ax_gen_error_correction_failure_total",
+      {
+        description: "Total number of failed error corrections"
+      }
+    ),
+    maxRetriesReachedCounter: meter.createCounter(
+      "ax_gen_max_retries_reached_total",
+      {
+        description: "Total number of generations that hit max retries limit"
+      }
+    ),
+    // Function calling metrics
+    functionsEnabledGenerationsCounter: meter.createCounter(
+      "ax_gen_functions_enabled_generations_total",
+      {
+        description: "Total number of generations with functions enabled"
+      }
+    ),
+    functionCallStepsCounter: meter.createCounter(
+      "ax_gen_function_call_steps_total",
+      {
+        description: "Total number of steps that included function calls"
+      }
+    ),
+    functionsExecutedPerGenerationHistogram: meter.createHistogram(
+      "ax_gen_functions_executed_per_generation",
+      {
+        description: "Number of unique functions executed per generation"
+      }
+    ),
+    functionErrorCorrectionCounter: meter.createCounter(
+      "ax_gen_function_error_correction_total",
+      {
+        description: "Total number of function-related error corrections"
+      }
+    ),
+    // Field processing metrics
+    fieldProcessorsExecutedCounter: meter.createCounter(
+      "ax_gen_field_processors_executed_total",
+      {
+        description: "Total number of field processors executed"
+      }
+    ),
+    streamingFieldProcessorsExecutedCounter: meter.createCounter(
+      "ax_gen_streaming_field_processors_executed_total",
+      {
+        description: "Total number of streaming field processors executed"
+      }
+    ),
+    // Streaming specific metrics
+    streamingGenerationsCounter: meter.createCounter(
+      "ax_gen_streaming_generations_total",
+      {
+        description: "Total number of streaming generations"
+      }
+    ),
+    streamingDeltasEmittedCounter: meter.createCounter(
+      "ax_gen_streaming_deltas_emitted_total",
+      {
+        description: "Total number of streaming deltas emitted"
+      }
+    ),
+    streamingFinalizationLatencyHistogram: meter.createHistogram(
+      "ax_gen_streaming_finalization_duration_ms",
+      {
+        description: "Duration of streaming response finalization",
+        unit: "ms"
+      }
+    ),
+    // Memory and samples metrics
+    samplesGeneratedHistogram: meter.createHistogram(
+      "ax_gen_samples_generated",
+      {
+        description: "Number of samples generated per request"
+      }
+    ),
+    resultPickerUsageCounter: meter.createCounter(
+      "ax_gen_result_picker_usage_total",
+      {
+        description: "Total number of times result picker was used"
+      }
+    ),
+    resultPickerLatencyHistogram: meter.createHistogram(
+      "ax_gen_result_picker_duration_ms",
+      {
+        description: "Duration of result picker execution",
+        unit: "ms"
+      }
+    ),
+    // Signature complexity metrics
+    inputFieldsGauge: meter.createGauge("ax_gen_input_fields", {
+      description: "Number of input fields in signature"
+    }),
+    outputFieldsGauge: meter.createGauge("ax_gen_output_fields", {
+      description: "Number of output fields in signature"
+    }),
+    examplesUsedGauge: meter.createGauge("ax_gen_examples_used", {
+      description: "Number of examples used in generation"
+    }),
+    demosUsedGauge: meter.createGauge("ax_gen_demos_used", {
+      description: "Number of demos used in generation"
+    }),
+    // Performance metrics
+    promptRenderLatencyHistogram: meter.createHistogram(
+      "ax_gen_prompt_render_duration_ms",
+      {
+        description: "Duration of prompt template rendering",
+        unit: "ms"
+      }
+    ),
+    extractionLatencyHistogram: meter.createHistogram(
+      "ax_gen_extraction_duration_ms",
+      {
+        description: "Duration of value extraction from responses",
+        unit: "ms"
+      }
+    ),
+    assertionLatencyHistogram: meter.createHistogram(
+      "ax_gen_assertion_duration_ms",
+      {
+        description: "Duration of assertion checking",
+        unit: "ms"
+      }
+    ),
+    // State management
+    stateCreationLatencyHistogram: meter.createHistogram(
+      "ax_gen_state_creation_duration_ms",
+      {
+        description: "Duration of state creation for multiple samples",
+        unit: "ms"
+      }
+    ),
+    memoryUpdateLatencyHistogram: meter.createHistogram(
+      "ax_gen_memory_update_duration_ms",
+      {
+        description: "Duration of memory updates during generation",
+        unit: "ms"
+      }
+    )
+  };
+};
+var currentMetricsConfig = axDefaultMetricsConfig;
+var axUpdateMetricsConfig = (config) => {
+  currentMetricsConfig = { ...currentMetricsConfig, ...config };
+};
+var axGetMetricsConfig = () => {
+  return { ...currentMetricsConfig };
+};
+var sanitizeLabels2 = (labels) => {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(labels)) {
+    if (value !== void 0 && value !== null) {
+      const stringValue = String(value);
+      const maxLength = currentMetricsConfig.maxLabelLength;
+      sanitized[key] = stringValue.length > maxLength ? stringValue.substring(0, maxLength) : stringValue;
+    }
+  }
+  return sanitized;
+};
+var recordGenerationMetric = (instruments, duration, success, signatureName, aiService, model) => {
+  try {
+    const labels = sanitizeLabels2({
+      success: success.toString(),
+      ...signatureName ? { signature: signatureName } : {},
+      ...aiService ? { ai_service: aiService } : {},
+      ...model ? { model } : {}
+    });
+    if (instruments.generationLatencyHistogram) {
+      instruments.generationLatencyHistogram.record(duration, labels);
+    }
+    if (instruments.generationRequestsCounter) {
+      instruments.generationRequestsCounter.add(1, labels);
+    }
+    if (!success && instruments.generationErrorsCounter) {
+      instruments.generationErrorsCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record generation metric:", error);
+  }
+};
+var recordMultiStepMetric = (instruments, stepsUsed, maxSteps, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (stepsUsed > 1 && instruments.multiStepGenerationsCounter) {
+      instruments.multiStepGenerationsCounter.add(1, labels);
+    }
+    if (instruments.stepsPerGenerationHistogram) {
+      instruments.stepsPerGenerationHistogram.record(stepsUsed, labels);
+    }
+    if (stepsUsed >= maxSteps && instruments.maxStepsReachedCounter) {
+      instruments.maxStepsReachedCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record multi-step metric:", error);
+  }
+};
+var recordValidationErrorMetric = (instruments, errorType, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      error_type: errorType,
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (errorType === "validation" && instruments.validationErrorsCounter) {
+      instruments.validationErrorsCounter.add(1, labels);
+    }
+    if (errorType === "assertion" && instruments.assertionErrorsCounter) {
+      instruments.assertionErrorsCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record validation error metric:", error);
+  }
+};
+var recordErrorCorrectionMetric = (instruments, attempts, success, maxRetries, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      success: success.toString(),
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (instruments.errorCorrectionAttemptsHistogram) {
+      instruments.errorCorrectionAttemptsHistogram.record(attempts, labels);
+    }
+    if (success && instruments.errorCorrectionSuccessCounter) {
+      instruments.errorCorrectionSuccessCounter.add(1, labels);
+    }
+    if (!success) {
+      if (instruments.errorCorrectionFailureCounter) {
+        instruments.errorCorrectionFailureCounter.add(1, labels);
+      }
+      if (attempts >= maxRetries && instruments.maxRetriesReachedCounter) {
+        instruments.maxRetriesReachedCounter.add(1, labels);
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to record error correction metric:", error);
+  }
+};
+var recordFunctionCallingMetric = (instruments, functionsEnabled, functionsExecuted, hadFunctionCalls, functionErrorCorrection = false, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      functions_enabled: functionsEnabled.toString(),
+      had_function_calls: hadFunctionCalls.toString(),
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (functionsEnabled && instruments.functionsEnabledGenerationsCounter) {
+      instruments.functionsEnabledGenerationsCounter.add(1, labels);
+    }
+    if (hadFunctionCalls && instruments.functionCallStepsCounter) {
+      instruments.functionCallStepsCounter.add(1, labels);
+    }
+    if (functionsExecuted > 0 && instruments.functionsExecutedPerGenerationHistogram) {
+      instruments.functionsExecutedPerGenerationHistogram.record(
+        functionsExecuted,
+        labels
+      );
+    }
+    if (functionErrorCorrection && instruments.functionErrorCorrectionCounter) {
+      instruments.functionErrorCorrectionCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record function calling metric:", error);
+  }
+};
+var recordFieldProcessingMetric = (instruments, fieldProcessorsExecuted, streamingFieldProcessorsExecuted, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (fieldProcessorsExecuted > 0 && instruments.fieldProcessorsExecutedCounter) {
+      instruments.fieldProcessorsExecutedCounter.add(
+        fieldProcessorsExecuted,
+        labels
+      );
+    }
+    if (streamingFieldProcessorsExecuted > 0 && instruments.streamingFieldProcessorsExecutedCounter) {
+      instruments.streamingFieldProcessorsExecutedCounter.add(
+        streamingFieldProcessorsExecuted,
+        labels
+      );
+    }
+  } catch (error) {
+    console.warn("Failed to record field processing metric:", error);
+  }
+};
+var recordStreamingMetric = (instruments, isStreaming, deltasEmitted, finalizationDuration, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      is_streaming: isStreaming.toString(),
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (isStreaming && instruments.streamingGenerationsCounter) {
+      instruments.streamingGenerationsCounter.add(1, labels);
+    }
+    if (deltasEmitted > 0 && instruments.streamingDeltasEmittedCounter) {
+      instruments.streamingDeltasEmittedCounter.add(deltasEmitted, labels);
+    }
+    if (finalizationDuration && instruments.streamingFinalizationLatencyHistogram) {
+      instruments.streamingFinalizationLatencyHistogram.record(
+        finalizationDuration,
+        labels
+      );
+    }
+  } catch (error) {
+    console.warn("Failed to record streaming metric:", error);
+  }
+};
+var recordSamplesMetric = (instruments, samplesCount, resultPickerUsed, resultPickerLatency, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      result_picker_used: resultPickerUsed.toString(),
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (instruments.samplesGeneratedHistogram) {
+      instruments.samplesGeneratedHistogram.record(samplesCount, labels);
+    }
+    if (resultPickerUsed && instruments.resultPickerUsageCounter) {
+      instruments.resultPickerUsageCounter.add(1, labels);
+    }
+    if (resultPickerLatency && instruments.resultPickerLatencyHistogram) {
+      instruments.resultPickerLatencyHistogram.record(
+        resultPickerLatency,
+        labels
+      );
+    }
+  } catch (error) {
+    console.warn("Failed to record samples metric:", error);
+  }
+};
+var recordSignatureComplexityMetrics = (instruments, inputFields, outputFields, examplesCount, demosCount, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    if (instruments.inputFieldsGauge) {
+      instruments.inputFieldsGauge.record(inputFields, labels);
+    }
+    if (instruments.outputFieldsGauge) {
+      instruments.outputFieldsGauge.record(outputFields, labels);
+    }
+    if (instruments.examplesUsedGauge) {
+      instruments.examplesUsedGauge.record(examplesCount, labels);
+    }
+    if (instruments.demosUsedGauge) {
+      instruments.demosUsedGauge.record(demosCount, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record signature complexity metrics:", error);
+  }
+};
+var recordPerformanceMetric = (instruments, metricType, duration, signatureName) => {
+  try {
+    const labels = sanitizeLabels2({
+      metric_type: metricType,
+      ...signatureName ? { signature: signatureName } : {}
+    });
+    switch (metricType) {
+      case "prompt_render":
+        if (instruments.promptRenderLatencyHistogram) {
+          instruments.promptRenderLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "extraction":
+        if (instruments.extractionLatencyHistogram) {
+          instruments.extractionLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "assertion":
+        if (instruments.assertionLatencyHistogram) {
+          instruments.assertionLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "state_creation":
+        if (instruments.stateCreationLatencyHistogram) {
+          instruments.stateCreationLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "memory_update":
+        if (instruments.memoryUpdateLatencyHistogram) {
+          instruments.memoryUpdateLatencyHistogram.record(duration, labels);
+        }
+        break;
+    }
+  } catch (error) {
+    console.warn("Failed to record performance metric:", error);
+  }
+};
+
+// dsp/processResponse.ts
+import "stream/web";
+
+// ai/util.ts
+function mergeFunctionCalls(functionCalls, functionCallDeltas) {
+  for (const _fc of functionCallDeltas) {
+    const fc = functionCalls.find((fc2) => fc2.id === _fc.id);
+    if (fc) {
+      if (typeof _fc.function.name == "string" && _fc.function.name.length > 0) {
+        fc.function.name += _fc.function.name;
+      }
+      if (typeof _fc.function.params == "string" && _fc.function.params.length > 0) {
+        fc.function.params += _fc.function.params;
+      }
+      if (typeof _fc.function.params == "object") {
+        fc.function.params = _fc.function.params;
+      }
+    } else {
+      functionCalls.push(_fc);
+    }
+  }
+}
+
+// dsp/sig.ts
+import { createHash } from "crypto";
+
+// dsp/parser.ts
+var SignatureValidationError = class extends Error {
+  constructor(message, position, context3, suggestion) {
+    super(message);
+    this.position = position;
+    this.context = context3;
+    this.suggestion = suggestion;
+    this.name = "SignatureValidationError";
+  }
+};
+var SignatureParser = class {
+  input;
+  position;
+  currentFieldName = null;
+  currentSection = "description";
+  constructor(input) {
+    this.input = input.trim();
+    this.position = 0;
+    if (!this.input) {
+      throw new SignatureValidationError(
+        "Empty signature provided",
+        0,
+        "",
+        'A signature must contain at least input and output fields separated by "->". Example: "userQuery:string -> aiResponse:string"'
+      );
+    }
+  }
+  parse() {
+    try {
+      this.skipWhitespace();
+      const optionalDesc = this.parseParsedString();
+      this.skipWhitespace();
+      this.currentSection = "inputs";
+      const inputs = this.parseFieldList(
+        this.parseInputField.bind(this),
+        "input"
+      );
+      this.skipWhitespace();
+      if (this.position >= this.input.length) {
+        throw new SignatureValidationError(
+          "Incomplete signature: Missing output section",
+          this.position,
+          this.getErrorContext(),
+          'Add "->" followed by output fields. Example: "-> responseText:string"'
+        );
+      }
+      this.expectArrow();
+      this.skipWhitespace();
+      if (this.position >= this.input.length) {
+        throw new SignatureValidationError(
+          'Incomplete signature: No output fields specified after "->"',
+          this.position,
+          this.getErrorContext(),
+          'Add at least one output field. Example: "-> responseText:string"'
+        );
+      }
+      this.currentSection = "outputs";
+      const outputs = this.parseFieldList(
+        this.parseOutputField.bind(this),
+        "output"
+      );
+      this.skipWhitespace();
+      if (this.position < this.input.length) {
+        const remaining = this.input.slice(this.position);
+        throw new SignatureValidationError(
+          `Unexpected content after signature: "${remaining}"`,
+          this.position,
+          this.getErrorContext(),
+          "Remove any extra content after the output fields"
+        );
+      }
+      this.validateParsedSignature({
+        desc: optionalDesc?.trim(),
+        inputs,
+        outputs
+      });
+      return {
+        desc: optionalDesc?.trim(),
+        inputs,
+        outputs
+      };
+    } catch (error) {
+      if (error instanceof SignatureValidationError) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new SignatureValidationError(
+        errorMessage,
+        this.position,
+        this.getErrorContext()
+      );
+    }
+  }
+  validateParsedSignature(signature) {
+    const inputNames = /* @__PURE__ */ new Set();
+    for (const field of signature.inputs) {
+      if (inputNames.has(field.name)) {
+        throw new SignatureValidationError(
+          `Duplicate input field name: "${field.name}"`,
+          0,
+          "",
+          "Each field name must be unique within the signature"
+        );
+      }
+      inputNames.add(field.name);
+    }
+    const outputNames = /* @__PURE__ */ new Set();
+    for (const field of signature.outputs) {
+      if (outputNames.has(field.name)) {
+        throw new SignatureValidationError(
+          `Duplicate output field name: "${field.name}"`,
+          0,
+          "",
+          "Each field name must be unique within the signature"
+        );
+      }
+      outputNames.add(field.name);
+    }
+    for (const outputField of signature.outputs) {
+      if (inputNames.has(outputField.name)) {
+        throw new SignatureValidationError(
+          `Field name "${outputField.name}" appears in both inputs and outputs`,
+          0,
+          "",
+          "Use different names for input and output fields to avoid confusion"
+        );
+      }
+    }
+    if (signature.inputs.length === 0) {
+      throw new SignatureValidationError(
+        "Signature must have at least one input field",
+        0,
+        "",
+        'Add an input field before "->". Example: "userInput:string -> ..."'
+      );
+    }
+    if (signature.outputs.length === 0) {
+      throw new SignatureValidationError(
+        "Signature must have at least one output field",
+        0,
+        "",
+        'Add an output field after "->". Example: "... -> responseText:string"'
+      );
+    }
+  }
+  getErrorContext() {
+    const start = Math.max(0, this.position - 25);
+    const end = Math.min(this.input.length, this.position + 25);
+    const before = this.input.slice(start, this.position);
+    const after = this.input.slice(this.position, end);
+    const pointer = " ".repeat(before.length) + "^";
+    const lines = [
+      `Position ${this.position} in signature:`,
+      `"${before}${after}"`,
+      ` ${pointer}`
+    ];
+    return lines.join("\n");
+  }
+  parseFieldList(parseFieldFn, section) {
+    const fields = [];
+    this.skipWhitespace();
+    if (this.position >= this.input.length) {
+      throw new SignatureValidationError(
+        `Empty ${section} section: Expected at least one field`,
         this.position,
         this.getErrorContext(),
         `Add a ${section} field. Example: ${section === "input" ? "userInput:string" : "responseText:string"}`
@@ -10914,6 +11435,15 @@ var AxGen = class extends AxProgramWithSignature {
       this.functions = parseFunctions(options.functions);
     }
   }
+  getSignatureName() {
+    return this.signature.getDescription() || "unknown_signature";
+  }
+  getMetricsInstruments() {
+    return getOrCreateGenMetricsInstruments();
+  }
+  updateMeter(meter) {
+    getOrCreateGenMetricsInstruments(meter);
+  }
   createStates(n) {
     return Array.from({ length: n }, (_, index) => ({
       index,
@@ -11103,6 +11633,7 @@ var AxGen = class extends AxProgramWithSignature {
       );
     }
     let prompt;
+    const promptRenderStart = performance.now();
     if (Array.isArray(values)) {
       validateAxMessageArray(values);
       prompt = this.promptTemplate.render(values, {
@@ -11116,7 +11647,27 @@ var AxGen = class extends AxProgramWithSignature {
         demos: this.demos
       });
     }
+    const promptRenderDuration = performance.now() - promptRenderStart;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      recordPerformanceMetric(
+        metricsInstruments,
+        "prompt_render",
+        promptRenderDuration,
+        this.getSignatureName()
+      );
+    }
+    const memoryUpdateStart = performance.now();
     mem.addRequest(prompt, options.sessionId);
+    const memoryUpdateDuration = performance.now() - memoryUpdateStart;
+    if (metricsInstruments) {
+      recordPerformanceMetric(
+        metricsInstruments,
+        "memory_update",
+        memoryUpdateDuration,
+        this.getSignatureName()
+      );
+    }
     multiStepLoop: for (let n = 0; n < maxSteps; n++) {
       const firstStep = n === 0;
       for (let errCount = 0; errCount < maxRetries; errCount++) {
@@ -11145,8 +11696,48 @@ var AxGen = class extends AxProgramWithSignature {
             options?.sessionId
           );
           if (shouldContinue) {
+            const metricsInstruments4 = this.getMetricsInstruments();
+            if (metricsInstruments4) {
+              recordMultiStepMetric(
+                metricsInstruments4,
+                n + 1,
+                maxSteps,
+                this.getSignatureName()
+              );
+            }
             continue multiStepLoop;
           }
+          const metricsInstruments3 = this.getMetricsInstruments();
+          if (metricsInstruments3) {
+            recordMultiStepMetric(
+              metricsInstruments3,
+              n + 1,
+              maxSteps,
+              this.getSignatureName()
+            );
+            const allFunctionsExecuted = /* @__PURE__ */ new Set();
+            states.forEach((state) => {
+              state.functionsExecuted.forEach(
+                (func) => allFunctionsExecuted.add(func)
+              );
+            });
+            if (allFunctionsExecuted.size > 0) {
+              recordFunctionCallingMetric(
+                metricsInstruments3,
+                true,
+                allFunctionsExecuted.size,
+                true,
+                false,
+                this.getSignatureName()
+              );
+            }
+            recordFieldProcessingMetric(
+              metricsInstruments3,
+              this.fieldProcessors.length,
+              this.streamingFieldProcessors.length,
+              this.getSignatureName()
+            );
+          }
           this.getLogger(ai, options)?.("", { tags: ["responseEnd"] });
           return;
         } catch (e) {
@@ -11155,6 +11746,14 @@ var AxGen = class extends AxProgramWithSignature {
           if (e instanceof ValidationError) {
             errorFields = e.getFixingInstructions();
             err = e;
+            const metricsInstruments3 = this.getMetricsInstruments();
+            if (metricsInstruments3) {
+              recordValidationErrorMetric(
+                metricsInstruments3,
+                "validation",
+                this.getSignatureName()
+              );
+            }
             if (span) {
               span.addEvent("validation.error", {
                 message: e.toString(),
@@ -11165,6 +11764,14 @@ var AxGen = class extends AxProgramWithSignature {
             const e1 = e;
             errorFields = e1.getFixingInstructions();
             err = e;
+            const assertionMetricsInstruments = this.getMetricsInstruments();
+            if (assertionMetricsInstruments) {
+              recordValidationErrorMetric(
+                assertionMetricsInstruments,
+                "assertion",
+                this.getSignatureName()
+              );
+            }
             if (span) {
               span.addEvent("assertion.error", {
                 message: e1.toString(),
@@ -11186,12 +11793,31 @@ var AxGen = class extends AxProgramWithSignature {
           }
         }
       }
+      const metricsInstruments2 = this.getMetricsInstruments();
+      if (metricsInstruments2) {
+        recordErrorCorrectionMetric(
+          metricsInstruments2,
+          maxRetries,
+          false,
+          // failed
+          maxRetries,
+          this.getSignatureName()
+        );
+      }
       throw enhanceError(
         new Error(`Unable to fix validation error: ${err?.toString()}`),
         ai,
         this.signature
       );
     }
+    if (metricsInstruments) {
+      recordMultiStepMetric(
+        metricsInstruments,
+        maxSteps,
+        maxSteps,
+        this.getSignatureName()
+      );
+    }
     throw enhanceError(
       new Error(`Max steps reached: ${maxSteps}`),
       ai,
@@ -11199,7 +11825,18 @@ var AxGen = class extends AxProgramWithSignature {
     );
   }
   async *_forward1(ai, values, options) {
+    const stateCreationStart = performance.now();
     const states = this.createStates(options.sampleCount ?? 1);
+    const stateCreationDuration = performance.now() - stateCreationStart;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      recordPerformanceMetric(
+        metricsInstruments,
+        "state_creation",
+        stateCreationDuration,
+        this.getSignatureName()
+      );
+    }
     const tracer = options?.tracer ?? this.options?.tracer ?? ai.getOptions().tracer;
     let functions = this.functions;
     if (options?.functions) {
@@ -11258,29 +11895,111 @@ var AxGen = class extends AxProgramWithSignature {
     }
   }
   async forward(ai, values, options) {
-    const generator = this._forward1(ai, values, options ?? {});
-    let buffer = [];
-    let currentVersion = 0;
-    for await (const delta of generator) {
-      if (delta.version !== currentVersion) {
-        buffer = [];
+    const startTime = performance.now();
+    const signatureName = this.getSignatureName();
+    const isStreaming = options?.stream ?? false;
+    let success = false;
+    let errorCorrectionAttempts = 0;
+    let functionsEnabled = false;
+    let functionsExecuted = 0;
+    let resultPickerUsed = false;
+    try {
+      const metricsInstruments = this.getMetricsInstruments();
+      if (metricsInstruments) {
+        recordSignatureComplexityMetrics(
+          metricsInstruments,
+          this.signature.getInputFields().length,
+          this.signature.getOutputFields().length,
+          this.examples?.length ?? 0,
+          this.demos?.length ?? 0,
+          signatureName
+        );
       }
-      currentVersion = delta.version;
-      buffer = mergeDeltas(buffer, delta);
-    }
-    const selectedIndex = await selectFromSamples(
-      buffer,
-      {
-        resultPicker: options?.resultPicker
-      },
-      // Pass memory to enable function result selection
-      options?.mem,
-      options?.sessionId
-    );
-    const selectedResult = buffer[selectedIndex];
-    const result = selectedResult?.delta ?? {};
-    this.trace = { ...values, ...result };
-    return result;
+      functionsEnabled = !!(options?.functions || this.functions);
+      const generator = this._forward1(ai, values, options ?? {});
+      let buffer = [];
+      let currentVersion = 0;
+      let deltasEmitted = 0;
+      for await (const delta of generator) {
+        if (delta.version !== currentVersion) {
+          buffer = [];
+        }
+        currentVersion = delta.version;
+        buffer = mergeDeltas(buffer, delta);
+        deltasEmitted++;
+      }
+      errorCorrectionAttempts = currentVersion;
+      const resultPickerStart = performance.now();
+      resultPickerUsed = !!options?.resultPicker;
+      const selectedIndex = await selectFromSamples(
+        buffer,
+        {
+          resultPicker: options?.resultPicker
+        },
+        // Pass memory to enable function result selection
+        options?.mem,
+        options?.sessionId
+      );
+      const resultPickerLatency = performance.now() - resultPickerStart;
+      const selectedResult = buffer[selectedIndex];
+      const result = selectedResult?.delta ?? {};
+      this.trace = { ...values, ...result };
+      success = true;
+      if (metricsInstruments) {
+        recordSamplesMetric(
+          metricsInstruments,
+          buffer.length,
+          resultPickerUsed,
+          resultPickerUsed ? resultPickerLatency : void 0,
+          signatureName
+        );
+        recordStreamingMetric(
+          metricsInstruments,
+          isStreaming,
+          deltasEmitted,
+          void 0,
+          // finalization latency not applicable here
+          signatureName
+        );
+      }
+      return result;
+    } catch (error) {
+      success = false;
+      throw error;
+    } finally {
+      const duration = performance.now() - startTime;
+      const finalMetricsInstruments = this.getMetricsInstruments();
+      if (finalMetricsInstruments) {
+        recordGenerationMetric(
+          finalMetricsInstruments,
+          duration,
+          success,
+          signatureName,
+          ai.getName(),
+          options?.model
+        );
+        if (functionsEnabled) {
+          recordFunctionCallingMetric(
+            finalMetricsInstruments,
+            functionsEnabled,
+            functionsExecuted,
+            functionsExecuted > 0,
+            false,
+            // function error correction tracking would need more complex logic
+            signatureName
+          );
+        }
+        if (errorCorrectionAttempts > 0) {
+          recordErrorCorrectionMetric(
+            finalMetricsInstruments,
+            errorCorrectionAttempts,
+            success,
+            options?.maxRetries ?? 10,
+            signatureName
+          );
+        }
+      }
+    }
   }
   async *streamingForward(ai, values, options) {
     if (!options?.resultPicker) {
@@ -11836,143 +12555,603 @@ var AxBalancer = class _AxBalancer {
     );
     return timeSinceLastFailure >= backoffMs;
   }
-  handleFailure() {
-    const failure = this.serviceFailures.get(this.currentService.getId());
-    const retries = (failure?.retries ?? 0) + 1;
-    this.serviceFailures.set(this.currentService.getId(), {
-      retries,
-      lastFailureTime: Date.now()
+  handleFailure() {
+    const failure = this.serviceFailures.get(this.currentService.getId());
+    const retries = (failure?.retries ?? 0) + 1;
+    this.serviceFailures.set(this.currentService.getId(), {
+      retries,
+      lastFailureTime: Date.now()
+    });
+    if (this.debug) {
+      console.warn(
+        `AxBalancer: Service ${this.currentService.getName()} failed (retry ${retries}/${this.maxRetries})`
+      );
+    }
+    if (retries >= this.maxRetries) {
+      const gotNextService = this.getNextService();
+      if (this.debug) {
+        console.warn(
+          `AxBalancer: Switching to service ${this.currentService.getName()}`
+        );
+      }
+      return gotNextService;
+    }
+    return true;
+  }
+  handleSuccess() {
+    this.serviceFailures.delete(this.currentService.getId());
+  }
+  async chat(req, options) {
+    this.reset();
+    while (true) {
+      if (!this.canRetryService()) {
+        if (!this.getNextService()) {
+          throw new Error("All services exhausted");
+        }
+        continue;
+      }
+      try {
+        const response = await this.currentService.chat(req, options);
+        this.handleSuccess();
+        return response;
+      } catch (e) {
+        if (!(e instanceof AxAIServiceError)) {
+          throw e;
+        }
+        switch (e.constructor) {
+          case AxAIServiceAuthenticationError:
+            throw e;
+          case AxAIServiceStatusError:
+            break;
+          case AxAIServiceNetworkError:
+            break;
+          case AxAIServiceResponseError:
+            break;
+          case AxAIServiceStreamTerminatedError:
+            break;
+          case AxAIServiceTimeoutError:
+            break;
+          default:
+            throw e;
+        }
+        if (!this.handleFailure()) {
+          throw e;
+        }
+      }
+    }
+  }
+  async embed(req, options) {
+    this.reset();
+    while (true) {
+      if (!this.canRetryService()) {
+        if (!this.getNextService()) {
+          throw new Error("All services exhausted");
+        }
+        continue;
+      }
+      try {
+        const response = await this.currentService.embed(req, options);
+        this.handleSuccess();
+        return response;
+      } catch (e) {
+        if (!this.handleFailure()) {
+          throw e;
+        }
+      }
+    }
+  }
+  setOptions(options) {
+    this.currentService.setOptions(options);
+  }
+  getOptions() {
+    return this.currentService.getOptions();
+  }
+  getLogger() {
+    return this.currentService.getLogger();
+  }
+};
+function validateModels2(services) {
+  const serviceWithModel = services.find(
+    (service) => service.getModelList() !== void 0
+  );
+  if (!serviceWithModel) {
+    return;
+  }
+  const referenceModelList = serviceWithModel.getModelList();
+  if (!referenceModelList) {
+    throw new Error("No model list found in any service.");
+  }
+  const referenceKeys = new Set(referenceModelList.map((model) => model.key));
+  for (let i = 0; i < services.length; i++) {
+    const service = services[i];
+    if (!service) {
+      throw new Error(`Service at index ${i} is undefined`);
+    }
+    const modelList = service.getModelList();
+    if (!modelList) {
+      throw new Error(
+        `Service at index ${i} (${service.getName()}) has no model list while another service does.`
+      );
+    }
+    const serviceKeys = new Set(modelList.map((model) => model.key));
+    for (const key of referenceKeys) {
+      if (!serviceKeys.has(key)) {
+        throw new Error(
+          `Service at index ${i} (${service.getName()}) is missing model "${key}"`
+        );
+      }
+    }
+    for (const key of serviceKeys) {
+      if (!referenceKeys.has(key)) {
+        throw new Error(
+          `Service at index ${i} (${service.getName()}) has extra model "${key}"`
+        );
+      }
+    }
+  }
+}
+
+// dsp/optimizer.ts
+var axDefaultOptimizerMetricsConfig = {
+  enabled: true,
+  enabledCategories: [
+    "optimization",
+    "convergence",
+    "resource_usage",
+    "teacher_student",
+    "checkpointing",
+    "pareto"
+  ],
+  maxLabelLength: 100,
+  samplingRate: 1
+};
+var globalOptimizerMetricsInstruments;
+var getOrCreateOptimizerMetricsInstruments = (meter) => {
+  if (globalOptimizerMetricsInstruments) {
+    return globalOptimizerMetricsInstruments;
+  }
+  if (meter) {
+    globalOptimizerMetricsInstruments = createOptimizerMetricsInstruments(meter);
+    return globalOptimizerMetricsInstruments;
+  }
+  return void 0;
+};
+var currentOptimizerMetricsConfig = axDefaultOptimizerMetricsConfig;
+var axUpdateOptimizerMetricsConfig = (config) => {
+  currentOptimizerMetricsConfig = {
+    ...currentOptimizerMetricsConfig,
+    ...config
+  };
+};
+var axGetOptimizerMetricsConfig = () => {
+  return { ...currentOptimizerMetricsConfig };
+};
+var createOptimizerMetricsInstruments = (meter) => {
+  return {
+    // Optimization flow metrics
+    optimizationLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_optimization_duration_ms",
+      {
+        description: "End-to-end duration of optimization runs",
+        unit: "ms"
+      }
+    ),
+    optimizationRequestsCounter: meter.createCounter(
+      "ax_optimizer_optimization_requests_total",
+      {
+        description: "Total number of optimization requests"
+      }
+    ),
+    optimizationErrorsCounter: meter.createCounter(
+      "ax_optimizer_optimization_errors_total",
+      {
+        description: "Total number of failed optimizations"
+      }
+    ),
+    // Convergence metrics
+    convergenceRoundsHistogram: meter.createHistogram(
+      "ax_optimizer_convergence_rounds",
+      {
+        description: "Number of rounds until convergence"
+      }
+    ),
+    convergenceScoreGauge: meter.createGauge("ax_optimizer_convergence_score", {
+      description: "Current best score during optimization"
+    }),
+    convergenceImprovementGauge: meter.createGauge(
+      "ax_optimizer_convergence_improvement",
+      {
+        description: "Improvement in score from baseline"
+      }
+    ),
+    stagnationRoundsGauge: meter.createGauge("ax_optimizer_stagnation_rounds", {
+      description: "Number of rounds without improvement"
+    }),
+    earlyStoppingCounter: meter.createCounter(
+      "ax_optimizer_early_stopping_total",
+      {
+        description: "Total number of early stopping events"
+      }
+    ),
+    // Resource usage metrics
+    tokenUsageCounter: meter.createCounter("ax_optimizer_token_usage_total", {
+      description: "Total tokens used during optimization"
+    }),
+    costUsageCounter: meter.createCounter("ax_optimizer_cost_usage_total", {
+      description: "Total cost incurred during optimization",
+      unit: "$"
+    }),
+    memoryUsageGauge: meter.createGauge("ax_optimizer_memory_usage_bytes", {
+      description: "Peak memory usage during optimization",
+      unit: "By"
+    }),
+    optimizationDurationHistogram: meter.createHistogram(
+      "ax_optimizer_duration_ms",
+      {
+        description: "Duration of optimization runs",
+        unit: "ms"
+      }
+    ),
+    // Teacher-student metrics
+    teacherStudentUsageCounter: meter.createCounter(
+      "ax_optimizer_teacher_student_usage_total",
+      {
+        description: "Total number of teacher-student interactions"
+      }
+    ),
+    teacherStudentLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_teacher_student_latency_ms",
+      {
+        description: "Latency of teacher-student interactions",
+        unit: "ms"
+      }
+    ),
+    teacherStudentScoreImprovementGauge: meter.createGauge(
+      "ax_optimizer_teacher_student_score_improvement",
+      {
+        description: "Score improvement from teacher-student interactions"
+      }
+    ),
+    // Checkpointing metrics
+    checkpointSaveCounter: meter.createCounter(
+      "ax_optimizer_checkpoint_save_total",
+      {
+        description: "Total number of checkpoint saves"
+      }
+    ),
+    checkpointLoadCounter: meter.createCounter(
+      "ax_optimizer_checkpoint_load_total",
+      {
+        description: "Total number of checkpoint loads"
+      }
+    ),
+    checkpointSaveLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_checkpoint_save_latency_ms",
+      {
+        description: "Latency of checkpoint save operations",
+        unit: "ms"
+      }
+    ),
+    checkpointLoadLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_checkpoint_load_latency_ms",
+      {
+        description: "Latency of checkpoint load operations",
+        unit: "ms"
+      }
+    ),
+    // Pareto optimization metrics
+    paretoOptimizationsCounter: meter.createCounter(
+      "ax_optimizer_pareto_optimizations_total",
+      {
+        description: "Total number of Pareto optimizations"
+      }
+    ),
+    paretoFrontSizeHistogram: meter.createHistogram(
+      "ax_optimizer_pareto_front_size",
+      {
+        description: "Size of Pareto frontier"
+      }
+    ),
+    paretoHypervolumeGauge: meter.createGauge(
+      "ax_optimizer_pareto_hypervolume",
+      {
+        description: "Hypervolume of Pareto frontier"
+      }
+    ),
+    paretoSolutionsGeneratedHistogram: meter.createHistogram(
+      "ax_optimizer_pareto_solutions_generated",
+      {
+        description: "Number of solutions generated for Pareto optimization"
+      }
+    ),
+    // Program complexity metrics
+    programInputFieldsGauge: meter.createGauge(
+      "ax_optimizer_program_input_fields",
+      {
+        description: "Number of input fields in optimized program"
+      }
+    ),
+    programOutputFieldsGauge: meter.createGauge(
+      "ax_optimizer_program_output_fields",
+      {
+        description: "Number of output fields in optimized program"
+      }
+    ),
+    examplesCountGauge: meter.createGauge("ax_optimizer_examples_count", {
+      description: "Number of training examples used"
+    }),
+    validationSetSizeGauge: meter.createGauge(
+      "ax_optimizer_validation_set_size",
+      {
+        description: "Size of validation set used"
+      }
+    ),
+    // Performance metrics
+    evaluationLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_evaluation_latency_ms",
+      {
+        description: "Latency of program evaluations",
+        unit: "ms"
+      }
+    ),
+    demoGenerationLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_demo_generation_latency_ms",
+      {
+        description: "Latency of demo generation",
+        unit: "ms"
+      }
+    ),
+    metricComputationLatencyHistogram: meter.createHistogram(
+      "ax_optimizer_metric_computation_latency_ms",
+      {
+        description: "Latency of metric computation",
+        unit: "ms"
+      }
+    ),
+    // Configuration metrics
+    optimizerTypeGauge: meter.createGauge("ax_optimizer_type", {
+      description: "Type of optimizer being used"
+    }),
+    targetScoreGauge: meter.createGauge("ax_optimizer_target_score", {
+      description: "Target score for optimization"
+    }),
+    maxRoundsGauge: meter.createGauge("ax_optimizer_max_rounds", {
+      description: "Maximum rounds for optimization"
+    })
+  };
+};
+var sanitizeOptimizerLabels = (labels) => {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(labels)) {
+    if (value !== void 0 && value !== null) {
+      const stringValue = String(value);
+      const maxLength = currentOptimizerMetricsConfig.maxLabelLength;
+      sanitized[key] = stringValue.length > maxLength ? stringValue.substring(0, maxLength) : stringValue;
+    }
+  }
+  return sanitized;
+};
+var recordOptimizationMetric = (instruments, duration, success, optimizerType, programSignature) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      success: success.toString(),
+      optimizer_type: optimizerType,
+      ...programSignature ? { program_signature: programSignature } : {}
+    });
+    if (instruments.optimizationLatencyHistogram) {
+      instruments.optimizationLatencyHistogram.record(duration, labels);
+    }
+    if (instruments.optimizationRequestsCounter) {
+      instruments.optimizationRequestsCounter.add(1, labels);
+    }
+    if (!success && instruments.optimizationErrorsCounter) {
+      instruments.optimizationErrorsCounter.add(1, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record optimization metric:", error);
+  }
+};
+var recordConvergenceMetric = (instruments, rounds, currentScore, improvement, stagnationRounds, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.convergenceRoundsHistogram) {
+      instruments.convergenceRoundsHistogram.record(rounds, labels);
+    }
+    if (instruments.convergenceScoreGauge) {
+      instruments.convergenceScoreGauge.record(currentScore, labels);
+    }
+    if (instruments.convergenceImprovementGauge) {
+      instruments.convergenceImprovementGauge.record(improvement, labels);
+    }
+    if (instruments.stagnationRoundsGauge) {
+      instruments.stagnationRoundsGauge.record(stagnationRounds, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record convergence metric:", error);
+  }
+};
+var recordEarlyStoppingMetric = (instruments, reason, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      reason,
+      optimizer_type: optimizerType
     });
-    if (this.debug) {
-      console.warn(
-        `AxBalancer: Service ${this.currentService.getName()} failed (retry ${retries}/${this.maxRetries})`
-      );
+    if (instruments.earlyStoppingCounter) {
+      instruments.earlyStoppingCounter.add(1, labels);
     }
-    if (retries >= this.maxRetries) {
-      const gotNextService = this.getNextService();
-      if (this.debug) {
-        console.warn(
-          `AxBalancer: Switching to service ${this.currentService.getName()}`
-        );
-      }
-      return gotNextService;
+  } catch (error) {
+    console.warn("Failed to record early stopping metric:", error);
+  }
+};
+var recordResourceUsageMetric = (instruments, tokensUsed, costIncurred, optimizerType, memoryUsage) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.tokenUsageCounter) {
+      instruments.tokenUsageCounter.add(tokensUsed, labels);
     }
-    return true;
+    if (instruments.costUsageCounter) {
+      instruments.costUsageCounter.add(costIncurred, labels);
+    }
+    if (memoryUsage !== void 0 && instruments.memoryUsageGauge) {
+      instruments.memoryUsageGauge.record(memoryUsage, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record resource usage metric:", error);
   }
-  handleSuccess() {
-    this.serviceFailures.delete(this.currentService.getId());
+};
+var recordOptimizationDurationMetric = (instruments, duration, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.optimizationDurationHistogram) {
+      instruments.optimizationDurationHistogram.record(duration, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record optimization duration metric:", error);
   }
-  async chat(req, options) {
-    this.reset();
-    while (true) {
-      if (!this.canRetryService()) {
-        if (!this.getNextService()) {
-          throw new Error("All services exhausted");
-        }
-        continue;
-      }
-      try {
-        const response = await this.currentService.chat(req, options);
-        this.handleSuccess();
-        return response;
-      } catch (e) {
-        if (!(e instanceof AxAIServiceError)) {
-          throw e;
-        }
-        switch (e.constructor) {
-          case AxAIServiceAuthenticationError:
-            throw e;
-          case AxAIServiceStatusError:
-            break;
-          case AxAIServiceNetworkError:
-            break;
-          case AxAIServiceResponseError:
-            break;
-          case AxAIServiceStreamTerminatedError:
-            break;
-          case AxAIServiceTimeoutError:
-            break;
-          default:
-            throw e;
-        }
-        if (!this.handleFailure()) {
-          throw e;
-        }
-      }
+};
+var recordTeacherStudentMetric = (instruments, latency, scoreImprovement, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.teacherStudentUsageCounter) {
+      instruments.teacherStudentUsageCounter.add(1, labels);
+    }
+    if (instruments.teacherStudentLatencyHistogram) {
+      instruments.teacherStudentLatencyHistogram.record(latency, labels);
+    }
+    if (instruments.teacherStudentScoreImprovementGauge) {
+      instruments.teacherStudentScoreImprovementGauge.record(
+        scoreImprovement,
+        labels
+      );
     }
+  } catch (error) {
+    console.warn("Failed to record teacher-student metric:", error);
   }
-  async embed(req, options) {
-    this.reset();
-    while (true) {
-      if (!this.canRetryService()) {
-        if (!this.getNextService()) {
-          throw new Error("All services exhausted");
-        }
-        continue;
+};
+var recordCheckpointMetric = (instruments, operation, latency, success, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      operation,
+      success: success.toString(),
+      optimizer_type: optimizerType
+    });
+    if (operation === "save") {
+      if (instruments.checkpointSaveCounter) {
+        instruments.checkpointSaveCounter.add(1, labels);
       }
-      try {
-        const response = await this.currentService.embed(req, options);
-        this.handleSuccess();
-        return response;
-      } catch (e) {
-        if (!this.handleFailure()) {
-          throw e;
-        }
+      if (instruments.checkpointSaveLatencyHistogram) {
+        instruments.checkpointSaveLatencyHistogram.record(latency, labels);
+      }
+    } else {
+      if (instruments.checkpointLoadCounter) {
+        instruments.checkpointLoadCounter.add(1, labels);
+      }
+      if (instruments.checkpointLoadLatencyHistogram) {
+        instruments.checkpointLoadLatencyHistogram.record(latency, labels);
       }
     }
-  }
-  setOptions(options) {
-    this.currentService.setOptions(options);
-  }
-  getOptions() {
-    return this.currentService.getOptions();
-  }
-  getLogger() {
-    return this.currentService.getLogger();
+  } catch (error) {
+    console.warn("Failed to record checkpoint metric:", error);
   }
 };
-function validateModels2(services) {
-  const serviceWithModel = services.find(
-    (service) => service.getModelList() !== void 0
-  );
-  if (!serviceWithModel) {
-    return;
+var recordParetoMetric = (instruments, frontSize, solutionsGenerated, optimizerType, hypervolume) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.paretoOptimizationsCounter) {
+      instruments.paretoOptimizationsCounter.add(1, labels);
+    }
+    if (instruments.paretoFrontSizeHistogram) {
+      instruments.paretoFrontSizeHistogram.record(frontSize, labels);
+    }
+    if (hypervolume !== void 0 && instruments.paretoHypervolumeGauge) {
+      instruments.paretoHypervolumeGauge.record(hypervolume, labels);
+    }
+    if (instruments.paretoSolutionsGeneratedHistogram) {
+      instruments.paretoSolutionsGeneratedHistogram.record(
+        solutionsGenerated,
+        labels
+      );
+    }
+  } catch (error) {
+    console.warn("Failed to record Pareto metric:", error);
   }
-  const referenceModelList = serviceWithModel.getModelList();
-  if (!referenceModelList) {
-    throw new Error("No model list found in any service.");
+};
+var recordProgramComplexityMetric = (instruments, inputFields, outputFields, examplesCount, validationSetSize, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.programInputFieldsGauge) {
+      instruments.programInputFieldsGauge.record(inputFields, labels);
+    }
+    if (instruments.programOutputFieldsGauge) {
+      instruments.programOutputFieldsGauge.record(outputFields, labels);
+    }
+    if (instruments.examplesCountGauge) {
+      instruments.examplesCountGauge.record(examplesCount, labels);
+    }
+    if (instruments.validationSetSizeGauge) {
+      instruments.validationSetSizeGauge.record(validationSetSize, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record program complexity metric:", error);
   }
-  const referenceKeys = new Set(referenceModelList.map((model) => model.key));
-  for (let i = 0; i < services.length; i++) {
-    const service = services[i];
-    if (!service) {
-      throw new Error(`Service at index ${i} is undefined`);
+};
+var recordOptimizerPerformanceMetric = (instruments, metricType, duration, optimizerType) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      metric_type: metricType,
+      optimizer_type: optimizerType
+    });
+    switch (metricType) {
+      case "evaluation":
+        if (instruments.evaluationLatencyHistogram) {
+          instruments.evaluationLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "demo_generation":
+        if (instruments.demoGenerationLatencyHistogram) {
+          instruments.demoGenerationLatencyHistogram.record(duration, labels);
+        }
+        break;
+      case "metric_computation":
+        if (instruments.metricComputationLatencyHistogram) {
+          instruments.metricComputationLatencyHistogram.record(duration, labels);
+        }
+        break;
     }
-    const modelList = service.getModelList();
-    if (!modelList) {
-      throw new Error(
-        `Service at index ${i} (${service.getName()}) has no model list while another service does.`
-      );
+  } catch (error) {
+    console.warn("Failed to record optimizer performance metric:", error);
+  }
+};
+var recordOptimizerConfigurationMetric = (instruments, optimizerType, targetScore, maxRounds) => {
+  try {
+    const labels = sanitizeOptimizerLabels({
+      optimizer_type: optimizerType
+    });
+    if (instruments.optimizerTypeGauge) {
+      instruments.optimizerTypeGauge.record(1, labels);
     }
-    const serviceKeys = new Set(modelList.map((model) => model.key));
-    for (const key of referenceKeys) {
-      if (!serviceKeys.has(key)) {
-        throw new Error(
-          `Service at index ${i} (${service.getName()}) is missing model "${key}"`
-        );
-      }
+    if (targetScore !== void 0 && instruments.targetScoreGauge) {
+      instruments.targetScoreGauge.record(targetScore, labels);
     }
-    for (const key of serviceKeys) {
-      if (!referenceKeys.has(key)) {
-        throw new Error(
-          `Service at index ${i} (${service.getName()}) has extra model "${key}"`
-        );
-      }
+    if (maxRounds !== void 0 && instruments.maxRoundsGauge) {
+      instruments.maxRoundsGauge.record(maxRounds, labels);
     }
+  } catch (error) {
+    console.warn("Failed to record optimizer configuration metric:", error);
   }
-}
-
-// dsp/optimizer.ts
+};
 var AxDefaultCostTracker = class {
   tokenUsage = {};
   totalTokens = 0;
@@ -12046,6 +13225,8 @@ var AxBaseOptimizer = class {
   configurationHistory = [];
   // Common optimization statistics
   stats;
+  // Metrics instruments
+  metricsInstruments;
   constructor(args) {
     if (args.examples.length === 0) {
       throw new Error("No examples found");
@@ -12069,6 +13250,9 @@ var AxBaseOptimizer = class {
       maxTokens: 1e6
     });
     this.costTracker = args.costTracker ?? costTracker;
+    this.metricsInstruments = getOrCreateOptimizerMetricsInstruments(
+      axGlobals.meter
+    );
     this.stats = this.initializeStats();
   }
   /**
@@ -12140,6 +13324,7 @@ var AxBaseOptimizer = class {
       patienceExhausted: reason.includes("improvement"),
       reason
     };
+    this.recordEarlyStoppingMetrics(reason, "unknown");
     if (this.onEarlyStop) {
       this.onEarlyStop(reason, this.stats);
     }
@@ -12283,6 +13468,12 @@ var AxBaseOptimizer = class {
     }
     this.updateResourceUsage(startTime);
     this.stats.convergenceInfo.converged = true;
+    this.recordParetoMetrics(
+      paretoFront.length,
+      allSolutions.length,
+      "base_optimizer",
+      hypervolume
+    );
     const bestScore = paretoFront.length > 0 ? Math.max(
       ...paretoFront.map((sol) => Math.max(...Object.values(sol.scores)))
     ) : 0;
@@ -12589,23 +13780,36 @@ var AxBaseOptimizer = class {
   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);
+    const startTime = Date.now();
+    let success = false;
+    let checkpointId;
+    try {
+      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
+      };
+      checkpointId = await saveFn(checkpoint);
+      success = true;
+    } catch (error) {
+      success = false;
+      throw error;
+    } finally {
+      const latency = Date.now() - startTime;
+      this.recordCheckpointMetrics("save", latency, success, optimizerType);
+    }
+    return checkpointId;
   }
   /**
    * Load optimization state from checkpoint
@@ -12613,7 +13817,20 @@ var AxBaseOptimizer = class {
   async loadCheckpoint(checkpointId, options) {
     const loadFn = options?.overrideCheckpointLoad || this.checkpointLoad;
     if (!loadFn) return null;
-    return await loadFn(checkpointId);
+    const startTime = Date.now();
+    let success = false;
+    let checkpoint = null;
+    try {
+      checkpoint = await loadFn(checkpointId);
+      success = checkpoint !== null;
+    } catch (error) {
+      success = false;
+      throw error;
+    } finally {
+      const latency = Date.now() - startTime;
+      this.recordCheckpointMetrics("load", latency, success, "unknown");
+    }
+    return checkpoint;
   }
   /**
    * Restore optimizer state from checkpoint
@@ -12690,6 +13907,128 @@ var AxBaseOptimizer = class {
     }
     return this.verbose ?? true;
   }
+  /**
+   * Record optimization start metrics
+   */
+  recordOptimizationStart(optimizerType, programSignature) {
+    if (!this.metricsInstruments) return;
+    if (programSignature) {
+      const inputFields = (programSignature.match(/input:/g) || []).length;
+      const outputFields = (programSignature.match(/output:/g) || []).length;
+      recordProgramComplexityMetric(
+        this.metricsInstruments,
+        inputFields,
+        outputFields,
+        this.examples.length,
+        this.getValidationSet().length,
+        optimizerType
+      );
+    }
+    recordOptimizerConfigurationMetric(
+      this.metricsInstruments,
+      optimizerType,
+      this.targetScore,
+      void 0
+      // maxRounds would be set by concrete optimizers
+    );
+  }
+  /**
+   * Record optimization completion metrics
+   */
+  recordOptimizationComplete(duration, success, optimizerType, programSignature) {
+    if (!this.metricsInstruments) return;
+    recordOptimizationMetric(
+      this.metricsInstruments,
+      duration,
+      success,
+      optimizerType,
+      programSignature
+    );
+    recordOptimizationDurationMetric(
+      this.metricsInstruments,
+      duration,
+      optimizerType
+    );
+    const currentCost = this.costTracker?.getCurrentCost() ?? 0;
+    const totalTokens = this.costTracker?.getTotalTokens() ?? 0;
+    recordResourceUsageMetric(
+      this.metricsInstruments,
+      totalTokens,
+      currentCost,
+      optimizerType
+    );
+  }
+  /**
+   * Record convergence metrics
+   */
+  recordConvergenceMetrics(rounds, currentScore, improvement, stagnationRounds, optimizerType) {
+    if (!this.metricsInstruments) return;
+    recordConvergenceMetric(
+      this.metricsInstruments,
+      rounds,
+      currentScore,
+      improvement,
+      stagnationRounds,
+      optimizerType
+    );
+  }
+  /**
+   * Record early stopping metrics
+   */
+  recordEarlyStoppingMetrics(reason, optimizerType) {
+    if (!this.metricsInstruments) return;
+    recordEarlyStoppingMetric(this.metricsInstruments, reason, optimizerType);
+  }
+  /**
+   * Record teacher-student interaction metrics
+   */
+  recordTeacherStudentMetrics(latency, scoreImprovement, optimizerType) {
+    if (!this.metricsInstruments) return;
+    recordTeacherStudentMetric(
+      this.metricsInstruments,
+      latency,
+      scoreImprovement,
+      optimizerType
+    );
+  }
+  /**
+   * Record checkpoint metrics
+   */
+  recordCheckpointMetrics(operation, latency, success, optimizerType) {
+    if (!this.metricsInstruments) return;
+    recordCheckpointMetric(
+      this.metricsInstruments,
+      operation,
+      latency,
+      success,
+      optimizerType
+    );
+  }
+  /**
+   * Record Pareto optimization metrics
+   */
+  recordParetoMetrics(frontSize, solutionsGenerated, optimizerType, hypervolume) {
+    if (!this.metricsInstruments) return;
+    recordParetoMetric(
+      this.metricsInstruments,
+      frontSize,
+      solutionsGenerated,
+      optimizerType,
+      hypervolume
+    );
+  }
+  /**
+   * Record performance metrics
+   */
+  recordPerformanceMetrics(metricType, duration, optimizerType) {
+    if (!this.metricsInstruments) return;
+    recordOptimizerPerformanceMetric(
+      this.metricsInstruments,
+      metricType,
+      duration,
+      optimizerType
+    );
+  }
 };
 
 // db/base.ts
@@ -18231,10 +19570,15 @@ export {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axCheckMetricsHealth,
   axCreateDefaultLogger,
   axCreateDefaultTextLogger,
   axCreateOptimizerLogger,
+  axDefaultMetricsConfig,
   axDefaultOptimizerLogger,
+  axDefaultOptimizerMetricsConfig,
+  axGetMetricsConfig,
+  axGetOptimizerMetricsConfig,
   axGlobals,
   axModelInfoAnthropic,
   axModelInfoCohere,
@@ -18250,6 +19594,8 @@ export {
   axModelInfoTogether,
   axSpanAttributes,
   axSpanEvents,
+  axUpdateMetricsConfig,
+  axUpdateOptimizerMetricsConfig,
   axValidateChatRequestMessage,
   axValidateChatResponseResult,
   f,