@mastra/otel-exporter 1.3.5 → 1.3.6

package/dist/index.cjs

@@ -1,1193 +1,1045 @@
-'use strict';
-
-var observability = require('@mastra/core/observability');
-var observability$1 = require('@mastra/observability');
-var api = require('@opentelemetry/api');
-var core = require('@opentelemetry/core');
-var resources = require('@opentelemetry/resources');
-var sdkLogs = require('@opentelemetry/sdk-logs');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
-var apiLogs = require('@opentelemetry/api-logs');
-var fs = require('fs');
-var url = require('url');
-var incubating = require('@opentelemetry/semantic-conventions/incubating');
-
-// src/tracing.ts
-
-// src/loadExporter.ts
-var EXPORTER_SPECS = {
-  traces: {
-    "http/json": { pkg: "@opentelemetry/exporter-trace-otlp-http", exportName: "OTLPTraceExporter" },
-    "http/protobuf": { pkg: "@opentelemetry/exporter-trace-otlp-proto", exportName: "OTLPTraceExporter" },
-    grpc: {
-      pkg: "@opentelemetry/exporter-trace-otlp-grpc",
-      exportName: "OTLPTraceExporter",
-      extras: ["@grpc/grpc-js"]
-    },
-    zipkin: { pkg: "@opentelemetry/exporter-zipkin", exportName: "ZipkinExporter" }
-  },
-  logs: {
-    "http/json": { pkg: "@opentelemetry/exporter-logs-otlp-http", exportName: "OTLPLogExporter" },
-    "http/protobuf": { pkg: "@opentelemetry/exporter-logs-otlp-proto", exportName: "OTLPLogExporter" },
-    grpc: {
-      pkg: "@opentelemetry/exporter-logs-otlp-grpc",
-      exportName: "OTLPLogExporter",
-      extras: ["@grpc/grpc-js"]
-    }
-    // zipkin: not supported
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _mastra_core_observability = require("@mastra/core/observability");
+let _mastra_observability = require("@mastra/observability");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_core = require("@opentelemetry/core");
+let _opentelemetry_resources = require("@opentelemetry/resources");
+let _opentelemetry_sdk_logs = require("@opentelemetry/sdk-logs");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
+let fs = require("fs");
+let url = require("url");
+let _opentelemetry_semantic_conventions_incubating = require("@opentelemetry/semantic-conventions/incubating");
+//#region src/loadExporter.ts
+const EXPORTER_SPECS = {
+	traces: {
+		"http/json": {
+			pkg: "@opentelemetry/exporter-trace-otlp-http",
+			exportName: "OTLPTraceExporter"
+		},
+		"http/protobuf": {
+			pkg: "@opentelemetry/exporter-trace-otlp-proto",
+			exportName: "OTLPTraceExporter"
+		},
+		grpc: {
+			pkg: "@opentelemetry/exporter-trace-otlp-grpc",
+			exportName: "OTLPTraceExporter",
+			extras: ["@grpc/grpc-js"]
+		},
+		zipkin: {
+			pkg: "@opentelemetry/exporter-zipkin",
+			exportName: "ZipkinExporter"
+		}
+	},
+	logs: {
+		"http/json": {
+			pkg: "@opentelemetry/exporter-logs-otlp-http",
+			exportName: "OTLPLogExporter"
+		},
+		"http/protobuf": {
+			pkg: "@opentelemetry/exporter-logs-otlp-proto",
+			exportName: "OTLPLogExporter"
+		},
+		grpc: {
+			pkg: "@opentelemetry/exporter-logs-otlp-grpc",
+			exportName: "OTLPLogExporter",
+			extras: ["@grpc/grpc-js"]
+		}
+	}
 };
-var cache = /* @__PURE__ */ new Map();
+/** Cache keyed by "signal:protocol" */
+const cache = /* @__PURE__ */ new Map();
+/**
+* Load a trace exporter for the given protocol.
+* Backward-compatible with existing usage in tracing.ts.
+*/
 async function loadExporter(protocol, provider) {
-  return loadSignalExporter("traces", protocol, provider);
+	return loadSignalExporter("traces", protocol, provider);
 }
+/**
+* Load a signal-specific exporter class for the given protocol.
+* Returns the constructor, or null if the package isn't installed.
+*/
 async function loadSignalExporter(signal, protocol, provider) {
-  const spec = EXPORTER_SPECS[signal]?.[protocol];
-  if (!spec) {
-    if (protocol === "zipkin") {
-      console.warn(
-        `[OtelExporter] Zipkin does not support OTLP ${signal}. ${capitalize(signal)} export will be disabled.`
-      );
-    }
-    return null;
-  }
-  const cacheKey = `${signal}:${protocol}`;
-  if (cache.has(cacheKey)) {
-    return cache.get(cacheKey);
-  }
-  try {
-    const mod = await import(spec.pkg);
-    const ExporterClass = mod[spec.exportName];
-    if (typeof ExporterClass !== "function") {
-      console.error(
-        `[OtelExporter] ${capitalize(signal)} ${protocol} exporter package "${spec.pkg}" did not expose a "${spec.exportName}" export. ${capitalize(signal)} export will be disabled.`
-      );
-      return null;
-    }
-    cache.set(cacheKey, ExporterClass);
-    return ExporterClass;
-  } catch {
-    const providerInfo = provider ? ` (required for ${provider})` : "";
-    const allPkgs = [spec.pkg, ...spec.extras ?? []].join(" ");
-    console.error(
-      `[OtelExporter] ${capitalize(signal)} ${protocol} exporter is not installed${providerInfo}.
-  Install the required package(s):
-  npm install ${allPkgs}`
-    );
-    return null;
-  }
+	const spec = EXPORTER_SPECS[signal]?.[protocol];
+	if (!spec) {
+		if (protocol === "zipkin") console.warn(`[OtelExporter] Zipkin does not support OTLP ${signal}. ${capitalize(signal)} export will be disabled.`);
+		return null;
+	}
+	const cacheKey = `${signal}:${protocol}`;
+	if (cache.has(cacheKey)) return cache.get(cacheKey);
+	try {
+		const ExporterClass = (await import(spec.pkg))[spec.exportName];
+		if (typeof ExporterClass !== "function") {
+			console.error(`[OtelExporter] ${capitalize(signal)} ${protocol} exporter package "${spec.pkg}" did not expose a "${spec.exportName}" export. ${capitalize(signal)} export will be disabled.`);
+			return null;
+		}
+		cache.set(cacheKey, ExporterClass);
+		return ExporterClass;
+	} catch {
+		const providerInfo = provider ? ` (required for ${provider})` : "";
+		const allPkgs = [spec.pkg, ...spec.extras ?? []].join(" ");
+		console.error(`[OtelExporter] ${capitalize(signal)} ${protocol} exporter is not installed${providerInfo}.\n  Install the required package(s):\n  npm install ${allPkgs}`);
+		return null;
+	}
 }
 function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
+	return s.charAt(0).toUpperCase() + s.slice(1);
 }
+//#endregion
+//#region src/log-converter.ts
+/**
+* Map Mastra LogLevel to OTEL SeverityNumber
+*/
 function mapSeverity(level) {
-  switch (level) {
-    case "debug":
-      return apiLogs.SeverityNumber.DEBUG;
-    case "info":
-      return apiLogs.SeverityNumber.INFO;
-    case "warn":
-      return apiLogs.SeverityNumber.WARN;
-    case "error":
-      return apiLogs.SeverityNumber.ERROR;
-    case "fatal":
-      return apiLogs.SeverityNumber.FATAL;
-    default:
-      return apiLogs.SeverityNumber.UNSPECIFIED;
-  }
+	switch (level) {
+		case "debug": return _opentelemetry_api_logs.SeverityNumber.DEBUG;
+		case "info": return _opentelemetry_api_logs.SeverityNumber.INFO;
+		case "warn": return _opentelemetry_api_logs.SeverityNumber.WARN;
+		case "error": return _opentelemetry_api_logs.SeverityNumber.ERROR;
+		case "fatal": return _opentelemetry_api_logs.SeverityNumber.FATAL;
+		default: return _opentelemetry_api_logs.SeverityNumber.UNSPECIFIED;
+	}
 }
-function dateToHrTime(date) {
-  const ms = date.getTime();
-  const seconds = Math.floor(ms / 1e3);
-  const nanoseconds = ms % 1e3 * 1e6;
-  return [seconds, nanoseconds];
+/**
+* Convert a Date to OTEL HrTime [seconds, nanoseconds]
+*/
+function dateToHrTime$1(date) {
+	const ms = date.getTime();
+	return [Math.floor(ms / 1e3), ms % 1e3 * 1e6];
 }
+/**
+* Stringify a value for use as an OTEL log attribute. Falls back to a
+* placeholder rather than throwing if the value contains a circular
+* reference, throws from a custom toJSON, or otherwise cannot be serialized.
+*/
 function safeStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "[unserializable]";
-  }
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
 }
+/**
+* Build OTEL log attributes from ExportedLog fields.
+* Includes trace correlation and metadata.
+*/
 function buildLogAttributes(log) {
-  const attributes = {};
-  if (log.data) {
-    for (const [key, value] of Object.entries(log.data)) {
-      if (value === null || value === void 0) continue;
-      attributes[`mastra.log.${key}`] = typeof value === "object" ? safeStringify(value) : value;
-    }
-  }
-  if (log.metadata) {
-    for (const [key, value] of Object.entries(log.metadata)) {
-      if (value === null || value === void 0) continue;
-      attributes[`mastra.metadata.${key}`] = typeof value === "object" ? safeStringify(value) : value;
-    }
-  }
-  if (log.tags?.length) {
-    attributes["mastra.tags"] = safeStringify(log.tags);
-  }
-  return attributes;
+	const attributes = {};
+	if (log.data) for (const [key, value] of Object.entries(log.data)) {
+		if (value === null || value === void 0) continue;
+		attributes[`mastra.log.${key}`] = typeof value === "object" ? safeStringify(value) : value;
+	}
+	if (log.metadata) for (const [key, value] of Object.entries(log.metadata)) {
+		if (value === null || value === void 0) continue;
+		attributes[`mastra.metadata.${key}`] = typeof value === "object" ? safeStringify(value) : value;
+	}
+	if (log.tags?.length) attributes["mastra.tags"] = safeStringify(log.tags);
+	return attributes;
 }
+/**
+* Convert an ExportedLog into parameters suitable for OTEL Logger.emit()
+*/
 function convertLog(log) {
-  return {
-    timestamp: dateToHrTime(log.timestamp),
-    severityNumber: mapSeverity(log.level),
-    severityText: log.level.toUpperCase(),
-    body: log.message,
-    attributes: buildLogAttributes(log),
-    traceId: log.traceId,
-    spanId: log.spanId
-  };
+	return {
+		timestamp: dateToHrTime$1(log.timestamp),
+		severityNumber: mapSeverity(log.level),
+		severityText: log.level.toUpperCase(),
+		body: log.message,
+		attributes: buildLogAttributes(log),
+		traceId: log.traceId,
+		spanId: log.spanId
+	};
 }
