@mastra/observability 1.0.0-beta.6 → 1.0.0-beta.8

package/CHANGELOG.md

@@ -1,5 +1,132 @@
 # @mastra/observability
 
+## 1.0.0-beta.8
+
+### Patch Changes
+
+- fix(observability): start MODEL_STEP span at beginning of LLM execution ([#11409](https://github.com/mastra-ai/mastra/pull/11409))
+
+  The MODEL_STEP span was being created when the step-start chunk arrived (after the model API call completed), causing the span's startTime to be close to its endTime instead of accurately reflecting when the step began.
+
+  This fix ensures MODEL_STEP spans capture the full duration of each LLM execution step, including the API call latency, by starting the span at the beginning of the step execution rather than when the response starts streaming.
+
+  Fixes #11271
+
+- Updated dependencies [[`3d93a15`](https://github.com/mastra-ai/mastra/commit/3d93a15796b158c617461c8b98bede476ebb43e2), [`efe406a`](https://github.com/mastra-ai/mastra/commit/efe406a1353c24993280ebc2ed61dd9f65b84b26), [`119e5c6`](https://github.com/mastra-ai/mastra/commit/119e5c65008f3e5cfca954eefc2eb85e3bf40da4), [`74e504a`](https://github.com/mastra-ai/mastra/commit/74e504a3b584eafd2f198001c6a113bbec589fd3), [`e33fdbd`](https://github.com/mastra-ai/mastra/commit/e33fdbd07b33920d81e823122331b0c0bee0bb59), [`929f69c`](https://github.com/mastra-ai/mastra/commit/929f69c3436fa20dd0f0e2f7ebe8270bd82a1529), [`8a73529`](https://github.com/mastra-ai/mastra/commit/8a73529ca01187f604b1f3019d0a725ac63ae55f)]:
+  - @mastra/core@1.0.0-beta.16
+
+## 1.0.0-beta.7
+
+### Minor Changes
+
+- Unified observability schema with entity-based span identification ([#11132](https://github.com/mastra-ai/mastra/pull/11132))
+
+  ## What changed
+
+  Spans now use a unified identification model with `entityId`, `entityType`, and `entityName` instead of separate `agentId`, `toolId`, `workflowId` fields.
+
+  **Before:**
+
+  ```typescript
+  // Old span structure
+  span.agentId; // 'my-agent'
+  span.toolId; // undefined
+  span.workflowId; // undefined
+  ```
+
+  **After:**
+
+  ```typescript
+  // New span structure
+  span.entityType; // EntityType.AGENT
+  span.entityId; // 'my-agent'
+  span.entityName; // 'My Agent'
+  ```
+
+  ## New `listTraces()` API
+
+  Query traces with filtering, pagination, and sorting:
+
+  ```typescript
+  const { spans, pagination } = await storage.listTraces({
+    filters: {
+      entityType: EntityType.AGENT,
+      entityId: 'my-agent',
+      userId: 'user-123',
+      environment: 'production',
+      status: TraceStatus.SUCCESS,
+      startedAt: { start: new Date('2024-01-01'), end: new Date('2024-01-31') },
+    },
+    pagination: { page: 0, perPage: 50 },
+    orderBy: { field: 'startedAt', direction: 'DESC' },
+  });
+  ```
+
+  **Available filters:** date ranges (`startedAt`, `endedAt`), entity (`entityType`, `entityId`, `entityName`), identity (`userId`, `organizationId`), correlation IDs (`runId`, `sessionId`, `threadId`), deployment (`environment`, `source`, `serviceName`), `tags`, `metadata`, and `status`.
+
+  ## New retrieval methods
+  - `getSpan({ traceId, spanId })` - Get a single span
+  - `getRootSpan({ traceId })` - Get the root span of a trace
+  - `getTrace({ traceId })` - Get all spans for a trace
+
+  ## Backward compatibility
+
+  The legacy `getTraces()` method continues to work. When you pass `name: "agent run: my-agent"`, it automatically transforms to `entityId: "my-agent", entityType: AGENT`.
+
+  ## Migration
+
+  **Automatic:** SQL-based stores (PostgreSQL, LibSQL, MSSQL) automatically add new columns to existing `spans` tables on initialization. Existing data is preserved with new columns set to `NULL`.
+
+  **No action required:** Your existing code continues to work. Adopt the new fields and `listTraces()` API at your convenience.
+
+### Patch Changes
+
+- Refactor storage architecture to use domain-specific stores via `getStore()` pattern ([#11361](https://github.com/mastra-ai/mastra/pull/11361))
+
+  ### Summary
+
+  This release introduces a new storage architecture that replaces passthrough methods on `MastraStorage` with domain-specific storage interfaces accessed via `getStore()`. This change reduces code duplication across storage adapters and provides a cleaner, more modular API.
+
+  ### Migration Guide
+
+  All direct method calls on storage instances should be updated to use `getStore()`:
+
+  ```typescript
+  // Before
+  const thread = await storage.getThreadById({ threadId });
+  await storage.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  await storage.createSpan(span);
+
+  // After
+  const memory = await storage.getStore('memory');
+  const thread = await memory?.getThreadById({ threadId });
+
+  const workflows = await storage.getStore('workflows');
+  await workflows?.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+
+  const observability = await storage.getStore('observability');
+  await observability?.createSpan(span);
+  ```
+
+  ### Available Domains
+  - **`memory`**: Thread and message operations (`getThreadById`, `saveThread`, `saveMessages`, etc.)
+  - **`workflows`**: Workflow state persistence (`persistWorkflowSnapshot`, `loadWorkflowSnapshot`, `getWorkflowRunById`, etc.)
+  - **`scores`**: Evaluation scores (`saveScore`, `listScoresByScorerId`, etc.)
+  - **`observability`**: Tracing and spans (`createSpan`, `updateSpan`, `getTrace`, etc.)
+  - **`agents`**: Stored agent configurations (`createAgent`, `getAgentById`, `listAgents`, etc.)
+
+  ### Breaking Changes
+  - Passthrough methods have been removed from `MastraStorage` base class
+  - All storage adapters now require accessing domains via `getStore()`
+  - The `stores` property on storage instances is now the canonical way to access domain storage
+
+  ### Internal Changes
+  - Each storage adapter now initializes domain-specific stores in its constructor
+  - Domain stores share database connections and handle their own table initialization
+
+- Updated dependencies [[`33a4d2e`](https://github.com/mastra-ai/mastra/commit/33a4d2e4ed8af51f69256232f00c34d6b6b51d48), [`4aaa844`](https://github.com/mastra-ai/mastra/commit/4aaa844a4f19d054490f43638a990cc57bda8d2f), [`4a1a6cb`](https://github.com/mastra-ai/mastra/commit/4a1a6cb3facad54b2bb6780b00ce91d6de1edc08), [`31d13d5`](https://github.com/mastra-ai/mastra/commit/31d13d5fdc2e2380e2e3ee3ec9fb29d2a00f265d), [`4c62166`](https://github.com/mastra-ai/mastra/commit/4c621669f4a29b1f443eca3ba70b814afa286266), [`7bcbf10`](https://github.com/mastra-ai/mastra/commit/7bcbf10133516e03df964b941f9a34e9e4ab4177), [`4353600`](https://github.com/mastra-ai/mastra/commit/43536005a65988a8eede236f69122e7f5a284ba2), [`6986fb0`](https://github.com/mastra-ai/mastra/commit/6986fb064f5db6ecc24aa655e1d26529087b43b3), [`053e979`](https://github.com/mastra-ai/mastra/commit/053e9793b28e970086b0507f7f3b76ea32c1e838), [`e26dc9c`](https://github.com/mastra-ai/mastra/commit/e26dc9c3ccfec54ae3dc3e2b2589f741f9ae60a6), [`55edf73`](https://github.com/mastra-ai/mastra/commit/55edf7302149d6c964fbb7908b43babfc2b52145), [`27c0009`](https://github.com/mastra-ai/mastra/commit/27c0009777a6073d7631b0eb7b481d94e165b5ca), [`dee388d`](https://github.com/mastra-ai/mastra/commit/dee388dde02f2e63c53385ae69252a47ab6825cc), [`3f3fc30`](https://github.com/mastra-ai/mastra/commit/3f3fc3096f24c4a26cffeecfe73085928f72aa63), [`d90ea65`](https://github.com/mastra-ai/mastra/commit/d90ea6536f7aa51c6545a4e9215b55858e98e16d), [`d171e55`](https://github.com/mastra-ai/mastra/commit/d171e559ead9f52ec728d424844c8f7b164c4510), [`10c2735`](https://github.com/mastra-ai/mastra/commit/10c27355edfdad1ee2b826b897df74125eb81fb8), [`1924cf0`](https://github.com/mastra-ai/mastra/commit/1924cf06816e5e4d4d5333065ec0f4bb02a97799), [`b339816`](https://github.com/mastra-ai/mastra/commit/b339816df0984d0243d944ac2655d6ba5f809cde)]:
+  - @mastra/core@1.0.0-beta.15
+
 ## 1.0.0-beta.6
 
 ### Patch Changes

package/dist/exporters/default.d.ts

@@ -1,4 +1,5 @@
-import type { TracingEvent, InitExporterOptions, TracingStorageStrategy } from '@mastra/core/observability';
+import type { TracingEvent, InitExporterOptions } from '@mastra/core/observability';
+import type { TracingStorageStrategy } from '@mastra/core/storage';
 import type { BaseExporterConfig } from './base.js';
 import { BaseExporter } from './base.js';
 interface DefaultExporterConfig extends BaseExporterConfig {
@@ -18,9 +19,9 @@ export declare class DefaultExporter extends BaseExporter {
     /**
      * Initialize the exporter (called after all dependencies are ready)
      */
-    init(options: InitExporterOptions): void;
+    init(options: InitExporterOptions): Promise<void>;
     /**
-     * Initialize the resolved strategy once storage is available
+     * Initialize the resolved strategy once observability store is available
      */
     private initializeStrategy;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/exporters/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EAEZ,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,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;AAwDD,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,IAAI,SAA2C;IAK/C,OAAO,CAAC,MAAM,CAAc;IAI5B,OAAO,CAAC,eAAe,CAA0B;gBAErC,MAAM,GAAE,qBAA0B;IAoC9C;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAUxC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAgFnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,mBAAmB;IAyCjC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;YACW,KAAK;IAsDnB;;OAEG;YACW,gBAAgB;IA2DxB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBvD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuBhC"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/exporters/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAmB,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAErG,OAAO,KAAK,EAKV,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,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;AAmED,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,IAAI,SAA2C;IAM/C,OAAO,CAAC,MAAM,CAAc;IAI5B,OAAO,CAAC,eAAe,CAA0B;gBAErC,MAAM,GAAE,qBAA0B;IAoC9C;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAgFnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,mBAAmB;IAyCjC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;YACW,KAAK;IAsDnB;;OAEG;YACW,gBAAgB;IA+DxB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBvD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuBhC"}

package/dist/index.cjs

@@ -4489,24 +4489,31 @@ var ConsoleExporter = class extends BaseExporter {
     this.logger.info("ConsoleExporter shutdown");
   }
 };
-function resolveTracingStorageStrategy(config, storage, logger) {
+function resolveTracingStorageStrategy(config, observability, storageName, logger) {
   if (config.strategy && config.strategy !== "auto") {
-    const hints = storage.tracingStrategy;
+    const hints = observability.tracingStrategy;
     if (hints.supported.includes(config.strategy)) {
       return config.strategy;
     }
     logger.warn("User-specified tracing strategy not supported by storage adapter, falling back to auto-selection", {
       userStrategy: config.strategy,
-      storageAdapter: storage.constructor.name,
+      storageAdapter: storageName,
       supportedStrategies: hints.supported,
       fallbackStrategy: hints.preferred
     });
   }
-  return storage.tracingStrategy.preferred;
+  return observability.tracingStrategy.preferred;
+}
+function getStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function getObjectOrNull(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 var DefaultExporter = class extends BaseExporter {
   name = "mastra-default-observability-exporter";
   #storage;
+  #observability;
   #config;
   #resolvedStrategy;
   buffer;
@@ -4543,25 +4550,30 @@ var DefaultExporter = class extends BaseExporter {
   /**
    * Initialize the exporter (called after all dependencies are ready)
    */
-  init(options) {
+  async init(options) {
     this.#storage = options.mastra?.getStorage();
     if (!this.#storage) {
       this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
       return;
     }
-    this.initializeStrategy(this.#storage);
+    this.#observability = await this.#storage.getStore("observability");
+    if (!this.#observability) {
+      this.logger.warn("DefaultExporter disabled: Observability storage not available. Traces will not be persisted.");
+      return;
+    }
+    this.initializeStrategy(this.#observability, this.#storage.constructor.name);
   }
   /**
-   * Initialize the resolved strategy once storage is available
+   * Initialize the resolved strategy once observability store is available
    */
-  initializeStrategy(storage) {
+  initializeStrategy(observability, storageName) {
     if (this.#strategyInitialized) return;
-    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, storage, this.logger);
+    this.#resolvedStrategy = resolveTracingStorageStrategy(this.#config, observability, storageName, this.logger);
     this.#strategyInitialized = true;
     this.logger.debug("tracing storage exporter initialized", {
       strategy: this.#resolvedStrategy,
       source: this.#config.strategy !== "auto" ? "user" : "auto",
-      storageAdapter: storage.constructor.name,
+      storageAdapter: storageName,
       maxBatchSize: this.#config.maxBatchSize,
       maxBatchWaitMs: this.#config.maxBatchWaitMs
     });
@@ -4734,22 +4746,44 @@ var DefaultExporter = class extends BaseExporter {
     }
   }
   buildCreateRecord(span) {
+    const metadata = span.metadata ?? {};
     return {
       traceId: span.traceId,
       spanId: span.id,
       parentSpanId: span.parentSpanId ?? null,
       name: span.name,
-      scope: null,
+      // Entity identification - from span
+      entityType: span.entityType ?? null,
+      entityId: span.entityId ?? null,
+      entityName: span.entityName ?? null,
+      // Identity & Tenancy - extracted from metadata if present
+      userId: getStringOrNull(metadata.userId),
+      organizationId: getStringOrNull(metadata.organizationId),
+      resourceId: getStringOrNull(metadata.resourceId),
+      // Correlation IDs - extracted from metadata if present
+      runId: getStringOrNull(metadata.runId),
+      sessionId: getStringOrNull(metadata.sessionId),
+      threadId: getStringOrNull(metadata.threadId),
+      requestId: getStringOrNull(metadata.requestId),
+      // Deployment context - extracted from metadata if present
+      environment: getStringOrNull(metadata.environment),
+      source: getStringOrNull(metadata.source),
+      serviceName: getStringOrNull(metadata.serviceName),
+      scope: getObjectOrNull(metadata.scope),
+      // Span data
       spanType: span.type,
       attributes: this.serializeAttributes(span),
       metadata: span.metadata ?? null,
+      // Keep all metadata including extracted fields
+      tags: span.tags ?? null,
       links: null,
+      input: span.input ?? null,
+      output: span.output ?? null,
+      error: span.errorInfo ?? null,
+      isEvent: span.isEvent,
+      // Timestamps
       startedAt: span.startTime,
-      endedAt: span.endTime ?? null,
-      input: span.input,
-      output: span.output,
-      error: span.errorInfo,
-      isEvent: span.isEvent
+      endedAt: span.endTime ?? null
     };
   }
   buildUpdateRecord(span) {
@@ -4762,36 +4796,36 @@ var DefaultExporter = class extends BaseExporter {
       endedAt: span.endTime ?? null,
       input: span.input,
       output: span.output,
-      error: span.errorInfo
+      error: span.errorInfo ?? null
     };
   }
   /**
    * Handles realtime strategy - processes each event immediately
    */
-  async handleRealtimeEvent(event, storage) {
+  async handleRealtimeEvent(event, observability$1) {
     const span = event.exportedSpan;
     const spanKey = this.buildSpanKey(span.traceId, span.id);
     if (span.isEvent) {
       if (event.type === observability.TracingEventType.SPAN_ENDED) {
-        await storage.createSpan(this.buildCreateRecord(event.exportedSpan));
+        await observability$1.createSpan({ span: this.buildCreateRecord(event.exportedSpan) });
       } else {
         this.logger.warn(`Tracing event type not implemented for event spans: ${event.type}`);
       }
     } else {
       switch (event.type) {
         case observability.TracingEventType.SPAN_STARTED:
-          await storage.createSpan(this.buildCreateRecord(event.exportedSpan));
+          await observability$1.createSpan({ span: this.buildCreateRecord(event.exportedSpan) });
           this.allCreatedSpans.add(spanKey);
           break;
         case observability.TracingEventType.SPAN_UPDATED:
-          await storage.updateSpan({
+          await observability$1.updateSpan({
             traceId: span.traceId,
             spanId: span.id,
             updates: this.buildUpdateRecord(span)
           });
           break;
         case observability.TracingEventType.SPAN_ENDED:
-          await storage.updateSpan({
+          await observability$1.updateSpan({
             traceId: span.traceId,
             spanId: span.id,
             updates: this.buildUpdateRecord(span)
@@ -4845,8 +4879,8 @@ var DefaultExporter = class extends BaseExporter {
    * Flushes the current buffer to storage with retry logic
    */
   async flush() {
-    if (!this.#storage) {
-      this.logger.debug("Cannot flush traces. Mastra storage is not initialized");
+    if (!this.#observability) {
+      this.logger.debug("Cannot flush traces. Observability storage is not initialized");
       return;
     }
     if (this.#flushTimer) {
@@ -4870,7 +4904,7 @@ var DefaultExporter = class extends BaseExporter {
       totalSize: this.buffer.totalSize
     };
     this.resetBuffer();
-    await this.flushWithRetries(this.#storage, bufferCopy, 0);
+    await this.flushWithRetries(this.#observability, bufferCopy, 0);
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {
       strategy: this.#resolvedStrategy,
@@ -4883,11 +4917,11 @@ var DefaultExporter = class extends BaseExporter {
   /**
    * Attempts to flush with exponential backoff retry logic
    */
-  async flushWithRetries(storage, buffer, attempt) {
+  async flushWithRetries(observability, buffer, attempt) {
     try {
       if (this.#resolvedStrategy === "batch-with-updates") {
         if (buffer.creates.length > 0) {
-          await storage.batchCreateSpans({ records: buffer.creates });
+          await observability.batchCreateSpans({ records: buffer.creates });
         }
         if (buffer.updates.length > 0) {
           const sortedUpdates = buffer.updates.sort((a, b) => {
@@ -4897,11 +4931,11 @@ var DefaultExporter = class extends BaseExporter {
             if (spanCompare !== 0) return spanCompare;
             return a.sequenceNumber - b.sequenceNumber;
           });
-          await storage.batchUpdateSpans({ records: sortedUpdates });
+          await observability.batchUpdateSpans({ records: sortedUpdates });
         }
       } else if (this.#resolvedStrategy === "insert-only") {
         if (buffer.insertOnly.length > 0) {
-          await storage.batchCreateSpans({ records: buffer.insertOnly });
+          await observability.batchCreateSpans({ records: buffer.insertOnly });
         }
       }
       for (const spanKey of buffer.completedSpans) {
@@ -4917,7 +4951,7 @@ var DefaultExporter = class extends BaseExporter {
           error: error instanceof Error ? error.message : String(error)
         });
         await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        return this.flushWithRetries(storage, buffer, attempt + 1);
+        return this.flushWithRetries(observability, buffer, attempt + 1);
       } else {
         this.logger.error("Batch flush failed after all retries, dropping batch", {
           finalAttempt: attempt + 1,
@@ -4932,16 +4966,16 @@ var DefaultExporter = class extends BaseExporter {
     }
   }
   async _exportTracingEvent(event) {
-    if (!this.#storage) {
-      this.logger.debug("Cannot store traces. Mastra storage is not initialized");
+    if (!this.#observability) {
+      this.logger.debug("Cannot store traces. Observability storage is not initialized");
       return;
     }
     if (!this.#strategyInitialized) {
-      this.initializeStrategy(this.#storage);
+      this.initializeStrategy(this.#observability, this.#storage?.constructor.name ?? "Unknown");
     }
     switch (this.#resolvedStrategy) {
       case "realtime":
-        await this.handleRealtimeEvent(event, this.#storage);
+        await this.handleRealtimeEvent(event, this.#observability);
         break;
       case "batch-with-updates":
         this.handleBatchWithUpdatesEvent(event);
@@ -5102,9 +5136,14 @@ var ModelSpanTracker = class {
     this.#modelSpan?.update(options);
   }
   /**
-   * Start a new Model execution step
+   * 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.
    */
-  #startStepSpan(payload) {
+  startStep(payload) {
+    if (this.#currentStepSpan) {
+      return;
+    }
     this.#currentStepSpan = this.#modelSpan?.createChildSpan({
       name: `step: ${this.#stepIndex}`,
       type: observability.SpanType.MODEL_STEP,
@@ -5117,6 +5156,22 @@ var ModelSpanTracker = class {
     });
     this.#chunkSequence = 0;
   }
+  /**
+   * Update the current step span with additional payload data.
+   * Called when step-start chunk arrives with request/warnings info.
+   */
+  updateStep(payload) {
+    if (!this.#currentStepSpan || !payload) {
+      return;
+    }
+    this.#currentStepSpan.update({
+      input: payload.request,
+      attributes: {
+        ...payload.messageId ? { messageId: payload.messageId } : {},
+        ...payload.warnings?.length ? { warnings: payload.warnings } : {}
+      }
+    });
+  }
   /**
    * End the current Model execution step with token usage, finish reason, output, and metadata
    */
@@ -5151,7 +5206,7 @@ var ModelSpanTracker = class {
    */
   #startChunkSpan(chunkType, initialData) {
     if (!this.#currentStepSpan) {
-      this.#startStepSpan();
+      this.startStep();
     }
     this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
       name: `chunk: '${chunkType}'`,
@@ -5191,7 +5246,7 @@ var ModelSpanTracker = class {
    */
   #createEventSpan(chunkType, output) {
     if (!this.#currentStepSpan) {
-      this.#startStepSpan();
+      this.startStep();
     }
     const span = this.#currentStepSpan?.createEventSpan({
       name: `chunk: '${chunkType}'`,
@@ -5310,7 +5365,7 @@ var ModelSpanTracker = class {
     let acc = this.#toolOutputAccumulators.get(toolCallId);
     if (!acc) {
       if (!this.#currentStepSpan) {
-        this.#startStepSpan();
+        this.startStep();
       }
       acc = {
         toolName: toolName || "unknown",
@@ -5410,7 +5465,11 @@ var ModelSpanTracker = class {
               this.#handleObjectChunk(chunk);
               break;
             case "step-start":
-              this.#startStepSpan(chunk.payload);
+              if (this.#currentStepSpan) {
+                this.updateStep(chunk.payload);
+              } else {
+                this.startStep(chunk.payload);
+              }
               break;
             case "step-finish":
               this.#endStepSpan(chunk.payload);
@@ -5617,6 +5676,12 @@ var BaseSpan = class {
   metadata;
   tags;
   traceState;
+  /** Entity type that created the span (e.g., agent, workflow) */
+  entityType;
+  /** Entity ID that created the span */
+  entityId;
+  /** Entity name that created the span */
+  entityName;
   /** Parent span ID (for root spans that are children of external spans) */
   parentSpanId;
   constructor(options, observabilityInstance) {
@@ -5631,6 +5696,9 @@ var BaseSpan = class {
     this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
     this.traceState = options.traceState;
     this.tags = !options.parent && options.tags?.length ? options.tags : void 0;
+    this.entityType = options.entityType;
+    this.entityId = options.entityId;
+    this.entityName = options.entityName;
     if (this.isEvent) {
       this.output = deepClean(options.output);
     } else {
@@ -5684,6 +5752,9 @@ var BaseSpan = class {
       traceId: this.traceId,
       name: this.name,
       type: this.type,
+      entityType: this.entityType,
+      entityId: this.entityId,
+      entityName: this.entityName,
       attributes: this.attributes,
       metadata: this.metadata,
       startTime: this.startTime,