@mastra/observability 1.5.1 → 1.6.0-alpha.0

package/dist/index.js

@@ -1,9 +1,12 @@
 import { MastraBase } from '@mastra/core/base';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { ConsoleLogger, LogLevel, RegisteredLogger } from '@mastra/core/logger';
-import { TracingEventType, SpanType, DEFAULT_BLOCKED_LABELS, InternalSpans } from '@mastra/core/observability';
+import { TracingEventType, DEFAULT_BLOCKED_LABELS, SpanType, InternalSpans } from '@mastra/core/observability';
 import { fetchWithRetry, getNestedValue, setNestedValue } from '@mastra/core/utils';
 import { buildUpdateSpanRecord, buildFeedbackRecord, buildLogRecord, buildMetricRecord, buildScoreRecord, buildCreateSpanRecord } from '@mastra/core/storage';
+import fs from 'fs';
+import { createRequire } from 'module';
+import path from 'path';
 import { TransformStream } from 'stream/web';
 
 var __defProp = Object.defineProperty;
@@ -777,10 +780,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1163,11 +1166,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -1350,7 +1353,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path = []) => {
+  const processError = (error49, path2 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1360,7 +1363,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1392,8 +1395,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13365,13 +13368,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path = ref.slice(1).split("/").filter(Boolean);
-  if (path.length === 0) {
+  const path2 = ref.slice(1).split("/").filter(Boolean);
+  if (path2.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path[0] === defsKey) {
-    const key = path[1];
+  if (path2[0] === defsKey) {
+    const key = path2[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15890,7 +15893,8 @@ var TestExporter = class extends BaseExporter {
     this.#trackEvent("log");
     if (this.#config.storeLogs) {
       const log = event.log;
-      const logMessage = `[TestExporter] log.${log.level}: "${log.message}"${log.traceId ? ` (trace: ${log.traceId.slice(-8)})` : ""}`;
+      const traceId = log.correlationContext?.traceId;
+      const logMessage = `[TestExporter] log.${log.level}: "${log.message}"${traceId ? ` (trace: ${traceId.slice(-8)})` : ""}`;
       this.#debugLogs.push(logMessage);
     }
     this.#logEvents.push(event);
@@ -16007,7 +16011,7 @@ var TestExporter = class extends BaseExporter {
   getByTraceId(traceId) {
     const events = this.#tracingEvents.filter((e) => e.exportedSpan.traceId === traceId);
     const spans = this.#getUniqueSpansFromEvents(events);
-    const logs = this.#logEvents.filter((e) => e.log.traceId === traceId).map((e) => e.log);
+    const logs = this.#logEvents.filter((e) => e.log.correlationContext?.traceId === traceId).map((e) => e.log);
     const scores = this.#scoreEvents.filter((e) => e.score.traceId === traceId).map((e) => e.score);
     const feedback = this.#feedbackEvents.filter((e) => e.feedback.traceId === traceId).map((e) => e.feedback);
     return { events, spans, logs, scores, feedback };
@@ -16074,7 +16078,7 @@ var TestExporter = class extends BaseExporter {
       traceIds.add(event.exportedSpan.traceId);
     }
     for (const event of this.#logEvents) {
-      if (event.log.traceId) traceIds.add(event.log.traceId);
+      if (event.log.correlationContext?.traceId) traceIds.add(event.log.correlationContext.traceId);
     }
     for (const event of this.#scoreEvents) {
       traceIds.add(event.score.traceId);
@@ -16109,7 +16113,7 @@ var TestExporter = class extends BaseExporter {
    * Get logs for a specific trace
    */
   getLogsByTraceId(traceId) {
-    return this.#logEvents.filter((e) => e.log.traceId === traceId).map((e) => e.log);
+    return this.#logEvents.filter((e) => e.log.correlationContext?.traceId === traceId).map((e) => e.log);
   }
   // ============================================================================
   // Metric Query Methods
@@ -16692,23 +16696,23 @@ Run with { updateSnapshot: true } to update.`
    * Deep compare two values, supporting special markers like __or__ and __any__.
    * Collects all mismatches into the provided array.
    */
-  #deepCompareWithMarkers(actual, expected, path, mismatches) {
+  #deepCompareWithMarkers(actual, expected, path2, mismatches) {
     if (this.#isOrMarker(expected)) {
       const allowedValues = expected.__or__;
       const matches = allowedValues.some((allowed) => {
         const tempMismatches = [];
-        this.#deepCompareWithMarkers(actual, allowed, path, tempMismatches);
+        this.#deepCompareWithMarkers(actual, allowed, path2, tempMismatches);
         return tempMismatches.length === 0;
       });
       if (!matches) {
-        mismatches.push({ path, expected: { __or__: allowedValues }, actual });
+        mismatches.push({ path: path2, expected: { __or__: allowedValues }, actual });
       }
       return;
     }
     if (this.#isAnyMarker(expected)) {
       const typeConstraint = expected.__any__;
       if (actual === null || actual === void 0) {
-        mismatches.push({ path, expected: { __any__: typeConstraint }, actual });
+        mismatches.push({ path: path2, expected: { __any__: typeConstraint }, actual });
         return;
       }
       if (typeConstraint === true) {
@@ -16717,7 +16721,7 @@ Run with { updateSnapshot: true } to update.`
       const actualType = Array.isArray(actual) ? "array" : typeof actual;
       if (actualType !== typeConstraint) {
         mismatches.push({
-          path,
+          path: path2,
           expected: { __any__: typeConstraint },
           actual: `(${actualType}) ${JSON.stringify(actual).slice(0, 50)}...`
         });
@@ -16726,21 +16730,21 @@ Run with { updateSnapshot: true } to update.`
     }
     if (Array.isArray(expected)) {
       if (!Array.isArray(actual)) {
-        mismatches.push({ path, expected, actual });
+        mismatches.push({ path: path2, expected, actual });
         return;
       }
       if (actual.length !== expected.length) {
-        mismatches.push({ path: `${path}.length`, expected: expected.length, actual: actual.length });
+        mismatches.push({ path: `${path2}.length`, expected: expected.length, actual: actual.length });
         return;
       }
       for (let i = 0; i < expected.length; i++) {
-        this.#deepCompareWithMarkers(actual[i], expected[i], `${path}[${i}]`, mismatches);
+        this.#deepCompareWithMarkers(actual[i], expected[i], `${path2}[${i}]`, mismatches);
       }
       return;
     }
     if (expected !== null && typeof expected === "object") {
       if (actual === null || typeof actual !== "object" || Array.isArray(actual)) {
-        mismatches.push({ path, expected, actual });
+        mismatches.push({ path: path2, expected, actual });
         return;
       }
       const expectedObj = expected;
@@ -16751,11 +16755,11 @@ Run with { updateSnapshot: true } to update.`
         }
         if (!(key in actualObj)) {
           if (expectedObj[key] !== void 0) {
-            mismatches.push({ path: `${path}.${key}`, expected: expectedObj[key], actual: void 0 });
+            mismatches.push({ path: `${path2}.${key}`, expected: expectedObj[key], actual: void 0 });
           }
           continue;
         }
-        this.#deepCompareWithMarkers(actualObj[key], expectedObj[key], `${path}.${key}`, mismatches);
+        this.#deepCompareWithMarkers(actualObj[key], expectedObj[key], `${path2}.${key}`, mismatches);
       }
       for (const key of Object.keys(actualObj)) {
         if (this.#isMetadataKey(key)) {
@@ -16763,14 +16767,14 @@ Run with { updateSnapshot: true } to update.`
         }
         if (!(key in expectedObj)) {
           if (actualObj[key] !== void 0) {
-            mismatches.push({ path: `${path}.${key}`, expected: void 0, actual: actualObj[key] });
+            mismatches.push({ path: `${path2}.${key}`, expected: void 0, actual: actualObj[key] });
           }
         }
       }
       return;
     }
     if (actual !== expected) {
-      mismatches.push({ path, expected, actual });
+      mismatches.push({ path: path2, expected, actual });
     }
   }
   /**
@@ -16983,120 +16987,6 @@ var BaseObservabilityEventBus = class _BaseObservabilityEventBus extends MastraB
     this.subscribers.clear();
   }
 };
-var AutoExtractedMetrics = class {
-  constructor(observabilityBus) {
-    this.observabilityBus = observabilityBus;
-  }
-  /**
-   * Route a tracing event to the appropriate handler.
-   * SPAN_ENDED emits duration and token metrics (for model spans).
-   */
-  processTracingEvent(event) {
-    if (event.type === TracingEventType.SPAN_ENDED) {
-      this.onSpanEnded(event.exportedSpan);
-    }
-  }
-  /** Emit duration and token metrics when a span ends. */
-  onSpanEnded(span) {
-    const labels = this.extractLabels(span);
-    const durationMetricName = this.getDurationMetricName(span);
-    if (durationMetricName && span.startTime && span.endTime) {
-      const durationMs = span.endTime.getTime() - span.startTime.getTime();
-      const durationLabels = { ...labels };
-      durationLabels.status = span.errorInfo ? "error" : "ok";
-      this.observabilityBus.emitMetric(durationMetricName, durationMs, durationLabels);
-    }
-    if (span.type === SpanType.MODEL_GENERATION) {
-      const attrs = span.attributes;
-      if (attrs?.usage) {
-        this.extractTokenMetrics(attrs.usage, labels);
-      }
-    }
-  }
-  /** Build base metric labels from a span's entity and model attributes. */
-  extractLabels(span) {
-    const labels = {};
-    if (span.entityType) labels.entity_type = span.entityType;
-    const entityName = span.entityName ?? span.entityId;
-    if (entityName) labels.entity_name = entityName;
-    if (span.type === SpanType.MODEL_GENERATION) {
-      const attrs = span.attributes;
-      if (attrs?.model) labels.model = attrs.model;
-      if (attrs?.provider) labels.provider = attrs.provider;
-    }
-    return labels;
-  }
-  /** Emit token usage metrics from UsageStats. */
-  extractTokenMetrics(usage, labels) {
-    const emit = (name, value) => this.observabilityBus.emitMetric(name, value, labels);
-    const emitNonZero = (name, value) => {
-      if (value > 0) emit(name, value);
-    };
-    emit("mastra_model_total_input_tokens", usage.inputTokens ?? 0);
-    emit("mastra_model_total_output_tokens", usage.outputTokens ?? 0);
-    if (usage.inputDetails) {
-      emitNonZero("mastra_model_input_text_tokens", usage.inputDetails.text ?? 0);
-      emitNonZero("mastra_model_input_cache_read_tokens", usage.inputDetails.cacheRead ?? 0);
-      emitNonZero("mastra_model_input_cache_write_tokens", usage.inputDetails.cacheWrite ?? 0);
-      emitNonZero("mastra_model_input_audio_tokens", usage.inputDetails.audio ?? 0);
-      emitNonZero("mastra_model_input_image_tokens", usage.inputDetails.image ?? 0);
-    }
-    if (usage.outputDetails) {
-      emitNonZero("mastra_model_output_text_tokens", usage.outputDetails.text ?? 0);
-      emitNonZero("mastra_model_output_reasoning_tokens", usage.outputDetails.reasoning ?? 0);
-      emitNonZero("mastra_model_output_audio_tokens", usage.outputDetails.audio ?? 0);
-      emitNonZero("mastra_model_output_image_tokens", usage.outputDetails.image ?? 0);
-    }
-  }
-  /** Map a span type to its `*_duration_ms` metric name, or `null` for unsupported types. */
-  getDurationMetricName(span) {
-    switch (span.type) {
-      case SpanType.AGENT_RUN:
-        return "mastra_agent_duration_ms";
-      case SpanType.TOOL_CALL:
-        return "mastra_tool_duration_ms";
-      case SpanType.WORKFLOW_RUN:
-        return "mastra_workflow_duration_ms";
-      case SpanType.MODEL_GENERATION:
-        return "mastra_model_duration_ms";
-      default:
-        return null;
-    }
-  }
-};
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var CardinalityFilter = class {
-  blockedLabels;
-  blockUUIDs;
-  /**
-   * @param config - Optional configuration. When omitted, uses
-   *   {@link DEFAULT_BLOCKED_LABELS} and blocks UUID-valued labels.
-   */
-  constructor(config2) {
-    const blocked = config2?.blockedLabels ?? [...DEFAULT_BLOCKED_LABELS];
-    this.blockedLabels = new Set(blocked.map((l) => l.toLowerCase()));
-    this.blockUUIDs = config2?.blockUUIDs ?? true;
-  }
-  /**
-   * Return a copy of `labels` with blocked keys and UUID values removed.
-   *
-   * @param labels - Raw metric labels to filter.
-   * @returns A new object containing only the allowed labels.
-   */
-  filterLabels(labels) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(labels)) {
-      if (this.blockedLabels.has(key.toLowerCase())) {
-        continue;
-      }
-      if (this.blockUUIDs && UUID_REGEX.test(value)) {
-        continue;
-      }
-      filtered[key] = value;
-    }
-    return filtered;
-  }
-};
 function routeToHandler(handler, event, logger) {
   try {
     switch (event.type) {
@@ -17141,39 +17031,13 @@ function catchAsyncResult(result, handlerName, signal, logger) {
 
 // src/bus/observability-bus.ts
 var MAX_FLUSH_ITERATIONS = 3;
-function isTracingEvent(event) {
-  return event.type === TracingEventType.SPAN_STARTED || event.type === TracingEventType.SPAN_UPDATED || event.type === TracingEventType.SPAN_ENDED;
-}
 var ObservabilityBus = class extends BaseObservabilityEventBus {
   exporters = [];
   bridge;
-  autoExtractor;
-  cardinalityFilter;
   /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
   pendingHandlers = /* @__PURE__ */ new Set();
-  constructor(config2) {
+  constructor() {
     super({ name: "ObservabilityBus" });
-    this.cardinalityFilter = config2?.cardinalityFilter ?? new CardinalityFilter();
-    if (config2?.autoExtractMetrics !== false) {
-      this.autoExtractor = new AutoExtractedMetrics(this);
-    }
-  }
-  /**
-   * Emit a metric event with validation and cardinality filtering.
-   * Non-finite or negative values are silently dropped.
-   * This is the single entry point for all metric emission (auto-extracted and user-defined).
-   */
-  emitMetric(name, value, labels) {
-    if (!Number.isFinite(value) || value < 0) return;
-    const filteredLabels = this.cardinalityFilter.filterLabels(labels);
-    const exportedMetric = {
-      timestamp: /* @__PURE__ */ new Date(),
-      name,
-      value,
-      labels: filteredLabels
-    };
-    const event = { type: "metric", metric: exportedMetric };
-    this.emit(event);
   }
   /**
    * Register an exporter to receive routed events.
@@ -17239,8 +17103,8 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
     return this.bridge;
   }
   /**
-   * Emit an event: route to exporter/bridge handlers, run auto-extraction,
-   * then forward to base class for subscriber delivery.
+   * Emit an event: route to exporter/bridge handlers, then forward to base
+   * class for subscriber delivery.
    *
    * emit() is synchronous — async handler promises are tracked internally
    * and can be drained via flush().
@@ -17252,13 +17116,6 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
     if (this.bridge) {
       this.trackPromise(routeToHandler(this.bridge, event, this.logger));
     }
-    if (this.autoExtractor && isTracingEvent(event)) {
-      try {
-        this.autoExtractor.processTracingEvent(event);
-      } catch (err) {
-        this.logger.error("[ObservabilityBus] Auto-extraction error:", err);
-      }
-    }
     super.emit(event);
   }
   /**
@@ -17326,13 +17183,13 @@ var LOG_LEVEL_PRIORITY = {
 var LoggerContextImpl = class {
   config;
   /**
-   * Create a logger context. Tags and metadata are defensively copied so
+   * Create a logger context. Context and metadata are defensively copied so
    * mutations after construction do not affect emitted logs.
    */
   constructor(config2) {
     this.config = {
       ...config2,
-      tags: config2.tags ? [...config2.tags] : void 0,
+      correlationContext: config2.correlationContext ? { ...config2.correlationContext } : void 0,
       metadata: config2.metadata ? structuredClone(config2.metadata) : void 0
     };
   }
@@ -17369,9 +17226,7 @@ var LoggerContextImpl = class {
       level,
       message,
       data,
-      traceId: this.config.traceId,
-      spanId: this.config.spanId,
-      tags: this.config.tags,
+      correlationContext: this.config.correlationContext,
       metadata: this.config.metadata
     };
     const event = { type: "log", log: exportedLog };
@@ -17381,20 +17236,38 @@ var LoggerContextImpl = class {
 
 // src/context/metrics.ts
 var MetricsContextImpl = class {
-  baseLabels;
+  correlationContext;
+  metadata;
+  cardinalityFilter;
   observabilityBus;
   /**
-   * Create a metrics context. Base labels are defensively copied so
-   * mutations after construction do not affect emitted metrics.
+   * Create a metrics context. Correlation context and metadata are defensively
+   * copied so mutations after construction do not affect emitted metrics.
    */
   constructor(config2) {
-    this.baseLabels = config2.labels ? { ...config2.labels } : {};
+    this.correlationContext = config2.correlationContext ? { ...config2.correlationContext } : void 0;
+    this.metadata = config2.metadata ? structuredClone(config2.metadata) : void 0;
+    this.cardinalityFilter = config2.cardinalityFilter;
     this.observabilityBus = config2.observabilityBus;
   }
   /** Emit a metric observation. */
-  emit(name, value, labels) {
-    const allLabels = { ...this.baseLabels, ...labels };
-    this.observabilityBus.emitMetric(name, value, allLabels);
+  emit(name, value, labels, options) {
+    if (!Number.isFinite(value) || value < 0) {
+      return;
+    }
+    const filteredLabels = labels ? this.cardinalityFilter.filterLabels(labels) : {};
+    const costContext = options?.costContext ? cloneCostContext(options.costContext) : void 0;
+    const exportedMetric = {
+      timestamp: /* @__PURE__ */ new Date(),
+      name,
+      value,
+      labels: filteredLabels,
+      correlationContext: this.correlationContext,
+      costContext,
+      metadata: this.metadata
+    };
+    const event = { type: "metric", metric: exportedMetric };
+    this.observabilityBus.emit(event);
   }
   /** @deprecated Use `emit()` instead. */
   counter(name) {
@@ -17421,6 +17294,563 @@ var MetricsContextImpl = class {
     };
   }
 };
+function cloneCostContext(costContext) {
+  return {
+    provider: costContext.provider,
+    model: costContext.model,
+    estimatedCost: costContext.estimatedCost,
+    costUnit: costContext.costUnit,
+    costMetadata: costContext.costMetadata ? structuredClone(costContext.costMetadata) : void 0
+  };
+}
+
+// src/metrics/pricing-model.ts
+var PricingTier = class {
+  index;
+  when;
+  rates;
+  constructor(args) {
+    this.index = args.index;
+    this.when = args.when;
+    this.rates = args.rates;
+  }
+  matchesUsage(usage) {
+    if (!this.when || this.when.length === 0) {
+      return true;
+    }
+    return this.when.every((condition) => this.matchesCondition(condition, usage));
+  }
+  hasMatchingMeterForUsage(meter) {
+    return Boolean(meter && typeof this.rates[meter] === "number");
+  }
+  matchesCondition(condition, usage) {
+    const left = this.getConditionFieldValue(condition.field, usage);
+    if (left == null) {
+      return false;
+    }
+    switch (condition.op) {
+      case "gt":
+        return left > condition.value;
+      case "gte":
+        return left >= condition.value;
+      case "lt":
+        return left < condition.value;
+      case "lte":
+        return left <= condition.value;
+      case "eq":
+        return left === condition.value;
+      case "neq":
+        return left !== condition.value;
+      default:
+        return false;
+    }
+  }
+  getConditionFieldValue(field, usage) {
+    switch (field) {
+      case "total_input_tokens":
+        return typeof usage.inputTokens === "number" ? usage.inputTokens : null;
+      default:
+        return null;
+    }
+  }
+};
+var PricingModel = class {
+  id;
+  provider;
+  model;
+  schema;
+  currency;
+  tiers;
+  constructor(args) {
+    this.id = args.id;
+    this.provider = args.provider;
+    this.model = args.model;
+    this.schema = args.schema;
+    this.currency = args.currency;
+    this.tiers = args.tiers;
+  }
+  getPricingTierForUsage(usage) {
+    for (const tier of this.tiers) {
+      if (tier.when && tier.when.length > 0 && tier.matchesUsage(usage)) {
+        return tier;
+      }
+    }
+    return this.getBasePricingTier();
+  }
+  getBasePricingTier() {
+    return this.tiers[0] ?? null;
+  }
+};
+
+// src/metrics/pricing-registry.ts
+var DATA_FILE_NAME = "pricing-data.jsonl";
+var MINIFIED_METER_TO_CANONICAL = {
+  it: "input_tokens",
+  ot: "output_tokens",
+  icrt: "input_cache_read_tokens",
+  icwt: "input_cache_write_tokens",
+  iat: "input_audio_tokens",
+  oat: "output_audio_tokens",
+  ort: "output_reasoning_tokens"
+};
+var MINIFIED_CONDITION_FIELD_TO_CANONICAL = {
+  tit: "total_input_tokens"
+};
+var cachedLoadError = null;
+var PricingRegistry = class _PricingRegistry {
+  constructor(pricingModels) {
+    this.pricingModels = pricingModels;
+  }
+  static globalRegistry = null;
+  static fromText(pricingModelText) {
+    return new _PricingRegistry(parsePricingModelText(pricingModelText));
+  }
+  static getGlobal() {
+    if (_PricingRegistry.globalRegistry) {
+      return _PricingRegistry.globalRegistry;
+    }
+    const pricingModels = loadPricingModels();
+    if (!pricingModels) {
+      return null;
+    }
+    _PricingRegistry.globalRegistry = new _PricingRegistry(pricingModels);
+    return _PricingRegistry.globalRegistry;
+  }
+  get(args) {
+    return this.pricingModels.get(makePricingKey(args)) ?? null;
+  }
+};
+function loadPricingModels() {
+  if (cachedLoadError) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(resolvePricingModelPath(), "utf-8");
+    return parsePricingModelText(content);
+  } catch (error48) {
+    cachedLoadError = error48 instanceof Error ? error48.message : String(error48);
+    return null;
+  }
+}
+function parsePricingModelText(content) {
+  const pricingModels = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const parsed = JSON.parse(trimmed);
+    const pricingModel = expandPricingModelRow(parsed);
+    pricingModels.set(makePricingKey(pricingModel), pricingModel);
+  }
+  return pricingModels;
+}
+function expandPricingModelRow(row) {
+  return new PricingModel({
+    id: row.i,
+    provider: row.p,
+    model: row.m,
+    schema: row.s.v,
+    currency: row.s.d.u,
+    tiers: row.s.d.t.map(
+      (tier, index) => new PricingTier({
+        index,
+        when: tier.w?.map((condition) => ({
+          field: MINIFIED_CONDITION_FIELD_TO_CANONICAL[condition.f],
+          op: condition.op,
+          value: condition.value
+        })),
+        rates: Object.fromEntries(
+          Object.entries(tier.r).map(([meter, value]) => [
+            MINIFIED_METER_TO_CANONICAL[meter],
+            value.c
+          ])
+        )
+      })
+    )
+  });
+}
+function resolvePricingModelPath() {
+  const packageRoot = getPackageRoot();
+  const candidates = [
+    path.join(packageRoot, "dist", "metrics", DATA_FILE_NAME),
+    path.join(packageRoot, "src", "metrics", DATA_FILE_NAME),
+    path.join(process.cwd(), "observability", "mastra", "src", "metrics", DATA_FILE_NAME),
+    path.join(process.cwd(), "src", "metrics", DATA_FILE_NAME)
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to locate pricing data JSONL at any known path: ${candidates.join(", ")}`);
+}
+function getPackageRoot() {
+  try {
+    const require2 = createRequire(import.meta.url || "file://");
+    const packageJsonPath = require2.resolve("@mastra/observability/package.json");
+    return path.dirname(packageJsonPath);
+  } catch {
+    return process.cwd();
+  }
+}
+function makePricingKey(args) {
+  return `${normalizeKeyPart(args.provider)}::${normalizeKeyPart(args.model)}`;
+}
+function normalizeKeyPart(value) {
+  return value.trim().toLowerCase();
+}
+
+// src/metrics/types.ts
+var PricingMeter = {
+  INPUT_TOKENS: "input_tokens",
+  INPUT_AUDIO_TOKENS: "input_audio_tokens",
+  INPUT_CACHE_READ_TOKENS: "input_cache_read_tokens",
+  INPUT_CACHE_WRITE_TOKENS: "input_cache_write_tokens",
+  INPUT_IMAGE_TOKENS: "input_image_tokens",
+  OUTPUT_TOKENS: "output_tokens",
+  OUTPUT_AUDIO_TOKENS: "output_audio_tokens",
+  OUTPUT_IMAGE_TOKENS: "output_image_tokens",
+  OUTPUT_REASONING_TOKENS: "output_reasoning_tokens"
+};
+var TokenMetrics = {
+  TOTAL_INPUT: "mastra_model_total_input_tokens",
+  TOTAL_OUTPUT: "mastra_model_total_output_tokens",
+  INPUT_TEXT: "mastra_model_input_text_tokens",
+  INPUT_CACHE_READ: "mastra_model_input_cache_read_tokens",
+  INPUT_CACHE_WRITE: "mastra_model_input_cache_write_tokens",
+  INPUT_AUDIO: "mastra_model_input_audio_tokens",
+  INPUT_IMAGE: "mastra_model_input_image_tokens",
+  OUTPUT_TEXT: "mastra_model_output_text_tokens",
+  OUTPUT_REASONING: "mastra_model_output_reasoning_tokens",
+  OUTPUT_AUDIO: "mastra_model_output_audio_tokens",
+  OUTPUT_IMAGE: "mastra_model_output_image_tokens"
+};
+
+// src/metrics/usage-metrics.ts
+function getTokenMetricSamples(usage) {
+  const samples = [];
+  const pushIfDefined = (name, value) => {
+    if (value != null) {
+      samples.push({ name, value });
+    }
+  };
+  const pushIfPositive = (name, value) => {
+    if (value != null && value > 0) {
+      samples.push({ name, value });
+    }
+  };
+  pushIfDefined(TokenMetrics.TOTAL_INPUT, usage.inputTokens);
+  pushIfDefined(TokenMetrics.TOTAL_OUTPUT, usage.outputTokens);
+  if (usage.inputDetails) {
+    pushIfPositive(TokenMetrics.INPUT_TEXT, usage.inputDetails.text);
+    pushIfPositive(TokenMetrics.INPUT_CACHE_READ, usage.inputDetails.cacheRead);
+    pushIfPositive(TokenMetrics.INPUT_CACHE_WRITE, usage.inputDetails.cacheWrite);
+    pushIfPositive(TokenMetrics.INPUT_AUDIO, usage.inputDetails.audio);
+    pushIfPositive(TokenMetrics.INPUT_IMAGE, usage.inputDetails.image);
+  }
+  if (usage.outputDetails) {
+    pushIfPositive(TokenMetrics.OUTPUT_TEXT, usage.outputDetails.text);
+    pushIfPositive(TokenMetrics.OUTPUT_REASONING, usage.outputDetails.reasoning);
+    pushIfPositive(TokenMetrics.OUTPUT_AUDIO, usage.outputDetails.audio);
+    pushIfPositive(TokenMetrics.OUTPUT_IMAGE, usage.outputDetails.image);
+  }
+  return samples;
+}
+
+// src/metrics/estimator.ts
+function estimateCosts(args, pricingRegistry = PricingRegistry.getGlobal()) {
+  const { provider, model, usage } = args;
+  const results = /* @__PURE__ */ new Map();
+  const pricingModel = pricingRegistry?.get({ provider, model });
+  if (!pricingModel) {
+    const errorContext = { costMetadata: { error: "no_matching_model" }, provider, model };
+    applyErrorContextForUsage(results, usage, errorContext);
+    return results;
+  }
+  const costMetadata = { pricing_id: pricingModel.id };
+  const pricingTier = pricingModel.getPricingTierForUsage(usage);
+  if (!pricingTier) {
+    const errorContext = { costMetadata: { ...costMetadata, error: "no_matching_tier" }, provider, model };
+    applyErrorContextForUsage(results, usage, errorContext);
+    return results;
+  }
+  costMetadata["tier_index"] = pricingTier.index;
+  const estimateFields = {
+    pricingModel,
+    pricingTier,
+    costMetadata
+  };
+  const inputDetailResults = [];
+  if (usage.inputDetails?.audio) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.INPUT_AUDIO_TOKENS,
+      tokenCount: usage.inputDetails.audio,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.INPUT_AUDIO, result.costContext);
+    inputDetailResults.push(result);
+  }
+  if (usage.inputDetails?.cacheRead) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.INPUT_CACHE_READ_TOKENS,
+      tokenCount: usage.inputDetails.cacheRead,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.INPUT_CACHE_READ, result.costContext);
+    inputDetailResults.push(result);
+  }
+  if (usage.inputDetails?.cacheWrite) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.INPUT_CACHE_WRITE_TOKENS,
+      tokenCount: usage.inputDetails.cacheWrite,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.INPUT_CACHE_WRITE, result.costContext);
+    inputDetailResults.push(result);
+  }
+  if (usage.inputDetails?.image) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.INPUT_IMAGE_TOKENS,
+      tokenCount: usage.inputDetails.image,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.INPUT_IMAGE, result.costContext);
+    inputDetailResults.push(result);
+  }
+  if (usage.inputDetails?.text) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.INPUT_TOKENS,
+      tokenCount: usage.inputDetails.text,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.INPUT_TEXT, result.costContext);
+    inputDetailResults.push(result);
+  }
+  setAggregateCostContext({
+    results,
+    totalMetric: TokenMetrics.TOTAL_INPUT,
+    fallbackMeter: PricingMeter.INPUT_TOKENS,
+    totalTokenCount: usage.inputTokens,
+    detailResults: inputDetailResults,
+    ...estimateFields
+  });
+  const outputDetailResults = [];
+  if (usage.outputDetails?.audio) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.OUTPUT_AUDIO_TOKENS,
+      tokenCount: usage.outputDetails.audio,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.OUTPUT_AUDIO, result.costContext);
+    outputDetailResults.push(result);
+  }
+  if (usage.outputDetails?.image) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.OUTPUT_IMAGE_TOKENS,
+      tokenCount: usage.outputDetails.image,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.OUTPUT_IMAGE, result.costContext);
+    outputDetailResults.push(result);
+  }
+  if (usage.outputDetails?.reasoning) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.OUTPUT_REASONING_TOKENS,
+      tokenCount: usage.outputDetails.reasoning,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.OUTPUT_REASONING, result.costContext);
+    outputDetailResults.push(result);
+  }
+  if (usage.outputDetails?.text) {
+    const result = estimateCostForMeter({
+      meter: PricingMeter.OUTPUT_TOKENS,
+      tokenCount: usage.outputDetails.text,
+      ...estimateFields
+    });
+    results.set(TokenMetrics.OUTPUT_TEXT, result.costContext);
+    outputDetailResults.push(result);
+  }
+  setAggregateCostContext({
+    results,
+    totalMetric: TokenMetrics.TOTAL_OUTPUT,
+    fallbackMeter: PricingMeter.OUTPUT_TOKENS,
+    totalTokenCount: usage.outputTokens,
+    detailResults: outputDetailResults,
+    ...estimateFields
+  });
+  return results;
+}
+function applyErrorContextForUsage(results, usage, errorContext) {
+  for (const sample of getTokenMetricSamples(usage)) {
+    results.set(sample.name, errorContext);
+  }
+}
+function setAggregateCostContext(args) {
+  const {
+    results,
+    totalMetric,
+    fallbackMeter,
+    totalTokenCount,
+    detailResults,
+    pricingModel,
+    pricingTier,
+    costMetadata
+  } = args;
+  if (totalTokenCount == null) {
+    return;
+  }
+  const successfulDetailCosts = detailResults.filter((result) => result.success).map((result) => result.costContext.estimatedCost).filter((value) => typeof value === "number");
+  if (successfulDetailCosts.length > 0) {
+    const hasFailedDetailCost = detailResults.some((result) => !result.success);
+    results.set(totalMetric, {
+      provider: pricingModel.provider,
+      model: pricingModel.model,
+      estimatedCost: successfulDetailCosts.reduce((sum, value) => sum + value, 0),
+      costUnit: pricingModel.currency,
+      costMetadata: hasFailedDetailCost ? { ...costMetadata, error: "partial_cost" } : { ...costMetadata }
+    });
+    return;
+  }
+  const fallbackResult = estimateCostForMeter({
+    meter: fallbackMeter,
+    tokenCount: totalTokenCount,
+    pricingModel,
+    pricingTier,
+    costMetadata
+  });
+  results.set(totalMetric, fallbackResult.costContext);
+}
+function estimateCostForMeter(args) {
+  const { pricingModel, pricingTier, meter, tokenCount, costMetadata } = args;
+  const costContext = {
+    provider: pricingModel.provider,
+    model: pricingModel.model
+  };
+  const pricePerUnit = pricingTier.rates[meter];
+  if (typeof pricePerUnit !== "number") {
+    return {
+      success: false,
+      costContext: {
+        ...costContext,
+        costMetadata: { ...costMetadata, error: "no_pricing_for_usage_type" }
+      }
+    };
+  }
+  return {
+    success: true,
+    costContext: {
+      ...costContext,
+      estimatedCost: tokenCount * pricePerUnit,
+      costUnit: pricingModel.currency,
+      costMetadata: { ...costMetadata }
+    }
+  };
+}
+
+// src/metrics/auto-extract.ts
+function emitDurationMetrics(span, metrics) {
+  const durationMetricName = getDurationMetricName(span);
+  if (!durationMetricName || !span.startTime || !span.endTime) {
+    return;
+  }
+  const durationMs = span.endTime.getTime() - span.startTime.getTime();
+  metrics.emit(durationMetricName, durationMs, {
+    status: span.errorInfo ? "error" : "ok"
+  });
+}
+function emitTokenMetrics(span, metrics) {
+  if (span.type !== SpanType.MODEL_GENERATION) {
+    return;
+  }
+  const attrs = span.attributes;
+  if (!attrs?.usage) {
+    return;
+  }
+  emitUsageMetrics(attrs, attrs.usage, metrics);
+}
+function emitAutoExtractedMetrics(span, metrics) {
+  emitDurationMetrics(span, metrics);
+  emitTokenMetrics(span, metrics);
+}
+function emitUsageMetrics(attrs, usage, metrics) {
+  let metricCosts = /* @__PURE__ */ new Map();
+  try {
+    const provider = attrs.provider;
+    const model = attrs.responseModel ?? attrs.model;
+    if (provider && model) {
+      metricCosts = estimateCosts({
+        provider,
+        model,
+        usage
+      });
+    }
+  } catch {
+    metricCosts = /* @__PURE__ */ new Map();
+  }
+  const emit = (name, value) => {
+    const costContext = metricCosts.get(name);
+    if (!costContext) {
+      metrics.emit(name, value);
+      return;
+    }
+    metrics.emit(name, value, void 0, { costContext });
+  };
+  for (const sample of getTokenMetricSamples(usage)) {
+    emit(sample.name, sample.value);
+  }
+}
+function getDurationMetricName(span) {
+  switch (span.type) {
+    case SpanType.AGENT_RUN:
+      return "mastra_agent_duration_ms";
+    case SpanType.TOOL_CALL:
+    case SpanType.MCP_TOOL_CALL:
+      return "mastra_tool_duration_ms";
+    case SpanType.WORKFLOW_RUN:
+      return "mastra_workflow_duration_ms";
+    case SpanType.MODEL_GENERATION:
+      return "mastra_model_duration_ms";
+    case SpanType.PROCESSOR_RUN:
+      return "mastra_processor_duration_ms";
+    default:
+      return null;
+  }
+}
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CardinalityFilter = class {
+  blockedLabels;
+  blockUUIDs;
+  /**
+   * @param config - Optional configuration. When omitted, uses
+   *   {@link DEFAULT_BLOCKED_LABELS} and blocks UUID-valued labels.
+   */
+  constructor(config2) {
+    const blocked = config2?.blockedLabels ?? [...DEFAULT_BLOCKED_LABELS];
+    this.blockedLabels = new Set(blocked.map((l) => l.toLowerCase()));
+    this.blockUUIDs = config2?.blockUUIDs ?? true;
+  }
+  /**
+   * Return a copy of `labels` with blocked keys and UUID values removed.
+   *
+   * @param labels - Raw metric labels to filter.
+   * @returns A new object containing only the allowed labels.
+   */
+  filterLabels(labels) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(labels)) {
+      if (this.blockedLabels.has(key.toLowerCase())) {
+        continue;
+      }
+      if (this.blockUUIDs && UUID_REGEX.test(value)) {
+        continue;
+      }
+      filtered[key] = value;
+    }
+    return filtered;
+  }
+};
 
 // src/usage.ts
 function isDefined(value) {
@@ -17456,7 +17886,6 @@ function extractUsageMetrics(usage, providerMetadata) {
       inputDetails.cacheWrite = anthropic.cacheCreationInputTokens;
     }
     if (isDefined(inputDetails.cacheRead) || isDefined(inputDetails.cacheWrite)) {
-      inputDetails.text = usage.inputTokens;
       inputTokens = (usage.inputTokens ?? 0) + (inputDetails.cacheRead ?? 0) + (inputDetails.cacheWrite ?? 0);
     }
   }