-
-// src/provider-configs.ts
+//#endregion
+//#region src/provider-configs.ts
 function resolveProviderConfig(config, debug) {
-  const providerName = Object.keys(config)[0];
-  if (debug) {
-    console.info(`[OtelExporter:debug] Resolving provider config for: ${providerName}`);
-  }
-  let resolved;
-  if ("dash0" in config) {
-    resolved = resolveDash0Config(config.dash0);
-  } else if ("signoz" in config) {
-    resolved = resolveSignozConfig(config.signoz);
-  } else if ("newrelic" in config) {
-    resolved = resolveNewRelicConfig(config.newrelic);
-  } else if ("traceloop" in config) {
-    resolved = resolveTraceloopConfig(config.traceloop);
-  } else if ("laminar" in config) {
-    resolved = resolveLaminarConfig(config.laminar);
-  } else if ("custom" in config) {
-    resolved = resolveCustomConfig(config.custom);
-  } else {
-    const _exhaustive = config;
-    return _exhaustive;
-  }
-  if (debug && resolved) {
-    const maskedHeaders = {};
-    for (const [key, value] of Object.entries(resolved.headers)) {
-      maskedHeaders[key] = value ? "[REDACTED]" : "[EMPTY]";
-    }
-    console.info(`[OtelExporter:debug] Provider "${providerName}" resolved:`, {
-      endpoint: resolved.endpoint,
-      protocol: resolved.protocol,
-      headers: maskedHeaders
-    });
-  } else if (debug && !resolved) {
-    console.info(`[OtelExporter:debug] Provider "${providerName}" resolution returned null (disabled)`);
-  }
-  return resolved;
+	const providerName = Object.keys(config)[0];
+	if (debug) console.info(`[OtelExporter:debug] Resolving provider config for: ${providerName}`);
+	let resolved;
+	if ("dash0" in config) resolved = resolveDash0Config(config.dash0);
+	else if ("signoz" in config) resolved = resolveSignozConfig(config.signoz);
+	else if ("newrelic" in config) resolved = resolveNewRelicConfig(config.newrelic);
+	else if ("traceloop" in config) resolved = resolveTraceloopConfig(config.traceloop);
+	else if ("laminar" in config) resolved = resolveLaminarConfig(config.laminar);
+	else if ("custom" in config) resolved = resolveCustomConfig(config.custom);
+	else return config;
+	if (debug && resolved) {
+		const maskedHeaders = {};
+		for (const [key, value] of Object.entries(resolved.headers)) maskedHeaders[key] = value ? "[REDACTED]" : "[EMPTY]";
+		console.info(`[OtelExporter:debug] Provider "${providerName}" resolved:`, {
+			endpoint: resolved.endpoint,
+			protocol: resolved.protocol,
+			headers: maskedHeaders
+		});
+	} else if (debug && !resolved) console.info(`[OtelExporter:debug] Provider "${providerName}" resolution returned null (disabled)`);
+	return resolved;
 }
 function resolveDash0Config(config) {
-  const apiKey = config.apiKey ?? process.env.DASH0_API_KEY;
-  const configEndpoint = config.endpoint ?? process.env.DASH0_ENDPOINT;
-  const dataset = config.dataset ?? process.env.DASH0_DATASET;
-  if (!apiKey) {
-    console.error(
-      "[OtelExporter] Dash0 configuration requires apiKey. Set DASH0_API_KEY environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  if (!configEndpoint) {
-    console.error(
-      "[OtelExporter] Dash0 configuration requires endpoint. Set DASH0_ENDPOINT environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  let endpoint = configEndpoint;
-  if (!endpoint.includes("/v1/traces")) {
-    endpoint = `${endpoint}/v1/traces`;
-  }
-  const headers = {
-    authorization: `Bearer ${apiKey}`
-    // lowercase for gRPC metadata
-  };
-  if (dataset) {
-    headers["dash0-dataset"] = dataset;
-  }
-  return {
-    endpoint,
-    headers,
-    protocol: "grpc"
-    // Use gRPC for Dash0
-  };
+	const apiKey = config.apiKey ?? process.env.DASH0_API_KEY;
+	const configEndpoint = config.endpoint ?? process.env.DASH0_ENDPOINT;
+	const dataset = config.dataset ?? process.env.DASH0_DATASET;
+	if (!apiKey) {
+		console.error("[OtelExporter] Dash0 configuration requires apiKey. Set DASH0_API_KEY environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	if (!configEndpoint) {
+		console.error("[OtelExporter] Dash0 configuration requires endpoint. Set DASH0_ENDPOINT environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	let endpoint = configEndpoint;
+	if (!endpoint.includes("/v1/traces")) endpoint = `${endpoint}/v1/traces`;
+	const headers = { authorization: `Bearer ${apiKey}` };
+	if (dataset) headers["dash0-dataset"] = dataset;
+	return {
+		endpoint,
+		headers,
+		protocol: "grpc"
+	};
 }
 function resolveSignozConfig(config) {
-  const apiKey = config.apiKey ?? process.env.SIGNOZ_API_KEY;
-  const region = config.region ?? process.env.SIGNOZ_REGION;
-  const configEndpoint = config.endpoint ?? process.env.SIGNOZ_ENDPOINT;
-  if (!apiKey) {
-    console.error(
-      "[OtelExporter] SigNoz configuration requires apiKey. Set SIGNOZ_API_KEY environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  const endpoint = configEndpoint || `https://ingest.${region || "us"}.signoz.cloud:443/v1/traces`;
-  return {
-    endpoint,
-    headers: {
-      "signoz-ingestion-key": apiKey
-    },
-    protocol: "http/protobuf"
-  };
+	const apiKey = config.apiKey ?? process.env.SIGNOZ_API_KEY;
+	const region = config.region ?? process.env.SIGNOZ_REGION;
+	const configEndpoint = config.endpoint ?? process.env.SIGNOZ_ENDPOINT;
+	if (!apiKey) {
+		console.error("[OtelExporter] SigNoz configuration requires apiKey. Set SIGNOZ_API_KEY environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	return {
+		endpoint: configEndpoint || `https://ingest.${region || "us"}.signoz.cloud:443/v1/traces`,
+		headers: { "signoz-ingestion-key": apiKey },
+		protocol: "http/protobuf"
+	};
 }
 function resolveNewRelicConfig(config) {
-  const apiKey = config.apiKey ?? process.env.NEW_RELIC_LICENSE_KEY;
-  const configEndpoint = config.endpoint ?? process.env.NEW_RELIC_ENDPOINT;
-  if (!apiKey) {
-    console.error(
-      "[OtelExporter] New Relic configuration requires apiKey (license key). Set NEW_RELIC_LICENSE_KEY environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  const endpoint = configEndpoint || "https://otlp.nr-data.net:443/v1/traces";
-  return {
-    endpoint,
-    headers: {
-      "api-key": apiKey
-    },
-    protocol: "http/protobuf"
-  };
+	const apiKey = config.apiKey ?? process.env.NEW_RELIC_LICENSE_KEY;
+	const configEndpoint = config.endpoint ?? process.env.NEW_RELIC_ENDPOINT;
+	if (!apiKey) {
+		console.error("[OtelExporter] New Relic configuration requires apiKey (license key). Set NEW_RELIC_LICENSE_KEY environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	return {
+		endpoint: configEndpoint || "https://otlp.nr-data.net:443/v1/traces",
+		headers: { "api-key": apiKey },
+		protocol: "http/protobuf"
+	};
 }
 function resolveTraceloopConfig(config) {
-  const apiKey = config.apiKey ?? process.env.TRACELOOP_API_KEY;
-  const destinationId = config.destinationId ?? process.env.TRACELOOP_DESTINATION_ID;
-  const configEndpoint = config.endpoint ?? process.env.TRACELOOP_ENDPOINT;
-  if (!apiKey) {
-    console.error(
-      "[OtelExporter] Traceloop configuration requires apiKey. Set TRACELOOP_API_KEY environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  const endpoint = configEndpoint || "https://api.traceloop.com/v1/traces";
-  const headers = {
-    Authorization: `Bearer ${apiKey}`
-  };
-  if (destinationId) {
-    headers["x-traceloop-destination-id"] = destinationId;
-  }
-  return {
-    endpoint,
-    headers,
-    protocol: "http/json"
-  };
+	const apiKey = config.apiKey ?? process.env.TRACELOOP_API_KEY;
+	const destinationId = config.destinationId ?? process.env.TRACELOOP_DESTINATION_ID;
+	const configEndpoint = config.endpoint ?? process.env.TRACELOOP_ENDPOINT;
+	if (!apiKey) {
+		console.error("[OtelExporter] Traceloop configuration requires apiKey. Set TRACELOOP_API_KEY environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	const endpoint = configEndpoint || "https://api.traceloop.com/v1/traces";
+	const headers = { Authorization: `Bearer ${apiKey}` };
+	if (destinationId) headers["x-traceloop-destination-id"] = destinationId;
+	return {
+		endpoint,
+		headers,
+		protocol: "http/json"
+	};
 }
 function resolveLaminarConfig(config) {
-  const apiKey = config.apiKey ?? process.env.LMNR_PROJECT_API_KEY;
-  const configEndpoint = config.endpoint ?? process.env.LAMINAR_ENDPOINT;
-  if (!apiKey) {
-    console.error(
-      "[OtelExporter] Laminar configuration requires apiKey. Set LMNR_PROJECT_API_KEY environment variable or pass it in config. Tracing will be disabled."
-    );
-    return null;
-  }
-  const endpoint = configEndpoint || "https://api.lmnr.ai/v1/traces";
-  const headers = {
-    Authorization: `Bearer ${apiKey}`
-  };
-  return {
-    endpoint,
-    headers,
-    protocol: "http/protobuf"
-    // Use HTTP/protobuf instead of gRPC for better compatibility
-  };
+	const apiKey = config.apiKey ?? process.env.LMNR_PROJECT_API_KEY;
+	const configEndpoint = config.endpoint ?? process.env.LAMINAR_ENDPOINT;
+	if (!apiKey) {
+		console.error("[OtelExporter] Laminar configuration requires apiKey. Set LMNR_PROJECT_API_KEY environment variable or pass it in config. Tracing will be disabled.");
+		return null;
+	}
+	return {
+		endpoint: configEndpoint || "https://api.lmnr.ai/v1/traces",
+		headers: { Authorization: `Bearer ${apiKey}` },
+		protocol: "http/protobuf"
+	};
 }
 function resolveCustomConfig(config) {
-  if (!config.endpoint) {
-    console.error("[OtelExporter] Custom configuration requires endpoint. Tracing will be disabled.");
-    return null;
-  }
-  return {
-    endpoint: config.endpoint,
-    headers: config.headers || {},
-    protocol: config.protocol || "http/json"
-  };
+	if (!config.endpoint) {
+		console.error("[OtelExporter] Custom configuration requires endpoint. Tracing will be disabled.");
+		return null;
+	}
+	return {
+		endpoint: config.endpoint,
+		headers: config.headers || {},
+		protocol: config.protocol || "http/json"
+	};
 }
-
-// src/gen-ai-messages.ts
-var isMastraMessagePart = (p) => {
-  return typeof p === "object" && p != null && "type" in p && (p.type === "text" || p.type === "tool-call" || p.type === "tool-result") && (p.type === "text" && "text" in p || p.type === "tool-call" && "toolCallId" in p && "toolName" in p && "input" in p || p.type === "tool-result" && "toolCallId" in p && "toolName" in p && "output" in p);
+//#endregion
+//#region src/gen-ai-messages.ts
+const isMastraMessagePart = (p) => {
+	return typeof p === "object" && p != null && "type" in p && (p.type === "text" || p.type === "tool-call" || p.type === "tool-result") && (p.type === "text" && "text" in p || p.type === "tool-call" && "toolCallId" in p && "toolName" in p && "input" in p || p.type === "tool-result" && "toolCallId" in p && "toolName" in p && "output" in p);
 };
-var isMastraMessage = (m) => {
-  return typeof m === "object" && m != null && "role" in m && "content" in m && (typeof m.content === "string" || Array.isArray(m.content) && m.content.every(isMastraMessagePart));
+const isMastraMessage = (m) => {
+	return typeof m === "object" && m != null && "role" in m && "content" in m && (typeof m.content === "string" || Array.isArray(m.content) && m.content.every(isMastraMessagePart));
 };
-var convertMastraMessagesToGenAIMessages = (inputOutputString) => {
-  try {
-    const parsedIO = JSON.parse(inputOutputString);
-    if (typeof parsedIO !== "object" || parsedIO == null || !("messages" in parsedIO) && !("text" in parsedIO)) {
-      return inputOutputString;
-    }
-    if ("text" in parsedIO) {
-      return JSON.stringify([
-        {
-          role: "assistant",
-          parts: [{ type: "text", content: parsedIO.text }]
-        }
-      ]);
-    }
-    if (Array.isArray(parsedIO.messages)) {
-      return JSON.stringify(
-        parsedIO.messages.map((m) => {
-          if (!isMastraMessage(m)) {
-            return m;
-          }
-          const role = m.role;
-          let parts = [];
-          if (Array.isArray(m.content)) {
-            parts = m.content.map((c) => {
-              switch (c.type) {
-                case "text":
-                  return {
-                    type: "text",
-                    content: c.text
-                  };
-                case "tool-call":
-                  return {
-                    type: "tool_call",
-                    id: c.toolCallId,
-                    name: c.toolName,
-                    arguments: JSON.stringify(c.input)
-                  };
-                case "tool-result":
-                  return {
-                    type: "tool_call_response",
-                    id: c.toolCallId,
-                    name: c.toolName,
-                    response: JSON.stringify(c.output.value)
-                  };
-                default:
-                  return c;
-              }
-            });
-          } else {
-            parts = [
-              {
-                type: "text",
-                content: m.content
-              }
-            ];
-          }
-          return {
-            role,
-            parts
-          };
-        })
-      );
-    }
-    return inputOutputString;
-  } catch {
-    return inputOutputString;
-  }
+/**
+* Convert an Input/Output string from a MastraSpan into a jsonified string that adheres to
+* OpenTelemetry gen_ai.input.messages and gen_ai.output.messages schema.
+* If parsing fails at any step, the original inputOutputString is returned unmodified.
+*
+* This conversion is best effort; It assumes a consistent shape for mastra messages, and converts
+* into the gen_ai input and output schemas as of October 20th, 2025.
+*
+* @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-input-messages
+* @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-input-messages.json
+* @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-output-messages
+* @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-output-messages.json
+*
+* @param inputOutputString a jsonified string that contains messages adhering to what appears to be
+* Mastra's message shape.
+* @returns a jsonified string that contains messages adhering to the OpenTelemetry gen_ai.input.messages and gen_ai.output.messages schema.
+* If parsing fails at any step, the original inputOutputString is returned unmodified.
+*/
+const convertMastraMessagesToGenAIMessages = (inputOutputString) => {
+	try {
+		const parsedIO = JSON.parse(inputOutputString);
+		if (typeof parsedIO !== "object" || parsedIO == null || !("messages" in parsedIO) && !("text" in parsedIO)) return inputOutputString;
+		if ("text" in parsedIO) return JSON.stringify([{
+			role: "assistant",
+			parts: [{
+				type: "text",
+				content: parsedIO.text
+			}]
+		}]);
+		if (Array.isArray(parsedIO.messages)) return JSON.stringify(parsedIO.messages.map((m) => {
+			if (!isMastraMessage(m)) return m;
+			const role = m.role;
+			let parts = [];
+			if (Array.isArray(m.content)) parts = m.content.map((c) => {
+				switch (c.type) {
+					case "text": return {
+						type: "text",
+						content: c.text
+					};
+					case "tool-call": return {
+						type: "tool_call",
+						id: c.toolCallId,
+						name: c.toolName,
+						arguments: JSON.stringify(c.input)
+					};
+					case "tool-result": return {
+						type: "tool_call_response",
+						id: c.toolCallId,
+						name: c.toolName,
+						response: JSON.stringify(c.output.value)
+					};
+					default: return c;
+				}
+			});
+			else parts = [{
+				type: "text",
+				content: m.content
+			}];
+			return {
+				role,
+				parts
+			};
+		}));
+		return inputOutputString;
+	} catch {
+		return inputOutputString;
+	}
 };
-
-// src/gen-ai-semantics.ts
+//#endregion
+//#region src/gen-ai-semantics.ts
+/**
+* Utilities for converting Mastra Spans to OTel Spans
+* with Semantic conventions for generative AI systems
+* @see https://github.com/open-telemetry/semantic-conventions/blob/v1.38.0/docs/gen-ai/README.md
+* @see https://github.com/open-telemetry/semantic-conventions/blob/v1.38.0/docs/gen-ai/gen-ai-events.md
+* @see https://github.com/open-telemetry/semantic-conventions/blob/v1.38.0/docs/gen-ai/gen-ai-spans.md
+* @see https://github.com/open-telemetry/semantic-conventions/blob/v1.38.0/docs/gen-ai/gen-ai-agent-spans.md
+* @see https://opentelemetry.io/docs/specs/semconv/gen-ai/non-normative/examples-llm-calls/
+* @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/
+*/
+/**
+* Formats UsageStats to OTel GenAI semantic convention attributes.
+*/
 function formatUsageMetrics(usage) {
-  if (!usage) return {};
-  const metrics = {};
-  if (usage.inputTokens !== void 0) {
-    metrics[incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
-  }
-  if (usage.outputTokens !== void 0) {
-    metrics[incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
-  }
-  if (usage.outputDetails?.reasoning !== void 0) {
-    metrics["gen_ai.usage.reasoning_tokens"] = usage.outputDetails.reasoning;
-  }
-  if (usage.inputDetails?.cacheRead !== void 0) {
-    metrics[incubating.ATTR_GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] = usage.inputDetails.cacheRead;
-  }
-  if (usage.inputDetails?.cacheWrite !== void 0) {
-    metrics[incubating.ATTR_GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS] = usage.inputDetails.cacheWrite;
-  }
-  if (usage.inputDetails?.audio !== void 0) {
-    metrics["gen_ai.usage.audio_input_tokens"] = usage.inputDetails.audio;
-  }
-  if (usage.outputDetails?.audio !== void 0) {
-    metrics["gen_ai.usage.audio_output_tokens"] = usage.outputDetails.audio;
-  }
-  return metrics;
+	if (!usage) return {};
+	const metrics = {};
+	if (usage.inputTokens !== void 0) metrics[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
+	if (usage.outputTokens !== void 0) metrics[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
+	if (usage.outputDetails?.reasoning !== void 0) metrics["gen_ai.usage.reasoning_tokens"] = usage.outputDetails.reasoning;
+	if (usage.inputDetails?.cacheRead !== void 0) metrics[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] = usage.inputDetails.cacheRead;
+	if (usage.inputDetails?.cacheWrite !== void 0) metrics[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS] = usage.inputDetails.cacheWrite;
+	if (usage.inputDetails?.audio !== void 0) metrics["gen_ai.usage.audio_input_tokens"] = usage.inputDetails.audio;
+	if (usage.outputDetails?.audio !== void 0) metrics["gen_ai.usage.audio_output_tokens"] = usage.outputDetails.audio;
+	return metrics;
 }
 function addModelRequestAttributes(attributes, attrs) {
-  if (attrs.model) {
-    attributes[incubating.ATTR_GEN_AI_REQUEST_MODEL] = attrs.model;
-  }
-  if (attrs.provider) {
-    attributes[incubating.ATTR_GEN_AI_PROVIDER_NAME] = normalizeProvider(attrs.provider);
-  }
-  Object.assign(attributes, formatUsageMetrics(attrs.usage));
+	if (attrs.model) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_MODEL] = attrs.model;
+	if (attrs.provider) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_PROVIDER_NAME] = normalizeProvider(attrs.provider);
+	Object.assign(attributes, formatUsageMetrics(attrs.usage));
 }
+/**
+* Get the operation name based on span type for gen_ai.operation.name
+*/
 function getOperationName(span) {
-  switch (span.type) {
-    case observability.SpanType.MODEL_GENERATION:
-      return "chat";
-    case observability.SpanType.RAG_EMBEDDING:
-      return "embeddings";
-    case observability.SpanType.TOOL_CALL:
-    case observability.SpanType.MCP_TOOL_CALL:
-    case observability.SpanType.PROVIDER_TOOL_CALL:
-      return "execute_tool";
-    case observability.SpanType.AGENT_RUN:
-      return "invoke_agent";
-    case observability.SpanType.WORKFLOW_RUN:
-      return "invoke_workflow";
-    default:
-      return span.type.toLowerCase();
-  }
+	switch (span.type) {
+		case _mastra_core_observability.SpanType.MODEL_GENERATION: return "chat";
+		case _mastra_core_observability.SpanType.RAG_EMBEDDING: return "embeddings";
+		case _mastra_core_observability.SpanType.TOOL_CALL:
+		case _mastra_core_observability.SpanType.MCP_TOOL_CALL:
+		case _mastra_core_observability.SpanType.PROVIDER_TOOL_CALL: return "execute_tool";
+		case _mastra_core_observability.SpanType.AGENT_RUN: return "invoke_agent";
+		case _mastra_core_observability.SpanType.WORKFLOW_RUN: return "invoke_workflow";
+		default: return span.type.toLowerCase();
+	}
 }
+/**
+* Keep only unicode letters, numbers, dot, underscore, space, dash.
+*/
 function sanitizeSpanName(name) {
-  return name.replace(/[^\p{L}\p{N}._ -]/gu, "");
+	return name.replace(/[^\p{L}\p{N}._ -]/gu, "");
 }
 function getSpanIdentifier(span) {
-  switch (span.type) {
-    case observability.SpanType.MODEL_GENERATION: {
-      const attrs = span.attributes;
-      return attrs?.model;
-    }
-    case observability.SpanType.RAG_EMBEDDING: {
-      const attrs = span.attributes;
-      return attrs?.model;
-    }
-    default:
-      return span.entityName ?? span.entityId;
-  }
+	switch (span.type) {
+		case _mastra_core_observability.SpanType.MODEL_GENERATION: return span.attributes?.model;
+		case _mastra_core_observability.SpanType.RAG_EMBEDDING: return span.attributes?.model;
+		default: return span.entityName ?? span.entityId;
+	}
 }
+/**
+* Get an OTEL-compliant span name based on span type and attributes
+*/
 function getSpanName(span) {
-  const identifier = getSpanIdentifier(span);
-  if (identifier) {
-    const operation = getOperationName(span);
-    return `${operation} ${identifier}`;
-  }
-  return sanitizeSpanName(span.name);
+	const identifier = getSpanIdentifier(span);
+	if (identifier) return `${getOperationName(span)} ${identifier}`;
+	return sanitizeSpanName(span.name);
 }
+/**
+* Gets OpenTelemetry attributes from Mastra Span
+* Following OTEL Semantic Conventions for GenAI
+*/
 function getAttributes(span) {
-  const attributes = {};
-  const spanType = span.type.toLowerCase();
-  attributes[incubating.ATTR_GEN_AI_OPERATION_NAME] = getOperationName(span);
-  attributes["mastra.span.type"] = span.type;
-  if (span.input !== void 0) {
-    const inputStr = typeof span.input === "string" ? span.input : JSON.stringify(span.input);
-    if (span.type === observability.SpanType.MODEL_GENERATION) {
-      attributes[incubating.ATTR_GEN_AI_INPUT_MESSAGES] = convertMastraMessagesToGenAIMessages(inputStr);
-    } else if (span.type === observability.SpanType.TOOL_CALL || span.type === observability.SpanType.MCP_TOOL_CALL || span.type === observability.SpanType.PROVIDER_TOOL_CALL) {
-      attributes["gen_ai.tool.call.arguments"] = inputStr;
-    } else {
-      attributes[`mastra.${spanType}.input`] = inputStr;
-    }
-  }
-  if (span.output !== void 0) {
-    const outputStr = typeof span.output === "string" ? span.output : JSON.stringify(span.output);
-    if (span.type === observability.SpanType.MODEL_GENERATION) {
-      attributes[incubating.ATTR_GEN_AI_OUTPUT_MESSAGES] = convertMastraMessagesToGenAIMessages(outputStr);
-    } else if (span.type === observability.SpanType.TOOL_CALL || span.type === observability.SpanType.MCP_TOOL_CALL || span.type === observability.SpanType.PROVIDER_TOOL_CALL) {
-      attributes["gen_ai.tool.call.result"] = outputStr;
-    } else {
-      attributes[`mastra.${spanType}.output`] = outputStr;
-    }
-  }
-  if (span.type === observability.SpanType.MODEL_GENERATION && span.attributes) {
-    const modelAttrs = span.attributes;
-    addModelRequestAttributes(attributes, modelAttrs);
-    if (span.entityId) {
-      attributes[incubating.ATTR_GEN_AI_AGENT_ID] = span.entityId;
-    }
-    if (span.entityName) {
-      attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = span.entityName;
-    }
-    if (modelAttrs.parameters) {
-      if (modelAttrs.parameters.temperature !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_TEMPERATURE] = modelAttrs.parameters.temperature;
-      }
-      if (modelAttrs.parameters.maxOutputTokens !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_MAX_TOKENS] = modelAttrs.parameters.maxOutputTokens;
-      }
-      if (modelAttrs.parameters.topP !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_TOP_P] = modelAttrs.parameters.topP;
-      }
-      if (modelAttrs.parameters.topK !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_TOP_K] = modelAttrs.parameters.topK;
-      }
-      if (modelAttrs.parameters.presencePenalty !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY] = modelAttrs.parameters.presencePenalty;
-      }
-      if (modelAttrs.parameters.frequencyPenalty !== void 0) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY] = modelAttrs.parameters.frequencyPenalty;
-      }
-      if (modelAttrs.parameters.stopSequences) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_STOP_SEQUENCES] = JSON.stringify(modelAttrs.parameters.stopSequences);
-      }
-      if (modelAttrs.parameters.seed) {
-        attributes[incubating.ATTR_GEN_AI_REQUEST_SEED] = modelAttrs.parameters.seed;
-      }
-    }
-    if (modelAttrs.completionStartTime) {
-      attributes["mastra.completion_start_time"] = modelAttrs.completionStartTime.toISOString();
-    }
-    if (modelAttrs.finishReason) {
-      attributes[incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS] = JSON.stringify([modelAttrs.finishReason]);
-    }
-    if (modelAttrs.responseModel) {
-      attributes[incubating.ATTR_GEN_AI_RESPONSE_MODEL] = modelAttrs.responseModel;
-    }
-    if (modelAttrs.responseId) {
-      attributes[incubating.ATTR_GEN_AI_RESPONSE_ID] = modelAttrs.responseId;
-    }
-    if (modelAttrs.serverAddress) {
-      attributes[incubating.ATTR_SERVER_ADDRESS] = modelAttrs.serverAddress;
-    }
-    if (modelAttrs.serverPort !== void 0) {
-      attributes[incubating.ATTR_SERVER_PORT] = modelAttrs.serverPort;
-    }
-  }
-  if (span.type === observability.SpanType.RAG_EMBEDDING && span.attributes) {
-    const embeddingAttrs = span.attributes;
-    addModelRequestAttributes(attributes, embeddingAttrs);
-    if (embeddingAttrs.mode) {
-      attributes[`mastra.${spanType}.mode`] = embeddingAttrs.mode;
-    }
-    if (embeddingAttrs.dimensions !== void 0) {
-      attributes["gen_ai.embeddings.dimension.count"] = embeddingAttrs.dimensions;
-      attributes[`mastra.${spanType}.dimensions`] = embeddingAttrs.dimensions;
-    }
-    if (embeddingAttrs.inputCount !== void 0) {
-      attributes[`mastra.${spanType}.input_count`] = embeddingAttrs.inputCount;
-    }
-  }
-  if ((span.type === observability.SpanType.TOOL_CALL || span.type === observability.SpanType.MCP_TOOL_CALL || span.type === observability.SpanType.PROVIDER_TOOL_CALL) && span.attributes) {
-    attributes[incubating.ATTR_GEN_AI_TOOL_NAME] = span.entityName ?? span.entityId;
-    if (span.type === observability.SpanType.MCP_TOOL_CALL) {
-      const mcpAttrs = span.attributes;
-      if (mcpAttrs.mcpServer) {
-        attributes[incubating.ATTR_SERVER_ADDRESS] = mcpAttrs.mcpServer;
-      }
-    } else {
-      const toolAttrs = span.attributes;
-      if (toolAttrs.toolDescription) {
-        attributes[incubating.ATTR_GEN_AI_TOOL_DESCRIPTION] = toolAttrs.toolDescription;
-      }
-      if (toolAttrs.toolType) {
-        attributes["gen_ai.tool.type"] = toolAttrs.toolType;
-      }
-    }
-  }
-  if (span.type === observability.SpanType.AGENT_RUN && span.attributes) {
-    const agentAttrs = span.attributes;
-    if (span.entityId) {
-      attributes[incubating.ATTR_GEN_AI_AGENT_ID] = span.entityId;
-    }
-    if (span.entityName) {
-      attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = span.entityName;
-    }
-    if (agentAttrs.conversationId) {
-      attributes[incubating.ATTR_GEN_AI_CONVERSATION_ID] = agentAttrs.conversationId;
-    }
-    if (agentAttrs.maxSteps) {
-      attributes[`mastra.${spanType}.max_steps`] = agentAttrs.maxSteps;
-    }
-    if (agentAttrs.availableTools) {
-      attributes[`gen_ai.tool.definitions`] = JSON.stringify(agentAttrs.availableTools);
-    }
-    attributes[incubating.ATTR_GEN_AI_SYSTEM_INSTRUCTIONS] = agentAttrs.instructions;
-  }
-  if (span.errorInfo) {
-    attributes[incubating.ATTR_ERROR_TYPE] = span.errorInfo.id || "unknown";
-    attributes[incubating.ATTR_ERROR_MESSAGE] = span.errorInfo.message;
-    if (span.errorInfo.domain) {
-      attributes["error.domain"] = span.errorInfo.domain;
-    }
-    if (span.errorInfo.category) {
-      attributes["error.category"] = span.errorInfo.category;
-    }
-  }
-  const threadId = span.metadata?.threadId;
-  if (typeof threadId === "string" && threadId.length > 0) {
-    attributes[incubating.ATTR_GEN_AI_CONVERSATION_ID] = threadId;
-  }
-  return attributes;
+	const attributes = {};
+	const spanType = span.type.toLowerCase();
+	attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_OPERATION_NAME] = getOperationName(span);
+	attributes["mastra.span.type"] = span.type;
+	if (span.input !== void 0) {
+		const inputStr = typeof span.input === "string" ? span.input : JSON.stringify(span.input);
+		if (span.type === _mastra_core_observability.SpanType.MODEL_GENERATION) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_INPUT_MESSAGES] = convertMastraMessagesToGenAIMessages(inputStr);
+		else if (span.type === _mastra_core_observability.SpanType.TOOL_CALL || span.type === _mastra_core_observability.SpanType.MCP_TOOL_CALL || span.type === _mastra_core_observability.SpanType.PROVIDER_TOOL_CALL) attributes["gen_ai.tool.call.arguments"] = inputStr;
+		else attributes[`mastra.${spanType}.input`] = inputStr;
+	}
+	if (span.output !== void 0) {
+		const outputStr = typeof span.output === "string" ? span.output : JSON.stringify(span.output);
+		if (span.type === _mastra_core_observability.SpanType.MODEL_GENERATION) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_OUTPUT_MESSAGES] = convertMastraMessagesToGenAIMessages(outputStr);
+		else if (span.type === _mastra_core_observability.SpanType.TOOL_CALL || span.type === _mastra_core_observability.SpanType.MCP_TOOL_CALL || span.type === _mastra_core_observability.SpanType.PROVIDER_TOOL_CALL) attributes["gen_ai.tool.call.result"] = outputStr;
+		else attributes[`mastra.${spanType}.output`] = outputStr;
+	}
+	if (span.type === _mastra_core_observability.SpanType.MODEL_GENERATION && span.attributes) {
+		const modelAttrs = span.attributes;
+		addModelRequestAttributes(attributes, modelAttrs);
+		if (span.entityId) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_AGENT_ID] = span.entityId;
+		if (span.entityName) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_AGENT_NAME] = span.entityName;
+		if (modelAttrs.parameters) {
+			if (modelAttrs.parameters.temperature !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_TEMPERATURE] = modelAttrs.parameters.temperature;
+			if (modelAttrs.parameters.maxOutputTokens !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_MAX_TOKENS] = modelAttrs.parameters.maxOutputTokens;
+			if (modelAttrs.parameters.topP !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_TOP_P] = modelAttrs.parameters.topP;
+			if (modelAttrs.parameters.topK !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_TOP_K] = modelAttrs.parameters.topK;
+			if (modelAttrs.parameters.presencePenalty !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY] = modelAttrs.parameters.presencePenalty;
+			if (modelAttrs.parameters.frequencyPenalty !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY] = modelAttrs.parameters.frequencyPenalty;
+			if (modelAttrs.parameters.stopSequences) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_STOP_SEQUENCES] = JSON.stringify(modelAttrs.parameters.stopSequences);
+			if (modelAttrs.parameters.seed) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_REQUEST_SEED] = modelAttrs.parameters.seed;
+		}
+		if (modelAttrs.completionStartTime) attributes["mastra.completion_start_time"] = modelAttrs.completionStartTime.toISOString();
+		if (modelAttrs.finishReason) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS] = JSON.stringify([modelAttrs.finishReason]);
+		if (modelAttrs.responseModel) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_RESPONSE_MODEL] = modelAttrs.responseModel;
+		if (modelAttrs.responseId) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_RESPONSE_ID] = modelAttrs.responseId;
+		if (modelAttrs.serverAddress) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_SERVER_ADDRESS] = modelAttrs.serverAddress;
+		if (modelAttrs.serverPort !== void 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_SERVER_PORT] = modelAttrs.serverPort;
+	}
+	if (span.type === _mastra_core_observability.SpanType.RAG_EMBEDDING && span.attributes) {
+		const embeddingAttrs = span.attributes;
+		addModelRequestAttributes(attributes, embeddingAttrs);
+		if (embeddingAttrs.mode) attributes[`mastra.${spanType}.mode`] = embeddingAttrs.mode;
+		if (embeddingAttrs.dimensions !== void 0) {
+			attributes["gen_ai.embeddings.dimension.count"] = embeddingAttrs.dimensions;
+			attributes[`mastra.${spanType}.dimensions`] = embeddingAttrs.dimensions;
+		}
+		if (embeddingAttrs.inputCount !== void 0) attributes[`mastra.${spanType}.input_count`] = embeddingAttrs.inputCount;
+	}
+	if ((span.type === _mastra_core_observability.SpanType.TOOL_CALL || span.type === _mastra_core_observability.SpanType.MCP_TOOL_CALL || span.type === _mastra_core_observability.SpanType.PROVIDER_TOOL_CALL) && span.attributes) {
+		attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_TOOL_NAME] = span.entityName ?? span.entityId;
+		if (span.type === _mastra_core_observability.SpanType.MCP_TOOL_CALL) {
+			const mcpAttrs = span.attributes;
+			if (mcpAttrs.mcpServer) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_SERVER_ADDRESS] = mcpAttrs.mcpServer;
+		} else {
+			const toolAttrs = span.attributes;
+			if (toolAttrs.toolDescription) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_TOOL_DESCRIPTION] = toolAttrs.toolDescription;
+			if (toolAttrs.toolType) attributes["gen_ai.tool.type"] = toolAttrs.toolType;
+		}
+	}
+	if (span.type === _mastra_core_observability.SpanType.AGENT_RUN && span.attributes) {
+		const agentAttrs = span.attributes;
+		if (span.entityId) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_AGENT_ID] = span.entityId;
+		if (span.entityName) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_AGENT_NAME] = span.entityName;
+		if (agentAttrs.conversationId) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_CONVERSATION_ID] = agentAttrs.conversationId;
+		if (agentAttrs.maxSteps) attributes[`mastra.${spanType}.max_steps`] = agentAttrs.maxSteps;
+		if (agentAttrs.availableTools) attributes[`gen_ai.tool.definitions`] = JSON.stringify(agentAttrs.availableTools);
+		attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_SYSTEM_INSTRUCTIONS] = agentAttrs.instructions;
+	}
+	if (span.errorInfo) {
+		attributes[_opentelemetry_semantic_conventions_incubating.ATTR_ERROR_TYPE] = span.errorInfo.id || "unknown";
+		attributes[_opentelemetry_semantic_conventions_incubating.ATTR_ERROR_MESSAGE] = span.errorInfo.message;
+		if (span.errorInfo.domain) attributes["error.domain"] = span.errorInfo.domain;
+		if (span.errorInfo.category) attributes["error.category"] = span.errorInfo.category;
+	}
+	const threadId = span.metadata?.threadId;
+	if (typeof threadId === "string" && threadId.length > 0) attributes[_opentelemetry_semantic_conventions_incubating.ATTR_GEN_AI_CONVERSATION_ID] = threadId;
+	return attributes;
 }
