@mastra/observability 1.12.0 → 1.13.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @mastra/observability
 
+## 1.13.0-alpha.1
+
+### Minor Changes
+
+- `MastraStorageExporter` now notifies custom exporters and connected integrations when it cannot persist observability events, such as unsupported storage or retries being exceeded. This matches the behavior already available on `DefaultExporter`. ([#16755](https://github.com/mastra-ai/mastra/pull/16755))
+
+  Also fixed an issue in both exporters where span updates waiting on their parent span could be silently lost if a later flush in the same cycle failed.
+
+### Patch Changes
+
+- Updated dependencies [[`5556cc1`](https://github.com/mastra-ai/mastra/commit/5556cc1befec71518d84f826b3bfe3a079a9daf7), [`5499303`](https://github.com/mastra-ai/mastra/commit/54993032c1ebc09642625b78d2014e0cf84a3cae), [`e47bca7`](https://github.com/mastra-ai/mastra/commit/e47bca7b72866d3abd173b9f530ac4318113a8ff), [`0031d0f`](https://github.com/mastra-ai/mastra/commit/0031d0f13831d7843ac5d498734a7d92862e2ce3), [`3498b49`](https://github.com/mastra-ai/mastra/commit/3498b4946be94f4313cd817733589680dcda5278), [`359439b`](https://github.com/mastra-ai/mastra/commit/359439bb8c635e048176306828195f8297f50021)]:
+  - @mastra/core@1.36.0-alpha.3
+
+## 1.13.0-alpha.0
+
+### Minor Changes
+
+- Roll up token usage from internal MODEL_GENERATION spans onto the closest exported ancestor span. When `tracingPolicy.internal` filters a model call out of exported traces, its tokens used to disappear from both the trace UI and metrics. Now: ([#16434](https://github.com/mastra-ai/mastra/pull/16434))
+  - The visible ancestor (e.g. `PROCESSOR_RUN`, `AGENT_RUN`) gets an `internalUsage` attribute summing the tokens consumed by its hidden descendants — so a Mastra-owned processor that runs an internal agent (moderation, PII detector, structured output, etc.) shows its aggregate cost on the visible `PROCESSOR_RUN` span.
+  - Token / cost metrics still emit, but are attributed via labels to the visible ancestor instead of the hidden agent.
+
+  No action required — the rollup applies automatically whenever an internal `MODEL_GENERATION` ends inside a non-internal ancestor.
+
+### Patch Changes
+
+- Updated dependencies [[`8cdb86c`](https://github.com/mastra-ai/mastra/commit/8cdb86ceed1137bc2768e147dce85a0692b9fb26), [`eda90c5`](https://github.com/mastra-ai/mastra/commit/eda90c5bfd7de11805ecc9f4552716c895fbaf78), [`afc004f`](https://github.com/mastra-ai/mastra/commit/afc004f5cc7e30697809e7021820b9f5881e6719), [`408be73`](https://github.com/mastra-ai/mastra/commit/408be73449dfab92b51eab8c6623b6c443debc25)]:
+  - @mastra/core@1.36.0-alpha.1
+
 ## 1.12.0
 
 ### Minor Changes

package/dist/exporters/default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/exporters/default.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,EAId,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAwB,sBAAsB,EAAwB,MAAM,sBAAsB,CAAC;AAS/G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC;;;;;;GAMG;AACH,UAAU,qBAAsB,SAAQ,kBAAkB;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;CAC5C;AA6BD;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,IAAI,SAA2C;gBAgBnC,MAAM,GAAE,qBAA0B;IAiB9C;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDvD;;OAEG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;YACW,kBAAkB;IAQhC,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,QAAQ;IAsBhB;;;;OAIG;YACW,YAAY;IA6B1B;;;OAGG;YACW,gBAAgB;IAoD9B;;;;;;;OAOG;YACW,WAAW;IAmHnB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7D;;;;OAIG;YACW,WAAW;IAOzB;;OAEG;IACG,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhD;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ1D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/exporters/default.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,EAId,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAwB,sBAAsB,EAAwB,MAAM,sBAAsB,CAAC;AAS/G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC;;;;;;GAMG;AACH,UAAU,qBAAsB,SAAQ,kBAAkB;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;CAC5C;AA6BD;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,IAAI,SAA2C;gBAgBnC,MAAM,GAAE,qBAA0B;IAiB9C;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDvD;;OAEG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;YACW,kBAAkB;IAQhC,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,QAAQ;IAsBhB;;;;OAIG;YACW,YAAY;IA6B1B;;;OAGG;YACW,gBAAgB;IA0D9B;;;;;;;OAOG;YACW,WAAW;IAmHnB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7D;;;;OAIG;YACW,WAAW;IAOzB;;OAEG;IACG,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhD;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ1D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/exporters/mastra-storage.d.ts

@@ -37,6 +37,8 @@ export declare class MastraStorageExporter extends BaseExporter {
      * Returns the flush promise when flushing so callers can await it.
      */
     private handleBatchedFlush;
+    private sanitizeDropError;
+    private emitDrop;
     /**
      * Flush a batch of create events for a single signal type.
      * On "not implemented" errors, disables the signal for future flushes.

package/dist/exporters/mastra-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mastra-storage.d.ts","sourceRoot":"","sources":["../../src/exporters/mastra-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAwB,sBAAsB,EAAwB,MAAM,sBAAsB,CAAC;AAS/G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC,4FAA4F;AAC5F,MAAM,WAAW,2BAA4B,SAAQ,kBAAkB;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;CAC5C;AA6BD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;;IACrD,IAAI,SAA6B;gBAerB,MAAM,GAAE,2BAAgC;IAiBpD;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDvD;;OAEG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;YACW,kBAAkB;IAQhC;;;;OAIG;YACW,YAAY;IAsB1B;;;OAGG;YACW,gBAAgB;IA4C9B;;;;;;;OAOG;YACW,WAAW;IA6GnB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7D;;;;OAIG;YACW,WAAW;IAOzB;;OAEG;IACG,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhD;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ1D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}
+{"version":3,"file":"mastra-storage.d.ts","sourceRoot":"","sources":["../../src/exporters/mastra-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,EAId,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAwB,sBAAsB,EAAwB,MAAM,sBAAsB,CAAC;AAS/G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC,4FAA4F;AAC5F,MAAM,WAAW,2BAA4B,SAAQ,kBAAkB;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;CAC5C;AA6BD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;;IACrD,IAAI,SAA6B;gBAgBrB,MAAM,GAAE,2BAAgC;IAiBpD;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDvD;;OAEG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;YACW,kBAAkB;IAQhC,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,QAAQ;IAsBhB;;;;OAIG;YACW,YAAY;IA6B1B;;;OAGG;YACW,gBAAgB;IA0D9B;;;;;;;OAOG;YACW,WAAW;IAmHnB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7D;;;;OAIG;YACW,WAAW;IAOzB;;OAEG;IACG,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhD;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ1D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../src/features.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAAqC,CAAC"}
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../src/features.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAA8D,CAAC"}

package/dist/index.cjs

@@ -16020,7 +16020,10 @@ var DefaultExporter = class extends BaseExporter {
         deferredUpdates.length = 0;
         this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
       } else {
-        deferredUpdates.length = 0;
+        const newlyDeferred = deferredUpdates.length - deferredCountAtEntry;
+        if (newlyDeferred > 0) {
+          deferredUpdates.splice(deferredUpdates.length - newlyDeferred, newlyDeferred);
+        }
         const dropped = this.#eventBuffer.reAddUpdates(events);
         this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
@@ -16719,6 +16722,7 @@ var MastraStorageExporter = class extends BaseExporter {
   #observabilityStorage;
   #resolvedStrategy;
   #flushTimer;
+  #emitDropEvent;
   // Signals whose storage methods threw "not implemented" — skip on future flushes
   #unsupportedSignals = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
@@ -16740,6 +16744,7 @@ var MastraStorageExporter = 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("MastraStorageExporter disabled: Storage not available. Traces will not be persisted.");
@@ -16825,21 +16830,54 @@ var MastraStorageExporter = 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);
       }
     }
   }
@@ -16848,7 +16886,12 @@ var MastraStorageExporter = 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;
@@ -16872,9 +16915,15 @@ var MastraStorageExporter = 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");
-      } else {
         deferredUpdates.length = 0;
-        this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
+      } else {
+        const newlyDeferred = deferredUpdates.length - deferredCountAtEntry;
+        if (newlyDeferred > 0) {
+          deferredUpdates.splice(deferredUpdates.length - newlyDeferred, newlyDeferred);
+        }
+        const dropped = this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -16950,17 +16999,17 @@ var MastraStorageExporter = 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)) })
       ),
@@ -16974,7 +17023,13 @@ var MastraStorageExporter = 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", {
@@ -19029,6 +19084,7 @@ var PricingRegistry = class _PricingRegistry {
   constructor(pricingModels) {
     this.pricingModels = pricingModels;
   }
+  pricingModels;
   static globalRegistry = null;
   static fromText(pricingModelText) {
     return new _PricingRegistry(parsePricingModelText(pricingModelText));
@@ -19432,6 +19488,9 @@ function emitTokenMetrics(span, metrics) {
   }
   emitUsageMetrics(attrs, attrs.usage, metrics);
 }
+function emitTokenMetricsForUsage(usage, provider, model, metrics) {
+  emitUsageMetrics({ provider, model }, usage, metrics);
+}
 function emitAutoExtractedMetrics(span, metrics) {
   emitDurationMetrics(span, metrics);
   emitTokenMetrics(span, metrics);
@@ -19593,6 +19652,46 @@ function extractUsageMetrics(usage, providerMetadata) {
 function sumDefinedValues(obj, keys) {
   return keys.reduce((sum, key) => sum + (obj[key] ?? 0), 0);
 }
+function addOptional(a, b) {
+  if (a === void 0 && b === void 0) return void 0;
+  return (a ?? 0) + (b ?? 0);
+}
+function mergeInputDetails(a, b) {
+  if (!a) return b ? { ...b } : void 0;
+  if (!b) return { ...a };
+  return {
+    text: addOptional(a.text, b.text),
+    cacheRead: addOptional(a.cacheRead, b.cacheRead),
+    cacheWrite: addOptional(a.cacheWrite, b.cacheWrite),
+    audio: addOptional(a.audio, b.audio),
+    image: addOptional(a.image, b.image)
+  };
+}
+function mergeOutputDetails(a, b) {
+  if (!a) return b ? { ...b } : void 0;
+  if (!b) return { ...a };
+  return {
+    text: addOptional(a.text, b.text),
+    reasoning: addOptional(a.reasoning, b.reasoning),
+    audio: addOptional(a.audio, b.audio),
+    image: addOptional(a.image, b.image)
+  };
+}
+function addUsageStats(a, b) {
+  if (!a) {
+    return {
+      ...b,
+      inputDetails: b.inputDetails ? { ...b.inputDetails } : void 0,
+      outputDetails: b.outputDetails ? { ...b.outputDetails } : void 0
+    };
+  }
+  return {
+    inputTokens: addOptional(a.inputTokens, b.inputTokens),
+    outputTokens: addOptional(a.outputTokens, b.outputTokens),
+    inputDetails: mergeInputDetails(a.inputDetails, b.inputDetails),
+    outputDetails: mergeOutputDetails(a.outputDetails, b.outputDetails)
+  };
+}
 
 // src/model-tracing.ts
 function supportsModelInference() {
@@ -21122,7 +21221,7 @@ var BaseObservabilityInstance = class extends base.MastraBase {
    * This ensures all spans emit events regardless of implementation
    */
   wireSpanLifecycle(span) {
-    if (!this.config.includeInternalSpans && span.isInternal) {
+    if (!this.config.includeInternalSpans && span.isInternal && span.type !== observability.SpanType.MODEL_GENERATION) {
       return;
     }
     const originalEnd = span.end.bind(span);
@@ -21132,7 +21231,11 @@ var BaseObservabilityInstance = class extends base.MastraBase {
         this.logger.warn(`End event is not available on event spans`);
         return;
       }
+      const rollupTarget = this.captureModelUsageRollup(span, options);
       originalEnd(options);
+      if (rollupTarget) {
+        this.applyUsageRollup(rollupTarget);
+      }
       this.emitSpanEnded(span);
     };
     span.update = (options) => {
@@ -21306,6 +21409,70 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       this.emitTracingEvent(event);
     }
   }
+  /**
+   * When an internal MODEL_GENERATION span ends, capture the rollup payload
+   * (usage, provider, model, target ancestor) needed to attribute its cost
+   * to the closest exported ancestor span. Returns undefined when no rollup
+   * applies — non-MODEL_GENERATION spans, spans that will be exported, or
+   * spans whose usage isn't available at end time.
+   */
+  captureModelUsageRollup(span, endOptions) {
+    if (span.type !== observability.SpanType.MODEL_GENERATION) return void 0;
+    if (!span.isInternal || this.config.includeInternalSpans) return void 0;
+    const endAttrs = endOptions?.attributes ?? void 0;
+    const liveAttrs = span.attributes;
+    const usage = endAttrs?.usage ?? liveAttrs?.usage;
+    if (!usage) return void 0;
+    const ancestor = this.findExportedAncestor(span);
+    if (!ancestor) return void 0;
+    const provider = endAttrs?.provider ?? liveAttrs?.provider;
+    const model = endAttrs?.responseModel ?? endAttrs?.model ?? liveAttrs?.responseModel ?? liveAttrs?.model;
+    return { ancestor, usage, provider, model };
+  }
+  /**
+   * Accumulate usage onto the ancestor's `internalUsage` attribute (for trace
+   * UI visibility) and emit auto-extracted token metrics now, using the
+   * ancestor's metrics context so cost / token labels point at the visible
+   * span instead of the hidden agent that incurred them.
+   */
+  applyUsageRollup(target) {
+    const { ancestor, usage, provider, model } = target;
+    const attrs = ancestor.attributes;
+    attrs.internalUsage = addUsageStats(attrs.internalUsage, usage);
+    try {
+      emitTokenMetricsForUsage(usage, provider, model, this.getMetricsContext(ancestor));
+    } catch (err) {
+      this.logger.error("[Observability] Usage rollup metric emission error:", err);
+    }
+  }
+  /**
+   * Walk up the parent chain to find the closest ancestor that will actually
+   * reach exporters. Skips both internal-filtered ancestors and ancestors
+   * whose type matches `excludeSpanTypes`, so the rollup target is one whose
+   * mutated `internalUsage` attribute is visible in exported traces.
+   *
+   * Note: this does not preemptively run `spanFilter` — that filter can be
+   * async and have side effects, so the rare case of a `spanFilter`-dropped
+   * ancestor falls through.
+   */
+  findExportedAncestor(span) {
+    let ancestor = span.parent;
+    while (ancestor && this.isFilteredFromExport(ancestor)) {
+      ancestor = ancestor.parent;
+    }
+    return ancestor;
+  }
+  /**
+   * Returns true when a span would be dropped by `getSpanForExport` for a
+   * reason cheap to check up-front (internal-span filtering or
+   * `excludeSpanTypes`). Used by `findExportedAncestor` to skip rollup
+   * targets that would silently lose their `internalUsage` attribute.
+   */
+  isFilteredFromExport(span) {
+    if (span.isInternal && !this.config.includeInternalSpans) return true;
+    if (this.config.excludeSpanTypes?.includes(span.type)) return true;
+    return false;
+  }
   /**
    * Emit a tracing event through the bus.
    *
@@ -22256,7 +22423,7 @@ var Observability = class extends base.MastraBase {
 };
 
 // src/features.ts
-var observabilityFeatures = /* @__PURE__ */ new Set(["model-inference-span"]);
+var observabilityFeatures = /* @__PURE__ */ new Set(["model-inference-span", "internal-usage-rollup"]);
 
 // src/tracing-options.ts
 function buildTracingOptions(...updaters) {