@mastra/core 0.16.2-alpha.0 → 0.16.3-alpha.0

package/dist/{chunk-2NKNTPFR.js → chunk-W5K2KOZX.js}

@@ -1,6 +1,13 @@
+import { RuntimeContext } from './chunk-HLRWYUFN.js';
 import { MastraError } from './chunk-MCOVMKIS.js';
+import { ToolStream } from './chunk-YW7UILPE.js';
+import { isVercelTool, validateToolInput } from './chunk-BJGHUKKM.js';
 import { MastraBase } from './chunk-6GF5M4GX.js';
-import { ConsoleLogger, LogLevel, RegisteredLogger } from './chunk-X3GXU6TZ.js';
+import { RegisteredLogger, ConsoleLogger, LogLevel } from './chunk-X3GXU6TZ.js';
+import { createHash } from 'crypto';
+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 {
@@ -47,6 +54,9 @@ var NoOpAISpan = class _NoOpAISpan {
   get isRootSpan() {
     return !this.parent;
   }
+  get isValid() {
+    return false;
+  }
 };
 
 // src/ai-tracing/types.ts
@@ -88,7 +98,7 @@ var MastraAITracing = class extends MastraBase {
     super({ component: RegisteredLogger.AI_TRACING, name: config.serviceName });
     this.config = {
       serviceName: config.serviceName,
-      instanceName: config.instanceName,
+      name: config.name,
       sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
       exporters: config.exporters ?? [],
       processors: config.processors ?? []
@@ -100,7 +110,7 @@ var MastraAITracing = class extends MastraBase {
   __setLogger(logger) {
     super.__setLogger(logger);
     this.logger.debug(
-      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.instanceName}] [sampling=${this.config.sampling.type}]`
+      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
     );
   }
   // ============================================================================
@@ -187,10 +197,18 @@ var MastraAITracing = class extends MastraBase {
     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);
     };
@@ -311,6 +329,718 @@ var MastraAITracing = class extends MastraBase {
     this.logger.info(`[AI Tracing] Shutdown completed [name=${this.name}]`);
   }
 };
+var CoreToolBuilder = class extends MastraBase {
+  originalTool;
+  options;
+  logType;
+  constructor(input) {
+    super({ name: "CoreToolBuilder" });
+    this.originalTool = input.originalTool;
+    this.options = input.options;
+    this.logType = input.logType;
+  }
+  // Helper to get parameters based on tool type
+  getParameters = () => {
+    if (isVercelTool(this.originalTool)) {
+      return this.originalTool.parameters ?? z.object({});
+    }
+    return this.originalTool.inputSchema ?? z.object({});
+  };
+  getOutputSchema = () => {
+    if ("outputSchema" in this.originalTool) return this.originalTool.outputSchema;
+    return null;
+  };
+  // For provider-defined tools, we need to include all required properties
+  buildProviderTool(tool) {
+    if ("type" in tool && tool.type === "provider-defined" && "id" in tool && typeof tool.id === "string" && tool.id.includes(".")) {
+      const parameters = this.getParameters();
+      const outputSchema = this.getOutputSchema();
+      return {
+        type: "provider-defined",
+        id: tool.id,
+        args: "args" in this.originalTool ? this.originalTool.args : {},
+        description: tool.description,
+        parameters: convertZodSchemaToAISDKSchema(parameters),
+        ...outputSchema ? { outputSchema: convertZodSchemaToAISDKSchema(outputSchema) } : {},
+        execute: this.originalTool.execute ? this.createExecute(
+          this.originalTool,
+          { ...this.options, description: this.originalTool.description },
+          this.logType
+        ) : void 0
+      };
+    }
+    return void 0;
+  }
+  createLogMessageOptions({ agentName, toolName, type }) {
+    if (!agentName) {
+      return {
+        start: `Executing tool ${toolName}`,
+        error: `Failed tool execution`
+      };
+    }
+    const prefix = `[Agent:${agentName}]`;
+    const toolType = type === "toolset" ? "toolset" : "tool";
+    return {
+      start: `${prefix} - Executing ${toolType} ${toolName}`,
+      error: `${prefix} - Failed ${toolType} execution`
+    };
+  }
+  createExecute(tool, options, logType) {
+    const { logger, mastra: _mastra, memory: _memory, runtimeContext, ...rest } = options;
+    const { start, error } = this.createLogMessageOptions({
+      agentName: options.agentName,
+      toolName: options.name,
+      type: logType
+    });
+    const execFunction = async (args, execOptions) => {
+      const toolSpan = options.tracingContext?.currentSpan?.createChildSpan({
+        type: "tool_call" /* TOOL_CALL */,
+        name: `tool: '${options.name}'`,
+        input: args,
+        attributes: {
+          toolId: options.name,
+          toolDescription: options.description,
+          toolType: logType || "tool"
+        }
+      });
+      try {
+        let result;
+        if (isVercelTool(tool)) {
+          result = await tool?.execute?.(args, execOptions);
+        } else {
+          const wrappedMastra = options.mastra ? wrapMastra(options.mastra, { currentSpan: toolSpan }) : options.mastra;
+          result = await tool?.execute?.(
+            {
+              context: args,
+              threadId: options.threadId,
+              resourceId: options.resourceId,
+              mastra: wrappedMastra,
+              memory: options.memory,
+              runId: options.runId,
+              runtimeContext: options.runtimeContext ?? new RuntimeContext(),
+              writer: new ToolStream(
+                {
+                  prefix: "tool",
+                  callId: execOptions.toolCallId,
+                  name: options.name,
+                  runId: options.runId
+                },
+                options.writableStream || execOptions.writableStream
+              ),
+              tracingContext: { currentSpan: toolSpan }
+            },
+            execOptions
+          );
+        }
+        toolSpan?.end({ output: result });
+        return result ?? void 0;
+      } catch (error2) {
+        toolSpan?.error({ error: error2 });
+        throw error2;
+      }
+    };
+    return async (args, execOptions) => {
+      let logger2 = options.logger || this.logger;
+      try {
+        logger2.debug(start, { ...rest, args });
+        const parameters = this.getParameters();
+        const { data, error: error2 } = validateToolInput(parameters, args, options.name);
+        if (error2) {
+          logger2.warn(`Tool input validation failed for '${options.name}'`, {
+            toolName: options.name,
+            errors: error2.validationErrors,
+            args
+          });
+          return error2;
+        }
+        args = data;
+        return await new Promise((resolve, reject) => {
+          setImmediate(async () => {
+            try {
+              const result = await execFunction(args, execOptions);
+              resolve(result);
+            } catch (err) {
+              reject(err);
+            }
+          });
+        });
+      } catch (err) {
+        const mastraError = new MastraError(
+          {
+            id: "TOOL_EXECUTION_FAILED",
+            domain: "TOOL" /* TOOL */,
+            category: "USER" /* USER */,
+            details: {
+              errorMessage: String(error),
+              argsJson: JSON.stringify(args),
+              model: rest.model?.modelId ?? ""
+            }
+          },
+          err
+        );
+        logger2.trackException(mastraError);
+        logger2.error(error, { ...rest, error: mastraError, args });
+        return mastraError;
+      }
+    };
+  }
+  buildV5() {
+    const builtTool = this.build();
+    if (!builtTool.parameters) {
+      throw new Error("Tool parameters are required");
+    }
+    return {
+      ...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
+    };
+  }
+  build() {
+    const providerTool = this.buildProviderTool(this.originalTool);
+    if (providerTool) {
+      return providerTool;
+    }
+    const definition = {
+      type: "function",
+      description: this.originalTool.description,
+      parameters: this.getParameters(),
+      outputSchema: this.getOutputSchema(),
+      execute: this.originalTool.execute ? this.createExecute(
+        this.originalTool,
+        { ...this.options, description: this.originalTool.description },
+        this.logType
+      ) : void 0
+    };
+    const model = this.options.model;
+    const schemaCompatLayers = [];
+    if (model) {
+      const supportsStructuredOutputs = model.specificationVersion !== "v2" ? model.supportsStructuredOutputs ?? false : false;
+      const modelInfo = {
+        modelId: model.modelId,
+        supportsStructuredOutputs,
+        provider: model.provider
+      };
+      schemaCompatLayers.push(
+        new OpenAIReasoningSchemaCompatLayer(modelInfo),
+        new OpenAISchemaCompatLayer(modelInfo),
+        new GoogleSchemaCompatLayer(modelInfo),
+        new AnthropicSchemaCompatLayer(modelInfo),
+        new DeepSeekSchemaCompatLayer(modelInfo),
+        new MetaSchemaCompatLayer(modelInfo)
+      );
+    }
+    const processedSchema = applyCompatLayer({
+      schema: this.getParameters(),
+      compatLayers: schemaCompatLayers,
+      mode: "aiSdkSchema"
+    });
+    let processedOutputSchema;
+    if (this.getOutputSchema()) {
+      processedOutputSchema = applyCompatLayer({
+        schema: this.getOutputSchema(),
+        compatLayers: schemaCompatLayers,
+        mode: "aiSdkSchema"
+      });
+    }
+    return {
+      ...definition,
+      id: "id" in this.originalTool ? this.originalTool.id : void 0,
+      parameters: processedSchema,
+      outputSchema: processedOutputSchema
+    };
+  }
+};
+
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (!source) return output;
+  Object.keys(source).forEach((key) => {
+    const targetValue = output[key];
+    const sourceValue = source[key];
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      output[key] = sourceValue;
+    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
+      output[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== void 0) {
+      output[key] = sourceValue;
+    }
+  });
+  return output;
+}
+function generateEmptyFromSchema(schema) {
+  try {
+    const parsedSchema = JSON.parse(schema);
+    if (!parsedSchema || parsedSchema.type !== "object" || !parsedSchema.properties) return {};
+    const obj = {};
+    const TYPE_DEFAULTS = {
+      string: "",
+      array: [],
+      object: {},
+      number: 0,
+      integer: 0,
+      boolean: false
+    };
+    for (const [key, prop] of Object.entries(parsedSchema.properties)) {
+      obj[key] = TYPE_DEFAULTS[prop.type] ?? null;
+    }
+    return obj;
+  } catch {
+    return {};
+  }
+}
+async function* maskStreamTags(stream, tag, options = {}) {
+  const { onStart, onEnd, onMask } = options;
+  const openTag = `<${tag}>`;
+  const closeTag = `</${tag}>`;
+  let buffer = "";
+  let fullContent = "";
+  let isMasking = false;
+  let isBuffering = false;
+  const trimOutsideDelimiter = (text, delimiter, trim) => {
+    if (!text.includes(delimiter)) {
+      return text;
+    }
+    const parts = text.split(delimiter);
+    if (trim === `before-start`) {
+      return `${delimiter}${parts[1]}`;
+    }
+    return `${parts[0]}${delimiter}`;
+  };
+  const startsWith = (text, pattern) => {
+    if (pattern.includes(openTag.substring(0, 3))) {
+      pattern = trimOutsideDelimiter(pattern, `<`, `before-start`);
+    }
+    return text.trim().startsWith(pattern.trim());
+  };
+  for await (const chunk of stream) {
+    fullContent += chunk;
+    if (isBuffering) buffer += chunk;
+    const chunkHasTag = startsWith(chunk, openTag);
+    const bufferHasTag = !chunkHasTag && isBuffering && startsWith(openTag, buffer);
+    let toYieldBeforeMaskedStartTag = ``;
+    if (!isMasking && (chunkHasTag || bufferHasTag)) {
+      isMasking = true;
+      isBuffering = false;
+      const taggedTextToMask = trimOutsideDelimiter(buffer, `<`, `before-start`);
+      if (taggedTextToMask !== buffer.trim()) {
+        toYieldBeforeMaskedStartTag = buffer.replace(taggedTextToMask, ``);
+      }
+      buffer = "";
+      onStart?.();
+    }
+    if (!isMasking && !isBuffering && startsWith(openTag, chunk) && chunk.trim() !== "") {
+      isBuffering = true;
+      buffer += chunk;
+      continue;
+    }
+    if (isBuffering && buffer && !startsWith(openTag, buffer)) {
+      yield buffer;
+      buffer = "";
+      isBuffering = false;
+      continue;
+    }
+    if (isMasking && fullContent.includes(closeTag)) {
+      onMask?.(chunk);
+      onEnd?.();
+      isMasking = false;
+      const lastFullContent = fullContent;
+      fullContent = ``;
+      const textUntilEndTag = trimOutsideDelimiter(lastFullContent, closeTag, "after-end");
+      if (textUntilEndTag !== lastFullContent) {
+        yield lastFullContent.replace(textUntilEndTag, ``);
+      }
+      continue;
+    }
+    if (isMasking) {
+      onMask?.(chunk);
+      if (toYieldBeforeMaskedStartTag) {
+        yield toYieldBeforeMaskedStartTag;
+      }
+      continue;
+    }
+    yield chunk;
+  }
+}
+function resolveSerializedZodOutput(schema) {
+  return Function("z", `"use strict";return (${schema});`)(z);
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function createDeterministicId(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function setVercelToolProperties(tool) {
+  const 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,
+    id: toolId,
+    inputSchema
+  };
+}
+function ensureToolProperties(tools) {
+  const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
+    const tool = tools?.[key];
+    if (tool) {
+      if (isVercelTool(tool)) {
+        acc[key] = setVercelToolProperties(tool);
+      } else {
+        acc[key] = tool;
+      }
+    }
+    return acc;
+  }, {});
+  return toolsWithProperties;
+}
+function convertVercelToolParameters(tool) {
+  const schema = tool.parameters ?? z.object({});
+  return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod(schema));
+}
+function makeCoreTool(originalTool, options, logType) {
+  return new CoreToolBuilder({ originalTool, options, logType }).build();
+}
+function makeCoreToolV5(originalTool, options, logType) {
+  return new CoreToolBuilder({ originalTool, options, logType }).buildV5();
+}
+function createMastraProxy({ mastra, logger }) {
+  return new Proxy(mastra, {
+    get(target, prop) {
+      const hasProp = Reflect.has(target, prop);
+      if (hasProp) {
+        const value = Reflect.get(target, prop);
+        const isFunction = typeof value === "function";
+        if (isFunction) {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (prop === "logger") {
+        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
+        return Reflect.apply(target.getLogger, target, []);
+      }
+      if (prop === "telemetry") {
+        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
+        return Reflect.apply(target.getTelemetry, target, []);
+      }
+      if (prop === "storage") {
+        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
+        return Reflect.get(target, "storage");
+      }
+      if (prop === "agents") {
+        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
+        return Reflect.apply(target.getAgents, target, []);
+      }
+      if (prop === "tts") {
+        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
+        return Reflect.apply(target.getTTS, target, []);
+      }
+      if (prop === "vectors") {
+        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
+        return Reflect.apply(target.getVectors, target, []);
+      }
+      if (prop === "memory") {
+        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
+        return Reflect.get(target, "memory");
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+}
+function checkEvalStorageFields(traceObject, logger) {
+  const missingFields = [];
+  if (!traceObject.input) missingFields.push("input");
+  if (!traceObject.output) missingFields.push("output");
+  if (!traceObject.agentName) missingFields.push("agent_name");
+  if (!traceObject.metricName) missingFields.push("metric_name");
+  if (!traceObject.instructions) missingFields.push("instructions");
+  if (!traceObject.globalRunId) missingFields.push("global_run_id");
+  if (!traceObject.runId) missingFields.push("run_id");
+  if (missingFields.length > 0) {
+    if (logger) {
+      logger.warn("Skipping evaluation storage due to missing required fields", {
+        missingFields,
+        runId: traceObject.runId,
+        agentName: traceObject.agentName
+      });
+    } else {
+      console.warn("Skipping evaluation storage due to missing required fields", {
+        missingFields,
+        runId: traceObject.runId,
+        agentName: traceObject.agentName
+      });
+    }
+    return false;
+  }
+  return true;
+}
+function detectSingleMessageCharacteristics(message) {
+  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
+  message.role === "data" || // UI-only role
+  "toolInvocations" in message || // UI-specific field
+  "parts" in message || // UI-specific field
+  "experimental_attachments" in message)) {
+    return "has-ui-specific-parts";
+  } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
+  "experimental_providerMetadata" in message || "providerOptions" in message)) {
+    return "has-core-specific-parts";
+  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
+    return "message";
+  } else {
+    return "other";
+  }
+}
+function isUiMessage(message) {
+  return detectSingleMessageCharacteristics(message) === `has-ui-specific-parts`;
+}
+function isCoreMessage(message) {
+  return [`has-core-specific-parts`, `message`].includes(detectSingleMessageCharacteristics(message));
+}
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function parseSqlIdentifier(name, kind = "identifier") {
+  if (!SQL_IDENTIFIER_PATTERN.test(name) || name.length > 63) {
+    throw new Error(
+      `Invalid ${kind}: ${name}. Must start with a letter or underscore, contain only letters, numbers, or underscores, and be at most 63 characters long.`
+    );
+  }
+  return name;
+}
+function parseFieldKey(key) {
+  if (!key) throw new Error("Field key cannot be empty");
+  const segments = key.split(".");
+  for (const segment of segments) {
+    if (!SQL_IDENTIFIER_PATTERN.test(segment) || segment.length > 63) {
+      throw new Error(`Invalid field key segment: ${segment} in ${key}`);
+    }
+  }
+  return key;
+}
+async function fetchWithRetry(url, options = {}, maxRetries = 3) {
+  let retryCount = 0;
+  let lastError = null;
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url, options);
+      if (!response.ok) {
+        throw new Error(`Request failed with status: ${response.status} ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      retryCount++;
+      if (retryCount >= maxRetries) {
+        break;
+      }
+      const delay2 = Math.min(1e3 * Math.pow(2, retryCount) * 1e3, 1e4);
+      await new Promise((resolve) => setTimeout(resolve, delay2));
+    }
+  }
+  throw lastError || new Error("Request failed after multiple retry attempts");
+}
+
+// src/ai-tracing/exporters/cloud.ts
+var CloudExporter = class {
+  name = "mastra-cloud-ai-tracing-exporter";
+  config;
+  buffer;
+  flushTimer = null;
+  logger;
+  isDisabled = false;
+  constructor(config = {}) {
+    this.logger = config.logger ?? new ConsoleLogger({ level: LogLevel.INFO });
+    const accessToken = config.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
+    if (!accessToken) {
+      this.logger.warn(
+        "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.isDisabled = true;
+    }
+    const endpoint = config.endpoint ?? process.env.MASTRA_CLOUD_AI_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
+    this.config = {
+      maxBatchSize: config.maxBatchSize ?? 1e3,
+      maxBatchWaitMs: config.maxBatchWaitMs ?? 5e3,
+      maxRetries: config.maxRetries ?? 3,
+      accessToken: accessToken || "",
+      // Empty string if no token
+      endpoint,
+      logger: this.logger
+    };
+    this.buffer = {
+      spans: [],
+      totalSize: 0
+    };
+  }
+  async exportEvent(event) {
+    if (this.isDisabled) {
+      return;
+    }
+    if (event.type !== "span_ended" /* SPAN_ENDED */) {
+      return;
+    }
+    this.addToBuffer(event);
+    if (this.shouldFlush()) {
+      this.flush().catch((error) => {
+        this.logger.error("Batch flush failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    } else if (this.buffer.totalSize === 1) {
+      this.scheduleFlush();
+    }
+  }
+  addToBuffer(event) {
+    if (this.buffer.totalSize === 0) {
+      this.buffer.firstEventTime = /* @__PURE__ */ new Date();
+    }
+    const spanRecord = this.formatSpan(event.span);
+    this.buffer.spans.push(spanRecord);
+    this.buffer.totalSize++;
+  }
+  formatSpan(span) {
+    const spanRecord = {
+      traceId: span.traceId,
+      spanId: span.id,
+      parentSpanId: span.parent?.id ?? null,
+      name: span.name,
+      spanType: span.type,
+      attributes: span.attributes ?? null,
+      metadata: span.metadata ?? null,
+      startedAt: span.startTime,
+      endedAt: span.endTime ?? null,
+      input: span.input ?? null,
+      output: span.output ?? null,
+      error: span.errorInfo,
+      isEvent: span.isEvent,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: null
+    };
+    return spanRecord;
+  }
+  shouldFlush() {
+    if (this.buffer.totalSize >= this.config.maxBatchSize) {
+      return true;
+    }
+    if (this.buffer.firstEventTime && this.buffer.totalSize > 0) {
+      const elapsed = Date.now() - this.buffer.firstEventTime.getTime();
+      if (elapsed >= this.config.maxBatchWaitMs) {
+        return true;
+      }
+    }
+    return false;
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        const mastraError = new MastraError(
+          {
+            id: `CLOUD_AI_TRACING_FAILED_TO_SCHEDULE_FLUSH`,
+            domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+            category: "USER" /* USER */
+          },
+          error
+        );
+        this.logger.trackException(mastraError);
+        this.logger.error("Scheduled flush failed", mastraError);
+      });
+    }, this.config.maxBatchWaitMs);
+  }
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize === 0) {
+      return;
+    }
+    const startTime = Date.now();
+    const spansCopy = [...this.buffer.spans];
+    const flushReason = this.buffer.totalSize >= this.config.maxBatchSize ? "size" : "time";
+    this.resetBuffer();
+    try {
+      await this.batchUpload(spansCopy);
+      const elapsed = Date.now() - startTime;
+      this.logger.debug("Batch flushed successfully", {
+        batchSize: spansCopy.length,
+        flushReason,
+        durationMs: elapsed
+      });
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: `CLOUD_AI_TRACING_FAILED_TO_BATCH_UPLOAD`,
+          domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+          category: "USER" /* USER */,
+          details: {
+            droppedBatchSize: spansCopy.length
+          }
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Batch upload failed after all retries, dropping batch", mastraError);
+    }
+  }
+  /**
+   * 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"
+    };
+    const options = {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ spans })
+    };
+    await fetchWithRetry(url, options, this.config.maxRetries);
+  }
+  resetBuffer() {
+    this.buffer.spans = [];
+    this.buffer.firstEventTime = void 0;
+    this.buffer.totalSize = 0;
+  }
+  async shutdown() {
+    if (this.isDisabled) {
+      return;
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer.totalSize > 0) {
+      this.logger.info("Flushing remaining events on shutdown", {
+        remainingEvents: this.buffer.totalSize
+      });
+      try {
+        await this.flush();
+      } catch (error) {
+        const mastraError = new MastraError(
+          {
+            id: `CLOUD_AI_TRACING_FAILED_TO_FLUSH_REMAINING_EVENTS_DURING_SHUTDOWN`,
+            domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+            category: "USER" /* USER */,
+            details: {
+              remainingEvents: this.buffer.totalSize
+            }
+          },
+          error
+        );
+        this.logger.trackException(mastraError);
+        this.logger.error("Failed to flush remaining events during shutdown", mastraError);
+      }
+    }
+    this.logger.info("CloudExporter shutdown complete");
+  }
+};
 
 // src/ai-tracing/exporters/console.ts
 var ConsoleExporter = class {
@@ -463,7 +1193,8 @@ var DefaultExporter = class {
     }
     const storage = this.mastra.getStorage();
     if (!storage) {
-      throw new Error("DefaultExporter: Storage not available during initialization");
+      this.logger.warn("DefaultExporter disabled: Storage not available. Traces will not be persisted.");
+      return;
     }
     this.initializeStrategy(storage);
   }