-var PROVIDER_ALIASES = {
-  anthropic: ["anthropic", "claude"],
-  "aws.bedrock": ["awsbedrock", "bedrock", "amazonbedrock"],
-  "azure.ai.inference": ["azureaiinference", "azureinference"],
-  "azure.ai.openai": ["azureaiopenai", "azureopenai", "msopenai", "microsoftopenai"],
-  cohere: ["cohere"],
-  deepseek: ["deepseek"],
-  "gcp.gemini": ["gcpgemini", "gemini"],
-  "gcp.gen_ai": ["gcpgenai", "googlegenai", "googleai"],
-  "gcp.vertex_ai": ["gcpvertexai", "vertexai"],
-  groq: ["groq"],
-  "ibm.watsonx.ai": ["ibmwatsonxai", "watsonx", "watsonxai"],
-  mistral_ai: ["mistral", "mistralai"],
-  openai: ["openai", "oai"],
-  perplexity: ["perplexity", "pplx"],
-  x_ai: ["xai", "x-ai", "x_ai", "x.com ai"]
+/**
+* Canonical OTel provider keys mapped to a list of possible fuzzy aliases.
+*/
+const PROVIDER_ALIASES = {
+	anthropic: ["anthropic", "claude"],
+	"aws.bedrock": [
+		"awsbedrock",
+		"bedrock",
+		"amazonbedrock"
+	],
+	"azure.ai.inference": ["azureaiinference", "azureinference"],
+	"azure.ai.openai": [
+		"azureaiopenai",
+		"azureopenai",
+		"msopenai",
+		"microsoftopenai"
+	],
+	cohere: ["cohere"],
+	deepseek: ["deepseek"],
+	"gcp.gemini": ["gcpgemini", "gemini"],
+	"gcp.gen_ai": [
+		"gcpgenai",
+		"googlegenai",
+		"googleai"
+	],
+	"gcp.vertex_ai": ["gcpvertexai", "vertexai"],
+	groq: ["groq"],
+	"ibm.watsonx.ai": [
+		"ibmwatsonxai",
+		"watsonx",
+		"watsonxai"
+	],
+	mistral_ai: ["mistral", "mistralai"],
+	openai: ["openai", "oai"],
+	perplexity: ["perplexity", "pplx"],
+	x_ai: [
+		"xai",
+		"x-ai",
+		"x_ai",
+		"x.com ai"
+	]
 };
+/**
+* Normalize a provider input string into a matchable token.
+* Keep only alphanumerics and lowercase the result.
+*/
 function normalizeProviderString(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]/g, "");
