@mastra/observability 1.12.0-alpha.0 → 1.12.0-alpha.2

package/dist/index.cjs

@@ -10,6 +10,7 @@ var fs = require('fs');
 var module$1 = require('module');
 var path = require('path');
 var web = require('stream/web');
+var features = require('@mastra/core/features');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -45,6 +46,23 @@ function routeToHandler(handler, event, logger) {
         if (handler.onScoreEvent) {
           return catchAsyncResult(handler.onScoreEvent(event), handler.name, "score", logger);
         }
+        if (handler.addScoreToTrace) {
+          const score = event.score;
+          if (!score.traceId) break;
+          return catchAsyncResult(
+            handler.addScoreToTrace({
+              traceId: score.traceId,
+              ...score.spanId ? { spanId: score.spanId } : {},
+              score: score.score,
+              ...score.reason ? { reason: score.reason } : {},
+              scorerName: score.scorerName ?? score.scorerId,
+              ...score.metadata ? { metadata: score.metadata } : {}
+            }),
+            handler.name,
+            "score",
+            logger
+          );
+        }
         break;
       case "feedback":
         if (handler.onFeedbackEvent) {
@@ -56,6 +74,15 @@ function routeToHandler(handler, event, logger) {
     logger.error(`[Observability] Handler error [handler=${handler.name}]:`, err);
   }
 }
+function routeDropToHandler(handler, event, logger) {
+  try {
+    if (handler.onDroppedEvent) {
+      return catchAsyncResult(handler.onDroppedEvent(event), handler.name, "drop", logger);
+    }
+  } catch (err) {
+    logger.error(`[Observability] Handler error [handler=${handler.name}]:`, err);
+  }
+}
 function catchAsyncResult(result, handlerName, signal, logger) {
   if (result && typeof result.then === "function") {
     return result.catch((err) => {
@@ -15686,31 +15713,39 @@ var EventBuffer = class {
         break;
     }
   }
-  /** Re-add failed create events to the buffer, dropping those that exceed max retries. */
+  /** Re-add failed create events to the buffer, returning events that exceed max retries. */
   reAddCreates(events) {
     const retryable = [];
+    const dropped = [];
     for (const e of events) {
       if (++e.retryCount <= this.#maxRetries) {
         retryable.push(e);
+      } else {
+        dropped.push(e);
       }
     }
     if (retryable.length > 0) {
       this.setFirstEventTime();
       this.#creates.push(...retryable);
     }
+    return dropped;
   }
-  /** Re-add failed update events to the buffer, dropping those that exceed max retries. */
+  /** Re-add failed update events to the buffer, returning events that exceed max retries. */
   reAddUpdates(events) {
     const retryable = [];
+    const dropped = [];
     for (const e of events) {
       if (++e.retryCount <= this.#maxRetries) {
         retryable.push(e);
+      } else {
+        dropped.push(e);
       }
     }
     if (retryable.length > 0) {
       this.setFirstEventTime();
       this.#updates.push(...retryable);
     }
+    return dropped;
   }
   /** Snapshot of buffered create events. */
   get creates() {
@@ -15789,6 +15824,7 @@ var DefaultExporter = class extends BaseExporter {
   #observabilityStorage;
   #resolvedStrategy;
   #flushTimer;
+  #emitDropEvent;
   // Signals whose storage methods threw "not implemented" — skip on future flushes
   #unsupportedSignals = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
@@ -15810,6 +15846,7 @@ var DefaultExporter = class extends BaseExporter {
   async init(options) {
     try {
       this.#isInitializing = true;
+      this.#emitDropEvent = options.emitDropEvent;
       this.#storage = options.mastra?.getStorage();
       if (!this.#storage) {
         this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
@@ -15895,21 +15932,54 @@ var DefaultExporter = class extends BaseExporter {
       this.scheduleFlush();
     }
   }
+  sanitizeDropError(error48) {
+    if (error48 instanceof error$1.MastraError) {
+      return {
+        id: error48.id,
+        domain: String(error48.domain),
+        message: error48.message
+      };
+    }
+    if (error48 instanceof Error) {
+      return { message: error48.message };
+    }
+    return { message: String(error48) };
+  }
+  emitDrop(signal, reason, count, error48) {
+    if (count === 0) return;
+    const dropEvent = {
+      type: "drop",
+      signal,
+      reason,
+      count,
+      timestamp: /* @__PURE__ */ new Date(),
+      exporterName: this.name,
+      ...this.#observabilityStorage ? { storageName: this.#observabilityStorage.constructor.name } : {},
+      ...error48 === void 0 ? {} : { error: this.sanitizeDropError(error48) }
+    };
+    this.#emitDropEvent?.(dropEvent);
+  }
   /**
    * Flush a batch of create events for a single signal type.
    * On "not implemented" errors, disables the signal for future flushes.
    * On other errors, re-adds events to the buffer for retry.
    */
   async flushCreates(signal, events, storageCall) {
-    if (this.#unsupportedSignals.has(signal) || events.length === 0) return;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has(signal)) {
+      this.emitDrop(signal, "unsupported-storage", events.length);
+      return;
+    }
     try {
       await storageCall(events);
     } catch (error48) {
       if (error48 instanceof error$1.MastraError && error48.domain === error$1.ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add(signal);
+        this.emitDrop(signal, "unsupported-storage", events.length, error48);
       } else {
-        this.#eventBuffer.reAddCreates(events);
+        const dropped = this.#eventBuffer.reAddCreates(events);
+        this.emitDrop(signal, "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -15918,7 +15988,12 @@ var DefaultExporter = class extends BaseExporter {
    * When `isEnd` is true, successfully flushed spans are removed from tracking.
    */
   async flushSpanUpdates(events, deferredUpdates, isEnd) {
-    if (this.#unsupportedSignals.has("tracing") || events.length === 0) return;
+    const deferredCountAtEntry = deferredUpdates.length;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has("tracing")) {
+      this.emitDrop("tracing", "unsupported-storage", events.length);
+      return;
+    }
     const partials = [];
     for (const event of events) {
       const span = event.exportedSpan;
@@ -15942,9 +16017,12 @@ var DefaultExporter = class extends BaseExporter {
       if (error48 instanceof error$1.MastraError && error48.domain === error$1.ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add("tracing");
+        deferredUpdates.length = 0;
+        this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
       } else {
         deferredUpdates.length = 0;
-        this.#eventBuffer.reAddUpdates(events);
+        const dropped = this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -16020,17 +16098,17 @@ var DefaultExporter = class extends BaseExporter {
         (events) => this.#observabilityStorage.batchCreateFeedback({ feedbacks: events.map((f) => storage.buildFeedbackRecord(f)) })
       ),
       this.flushCreates(
-        "logs",
+        "log",
         createLogEvents,
         (events) => this.#observabilityStorage.batchCreateLogs({ logs: events.map((l) => storage.buildLogRecord(l)) })
       ),
       this.flushCreates(
-        "metrics",
+        "metric",
         createMetricEvents,
         (events) => this.#observabilityStorage.batchCreateMetrics({ metrics: events.map((m) => storage.buildMetricRecord(m)) })
       ),
       this.flushCreates(
-        "scores",
+        "score",
         createScoreEvents,
         (events) => this.#observabilityStorage.batchCreateScores({ scores: events.map((s) => storage.buildScoreRecord(s)) })
       ),
@@ -16044,7 +16122,13 @@ var DefaultExporter = class extends BaseExporter {
     await this.flushSpanUpdates(updateSpanEvents, deferredUpdates, false);
     await this.flushSpanUpdates(endSpanEvents, deferredUpdates, true);
     if (deferredUpdates.length > 0) {
-      this.#eventBuffer.reAddUpdates(deferredUpdates);
+      if (this.#unsupportedSignals.has("tracing")) {
+        this.emitDrop("tracing", "unsupported-storage", deferredUpdates.length);
+        deferredUpdates.length = 0;
+      } else {
+        const dropped = this.#eventBuffer.reAddUpdates(deferredUpdates);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length);
+      }
     }
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {
@@ -17673,6 +17757,8 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
   bridge;
   /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
   pendingHandlers = /* @__PURE__ */ new Set();
+  handlerBufferFlushDepth = 0;
+  dropEventsEmittedDuringHandlerFlush = 0;
   /** Resolved deepClean options applied to non-tracing events before fan-out. */
   deepCleanOptions;
   constructor(opts) {
@@ -17759,6 +17845,23 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
     }
     super.emit(cleaned);
   }
+  /**
+   * Emit exporter pipeline drop events to exporters and the bridge.
+   *
+   * Drop events describe exporter health, not user observability data, so they
+   * are intentionally not delivered to generic event-bus subscribers.
+   */
+  emitDropEvent(event) {
+    if (this.handlerBufferFlushDepth > 0) {
+      this.dropEventsEmittedDuringHandlerFlush++;
+    }
+    for (const exporter of this.exporters) {
+      this.trackPromise(routeDropToHandler(exporter, event, this.logger));
+    }
+    if (this.bridge) {
+      this.trackPromise(routeDropToHandler(this.bridge, event, this.logger));
+    }
+  }
   /**
    * Track an async handler promise so flush() can await it.
    * No-ops for sync (void) results.
@@ -17770,19 +17873,8 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
       void promise2.finally(() => this.pendingHandlers.delete(promise2));
     }
   }
-  /**
-   * Two-phase flush to ensure all observability data is fully exported.
-   *
-   * **Phase 1 — Delivery:** Await all in-flight handler promises (exporters,
-   * bridge, and base-class subscribers). After this resolves, all event data
-   * has been delivered to handler methods.
-   *
-   * **Phase 2 — Buffer drain:** Call flush() on each exporter and bridge to
-   * drain their SDK-internal buffers (e.g., OTEL BatchSpanProcessor, Langfuse
-   * client queue). Phases are sequential — Phase 2 must not start until
-   * Phase 1 completes, otherwise exporters would flush empty buffers.
-   */
-  async flush() {
+  /** Await in-flight routed handler promises, draining until empty. */
+  async drainPendingHandlers() {
     let iterations = 0;
     while (this.pendingHandlers.size > 0) {
       await Promise.allSettled([...this.pendingHandlers]);
@@ -17797,14 +17889,54 @@ var ObservabilityBus = class extends BaseObservabilityEventBus {
         break;
       }
     }
-    await super.flush();
-    const bufferFlushPromises = this.exporters.map((e) => e.flush());
-    if (this.bridge) {
-      bufferFlushPromises.push(this.bridge.flush());
+  }
+  /** Drain exporter and bridge SDK-internal buffers. */
+  async flushHandlerBuffers() {
+    const initialDropCount = this.dropEventsEmittedDuringHandlerFlush;
+    this.handlerBufferFlushDepth++;
+    try {
+      const bufferFlushPromises = this.exporters.map((e) => e.flush());
+      if (this.bridge) {
+        bufferFlushPromises.push(this.bridge.flush());
+      }
+      if (bufferFlushPromises.length > 0) {
+        await Promise.allSettled(bufferFlushPromises);
+      }
+      return this.dropEventsEmittedDuringHandlerFlush > initialDropCount;
+    } finally {
+      this.handlerBufferFlushDepth--;
     }
-    if (bufferFlushPromises.length > 0) {
-      await Promise.allSettled(bufferFlushPromises);
+  }
+  /**
+   * Multi-phase flush to ensure all observability data is fully exported.
+   *
+   * **Phase 1 — Delivery:** Await all in-flight handler promises (exporters,
+   * bridge, and base-class subscribers). After this resolves, all event data
+   * has been delivered to handler methods.
+   *
+   * **Phase 2 — Buffer drain:** Call flush() on each exporter and bridge to
+   * drain their SDK-internal buffers (e.g., OTEL BatchSpanProcessor, Langfuse
+   * client queue). Phases are sequential — buffer drains must not start until
+   * delivery completes, otherwise exporters would flush empty buffers.
+   *
+   * Exporter flushes can emit drop events. When that happens, flush loops
+   * through delivery and buffer drain again so alerting integrations that buffer
+   * drop notifications are drained before returning.
+   */
+  async flush() {
+    await this.drainPendingHandlers();
+    await super.flush();
+    for (let iterations = 0; iterations < MAX_FLUSH_ITERATIONS; iterations++) {
+      const emittedDropEvents = await this.flushHandlerBuffers();
+      if (!emittedDropEvents && this.pendingHandlers.size === 0) {
+        return;
+      }
+      await this.drainPendingHandlers();
+      await super.flush();
     }
+    this.logger.error(
+      `[ObservabilityBus] flush() exceeded ${MAX_FLUSH_ITERATIONS} buffer drain iterations. Handlers may be emitting drop events during every flush.`
+    );
   }
   /** Flush all pending events and exporter buffers, then clear subscribers. */
   async shutdown() {
@@ -18163,8 +18295,19 @@ function normalizeProvider(provider) {
   return dotIndex !== -1 ? normalized.substring(0, dotIndex) : normalized;
 }
 function getModelVariants(model) {
-  const dashed = model.replace(/\./g, "-");
-  return [model, dashed, stripDateSuffix(model), stripDateSuffix(dashed)];
+  const variants = /* @__PURE__ */ new Set();
+  const add = (v) => {
+    variants.add(v);
+    variants.add(stripDateSuffix(v));
+  };
+  add(model);
+  add(model.replace(/\./g, "-"));
+  add(model.replace(/[./]/g, "-"));
+  const slashIndex = model.indexOf("/");
+  if (slashIndex !== -1) {
+    add(model.substring(slashIndex + 1));
+  }
+  return [...variants];
 }
 function stripDateSuffix(model) {
   let stripped = model.replace(/-20\d{2}-\d{2}-\d{2}$/, "");
@@ -18607,6 +18750,9 @@ function sumDefinedValues(obj, keys) {
 }
 
 // src/model-tracing.ts
+function supportsModelInference() {
+  return features.coreFeatures.has("model-inference-span");
+}
 function formatPreviewLabel(label, fallback) {
   return typeof label === "string" && label.length > 0 ? label : fallback;
 }
@@ -18765,6 +18911,7 @@ function extractStepInput(payload) {
 var ModelSpanTracker = class {
   #modelSpan;
   #currentStepSpan;
+  #currentInferenceSpan;
   #currentChunkSpan;
   #currentChunkType;
   #accumulator = {};
@@ -18776,9 +18923,18 @@ var ModelSpanTracker = class {
   #deferStepClose = false;
   /** Stored step-finish payload when defer mode is enabled */
   #pendingStepFinishPayload;
+  /** Static request-side context applied to every MODEL_INFERENCE span */
+  #inferenceContext;
   constructor(modelSpan) {
     this.#modelSpan = modelSpan;
   }
+  /**
+   * Set request-side context applied to subsequent MODEL_INFERENCE spans.
+   * No-op when paired with an older @mastra/core that lacks the feature flag.
+   */
+  setInferenceContext(context) {
+    this.#inferenceContext = context;
+  }
   /**
    * Capture the completion start time (time to first token) when the first content chunk arrives.
    */
@@ -18860,6 +19016,11 @@ var ModelSpanTracker = class {
    * Start a new Model execution step.
    * This should be called at the beginning of LLM execution to capture accurate startTime.
    * The step-start chunk payload can be passed later via updateStep() if needed.
+   *
+   * Note: this only opens MODEL_STEP. The MODEL_INFERENCE child span is opened
+   * separately via startInference() so its duration excludes input processor work.
+   * Callers that don't call startInference() explicitly will get one auto-created
+   * when the first model chunk arrives.
    */
   startStep(payload) {
     if (this.#currentStepSpan) {
@@ -18879,6 +19040,71 @@ var ModelSpanTracker = class {
     this.#currentStepInputIsFinal = Array.isArray(payload?.inputMessages);
     this.#chunkSequence = 0;
   }
+  /**
+   * End the current MODEL_INFERENCE span when the provider stream finishes.
+   * Fields are duplicated onto MODEL_STEP (in #endStepSpan) so existing
+   * integrations that read usage/finishReason from the step span continue
+   * to work unchanged.
+   *
+   * Safe to call multiple times - no-ops if the span is already closed.
+   */
+  #endInferenceSpan(payload) {
+    if (!this.#currentInferenceSpan) return;
+    const { usage: rawUsage, ...otherOutput } = payload.output;
+    const usage = extractUsageMetrics(rawUsage, payload.metadata?.providerMetadata);
+    this.#currentInferenceSpan.end({
+      output: otherOutput,
+      attributes: {
+        usage,
+        finishReason: payload.stepResult.reason,
+        warnings: payload.stepResult.warnings,
+        completionStartTime: this.#completionStartTime
+      }
+    });
+    this.#currentInferenceSpan = void 0;
+  }
+  /**
+   * Open the MODEL_INFERENCE span for the current step. Chunks (including tool-call
+   * chunks emitted by the model) parent under this span so its duration reflects
+   * pure model latency.
+   *
+   * Should be called immediately before invoking the model — after any input
+   * processors / `prepareStep` work has completed — so the span's startTime
+   * does not include processor time. The latest `#inferenceContext` (set via
+   * setInferenceContext) is snapshotted onto the span at creation.
+   *
+   * No-ops when the installed @mastra/core lacks the `model-inference-span`
+   * feature flag, or when called without an active step span. Auto-invoked from
+   * chunk handlers as a safety net; explicit callers get the most accurate
+   * start time.
+   */
+  startInference(payload) {
+    if (!supportsModelInference()) {
+      return;
+    }
+    if (!this.#currentStepSpan || this.#currentInferenceSpan) {
+      return;
+    }
+    const input = extractStepInput(payload);
+    const generationAttrs = this.#modelSpan?.attributes;
+    const ctx = this.#inferenceContext;
+    this.#currentInferenceSpan = this.#currentStepSpan.createChildSpan({
+      name: `inference: ${this.#stepIndex}`,
+      type: observability.SpanType.MODEL_INFERENCE,
+      attributes: {
+        stepIndex: this.#stepIndex,
+        model: generationAttrs?.model,
+        provider: generationAttrs?.provider,
+        streaming: generationAttrs?.streaming,
+        ...ctx?.parameters !== void 0 ? { parameters: ctx.parameters } : {},
+        ...ctx?.providerOptions !== void 0 ? { providerOptions: ctx.providerOptions } : {},
+        ...ctx?.availableTools !== void 0 ? { availableTools: ctx.availableTools } : {},
+        ...ctx?.toolChoice !== void 0 ? { toolChoice: ctx.toolChoice } : {},
+        ...ctx?.responseFormat !== void 0 ? { responseFormat: ctx.responseFormat } : {}
+      },
+      input
+    });
+  }
   /**
    * Update the current step span with additional payload data.
    * Called when step-start chunk arrives with request/warnings info.
@@ -18917,6 +19143,7 @@ var ModelSpanTracker = class {
         delete cleanMetadata[key];
       }
     }
+    this.#endInferenceSpan(payload);
     this.#currentStepSpan.end({
       output: otherOutput,
       attributes: {
@@ -18934,14 +19161,35 @@ var ModelSpanTracker = class {
     this.#stepIndex++;
   }
   /**
-   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   * Returns the parent span for chunks. Chunks parent under MODEL_INFERENCE
+   * (the provider call) when available, falling back to MODEL_STEP only if
+   * startStep() was bypassed.
    */
-  #startChunkSpan(chunkType, initialData) {
-    this.#endChunkSpan();
+  #chunkParent() {
+    return this.#currentInferenceSpan ?? this.#currentStepSpan;
+  }
+  /**
+   * Safety-net invoked from chunk handlers: auto-create MODEL_STEP and
+   * MODEL_INFERENCE if a chunk arrives before the loop has explicitly opened
+   * them, so chunks parent under MODEL_INFERENCE rather than falling through
+   * to MODEL_STEP. Idempotent — each public start* method is itself a no-op
+   * when its span is already live.
+   */
+  #ensureStepAndInference() {
     if (!this.#currentStepSpan) {
       this.startStep();
     }
-    this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
+    if (!this.#currentInferenceSpan) {
+      this.startInference();
+    }
+  }
+  /**
+   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   */
+  #startChunkSpan(chunkType, initialData) {
+    this.#endChunkSpan();
+    this.#ensureStepAndInference();
+    this.#currentChunkSpan = this.#chunkParent()?.createChildSpan({
       name: `chunk: '${chunkType}'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -18980,10 +19228,8 @@ var ModelSpanTracker = class {
    * Create an event span (for single chunks like tool-call)
    */
   #createEventSpan(chunkType, output, options) {
-    if (!this.#currentStepSpan) {
-      this.startStep();
-    }
-    const span = this.#currentStepSpan?.createEventSpan({
+    this.#ensureStepAndInference();
+    const span = this.#chunkParent()?.createEventSpan({
       name: `chunk: '${chunkType}'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -19104,10 +19350,8 @@ var ModelSpanTracker = class {
   #handleToolApprovalChunk(chunk) {
     if (chunk.type !== "tool-call-approval") return;
     const payload = chunk.payload;
-    if (!this.#currentStepSpan) {
-      this.startStep();
-    }
-    const span = this.#currentStepSpan?.createEventSpan({
+    this.#ensureStepAndInference();
+    const span = this.#chunkParent()?.createEventSpan({
       name: `chunk: 'tool-call-approval'`,
       type: observability.SpanType.MODEL_CHUNK,
       attributes: {
@@ -19165,10 +19409,15 @@ var ModelSpanTracker = class {
               } else {
                 this.startStep(chunk.payload);
               }
+              if (!this.#currentInferenceSpan) {
+                this.startInference(chunk.payload);
+              }
               break;
             case "step-finish":
               if (this.#deferStepClose) {
                 this.#pendingStepFinishPayload = chunk.payload;
+                this.#endChunkSpan();
+                this.#endInferenceSpan(chunk.payload);
               } else {
                 this.#endStepSpan(chunk.payload);
               }
@@ -19264,6 +19513,7 @@ function isSpanInternal(spanType, flags) {
     // Model-related spans
     case observability.SpanType.MODEL_GENERATION:
     case observability.SpanType.MODEL_STEP:
+    case observability.SpanType.MODEL_INFERENCE:
     case observability.SpanType.MODEL_CHUNK:
       return (flags & observability.InternalSpans.MODEL) !== 0;
     // Default: never internal
@@ -20356,6 +20606,7 @@ function buildScoreEvent(args) {
       traceId,
       spanId,
       scorerId: score.scorerId,
+      scorerName: score.scorerName,
       scorerVersion: score.scorerVersion,
       source: score.source,
       scoreSource: score.scoreSource,
@@ -20363,6 +20614,7 @@ function buildScoreEvent(args) {
       reason: score.reason,
       experimentId: score.experimentId,
       scoreTraceId: score.scoreTraceId,
+      targetEntityType: score.targetEntityType,
       correlationContext,
       metadata: mergeMetadata(inheritedMetadata, score.metadata)
     }
@@ -20961,10 +21213,11 @@ var Observability = class extends base.MastraBase {
       instance.__setMastraEnvironment?.(mastraEnvironment);
       const config2 = instance.getConfig();
       const exporters = instance.getExporters();
+      const emitDropEvent = instance instanceof BaseObservabilityInstance ? (event) => instance.getObservabilityBus().emitDropEvent(event) : void 0;
       exporters.forEach((exporter) => {
         if ("init" in exporter && typeof exporter.init === "function") {
           try {
-            exporter.init({ mastra, config: config2 });
+            exporter.init({ mastra, config: config2, emitDropEvent });
           } catch (error48) {
             this.logger?.warn("Failed to initialize observability exporter", {
               exporterName: exporter.name,
@@ -21152,6 +21405,9 @@ var Observability = class extends base.MastraBase {
   }
 };
 
+// src/features.ts
+var observabilityFeatures = /* @__PURE__ */ new Set(["model-inference-span"]);
+
 // src/tracing-options.ts
 function buildTracingOptions(...updaters) {
   return updaters.reduce((opts, updater) => updater(opts), {});
@@ -21188,6 +21444,7 @@ exports.getExternalParentId = getExternalParentId;
 exports.isSerializedMap = isSerializedMap;
 exports.mergeSerializationOptions = mergeSerializationOptions;
 exports.observabilityConfigValueSchema = observabilityConfigValueSchema;
+exports.observabilityFeatures = observabilityFeatures;
 exports.observabilityInstanceConfigSchema = observabilityInstanceConfigSchema;
 exports.observabilityRegistryConfigSchema = observabilityRegistryConfigSchema;
 exports.reconstructSerializedMap = reconstructSerializedMap;