@mastra/core 0.21.1 → 0.22.0-alpha.1

package/dist/{chunk-44ODA6L3.cjs → chunk-5GIAZ3CH.cjs}

@@ -2,14 +2,15 @@
 
 var chunkGPWMM745_cjs = require('./chunk-GPWMM745.cjs');
 var chunkWM4VQWOZ_cjs = require('./chunk-WM4VQWOZ.cjs');
-var chunkOXAN5SM7_cjs = require('./chunk-OXAN5SM7.cjs');
-var chunkSE4PA467_cjs = require('./chunk-SE4PA467.cjs');
+var chunkLRSB62Z6_cjs = require('./chunk-LRSB62Z6.cjs');
+var chunkVF676YCO_cjs = require('./chunk-VF676YCO.cjs');
 var chunk6VOPKVYH_cjs = require('./chunk-6VOPKVYH.cjs');
 var chunkA5KDVZDL_cjs = require('./chunk-A5KDVZDL.cjs');
 var crypto$1 = require('crypto');
 var jsonSchemaToZod = require('json-schema-to-zod');
 var zod = require('zod');
 var schemaCompat = require('@mastra/schema-compat');
+var web = require('stream/web');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -20,6 +21,7 @@ var AISpanType = /* @__PURE__ */ ((AISpanType2) => {
   AISpanType2["AGENT_RUN"] = "agent_run";
   AISpanType2["GENERIC"] = "generic";
   AISpanType2["LLM_GENERATION"] = "llm_generation";
+  AISpanType2["LLM_STEP"] = "llm_step";
   AISpanType2["LLM_CHUNK"] = "llm_chunk";
   AISpanType2["MCP_TOOL_CALL"] = "mcp_tool_call";
   AISpanType2["PROCESSOR_RUN"] = "processor_run";
@@ -82,6 +84,7 @@ function isSpanInternal(spanType, flags) {
       return (flags & 4 /* TOOL */) !== 0;
     // LLM-related spans
     case "llm_generation" /* LLM_GENERATION */:
+    case "llm_step" /* LLM_STEP */:
     case "llm_chunk" /* LLM_CHUNK */:
       return (flags & 8 /* LLM */) !== 0;
     // Default: never internal
@@ -103,6 +106,9 @@ var BaseAISpan = class {
   output;
   errorInfo;
   metadata;
+  traceState;
+  /** Parent span ID (for root spans that are children of external spans) */
+  parentSpanId;
   constructor(options, aiTracing) {
     this.name = options.name;
     this.type = options.type;
@@ -113,6 +119,7 @@ var BaseAISpan = class {
     this.aiTracing = aiTracing;
     this.isEvent = options.isEvent ?? false;
     this.isInternal = isSpanInternal(this.type, options.tracingPolicy?.internal);
+    this.traceState = options.traceState;
     if (this.isEvent) {
       this.output = deepClean(options.output);
     } else {
@@ -131,7 +138,9 @@ var BaseAISpan = class {
   }
   /** Get the closest parent spanId that isn't an internal span */
   getParentSpanId(includeInternalSpans) {
-    if (!this.parent) return void 0;
+    if (!this.parent) {
+      return this.parentSpanId;
+    }
     if (includeInternalSpans) return this.parent.id;
     if (this.parent.isInternal) return this.parent.getParentSpanId(includeInternalSpans);
     return this.parent.id;
@@ -215,10 +224,28 @@ var DefaultAISpan = class extends BaseAISpan {
   constructor(options, aiTracing) {
     super(options, aiTracing);
     this.id = generateSpanId();
-    if (!options.parent) {
-      this.traceId = generateTraceId();
-    } else {
+    if (options.parent) {
       this.traceId = options.parent.traceId;
+    } else if (options.traceId) {
+      if (isValidTraceId(options.traceId)) {
+        this.traceId = options.traceId;
+      } else {
+        console.error(
+          `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
+        );
+        this.traceId = generateTraceId();
+      }
+    } else {
+      this.traceId = generateTraceId();
+    }
+    if (!options.parent && options.parentSpanId) {
+      if (isValidSpanId(options.parentSpanId)) {
+        this.parentSpanId = options.parentSpanId;
+      } else {
+        console.error(
+          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring parent span ID.`
+        );
+      }
     }
   }
   end(options) {
@@ -315,6 +342,12 @@ function generateTraceId() {
   }
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
+function isValidTraceId(traceId) {
+  return /^[0-9a-f]{1,32}$/i.test(traceId);
+}
+function isValidSpanId(spanId) {
+  return /^[0-9a-f]{1,16}$/i.test(spanId);
+}
 
 // src/ai-tracing/spans/no-op.ts
 var NoOpAISpan = class extends BaseAISpan {
@@ -336,247 +369,72 @@ var NoOpAISpan = class extends BaseAISpan {
   }
 };
 
-// src/ai-tracing/tracers/base.ts
-var BaseAITracing = class extends chunk6VOPKVYH_cjs.MastraBase {
-  config;
-  constructor(config) {
-    super({ component: chunkA5KDVZDL_cjs.RegisteredLogger.AI_TRACING, name: config.serviceName });
-    this.config = {
-      serviceName: config.serviceName,
-      name: config.name,
-      sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
-      exporters: config.exporters ?? [],
-      processors: config.processors ?? [],
-      includeInternalSpans: config.includeInternalSpans ?? false
-    };
-  }
-  /**
-   * Override setLogger to add AI tracing specific initialization log
-   */
-  __setLogger(logger) {
-    super.__setLogger(logger);
-    this.logger.debug(
-      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
-    );
-  }
-  // ============================================================================
-  // Protected getters for clean config access
-  // ============================================================================
-  get exporters() {
-    return this.config.exporters || [];
-  }
-  get processors() {
-    return this.config.processors || [];
-  }
-  // ============================================================================
-  // Public API - Single type-safe span creation method
-  // ============================================================================
-  /**
-   * Start a new span of a specific AISpanType
-   */
-  startSpan(options) {
-    const { customSamplerOptions, ...createSpanOptions } = options;
-    if (!this.shouldSample(customSamplerOptions)) {
-      return new NoOpAISpan(createSpanOptions, this);
-    }
-    const span = this.createSpan(createSpanOptions);
-    if (span.isEvent) {
-      this.emitSpanEnded(span);
-    } else {
-      this.wireSpanLifecycle(span);
-      this.emitSpanStarted(span);
-    }
-    return span;
-  }
-  // ============================================================================
-  // Configuration Management
-  // ============================================================================
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ============================================================================
-  // Plugin Access
-  // ============================================================================
-  /**
-   * Get all exporters
-   */
-  getExporters() {
-    return [...this.exporters];
-  }
+// src/ai-tracing/exporters/base.ts
+var BaseExporter = class {
+  /** Mastra logger instance */
+  logger;
+  /** Whether this exporter is disabled */
+  isDisabled = false;
   /**
-   * Get all processors
+   * Initialize the base exporter with logger
    */
-  getProcessors() {
-    return [...this.processors];
+  constructor(config = {}) {
+    const logLevel = this.resolveLogLevel(config.logLevel);
+    this.logger = config.logger ?? new chunkA5KDVZDL_cjs.ConsoleLogger({ level: logLevel, name: this.constructor.name });
   }
   /**
-   * Get the logger instance (for exporters and other components)
+   * Set the logger for the exporter (called by Mastra/AITracing during initialization)
    */
-  getLogger() {
-    return this.logger;
+  __setLogger(logger) {
+    this.logger = logger;
+    this.logger.debug(`Logger updated for exporter [name=${this.name}]`);
   }
-  // ============================================================================
-  // Span Lifecycle Management
-  // ============================================================================
   /**
-   * Automatically wires up AI tracing lifecycle events for any span
-   * This ensures all spans emit events regardless of implementation
+   * Convert string log level to LogLevel enum
    */
-  wireSpanLifecycle(span) {
-    if (!this.config.includeInternalSpans && span.isInternal) {
-      return;
-    }
-    const originalEnd = span.end.bind(span);
-    const originalUpdate = span.update.bind(span);
-    span.end = (options) => {
-      if (span.isEvent) {
-        this.logger.warn(`End event is not available on event spans`);
-        return;
-      }
-      originalEnd(options);
-      this.emitSpanEnded(span);
-    };
-    span.update = (options) => {
-      if (span.isEvent) {
-        this.logger.warn(`Update() is not available on event spans`);
-        return;
-      }
-      originalUpdate(options);
-      this.emitSpanUpdated(span);
+  resolveLogLevel(logLevel) {
+    if (!logLevel) {
+      return chunkA5KDVZDL_cjs.LogLevel.INFO;
+    }
+    if (typeof logLevel === "number") {
+      return logLevel;
+    }
+    const logLevelMap = {
+      debug: chunkA5KDVZDL_cjs.LogLevel.DEBUG,
+      info: chunkA5KDVZDL_cjs.LogLevel.INFO,
+      warn: chunkA5KDVZDL_cjs.LogLevel.WARN,
+      error: chunkA5KDVZDL_cjs.LogLevel.ERROR
     };
-  }
-  // ============================================================================
-  // Utility Methods
-  // ============================================================================
-  /**
-   * Check if an AI trace should be sampled
-   */
-  shouldSample(options) {
-    const { sampling } = this.config;
-    switch (sampling.type) {
-      case "always" /* ALWAYS */:
-        return true;
-      case "never" /* NEVER */:
-        return false;
-      case "ratio" /* RATIO */:
-        if (sampling.probability === void 0 || sampling.probability < 0 || sampling.probability > 1) {
-          this.logger.warn(
-            `Invalid sampling probability: ${sampling.probability}. Expected value between 0 and 1. Defaulting to no sampling.`
-          );
-          return false;
-        }
-        return Math.random() < sampling.probability;
-      case "custom" /* CUSTOM */:
-        return sampling.sampler(options);
-      default:
-        throw new Error(`Sampling strategy type not implemented: ${sampling.type}`);
-    }
-  }
-  /**
-   * Process a span through all processors
-   */
-  processSpan(span) {
-    for (const processor of this.processors) {
-      if (!span) {
-        break;
-      }
-      try {
-        span = processor.process(span);
-      } catch (error) {
-        this.logger.error(`[AI Tracing] Processor error [name=${processor.name}]`, error);
-      }
-    }
-    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 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);
-      });
-    }
-  }
-  /**
-   * Emit a span ended event (called automatically when spans end)
-   */
-  emitSpanEnded(span) {
-    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);
-      });
-    }
+    return logLevelMap[logLevel] ?? chunkA5KDVZDL_cjs.LogLevel.INFO;
   }
   /**
-   * Emit a span updated event
+   * Mark the exporter as disabled and log a message
+   *
+   * @param reason - Reason why the exporter is disabled
    */
-  emitSpanUpdated(span) {
-    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);
-      });
-    }
+  setDisabled(reason) {
+    this.isDisabled = true;
+    this.logger.warn(`${this.name} disabled: ${reason}`);
   }
   /**
-   * Export tracing event through all exporters (realtime mode)
+   * Export a tracing event
+   *
+   * This method checks if the exporter is disabled before calling _exportEvent.
+   * Subclasses should implement _exportEvent instead of overriding this method.
    */
   async exportEvent(event) {
-    const exportPromises = this.exporters.map(async (exporter) => {
-      try {
-        if (exporter.exportEvent) {
-          await exporter.exportEvent(event);
-          this.logger.debug(`[AI Tracing] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
-        }
-      } catch (error) {
-        this.logger.error(`[AI Tracing] Export error [exporter=${exporter.name}]`, error);
-      }
-    });
-    await Promise.allSettled(exportPromises);
-  }
-  // ============================================================================
-  // Lifecycle Management
-  // ============================================================================
-  /**
-   * Initialize AI tracing (called by Mastra during component registration)
-   */
-  init() {
-    this.logger.debug(`[AI Tracing] Initialization started [name=${this.name}]`);
-    this.logger.info(`[AI Tracing] Initialized successfully [name=${this.name}]`);
+    if (this.isDisabled) {
+      return;
+    }
+    await this._exportEvent(event);
   }
   /**
-   * Shutdown AI tracing and clean up resources
+   * Shutdown the exporter and clean up resources
+   *
+   * Default implementation just logs. Override to add custom cleanup.
    */
   async shutdown() {
-    this.logger.debug(`[AI Tracing] Shutdown started [name=${this.name}]`);
-    const shutdownPromises = [...this.exporters.map((e) => e.shutdown()), ...this.processors.map((p) => p.shutdown())];
-    await Promise.allSettled(shutdownPromises);
-    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);
+    this.logger.info(`${this.name} shutdown complete`);
   }
 };
 var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
@@ -591,13 +449,27 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
   }
   // Helper to get parameters based on tool type
   getParameters = () => {
-    if (chunkSE4PA467_cjs.isVercelTool(this.originalTool)) {
-      return this.originalTool.parameters ?? zod.z.object({});
+    if (chunkVF676YCO_cjs.isVercelTool(this.originalTool)) {
+      let schema2 = this.originalTool.parameters ?? ("inputSchema" in this.originalTool ? this.originalTool.inputSchema : void 0) ?? zod.z.object({});
+      if (typeof schema2 === "function") {
+        schema2 = schema2();
+      }
+      return schema2;
     }
-    return this.originalTool.inputSchema ?? zod.z.object({});
+    let schema = this.originalTool.inputSchema ?? zod.z.object({});
+    if (typeof schema === "function") {
+      schema = schema();
+    }
+    return schema;
   };
   getOutputSchema = () => {
-    if ("outputSchema" in this.originalTool) return this.originalTool.outputSchema;
+    if ("outputSchema" in this.originalTool) {
+      let schema = this.originalTool.outputSchema;
+      if (typeof schema === "function") {
+        schema = schema();
+      }
+      return schema;
+    }
     return null;
   };
   // For provider-defined tools, we need to include all required properties
@@ -610,8 +482,8 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
         id: tool.id,
         args: "args" in this.originalTool ? this.originalTool.args : {},
         description: tool.description,
-        parameters: schemaCompat.convertZodSchemaToAISDKSchema(parameters),
-        ...outputSchema ? { outputSchema: schemaCompat.convertZodSchemaToAISDKSchema(outputSchema) } : {},
+        parameters: parameters.jsonSchema ? parameters : schemaCompat.convertZodSchemaToAISDKSchema(parameters),
+        ...outputSchema ? { outputSchema: outputSchema.jsonSchema ? outputSchema : schemaCompat.convertZodSchemaToAISDKSchema(outputSchema) } : {},
         execute: this.originalTool.execute ? this.createExecute(
           this.originalTool,
           { ...this.options, description: this.originalTool.description },
@@ -648,7 +520,8 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
       type: logType
     });
     const execFunction = async (args, execOptions) => {
-      const toolSpan = options.tracingContext?.currentSpan?.createChildSpan({
+      const tracingContext = execOptions.tracingContext || options.tracingContext;
+      const toolSpan = tracingContext?.currentSpan?.createChildSpan({
         type: "tool_call" /* TOOL_CALL */,
         name: `tool: '${options.name}'`,
         input: args,
@@ -661,7 +534,7 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
       });
       try {
         let result;
-        if (chunkSE4PA467_cjs.isVercelTool(tool)) {
+        if (chunkVF676YCO_cjs.isVercelTool(tool)) {
           result = await tool?.execute?.(args, execOptions);
         } else {
           const wrappedMastra = options.mastra ? wrapMastra(options.mastra, { currentSpan: toolSpan }) : options.mastra;
@@ -674,7 +547,7 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
               memory: options.memory,
               runId: options.runId,
               runtimeContext: options.runtimeContext ?? new chunkGPWMM745_cjs.RuntimeContext(),
-              writer: new chunkOXAN5SM7_cjs.ToolStream(
+              writer: new chunkLRSB62Z6_cjs.ToolStream(
                 {
                   prefix: "tool",
                   callId: execOptions.toolCallId,
@@ -700,7 +573,7 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
       try {
         logger2.debug(start, { ...rest, model: logModelObject, args });
         const parameters = this.getParameters();
-        const { data, error: error2 } = chunkSE4PA467_cjs.validateToolInput(parameters, args, options.name);
+        const { data, error: error2 } = chunkVF676YCO_cjs.validateToolInput(parameters, args, options.name);
         if (error2) {
           logger2.warn(`Tool input validation failed for '${options.name}'`, {
             toolName: options.name,
@@ -745,13 +618,25 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
     if (!builtTool.parameters) {
       throw new Error("Tool parameters are required");
     }
-    return {
+    const base = {
       ...builtTool,
       inputSchema: builtTool.parameters,
       onInputStart: "onInputStart" in this.originalTool ? this.originalTool.onInputStart : void 0,
       onInputDelta: "onInputDelta" in this.originalTool ? this.originalTool.onInputDelta : void 0,
       onInputAvailable: "onInputAvailable" in this.originalTool ? this.originalTool.onInputAvailable : void 0
     };
+    if (builtTool.type === "provider-defined") {
+      const { execute, parameters, ...rest } = base;
+      const name = builtTool.id.split(".")[1] || builtTool.id;
+      return {
+        ...rest,
+        type: builtTool.type,
+        id: builtTool.id,
+        name,
+        args: builtTool.args
+      };
+    }
+    return base;
   }
   build() {
     const providerTool = this.buildProviderTool(this.originalTool);
@@ -932,7 +817,7 @@ function createDeterministicId(input) {
   return crypto$1.createHash("sha256").update(input).digest("hex").slice(0, 8);
 }
 function setVercelToolProperties(tool) {
-  const inputSchema = convertVercelToolParameters(tool);
+  const inputSchema = "inputSchema" in tool ? tool.inputSchema : convertVercelToolParameters(tool);
   const toolId = !("id" in tool) ? tool.description ? `tool-${createDeterministicId(tool.description)}` : `tool-${Math.random().toString(36).substring(2, 9)}` : tool.id;
   return {
     ...tool,
@@ -944,7 +829,7 @@ function ensureToolProperties(tools) {
   const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
     const tool = tools?.[key];
     if (tool) {
-      if (chunkSE4PA467_cjs.isVercelTool(tool)) {
+      if (chunkVF676YCO_cjs.isVercelTool(tool)) {
         acc[key] = setVercelToolProperties(tool);
       } else {
         acc[key] = tool;
@@ -955,7 +840,10 @@ function ensureToolProperties(tools) {
   return toolsWithProperties;
 }
 function convertVercelToolParameters(tool) {
-  const schema = tool.parameters ?? zod.z.object({});
+  let schema = tool.parameters ?? zod.z.object({});
+  if (typeof schema === "function") {
+    schema = schema();
+  }
   return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod__default.default(schema));
 }
 function makeCoreTool(originalTool, options, logType) {
@@ -1100,42 +988,36 @@ async function fetchWithRetry(url, options = {}, maxRetries = 3) {
 }
 
 // src/ai-tracing/exporters/cloud.ts
-var CloudExporter = class {
+var CloudExporter = class extends BaseExporter {
   name = "mastra-cloud-ai-tracing-exporter";
   config;
   buffer;
   flushTimer = null;
-  logger;
-  isDisabled = false;
   constructor(config = {}) {
-    this.logger = config.logger ?? new chunkA5KDVZDL_cjs.ConsoleLogger({ level: chunkA5KDVZDL_cjs.LogLevel.INFO });
+    super(config);
     const accessToken = config.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
     if (!accessToken) {
-      this.logger.debug(
-        "CloudExporter disabled: MASTRA_CLOUD_ACCESS_TOKEN environment variable not set. \u{1F680} Sign up for Mastra Cloud at https://cloud.mastra.ai to see your AI traces online and obtain your access token."
+      this.setDisabled(
+        "MASTRA_CLOUD_ACCESS_TOKEN environment variable not set. \u{1F680} Sign up for Mastra Cloud at https://cloud.mastra.ai to see your AI traces online and obtain your access token."
       );
-      this.isDisabled = true;
     }
     const endpoint = config.endpoint ?? process.env.MASTRA_CLOUD_AI_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
     this.config = {
+      logger: this.logger,
+      logLevel: config.logLevel ?? chunkA5KDVZDL_cjs.LogLevel.INFO,
       maxBatchSize: config.maxBatchSize ?? 1e3,
       maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
       maxRetries: config.maxRetries ?? 3,
       accessToken: accessToken || "",
-      // Empty string if no token
-      endpoint,
-      logger: this.logger
+      endpoint
     };
     this.buffer = {
       spans: [],
       totalSize: 0
     };
   }
-  async exportEvent(event) {
-    if (this.isDisabled) {
-      return;
-    }
-    if (event.type !== "span_ended" /* SPAN_ENDED */) {
+  async _exportEvent(event) {
+    if (event.type !== "span_ended" /* SPAN_ENDED */) {
       return;
     }
     this.addToBuffer(event);
@@ -1248,7 +1130,6 @@ var CloudExporter = class {
    * Uploads spans to cloud API using fetchWithRetry for all retry logic
    */
   async batchUpload(spans) {
-    const url = `${this.config.endpoint}`;
     const headers = {
       Authorization: `Bearer ${this.config.accessToken}`,
       "Content-Type": "application/json"
@@ -1258,7 +1139,7 @@ var CloudExporter = class {
       headers,
       body: JSON.stringify({ spans })
     };
-    await fetchWithRetry(url, options, this.config.maxRetries);
+    await fetchWithRetry(this.config.endpoint, options, this.config.maxRetries);
   }
   resetBuffer() {
     this.buffer.spans = [];
@@ -1300,17 +1181,12 @@ var CloudExporter = class {
 };
 
 // src/ai-tracing/exporters/console.ts
-var ConsoleExporter = class {
+var ConsoleExporter = class extends BaseExporter {
   name = "tracing-console-exporter";
-  logger;
-  constructor(logger) {
-    if (logger) {
-      this.logger = logger;
-    } else {
-      this.logger = new chunkA5KDVZDL_cjs.ConsoleLogger({ level: chunkA5KDVZDL_cjs.LogLevel.INFO });
-    }
+  constructor(config = {}) {
+    super(config);
   }
-  async exportEvent(event) {
+  async _exportEvent(event) {
     const span = event.exportedSpan;
     const formatAttributes = (attributes) => {
       try {
@@ -2197,10 +2073,10 @@ function getValidTraceId(span) {
   return span?.isValid ? span.traceId : void 0;
 }
 function getOrCreateSpan(options) {
-  const { type, attributes, tracingContext, runtimeContext, ...rest } = options;
+  const { type, attributes, tracingContext, runtimeContext, tracingOptions, ...rest } = options;
   const metadata = {
     ...rest.metadata ?? {},
-    ...rest.tracingOptions?.metadata ?? {}
+    ...tracingOptions?.metadata ?? {}
   };
   if (tracingContext?.currentSpan) {
     return tracingContext.currentSpan.createChildSpan({
@@ -2218,6 +2094,10 @@ function getOrCreateSpan(options) {
     attributes,
     ...rest,
     metadata,
+    runtimeContext,
+    tracingOptions,
+    traceId: tracingOptions?.traceId,
+    parentSpanId: tracingOptions?.parentSpanId,
     customSamplerOptions: {
       runtimeContext,
       metadata
@@ -2225,6 +2105,322 @@ function getOrCreateSpan(options) {
   });
 }
 
+// src/ai-tracing/tracers/base.ts
+var BaseAITracing = class extends chunk6VOPKVYH_cjs.MastraBase {
+  config;
+  constructor(config) {
+    super({ component: chunkA5KDVZDL_cjs.RegisteredLogger.AI_TRACING, name: config.serviceName });
+    this.config = {
+      serviceName: config.serviceName,
+      name: config.name,
+      sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
+      exporters: config.exporters ?? [],
+      processors: config.processors ?? [],
+      includeInternalSpans: config.includeInternalSpans ?? false,
+      runtimeContextKeys: config.runtimeContextKeys ?? []
+    };
+  }
+  /**
+   * Override setLogger to add AI tracing specific initialization log
+   * and propagate logger to exporters
+   */
+  __setLogger(logger) {
+    super.__setLogger(logger);
+    this.exporters.forEach((exporter) => {
+      if (typeof exporter.__setLogger === "function") {
+        exporter.__setLogger(logger);
+      }
+    });
+    this.logger.debug(
+      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
+    );
+  }
+  // ============================================================================
+  // Protected getters for clean config access
+  // ============================================================================
+  get exporters() {
+    return this.config.exporters || [];
+  }
+  get processors() {
+    return this.config.processors || [];
+  }
+  // ============================================================================
+  // Public API - Single type-safe span creation method
+  // ============================================================================
+  /**
+   * Start a new span of a specific AISpanType
+   */
+  startSpan(options) {
+    const { customSamplerOptions, runtimeContext, metadata, tracingOptions, ...rest } = options;
+    if (!this.shouldSample(customSamplerOptions)) {
+      return new NoOpAISpan({ ...rest, metadata }, this);
+    }
+    let traceState;
+    if (options.parent) {
+      traceState = options.parent.traceState;
+    } else {
+      traceState = this.computeTraceState(tracingOptions);
+    }
+    const enrichedMetadata = this.extractMetadataFromRuntimeContext(runtimeContext, metadata, traceState);
+    const span = this.createSpan({
+      ...rest,
+      metadata: enrichedMetadata,
+      traceState
+    });
+    if (span.isEvent) {
+      this.emitSpanEnded(span);
+    } else {
+      this.wireSpanLifecycle(span);
+      this.emitSpanStarted(span);
+    }
+    return span;
+  }
+  // ============================================================================
+  // Configuration Management
+  // ============================================================================
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  // ============================================================================
+  // Plugin Access
+  // ============================================================================
+  /**
+   * Get all exporters
+   */
+  getExporters() {
+    return [...this.exporters];
+  }
+  /**
+   * Get all processors
+   */
+  getProcessors() {
+    return [...this.processors];
+  }
+  /**
+   * Get the logger instance (for exporters and other components)
+   */
+  getLogger() {
+    return this.logger;
+  }
+  // ============================================================================
+  // Span Lifecycle Management
+  // ============================================================================
+  /**
+   * Automatically wires up AI tracing lifecycle events for any span
+   * 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) => {
+      if (span.isEvent) {
+        this.logger.warn(`End event is not available on event spans`);
+        return;
+      }
+      originalEnd(options);
+      this.emitSpanEnded(span);
+    };
+    span.update = (options) => {
+      if (span.isEvent) {
+        this.logger.warn(`Update() is not available on event spans`);
+        return;
+      }
+      originalUpdate(options);
+      this.emitSpanUpdated(span);
+    };
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Check if an AI trace should be sampled
+   */
+  shouldSample(options) {
+    const { sampling } = this.config;
+    switch (sampling.type) {
+      case "always" /* ALWAYS */:
+        return true;
+      case "never" /* NEVER */:
+        return false;
+      case "ratio" /* RATIO */:
+        if (sampling.probability === void 0 || sampling.probability < 0 || sampling.probability > 1) {
+          this.logger.warn(
+            `Invalid sampling probability: ${sampling.probability}. Expected value between 0 and 1. Defaulting to no sampling.`
+          );
+          return false;
+        }
+        return Math.random() < sampling.probability;
+      case "custom" /* CUSTOM */:
+        return sampling.sampler(options);
+      default:
+        throw new Error(`Sampling strategy type not implemented: ${sampling.type}`);
+    }
+  }
+  /**
+   * Compute TraceState for a new trace based on configured and per-request keys
+   */
+  computeTraceState(tracingOptions) {
+    const configuredKeys = this.config.runtimeContextKeys ?? [];
+    const additionalKeys = tracingOptions?.runtimeContextKeys ?? [];
+    const allKeys = [...configuredKeys, ...additionalKeys];
+    if (allKeys.length === 0) {
+      return void 0;
+    }
+    return {
+      runtimeContextKeys: allKeys
+    };
+  }
+  /**
+   * Extract metadata from RuntimeContext using TraceState
+   */
+  extractMetadataFromRuntimeContext(runtimeContext, explicitMetadata, traceState) {
+    if (!runtimeContext || !traceState || traceState.runtimeContextKeys.length === 0) {
+      return explicitMetadata;
+    }
+    const extracted = this.extractKeys(runtimeContext, traceState.runtimeContextKeys);
+    if (Object.keys(extracted).length === 0 && !explicitMetadata) {
+      return void 0;
+    }
+    return {
+      ...extracted,
+      ...explicitMetadata
+      // Explicit metadata always wins
+    };
+  }
+  /**
+   * Extract specific keys from RuntimeContext
+   */
+  extractKeys(runtimeContext, keys) {
+    const result = {};
+    for (const key of keys) {
+      const parts = key.split(".");
+      const rootKey = parts[0];
+      const value = runtimeContext.get(rootKey);
+      if (value !== void 0) {
+        if (parts.length > 1) {
+          const nestedPath = parts.slice(1).join(".");
+          const nestedValue = getNestedValue(value, nestedPath);
+          if (nestedValue !== void 0) {
+            setNestedValue(result, key, nestedValue);
+          }
+        } else {
+          setNestedValue(result, key, value);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Process a span through all processors
+   */
+  processSpan(span) {
+    for (const processor of this.processors) {
+      if (!span) {
+        break;
+      }
+      try {
+        span = processor.process(span);
+      } catch (error) {
+        this.logger.error(`[AI Tracing] Processor error [name=${processor.name}]`, error);
+      }
+    }
+    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 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);
+      });
+    }
+  }
+  /**
+   * Emit a span ended event (called automatically when spans end)
+   */
+  emitSpanEnded(span) {
+    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);
+      });
+    }
+  }
+  /**
+   * Emit a span updated event
+   */
+  emitSpanUpdated(span) {
+    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);
+      });
+    }
+  }
+  /**
+   * Export tracing event through all exporters (realtime mode)
+   */
+  async exportEvent(event) {
+    const exportPromises = this.exporters.map(async (exporter) => {
+      try {
+        if (exporter.exportEvent) {
+          await exporter.exportEvent(event);
+          this.logger.debug(`[AI Tracing] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
+        }
+      } catch (error) {
+        this.logger.error(`[AI Tracing] Export error [exporter=${exporter.name}]`, error);
+      }
+    });
+    await Promise.allSettled(exportPromises);
+  }
+  // ============================================================================
+  // Lifecycle Management
+  // ============================================================================
+  /**
+   * Initialize AI tracing (called by Mastra during component registration)
+   */
+  init() {
+    this.logger.debug(`[AI Tracing] Initialization started [name=${this.name}]`);
+    this.logger.info(`[AI Tracing] Initialized successfully [name=${this.name}]`);
+  }
+  /**
+   * Shutdown AI tracing and clean up resources
+   */
+  async shutdown() {
+    this.logger.debug(`[AI Tracing] Shutdown started [name=${this.name}]`);
+    const shutdownPromises = [...this.exporters.map((e) => e.shutdown()), ...this.processors.map((p) => p.shutdown())];
+    await Promise.allSettled(shutdownPromises);
+    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);
+  }
+};
+
 // src/ai-tracing/context.ts
 var AGENT_GETTERS = ["getAgent", "getAgentById"];
 var AGENT_METHODS_TO_WRAP = ["generate", "stream", "generateLegacy", "streamLegacy"];
@@ -2371,17 +2567,284 @@ function wrapRun(run, tracingContext) {
     return run;
   }
 }
+var ModelSpanTracker = class {
+  modelSpan;
+  currentStepSpan;
+  currentChunkSpan;
+  accumulator = {};
+  stepIndex = 0;
+  chunkSequence = 0;
+  constructor(modelSpan) {
+    this.modelSpan = modelSpan;
+  }
+  /**
+   * Start a new Model execution step
+   */
+  startStepSpan(payload) {
+    this.currentStepSpan = this.modelSpan?.createChildSpan({
+      name: `step: ${this.stepIndex}`,
+      type: "llm_step" /* LLM_STEP */,
+      attributes: {
+        stepIndex: this.stepIndex,
+        ...payload?.messageId ? { messageId: payload.messageId } : {},
+        ...payload?.warnings?.length ? { warnings: payload.warnings } : {}
+      },
+      input: payload?.request
+    });
+    this.chunkSequence = 0;
+  }
+  /**
+   * End the current Model execution step with token usage, finish reason, output, and metadata
+   */
+  endStepSpan(payload) {
+    if (!this.currentStepSpan) return;
+    const output = payload.output;
+    const { usage, ...otherOutput } = output;
+    const stepResult = payload.stepResult;
+    const metadata = payload.metadata;
+    const cleanMetadata = metadata ? { ...metadata } : void 0;
+    if (cleanMetadata?.request) {
+      delete cleanMetadata.request;
+    }
+    this.currentStepSpan.end({
+      output: otherOutput,
+      attributes: {
+        usage,
+        isContinued: stepResult.isContinued,
+        finishReason: stepResult.reason,
+        warnings: stepResult.warnings
+      },
+      metadata: {
+        ...cleanMetadata
+      }
+    });
+    this.currentStepSpan = void 0;
+    this.stepIndex++;
+  }
+  /**
+   * Create a new chunk span (for multi-part chunks like text-start/delta/end)
+   */
+  startChunkSpan(chunkType, initialData) {
+    if (!this.currentStepSpan) {
+      this.startStepSpan();
+    }
+    this.currentChunkSpan = this.currentStepSpan?.createChildSpan({
+      name: `chunk: '${chunkType}'`,
+      type: "llm_chunk" /* LLM_CHUNK */,
+      attributes: {
+        chunkType,
+        sequenceNumber: this.chunkSequence
+      }
+    });
+    this.accumulator = initialData || {};
+  }
+  /**
+   * Append string content to a specific field in the accumulator
+   */
+  appendToAccumulator(field, text) {
+    if (this.accumulator[field] === void 0) {
+      this.accumulator[field] = text;
+    } else {
+      this.accumulator[field] += text;
+    }
+  }
+  /**
+   * End the current chunk span.
+   * Safe to call multiple times - will no-op if span already ended.
+   */
+  endChunkSpan(output) {
+    if (!this.currentChunkSpan) return;
+    this.currentChunkSpan.end({
+      output: output !== void 0 ? output : this.accumulator
+    });
+    this.currentChunkSpan = void 0;
+    this.accumulator = {};
+    this.chunkSequence++;
+  }
+  /**
+   * Create an event span (for single chunks like tool-call)
+   */
+  createEventSpan(chunkType, output) {
+    if (!this.currentStepSpan) {
+      this.startStepSpan();
+    }
+    const span = this.currentStepSpan?.createEventSpan({
+      name: `chunk: '${chunkType}'`,
+      type: "llm_chunk" /* LLM_CHUNK */,
+      attributes: {
+        chunkType,
+        sequenceNumber: this.chunkSequence
+      },
+      output
+    });
+    if (span) {
+      this.chunkSequence++;
+    }
+  }
+  /**
+   * Check if there is currently an active chunk span
+   */
+  hasActiveChunkSpan() {
+    return !!this.currentChunkSpan;
+  }
+  /**
+   * Get the current accumulator value
+   */
+  getAccumulator() {
+    return this.accumulator;
+  }
+  /**
+   * Get the current step span (for making tool calls children of steps)
+   */
+  getCurrentStepSpan() {
+    return this.currentStepSpan;
+  }
+  /**
+   * Wraps a stream with model tracing transform to track LLM_STEP and LLM_CHUNK spans.
+   *
+   * This should be added to the stream pipeline to automatically
+   * create LLM_STEP and LLM_CHUNK spans for each semantic unit in the stream.
+   */
+  wrapStream(stream) {
+    const tracker = this;
+    return stream.pipeThrough(
+      new web.TransformStream({
+        transform(chunk, controller) {
+          controller.enqueue(chunk);
+          switch (chunk.type) {
+            case "text-start":
+            case "text-delta":
+            case "text-end":
+              handleTextChunk(chunk, tracker);
+              break;
+            case "tool-call-input-streaming-start":
+            case "tool-call-delta":
+            case "tool-call-input-streaming-end":
+            case "tool-call":
+              handleToolCallChunk(chunk, tracker);
+              break;
+            case "reasoning-start":
+            case "reasoning-delta":
+            case "reasoning-end":
+              handleReasoningChunk(chunk, tracker);
+              break;
+            case "object":
+            case "object-result":
+              handleObjectChunk(chunk, tracker);
+              break;
+            case "step-start":
+              tracker.startStepSpan(chunk.payload);
+              break;
+            case "step-finish":
+              tracker.endStepSpan(chunk.payload);
+              break;
+            case "raw":
+            // Skip raw chunks as they're redundant
+            case "start":
+            case "finish":
+              break;
+            // Default: auto-create event span for all other chunk types
+            default: {
+              let outputPayload = chunk.payload;
+              if (outputPayload && typeof outputPayload === "object" && "data" in outputPayload) {
+                const typedPayload = outputPayload;
+                outputPayload = { ...typedPayload };
+                if (typedPayload.data) {
+                  outputPayload.size = typeof typedPayload.data === "string" ? typedPayload.data.length : typedPayload.data instanceof Uint8Array ? typedPayload.data.length : void 0;
+                  delete outputPayload.data;
+                }
+              }
+              tracker.createEventSpan(chunk.type, outputPayload);
+              break;
+            }
+          }
+        }
+      })
+    );
+  }
+};
+function handleTextChunk(chunk, tracker) {
+  switch (chunk.type) {
+    case "text-start":
+      tracker.startChunkSpan("text");
+      break;
+    case "text-delta":
+      tracker.appendToAccumulator("text", chunk.payload.text);
+      break;
+    case "text-end": {
+      tracker.endChunkSpan();
+      break;
+    }
+  }
+}
+function handleReasoningChunk(chunk, tracker) {
+  switch (chunk.type) {
+    case "reasoning-start":
+      tracker.startChunkSpan("reasoning");
+      break;
+    case "reasoning-delta":
+      tracker.appendToAccumulator("text", chunk.payload.text);
+      break;
+    case "reasoning-end": {
+      tracker.endChunkSpan();
+      break;
+    }
+  }
+}
+function handleToolCallChunk(chunk, tracker) {
+  switch (chunk.type) {
+    case "tool-call-input-streaming-start":
+      tracker.startChunkSpan("tool-call", {
+        toolName: chunk.payload.toolName,
+        toolCallId: chunk.payload.toolCallId
+      });
+      break;
+    case "tool-call-delta":
+      tracker.appendToAccumulator("toolInput", chunk.payload.argsTextDelta);
+      break;
+    case "tool-call-input-streaming-end":
+    case "tool-call": {
+      const acc = tracker.getAccumulator();
+      let toolInput;
+      try {
+        toolInput = acc.toolInput ? JSON.parse(acc.toolInput) : {};
+      } catch {
+        toolInput = acc.toolInput;
+      }
+      tracker.endChunkSpan({
+        toolName: acc.toolName,
+        toolCallId: acc.toolCallId,
+        toolInput
+      });
+      break;
+    }
+  }
+}
+function handleObjectChunk(chunk, tracker) {
+  switch (chunk.type) {
+    case "object":
+      if (!tracker.hasActiveChunkSpan()) {
+        tracker.startChunkSpan("object");
+      }
+      break;
+    case "object-result":
+      tracker.endChunkSpan(chunk.object);
+      break;
+  }
+}
 
 exports.AISpanType = AISpanType;
 exports.AITracingEventType = AITracingEventType;
 exports.BaseAISpan = BaseAISpan;
 exports.BaseAITracing = BaseAITracing;
+exports.BaseExporter = BaseExporter;
 exports.CloudExporter = CloudExporter;
 exports.ConsoleExporter = ConsoleExporter;
 exports.DefaultAISpan = DefaultAISpan;
 exports.DefaultAITracing = DefaultAITracing;
 exports.DefaultExporter = DefaultExporter;
 exports.InternalSpans = InternalSpans;
+exports.ModelSpanTracker = ModelSpanTracker;
 exports.NoOpAISpan = NoOpAISpan;
 exports.SamplingStrategyType = SamplingStrategyType;
 exports.SensitiveDataFilter = SensitiveDataFilter;
@@ -2397,6 +2860,7 @@ exports.generateEmptyFromSchema = generateEmptyFromSchema;
 exports.getAITracing = getAITracing;
 exports.getAllAITracing = getAllAITracing;
 exports.getDefaultAITracing = getDefaultAITracing;
+exports.getNestedValue = getNestedValue;
 exports.getOrCreateSpan = getOrCreateSpan;
 exports.getSelectedAITracing = getSelectedAITracing;
 exports.getValidTraceId = getValidTraceId;
@@ -2414,10 +2878,11 @@ exports.parseSqlIdentifier = parseSqlIdentifier;
 exports.registerAITracing = registerAITracing;
 exports.resolveSerializedZodOutput = resolveSerializedZodOutput;
 exports.selectFields = selectFields;
+exports.setNestedValue = setNestedValue;
 exports.setSelector = setSelector;
 exports.setupAITracing = setupAITracing;
 exports.shutdownAITracingRegistry = shutdownAITracingRegistry;
 exports.unregisterAITracing = unregisterAITracing;
 exports.wrapMastra = wrapMastra;
-//# sourceMappingURL=chunk-44ODA6L3.cjs.map
-//# sourceMappingURL=chunk-44ODA6L3.cjs.map
+//# sourceMappingURL=chunk-5GIAZ3CH.cjs.map
+//# sourceMappingURL=chunk-5GIAZ3CH.cjs.map