@ax-llm/ax 12.0.19 → 12.0.21

package/index.js

@@ -586,6 +586,16 @@ var apiCall = async (api, json) => {
 import crypto2 from "crypto";
 import { context, SpanKind } from "@opentelemetry/api";
 
+// dsp/globals.ts
+var axGlobals = {
+  signatureStrict: true,
+  // Controls reservedNames enforcement in signature parsing/validation
+  tracer: void 0,
+  // Global OpenTelemetry tracer for all AI operations
+  meter: void 0
+  // Global OpenTelemetry meter for metrics collection
+};
+
 // trace/trace.ts
 var axSpanAttributes = {
   // LLM
@@ -1021,6 +1031,326 @@ var logResponseDelta = (delta, logger = defaultLogger) => {
   logger(delta, { tags: ["responseContent"] });
 };
 
+// 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", {
+      description: "Duration of LLM requests in milliseconds",
+      unit: "ms"
+    }),
+    errorCounter: meter.createCounter("ax_llm_errors_total", {
+      description: "Total number of LLM request errors"
+    }),
+    requestCounter: meter.createCounter("ax_llm_requests_total", {
+      description: "Total number of LLM requests"
+    }),
+    tokenCounter: meter.createCounter("ax_llm_tokens_total", {
+      description: "Total number of LLM tokens consumed"
+    }),
+    inputTokenCounter: meter.createCounter("ax_llm_input_tokens_total", {
+      description: "Total number of input/prompt tokens consumed"
+    }),
+    outputTokenCounter: meter.createCounter("ax_llm_output_tokens_total", {
+      description: "Total number of output/completion tokens generated"
+    }),
+    errorRateGauge: meter.createGauge("ax_llm_error_rate", {
+      description: "Current error rate as a percentage (0-100)"
+    }),
+    meanLatencyGauge: meter.createGauge("ax_llm_mean_latency_ms", {
+      description: "Mean latency of LLM requests in milliseconds",
+      unit: "ms"
+    }),
+    p95LatencyGauge: meter.createGauge("ax_llm_p95_latency_ms", {
+      description: "95th percentile latency of LLM requests in milliseconds",
+      unit: "ms"
+    }),
+    p99LatencyGauge: meter.createGauge("ax_llm_p99_latency_ms", {
+      description: "99th percentile latency of LLM requests in milliseconds",
+      unit: "ms"
+    }),
+    streamingRequestsCounter: meter.createCounter(
+      "ax_llm_streaming_requests_total",
+      {
+        description: "Total number of streaming LLM requests"
+      }
+    ),
+    functionCallsCounter: meter.createCounter("ax_llm_function_calls_total", {
+      description: "Total number of function/tool calls made"
+    }),
+    functionCallLatencyHistogram: meter.createHistogram(
+      "ax_llm_function_call_latency_ms",
+      {
+        description: "Latency of function calls in milliseconds",
+        unit: "ms"
+      }
+    ),
+    requestSizeHistogram: meter.createHistogram("ax_llm_request_size_bytes", {
+      description: "Size of LLM request payloads in bytes",
+      unit: "By"
+    }),
+    responseSizeHistogram: meter.createHistogram("ax_llm_response_size_bytes", {
+      description: "Size of LLM response payloads in bytes",
+      unit: "By"
+    }),
+    temperatureGauge: meter.createGauge("ax_llm_temperature_gauge", {
+      description: "Temperature setting used for LLM requests"
+    }),
+    maxTokensGauge: meter.createGauge("ax_llm_max_tokens_gauge", {
+      description: "Maximum tokens setting used for LLM requests"
+    }),
+    estimatedCostCounter: meter.createCounter("ax_llm_estimated_cost_total", {
+      description: "Estimated cost of LLM requests in USD",
+      unit: "$"
+    }),
+    promptLengthHistogram: meter.createHistogram("ax_llm_prompt_length_chars", {
+      description: "Length of prompts in characters"
+    }),
+    contextWindowUsageGauge: meter.createGauge(
+      "ax_llm_context_window_usage_ratio",
+      {
+        description: "Context window utilization ratio (0-1)"
+      }
+    ),
+    timeoutsCounter: meter.createCounter("ax_llm_timeouts_total", {
+      description: "Total number of timed out LLM requests"
+    }),
+    abortsCounter: meter.createCounter("ax_llm_aborts_total", {
+      description: "Total number of aborted LLM requests"
+    }),
+    thinkingBudgetUsageCounter: meter.createCounter(
+      "ax_llm_thinking_budget_usage_total",
+      {
+        description: "Total thinking budget tokens used"
+      }
+    ),
+    multimodalRequestsCounter: meter.createCounter(
+      "ax_llm_multimodal_requests_total",
+      {
+        description: "Total number of multimodal requests (with images/audio)"
+      }
+    )
+  };
+};
+var recordLatencyMetric = (instruments, type, duration, aiService, 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) => {
+  const labels = {
+    operation: type,
+    ai_service: aiService,
+    ...model ? { model } : {}
+  };
+  if (instruments.meanLatencyGauge) {
+    instruments.meanLatencyGauge.record(meanLatency, labels);
+  }
+  if (instruments.p95LatencyGauge) {
+    instruments.p95LatencyGauge.record(p95Latency, labels);
+  }
+  if (instruments.p99LatencyGauge) {
+    instruments.p99LatencyGauge.record(p99Latency, labels);
+  }
+};
+var recordErrorMetric = (instruments, type, aiService, 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) => {
+  if (instruments.errorRateGauge) {
+    instruments.errorRateGauge.record(errorRate * 100, {
+      // Convert to percentage
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordRequestMetric = (instruments, type, aiService, model) => {
+  if (instruments.requestCounter) {
+    instruments.requestCounter.add(1, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordTokenMetric = (instruments, type, tokens, aiService, model) => {
+  try {
+    const labels = sanitizeLabels({
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+    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) => {
+  if (isStreaming && instruments.streamingRequestsCounter) {
+    instruments.streamingRequestsCounter.add(1, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordFunctionCallMetric = (instruments, functionName, latency, aiService, model) => {
+  const labels = {
+    function_name: functionName,
+    ...aiService ? { ai_service: aiService } : {},
+    ...model ? { model } : {}
+  };
+  if (instruments.functionCallsCounter) {
+    instruments.functionCallsCounter.add(1, labels);
+  }
+  if (latency && instruments.functionCallLatencyHistogram) {
+    instruments.functionCallLatencyHistogram.record(latency, labels);
+  }
+};
+var recordRequestSizeMetric = (instruments, type, sizeBytes, aiService, model) => {
+  if (instruments.requestSizeHistogram) {
+    instruments.requestSizeHistogram.record(sizeBytes, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordResponseSizeMetric = (instruments, type, sizeBytes, aiService, model) => {
+  if (instruments.responseSizeHistogram) {
+    instruments.responseSizeHistogram.record(sizeBytes, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordModelConfigMetrics = (instruments, temperature, maxTokens, aiService, model) => {
+  const labels = {
+    ...aiService ? { ai_service: aiService } : {},
+    ...model ? { model } : {}
+  };
+  if (temperature !== void 0 && instruments.temperatureGauge) {
+    instruments.temperatureGauge.record(temperature, labels);
+  }
+  if (maxTokens !== void 0 && instruments.maxTokensGauge) {
+    instruments.maxTokensGauge.record(maxTokens, labels);
+  }
+};
+var recordEstimatedCostMetric = (instruments, type, costUSD, aiService, model) => {
+  if (instruments.estimatedCostCounter) {
+    instruments.estimatedCostCounter.add(costUSD, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordPromptLengthMetric = (instruments, lengthChars, aiService, model) => {
+  if (instruments.promptLengthHistogram) {
+    instruments.promptLengthHistogram.record(lengthChars, {
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordContextWindowUsageMetric = (instruments, usageRatio, aiService, model) => {
+  if (instruments.contextWindowUsageGauge) {
+    instruments.contextWindowUsageGauge.record(usageRatio, {
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordTimeoutMetric = (instruments, type, aiService, model) => {
+  if (instruments.timeoutsCounter) {
+    instruments.timeoutsCounter.add(1, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordAbortMetric = (instruments, type, aiService, model) => {
+  if (instruments.abortsCounter) {
+    instruments.abortsCounter.add(1, {
+      operation: type,
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordThinkingBudgetUsageMetric = (instruments, tokensUsed, aiService, model) => {
+  if (instruments.thinkingBudgetUsageCounter) {
+    instruments.thinkingBudgetUsageCounter.add(tokensUsed, {
+      ai_service: aiService,
+      ...model ? { model } : {}
+    });
+  }
+};
+var recordMultimodalRequestMetric = (instruments, hasImages, hasAudio, aiService, model) => {
+  if ((hasImages || hasAudio) && instruments.multimodalRequestsCounter) {
+    instruments.multimodalRequestsCounter.add(1, {
+      ai_service: aiService,
+      has_images: hasImages.toString(),
+      has_audio: hasAudio.toString(),
+      ...model ? { model } : {}
+    });
+  }
+};
+
 // ai/base.ts
 var axBaseAIDefaultConfig = () => structuredClone({
   temperature: 0,
@@ -1051,7 +1381,8 @@ var AxBaseAI = class {
     this.apiURL = apiURL;
     this.headers = headers;
     this.supportFor = supportFor;
-    this.tracer = options.tracer;
+    this.tracer = options.tracer ?? axGlobals.tracer;
+    this.meter = options.meter ?? axGlobals.meter;
     this.modelInfo = modelInfo;
     this.models = models;
     this.id = crypto2.randomUUID();
@@ -1070,6 +1401,7 @@ var AxBaseAI = class {
   rt;
   fetch;
   tracer;
+  meter;
   timeout;
   excludeContentFromTrace;
   models;
@@ -1116,6 +1448,9 @@ var AxBaseAI = class {
       }
     }
   };
+  getMetricsInstruments() {
+    return getOrCreateAIMetricsInstruments(this.meter);
+  }
   setName(name) {
     this.name = name;
   }
@@ -1133,7 +1468,8 @@ var AxBaseAI = class {
     this.rt = options.rateLimiter;
     this.fetch = options.fetch;
     this.timeout = options.timeout;
-    this.tracer = options.tracer;
+    this.tracer = options.tracer ?? axGlobals.tracer;
+    this.meter = options.meter ?? axGlobals.meter;
     this.excludeContentFromTrace = options.excludeContentFromTrace;
     this.abortSignal = options.abortSignal;
     this.logger = options.logger ?? defaultLogger2;
@@ -1144,6 +1480,7 @@ var AxBaseAI = class {
       rateLimiter: this.rt,
       fetch: this.fetch,
       tracer: this.tracer,
+      meter: this.meter,
       timeout: this.timeout,
       excludeContentFromTrace: this.excludeContentFromTrace,
       abortSignal: this.abortSignal,
@@ -1208,6 +1545,20 @@ 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);
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
+      recordLatencyMetric(metricsInstruments, type, duration, this.name, model);
+      recordLatencyStatsMetrics(
+        metricsInstruments,
+        type,
+        metrics.mean,
+        metrics.p95,
+        metrics.p99,
+        this.name,
+        model
+      );
+    }
   }
   // Method to update error metrics
   updateErrorMetrics(type, isError) {
@@ -1217,6 +1568,319 @@ var AxBaseAI = class {
       metrics.count++;
     }
     metrics.rate = metrics.count / metrics.total;
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
+      recordRequestMetric(metricsInstruments, type, this.name, model);
+      if (isError) {
+        recordErrorMetric(metricsInstruments, type, this.name, model);
+      }
+      recordErrorRateMetric(
+        metricsInstruments,
+        type,
+        metrics.rate,
+        this.name,
+        model
+      );
+    }
+  }
+  // Method to record token usage metrics
+  recordTokenUsage(modelUsage) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments && modelUsage?.tokens) {
+      const { promptTokens, completionTokens, totalTokens, thoughtsTokens } = modelUsage.tokens;
+      if (promptTokens) {
+        recordTokenMetric(
+          metricsInstruments,
+          "input",
+          promptTokens,
+          this.name,
+          modelUsage.model
+        );
+      }
+      if (completionTokens) {
+        recordTokenMetric(
+          metricsInstruments,
+          "output",
+          completionTokens,
+          this.name,
+          modelUsage.model
+        );
+      }
+      if (totalTokens) {
+        recordTokenMetric(
+          metricsInstruments,
+          "total",
+          totalTokens,
+          this.name,
+          modelUsage.model
+        );
+      }
+      if (thoughtsTokens) {
+        recordTokenMetric(
+          metricsInstruments,
+          "thoughts",
+          thoughtsTokens,
+          this.name,
+          modelUsage.model
+        );
+      }
+    }
+  }
+  // Helper method to calculate request size in bytes
+  calculateRequestSize(req) {
+    try {
+      return new TextEncoder().encode(JSON.stringify(req)).length;
+    } catch {
+      return 0;
+    }
+  }
+  // Helper method to calculate response size in bytes
+  calculateResponseSize(response) {
+    try {
+      return new TextEncoder().encode(JSON.stringify(response)).length;
+    } catch {
+      return 0;
+    }
+  }
+  // Helper method to detect multimodal content
+  detectMultimodalContent(req) {
+    let hasImages = false;
+    let hasAudio = false;
+    if (req.chatPrompt && Array.isArray(req.chatPrompt)) {
+      for (const message of req.chatPrompt) {
+        if (message.role === "user" && Array.isArray(message.content)) {
+          for (const part of message.content) {
+            if (part.type === "image") {
+              hasImages = true;
+            } else if (part.type === "audio") {
+              hasAudio = true;
+            }
+          }
+        }
+      }
+    }
+    return { hasImages, hasAudio };
+  }
+  // Helper method to calculate prompt length
+  calculatePromptLength(req) {
+    let totalLength = 0;
+    if (req.chatPrompt && Array.isArray(req.chatPrompt)) {
+      for (const message of req.chatPrompt) {
+        if (message.role === "system" || message.role === "assistant") {
+          if (message.content) {
+            totalLength += message.content.length;
+          }
+        } else if (message.role === "user") {
+          if (typeof message.content === "string") {
+            totalLength += message.content.length;
+          } else if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+              if (part.type === "text") {
+                totalLength += part.text.length;
+              }
+            }
+          }
+        } else if (message.role === "function") {
+          if (message.result) {
+            totalLength += message.result.length;
+          }
+        }
+      }
+    }
+    return totalLength;
+  }
+  // Helper method to calculate context window usage
+  calculateContextWindowUsage(model, modelUsage) {
+    if (!modelUsage?.tokens?.promptTokens) return 0;
+    const modelInfo = this.modelInfo.find(
+      (info) => info.name === model
+    );
+    if (!modelInfo?.contextWindow) return 0;
+    return modelUsage.tokens.promptTokens / modelInfo.contextWindow;
+  }
+  // Helper method to estimate cost
+  estimateCost(model, modelUsage) {
+    if (!modelUsage?.tokens) return 0;
+    const modelInfo = this.modelInfo.find(
+      (info) => info.name === model
+    );
+    if (!modelInfo || !modelInfo.promptTokenCostPer1M && !modelInfo.completionTokenCostPer1M)
+      return 0;
+    const { promptTokens = 0, completionTokens = 0 } = modelUsage.tokens;
+    const promptCostPer1M = modelInfo.promptTokenCostPer1M || 0;
+    const completionCostPer1M = modelInfo.completionTokenCostPer1M || 0;
+    return promptTokens * promptCostPer1M / 1e6 + completionTokens * completionCostPer1M / 1e6;
+  }
+  // Helper method to estimate cost by model name
+  estimateCostByName(modelName, modelUsage) {
+    if (!modelUsage?.tokens) return 0;
+    const modelInfo = this.modelInfo.find((info) => info.name === modelName);
+    if (!modelInfo || !modelInfo.promptTokenCostPer1M && !modelInfo.completionTokenCostPer1M)
+      return 0;
+    const { promptTokens = 0, completionTokens = 0 } = modelUsage.tokens;
+    const promptCostPer1M = modelInfo.promptTokenCostPer1M || 0;
+    const completionCostPer1M = modelInfo.completionTokenCostPer1M || 0;
+    return promptTokens * promptCostPer1M / 1e6 + completionTokens * completionCostPer1M / 1e6;
+  }
+  // Helper method to record function call metrics
+  recordFunctionCallMetrics(functionCalls, model) {
+    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(
+          metricsInstruments,
+          call.function.name,
+          void 0,
+          // latency would need to be tracked separately
+          this.name,
+          model
+        );
+      }
+    }
+  }
+  // Helper method to record timeout metrics
+  recordTimeoutMetric(type) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
+      recordTimeoutMetric(metricsInstruments, type, this.name, model);
+    }
+  }
+  // Helper method to record abort metrics
+  recordAbortMetric(type) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (metricsInstruments) {
+      const model = type === "chat" ? this.lastUsedChatModel : this.lastUsedEmbedModel;
+      recordAbortMetric(metricsInstruments, type, this.name, model);
+    }
+  }
+  // Comprehensive method to record all chat-related metrics
+  recordChatMetrics(req, options, result) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (!metricsInstruments) return;
+    const model = this.lastUsedChatModel;
+    const modelConfig = this.lastUsedModelConfig;
+    const isStreaming = modelConfig?.stream ?? false;
+    recordStreamingRequestMetric(
+      metricsInstruments,
+      "chat",
+      isStreaming,
+      this.name,
+      model
+    );
+    const { hasImages, hasAudio } = this.detectMultimodalContent(req);
+    recordMultimodalRequestMetric(
+      metricsInstruments,
+      hasImages,
+      hasAudio,
+      this.name,
+      model
+    );
+    const promptLength = this.calculatePromptLength(req);
+    recordPromptLengthMetric(metricsInstruments, promptLength, this.name, model);
+    recordModelConfigMetrics(
+      metricsInstruments,
+      modelConfig?.temperature,
+      modelConfig?.maxTokens,
+      this.name,
+      model
+    );
+    if (options?.thinkingTokenBudget && this.modelUsage?.tokens?.thoughtsTokens) {
+      recordThinkingBudgetUsageMetric(
+        metricsInstruments,
+        this.modelUsage.tokens.thoughtsTokens,
+        this.name,
+        model
+      );
+    }
+    const requestSize = this.calculateRequestSize(req);
+    recordRequestSizeMetric(
+      metricsInstruments,
+      "chat",
+      requestSize,
+      this.name,
+      model
+    );
+    if (result && !isStreaming) {
+      const chatResponse = result;
+      const responseSize = this.calculateResponseSize(chatResponse);
+      recordResponseSizeMetric(
+        metricsInstruments,
+        "chat",
+        responseSize,
+        this.name,
+        model
+      );
+      if (chatResponse.results) {
+        for (const chatResult of chatResponse.results) {
+          if (chatResult.functionCalls) {
+            this.recordFunctionCallMetrics(
+              chatResult.functionCalls,
+              this.lastUsedChatModel
+            );
+          }
+        }
+      }
+      const contextUsage = this.calculateContextWindowUsage(
+        this.lastUsedChatModel,
+        chatResponse.modelUsage
+      );
+      if (contextUsage > 0) {
+        recordContextWindowUsageMetric(
+          metricsInstruments,
+          contextUsage,
+          this.name,
+          model
+        );
+      }
+      const estimatedCost = this.estimateCost(
+        this.lastUsedChatModel,
+        chatResponse.modelUsage
+      );
+      if (estimatedCost > 0) {
+        recordEstimatedCostMetric(
+          metricsInstruments,
+          "chat",
+          estimatedCost,
+          this.name,
+          model
+        );
+      }
+    }
+  }
+  // Comprehensive method to record all embed-related metrics
+  recordEmbedMetrics(req, result) {
+    const metricsInstruments = this.getMetricsInstruments();
+    if (!metricsInstruments) return;
+    const model = this.lastUsedEmbedModel;
+    const requestSize = this.calculateRequestSize(req);
+    recordRequestSizeMetric(
+      metricsInstruments,
+      "embed",
+      requestSize,
+      this.name,
+      model
+    );
+    const responseSize = this.calculateResponseSize(result);
+    recordResponseSizeMetric(
+      metricsInstruments,
+      "embed",
+      responseSize,
+      this.name,
+      model
+    );
+    const estimatedCost = this.estimateCostByName(model, result.modelUsage);
+    if (estimatedCost > 0) {
+      recordEstimatedCostMetric(
+        metricsInstruments,
+        "embed",
+        estimatedCost,
+        this.name,
+        model
+      );
+    }
   }
   // Public method to get metrics
   getMetrics() {
@@ -1225,16 +1889,27 @@ var AxBaseAI = class {
   async chat(req, options) {
     const startTime = performance.now();
     let isError = false;
+    let result;
     try {
-      const result = await this._chat1(req, options);
+      result = await this._chat1(req, options);
       return result;
     } catch (error) {
       isError = true;
+      if (error instanceof Error) {
+        if (error.message.includes("timeout") || error.name === "TimeoutError") {
+          this.recordTimeoutMetric("chat");
+        } else if (error.message.includes("abort") || error.name === "AbortError") {
+          this.recordAbortMetric("chat");
+        }
+      }
       throw error;
     } finally {
       const duration = performance.now() - startTime;
       this.updateLatencyMetrics("chat", duration);
       this.updateErrorMetrics("chat", isError);
+      if (!isError) {
+        this.recordChatMetrics(req, options, result);
+      }
     }
   }
   async _chat1(req, options) {
@@ -1381,6 +2056,7 @@ var AxBaseAI = class {
           }
         }
         this.modelUsage = res2.modelUsage;
+        this.recordTokenUsage(res2.modelUsage);
         if (span?.isRecording()) {
           setChatResponseEvents(res2, span, this.excludeContentFromTrace);
         }
@@ -1423,6 +2099,7 @@ var AxBaseAI = class {
     }
     if (res.modelUsage) {
       this.modelUsage = res.modelUsage;
+      this.recordTokenUsage(res.modelUsage);
     }
     if (span?.isRecording()) {
       setChatResponseEvents(res, span, this.excludeContentFromTrace);
@@ -1439,15 +2116,27 @@ var AxBaseAI = class {
   async embed(req, options) {
     const startTime = performance.now();
     let isError = false;
+    let result;
     try {
-      return this._embed1(req, options);
+      result = await this._embed1(req, options);
+      return result;
     } catch (error) {
       isError = true;
+      if (error instanceof Error) {
+        if (error.message.includes("timeout") || error.name === "TimeoutError") {
+          this.recordTimeoutMetric("embed");
+        } else if (error.message.includes("abort") || error.name === "AbortError") {
+          this.recordAbortMetric("embed");
+        }
+      }
       throw error;
     } finally {
       const duration = performance.now() - startTime;
       this.updateLatencyMetrics("embed", duration);
       this.updateErrorMetrics("embed", isError);
+      if (!isError) {
+        this.recordEmbedMetrics(req, result);
+      }
     }
   }
   async _embed1(req, options) {
@@ -1522,6 +2211,7 @@ var AxBaseAI = class {
       }
     }
     this.embedModelUsage = res.modelUsage;
+    this.recordTokenUsage(res.modelUsage);
     if (span?.isRecording() && res.modelUsage?.tokens) {
       span.addEvent(axSpanEvents.GEN_AI_USAGE, {
         [axSpanAttributes.LLM_USAGE_INPUT_TOKENS]: res.modelUsage.tokens.promptTokens,
@@ -7858,88 +8548,577 @@ 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/sig.ts
-import { createHash } from "crypto";
-
-// dsp/globals.ts
-var axGlobals = {
-  signatureStrict: true
-  // Controls reservedNames enforcement in signature parsing/validation
+// dsp/metrics.ts
+var axDefaultMetricsConfig = {
+  enabled: true,
+  enabledCategories: [
+    "generation",
+    "streaming",
+    "functions",
+    "errors",
+    "performance"
+  ],
+  maxLabelLength: 100,
+  samplingRate: 1
 };
-
-// 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 globalGenMetricsInstruments;
+var getOrCreateGenMetricsInstruments = (meter) => {
+  if (globalGenMetricsInstruments) {
+    return globalGenMetricsInstruments;
   }
+  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"'
-        );
-      }
-      this.expectArrow();
-      this.skipWhitespace();
-      if (this.position >= this.input.length) {
-        throw new SignatureValidationError(
+  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"
+      }
+    ),
+    generationRequestsCounter: meter.createCounter(
+      "ax_gen_generation_requests_total",
+      {
+        description: "Total number of AxGen generation requests"
+      }
+    ),
+    generationErrorsCounter: meter.createCounter(
+      "ax_gen_generation_errors_total",
+      {
+        description: "Total number of failed AxGen generations"
+      }
+    ),
+    // Multi-step flow metrics
+    multiStepGenerationsCounter: meter.createCounter(
+      "ax_gen_multistep_generations_total",
+      {
+        description: "Total number of generations that required multiple steps"
+      }
+    ),
+    stepsPerGenerationHistogram: meter.createHistogram(
+      "ax_gen_steps_per_generation",
+      {
+        description: "Number of steps taken per generation"
+      }
+    ),
+    maxStepsReachedCounter: meter.createCounter(
+      "ax_gen_max_steps_reached_total",
+      {
+        description: "Total number of generations that hit max steps limit"
+      }
+    ),
+    // Error correction metrics
+    validationErrorsCounter: meter.createCounter(
+      "ax_gen_validation_errors_total",
+      {
+        description: "Total number of validation errors encountered"
+      }
+    ),
+    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(),
@@ -10256,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,
@@ -10445,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, {
@@ -10458,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++) {
@@ -10487,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) {
@@ -10497,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(),
@@ -10507,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(),
@@ -10528,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,
@@ -10541,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) {
@@ -10600,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
+        );
+      }
+      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
+          );
+        }
       }
-      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;
   }
   async *streamingForward(ai, values, options) {
     if (!options?.resultPicker) {
@@ -11315,6 +12692,466 @@ function validateModels2(services) {
 }
 
 // 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 (instruments.earlyStoppingCounter) {
+      instruments.earlyStoppingCounter.add(1, labels);
+    }
+  } 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);
+    }
+    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);
+  }
+};
+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);
+  }
+};
+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);
+  }
+};
+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);
+      }
+      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);
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to record checkpoint metric:", error);
+  }
+};
+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);
+  }
+};
+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);
+  }
+};
+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;
+    }
+  } 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);
+    }
+    if (targetScore !== void 0 && instruments.targetScoreGauge) {
+      instruments.targetScoreGauge.record(targetScore, labels);
+    }
+    if (maxRounds !== void 0 && instruments.maxRoundsGauge) {
+      instruments.maxRoundsGauge.record(maxRounds, labels);
+    }
+  } catch (error) {
+    console.warn("Failed to record optimizer configuration metric:", error);
+  }
+};
 var AxDefaultCostTracker = class {
   tokenUsage = {};
   totalTokens = 0;
@@ -11388,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");
@@ -11411,6 +13250,9 @@ var AxBaseOptimizer = class {
       maxTokens: 1e6
     });
     this.costTracker = args.costTracker ?? costTracker;
+    this.metricsInstruments = getOrCreateOptimizerMetricsInstruments(
+      axGlobals.meter
+    );
     this.stats = this.initializeStats();
   }
   /**
@@ -11482,6 +13324,7 @@ var AxBaseOptimizer = class {
       patienceExhausted: reason.includes("improvement"),
       reason
     };
+    this.recordEarlyStoppingMetrics(reason, "unknown");
     if (this.onEarlyStop) {
       this.onEarlyStop(reason, this.stats);
     }
@@ -11625,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;
@@ -11931,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
@@ -11955,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
@@ -12032,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
@@ -17573,10 +19570,15 @@ export {
   axAITogetherDefaultConfig,
   axBaseAIDefaultConfig,
   axBaseAIDefaultCreativeConfig,
+  axCheckMetricsHealth,
   axCreateDefaultLogger,
   axCreateDefaultTextLogger,
   axCreateOptimizerLogger,
+  axDefaultMetricsConfig,
   axDefaultOptimizerLogger,
+  axDefaultOptimizerMetricsConfig,
+  axGetMetricsConfig,
+  axGetOptimizerMetricsConfig,
   axGlobals,
   axModelInfoAnthropic,
   axModelInfoCohere,
@@ -17592,6 +19594,8 @@ export {
   axModelInfoTogether,
   axSpanAttributes,
   axSpanEvents,
+  axUpdateMetricsConfig,
+  axUpdateOptimizerMetricsConfig,
   axValidateChatRequestMessage,
   axValidateChatResponseResult,
   f,