@mastra/observability 1.7.3 → 1.8.0-alpha.0

package/dist/index.cjs

@@ -15034,18 +15034,144 @@ function chainFormatters(formatters) {
     return currentSpan;
   };
 }
+var SIGNAL_PUBLISH_SUFFIXES = {
+  traces: "/spans/publish",
+  logs: "/logs/publish",
+  metrics: "/metrics/publish",
+  scores: "/scores/publish",
+  feedback: "/feedback/publish"
+};
+var SIGNAL_PUBLISH_PATHS = {
+  traces: "/ai/spans/publish",
+  logs: "/ai/logs/publish",
+  metrics: "/ai/metrics/publish",
+  scores: "/ai/scores/publish",
+  feedback: "/ai/feedback/publish"
+};
+var SIGNAL_PAYLOAD_KEYS = {
+  traces: "spans",
+  logs: "logs",
+  metrics: "metrics",
+  scores: "scores",
+  feedback: "feedback"
+};
+var DEFAULT_CLOUD_ENDPOINT = "https://api.mastra.ai";
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function createInvalidEndpointError(endpoint, text, cause) {
+  return new error$1.MastraError(
+    {
+      id: `CLOUD_EXPORTER_INVALID_ENDPOINT`,
+      text,
+      domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
+      category: error$1.ErrorCategory.USER,
+      details: {
+        endpoint
+      }
+    },
+    cause
+  );
+}
+function resolveBaseEndpoint(baseEndpoint) {
+  const normalizedEndpoint = trimTrailingSlashes(baseEndpoint);
+  const invalidText = 'CloudExporter endpoint must be a base origin like "https://collector.example.com" with no path, search, or hash.';
+  try {
+    const parsedEndpoint = new URL(normalizedEndpoint);
+    if (parsedEndpoint.pathname !== "/" || parsedEndpoint.search || parsedEndpoint.hash) {
+      throw createInvalidEndpointError(baseEndpoint, invalidText);
+    }
+    return trimTrailingSlashes(parsedEndpoint.origin);
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError(baseEndpoint, invalidText, error48);
+  }
+}
+function buildSignalEndpoint(baseEndpoint, signal) {
+  return `${baseEndpoint}${SIGNAL_PUBLISH_PATHS[signal]}`;
+}
+function resolveExplicitSignalEndpoint(signal, endpoint) {
+  const normalizedEndpoint = trimTrailingSlashes(endpoint);
+  const invalidText = `CloudExporter ${signal}Endpoint must be a base origin like "https://collector.example.com" or a full ${signal} publish URL ending in "${SIGNAL_PUBLISH_SUFFIXES[signal]}".`;
+  try {
+    const parsedEndpoint = new URL(normalizedEndpoint);
+    if (parsedEndpoint.search || parsedEndpoint.hash) {
+      throw createInvalidEndpointError(endpoint, invalidText);
+    }
+    const normalizedOrigin = trimTrailingSlashes(parsedEndpoint.origin);
+    const normalizedPathname = trimTrailingSlashes(parsedEndpoint.pathname);
+    if (!normalizedPathname || normalizedPathname === "/") {
+      return buildSignalEndpoint(normalizedOrigin, signal);
+    }
+    if (normalizedPathname.endsWith(SIGNAL_PUBLISH_SUFFIXES[signal])) {
+      return `${normalizedOrigin}${normalizedPathname}`;
+    }
+    throw createInvalidEndpointError(endpoint, invalidText);
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError(endpoint, invalidText, error48);
+  }
+}
+function deriveSignalEndpointFromTracesEndpoint(signal, tracesEndpoint) {
+  if (signal === "traces") {
+    return tracesEndpoint;
+  }
+  const normalizedTracesEndpoint = trimTrailingSlashes(tracesEndpoint);
+  const invalidText = 'CloudExporter tracesEndpoint must be a base origin like "https://collector.example.com" or a full traces publish URL ending in "/spans/publish".';
+  try {
+    const parsedEndpoint = new URL(normalizedTracesEndpoint);
+    const normalizedOrigin = trimTrailingSlashes(parsedEndpoint.origin);
+    const normalizedPathname = trimTrailingSlashes(parsedEndpoint.pathname);
+    if (!normalizedPathname.endsWith(SIGNAL_PUBLISH_SUFFIXES.traces)) {
+      throw createInvalidEndpointError(tracesEndpoint, invalidText);
+    }
+    const basePath = normalizedPathname.slice(0, -SIGNAL_PUBLISH_SUFFIXES.traces.length);
+    return `${normalizedOrigin}${basePath}${SIGNAL_PUBLISH_SUFFIXES[signal]}`;
+  } catch (error48) {
+    if (error48 instanceof error$1.MastraError) {
+      throw error48;
+    }
+    throw createInvalidEndpointError(tracesEndpoint, invalidText, error48);
+  }
+}
 var CloudExporter = class extends BaseExporter {
   name = "mastra-cloud-observability-exporter";
   cloudConfig;
   buffer;
   flushTimer = null;
+  inFlightFlushes = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
     super(config2);
     const accessToken = config2.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
     if (!accessToken) {
       this.setDisabled("MASTRA_CLOUD_ACCESS_TOKEN environment variable not set.");
     }
-    const endpoint = config2.endpoint ?? process.env.MASTRA_CLOUD_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
+    const tracesEndpointOverride = config2.tracesEndpoint ?? process.env.MASTRA_CLOUD_TRACES_ENDPOINT;
+    let baseEndpoint;
+    let tracesEndpoint;
+    if (tracesEndpointOverride) {
+      tracesEndpoint = resolveExplicitSignalEndpoint("traces", tracesEndpointOverride);
+    } else {
+      baseEndpoint = resolveBaseEndpoint(config2.endpoint ?? DEFAULT_CLOUD_ENDPOINT);
+      tracesEndpoint = buildSignalEndpoint(baseEndpoint, "traces");
+    }
+    const resolveConfiguredSignalEndpoint = (signal, explicitEndpoint) => {
+      if (explicitEndpoint) {
+        return resolveExplicitSignalEndpoint(signal, explicitEndpoint);
+      }
+      if (tracesEndpointOverride) {
+        return deriveSignalEndpointFromTracesEndpoint(signal, tracesEndpoint);
+      }
+      return buildSignalEndpoint(baseEndpoint, signal);
+    };
     this.cloudConfig = {
       logger: this.logger,
       logLevel: config2.logLevel ?? logger.LogLevel.INFO,
@@ -15053,10 +15179,18 @@ var CloudExporter = class extends BaseExporter {
       maxBatchWaitMs: config2.maxBatchWaitMs ?? 5e3,
       maxRetries: config2.maxRetries ?? 3,
       accessToken: accessToken || "",
-      endpoint
+      tracesEndpoint,
+      logsEndpoint: resolveConfiguredSignalEndpoint("logs", config2.logsEndpoint),
+      metricsEndpoint: resolveConfiguredSignalEndpoint("metrics", config2.metricsEndpoint),
+      scoresEndpoint: resolveConfiguredSignalEndpoint("scores", config2.scoresEndpoint),
+      feedbackEndpoint: resolveConfiguredSignalEndpoint("feedback", config2.feedbackEndpoint)
     };
     this.buffer = {
       spans: [],
+      logs: [],
+      metrics: [],
+      scores: [],
+      feedback: [],
       totalSize: 0
     };
   }
@@ -15065,45 +15199,111 @@ var CloudExporter = class extends BaseExporter {
       return;
     }
     this.addToBuffer(event);
-    if (this.shouldFlush()) {
-      this.flush().catch((error48) => {
-        this.logger.error("Batch flush failed", {
-          error: error48 instanceof Error ? error48.message : String(error48)
-        });
-      });
-    } else if (this.buffer.totalSize === 1) {
-      this.scheduleFlush();
+    await this.handleBufferedEvent();
+  }
+  async onLogEvent(event) {
+    if (this.isDisabled) {
+      return;
     }
+    this.addLogToBuffer(event);
+    await this.handleBufferedEvent();
   }
-  addToBuffer(event) {
-    if (this.buffer.totalSize === 0) {
-      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+  async onMetricEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addMetricToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onScoreEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    this.addScoreToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  async onFeedbackEvent(event) {
+    if (this.isDisabled) {
+      return;
     }
+    this.addFeedbackToBuffer(event);
+    await this.handleBufferedEvent();
+  }
+  addToBuffer(event) {
+    this.markBufferStart();
     const spanRecord = this.formatSpan(event.exportedSpan);
     this.buffer.spans.push(spanRecord);
     this.buffer.totalSize++;
   }
+  addLogToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.logs.push(this.formatLog(event.log));
+    this.buffer.totalSize++;
+  }
+  addMetricToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.metrics.push(this.formatMetric(event.metric));
+    this.buffer.totalSize++;
+  }
+  addScoreToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.scores.push(this.formatScore(event.score));
+    this.buffer.totalSize++;
+  }
+  addFeedbackToBuffer(event) {
+    this.markBufferStart();
+    this.buffer.feedback.push(this.formatFeedback(event.feedback));
+    this.buffer.totalSize++;
+  }
+  markBufferStart() {
+    if (this.buffer.totalSize === 0) {
+      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    }
+  }
   formatSpan(span) {
     const spanRecord = {
-      traceId: span.traceId,
+      ...span,
       spanId: span.id,
-      parentSpanId: span.parentSpanId ?? null,
-      name: span.name,
       spanType: span.type,
-      attributes: span.attributes ?? null,
-      metadata: span.metadata ?? null,
-      requestContext: span.requestContext ?? null,
       startedAt: span.startTime,
       endedAt: span.endTime ?? null,
-      input: span.input ?? null,
-      output: span.output ?? null,
-      error: span.errorInfo,
-      isEvent: span.isEvent,
+      error: span.errorInfo ?? null,
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: null
     };
     return spanRecord;
   }
