@mastra/core 0.16.3 → 0.16.4-alpha.1

package/dist/{chunk-W5K2KOZX.js → chunk-ODLGLX2R.js}

@@ -1,6 +1,6 @@
 import { RuntimeContext } from './chunk-HLRWYUFN.js';
 import { MastraError } from './chunk-MCOVMKIS.js';
-import { ToolStream } from './chunk-YW7UILPE.js';
+import { ToolStream } from './chunk-A3QHQYMC.js';
 import { isVercelTool, validateToolInput } from './chunk-BJGHUKKM.js';
 import { MastraBase } from './chunk-6GF5M4GX.js';
 import { RegisteredLogger, ConsoleLogger, LogLevel } from './chunk-X3GXU6TZ.js';
@@ -9,51 +9,238 @@ import jsonSchemaToZod from 'json-schema-to-zod';
 import { z } from 'zod';
 import { convertZodSchemaToAISDKSchema, OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, GoogleSchemaCompatLayer, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, MetaSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
 
-// src/ai-tracing/no-op.ts
-var NoOpAISpan = class _NoOpAISpan {
-  id;
+// src/ai-tracing/spans/base.ts
+var BaseAISpan = class {
   name;
   type;
   attributes;
   parent;
-  traceId;
   startTime;
   endTime;
   isEvent;
+  isInternal;
   aiTracing;
   input;
   output;
   errorInfo;
   metadata;
   constructor(options, aiTracing) {
-    this.id = "no-op";
     this.name = options.name;
     this.type = options.type;
-    this.attributes = options.attributes || {};
-    this.metadata = options.metadata;
+    this.attributes = deepClean(options.attributes) || {};
+    this.metadata = deepClean(options.metadata);
     this.parent = options.parent;
-    this.traceId = "no-op-trace";
     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) {
+    this.isEvent = options.isEvent ?? false;
+    this.isInternal = options.isInternal ?? false;
+    if (this.isEvent) {
+      this.output = deepClean(options.output);
+    } else {
+      this.input = deepClean(options.input);
+    }
   }
   createChildSpan(options) {
-    return new _NoOpAISpan({ ...options, parent: this, isEvent: false }, this.aiTracing);
+    return this.aiTracing.startSpan({ ...options, parent: this, isEvent: false });
   }
   createEventSpan(options) {
-    return new _NoOpAISpan({ ...options, parent: this, isEvent: true }, this.aiTracing);
-  }
-  update(_options) {
+    return this.aiTracing.startSpan({ ...options, parent: this, isEvent: true });
   }
+  /** Returns `TRUE` if the span is the root span of a trace */
   get isRootSpan() {
     return !this.parent;
   }
+  /** Get the closest parent spanId that isn't an internal span */
+  getParentSpanId(includeInternalSpans) {
+    if (!this.parent) return void 0;
+    if (includeInternalSpans) return this.parent.id;
+    if (this.parent.isInternal) return this.parent.getParentSpanId(includeInternalSpans);
+    return this.parent.id;
+  }
+  /** Returns a lightweight span ready for export */
+  exportSpan(includeInternalSpans) {
+    return {
+      id: this.id,
+      traceId: this.traceId,
+      name: this.name,
+      type: this.type,
+      attributes: this.attributes,
+      metadata: this.metadata,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      input: this.input,
+      output: this.output,
+      errorInfo: this.errorInfo,
+      isEvent: this.isEvent,
+      isRootSpan: this.isRootSpan,
+      parentSpanId: this.getParentSpanId(includeInternalSpans)
+    };
+  }
+};
+var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
+  "logger",
+  "experimental_providerMetadata",
+  "providerMetadata",
+  "steps",
+  "tracingContext"
+]);
+function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _depth = 0) {
+  const { keysToStrip = DEFAULT_KEYS_TO_STRIP, maxDepth = 10 } = options;
+  if (_depth > maxDepth) {
+    return "[MaxDepth]";
+  }
+  if (value === null || typeof value !== "object") {
+    try {
+      JSON.stringify(value);
+      return value;
+    } catch (error) {
+      return `[${error instanceof Error ? error.message : String(error)}]`;
+    }
+  }
+  if (_seen.has(value)) {
+    return "[Circular]";
+  }
+  _seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClean(item, options, _seen, _depth + 1));
+  }
+  const cleaned = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (keysToStrip.has(key)) {
+      continue;
+    }
+    try {
+      cleaned[key] = deepClean(val, options, _seen, _depth + 1);
+    } catch (error) {
+      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
+    }
+  }
+  return cleaned;
+}
+
+// src/ai-tracing/spans/default.ts
+var DefaultAISpan = class extends BaseAISpan {
+  id;
+  traceId;
+  constructor(options, aiTracing) {
+    super(options, aiTracing);
+    this.id = generateSpanId();
+    if (!options.parent) {
+      this.traceId = generateTraceId();
+    } else {
+      this.traceId = options.parent.traceId;
+    }
+  }
+  end(options) {
+    if (this.isEvent) {
+      return;
+    }
+    this.endTime = /* @__PURE__ */ new Date();
+    if (options?.output !== void 0) {
+      this.output = deepClean(options.output);
+    }
+    if (options?.attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
+    }
+    if (options?.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
+    }
+  }
+  error(options) {
+    if (this.isEvent) {
+      return;
+    }
+    const { error, endSpan = true, attributes, metadata } = options;
+    this.errorInfo = error instanceof MastraError ? {
+      id: error.id,
+      details: error.details,
+      category: error.category,
+      domain: error.domain,
+      message: error.message
+    } : {
+      message: error.message
+    };
+    if (attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(attributes) };
+    }
+    if (metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(metadata) };
+    }
+    if (endSpan) {
+      this.end();
+    } else {
+      this.update({});
+    }
+  }
+  update(options) {
+    if (this.isEvent) {
+      return;
+    }
+    if (options.input !== void 0) {
+      this.input = deepClean(options.input);
+    }
+    if (options.output !== void 0) {
+      this.output = deepClean(options.output);
+    }
+    if (options.attributes) {
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
+    }
+    if (options.metadata) {
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
+    }
+  }
+  get isValid() {
+    return true;
+  }
+  async export() {
+    return JSON.stringify({
+      spanId: this.id,
+      traceId: this.traceId,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      metadata: this.metadata
+    });
+  }
+};
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/ai-tracing/spans/no-op.ts
+var NoOpAISpan = class extends BaseAISpan {
+  id;
+  traceId;
+  constructor(options, aiTracing) {
+    super(options, aiTracing);
+    this.id = "no-op";
+    this.traceId = "no-op-trace";
+  }
+  end(_options) {
+  }
+  error(_options) {
+  }
+  update(_options) {
+  }
   get isValid() {
     return false;
   }
@@ -91,8 +278,8 @@ var AITracingEventType = /* @__PURE__ */ ((AITracingEventType2) => {
   return AITracingEventType2;
 })(AITracingEventType || {});
 
-// src/ai-tracing/base.ts
-var MastraAITracing = class extends MastraBase {
+// src/ai-tracing/tracers/base.ts
+var BaseAITracing = class extends MastraBase {
   config;
   constructor(config) {
     super({ component: RegisteredLogger.AI_TRACING, name: config.serviceName });
@@ -101,7 +288,8 @@ var MastraAITracing = class extends MastraBase {
       name: config.name,
       sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
       exporters: config.exporters ?? [],
-      processors: config.processors ?? []
+      processors: config.processors ?? [],
+      includeInternalSpans: config.includeInternalSpans ?? false
     };
   }
   /**
@@ -129,25 +317,11 @@ var MastraAITracing = class extends MastraBase {
    * Start a new span of a specific AISpanType
    */
   startSpan(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, output, attributes, metadata, parent, isEvent: isEvent === true },
-        this
-      );
+    const { customSamplerOptions, ...createSpanOptions } = options;
+    if (!this.shouldSample(customSamplerOptions)) {
+      return new NoOpAISpan(createSpanOptions, this);
     }
-    const spanOptions = {
-      type,
-      name,
-      input,
-      output,
-      attributes,
-      metadata,
-      parent,
-      isEvent: isEvent === true
-    };
-    const span = this.createSpan(spanOptions);
+    const span = this.createSpan(createSpanOptions);
     if (span.isEvent) {
       this.emitSpanEnded(span);
     } else {
@@ -194,6 +368,9 @@ var MastraAITracing = class extends MastraBase {
    * This ensures all spans emit events regardless of implementation
    */
   wireSpanLifecycle(span) {
+    if (!this.config.includeInternalSpans && span.isInternal) {
+      return;
+    }
     const originalEnd = span.end.bind(span);
     const originalUpdate = span.update.bind(span);
     span.end = (options) => {
@@ -219,7 +396,7 @@ var MastraAITracing = class extends MastraBase {
   /**
    * Check if an AI trace should be sampled
    */
-  shouldSample(traceContext) {
+  shouldSample(options) {
     const { sampling } = this.config;
     switch (sampling.type) {
       case "always" /* ALWAYS */:
@@ -235,7 +412,7 @@ var MastraAITracing = class extends MastraBase {
         }
         return Math.random() < sampling.probability;
       case "custom" /* CUSTOM */:
-        return sampling.sampler(traceContext);
+        return sampling.sampler(options);
       default:
         throw new Error(`Sampling strategy type not implemented: ${sampling.type}`);
     }
@@ -244,29 +421,34 @@ var MastraAITracing = class extends MastraBase {
    * Process a span through all processors
    */
   processSpan(span) {
-    let processedSpan = span;
     for (const processor of this.processors) {
-      if (!processedSpan) {
+      if (!span) {
         break;
       }
       try {
-        processedSpan = processor.process(processedSpan);
+        span = processor.process(span);
       } catch (error) {
         this.logger.error(`[AI Tracing] Processor error [name=${processor.name}]`, error);
       }
     }
-    return processedSpan;
+    return span;
   }
   // ============================================================================
   // Event-driven Export Methods
   // ============================================================================
+  getSpanForExport(span) {
+    if (!span.isValid) return void 0;
+    if (span.isInternal && !this.config.includeInternalSpans) return void 0;
+    const processedSpan = this.processSpan(span);
+    return processedSpan?.exportSpan(this.config.includeInternalSpans);
+  }
   /**
    * Emit a span started event
    */
   emitSpanStarted(span) {
-    const processedSpan = this.processSpan(span);
-    if (processedSpan) {
-      this.exportEvent({ type: "span_started" /* SPAN_STARTED */, span: processedSpan }).catch((error) => {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportEvent({ type: "span_started" /* SPAN_STARTED */, exportedSpan }).catch((error) => {
         this.logger.error("[AI Tracing] Failed to export span_started event", error);
       });
     }
@@ -275,9 +457,9 @@ var MastraAITracing = class extends MastraBase {
    * Emit a span ended event (called automatically when spans end)
    */
   emitSpanEnded(span) {
-    const processedSpan = this.processSpan(span);
-    if (processedSpan) {
-      this.exportEvent({ type: "span_ended" /* SPAN_ENDED */, span: processedSpan }).catch((error) => {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportEvent({ type: "span_ended" /* SPAN_ENDED */, exportedSpan }).catch((error) => {
         this.logger.error("[AI Tracing] Failed to export span_ended event", error);
       });
     }
@@ -286,9 +468,9 @@ var MastraAITracing = class extends MastraBase {
    * Emit a span updated event
    */
   emitSpanUpdated(span) {
-    const processedSpan = this.processSpan(span);
-    if (processedSpan) {
-      this.exportEvent({ type: "span_updated" /* SPAN_UPDATED */, span: processedSpan }).catch((error) => {
+    const exportedSpan = this.getSpanForExport(span);
+    if (exportedSpan) {
+      this.exportEvent({ type: "span_updated" /* SPAN_UPDATED */, exportedSpan }).catch((error) => {
         this.logger.error("[AI Tracing] Failed to export span_updated event", error);
       });
     }
@@ -329,6 +511,16 @@ var MastraAITracing = class extends MastraBase {
     this.logger.info(`[AI Tracing] Shutdown completed [name=${this.name}]`);
   }
 };
+
+// src/ai-tracing/tracers/default.ts
+var DefaultAITracing = class extends BaseAITracing {
+  constructor(config) {
+    super(config);
+  }
+  createSpan(options) {
+    return new DefaultAISpan(options, this);
+  }
+};
 var CoreToolBuilder = class extends MastraBase {
   originalTool;
   options;
@@ -401,7 +593,8 @@ var CoreToolBuilder = class extends MastraBase {
           toolId: options.name,
           toolDescription: options.description,
           toolType: logType || "tool"
-        }
+        },
+        isInternal: options.tracingContext?.isInternal
       });
       try {
         let result;
@@ -896,7 +1089,7 @@ var CloudExporter = class {
     if (this.buffer.totalSize === 0) {
       this.buffer.firstEventTime = /* @__PURE__ */ new Date();
     }
-    const spanRecord = this.formatSpan(event.span);
+    const spanRecord = this.formatSpan(event.exportedSpan);
     this.buffer.spans.push(spanRecord);
     this.buffer.totalSize++;
   }
@@ -904,7 +1097,7 @@ var CloudExporter = class {
     const spanRecord = {
       traceId: span.traceId,
       spanId: span.id,
-      parentSpanId: span.parent?.id ?? null,
+      parentSpanId: span.parentSpanId ?? null,
       name: span.name,
       spanType: span.type,
       attributes: span.attributes ?? null,
@@ -1054,7 +1247,7 @@ var ConsoleExporter = class {
     }
   }
   async exportEvent(event) {
-    const span = event.span;
+    const span = event.exportedSpan;
     const formatAttributes = (attributes) => {
       try {
         return JSON.stringify(attributes, null, 2);
@@ -1233,8 +1426,8 @@ var DefaultExporter = class {
    */
   handleOutOfOrderUpdate(event) {
     this.logger.warn("Out-of-order span update detected - skipping event", {
-      spanId: event.span.id,
-      traceId: event.span.traceId,
+      spanId: event.exportedSpan.id,
+      traceId: event.exportedSpan.traceId,
       eventType: event.type
     });
   }
@@ -1242,7 +1435,7 @@ var DefaultExporter = class {
    * Adds an event to the appropriate buffer based on strategy
    */
   addToBuffer(event) {
-    const spanKey = this.buildSpanKey(event.span.traceId, event.span.id);
+    const spanKey = this.buildSpanKey(event.exportedSpan.traceId, event.exportedSpan.id);
     if (this.buffer.totalSize === 0) {
       this.buffer.firstEventTime = /* @__PURE__ */ new Date();
     }
@@ -1250,9 +1443,9 @@ var DefaultExporter = class {
       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),
+            traceId: event.exportedSpan.traceId,
+            spanId: event.exportedSpan.id,
+            ...this.buildCreateRecord(event.exportedSpan),
             createdAt: /* @__PURE__ */ new Date(),
             updatedAt: null
           };
@@ -1264,10 +1457,10 @@ var DefaultExporter = class {
         if (this.resolvedStrategy === "batch-with-updates") {
           if (this.buffer.seenSpans.has(spanKey)) {
             this.buffer.updates.push({
-              traceId: event.span.traceId,
-              spanId: event.span.id,
+              traceId: event.exportedSpan.traceId,
+              spanId: event.exportedSpan.id,
               updates: {
-                ...this.buildUpdateRecord(event.span),
+                ...this.buildUpdateRecord(event.exportedSpan),
                 updatedAt: /* @__PURE__ */ new Date()
               },
               sequenceNumber: this.getNextSequence(spanKey)
@@ -1282,19 +1475,19 @@ var DefaultExporter = class {
         if (this.resolvedStrategy === "batch-with-updates") {
           if (this.buffer.seenSpans.has(spanKey)) {
             this.buffer.updates.push({
-              traceId: event.span.traceId,
-              spanId: event.span.id,
+              traceId: event.exportedSpan.traceId,
+              spanId: event.exportedSpan.id,
               updates: {
-                ...this.buildUpdateRecord(event.span),
+                ...this.buildUpdateRecord(event.exportedSpan),
                 updatedAt: /* @__PURE__ */ new Date()
               },
               sequenceNumber: this.getNextSequence(spanKey)
             });
-          } else if (event.span.isEvent) {
+          } else if (event.exportedSpan.isEvent) {
             const createRecord = {
-              traceId: event.span.traceId,
-              spanId: event.span.id,
-              ...this.buildCreateRecord(event.span),
+              traceId: event.exportedSpan.traceId,
+              spanId: event.exportedSpan.id,
+              ...this.buildCreateRecord(event.exportedSpan),
               createdAt: /* @__PURE__ */ new Date(),
               updatedAt: null
             };
@@ -1306,9 +1499,9 @@ var DefaultExporter = class {
           }
         } else if (this.resolvedStrategy === "insert-only") {
           const createRecord = {
-            traceId: event.span.traceId,
-            spanId: event.span.id,
-            ...this.buildCreateRecord(event.span),
+            traceId: event.exportedSpan.traceId,
+            spanId: event.exportedSpan.id,
+            ...this.buildCreateRecord(event.exportedSpan),
             createdAt: /* @__PURE__ */ new Date(),
             updatedAt: null
           };
@@ -1395,7 +1588,7 @@ var DefaultExporter = class {
   }
   buildCreateRecord(span) {
     return {
-      parentSpanId: span.parent?.id ?? null,
+      parentSpanId: span.parentSpanId ?? null,
       name: span.name,
       scope: null,
       spanType: span.type,
@@ -1427,7 +1620,7 @@ var DefaultExporter = class {
    * Handles realtime strategy - processes each event immediately
    */
   async handleRealtimeEvent(event, storage) {
-    const span = event.span;
+    const span = event.exportedSpan;
     if (span.isEvent) {
       if (event.type === "span_ended" /* SPAN_ENDED */) {
         await storage.createAISpan({
@@ -1639,11 +1832,125 @@ var DefaultExporter = class {
   }
 };
 
+// src/ai-tracing/span_processors/sensitive-data-filter.ts
+var SensitiveDataFilter = class {
+  name = "sensitive-data-filter";
+  sensitiveFields;
+  redactionToken;
+  redactionStyle;
+  constructor(options = {}) {
+    this.sensitiveFields = (options.sensitiveFields || [
+      "password",
+      "token",
+      "secret",
+      "key",
+      "apikey",
+      "auth",
+      "authorization",
+      "bearer",
+      "bearertoken",
+      "jwt",
+      "credential",
+      "clientsecret",
+      "privatekey",
+      "refresh",
+      "ssn"
+    ]).map((f) => this.normalizeKey(f));
+    this.redactionToken = options.redactionToken ?? "[REDACTED]";
+    this.redactionStyle = options.redactionStyle ?? "full";
+  }
+  /**
+   * Process a span by filtering sensitive data across its key fields.
+   * Fields processed: attributes, metadata, input, output, errorInfo.
+   *
+   * @param span - The input span to filter
+   * @returns A new span with sensitive values redacted
+   */
+  process(span) {
+    span.attributes = this.tryFilter(span.attributes);
+    span.metadata = this.tryFilter(span.metadata);
+    span.input = this.tryFilter(span.input);
+    span.output = this.tryFilter(span.output);
+    span.errorInfo = this.tryFilter(span.errorInfo);
+    return span;
+  }
+  /**
+   * Recursively filter objects/arrays for sensitive keys.
+   * Handles circular references by replacing with a marker.
+   */
+  deepFilter(obj, seen = /* @__PURE__ */ new WeakSet()) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (seen.has(obj)) {
+      return "[Circular Reference]";
+    }
+    seen.add(obj);
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.deepFilter(item, seen));
+    }
+    const filtered = {};
+    for (const key of Object.keys(obj)) {
+      const normKey = this.normalizeKey(key);
+      if (this.isSensitive(normKey)) {
+        if (obj[key] && typeof obj[key] === "object") {
+          filtered[key] = this.deepFilter(obj[key], seen);
+        } else {
+          filtered[key] = this.redactValue(obj[key]);
+        }
+      } else {
+        filtered[key] = this.deepFilter(obj[key], seen);
+      }
+    }
+    return filtered;
+  }
+  tryFilter(value) {
+    try {
+      return this.deepFilter(value);
+    } catch {
+      return { error: { processor: this.name } };
+    }
+  }
+  /**
+   * Normalize keys by lowercasing and stripping non-alphanumeric characters.
+   * Ensures consistent matching for variants like "api-key", "api_key", "Api Key".
+   */
+  normalizeKey(key) {
+    return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  }
+  /**
+   * Check whether a normalized key matches any sensitive field substring.
+   */
+  isSensitive(normalizedKey) {
+    return this.sensitiveFields.some((f) => normalizedKey.includes(f));
+  }
+  /**
+   * Redact a sensitive value.
+   * - Full style: replaces with a fixed token.
+   * - Partial style: shows 3 chars at start and end, hides the middle.
+   *
+   * Non-string values are converted to strings before partial redaction.
+   */
+  redactValue(value) {
+    if (this.redactionStyle === "full") {
+      return this.redactionToken;
+    }
+    const str = String(value);
+    const len = str.length;
+    if (len <= 6) {
+      return this.redactionToken;
+    }
+    return str.slice(0, 3) + "\u2026" + str.slice(len - 3);
+  }
+  async shutdown() {
+  }
+};
+
 // src/ai-tracing/registry.ts
 var AITracingRegistry = class {
   instances = /* @__PURE__ */ new Map();
   defaultInstance;
-  selector;
+  configSelector;
   /**
    * Register a tracing instance
    */
@@ -1672,14 +1979,14 @@ var AITracingRegistry = class {
    * Set the tracing selector function
    */
   setSelector(selector) {
-    this.selector = selector;
+    this.configSelector = selector;
   }
   /**
    * Get the selected tracing instance based on context
    */
-  getSelected(context) {
-    if (this.selector) {
-      const selected = this.selector(context, this.instances);
+  getSelected(options) {
+    if (this.configSelector) {
+      const selected = this.configSelector(options, this.instances);
       if (selected && this.instances.has(selected)) {
         return this.instances.get(selected);
       }
@@ -1706,7 +2013,7 @@ var AITracingRegistry = class {
   clear() {
     this.instances.clear();
     this.defaultInstance = void 0;
-    this.selector = void 0;
+    this.configSelector = void 0;
   }
   /**
    * Get all registered instances
@@ -1725,11 +2032,11 @@ function getAITracing(name) {
 function getDefaultAITracing() {
   return aiTracingRegistry.getDefault();
 }
-function setAITracingSelector(selector) {
+function setSelector(selector) {
   aiTracingRegistry.setSelector(selector);
 }
-function getSelectedAITracing(context) {
-  return aiTracingRegistry.getSelected(context);
+function getSelectedAITracing(options) {
+  return aiTracingRegistry.getSelected(options);
 }
 function unregisterAITracing(name) {
   return aiTracingRegistry.unregister(name);
@@ -1751,7 +2058,7 @@ function hasAITracing(name) {
   return sampling.type !== "never" /* NEVER */;
 }
 function isAITracingInstance(obj) {
-  return obj instanceof MastraAITracing;
+  return obj instanceof BaseAITracing;
 }
 function setupAITracing(config) {
   if (!config) {
@@ -1781,51 +2088,11 @@ function setupAITracing(config) {
     });
   }
   if (config.configSelector) {
-    setAITracingSelector(config.configSelector);
+    setSelector(config.configSelector);
   }
 }
 
 // src/ai-tracing/utils.ts
-var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
-  "logger",
-  "experimental_providerMetadata",
-  "providerMetadata",
-  "steps",
-  "tracingContext"
-]);
-function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _depth = 0) {
-  const { keysToStrip = DEFAULT_KEYS_TO_STRIP, maxDepth = 10 } = options;
-  if (_depth > maxDepth) {
-    return "[MaxDepth]";
-  }
-  if (value === null || typeof value !== "object") {
-    try {
-      JSON.stringify(value);
-      return value;
-    } catch (error) {
-      return `[${error instanceof Error ? error.message : String(error)}]`;
-    }
-  }
-  if (_seen.has(value)) {
-    return "[Circular]";
-  }
-  _seen.add(value);
-  if (Array.isArray(value)) {
-    return value.map((item) => deepClean(item, options, _seen, _depth + 1));
-  }
-  const cleaned = {};
-  for (const [key, val] of Object.entries(value)) {
-    if (keysToStrip.has(key)) {
-      continue;
-    }
-    try {
-      cleaned[key] = deepClean(val, options, _seen, _depth + 1);
-    } catch (error) {
-      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
-    }
-  }
-  return cleaned;
-}
 function omitKeys(obj, keysToOmit) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => !keysToOmit.includes(key)));
 }
@@ -1861,6 +2128,9 @@ function setNestedValue(obj, path, value) {
   }, obj);
   target[lastKey] = value;
 }
+function getValidTraceId(span) {
+  return span?.isValid ? span.traceId : void 0;
+}
 function getOrCreateSpan(options) {
   const { type, attributes, tracingContext, tracingOptions, runtimeContext, ...rest } = options;
   const metadata = {
@@ -1872,7 +2142,8 @@ function getOrCreateSpan(options) {
       type,
       attributes,
       ...rest,
-      metadata
+      metadata,
+      isInternal: tracingContext?.isInternal
     });
   }
   const aiTracing = getSelectedAITracing({
@@ -1881,244 +2152,14 @@ function getOrCreateSpan(options) {
   return aiTracing?.startSpan({
     type,
     attributes,
-    startOptions: {
-      runtimeContext
+    customSamplerOptions: {
+      runtimeContext,
+      metadata
     },
     ...rest,
     metadata
   });
 }
-function getValidTraceId(span) {
-  return span?.isValid ? span.traceId : void 0;
-}
-
-// src/ai-tracing/default.ts
-function generateSpanId() {
-  const bytes = new Uint8Array(8);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 8; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function generateTraceId() {
-  const bytes = new Uint8Array(16);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 16; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-var DefaultAISpan = class {
-  id;
-  name;
-  type;
-  attributes;
-  parent;
-  traceId;
-  startTime;
-  endTime;
-  isEvent;
-  aiTracing;
-  input;
-  output;
-  errorInfo;
-  metadata;
-  constructor(options, aiTracing) {
-    this.id = generateSpanId();
-    this.name = options.name;
-    this.type = options.type;
-    this.attributes = deepClean(options.attributes) || {};
-    this.metadata = deepClean(options.metadata);
-    this.parent = options.parent;
-    this.startTime = /* @__PURE__ */ new Date();
-    this.aiTracing = aiTracing;
-    this.input = deepClean(options.input);
-    this.isEvent = options.isEvent;
-    if (!options.parent) {
-      this.traceId = generateTraceId();
-    } else {
-      this.traceId = options.parent.traceId;
-    }
-    if (this.isEvent) {
-      this.output = deepClean(options.output);
-    }
-  }
-  end(options) {
-    if (this.isEvent) {
-      return;
-    }
-    this.endTime = /* @__PURE__ */ new Date();
-    if (options?.output !== void 0) {
-      this.output = deepClean(options.output);
-    }
-    if (options?.attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
-    }
-    if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
-    }
-  }
-  error(options) {
-    if (this.isEvent) {
-      return;
-    }
-    const { error, endSpan = true, attributes, metadata } = options;
-    this.errorInfo = error instanceof MastraError ? {
-      id: error.id,
-      details: error.details,
-      category: error.category,
-      domain: error.domain,
-      message: error.message
-    } : {
-      message: error.message
-    };
-    if (attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(attributes) };
-    }
-    if (metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(metadata) };
-    }
-    if (endSpan) {
-      this.end();
-    } else {
-      this.update({});
-    }
-  }
-  createChildSpan(options) {
-    return this.aiTracing.startSpan({
-      ...options,
-      parent: this,
-      isEvent: false
-    });
-  }
-  createEventSpan(options) {
-    return this.aiTracing.startSpan({
-      ...options,
-      parent: this,
-      isEvent: true
-    });
-  }
-  update(options) {
-    if (this.isEvent) {
-      return;
-    }
-    if (options?.input !== void 0) {
-      this.input = deepClean(options.input);
-    }
-    if (options?.output !== void 0) {
-      this.output = deepClean(options.output);
-    }
-    if (options?.attributes) {
-      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
-    }
-    if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
-    }
-  }
-  get isRootSpan() {
-    return !this.parent;
-  }
-  get isValid() {
-    return true;
-  }
-  async export() {
-    return JSON.stringify({
-      id: this.id,
-      attributes: this.attributes,
-      metadata: this.metadata,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      traceId: this.traceId
-      // OpenTelemetry trace ID
-    });
-  }
-};
-var SensitiveDataFilter = class {
-  name = "sensitive-data-filter";
-  sensitiveFields;
-  constructor(sensitiveFields) {
-    this.sensitiveFields = (sensitiveFields || [
-      "password",
-      "token",
-      "secret",
-      "key",
-      "apiKey",
-      "auth",
-      "authorization",
-      "bearer",
-      "jwt",
-      "credential",
-      "sessionId"
-    ]).map((field) => field.toLowerCase());
-  }
-  process(span) {
-    const deepFilter = (obj, seen = /* @__PURE__ */ new WeakSet()) => {
-      if (obj === null || typeof obj !== "object") {
-        return obj;
-      }
-      if (seen.has(obj)) {
-        return "[Circular Reference]";
-      }
-      seen.add(obj);
-      if (Array.isArray(obj)) {
-        return obj.map((item) => deepFilter(item, seen));
-      }
-      const filtered = {};
-      Object.keys(obj).forEach((key) => {
-        if (this.sensitiveFields.includes(key.toLowerCase())) {
-          if (obj[key] && typeof obj[key] === "object") {
-            filtered[key] = deepFilter(obj[key], seen);
-          } else {
-            filtered[key] = "[REDACTED]";
-          }
-        } else {
-          filtered[key] = deepFilter(obj[key], seen);
-        }
-      });
-      return filtered;
-    };
-    try {
-      const filteredSpan = { ...span };
-      filteredSpan.attributes = deepFilter(span.attributes);
-      filteredSpan.metadata = deepFilter(span.metadata);
-      filteredSpan.input = deepFilter(span.input);
-      filteredSpan.output = deepFilter(span.output);
-      filteredSpan.errorInfo = deepFilter(span.errorInfo);
-      return filteredSpan;
-    } catch (error) {
-      const safeSpan = { ...span };
-      safeSpan.attributes = {
-        "[FILTERING_ERROR]": "Attributes were completely redacted due to filtering error",
-        "[ERROR_MESSAGE]": error instanceof Error ? error.message : "Unknown filtering error"
-      };
-      return safeSpan;
-    }
-  }
-  async shutdown() {
-  }
-};
-var DefaultAITracing = class extends MastraAITracing {
-  constructor(config) {
-    const configWithDefaults = {
-      ...config,
-      exporters: config.exporters?.length ? config.exporters : [new ConsoleExporter()]
-    };
-    super(configWithDefaults);
-  }
-  // ============================================================================
-  // Abstract Method Implementations
-  // ============================================================================
-  createSpan(options) {
-    return new DefaultAISpan(options, this);
-  }
-};
 
 // src/ai-tracing/context.ts
 var AGENT_GETTERS = ["getAgent", "getAgentById"];
@@ -2267,6 +2308,6 @@ function wrapRun(run, tracingContext) {
   }
 }
 
-export { AISpanType, AITracingEventType, CloudExporter, ConsoleExporter, DefaultAITracing, DefaultExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, checkEvalStorageFields, clearAITracingRegistry, createMastraProxy, deepClean, deepMerge, delay, ensureToolProperties, fetchWithRetry, generateEmptyFromSchema, getAITracing, getAllAITracing, getDefaultAITracing, getOrCreateSpan, getSelectedAITracing, getValidTraceId, hasAITracing, isCoreMessage, isMastra, isUiMessage, isZodType, makeCoreTool, makeCoreToolV5, maskStreamTags, omitKeys, parseFieldKey, parseSqlIdentifier, registerAITracing, resolveSerializedZodOutput, selectFields, setAITracingSelector, setupAITracing, shutdownAITracingRegistry, unregisterAITracing, wrapMastra };
-//# sourceMappingURL=chunk-W5K2KOZX.js.map
-//# sourceMappingURL=chunk-W5K2KOZX.js.map
+export { AISpanType, AITracingEventType, BaseAISpan, BaseAITracing, CloudExporter, ConsoleExporter, DefaultAISpan, DefaultAITracing, DefaultExporter, NoOpAISpan, SamplingStrategyType, SensitiveDataFilter, checkEvalStorageFields, clearAITracingRegistry, createMastraProxy, deepClean, deepMerge, delay, ensureToolProperties, fetchWithRetry, generateEmptyFromSchema, getAITracing, getAllAITracing, getDefaultAITracing, getOrCreateSpan, getSelectedAITracing, getValidTraceId, hasAITracing, isCoreMessage, isMastra, isUiMessage, isZodType, makeCoreTool, makeCoreToolV5, maskStreamTags, omitKeys, parseFieldKey, parseSqlIdentifier, registerAITracing, resolveSerializedZodOutput, selectFields, setSelector, setupAITracing, shutdownAITracingRegistry, unregisterAITracing, wrapMastra };
+//# sourceMappingURL=chunk-ODLGLX2R.js.map
+//# sourceMappingURL=chunk-ODLGLX2R.js.map