+	return input.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
+/**
+* Attempts to map a providerName to one of the canonical OTel provider names.
+* If no match is found, returns the original providerName unchanged.
+*/
 function normalizeProvider(providerName) {
-  const normalized = normalizeProviderString(providerName);
-  for (const [canonical, aliases] of Object.entries(PROVIDER_ALIASES)) {
-    for (const alias of aliases) {
-      if (normalized === alias) {
-        return canonical;
-      }
-    }
-  }
-  return providerName.toLowerCase();
+	const normalized = normalizeProviderString(providerName);
+	for (const [canonical, aliases] of Object.entries(PROVIDER_ALIASES)) for (const alias of aliases) if (normalized === alias) return canonical;
+	return providerName.toLowerCase();
 }
-
-// src/span-converter.ts
+//#endregion
+//#region src/span-converter.ts
+/**
+* Convert Mastra Spans to OpenTelemetry spans
+*/
 var SpanConverter = class {
-  constructor(params) {
-    this.params = params;
-    this.format = params.format;
-  }
-  params;
-  resource;
-  scope;
-  initPromise;
-  format;
-  /**
-   * Lazily initialize resource & scope on first use.
-   * Subsequent calls reuse the same promise (no races).
-   */
-  async initIfNeeded() {
-    if (this.initPromise) {
-      return this.initPromise;
-    }
-    this.initPromise = (async () => {
-      const packageVersion = await getPackageVersion(this.params.packageName) ?? "unknown";
-      const serviceVersion = await getPackageVersion("@mastra/core") ?? "unknown";
-      let resource = resources.resourceFromAttributes({
-        [semanticConventions.ATTR_SERVICE_NAME]: this.params.serviceName || "mastra-service",
-        [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion,
-        [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: this.params.packageName,
-        [semanticConventions.ATTR_TELEMETRY_SDK_VERSION]: packageVersion,
-        [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
-      });
-      if (this.params.config?.resourceAttributes) {
-        resource = resource.merge(
-          // Duplicate attributes from config will override defaults above
-          resources.resourceFromAttributes(this.params.config.resourceAttributes)
-        );
-      }
-      this.resource = resource;
-      this.scope = {
-        name: this.params.packageName,
-        version: packageVersion
-      };
-    })();
-    return this.initPromise;
-  }
-  /**
-   * Convert a Mastra Span to an OpenTelemetry ReadableSpan
-   */
-  async convertSpan(span) {
-    await this.initIfNeeded();
-    if (!this.resource || !this.scope) {
-      throw new Error("SpanConverter not initialized correctly");
-    }
-    const name = getSpanName(span);
-    const kind = getSpanKind(span.type);
-    const attributes = getAttributes(span);
-    if (span.metadata) {
-      for (const [k, v] of Object.entries(span.metadata)) {
-        if (v === null || v === void 0) {
-          continue;
-        }
-        attributes[`mastra.metadata.${k}`] = typeof v === "object" ? JSON.stringify(v) : v;
-      }
-    }
-    if (span.isRootSpan && span.tags?.length) {
-      attributes["mastra.tags"] = JSON.stringify(span.tags);
-    }
-    const startTime = dateToHrTime2(span.startTime);
-    const endTime = span.endTime ? dateToHrTime2(span.endTime) : startTime;
-    const duration = computeDuration(span.startTime, span.endTime);
-    const { status, events } = buildStatusAndEvents(span, startTime);
-    const spanContext = {
-      traceId: span.traceId,
-      spanId: span.id,
-      traceFlags: api.TraceFlags.SAMPLED,
-      isRemote: false
-    };
-    const parentSpanContext = span.parentSpanId ? {
-      traceId: span.traceId,
-      spanId: span.parentSpanId,
-      traceFlags: api.TraceFlags.SAMPLED,
-      isRemote: false
-    } : void 0;
-    const links = [];
-    const readable = {
-      name,
-      kind,
-      spanContext: () => spanContext,
-      parentSpanContext,
-      startTime,
-      endTime,
-      status,
-      attributes,
-      links,
-      events,
-      duration,
-      ended: !!span.endTime,
-      resource: this.resource,
-      instrumentationScope: this.scope,
-      droppedAttributesCount: 0,
-      droppedEventsCount: 0,
-      droppedLinksCount: 0
-    };
-    return readable;
-  }
+	params;
+	resource;
+	scope;
+	initPromise;
+	format;
+	constructor(params) {
+		this.params = params;
+		this.format = params.format;
+	}
+	/**
+	* Lazily initialize resource & scope on first use.
+	* Subsequent calls reuse the same promise (no races).
+	*/
+	async initIfNeeded() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = (async () => {
+			const packageVersion = await getPackageVersion(this.params.packageName) ?? "unknown";
+			const serviceVersion = await getPackageVersion("@mastra/core") ?? "unknown";
+			let resource = (0, _opentelemetry_resources.resourceFromAttributes)({
+				[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: this.params.serviceName || "mastra-service",
+				[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: serviceVersion,
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: this.params.packageName,
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: packageVersion,
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
+			});
+			if (this.params.config?.resourceAttributes) resource = resource.merge((0, _opentelemetry_resources.resourceFromAttributes)(this.params.config.resourceAttributes));
+			this.resource = resource;
+			this.scope = {
+				name: this.params.packageName,
+				version: packageVersion
+			};
+		})();
+		return this.initPromise;
+	}
+	/**
+	* Convert a Mastra Span to an OpenTelemetry ReadableSpan
+	*/
+	async convertSpan(span) {
+		await this.initIfNeeded();
+		if (!this.resource || !this.scope) throw new Error("SpanConverter not initialized correctly");
+		const name = getSpanName(span);
+		const kind = getSpanKind(span.type);
+		const attributes = getAttributes(span);
+		if (span.metadata) for (const [k, v] of Object.entries(span.metadata)) {
+			if (v === null || v === void 0) continue;
+			attributes[`mastra.metadata.${k}`] = typeof v === "object" ? JSON.stringify(v) : v;
+		}
+		if (span.isRootSpan && span.tags?.length) attributes["mastra.tags"] = JSON.stringify(span.tags);
+		const startTime = dateToHrTime(span.startTime);
+		const endTime = span.endTime ? dateToHrTime(span.endTime) : startTime;
+		const duration = computeDuration(span.startTime, span.endTime);
+		const { status, events } = buildStatusAndEvents(span, startTime);
+		const spanContext = {
+			traceId: span.traceId,
+			spanId: span.id,
+			traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+			isRemote: false
+		};
+		return {
+			name,
+			kind,
+			spanContext: () => spanContext,
+			parentSpanContext: span.parentSpanId ? {
+				traceId: span.traceId,
+				spanId: span.parentSpanId,
+				traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+				isRemote: false
+			} : void 0,
+			startTime,
+			endTime,
+			status,
+			attributes,
+			links: [],
+			events,
+			duration,
+			ended: !!span.endTime,
+			resource: this.resource,
+			instrumentationScope: this.scope,
+			droppedAttributesCount: 0,
+			droppedEventsCount: 0,
+			droppedLinksCount: 0
+		};
+	}
 };
 async function getPackageVersion(pkgName) {
-  try {
-    const manifestUrl = new URL(await undefined(`${pkgName}/package.json`));
-    const path = url.fileURLToPath(manifestUrl);
-    const pkgJson = JSON.parse(fs.readFileSync(path, "utf8"));
-    return pkgJson.version;
-  } catch {
-    return void 0;
-  }
+	try {
+		const path = (0, url.fileURLToPath)(new URL(await {}.resolve(`${pkgName}/package.json`)));
+		return JSON.parse((0, fs.readFileSync)(path, "utf8")).version;
+	} catch {
+		return;
+	}
 }
+/**
+* Get the appropriate Otel SpanKind based on Mastra SpanType.
+*
+* @param type - The Mastra span type
+* @returns The appropriate OTEL SpanKind
+*/
 function getSpanKind(type) {
-  switch (type) {
-    case observability.SpanType.MODEL_GENERATION:
-    case observability.SpanType.RAG_EMBEDDING:
-    case observability.SpanType.MCP_TOOL_CALL:
-      return api.SpanKind.CLIENT;
-    default:
-      return api.SpanKind.INTERNAL;
-  }
+	switch (type) {
+		case _mastra_core_observability.SpanType.MODEL_GENERATION:
+		case _mastra_core_observability.SpanType.RAG_EMBEDDING:
+		case _mastra_core_observability.SpanType.MCP_TOOL_CALL: return _opentelemetry_api.SpanKind.CLIENT;
+		default: return _opentelemetry_api.SpanKind.INTERNAL;
+	}
 }
-function dateToHrTime2(date) {
-  const ms = date.getTime();
-  const seconds = Math.floor(ms / 1e3);
-  const nanoseconds = ms % 1e3 * 1e6;
-  return [seconds, nanoseconds];
+/**
+* Convert JavaScript Date to hrtime format
+*/
+function dateToHrTime(date) {
+	const ms = date.getTime();
+	return [Math.floor(ms / 1e3), ms % 1e3 * 1e6];
 }
 function computeDuration(start, end) {
-  if (!end) return [0, 0];
-  const diffMs = end.getTime() - start.getTime();
-  return [Math.floor(diffMs / 1e3), diffMs % 1e3 * 1e6];
+	if (!end) return [0, 0];
+	const diffMs = end.getTime() - start.getTime();
+	return [Math.floor(diffMs / 1e3), diffMs % 1e3 * 1e6];
 }
+/**
+* Build status + events from span.errorInfo (if present)
+*/
 function buildStatusAndEvents(span, defaultTime) {
-  const events = [];
-  if (span.errorInfo) {
-    const status = {
-      code: api.SpanStatusCode.ERROR,
-      message: span.errorInfo.message
-    };
-    events.push({
-      name: "exception",
-      attributes: {
-        "exception.message": span.errorInfo.message,
-        "exception.type": "Error",
-        ...span.errorInfo.details?.stack && {
-          "exception.stacktrace": span.errorInfo.details.stack
-        }
-      },
-      time: defaultTime,
-      droppedAttributesCount: 0
-    });
-    return { status, events };
-  }
-  if (span.endTime) {
-    return {
-      status: { code: api.SpanStatusCode.OK },
-      events
-    };
-  }
-  return {
-    status: { code: api.SpanStatusCode.UNSET },
-    events
-  };
+	const events = [];
+	if (span.errorInfo) {
+		const status = {
+			code: _opentelemetry_api.SpanStatusCode.ERROR,
+			message: span.errorInfo.message
+		};
+		events.push({
+			name: "exception",
+			attributes: {
+				"exception.message": span.errorInfo.message,
+				"exception.type": "Error",
+				...span.errorInfo.details?.stack && { "exception.stacktrace": span.errorInfo.details.stack }
+			},
+			time: defaultTime,
+			droppedAttributesCount: 0
+		});
+		return {
+			status,
+			events
+		};
+	}
+	if (span.endTime) return {
+		status: { code: _opentelemetry_api.SpanStatusCode.OK },
+		events
+	};
+	return {
+		status: { code: _opentelemetry_api.SpanStatusCode.UNSET },
+		events
+	};
 }
-
-// src/tracing.ts
+//#endregion
+//#region src/tracing.ts
+/**
+* Wrapper around a SpanExporter that logs export results when debug mode is enabled.
+* The OTel SDK intentionally does not log on success, making debugging difficult.
+* This wrapper adds visibility into each batch export's outcome.
+*/
 var DebugSpanExporterWrapper = class {
-  constructor(inner, debugLog) {
-    this.inner = inner;
-    this.debugLog = debugLog;
-  }
-  inner;
-  debugLog;
-  export(spans, resultCallback) {
-    const count = spans.length;
-    this.inner.export(spans, (result) => {
-      if (result.code === core.ExportResultCode.SUCCESS) {
-        this.debugLog(`[OtelExporter] Export completed: ${count} spans sent successfully`);
-      } else {
-        this.debugLog(`[OtelExporter] Export FAILED: ${count} spans, error: ${result.error?.message ?? "unknown"}`);
-      }
-      resultCallback(result);
-    });
-  }
-  async shutdown() {
-    return this.inner.shutdown();
-  }
-  async forceFlush() {
-    return this.inner.forceFlush?.();
-  }
+	inner;
+	debugLog;
+	constructor(inner, debugLog) {
+		this.inner = inner;
+		this.debugLog = debugLog;
+	}
+	export(spans, resultCallback) {
+		const count = spans.length;
+		this.inner.export(spans, (result) => {
+			if (result.code === _opentelemetry_core.ExportResultCode.SUCCESS) this.debugLog(`[OtelExporter] Export completed: ${count} spans sent successfully`);
+			else this.debugLog(`[OtelExporter] Export FAILED: ${count} spans, error: ${result.error?.message ?? "unknown"}`);
+			resultCallback(result);
+		});
+	}
+	async shutdown() {
+		return this.inner.shutdown();
+	}
+	async forceFlush() {
+		return this.inner.forceFlush?.();
+	}
 };
+/**
+* Wrapper around a LogRecordExporter that logs export results when debug mode is enabled.
+* Same pattern as DebugSpanExporterWrapper but for log records.
+*/
 var DebugLogExporterWrapper = class {
-  constructor(inner, debugLog) {
-    this.inner = inner;
-    this.debugLog = debugLog;
-  }
-  inner;
-  debugLog;
-  export(logs, resultCallback) {
-    const count = logs.length;
-    this.inner.export(logs, (result) => {
-      if (result.code === core.ExportResultCode.SUCCESS) {
-        this.debugLog(`[OtelExporter] Log export completed: ${count} logs sent successfully`);
-      } else {
-        this.debugLog(`[OtelExporter] Log export FAILED: ${count} logs, error: ${result.error?.message ?? "unknown"}`);
-      }
-      resultCallback(result);
-    });
-  }
-  async shutdown() {
-    return this.inner.shutdown();
-  }
-  async forceFlush() {
-    return this.inner.forceFlush?.();
-  }
+	inner;
+	debugLog;
+	constructor(inner, debugLog) {
+		this.inner = inner;
+		this.debugLog = debugLog;
+	}
+	export(logs, resultCallback) {
+		const count = logs.length;
+		this.inner.export(logs, (result) => {
+			if (result.code === _opentelemetry_core.ExportResultCode.SUCCESS) this.debugLog(`[OtelExporter] Log export completed: ${count} logs sent successfully`);
+			else this.debugLog(`[OtelExporter] Log export FAILED: ${count} logs, error: ${result.error?.message ?? "unknown"}`);
+			resultCallback(result);
+		});
+	}
+	async shutdown() {
+		return this.inner.shutdown();
+	}
+	async forceFlush() {
+		return this.inner.forceFlush?.();
+	}
 };
-var OtelExporter = class extends observability$1.BaseExporter {
-  config;
-  observabilityConfig;
-  // Trace signal
-  spanConverter;
-  processor;
-  exporter;
-  // Log signal
-  loggerProvider;
-  otelLogger;
-  // Provider config (resolved once, shared across signals)
-  resolvedConfig;
-  providerName;
-  // Single setup promise — all signals initialize together at init() time.
-  // Event handlers await this before processing. Never rejects.
-  setupPromise;
-  name = "opentelemetry";
-  constructor(config) {
-    super(config);
-    this.config = config;
-    if (config.logLevel === "debug") {
-      api.diag.setLogger(new api.DiagConsoleLogger(), api.DiagLogLevel.INFO);
-    }
-  }
-  /**
-   * Initialize with observability configuration and eagerly set up the trace
-   * and log signal exporters in parallel.
-   *
-   * Called by Mastra during component registration. The async setup runs in the
-   * background — event handlers await the resulting promise before processing.
-   */
-  init(options) {
-    this.observabilityConfig = options.config;
-    this.setupPromise = this.setupAllSignals();
-  }
-  // ===========================================================================
-  // Provider config resolution (shared across all signals)
-  // ===========================================================================
-  get isDebug() {
-    return this.config.logLevel === "debug";
-  }
-  /**
-   * Debug logging that bypasses the Mastra logger.
-   *
-   * The Mastra framework replaces our logger via __setLogger() with one at
-   * INFO level, which silently swallows all this.logger.debug() calls.
-   * For debug output we need to go through console.info directly.
-   */
-  debugLog = (...args) => this.isDebug && console.info("[OtelExporter:debug]", ...args);
-  resolveProvider() {
-    if (this.resolvedConfig !== void 0) {
-      return this.resolvedConfig;
-    }
-    if (!this.config.provider) {
-      this.setDisabled(
-        '[OtelExporter] Provider configuration is required. Use the "custom" provider for generic endpoints.'
-      );
-      this.resolvedConfig = null;
-      return null;
-    }
-    this.providerName = Object.keys(this.config.provider)[0];
-    const resolved = resolveProviderConfig(this.config.provider, this.isDebug);
-    if (!resolved) {
-      this.setDisabled("[OtelExporter] Provider configuration validation failed.");
-      this.resolvedConfig = null;
-      return null;
-    }
-    this.resolvedConfig = resolved;
-    return resolved;
-  }
-  /**
-   * Derive the endpoint for a specific signal from the resolved provider config.
-   * Strips trailing slashes and any existing signal-path suffix so we never
-   * produce a doubled "//v1/logs" or leave a stale "/v1/traces" on a logs URL.
-   */
-  getSignalEndpoint(resolved, signal) {
-    const signalPaths = {
-      traces: "/v1/traces",
-      logs: "/v1/logs"
-    };
-    let base = resolved.endpoint;
-    while (base.endsWith("/")) {
-      base = base.slice(0, -1);
-    }
-    for (const path of Object.values(signalPaths)) {
-      if (base.endsWith(path)) {
-        base = base.slice(0, -path.length);
-        break;
-      }
-    }
-    return base + signalPaths[signal];
-  }
-  /**
-   * Build exporter constructor options for the given signal endpoint.
-   * For gRPC, converts headers to Metadata. For HTTP protocols, passes headers directly.
-   */
-  async buildExporterOptions(protocol, url, headers) {
-    if (protocol === "grpc") {
-      const grpcModule = await import('@grpc/grpc-js');
-      const metadata = new grpcModule.Metadata();
-      for (const [key, value] of Object.entries(headers)) {
-        metadata.set(key, value);
-      }
-      return { url, metadata, timeoutMillis: this.config.timeout };
-    }
-    return { url, headers, timeoutMillis: this.config.timeout };
-  }
-  // ===========================================================================
-  // Setup — eager, parallel initialization of all signals
-  // ===========================================================================
-  /**
-   * Wait for setup to complete. If init() was called, this awaits the
-   * already-in-flight setup promise. If init() was never called (standalone
-   * usage without Mastra), this triggers setup on first use.
-   */
-  ensureSetup() {
-    if (!this.setupPromise) {
-      this.setupPromise = this.setupAllSignals();
-    }
-    return this.setupPromise;
-  }
-  /**
-   * Resolve provider config once and set up all enabled signals in parallel.
-   * Each signal setup catches its own errors — this method never rejects.
-   */
-  async setupAllSignals() {
-    const resolved = this.resolveProvider();
-    if (!resolved) {
-      this.debugLog("Setup skipped: provider not resolved");
-      return;
-    }
-    const protocol = resolved.protocol;
-    const setupTasks = [];
-    if (this.config.signals?.traces !== false) {
-      setupTasks.push(this.setupTraces(resolved, protocol));
-    } else {
-      this.debugLog("Trace export disabled via config");
-    }
-    if (this.config.signals?.logs !== false) {
-      setupTasks.push(this.setupLogs(resolved, protocol));
-    } else {
-      this.debugLog("Log export disabled via config");
-    }
-    await Promise.all(setupTasks);
-    this.debugLog(`Setup complete [traces=${!!this.processor}, logs=${!!this.otelLogger}]`);
-  }
-  // ---------------------------------------------------------------------------
-  // Trace setup
-  // ---------------------------------------------------------------------------
-  async setupTraces(resolved, protocol) {
-    try {
-      if (this.config.exporter) {
-        this.exporter = this.config.exporter;
-      } else {
-        const headers = resolved.headers;
-        const endpoint = protocol === "zipkin" ? resolved.endpoint : this.getSignalEndpoint(resolved, "traces");
-        this.debugLog(`Setting up trace exporter: protocol=${protocol}, endpoint=${endpoint}`);
-        const ExporterClass = await loadExporter(protocol, this.providerName);
-        if (!ExporterClass) {
-          this.debugLog(`Trace exporter not available for protocol: ${protocol}`);
-          return;
-        }
-        const exporterOptions = protocol === "zipkin" ? { url: endpoint, headers } : await this.buildExporterOptions(protocol, endpoint, headers);
-        this.exporter = new ExporterClass(exporterOptions);
-        this.debugLog(`Trace exporter created: ${this.exporter?.constructor?.name ?? "unknown"} -> ${endpoint}`);
-      }
-      const serviceName = this.observabilityConfig?.serviceName || "mastra-service";
-      this.spanConverter = new SpanConverter({
-        packageName: "@mastra/otel-exporter",
-        serviceName,
-        config: this.config,
-        format: "GenAI_v1_38_0"
-      });
-      const exporterForProcessor = this.isDebug ? new DebugSpanExporterWrapper(this.exporter, (msg) => this.debugLog(msg)) : this.exporter;
-      this.processor = new sdkTraceBase.BatchSpanProcessor(exporterForProcessor, {
-        maxExportBatchSize: this.config.batchSize || 512,
-        maxQueueSize: 2048,
-        scheduledDelayMillis: 5e3,
-        exportTimeoutMillis: this.config.timeout || 3e4
-      });
-      this.debugLog(
-        `Trace export initialized (service.name: "${serviceName}", batch size: ${this.config.batchSize || 512}, delay: 5s)`
-      );
-    } catch (error) {
-      this.logger.warn("[OtelExporter] Failed to initialize trace export");
-      this.debugLog("Trace setup error:", error);
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Log setup
-  // ---------------------------------------------------------------------------
-  async setupLogs(resolved, protocol) {
-    try {
-      const LogExporterClass = await loadSignalExporter("logs", protocol, this.providerName);
-      if (!LogExporterClass) {
-        this.debugLog(`Log exporter package not available for protocol "${protocol}". Log export disabled.`);
-        return;
-      }
-      const logEndpoint = this.getSignalEndpoint(resolved, "logs");
-      const headers = resolved.headers;
-      this.debugLog(`Setting up log exporter: protocol=${protocol}, endpoint=${logEndpoint}`);
-      const logExporterOptions = await this.buildExporterOptions(protocol, logEndpoint, headers);
-      const logExporter = new LogExporterClass(logExporterOptions);
-      const exporterForProcessor = this.isDebug ? new DebugLogExporterWrapper(logExporter, (msg) => this.debugLog(msg)) : logExporter;
-      const resource = resources.resourceFromAttributes({
-        ...this.config.resourceAttributes ?? {},
-        [semanticConventions.ATTR_SERVICE_NAME]: this.observabilityConfig?.serviceName || "mastra-service"
-      });
-      this.loggerProvider = new sdkLogs.LoggerProvider({
-        resource,
-        processors: [
-          new sdkLogs.BatchLogRecordProcessor(exporterForProcessor, {
-            maxExportBatchSize: this.config.batchSize || 512,
-            maxQueueSize: 2048,
-            scheduledDelayMillis: 5e3,
-            exportTimeoutMillis: this.config.timeout || 3e4
-          })
-        ]
-      });
-      this.otelLogger = this.loggerProvider.getLogger("@mastra/otel-exporter");
-      this.debugLog(`Log export initialized (endpoint: ${logEndpoint})`);
-    } catch (error) {
-      this.logger.warn("[OtelExporter] Failed to initialize log export");
-      this.debugLog("Log setup error:", error);
-    }
-  }
-  // ===========================================================================
-  // Trace event handler
-  // ===========================================================================
-  async _exportTracingEvent(event) {
-    if (this.config.signals?.traces === false) return;
-    if (event.type !== observability.TracingEventType.SPAN_ENDED) return;
-    await this.ensureSetup();
-    if (this.isDisabled || !this.processor) return;
-    const span = event.exportedSpan;
-    try {
-      const otelSpan = await this.spanConverter.convertSpan(span);
-      this.processor.onEnd(otelSpan);
-      this.debugLog(
-        `Queued span ${span.id} (trace: ${span.traceId}, parent: ${span.parentSpanId || "none"}, type: ${span.type})`
-      );
-    } catch (error) {
-      this.logger.error(`[OtelExporter] Failed to export span ${span.id}:`, error);
-    }
-  }
-  // ===========================================================================
-  // Log event handler
-  // ===========================================================================
-  async onLogEvent(event) {
-    this.debugLog(`onLogEvent received (level: ${event.log.level}, message: "${event.log.message}")`);
-    await this.ensureSetup();
-    if (this.isDisabled) {
-      this.debugLog("Log event skipped: exporter is disabled");
-      return;
-    }
-    if (!this.otelLogger) {
-      this.debugLog("Log event skipped: log exporter not available");
-      return;
-    }
-    try {
-      const logParams = convertLog(event.log);
-      const attributes = { ...logParams.attributes };
-      let logContext = api.context.active();
-      if (logParams.traceId && logParams.spanId) {
-        attributes["mastra.traceId"] = logParams.traceId;
-        attributes["mastra.spanId"] = logParams.spanId;
-        logContext = api.trace.setSpanContext(logContext, {
-          traceId: logParams.traceId,
-          spanId: logParams.spanId,
-          traceFlags: api.TraceFlags.SAMPLED,
-          isRemote: false
-        });
-      }
-      this.otelLogger.emit({
-        timestamp: logParams.timestamp,
-        severityNumber: logParams.severityNumber,
-        severityText: logParams.severityText,
-        body: logParams.body,
-        attributes,
-        context: logContext
-      });
-      this.debugLog(`Exported log (level: ${event.log.level}, trace: ${event.log.traceId || "none"})`);
-    } catch (error) {
-      this.logger.error("[OtelExporter] Failed to export log:", error);
-    }
-  }
-  // ===========================================================================
-  // Lifecycle
-  // ===========================================================================
-  /**
-   * Force flush any buffered data without shutting down the exporter.
-   * Delegates to all active processors/providers.
-   */
-  async flush() {
-    if (this.setupPromise) {
-      await this.setupPromise;
-    }
-    const flushPromises = [];
-    const signals = [];
-    if (this.processor) {
-      flushPromises.push(this.processor.forceFlush());
-      signals.push("traces");
-    }
-    if (this.loggerProvider) {
-      flushPromises.push(this.loggerProvider.forceFlush());
-      signals.push("logs");
-    }
-    if (flushPromises.length > 0) {
-      this.debugLog(`Flushing signals: ${signals.join(", ")}...`);
-      await Promise.all(flushPromises);
-      this.debugLog("Flushed all pending data");
-    } else {
-      this.debugLog("Flush called but no active exporters");
-    }
-  }
-  async shutdown() {
-    if (this.setupPromise) {
-      await this.setupPromise;
-    }
-    const shutdownPromises = [];
-    if (this.processor) {
-      shutdownPromises.push(this.processor.shutdown());
-    }
-    if (this.loggerProvider) {
-      shutdownPromises.push(this.loggerProvider.shutdown());
-    }
-    if (shutdownPromises.length > 0) {
-      await Promise.all(shutdownPromises);
-    }
-  }
+var OtelExporter = class extends _mastra_observability.BaseExporter {
+	config;
+	observabilityConfig;
+	spanConverter;
+	processor;
+	exporter;
+	loggerProvider;
+	otelLogger;
+	resolvedConfig;
+	providerName;
+	setupPromise;
+	name = "opentelemetry";
+	constructor(config) {
+		super(config);
+		this.config = config;
+		if (config.logLevel === "debug") _opentelemetry_api.diag.setLogger(new _opentelemetry_api.DiagConsoleLogger(), _opentelemetry_api.DiagLogLevel.INFO);
+	}
+	/**
+	* Initialize with observability configuration and eagerly set up the trace
+	* and log signal exporters in parallel.
+	*
+	* Called by Mastra during component registration. The async setup runs in the
+	* background — event handlers await the resulting promise before processing.
+	*/
+	init(options) {
+		this.observabilityConfig = options.config;
+		this.setupPromise = this.setupAllSignals();
+	}
+	get isDebug() {
+		return this.config.logLevel === "debug";
+	}
+	/**
+	* Debug logging that bypasses the Mastra logger.
+	*
+	* The Mastra framework replaces our logger via __setLogger() with one at
+	* INFO level, which silently swallows all this.logger.debug() calls.
+	* For debug output we need to go through console.info directly.
+	*/
+	debugLog = (...args) => this.isDebug && console.info("[OtelExporter:debug]", ...args);
+	resolveProvider() {
+		if (this.resolvedConfig !== void 0) return this.resolvedConfig;
+		if (!this.config.provider) {
+			this.setDisabled("[OtelExporter] Provider configuration is required. Use the \"custom\" provider for generic endpoints.");
+			this.resolvedConfig = null;
+			return null;
+		}
+		this.providerName = Object.keys(this.config.provider)[0];
+		const resolved = resolveProviderConfig(this.config.provider, this.isDebug);
+		if (!resolved) {
+			this.setDisabled("[OtelExporter] Provider configuration validation failed.");
+			this.resolvedConfig = null;
+			return null;
+		}
+		this.resolvedConfig = resolved;
+		return resolved;
+	}
+	/**
+	* Derive the endpoint for a specific signal from the resolved provider config.
+	* Strips trailing slashes and any existing signal-path suffix so we never
+	* produce a doubled "//v1/logs" or leave a stale "/v1/traces" on a logs URL.
+	*/
+	getSignalEndpoint(resolved, signal) {
+		const signalPaths = {
+			traces: "/v1/traces",
+			logs: "/v1/logs"
+		};
+		let base = resolved.endpoint;
+		while (base.endsWith("/")) base = base.slice(0, -1);
+		for (const path of Object.values(signalPaths)) if (base.endsWith(path)) {
+			base = base.slice(0, -path.length);
+			break;
+		}
+		return base + signalPaths[signal];
+	}
+	/**
+	* Build exporter constructor options for the given signal endpoint.
+	* For gRPC, converts headers to Metadata. For HTTP protocols, passes headers directly.
+	*/
+	async buildExporterOptions(protocol, url, headers) {
+		if (protocol === "grpc") {
+			const metadata = new (await (import("@grpc/grpc-js"))).Metadata();
+			for (const [key, value] of Object.entries(headers)) metadata.set(key, value);
+			return {
+				url,
+				metadata,
+				timeoutMillis: this.config.timeout
+			};
+		}
+		return {
+			url,
+			headers,
+			timeoutMillis: this.config.timeout
+		};
+	}
+	/**
+	* Wait for setup to complete. If init() was called, this awaits the
+	* already-in-flight setup promise. If init() was never called (standalone
+	* usage without Mastra), this triggers setup on first use.
+	*/
+	ensureSetup() {
+		if (!this.setupPromise) this.setupPromise = this.setupAllSignals();
+		return this.setupPromise;
+	}
+	/**
+	* Resolve provider config once and set up all enabled signals in parallel.
+	* Each signal setup catches its own errors — this method never rejects.
+	*/
+	async setupAllSignals() {
+		const resolved = this.resolveProvider();
+		if (!resolved) {
+			this.debugLog("Setup skipped: provider not resolved");
+			return;
+		}
+		const protocol = resolved.protocol;
+		const setupTasks = [];
+		if (this.config.signals?.traces !== false) setupTasks.push(this.setupTraces(resolved, protocol));
+		else this.debugLog("Trace export disabled via config");
+		if (this.config.signals?.logs !== false) setupTasks.push(this.setupLogs(resolved, protocol));
+		else this.debugLog("Log export disabled via config");
+		await Promise.all(setupTasks);
+		this.debugLog(`Setup complete [traces=${!!this.processor}, logs=${!!this.otelLogger}]`);
+	}
+	async setupTraces(resolved, protocol) {
+		try {
+			if (this.config.exporter) this.exporter = this.config.exporter;
+			else {
+				const headers = resolved.headers;
+				const endpoint = protocol === "zipkin" ? resolved.endpoint : this.getSignalEndpoint(resolved, "traces");
+				this.debugLog(`Setting up trace exporter: protocol=${protocol}, endpoint=${endpoint}`);
+				const ExporterClass = await loadExporter(protocol, this.providerName);
+				if (!ExporterClass) {
+					this.debugLog(`Trace exporter not available for protocol: ${protocol}`);
+					return;
+				}
+				const exporterOptions = protocol === "zipkin" ? {
+					url: endpoint,
+					headers
+				} : await this.buildExporterOptions(protocol, endpoint, headers);
+				this.exporter = new ExporterClass(exporterOptions);
+				this.debugLog(`Trace exporter created: ${this.exporter?.constructor?.name ?? "unknown"} -> ${endpoint}`);
+			}
+			const serviceName = this.observabilityConfig?.serviceName || "mastra-service";
+			this.spanConverter = new SpanConverter({
+				packageName: "@mastra/otel-exporter",
+				serviceName,
+				config: this.config,
+				format: "GenAI_v1_38_0"
+			});
+			const exporterForProcessor = this.isDebug ? new DebugSpanExporterWrapper(this.exporter, (msg) => this.debugLog(msg)) : this.exporter;
+			this.processor = new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporterForProcessor, {
+				maxExportBatchSize: this.config.batchSize || 512,
+				maxQueueSize: 2048,
+				scheduledDelayMillis: 5e3,
+				exportTimeoutMillis: this.config.timeout || 3e4
+			});
+			this.debugLog(`Trace export initialized (service.name: "${serviceName}", batch size: ${this.config.batchSize || 512}, delay: 5s)`);
+		} catch (error) {
+			this.logger.warn("[OtelExporter] Failed to initialize trace export");
+			this.debugLog("Trace setup error:", error);
+		}
+	}
+	async setupLogs(resolved, protocol) {
+		try {
+			const LogExporterClass = await loadSignalExporter("logs", protocol, this.providerName);
+			if (!LogExporterClass) {
+				this.debugLog(`Log exporter package not available for protocol "${protocol}". Log export disabled.`);
+				return;
+			}
+			const logEndpoint = this.getSignalEndpoint(resolved, "logs");
+			const headers = resolved.headers;
+			this.debugLog(`Setting up log exporter: protocol=${protocol}, endpoint=${logEndpoint}`);
+			const logExporter = new LogExporterClass(await this.buildExporterOptions(protocol, logEndpoint, headers));
+			const exporterForProcessor = this.isDebug ? new DebugLogExporterWrapper(logExporter, (msg) => this.debugLog(msg)) : logExporter;
+			const resource = (0, _opentelemetry_resources.resourceFromAttributes)({
+				...this.config.resourceAttributes ?? {},
+				[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: this.observabilityConfig?.serviceName || "mastra-service"
+			});
+			this.loggerProvider = new _opentelemetry_sdk_logs.LoggerProvider({
+				resource,
+				processors: [new _opentelemetry_sdk_logs.BatchLogRecordProcessor(exporterForProcessor, {
+					maxExportBatchSize: this.config.batchSize || 512,
+					maxQueueSize: 2048,
+					scheduledDelayMillis: 5e3,
+					exportTimeoutMillis: this.config.timeout || 3e4
+				})]
+			});
+			this.otelLogger = this.loggerProvider.getLogger("@mastra/otel-exporter");
+			this.debugLog(`Log export initialized (endpoint: ${logEndpoint})`);
+		} catch (error) {
+			this.logger.warn("[OtelExporter] Failed to initialize log export");
+			this.debugLog("Log setup error:", error);
+		}
+	}
+	async _exportTracingEvent(event) {
+		if (this.config.signals?.traces === false) return;
+		if (event.type !== _mastra_core_observability.TracingEventType.SPAN_ENDED) return;
+		await this.ensureSetup();
+		if (this.isDisabled || !this.processor) return;
+		const span = event.exportedSpan;
+		try {
+			const otelSpan = await this.spanConverter.convertSpan(span);
+			this.processor.onEnd(otelSpan);
+			this.debugLog(`Queued span ${span.id} (trace: ${span.traceId}, parent: ${span.parentSpanId || "none"}, type: ${span.type})`);
+		} catch (error) {
+			this.logger.error(`[OtelExporter] Failed to export span ${span.id}:`, error);
+		}
+	}
+	async onLogEvent(event) {
+		this.debugLog(`onLogEvent received (level: ${event.log.level}, message: "${event.log.message}")`);
+		await this.ensureSetup();
+		if (this.isDisabled) {
+			this.debugLog("Log event skipped: exporter is disabled");
+			return;
+		}
+		if (!this.otelLogger) {
+			this.debugLog("Log event skipped: log exporter not available");
+			return;
+		}
+		try {
+			const logParams = convertLog(event.log);
+			const attributes = { ...logParams.attributes };
+			let logContext = _opentelemetry_api.context.active();
+			if (logParams.traceId && logParams.spanId) {
+				attributes["mastra.traceId"] = logParams.traceId;
+				attributes["mastra.spanId"] = logParams.spanId;
+				logContext = _opentelemetry_api.trace.setSpanContext(logContext, {
+					traceId: logParams.traceId,
+					spanId: logParams.spanId,
+					traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+					isRemote: false
+				});
+			}
+			this.otelLogger.emit({
+				timestamp: logParams.timestamp,
+				severityNumber: logParams.severityNumber,
+				severityText: logParams.severityText,
+				body: logParams.body,
+				attributes,
+				context: logContext
+			});
+			this.debugLog(`Exported log (level: ${event.log.level}, trace: ${event.log.traceId || "none"})`);
+		} catch (error) {
+			this.logger.error("[OtelExporter] Failed to export log:", error);
+		}
+	}
+	/**
+	* Force flush any buffered data without shutting down the exporter.
+	* Delegates to all active processors/providers.
+	*/
+	async flush() {
+		if (this.setupPromise) await this.setupPromise;
+		const flushPromises = [];
+		const signals = [];
+		if (this.processor) {
+			flushPromises.push(this.processor.forceFlush());
+			signals.push("traces");
+		}
+		if (this.loggerProvider) {
+			flushPromises.push(this.loggerProvider.forceFlush());
+			signals.push("logs");
+		}
+		if (flushPromises.length > 0) {
+			this.debugLog(`Flushing signals: ${signals.join(", ")}...`);
+			await Promise.all(flushPromises);
+			this.debugLog("Flushed all pending data");
+		} else this.debugLog("Flush called but no active exporters");
+	}
+	async shutdown() {
+		if (this.setupPromise) await this.setupPromise;
+		const shutdownPromises = [];
+		if (this.processor) shutdownPromises.push(this.processor.shutdown());
+		if (this.loggerProvider) shutdownPromises.push(this.loggerProvider.shutdown());
+		if (shutdownPromises.length > 0) await Promise.all(shutdownPromises);
+	}
 };
-
+//#endregion
 exports.OtelExporter = OtelExporter;
 exports.SpanConverter = SpanConverter;
 exports.buildLogAttributes = buildLogAttributes;
@@ -1196,5 +1048,5 @@ exports.getAttributes = getAttributes;
 exports.getSpanKind = getSpanKind;
 exports.getSpanName = getSpanName;
 exports.mapSeverity = mapSeverity;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map