+  formatLog(log) {
+    return {
+      ...log
+    };
+  }
+  formatMetric(metric) {
+    return {
+      ...metric
+    };
+  }
+  formatScore(score) {
+    return {
+      ...score
+    };
+  }
+  formatFeedback(feedback) {
+    return {
+      ...feedback
+    };
+  }
+  async handleBufferedEvent() {
+    if (this.shouldFlush()) {
+      void this.flush().catch((error48) => {
+        this.logger.error("Batch flush failed", {
+          error: error48 instanceof Error ? error48.message : String(error48)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
+    }
+  }
   shouldFlush() {
     if (this.buffer.totalSize >= this.cloudConfig.maxBatchSize) {
       return true;
@@ -15121,7 +15321,7 @@ var CloudExporter = class extends BaseExporter {
       clearTimeout(this.flushTimer);
     }
     this.flushTimer = setTimeout(() => {
-      this.flush().catch((error48) => {
+      void this.flush().catch((error48) => {
         const mastraError = new error$1.MastraError(
           {
             id: `CLOUD_EXPORTER_FAILED_TO_SCHEDULE_FLUSH`,
@@ -15145,49 +15345,91 @@ var CloudExporter = class extends BaseExporter {
     }
     const startTime = Date.now();
     const spansCopy = [...this.buffer.spans];
+    const logsCopy = [...this.buffer.logs];
+    const metricsCopy = [...this.buffer.metrics];
+    const scoresCopy = [...this.buffer.scores];
+    const feedbackCopy = [...this.buffer.feedback];
+    const batchSize = this.buffer.totalSize;
     const flushReason = this.buffer.totalSize >= this.cloudConfig.maxBatchSize ? "size" : "time";
     this.resetBuffer();
-    try {
-      await this.batchUpload(spansCopy);
-      const elapsed = Date.now() - startTime;
+    const results = await Promise.all([
+      this.flushSignalBatch("traces", spansCopy),
+      this.flushSignalBatch("logs", logsCopy),
+      this.flushSignalBatch("metrics", metricsCopy),
+      this.flushSignalBatch("scores", scoresCopy),
+      this.flushSignalBatch("feedback", feedbackCopy)
+    ]);
+    const failedSignals = results.filter((result) => !result.succeeded).map((result) => result.signal);
+    const elapsed = Date.now() - startTime;
+    if (failedSignals.length === 0) {
       this.logger.debug("Batch flushed successfully", {
-        batchSize: spansCopy.length,
+        batchSize,
         flushReason,
         durationMs: elapsed
       });
+      return;
+    }
+    this.logger.warn("Batch flush completed with dropped signal batches", {
+      batchSize,
+      flushReason,
+      durationMs: elapsed,
+      failedSignals
+    });
+  }
+  /**
+   * Uploads a signal batch to the configured cloud API using fetchWithRetry.
+   */
+  async batchUpload(signal, records) {
+    const headers = {
+      Authorization: `Bearer ${this.cloudConfig.accessToken}`,
+      "Content-Type": "application/json"
+    };
+    const endpointMap = {
+      traces: this.cloudConfig.tracesEndpoint,
+      logs: this.cloudConfig.logsEndpoint,
+      metrics: this.cloudConfig.metricsEndpoint,
+      scores: this.cloudConfig.scoresEndpoint,
+      feedback: this.cloudConfig.feedbackEndpoint
+    };
+    const options = {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ [SIGNAL_PAYLOAD_KEYS[signal]]: records })
+    };
+    await utils.fetchWithRetry(endpointMap[signal], options, this.cloudConfig.maxRetries);
+  }
+  async flushSignalBatch(signal, records) {
+    if (records.length === 0) {
+      return { signal, succeeded: true };
+    }
+    try {
+      await this.batchUpload(signal, records);
+      return { signal, succeeded: true };
     } catch (error48) {
+      const errorId = `CLOUD_EXPORTER_FAILED_TO_BATCH_UPLOAD_${signal.toUpperCase()}`;
       const mastraError = new error$1.MastraError(
         {
-          id: `CLOUD_EXPORTER_FAILED_TO_BATCH_UPLOAD`,
+          id: errorId,
           domain: error$1.ErrorDomain.MASTRA_OBSERVABILITY,
           category: error$1.ErrorCategory.USER,
           details: {
-            droppedBatchSize: spansCopy.length
+            signal,
+            droppedBatchSize: records.length
           }
         },
         error48
       );
       this.logger.trackException(mastraError);
       this.logger.error("Batch upload failed after all retries, dropping batch", mastraError);
+      return { signal, succeeded: false };
     }
   }
-  /**
-   * Uploads spans to cloud API using fetchWithRetry for all retry logic
-   */
-  async batchUpload(spans) {
-    const headers = {
-      Authorization: `Bearer ${this.cloudConfig.accessToken}`,
-      "Content-Type": "application/json"
-    };
-    const options = {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ spans })
-    };
-    await utils.fetchWithRetry(this.cloudConfig.endpoint, options, this.cloudConfig.maxRetries);
-  }
   resetBuffer() {
     this.buffer.spans = [];
+    this.buffer.logs = [];
+    this.buffer.metrics = [];
+    this.buffer.scores = [];
+    this.buffer.feedback = [];
     this.buffer.firstEventTime = void 0;
     this.buffer.totalSize = 0;
   }
@@ -15200,11 +15442,21 @@ var CloudExporter = class extends BaseExporter {
     if (this.isDisabled) {
       return;
     }
-    if (this.buffer.totalSize > 0) {
-      this.logger.debug("Flushing buffered events", {
-        bufferedEvents: this.buffer.totalSize
-      });
-      await this.flushBuffer();
+    while (this.buffer.totalSize > 0 || this.inFlightFlushes.size > 0) {
+      if (this.buffer.totalSize > 0) {
+        this.logger.debug("Flushing buffered events", {
+          bufferedEvents: this.buffer.totalSize
+        });
+        const flushPromise = this.flushBuffer();
+        this.inFlightFlushes.add(flushPromise);
+        try {
+          await flushPromise;
+        } finally {
+          this.inFlightFlushes.delete(flushPromise);
+        }
+        continue;
+      }
+      await Promise.allSettled([...this.inFlightFlushes]);
     }
   }
   async shutdown() {
@@ -17044,96 +17296,464 @@ var BaseObservabilityEventBus = class _BaseObservabilityEventBus extends base.Ma
   }
 };
 
-// src/bus/observability-bus.ts
-var MAX_FLUSH_ITERATIONS = 3;
-var ObservabilityBus = class extends BaseObservabilityEventBus {
-  exporters = [];
-  bridge;
-  /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
-  pendingHandlers = /* @__PURE__ */ new Set();
-  constructor() {
-    super({ name: "ObservabilityBus" });
+// src/spans/serialization.ts
+var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
+  "logger",
+  "experimental_providerMetadata",
+  "providerMetadata",
+  "steps",
+  "tracingContext",
+  "execute",
+  // Tool execute functions
+  "validate"
+  // Schema validate functions
+]);
+var DEFAULT_DEEP_CLEAN_OPTIONS = Object.freeze({
+  keysToStrip: DEFAULT_KEYS_TO_STRIP,
+  maxDepth: 8,
+  maxStringLength: 128 * 1024,
+  // 128KB - sufficient for large LLM prompts/responses
+  maxArrayLength: 50,
+  maxObjectKeys: 50
+});
+function mergeSerializationOptions(userOptions) {
+  if (!userOptions) {
+    return DEFAULT_DEEP_CLEAN_OPTIONS;
   }
-  /**
-   * Register an exporter to receive routed events.
-   * Duplicate registrations (same instance) are silently ignored.
-   *
-   * @param exporter - The exporter to register.
-   */
-  registerExporter(exporter) {
-    if (this.exporters.includes(exporter)) {
-      return;
-    }
-    this.exporters.push(exporter);
+  return {
+    keysToStrip: DEFAULT_KEYS_TO_STRIP,
+    maxDepth: userOptions.maxDepth ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxDepth,
+    maxStringLength: userOptions.maxStringLength ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxStringLength,
+    maxArrayLength: userOptions.maxArrayLength ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxArrayLength,
+    maxObjectKeys: userOptions.maxObjectKeys ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxObjectKeys
+  };
+}
+function truncateString(s, maxChars) {
+  if (s.length <= maxChars) {
+    return s;
   }
-  /**
-   * Unregister an exporter.
-   *
-   * @param exporter - The exporter instance to remove.
-   * @returns `true` if the exporter was found and removed, `false` otherwise.
-   */
-  unregisterExporter(exporter) {
-    const index = this.exporters.indexOf(exporter);
-    if (index !== -1) {
-      this.exporters.splice(index, 1);
-      return true;
-    }
-    return false;
+  return s.slice(0, maxChars) + "\u2026[truncated]";
+}
+function formatSerializationError(error48) {
+  return `[${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+}
+function getMapKeyType(key) {
+  if (key === null) {
+    return "null";
   }
-  /**
-   * Get registered exporters (read-only snapshot).
-   */
-  getExporters() {
-    return [...this.exporters];
+  if (key instanceof Date) {
+    return "date";
   }
-  /**
-   * Register a bridge to receive all routed events alongside exporters.
-   * Only one bridge can be registered at a time; replacing an existing bridge
-   * logs a warning.
-   *
-   * @param bridge - The bridge to register.
-   */
-  registerBridge(bridge) {
-    if (this.bridge) {
-      this.logger.warn(`[ObservabilityBus] Replacing existing bridge with new bridge`);
-    }
-    this.bridge = bridge;
+  if (Array.isArray(key)) {
+    return "array";
   }
-  /**
-   * Unregister the bridge.
-   *
-   * @returns `true` if a bridge was registered and removed, `false` otherwise.
-   */
-  unregisterBridge() {
-    if (this.bridge) {
-      this.bridge = void 0;
-      return true;
-    }
-    return false;
+  if (key instanceof Map) {
+    return "map";
   }
-  /**
-   * Get the registered bridge, if any.
-   */
-  getBridge() {
-    return this.bridge;
+  if (key instanceof Set) {
+    return "set";
   }
-  /**
-   * Emit an event: route to exporter/bridge handlers, then forward to base
-   * class for subscriber delivery.
-   *
-   * emit() is synchronous — async handler promises are tracked internally
-   * and can be drained via flush().
-   */
-  emit(event) {
-    for (const exporter of this.exporters) {
-      this.trackPromise(routeToHandler(exporter, event, this.logger));
-    }
-    if (this.bridge) {
-      this.trackPromise(routeToHandler(this.bridge, event, this.logger));
-    }
-    super.emit(event);
+  if (key instanceof Error) {
+    return "error";
   }
-  /**
+  return typeof key;
+}
+function restoreSerializedMapKey(keyType, key) {
+  switch (keyType) {
+    case "undefined":
+      return void 0;
+    case "null":
+      return null;
+    case "bigint":
+      return typeof key === "string" && key.endsWith("n") ? BigInt(key.slice(0, -1)) : key;
+    case "date":
+      return typeof key === "string" ? new Date(key) : key;
+    default:
+      return key;
+  }
+}
+function isSerializedMap(value) {
+  return typeof value === "object" && value !== null && value.__type === "Map" && Array.isArray(value.__map_entries);
+}
+function reconstructSerializedMap(value) {
+  return new Map(
+    value.__map_entries.map(([keyType, key, mapValue]) => [restoreSerializedMapKey(keyType, key), mapValue])
+  );
+}
+function isJsonSchema(val) {
+  if (typeof val !== "object" || val === null) return false;
+  if (val.$schema && typeof val.$schema === "string" && val.$schema.includes("json-schema")) {
+    return true;
+  }
+  if (val.type === "object" && val.properties && typeof val.properties === "object") {
+    return true;
+  }
+  return false;
+}
+function compressJsonSchema(schema, depth = 0) {
+  if (depth > 3) {
+    return schema.type || "object";
+  }
+  const compositionKeys = ["oneOf", "anyOf", "allOf"].filter((key) => Array.isArray(schema[key]));
+  if (compositionKeys.length > 0) {
+    const compressed2 = {};
+    for (const key of compositionKeys) {
+      compressed2[key] = schema[key].map((entry) => compressJsonSchema(entry, depth + 1));
+    }
+    if (typeof schema.type === "string") {
+      compressed2.type = schema.type;
+    }
+    return compressed2;
+  }
+  if (schema.type !== "object" || !schema.properties) {
+    return schema.type || schema;
+  }
+  const required2 = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const compressed = {};
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const prop = propSchema;
+    let value = prop.type || "unknown";
+    if (prop.type === "object" && prop.properties) {
+      value = compressJsonSchema(prop, depth + 1);
+      if (required2.has(key)) {
+        compressed[key + " (required)"] = value;
+        continue;
+      }
+    } else if (prop.type === "array" && prop.items) {
+      if (prop.items.type === "object" && prop.items.properties) {
+        value = [compressJsonSchema(prop.items, depth + 1)];
+      } else {
+        value = `${prop.items.type || "any"}[]`;
+      }
+    } else if (prop.enum) {
+      value = prop.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    if (required2.has(key) && typeof value === "string") {
+      value += " (required)";
+    }
+    compressed[key] = value;
+  }
+  return compressed;
+}
+function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
+  const { keysToStrip, maxDepth, maxStringLength, maxArrayLength, maxObjectKeys } = options;
+  const stripSet = keysToStrip instanceof Set ? keysToStrip : new Set(Array.isArray(keysToStrip) ? keysToStrip : Object.keys(keysToStrip));
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  function helper(val, depth) {
+    if (depth > maxDepth) {
+      return "[MaxDepth]";
+    }
+    if (val === null || val === void 0) {
+      return val;
+    }
+    if (typeof val === "string") {
+      return truncateString(val, maxStringLength);
+    }
+    if (typeof val === "number" || typeof val === "boolean") {
+      return val;
+    }
+    if (typeof val === "bigint") {
+      return `${val}n`;
+    }
+    if (typeof val === "function") {
+      return "[Function]";
+    }
+    if (typeof val === "symbol") {
+      return val.description ? `[Symbol(${val.description})]` : "[Symbol]";
+    }
+    if (val instanceof Date) {
+      return val;
+    }
+    if (typeof val === "object") {
+      if (ancestors.has(val)) {
+        return "[Circular]";
+      }
+      ancestors.add(val);
+    }
+    try {
+      if (val instanceof Error) {
+        let errorName;
+        let errorMessage;
+        let errorStack;
+        let rawCause;
+        let causeReadFailed = false;
+        try {
+          errorName = val.name;
+        } catch (error48) {
+          errorName = formatSerializationError(error48);
+        }
+        try {
+          errorMessage = val.message;
+        } catch (error48) {
+          errorMessage = formatSerializationError(error48);
+        }
+        try {
+          errorStack = val.stack;
+        } catch (error48) {
+          errorStack = formatSerializationError(error48);
+        }
+        try {
+          rawCause = val.cause;
+        } catch (error48) {
+          causeReadFailed = true;
+          rawCause = formatSerializationError(error48);
+        }
+        const cleanedError = {
+          name: typeof errorName === "string" ? truncateString(errorName, maxStringLength) : errorName,
+          message: typeof errorMessage === "string" ? truncateString(errorMessage, maxStringLength) : errorMessage
+        };
+        if (typeof errorStack === "string") {
+          cleanedError.stack = truncateString(errorStack, maxStringLength);
+        } else if (errorStack !== void 0) {
+          cleanedError.stack = errorStack;
+        }
+        if (causeReadFailed) {
+          cleanedError.cause = rawCause;
+        } else if (rawCause !== void 0) {
+          try {
+            cleanedError.cause = helper(rawCause, depth + 1);
+          } catch (error48) {
+            cleanedError.cause = formatSerializationError(error48);
+          }
+        }
+        return cleanedError;
+      }
+      if (val instanceof Map) {
+        const cleanedMap = { __type: "Map", __map_entries: [] };
+        let mapKeyCount = 0;
+        let omittedMapEntries = 0;
+        for (const [mapKey, mapVal] of val) {
+          if (typeof mapKey === "string" && stripSet.has(mapKey)) {
+            continue;
+          }
+          if (mapKeyCount >= maxObjectKeys) {
+            omittedMapEntries++;
+            continue;
+          }
+          const mapKeyType = getMapKeyType(mapKey);
+          let cleanedMapKey;
+          let cleanedMapValue;
+          try {
+            cleanedMapKey = helper(mapKey, depth + 1);
+          } catch (error48) {
+            cleanedMapKey = formatSerializationError(error48);
+          }
+          try {
+            cleanedMapValue = helper(mapVal, depth + 1);
+          } catch (error48) {
+            cleanedMapValue = formatSerializationError(error48);
+          }
+          cleanedMap.__map_entries.push([mapKeyType, cleanedMapKey, cleanedMapValue]);
+          mapKeyCount++;
+        }
+        if (omittedMapEntries > 0) {
+          cleanedMap.__truncated = `${omittedMapEntries} more keys omitted`;
+        }
+        return cleanedMap;
+      }
+      if (val instanceof Set) {
+        const cleanedSet = [];
+        let i = 0;
+        const totalSetSize = val.size;
+        for (const item of val) {
+          if (i >= maxArrayLength) break;
+          try {
+            cleanedSet.push(helper(item, depth + 1));
+          } catch (error48) {
+            cleanedSet.push(formatSerializationError(error48));
+          }
+          i++;
+        }
+        if (totalSetSize > maxArrayLength) {
+          cleanedSet.push(`[\u2026${totalSetSize - maxArrayLength} more items]`);
+        }
+        return cleanedSet;
+      }
+      if (Array.isArray(val)) {
+        const cleaned2 = [];
+        for (let i = 0; i < Math.min(val.length, maxArrayLength); i++) {
+          try {
+            cleaned2.push(helper(val[i], depth + 1));
+          } catch (error48) {
+            cleaned2.push(formatSerializationError(error48));
+          }
+        }
+        if (val.length > maxArrayLength) {
+          cleaned2.push(`[\u2026${val.length - maxArrayLength} more items]`);
+        }
+        return cleaned2;
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) {
+        return `[Buffer length=${val.length}]`;
+      }
+      if (ArrayBuffer.isView(val)) {
+        const ctor = val.constructor?.name ?? "TypedArray";
+        const byteLength = val.byteLength ?? "?";
+        return `[${ctor} byteLength=${byteLength}]`;
+      }
+      if (val instanceof ArrayBuffer) {
+        return `[ArrayBuffer byteLength=${val.byteLength}]`;
+      }
+      let serializeForSpan;
+      try {
+        serializeForSpan = val.serializeForSpan;
+      } catch (error48) {
+        return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+      }
+      if (typeof serializeForSpan === "function") {
+        try {
+          return helper(serializeForSpan.call(val), depth);
+        } catch (error48) {
+          return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+        }
+      }
+      let looksLikeJsonSchema = false;
+      try {
+        looksLikeJsonSchema = isJsonSchema(val);
+      } catch {
+        looksLikeJsonSchema = false;
+      }
+      if (looksLikeJsonSchema) {
+        try {
+          const compressed = compressJsonSchema(val);
+          return compressed === val ? "[JSONSchema]" : helper(compressed, depth);
+        } catch {
+        }
+      }
+      const cleaned = {};
+      const keys = Object.keys(val).filter((key) => !stripSet.has(key));
+      let keyCount = 0;
+      for (const key of keys) {
+        if (keyCount >= maxObjectKeys) {
+          cleaned["__truncated"] = `${keys.length - keyCount} more keys omitted`;
+          break;
+        }
+        try {
+          cleaned[key] = helper(val[key], depth + 1);
+          keyCount++;
+        } catch (error48) {
+          cleaned[key] = formatSerializationError(error48);
+          keyCount++;
+        }
+      }
+      return cleaned;
+    } finally {
+      if (typeof val === "object" && val !== null) {
+        ancestors.delete(val);
+      }
+    }
+  }
+  return helper(value, 0);
+}
+
+// src/bus/observability-bus.ts
+function cleanEvent(event, options) {
+  switch (event.type) {
+    case "log":
+      return { type: "log", log: deepClean(event.log, options) };
+    case "metric":
+      return { type: "metric", metric: deepClean(event.metric, options) };
+    case "score":
+      return { type: "score", score: deepClean(event.score, options) };
+    case "feedback":
+      return { type: "feedback", feedback: deepClean(event.feedback, options) };
+    default:
+      return event;
+  }
+}
+var MAX_FLUSH_ITERATIONS = 3;
+var ObservabilityBus = class extends BaseObservabilityEventBus {
+  exporters = [];
+  bridge;
+  /** In-flight handler promises from routeToHandler. Self-cleaning via .finally(). */
+  pendingHandlers = /* @__PURE__ */ new Set();
+  /** Resolved deepClean options applied to non-tracing events before fan-out. */
+  deepCleanOptions;
+  constructor(opts) {
+    super({ name: "ObservabilityBus" });
+    this.deepCleanOptions = mergeSerializationOptions(opts?.serializationOptions);
+  }
+  /**
+   * Register an exporter to receive routed events.
+   * Duplicate registrations (same instance) are silently ignored.
+   *
+   * @param exporter - The exporter to register.
+   */
+  registerExporter(exporter) {
+    if (this.exporters.includes(exporter)) {
+      return;
+    }
+    this.exporters.push(exporter);
+  }
+  /**
+   * Unregister an exporter.
+   *
+   * @param exporter - The exporter instance to remove.
+   * @returns `true` if the exporter was found and removed, `false` otherwise.
+   */
+  unregisterExporter(exporter) {
+    const index = this.exporters.indexOf(exporter);
+    if (index !== -1) {
+      this.exporters.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get registered exporters (read-only snapshot).
+   */
+  getExporters() {
+    return [...this.exporters];
+  }
+  /**
+   * Register a bridge to receive all routed events alongside exporters.
+   * Only one bridge can be registered at a time; replacing an existing bridge
+   * logs a warning.
+   *
+   * @param bridge - The bridge to register.
+   */
+  registerBridge(bridge) {
+    if (this.bridge) {
+      this.logger.warn(`[ObservabilityBus] Replacing existing bridge with new bridge`);
+    }
+    this.bridge = bridge;
+  }
+  /**
+   * Unregister the bridge.
+   *
+   * @returns `true` if a bridge was registered and removed, `false` otherwise.
+   */
+  unregisterBridge() {
+    if (this.bridge) {
+      this.bridge = void 0;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get the registered bridge, if any.
+   */
+  getBridge() {
+    return this.bridge;
+  }
+  /**
+   * Emit an event: route to exporter/bridge handlers, then forward to base
+   * class for subscriber delivery.
+   *
+   * emit() is synchronous — async handler promises are tracked internally
+   * and can be drained via flush().
+   */
+  emit(event) {
+    const cleaned = cleanEvent(event, this.deepCleanOptions);
+    for (const exporter of this.exporters) {
+      this.trackPromise(routeToHandler(exporter, cleaned, this.logger));
+    }
+    if (this.bridge) {
+      this.trackPromise(routeToHandler(this.bridge, cleaned, this.logger));
+    }
+    super.emit(cleaned);
+  }
+  /**
    * Track an async handler promise so flush() can await it.
    * No-ops for sync (void) results.
    */
@@ -18402,218 +19022,6 @@ var ModelSpanTracker = class {
   }
 };
 
-// src/spans/serialization.ts
-var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
-  "logger",
-  "experimental_providerMetadata",
-  "providerMetadata",
-  "steps",
-  "tracingContext",
-  "execute",
-  // Tool execute functions
-  "validate"
-  // Schema validate functions
-]);
-var DEFAULT_DEEP_CLEAN_OPTIONS = Object.freeze({
-  keysToStrip: DEFAULT_KEYS_TO_STRIP,
-  maxDepth: 8,
-  maxStringLength: 128 * 1024,
-  // 128KB - sufficient for large LLM prompts/responses
-  maxArrayLength: 50,
-  maxObjectKeys: 50
-});
-function mergeSerializationOptions(userOptions) {
-  if (!userOptions) {
-    return DEFAULT_DEEP_CLEAN_OPTIONS;
-  }
-  return {
-    keysToStrip: DEFAULT_KEYS_TO_STRIP,
-    maxDepth: userOptions.maxDepth ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxDepth,
-    maxStringLength: userOptions.maxStringLength ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxStringLength,
-    maxArrayLength: userOptions.maxArrayLength ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxArrayLength,
-    maxObjectKeys: userOptions.maxObjectKeys ?? DEFAULT_DEEP_CLEAN_OPTIONS.maxObjectKeys
-  };
-}
-function truncateString(s, maxChars) {
-  if (s.length <= maxChars) {
-    return s;
-  }
-  return s.slice(0, maxChars) + "\u2026[truncated]";
-}
-function isJsonSchema(val) {
-  if (typeof val !== "object" || val === null) return false;
-  if (val.$schema && typeof val.$schema === "string" && val.$schema.includes("json-schema")) {
-    return true;
-  }
-  if (val.type === "object" && val.properties && typeof val.properties === "object") {
-    return true;
-  }
-  return false;
-}
-function compressJsonSchema(schema, depth = 0) {
-  if (depth > 3) {
-    return schema.type || "object";
-  }
-  const compositionKeys = ["oneOf", "anyOf", "allOf"].filter((key) => Array.isArray(schema[key]));
-  if (compositionKeys.length > 0) {
-    const compressed2 = {};
-    for (const key of compositionKeys) {
-      compressed2[key] = schema[key].map((entry) => compressJsonSchema(entry, depth + 1));
-    }
-    if (typeof schema.type === "string") {
-      compressed2.type = schema.type;
-    }
-    return compressed2;
-  }
-  if (schema.type !== "object" || !schema.properties) {
-    return schema.type || schema;
-  }
-  const required2 = new Set(Array.isArray(schema.required) ? schema.required : []);
-  const compressed = {};
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    const prop = propSchema;
-    let value = prop.type || "unknown";
-    if (prop.type === "object" && prop.properties) {
-      value = compressJsonSchema(prop, depth + 1);
-      if (required2.has(key)) {
-        compressed[key + " (required)"] = value;
-        continue;
-      }
-    } else if (prop.type === "array" && prop.items) {
-      if (prop.items.type === "object" && prop.items.properties) {
-        value = [compressJsonSchema(prop.items, depth + 1)];
-      } else {
-        value = `${prop.items.type || "any"}[]`;
-      }
-    } else if (prop.enum) {
-      value = prop.enum.map((v) => JSON.stringify(v)).join(" | ");
-    }
-    if (required2.has(key) && typeof value === "string") {
-      value += " (required)";
-    }
-    compressed[key] = value;
-  }
-  return compressed;
-}
-function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
-  const { keysToStrip, maxDepth, maxStringLength, maxArrayLength, maxObjectKeys } = options;
-  const stripSet = keysToStrip instanceof Set ? keysToStrip : new Set(Array.isArray(keysToStrip) ? keysToStrip : Object.keys(keysToStrip));
-  const ancestors = /* @__PURE__ */ new WeakSet();
-  function helper(val, depth) {
-    if (depth > maxDepth) {
-      return "[MaxDepth]";
-    }
-    if (val === null || val === void 0) {
-      return val;
-    }
-    if (typeof val === "string") {
-      return truncateString(val, maxStringLength);
-    }
-    if (typeof val === "number" || typeof val === "boolean") {
-      return val;
-    }
-    if (typeof val === "bigint") {
-      return `${val}n`;
-    }
-    if (typeof val === "function") {
-      return "[Function]";
-    }
-    if (typeof val === "symbol") {
-      return val.description ? `[Symbol(${val.description})]` : "[Symbol]";
-    }
-    if (val instanceof Date) {
-      return val;
-    }
-    if (val instanceof Error) {
-      return {
-        name: val.name,
-        message: val.message ? truncateString(val.message, maxStringLength) : void 0
-      };
-    }
-    if (typeof val === "object") {
-      if (ancestors.has(val)) {
-        return "[Circular]";
-      }
-      ancestors.add(val);
-    }
-    try {
-      if (Array.isArray(val)) {
-        const cleaned2 = [];
-        for (let i = 0; i < Math.min(val.length, maxArrayLength); i++) {
-          try {
-            cleaned2.push(helper(val[i], depth + 1));
-          } catch (error48) {
-            cleaned2.push(`[${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`);
-          }
-        }
-        if (val.length > maxArrayLength) {
-          cleaned2.push(`[\u2026${val.length - maxArrayLength} more items]`);
-        }
-        return cleaned2;
-      }
-      if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) {
-        return `[Buffer length=${val.length}]`;
-      }
-      if (ArrayBuffer.isView(val)) {
-        const ctor = val.constructor?.name ?? "TypedArray";
-        const byteLength = val.byteLength ?? "?";
-        return `[${ctor} byteLength=${byteLength}]`;
-      }
-      if (val instanceof ArrayBuffer) {
-        return `[ArrayBuffer byteLength=${val.byteLength}]`;
-      }
-      let serializeForSpan;
-      try {
-        serializeForSpan = val.serializeForSpan;
-      } catch (error48) {
-        return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
-      }
-      if (typeof serializeForSpan === "function") {
-        try {
-          return helper(serializeForSpan.call(val), depth);
-        } catch (error48) {
-          return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
-        }
-      }
-      let looksLikeJsonSchema = false;
-      try {
-        looksLikeJsonSchema = isJsonSchema(val);
-      } catch {
-        looksLikeJsonSchema = false;
-      }
-      if (looksLikeJsonSchema) {
-        try {
-          const compressed = compressJsonSchema(val);
-          return compressed === val ? "[JSONSchema]" : helper(compressed, depth);
-        } catch {
-        }
-      }
-      const cleaned = {};
-      const keys = Object.keys(val).filter((key) => !stripSet.has(key));
-      let keyCount = 0;
-      for (const key of keys) {
-        if (keyCount >= maxObjectKeys) {
-          cleaned["__truncated"] = `${keys.length - keyCount} more keys omitted`;
-          break;
-        }
-        try {
-          cleaned[key] = helper(val[key], depth + 1);
-          keyCount++;
-        } catch (error48) {
-          cleaned[key] = `[${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
-          keyCount++;
-        }
-      }
-      return cleaned;
-    } finally {
-      if (typeof val === "object" && val !== null) {
-        ancestors.delete(val);
-      }
-    }
-  }
-  return helper(value, 0);
-}
-
 // src/spans/base.ts
 function isSpanInternal(spanType, flags) {
   if (flags === void 0 || flags === observability.InternalSpans.NONE) {
@@ -19072,7 +19480,9 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       logging: config2.logging
     };
     this.cardinalityFilter = new CardinalityFilter(config2.cardinality);
-    this.observabilityBus = new ObservabilityBus();
+    this.observabilityBus = new ObservabilityBus({
+      serializationOptions: this.config.serializationOptions
+    });
     for (const exporter of this.exporters) {
       this.observabilityBus.registerExporter(exporter);
     }
@@ -20433,10 +20843,12 @@ exports.buildTracingOptions = buildTracingOptions;
 exports.chainFormatters = chainFormatters;
 exports.deepClean = deepClean;
 exports.getExternalParentId = getExternalParentId;
+exports.isSerializedMap = isSerializedMap;
 exports.mergeSerializationOptions = mergeSerializationOptions;
 exports.observabilityConfigValueSchema = observabilityConfigValueSchema;
 exports.observabilityInstanceConfigSchema = observabilityInstanceConfigSchema;
 exports.observabilityRegistryConfigSchema = observabilityRegistryConfigSchema;
+exports.reconstructSerializedMap = reconstructSerializedMap;
 exports.routeToHandler = routeToHandler;
 exports.samplingStrategySchema = samplingStrategySchema;
 exports.serializationOptionsSchema = serializationOptionsSchema;