@@ -17469,6 +17898,15 @@ function extractUsageMetrics(usage, providerMetadata) {
       outputDetails.reasoning = google.usageMetadata.thoughtsTokenCount;
     }
   }
+  if (isDefined(inputTokens)) {
+    inputDetails.text = Math.max(
+      0,
+      inputTokens - sumDefinedValues(inputDetails, ["cacheRead", "cacheWrite", "audio", "image"])
+    );
+  }
+  if (isDefined(outputTokens)) {
+    outputDetails.text = Math.max(0, outputTokens - sumDefinedValues(outputDetails, ["reasoning", "audio", "image"]));
+  }
   const result = {
     inputTokens,
     outputTokens
@@ -17481,6 +17919,9 @@ function extractUsageMetrics(usage, providerMetadata) {
   }
   return result;
 }
+function sumDefinedValues(obj, keys) {
+  return keys.reduce((sum, key) => sum + (obj[key] ?? 0), 0);
+}
 
 // src/model-tracing.ts
 var ModelSpanTracker = class {
@@ -18187,6 +18628,8 @@ var BaseSpan = class {
   parentSpanId;
   /** Deep clean options for serialization */
   deepCleanOptions;
+  /** Cached canonical correlation context for this live span */
+  correlationContext;
   constructor(options, observabilityInstance) {
     const serializationOptions = observabilityInstance.getConfig().serializationOptions;
     this.deepCleanOptions = mergeSerializationOptions(serializationOptions);
@@ -18268,6 +18711,46 @@ var BaseSpan = class {
     }
     return void 0;
   }
+  /** Build and cache the canonical correlation context for this live span. */
+  getCorrelationContext() {
+    if (this.correlationContext) {
+      return this.correlationContext;
+    }
+    const metadata = this.metadata ?? {};
+    const getMetadataString = (key) => typeof metadata[key] === "string" ? metadata[key] : void 0;
+    const parentSpan = this.getParentSpan(false);
+    let rootSpan = this;
+    while (rootSpan.parent) {
+      rootSpan = rootSpan.parent;
+    }
+    const rootTags = rootSpan.tags?.length ? [...rootSpan.tags] : void 0;
+    this.correlationContext = {
+      traceId: this.traceId,
+      spanId: this.id,
+      tags: rootTags,
+      entityType: this.entityType,
+      entityId: this.entityId,
+      entityName: this.entityName,
+      parentEntityType: parentSpan?.entityType,
+      parentEntityId: parentSpan?.entityId,
+      parentEntityName: parentSpan?.entityName,
+      rootEntityType: rootSpan.entityType,
+      rootEntityId: rootSpan.entityId,
+      rootEntityName: rootSpan.entityName,
+      userId: getMetadataString("userId"),
+      organizationId: getMetadataString("organizationId"),
+      resourceId: getMetadataString("resourceId"),
+      runId: getMetadataString("runId"),
+      sessionId: getMetadataString("sessionId"),
+      threadId: getMetadataString("threadId"),
+      requestId: getMetadataString("requestId"),
+      environment: getMetadataString("environment"),
+      source: getMetadataString("source"),
+      serviceName: getMetadataString("serviceName") ?? this.observabilityInstance.getConfig().serviceName,
+      experimentId: getMetadataString("experimentId")
+    };
+    return this.correlationContext;
+  }
   /** Returns a lightweight span ready for export */
   exportSpan(includeInternalSpans) {
     const hideInput = this.traceState?.hideInput ?? false;
@@ -18522,9 +19005,7 @@ var BaseObservabilityInstance = class extends MastraBase {
       serializationOptions: config2.serializationOptions
     };
     this.cardinalityFilter = new CardinalityFilter(config2.cardinality);
-    this.observabilityBus = new ObservabilityBus({
-      cardinalityFilter: this.cardinalityFilter
-    });
+    this.observabilityBus = new ObservabilityBus();
     for (const exporter of this.exporters) {
       this.observabilityBus.registerExporter(exporter);
     }
@@ -18695,85 +19176,32 @@ var BaseObservabilityInstance = class extends MastraBase {
   // ============================================================================
   // Context-factory bridge methods
   // ============================================================================
-  /**
-   * Extract entity context labels from a span's entity hierarchy by
-   * walking the parent chain.
-   *
-   * Returns labels for: entity_type/name, parent_type/name, root_type/name.
-   * Internal spans are skipped when resolving parent and root entities.
-   */
-  extractEntityLabels(span) {
-    const labels = {};
-    if (span.entityType) labels.entity_type = span.entityType;
-    if (span.entityName) labels.entity_name = span.entityName;
-    let parentSpan = span.parent;
-    while (parentSpan && parentSpan.isInternal) {
-      parentSpan = parentSpan.parent;
-    }
-    if (parentSpan?.entityType && parentSpan.entityName) {
-      labels.parent_type = parentSpan.entityType;
-      labels.parent_name = parentSpan.entityName;
-      let rootEntity = parentSpan;
-      let current = parentSpan.parent;
-      while (current) {
-        if (!current.isInternal && current.entityType && current.entityName) {
-          rootEntity = current;
-        }
-        current = current.parent;
-      }
-      if (rootEntity !== parentSpan) {
-        labels.root_type = rootEntity.entityType;
-        labels.root_name = rootEntity.entityName;
-      }
-    }
-    return labels;
-  }
-  /**
-   * Resolve tags for a span. Uses the span's own tags if present,
-   * otherwise walks to the root span to inherit its tags.
-   */
-  resolveSpanTags(span) {
-    if (span.tags) return span.tags;
-    let root = span;
-    while (root.parent) {
-      root = root.parent;
-    }
-    return root.tags;
-  }
   /**
    * Get a LoggerContext correlated to a span.
    * Called by the context-factory in core (deriveLoggerContext) so that
    * `observabilityContext.loggerVNext` is a real logger instead of no-op.
    */
   getLoggerContext(span) {
-    const entityLabels = span ? this.extractEntityLabels(span) : void 0;
-    const hasEntityLabels = entityLabels && Object.keys(entityLabels).length > 0;
-    const metadata = hasEntityLabels || span?.metadata || this.config.serviceName ? {
-      ...hasEntityLabels ? entityLabels : void 0,
-      ...span?.metadata,
-      ...this.config.serviceName ? { serviceName: this.config.serviceName } : void 0
-    } : void 0;
+    const correlationContext = span?.getCorrelationContext?.();
+    const metadata = span?.metadata ? structuredClone(span.metadata) : void 0;
     return new LoggerContextImpl({
-      traceId: span?.traceId,
-      spanId: span?.id,
-      tags: span ? this.resolveSpanTags(span) : void 0,
+      correlationContext,
       metadata,
       observabilityBus: this.observabilityBus
     });
   }
   /**
-   * Get a MetricsContext, optionally tagged from a span's entity info.
+   * Get a MetricsContext correlated to a span.
    * Called by the context-factory in core (deriveMetricsContext) so that
    * `observabilityContext.metrics` is a real metrics context instead of no-op.
    */
   getMetricsContext(span) {
-    const labels = span ? this.extractEntityLabels(span) : {};
-    const attrs = span?.attributes;
-    if (attrs?.model && typeof attrs.model === "string") labels.model = attrs.model;
-    if (attrs?.provider && typeof attrs.provider === "string") labels.provider = attrs.provider;
-    if (this.config.serviceName) labels.service_name = this.config.serviceName;
+    const correlationContext = span?.getCorrelationContext?.();
+    const metadata = span?.metadata ? structuredClone(span.metadata) : void 0;
     return new MetricsContextImpl({
-      labels: Object.keys(labels).length > 0 ? labels : void 0,
+      correlationContext,
+      metadata,
+      cardinalityFilter: this.cardinalityFilter,
       observabilityBus: this.observabilityBus
     });
   }
@@ -18930,8 +19358,7 @@ var BaseObservabilityInstance = class extends MastraBase {
   }
   /**
    * Emit a span started event.
-   * Routes through the ObservabilityBus so exporters receive it via onTracingEvent
-   * and auto-extracted metrics are generated.
+   * Routes through the ObservabilityBus so exporters receive it via onTracingEvent.
    */
   emitSpanStarted(span) {
     const exportedSpan = this.getSpanForExport(span);
@@ -18942,20 +19369,24 @@ var BaseObservabilityInstance = class extends MastraBase {
   }
   /**
    * Emit a span ended event (called automatically when spans end).
-   * Routes through the ObservabilityBus so exporters receive it via onTracingEvent
-   * and auto-extracted metrics are generated.
+   * Emits any auto-extracted metrics while the live span tree is still available,
+   * then routes the exported tracing event through the ObservabilityBus.
    */
   emitSpanEnded(span) {
     const exportedSpan = this.getSpanForExport(span);
     if (exportedSpan) {
+      try {
+        emitAutoExtractedMetrics(span, this.getMetricsContext(span));
+      } catch (err) {
+        this.logger.error("[Observability] Auto-extraction error:", err);
+      }
       const event = { type: TracingEventType.SPAN_ENDED, exportedSpan };
       this.emitTracingEvent(event);
     }
   }
   /**
    * Emit a span updated event.
-   * Routes through the ObservabilityBus so exporters receive it via onTracingEvent
-   * and auto-extracted metrics are generated.
+   * Routes through the ObservabilityBus so exporters receive it via onTracingEvent.
    */
   emitSpanUpdated(span) {
     const exportedSpan = this.getSpanForExport(span);
@@ -18968,8 +19399,7 @@ var BaseObservabilityInstance = class extends MastraBase {
    * Emit a tracing event through the bus.
    *
    * The bus routes the event to each registered exporter's and bridge's
-   * onTracingEvent handler and triggers auto-extracted metrics (e.g.,
-   * mastra_agent_duration_ms, mastra_model_duration_ms).
+   * onTracingEvent handler.
    */
   emitTracingEvent(event) {
     this.observabilityBus.emit(event);
@@ -19442,6 +19872,6 @@ function buildTracingOptions(...updaters) {
   return updaters.reduce((opts, updater) => updater(opts), {});
 }
 
-export { AutoExtractedMetrics, BaseExporter, BaseObservabilityEventBus, BaseObservabilityInstance, BaseSpan, CardinalityFilter, CloudExporter, ConsoleExporter, DEFAULT_DEEP_CLEAN_OPTIONS, DEFAULT_KEYS_TO_STRIP, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, JsonExporter, LoggerContextImpl, MetricsContextImpl, ModelSpanTracker, NoOpSpan, Observability, ObservabilityBus, SamplingStrategyType, SensitiveDataFilter, TestExporter, TraceData, TrackingExporter, buildTracingOptions, chainFormatters, deepClean, getExternalParentId, mergeSerializationOptions, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, routeToHandler, samplingStrategySchema, serializationOptionsSchema, truncateString };
+export { BaseExporter, BaseObservabilityEventBus, BaseObservabilityInstance, BaseSpan, CardinalityFilter, CloudExporter, ConsoleExporter, DEFAULT_DEEP_CLEAN_OPTIONS, DEFAULT_KEYS_TO_STRIP, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, JsonExporter, LoggerContextImpl, MetricsContextImpl, ModelSpanTracker, NoOpSpan, Observability, ObservabilityBus, SamplingStrategyType, SensitiveDataFilter, TestExporter, TraceData, TrackingExporter, buildTracingOptions, chainFormatters, deepClean, getExternalParentId, mergeSerializationOptions, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, routeToHandler, samplingStrategySchema, serializationOptionsSchema, truncateString };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map