@mastra/core 0.15.2 → 0.15.3-alpha.0

package/dist/{chunk-7TH2KSEC.js → chunk-WOTBMZCN.js}

@@ -13,6 +13,7 @@ var NoOpAISpan = class _NoOpAISpan {
   traceId;
   startTime;
   endTime;
+  isEvent;
   aiTracing;
   input;
   output;
@@ -30,13 +31,18 @@ var NoOpAISpan = class _NoOpAISpan {
     this.startTime = /* @__PURE__ */ new Date();
     this.aiTracing = aiTracing;
     this.input = options.input;
+    this.output = options.isEvent ? options.output : void 0;
+    this.isEvent = options.isEvent;
   }
   end(_options) {
   }
   error(_options) {
   }
   createChildSpan(options) {
-    return new _NoOpAISpan({ ...options, parent: this }, this.aiTracing);
+    return new _NoOpAISpan({ ...options, parent: this, isEvent: false }, this.aiTracing);
+  }
+  createEventSpan(options) {
+    return new _NoOpAISpan({ ...options, parent: this, isEvent: true }, this.aiTracing);
   }
   update(_options) {
   }
@@ -50,6 +56,7 @@ var AISpanType = /* @__PURE__ */ ((AISpanType2) => {
   AISpanType2["AGENT_RUN"] = "agent_run";
   AISpanType2["GENERIC"] = "generic";
   AISpanType2["LLM_GENERATION"] = "llm_generation";
+  AISpanType2["LLM_CHUNK"] = "llm_chunk";
   AISpanType2["MCP_TOOL_CALL"] = "mcp_tool_call";
   AISpanType2["TOOL_CALL"] = "tool_call";
   AISpanType2["WORKFLOW_RUN"] = "workflow_run";
@@ -114,22 +121,31 @@ var MastraAITracing = class extends MastraBase {
    * Start a new span of a specific AISpanType
    */
   startSpan(options) {
-    const { type, name, input, attributes, metadata, parent, startOptions } = options;
+    const { type, name, input, output, attributes, metadata, parent, startOptions, isEvent } = options;
     const { runtimeContext } = startOptions || {};
     if (!this.shouldSample({ runtimeContext })) {
-      return new NoOpAISpan({ type, name, input, attributes, metadata, parent }, this);
+      return new NoOpAISpan(
+        { type, name, input, output, attributes, metadata, parent, isEvent: isEvent === true },
+        this
+      );
     }
     const spanOptions = {
       type,
       name,
       input,
+      output,
       attributes,
       metadata,
-      parent
+      parent,
+      isEvent: isEvent === true
     };
     const span = this.createSpan(spanOptions);
-    this.wireSpanLifecycle(span);
-    this.emitSpanStarted(span);
+    if (span.isEvent) {
+      this.emitSpanEnded(span);
+    } else {
+      this.wireSpanLifecycle(span);
+      this.emitSpanStarted(span);
+    }
     return span;
   }
   // ============================================================================
@@ -283,7 +299,7 @@ var MastraAITracing = class extends MastraBase {
   /**
    * Initialize AI tracing (called by Mastra during component registration)
    */
-  async init() {
+  init() {
     this.logger.debug(`[AI Tracing] Initialization started [name=${this.name}]`);
     this.logger.info(`[AI Tracing] Initialized successfully [name=${this.name}]`);
   }
@@ -298,6 +314,592 @@ var MastraAITracing = class extends MastraBase {
   }
 };
 
+// src/ai-tracing/exporters/console.ts
+var ConsoleExporter = class {
+  name = "tracing-console-exporter";
+  logger;
+  constructor(logger) {
+    if (logger) {
+      this.logger = logger;
+    } else {
+      this.logger = new ConsoleLogger({ level: LogLevel.INFO });
+    }
+  }
+  async exportEvent(event) {
+    const span = event.span;
+    const formatAttributes = (attributes) => {
+      try {
+        return JSON.stringify(attributes, null, 2);
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : "Unknown formatting error";
+        return `[Unable to serialize attributes: ${errMsg}]`;
+      }
+    };
+    const formatDuration = (startTime, endTime) => {
+      if (!endTime) return "N/A";
+      const duration = endTime.getTime() - startTime.getTime();
+      return `${duration}ms`;
+    };
+    switch (event.type) {
+      case "span_started" /* SPAN_STARTED */:
+        this.logger.info(`\u{1F680} SPAN_STARTED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
+        break;
+      case "span_ended" /* SPAN_ENDED */:
+        const duration = formatDuration(span.startTime, span.endTime);
+        this.logger.info(`\u2705 SPAN_ENDED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Duration: ${duration}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
+        break;
+      case "span_updated" /* SPAN_UPDATED */:
+        this.logger.info(`\u{1F4DD} SPAN_UPDATED`);
+        this.logger.info(`   Type: ${span.type}`);
+        this.logger.info(`   Name: ${span.name}`);
+        this.logger.info(`   ID: ${span.id}`);
+        this.logger.info(`   Trace ID: ${span.traceId}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Updated Attributes: ${formatAttributes(span.attributes)}`);
+        this.logger.info("\u2500".repeat(80));
+        break;
+      default:
+        this.logger.warn(`Tracing event type not implemented: ${event.type}`);
+    }
+  }
+  async shutdown() {
+    this.logger.info("ConsoleExporter shutdown");
+  }
+};
+
+// src/ai-tracing/exporters/default.ts
+function resolveStrategy(userConfig, storage, logger) {
+  if (userConfig.strategy && userConfig.strategy !== "auto") {
+    const hints = storage.aiTracingStrategy;
+    if (hints.supported.includes(userConfig.strategy)) {
+      return userConfig.strategy;
+    }
+    logger.warn("User-specified AI tracing strategy not supported by storage adapter, falling back to auto-selection", {
+      userStrategy: userConfig.strategy,
+      storageAdapter: storage.constructor.name,
+      supportedStrategies: hints.supported,
+      fallbackStrategy: hints.preferred
+    });
+  }
+  return storage.aiTracingStrategy.preferred;
+}
+var DefaultExporter = class {
+  name = "tracing-default-exporter";
+  logger;
+  mastra = null;
+  config;
+  resolvedStrategy;
+  buffer;
+  flushTimer = null;
+  constructor(config = {}, logger) {
+    if (logger) {
+      this.logger = logger;
+    } else {
+      this.logger = new ConsoleLogger({ level: LogLevel.INFO });
+    }
+    this.config = {
+      maxBatchSize: config.maxBatchSize ?? 1e3,
+      maxBufferSize: config.maxBufferSize ?? 1e4,
+      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
+      maxRetries: config.maxRetries ?? 4,
+      retryDelayMs: config.retryDelayMs ?? 500,
+      strategy: config.strategy ?? "auto"
+    };
+    this.buffer = {
+      creates: [],
+      updates: [],
+      insertOnly: [],
+      seenSpans: /* @__PURE__ */ new Set(),
+      spanSequences: /* @__PURE__ */ new Map(),
+      outOfOrderCount: 0,
+      totalSize: 0
+    };
+    this.resolvedStrategy = "batch-with-updates";
+  }
+  strategyInitialized = false;
+  /**
+   * Register the Mastra instance (called after Mastra construction is complete)
+   */
+  __registerMastra(mastra) {
+    this.mastra = mastra;
+  }
+  /**
+   * Initialize the exporter (called after all dependencies are ready)
+   */
+  init() {
+    if (!this.mastra) {
+      throw new Error("DefaultExporter: init() called before __registerMastra()");
+    }
+    const storage = this.mastra.getStorage();
+    if (!storage) {
+      throw new Error("DefaultExporter: Storage not available during initialization");
+    }
+    this.initializeStrategy(storage);
+  }
+  /**
+   * Initialize the resolved strategy once storage is available
+   */
+  initializeStrategy(storage) {
+    if (this.strategyInitialized) return;
+    this.resolvedStrategy = resolveStrategy(this.config, storage, this.logger);
+    this.strategyInitialized = true;
+    this.logger.info("AI tracing exporter initialized", {
+      strategy: this.resolvedStrategy,
+      source: this.config.strategy !== "auto" ? "user" : "auto",
+      storageAdapter: storage.constructor.name,
+      maxBatchSize: this.config.maxBatchSize,
+      maxBatchWaitMs: this.config.maxBatchWaitMs
+    });
+  }
+  /**
+   * Builds a unique span key for tracking
+   */
+  buildSpanKey(traceId, spanId) {
+    return `${traceId}:${spanId}`;
+  }
+  /**
+   * Gets the next sequence number for a span
+   */
+  getNextSequence(spanKey) {
+    const current = this.buffer.spanSequences.get(spanKey) || 0;
+    const next = current + 1;
+    this.buffer.spanSequences.set(spanKey, next);
+    return next;
+  }
+  /**
+   * Handles out-of-order span updates by logging and skipping
+   */
+  handleOutOfOrderUpdate(event) {
+    this.logger.warn("Out-of-order span update detected - skipping event", {
+      spanId: event.span.id,
+      traceId: event.span.traceId,
+      eventType: event.type
+    });
+  }
+  /**
+   * Adds an event to the appropriate buffer based on strategy
+   */
+  addToBuffer(event) {
+    const spanKey = this.buildSpanKey(event.span.traceId, event.span.id);
+    if (this.buffer.totalSize === 0) {
+      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    }
+    switch (event.type) {
+      case "span_started" /* SPAN_STARTED */:
+        if (this.resolvedStrategy === "batch-with-updates") {
+          const createRecord = {
+            traceId: event.span.traceId,
+            spanId: event.span.id,
+            ...this.buildCreateRecord(event.span),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: null
+          };
+          this.buffer.creates.push(createRecord);
+          this.buffer.seenSpans.add(spanKey);
+        }
+        break;
+      case "span_updated" /* SPAN_UPDATED */:
+        if (this.resolvedStrategy === "batch-with-updates") {
+          if (this.buffer.seenSpans.has(spanKey)) {
+            this.buffer.updates.push({
+              traceId: event.span.traceId,
+              spanId: event.span.id,
+              updates: {
+                ...this.buildUpdateRecord(event.span),
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              sequenceNumber: this.getNextSequence(spanKey)
+            });
+          } else {
+            this.handleOutOfOrderUpdate(event);
+            this.buffer.outOfOrderCount++;
+          }
+        }
+        break;
+      case "span_ended" /* SPAN_ENDED */:
+        if (this.resolvedStrategy === "batch-with-updates") {
+          if (this.buffer.seenSpans.has(spanKey)) {
+            this.buffer.updates.push({
+              traceId: event.span.traceId,
+              spanId: event.span.id,
+              updates: {
+                ...this.buildUpdateRecord(event.span),
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              sequenceNumber: this.getNextSequence(spanKey)
+            });
+          } else {
+            this.handleOutOfOrderUpdate(event);
+            this.buffer.outOfOrderCount++;
+          }
+        } else if (this.resolvedStrategy === "insert-only") {
+          const createRecord = {
+            traceId: event.span.traceId,
+            spanId: event.span.id,
+            ...this.buildCreateRecord(event.span),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: null
+          };
+          this.buffer.insertOnly.push(createRecord);
+        }
+        break;
+    }
+    this.buffer.totalSize = this.buffer.creates.length + this.buffer.updates.length + this.buffer.insertOnly.length;
+  }
+  /**
+   * Checks if buffer should be flushed based on size or time triggers
+   */
+  shouldFlush() {
+    if (this.buffer.totalSize >= this.config.maxBufferSize) {
+      return true;
+    }
+    if (this.buffer.totalSize >= this.config.maxBatchSize) {
+      return true;
+    }
+    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
+      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
+      if (elapsed >= this.config.maxBatchWaitMs) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Resets the buffer after successful flush
+   */
+  resetBuffer() {
+    this.buffer.creates = [];
+    this.buffer.updates = [];
+    this.buffer.insertOnly = [];
+    this.buffer.seenSpans.clear();
+    this.buffer.spanSequences.clear();
+    this.buffer.outOfOrderCount = 0;
+    this.buffer.firstEventTime = void 0;
+    this.buffer.totalSize = 0;
+  }
+  /**
+   * Schedules a flush using setTimeout
+   */
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        this.logger.error("Scheduled flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, this.config.maxBatchWaitMs);
+  }
+  /**
+   * Serializes span attributes to storage record format
+   * Handles all AI span types and their specific attributes
+   */
+  serializeAttributes(span) {
+    if (!span.attributes) {
+      return null;
+    }
+    try {
+      return JSON.parse(
+        JSON.stringify(span.attributes, (_key, value) => {
+          if (value instanceof Date) {
+            return value.toISOString();
+          }
+          if (typeof value === "object" && value !== null) {
+            return value;
+          }
+          return value;
+        })
+      );
+    } catch (error) {
+      this.logger.warn("Failed to serialize span attributes, storing as null", {
+        spanId: span.id,
+        spanType: span.type,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  buildCreateRecord(span) {
+    return {
+      parentSpanId: span.parent?.id ?? null,
+      name: span.name,
+      scope: null,
+      spanType: span.type,
+      attributes: this.serializeAttributes(span),
+      metadata: span.metadata ?? null,
+      links: null,
+      startedAt: span.startTime,
+      endedAt: span.endTime ?? null,
+      input: span.input,
+      output: span.output,
+      error: span.errorInfo,
+      isEvent: span.isEvent
+    };
+  }
+  buildUpdateRecord(span) {
+    return {
+      name: span.name,
+      scope: null,
+      attributes: this.serializeAttributes(span),
+      metadata: span.metadata ?? null,
+      links: null,
+      endedAt: span.endTime ?? null,
+      input: span.input,
+      output: span.output,
+      error: span.errorInfo
+    };
+  }
+  /**
+   * Handles realtime strategy - processes each event immediately
+   */
+  async handleRealtimeEvent(event, storage) {
+    const span = event.span;
+    if (span.isEvent) {
+      if (event.type === "span_ended" /* SPAN_ENDED */) {
+        await storage.createAISpan({
+          traceId: span.traceId,
+          spanId: span.id,
+          ...this.buildCreateRecord(span),
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: null
+        });
+      } else {
+        this.logger.warn(`Tracing event type not implemented for event spans: ${event.type}`);
+      }
+    } else {
+      switch (event.type) {
+        case "span_started" /* SPAN_STARTED */:
+          await storage.createAISpan({
+            traceId: span.traceId,
+            spanId: span.id,
+            ...this.buildCreateRecord(span),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: null
+          });
+          break;
+        case "span_updated" /* SPAN_UPDATED */:
+        case "span_ended" /* SPAN_ENDED */:
+          await storage.updateAISpan({
+            traceId: span.traceId,
+            spanId: span.id,
+            updates: {
+              ...this.buildUpdateRecord(span),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          });
+          break;
+        default:
+          this.logger.warn(`Tracing event type not implemented for span spans: ${event.type}`);
+      }
+    }
+  }
+  /**
+   * Handles batch-with-updates strategy - buffers events and processes in batches
+   */
+  handleBatchWithUpdatesEvent(event) {
+    this.addToBuffer(event);
+    if (this.shouldFlush()) {
+      this.flush().catch((error) => {
+        this.logger.error("Batch flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
+    }
+  }
+  /**
+   * Handles insert-only strategy - only processes SPAN_ENDED events in batches
+   */
+  handleInsertOnlyEvent(event) {
+    if (event.type === "span_ended" /* SPAN_ENDED */) {
+      this.addToBuffer(event);
+      if (this.shouldFlush()) {
+        this.flush().catch((error) => {
+          this.logger.error("Batch flush failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      } else if (this.buffer.totalSize === 1) {
+        this.scheduleFlush();
+      }
+    }
+  }
+  /**
+   * Calculates retry delay using exponential backoff
+   */
+  calculateRetryDelay(attempt) {
+    return this.config.retryDelayMs * Math.pow(2, attempt);
+  }
+  /**
+   * Flushes the current buffer to storage with retry logic
+   */
+  async flush() {
+    if (!this.mastra) {
+      this.logger.warn("Cannot flush traces. Mastra instance not registered yet.");
+      return;
+    }
+    const storage = this.mastra.getStorage();
+    if (!storage) {
+      this.logger.warn("Cannot flush traces. Mastra storage is not initialized");
+      return;
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize === 0) {
+      return;
+    }
+    const startTime = Date.now();
+    const flushReason = this.buffer.totalSize >= this.config.maxBufferSize ? "overflow" : this.buffer.totalSize >= this.config.maxBatchSize ? "size" : "time";
+    const bufferCopy = {
+      creates: [...this.buffer.creates],
+      updates: [...this.buffer.updates],
+      insertOnly: [...this.buffer.insertOnly],
+      seenSpans: new Set(this.buffer.seenSpans),
+      spanSequences: new Map(this.buffer.spanSequences),
+      outOfOrderCount: this.buffer.outOfOrderCount,
+      firstEventTime: this.buffer.firstEventTime,
+      totalSize: this.buffer.totalSize
+    };
+    this.resetBuffer();
+    await this.flushWithRetries(storage, bufferCopy, 0);
+    const elapsed = Date.now() - startTime;
+    this.logger.debug("Batch flushed", {
+      strategy: this.resolvedStrategy,
+      batchSize: bufferCopy.totalSize,
+      flushReason,
+      durationMs: elapsed,
+      outOfOrderCount: bufferCopy.outOfOrderCount > 0 ? bufferCopy.outOfOrderCount : void 0
+    });
+  }
+  /**
+   * Attempts to flush with exponential backoff retry logic
+   */
+  async flushWithRetries(storage, buffer, attempt) {
+    try {
+      if (this.resolvedStrategy === "batch-with-updates") {
+        if (buffer.creates.length > 0) {
+          await storage.batchCreateAISpans({ records: buffer.creates });
+        }
+        if (buffer.updates.length > 0) {
+          const sortedUpdates = buffer.updates.sort((a, b) => {
+            const spanCompare = this.buildSpanKey(a.traceId, a.spanId).localeCompare(
+              this.buildSpanKey(b.traceId, b.spanId)
+            );
+            if (spanCompare !== 0) return spanCompare;
+            return a.sequenceNumber - b.sequenceNumber;
+          });
+          await storage.batchUpdateAISpans({ records: sortedUpdates });
+        }
+      } else if (this.resolvedStrategy === "insert-only") {
+        if (buffer.insertOnly.length > 0) {
+          await storage.batchCreateAISpans({ records: buffer.insertOnly });
+        }
+      }
+    } catch (error) {
+      if (attempt < this.config.maxRetries) {
+        const retryDelay = this.calculateRetryDelay(attempt);
+        this.logger.warn("Batch flush failed, retrying", {
+          attempt: attempt + 1,
+          maxRetries: this.config.maxRetries,
+          nextRetryInMs: retryDelay,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        return this.flushWithRetries(storage, buffer, attempt + 1);
+      } else {
+        this.logger.error("Batch flush failed after all retries, dropping batch", {
+          finalAttempt: attempt + 1,
+          maxRetries: this.config.maxRetries,
+          droppedBatchSize: buffer.totalSize,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  async exportEvent(event) {
+    if (!this.mastra) {
+      this.logger.warn("Cannot export AI tracing event. Mastra instance not registered yet.");
+      return;
+    }
+    const storage = this.mastra.getStorage();
+    if (!storage) {
+      this.logger.warn("Cannot store traces. Mastra storage is not initialized");
+      return;
+    }
+    if (!this.strategyInitialized) {
+      this.initializeStrategy(storage);
+    }
+    switch (this.resolvedStrategy) {
+      case "realtime":
+        await this.handleRealtimeEvent(event, storage);
+        break;
+      case "batch-with-updates":
+        this.handleBatchWithUpdatesEvent(event);
+        break;
+      case "insert-only":
+        this.handleInsertOnlyEvent(event);
+        break;
+    }
+  }
+  async shutdown() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize > 0) {
+      this.logger.info("Flushing remaining events on shutdown", {
+        remainingEvents: this.buffer.totalSize
+      });
+      try {
+        await this.flush();
+      } catch (error) {
+        this.logger.error("Failed to flush remaining events during shutdown", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.logger.info("DefaultExporter shutdown complete");
+  }
+};
+
 // src/ai-tracing/default.ts
 function generateSpanId() {
   const bytes = new Uint8Array(8);
@@ -331,11 +933,13 @@ var DefaultAISpan = class {
   traceId;
   startTime;
   endTime;
+  isEvent;
   aiTracing;
   input;
   output;
   errorInfo;
   metadata;
+  logger;
   constructor(options, aiTracing) {
     this.id = generateSpanId();
     this.name = options.name;
@@ -347,13 +951,26 @@ var DefaultAISpan = class {
     this.startTime = /* @__PURE__ */ new Date();
     this.aiTracing = aiTracing;
     this.input = options.input;
+    this.isEvent = options.isEvent;
+    this.logger = new ConsoleLogger({
+      name: "default-ai-span",
+      level: LogLevel.INFO
+      // Set to INFO so that info() calls actually log
+    });
     if (!options.parent) {
       this.traceId = generateTraceId();
     } else {
       this.traceId = options.parent.trace.traceId;
     }
+    if (this.isEvent) {
+      this.output = options.output;
+    }
   }
   end(options) {
+    if (this.isEvent) {
+      this.logger.warn(`End event is not available on event spans`);
+      return;
+    }
     this.endTime = /* @__PURE__ */ new Date();
     if (options?.output !== void 0) {
       this.output = options.output;
@@ -366,6 +983,10 @@ var DefaultAISpan = class {
     }
   }
   error(options) {
+    if (this.isEvent) {
+      this.logger.warn(`Error event is not available on event spans`);
+      return;
+    }
     const { error, endSpan = true, attributes, metadata } = options;
     this.errorInfo = error instanceof MastraError ? {
       id: error.id,
@@ -391,10 +1012,22 @@ var DefaultAISpan = class {
   createChildSpan(options) {
     return this.aiTracing.startSpan({
       ...options,
-      parent: this
+      parent: this,
+      isEvent: false
+    });
+  }
+  createEventSpan(options) {
+    return this.aiTracing.startSpan({
+      ...options,
+      parent: this,
+      isEvent: true
     });
   }
   update(options) {
+    if (this.isEvent) {
+      this.logger.warn(`Update() is not available on event spans`);
+      return;
+    }
     if (options?.input !== void 0) {
       this.input = options.input;
     }
@@ -487,100 +1120,11 @@ var SensitiveDataFilter = class {
   async shutdown() {
   }
 };
-var DefaultConsoleExporter = class {
-  name = "default-console";
-  logger;
-  constructor(logger) {
-    if (logger) {
-      this.logger = logger;
-    } else {
-      this.logger = new ConsoleLogger({
-        name: "default-console-exporter",
-        level: LogLevel.INFO
-        // Set to INFO so that info() calls actually log
-      });
-    }
-  }
-  async exportEvent(event) {
-    const span = event.span;
-    const formatAttributes = (attributes) => {
-      try {
-        return JSON.stringify(attributes, null, 2);
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown formatting error";
-        return `[Unable to serialize attributes: ${errMsg}]`;
-      }
-    };
-    const formatDuration = (startTime, endTime) => {
-      if (!endTime) return "N/A";
-      const duration = endTime.getTime() - startTime.getTime();
-      return `${duration}ms`;
-    };
-    switch (event.type) {
-      case "span_started" /* SPAN_STARTED */:
-        this.logger.info(`\u{1F680} SPAN_STARTED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      case "span_ended" /* SPAN_ENDED */:
-        const duration = formatDuration(span.startTime, span.endTime);
-        this.logger.info(`\u2705 SPAN_ENDED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Duration: ${duration}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        if (span.output !== void 0) {
-          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
-        }
-        if (span.errorInfo) {
-          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
-        }
-        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      case "span_updated" /* SPAN_UPDATED */:
-        this.logger.info(`\u{1F4DD} SPAN_UPDATED`);
-        this.logger.info(`   Type: ${span.type}`);
-        this.logger.info(`   Name: ${span.name}`);
-        this.logger.info(`   ID: ${span.id}`);
-        this.logger.info(`   Trace ID: ${span.traceId}`);
-        if (span.input !== void 0) {
-          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
-        }
-        if (span.output !== void 0) {
-          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
-        }
-        if (span.errorInfo) {
-          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
-        }
-        this.logger.info(`   Updated Attributes: ${formatAttributes(span.attributes)}`);
-        this.logger.info("\u2500".repeat(80));
-        break;
-      default:
-        throw new Error(`Tracing event type not implemented: ${event.type}`);
-    }
-  }
-  async shutdown() {
-    this.logger.info("DefaultConsoleExporter shutdown");
-  }
-};
 var aiTracingDefaultConfig = {
   serviceName: "mastra-ai-service",
   instanceName: "default",
   sampling: { type: "always" /* ALWAYS */ },
-  exporters: [new DefaultConsoleExporter()],
-  // Uses its own fallback logger
+  exporters: [new ConsoleExporter()],
   processors: [new SensitiveDataFilter()]
 };
 var DefaultAITracing = class extends MastraAITracing {
@@ -841,6 +1385,6 @@ function wrapWorkflow(workflow, tracingContext) {
   }
 }
 
-export { AISpanType, AITracingEventType, DefaultAITracing, DefaultConsoleExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, aiTracingDefaultConfig, clearAITracingRegistry, getAITracing, getAllAITracing, getDefaultAITracing, getSelectedAITracing, hasAITracing, isSerializable, omitKeys, registerAITracing, sanitizeMetadata, setAITracingSelector, setupAITracing, shutdownAITracingRegistry, unregisterAITracing, wrapAgent, wrapMastra, wrapWorkflow };
-//# sourceMappingURL=chunk-7TH2KSEC.js.map
-//# sourceMappingURL=chunk-7TH2KSEC.js.map
+export { AISpanType, AITracingEventType, ConsoleExporter, DefaultAITracing, DefaultExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, aiTracingDefaultConfig, clearAITracingRegistry, getAITracing, getAllAITracing, getDefaultAITracing, getSelectedAITracing, hasAITracing, isSerializable, omitKeys, registerAITracing, sanitizeMetadata, setAITracingSelector, setupAITracing, shutdownAITracingRegistry, unregisterAITracing, wrapAgent, wrapMastra, wrapWorkflow };
+//# sourceMappingURL=chunk-WOTBMZCN.js.map
+//# sourceMappingURL=chunk-WOTBMZCN.js.map