@@ -779,12 +1510,12 @@ var DefaultExporter = class {
    */
   async flush() {
     if (!this.mastra) {
-      this.logger.warn("Cannot flush traces. Mastra instance not registered yet.");
+      this.logger.debug("Cannot flush traces. Mastra instance not registered yet.");
       return;
     }
     const storage = this.mastra.getStorage();
     if (!storage) {
-      this.logger.warn("Cannot flush traces. Mastra storage is not initialized");
+      this.logger.debug("Cannot flush traces. Mastra storage is not initialized");
       return;
     }
     if (this.flushTimer) {
@@ -864,12 +1595,12 @@ var DefaultExporter = class {
   }
   async exportEvent(event) {
     if (!this.mastra) {
-      this.logger.warn("Cannot export AI tracing event. Mastra instance not registered yet.");
+      this.logger.debug("Cannot export AI tracing event. Mastra instance not registered yet.");
       return;
     }
     const storage = this.mastra.getStorage();
     if (!storage) {
-      this.logger.warn("Cannot store traces. Mastra storage is not initialized");
+      this.logger.debug("Cannot store traces. Mastra storage is not initialized");
       return;
     }
     if (!this.strategyInitialized) {
@@ -1023,59 +1754,77 @@ function isAITracingInstance(obj) {
   return obj instanceof MastraAITracing;
 }
 function setupAITracing(config) {
-  const entries = Object.entries(config.instances);
-  entries.forEach(([name, tracingDef], index) => {
-    const instance = isAITracingInstance(tracingDef) ? tracingDef : new DefaultAITracing({ ...tracingDef, instanceName: name });
-    const isDefault = index === 0;
-    registerAITracing(name, instance, isDefault);
-  });
-  if (config.selector) {
-    setAITracingSelector(config.selector);
+  if (!config) {
+    return;
+  }
+  if (config.default?.enabled && config.configs?.["default"]) {
+    throw new Error(
+      "Cannot use 'default' as a custom config name when default tracing is enabled. Please rename your custom config to avoid conflicts."
+    );
+  }
+  if (config.default?.enabled) {
+    const defaultInstance = new DefaultAITracing({
+      serviceName: "mastra",
+      name: "default",
+      sampling: { type: "always" /* ALWAYS */ },
+      exporters: [new DefaultExporter(), new CloudExporter()],
+      processors: [new SensitiveDataFilter()]
+    });
+    registerAITracing("default", defaultInstance, true);
+  }
+  if (config.configs) {
+    const instances = Object.entries(config.configs);
+    instances.forEach(([name, tracingDef], index) => {
+      const instance = isAITracingInstance(tracingDef) ? tracingDef : new DefaultAITracing({ ...tracingDef, name });
+      const isDefault = !config.default?.enabled && index === 0;
+      registerAITracing(name, instance, isDefault);
+    });
+  }
+  if (config.configSelector) {
+    setAITracingSelector(config.configSelector);
   }
 }
 
 // src/ai-tracing/utils.ts
-function shallowCleanObject(obj) {
-  const cleaned = {};
-  for (const [key, value] of Object.entries(obj)) {
+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);
-      cleaned[key] = value;
+      return value;
     } catch (error) {
-      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
+      return `[${error instanceof Error ? error.message : String(error)}]`;
     }
   }
-  return cleaned;
-}
-function shallowCleanArray(arr) {
-  return arr.map((item) => {
-    if (item && typeof item === "object" && !Array.isArray(item)) {
-      return shallowCleanObject(item);
+  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 {
-      JSON.stringify(item);
-      return item;
+      cleaned[key] = deepClean(val, options, _seen, _depth + 1);
     } catch (error) {
-      return `[${error instanceof Error ? error.message : String(error)}]`;
+      cleaned[key] = `[${error instanceof Error ? error.message : String(error)}]`;
     }
-  });
-}
-function shallowClean(value) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return shallowCleanArray(value);
-  }
-  if (typeof value === "object") {
-    return shallowCleanObject(value);
-  }
-  try {
-    JSON.stringify(value);
-    return value;
-  } catch (error) {
-    return `[${error instanceof Error ? error.message : String(error)}]`;
   }
+  return cleaned;
 }
 function omitKeys(obj, keysToOmit) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => !keysToOmit.includes(key)));
@@ -1113,12 +1862,17 @@ function setNestedValue(obj, path, value) {
   target[lastKey] = value;
 }
 function getOrCreateSpan(options) {
-  const { type, attributes, tracingContext, runtimeContext, ...rest } = options;
+  const { type, attributes, tracingContext, tracingOptions, runtimeContext, ...rest } = options;
+  const metadata = {
+    ...rest.metadata ?? {},
+    ...tracingOptions?.metadata ?? {}
+  };
   if (tracingContext?.currentSpan) {
     return tracingContext.currentSpan.createChildSpan({
       type,
       attributes,
-      ...rest
+      ...rest,
+      metadata
     });
   }
   const aiTracing = getSelectedAITracing({
@@ -1130,9 +1884,13 @@ function getOrCreateSpan(options) {
     startOptions: {
       runtimeContext
     },
-    ...rest
+    ...rest,
+    metadata
   });
 }
+function getValidTraceId(span) {
+  return span?.isValid ? span.traceId : void 0;
+}
 
 // src/ai-tracing/default.ts
 function generateSpanId() {
@@ -1172,51 +1930,43 @@ var DefaultAISpan = class {
   output;
   errorInfo;
   metadata;
-  logger;
   constructor(options, aiTracing) {
     this.id = generateSpanId();
     this.name = options.name;
     this.type = options.type;
-    this.attributes = shallowClean(options.attributes) || {};
-    this.metadata = shallowClean(options.metadata);
+    this.attributes = deepClean(options.attributes) || {};
+    this.metadata = deepClean(options.metadata);
     this.parent = options.parent;
     this.startTime = /* @__PURE__ */ new Date();
     this.aiTracing = aiTracing;
-    this.input = shallowClean(options.input);
+    this.input = deepClean(options.input);
     this.isEvent = options.isEvent;
-    this.logger = new ConsoleLogger({
-      name: "default-ai-span",
-      level: LogLevel.INFO
-      // Set to INFO so that info() calls actually log
-    });
     if (!options.parent) {
       this.traceId = generateTraceId();
     } else {
       this.traceId = options.parent.traceId;
     }
     if (this.isEvent) {
-      this.output = shallowClean(options.output);
+      this.output = deepClean(options.output);
     }
   }
   end(options) {
     if (this.isEvent) {
-      this.logger.warn(`End event is not available on event spans`);
       return;
     }
     this.endTime = /* @__PURE__ */ new Date();
     if (options?.output !== void 0) {
-      this.output = shallowClean(options.output);
+      this.output = deepClean(options.output);
     }
     if (options?.attributes) {
-      this.attributes = { ...this.attributes, ...shallowClean(options.attributes) };
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
     }
     if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...shallowClean(options.metadata) };
+      this.metadata = { ...this.metadata, ...deepClean(options.metadata) };
     }
   }
   error(options) {
     if (this.isEvent) {
-      this.logger.warn(`Error event is not available on event spans`);
       return;
     }
     const { error, endSpan = true, attributes, metadata } = options;
@@ -1230,10 +1980,10 @@ var DefaultAISpan = class {
       message: error.message
     };
     if (attributes) {
-      this.attributes = { ...this.attributes, ...shallowClean(attributes) };
+      this.attributes = { ...this.attributes, ...deepClean(attributes) };
     }
     if (metadata) {
-      this.metadata = { ...this.metadata, ...shallowClean(metadata) };
+      this.metadata = { ...this.metadata, ...deepClean(metadata) };
     }
     if (endSpan) {
       this.end();
@@ -1257,25 +2007,27 @@ var DefaultAISpan = class {
   }
   update(options) {
     if (this.isEvent) {
-      this.logger.warn(`Update() is not available on event spans`);
       return;
     }
     if (options?.input !== void 0) {
-      this.input = shallowClean(options.input);
+      this.input = deepClean(options.input);
     }
     if (options?.output !== void 0) {
-      this.output = shallowClean(options.output);
+      this.output = deepClean(options.output);
     }
     if (options?.attributes) {
-      this.attributes = { ...this.attributes, ...shallowClean(options.attributes) };
+      this.attributes = { ...this.attributes, ...deepClean(options.attributes) };
     }
     if (options?.metadata) {
-      this.metadata = { ...this.metadata, ...shallowClean(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,
@@ -1352,16 +2104,13 @@ var SensitiveDataFilter = class {
   async shutdown() {
   }
 };
-var aiTracingDefaultConfig = {
-  serviceName: "mastra-ai-service",
-  instanceName: "default",
-  sampling: { type: "always" /* ALWAYS */ },
-  exporters: [new ConsoleExporter()],
-  processors: [new SensitiveDataFilter()]
-};
 var DefaultAITracing = class extends MastraAITracing {
-  constructor(config = aiTracingDefaultConfig) {
-    super(config);
+  constructor(config) {
+    const configWithDefaults = {
+      ...config,
+      exporters: config.exporters?.length ? config.exporters : [new ConsoleExporter()]
+    };
+    super(configWithDefaults);
   }
   // ============================================================================
   // Abstract Method Implementations
@@ -1377,7 +2126,7 @@ var AGENT_METHODS_TO_WRAP = ["generate", "stream", "generateVNext", "streamVNext
 var WORKFLOW_GETTERS = ["getWorkflow", "getWorkflowById"];
 var WORKFLOW_METHODS_TO_WRAP = ["execute", "createRun", "createRunAsync"];
 function isNoOpSpan(span) {
-  return span.constructor.name === "NoOpAISpan" || span.__isNoOp === true || !span.aiTracing;
+  return span.constructor.name === "NoOpAISpan" || span.__isNoOp === true;
 }
 function isMastra(mastra) {
   const hasAgentGetters = AGENT_GETTERS.every((method) => typeof mastra?.[method] === "function");
@@ -1518,6 +2267,6 @@ function wrapRun(run, tracingContext) {
   }
 }
 
-export { AISpanType, AITracingEventType, ConsoleExporter, DefaultAITracing, DefaultExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, aiTracingDefaultConfig, clearAITracingRegistry, getAITracing, getAllAITracing, getDefaultAITracing, getOrCreateSpan, getSelectedAITracing, hasAITracing, isMastra, omitKeys, registerAITracing, selectFields, setAITracingSelector, setupAITracing, shallowClean, shallowCleanArray, shallowCleanObject, shutdownAITracingRegistry, unregisterAITracing, wrapMastra };
-//# sourceMappingURL=chunk-2NKNTPFR.js.map
-//# sourceMappingURL=chunk-2NKNTPFR.js.map
+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