@mastra/otel-exporter 0.0.0-dynamic-model-router-20251010230835 → 0.0.0-elated-armadillo-be37a1-20251219210627

package/dist/index.cjs

@@ -1,13 +1,16 @@
 'use strict';
 
-var aiTracing = require('@mastra/core/ai-tracing');
-var logger = require('@mastra/core/logger');
+var observability = require('@mastra/core/observability');
+var observability$1 = require('@mastra/observability');
 var api = require('@opentelemetry/api');
-var resources = require('@opentelemetry/resources');
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var fs = require('fs');
+var url = require('url');
+var resources = require('@opentelemetry/resources');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
+var incubating = require('@opentelemetry/semantic-conventions/incubating');
 
-// src/ai-tracing.ts
+// src/tracing.ts
 
 // src/loadExporter.ts
 var OTLPHttpExporter;
@@ -205,400 +208,498 @@ function resolveCustomConfig(config) {
     protocol: config.protocol || "http/json"
   };
 }
-var MastraReadableSpan = class {
-  name;
-  kind;
-  spanContext;
-  parentSpanId;
-  startTime;
-  endTime;
-  status;
-  attributes;
-  links;
-  events;
-  duration;
-  ended;
-  resource;
-  instrumentationLibrary;
-  instrumentationScope;
-  droppedAttributesCount = 0;
-  droppedEventsCount = 0;
-  droppedLinksCount = 0;
-  constructor(aiSpan, attributes, kind, parentSpanId, resource, instrumentationLibrary) {
-    this.name = aiSpan.name;
-    this.kind = kind;
-    this.attributes = attributes;
-    this.parentSpanId = parentSpanId;
-    this.links = [];
-    this.events = [];
-    this.startTime = this.dateToHrTime(aiSpan.startTime);
-    this.endTime = aiSpan.endTime ? this.dateToHrTime(aiSpan.endTime) : this.startTime;
-    this.ended = !!aiSpan.endTime;
-    if (aiSpan.endTime) {
-      const durationMs = aiSpan.endTime.getTime() - aiSpan.startTime.getTime();
-      this.duration = [Math.floor(durationMs / 1e3), durationMs % 1e3 * 1e6];
-    } else {
-      this.duration = [0, 0];
+
+// 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);
+};
+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));
+};
+var convertMastraMessagesToGenAIMessages = (inputOutputString) => {
+  try {
+    const parsedIO = JSON.parse(inputOutputString);
+    if (typeof parsedIO !== "object" || parsedIO == null || !("messages" in parsedIO) && !("text" in parsedIO)) {
+      return inputOutputString;
     }
-    if (aiSpan.errorInfo) {
-      this.status = {
-        code: api.SpanStatusCode.ERROR,
-        message: aiSpan.errorInfo.message
-      };
-      this.events.push({
-        name: "exception",
-        attributes: {
-          "exception.message": aiSpan.errorInfo.message,
-          "exception.type": "Error",
-          ...aiSpan.errorInfo.details?.stack && {
-            "exception.stacktrace": aiSpan.errorInfo.details.stack
+    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;
           }
-        },
-        time: this.startTime,
-        droppedAttributesCount: 0
-      });
-    } else if (aiSpan.endTime) {
-      this.status = { code: api.SpanStatusCode.OK };
-    } else {
-      this.status = { code: api.SpanStatusCode.UNSET };
-    }
-    if (aiSpan.isEvent) {
-      this.events.push({
-        name: "instant_event",
-        attributes: {},
-        time: this.startTime,
-        droppedAttributesCount: 0
-      });
+          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
+          };
+        })
+      );
     }
-    this.spanContext = () => ({
-      traceId: aiSpan.traceId,
-      spanId: aiSpan.id,
-      traceFlags: api.TraceFlags.SAMPLED,
-      isRemote: false
-    });
-    this.resource = resource || {};
-    this.instrumentationLibrary = instrumentationLibrary || {
-      name: "@mastra/otel",
-      version: "1.0.0"
-    };
-    this.instrumentationScope = this.instrumentationLibrary;
-  }
-  /**
-   * Convert JavaScript Date to hrtime format
-   */
-  dateToHrTime(date) {
-    const ms = date.getTime();
-    const seconds = Math.floor(ms / 1e3);
-    const nanoseconds = ms % 1e3 * 1e6;
-    return [seconds, nanoseconds];
+    return inputOutputString;
+  } catch {
+    return inputOutputString;
   }
 };
 
-// src/span-converter.ts
-var SPAN_KIND_MAPPING = {
-  // LLM operations are CLIENT spans (calling external AI services)
-  [aiTracing.AISpanType.LLM_GENERATION]: api.SpanKind.CLIENT,
-  [aiTracing.AISpanType.LLM_CHUNK]: api.SpanKind.CLIENT,
-  // MCP tool calls are CLIENT (external service calls)
-  [aiTracing.AISpanType.MCP_TOOL_CALL]: api.SpanKind.CLIENT,
-  // Root spans for agent/workflow are SERVER (entry points)
-  [aiTracing.AISpanType.AGENT_RUN]: api.SpanKind.SERVER,
-  [aiTracing.AISpanType.WORKFLOW_RUN]: api.SpanKind.SERVER
-};
-var SpanConverter = class {
-  resource;
-  instrumentationLibrary;
-  constructor(resource) {
-    this.resource = resource;
-    this.instrumentationLibrary = {
-      name: "@mastra/otel",
-      version: "1.0.0"
-    };
+// src/gen-ai-semantics.ts
+function formatUsageMetrics(usage) {
+  if (!usage) return {};
+  const metrics = {};
+  if (usage.inputTokens !== void 0) {
+    metrics[incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
   }
-  /**
-   * Convert a Mastra AI span to an OpenTelemetry ReadableSpan
-   * This preserves Mastra's trace and span IDs
-   */
-  convertSpan(aiSpan) {
-    const spanKind = this.getSpanKind(aiSpan);
-    const attributes = this.buildAttributes(aiSpan);
-    const spanName = this.buildSpanName(aiSpan);
-    const otelSpan = { ...aiSpan, name: spanName };
-    return new MastraReadableSpan(
-      otelSpan,
-      attributes,
-      spanKind,
-      aiSpan.parentSpanId,
-      // Use the parentSpanId from the Mastra span directly
-      this.resource,
-      this.instrumentationLibrary
-    );
+  if (usage.outputTokens !== void 0) {
+    metrics[incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
   }
-  /**
-   * Get the appropriate SpanKind based on span type and context
-   */
-  getSpanKind(aiSpan) {
-    if (aiSpan.isRootSpan) {
-      if (aiSpan.type === aiTracing.AISpanType.AGENT_RUN || aiSpan.type === aiTracing.AISpanType.WORKFLOW_RUN) {
-        return api.SpanKind.SERVER;
-      }
+  if (usage.outputDetails?.reasoning !== void 0) {
+    metrics["gen_ai.usage.reasoning_tokens"] = usage.outputDetails.reasoning;
+  }
+  if (usage.inputDetails?.cacheRead !== void 0) {
+    metrics["gen_ai.usage.cached_input_tokens"] = usage.inputDetails.cacheRead;
+  }
+  if (usage.inputDetails?.cacheWrite !== void 0) {
+    metrics["gen_ai.usage.cache_write_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 getOperationName(span) {
+  switch (span.type) {
+    case observability.SpanType.MODEL_GENERATION:
+      return "chat";
+    case observability.SpanType.TOOL_CALL:
+    case observability.SpanType.MCP_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();
+  }
+}
+function sanitizeSpanName(name) {
+  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 ?? "unknown";
     }
-    return SPAN_KIND_MAPPING[aiSpan.type] || api.SpanKind.INTERNAL;
+    case observability.SpanType.TOOL_CALL:
+    case observability.SpanType.MCP_TOOL_CALL: {
+      const attrs = span.attributes;
+      return attrs?.toolId ?? "unknown";
+    }
+    case observability.SpanType.AGENT_RUN: {
+      const attrs = span.attributes;
+      return attrs?.agentName ?? attrs?.agentId ?? "unknown";
+    }
+    case observability.SpanType.WORKFLOW_RUN: {
+      const attrs = span.attributes;
+      return attrs?.workflowId ?? "unknown";
+    }
+    default:
+      return null;
   }
-  /**
-   * Build OTEL-compliant span name based on span type and attributes
-   */
-  buildSpanName(aiSpan) {
-    switch (aiSpan.type) {
-      case aiTracing.AISpanType.LLM_GENERATION: {
-        const attrs = aiSpan.attributes;
-        const operation = attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
-        const model = attrs?.model || "unknown";
-        return `${operation} ${model}`;
-      }
-      case aiTracing.AISpanType.TOOL_CALL:
-      case aiTracing.AISpanType.MCP_TOOL_CALL: {
-        const toolAttrs = aiSpan.attributes;
-        const toolName = toolAttrs?.toolId || "unknown";
-        return `tool.execute ${toolName}`;
-      }
-      case aiTracing.AISpanType.AGENT_RUN: {
-        const agentAttrs = aiSpan.attributes;
-        const agentId = agentAttrs?.agentId || "unknown";
-        return `agent.${agentId}`;
-      }
-      case aiTracing.AISpanType.WORKFLOW_RUN: {
-        const workflowAttrs = aiSpan.attributes;
-        const workflowId = workflowAttrs?.workflowId || "unknown";
-        return `workflow.${workflowId}`;
-      }
-      case aiTracing.AISpanType.WORKFLOW_STEP:
-        return aiSpan.name;
-      default:
-        return aiSpan.name;
+}
+function getSpanName(span) {
+  const identifier = getSpanIdentifier(span);
+  if (identifier) {
+    const operation = getOperationName(span);
+    return `${operation} ${identifier}`;
+  }
+  return sanitizeSpanName(span.name);
+}
+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) {
+      attributes["gen_ai.tool.call.arguments"] = inputStr;
+    } else {
+      attributes[`mastra.${spanType}.input`] = inputStr;
     }
   }
-  /**
-   * Build OpenTelemetry attributes from Mastra AI span
-   * Following OTEL Semantic Conventions for GenAI
-   */
-  buildAttributes(aiSpan) {
-    const attributes = {};
-    attributes["gen_ai.operation.name"] = this.getOperationName(aiSpan);
-    attributes["span.kind"] = this.getSpanKindString(aiSpan);
-    attributes["mastra.span.type"] = aiSpan.type;
-    attributes["mastra.trace_id"] = aiSpan.traceId;
-    attributes["mastra.span_id"] = aiSpan.id;
-    if (aiSpan.parentSpanId) {
-      attributes["mastra.parent_span_id"] = aiSpan.parentSpanId;
-    }
-    if (aiSpan.input !== void 0) {
-      const inputStr = typeof aiSpan.input === "string" ? aiSpan.input : JSON.stringify(aiSpan.input);
-      attributes["input"] = inputStr;
-      if (aiSpan.type === aiTracing.AISpanType.LLM_GENERATION) {
-        attributes["gen_ai.prompt"] = inputStr;
-      } else if (aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
-        attributes["gen_ai.tool.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) {
+      attributes["gen_ai.tool.call.result"] = outputStr;
+    } else {
+      attributes[`mastra.${spanType}.output`] = outputStr;
     }
-    if (aiSpan.output !== void 0) {
-      const outputStr = typeof aiSpan.output === "string" ? aiSpan.output : JSON.stringify(aiSpan.output);
-      attributes["output"] = outputStr;
-      if (aiSpan.type === aiTracing.AISpanType.LLM_GENERATION) {
-        attributes["gen_ai.completion"] = outputStr;
-      } else if (aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
-        attributes["gen_ai.tool.output"] = outputStr;
-      }
+  }
+  if (span.type === observability.SpanType.MODEL_GENERATION && span.attributes) {
+    const modelAttrs = span.attributes;
+    if (modelAttrs.model) {
+      attributes[incubating.ATTR_GEN_AI_REQUEST_MODEL] = modelAttrs.model;
     }
-    if (aiSpan.type === aiTracing.AISpanType.LLM_GENERATION && aiSpan.attributes) {
-      const llmAttrs = aiSpan.attributes;
-      if (llmAttrs.model) {
-        attributes["gen_ai.request.model"] = llmAttrs.model;
+    if (modelAttrs.provider) {
+      attributes[incubating.ATTR_GEN_AI_PROVIDER_NAME] = normalizeProvider(modelAttrs.provider);
+    }
+    if (modelAttrs.agentId) {
+      attributes[incubating.ATTR_GEN_AI_AGENT_ID] = modelAttrs.agentId;
+    }
+    if (modelAttrs.agentName) {
+      attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = modelAttrs.agentName;
+    }
+    Object.assign(attributes, formatUsageMetrics(modelAttrs.usage));
+    if (modelAttrs.parameters) {
+      if (modelAttrs.parameters.temperature !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_TEMPERATURE] = modelAttrs.parameters.temperature;
       }
-      if (llmAttrs.provider) {
-        attributes["gen_ai.system"] = llmAttrs.provider;
+      if (modelAttrs.parameters.maxOutputTokens !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_MAX_TOKENS] = modelAttrs.parameters.maxOutputTokens;
       }
-      if (llmAttrs.usage) {
-        const inputTokens = llmAttrs.usage.inputTokens ?? llmAttrs.usage.promptTokens;
-        const outputTokens = llmAttrs.usage.outputTokens ?? llmAttrs.usage.completionTokens;
-        if (inputTokens !== void 0) {
-          attributes["gen_ai.usage.input_tokens"] = inputTokens;
-        }
-        if (outputTokens !== void 0) {
-          attributes["gen_ai.usage.output_tokens"] = outputTokens;
-        }
-        if (llmAttrs.usage.totalTokens !== void 0) {
-          attributes["gen_ai.usage.total_tokens"] = llmAttrs.usage.totalTokens;
-        }
-        if (llmAttrs.usage.reasoningTokens !== void 0) {
-          attributes["gen_ai.usage.reasoning_tokens"] = llmAttrs.usage.reasoningTokens;
-        }
-        if (llmAttrs.usage.cachedInputTokens !== void 0) {
-          attributes["gen_ai.usage.cached_input_tokens"] = llmAttrs.usage.cachedInputTokens;
-        }
+      if (modelAttrs.parameters.topP !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_TOP_P] = modelAttrs.parameters.topP;
       }
-      if (llmAttrs.parameters) {
-        if (llmAttrs.parameters.temperature !== void 0) {
-          attributes["gen_ai.request.temperature"] = llmAttrs.parameters.temperature;
-        }
-        if (llmAttrs.parameters.maxOutputTokens !== void 0) {
-          attributes["gen_ai.request.max_tokens"] = llmAttrs.parameters.maxOutputTokens;
-        }
-        if (llmAttrs.parameters.topP !== void 0) {
-          attributes["gen_ai.request.top_p"] = llmAttrs.parameters.topP;
-        }
-        if (llmAttrs.parameters.topK !== void 0) {
-          attributes["gen_ai.request.top_k"] = llmAttrs.parameters.topK;
-        }
-        if (llmAttrs.parameters.presencePenalty !== void 0) {
-          attributes["gen_ai.request.presence_penalty"] = llmAttrs.parameters.presencePenalty;
-        }
-        if (llmAttrs.parameters.frequencyPenalty !== void 0) {
-          attributes["gen_ai.request.frequency_penalty"] = llmAttrs.parameters.frequencyPenalty;
-        }
-        if (llmAttrs.parameters.stopSequences) {
-          attributes["gen_ai.request.stop_sequences"] = JSON.stringify(llmAttrs.parameters.stopSequences);
-        }
+      if (modelAttrs.parameters.topK !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_TOP_K] = modelAttrs.parameters.topK;
       }
-      if (llmAttrs.finishReason) {
-        attributes["gen_ai.response.finish_reasons"] = llmAttrs.finishReason;
+      if (modelAttrs.parameters.presencePenalty !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY] = modelAttrs.parameters.presencePenalty;
       }
-    }
-    if ((aiSpan.type === aiTracing.AISpanType.TOOL_CALL || aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) && aiSpan.attributes) {
-      const toolAttrs = aiSpan.attributes;
-      if (toolAttrs.toolId) {
-        attributes["gen_ai.tool.name"] = toolAttrs.toolId;
+      if (modelAttrs.parameters.frequencyPenalty !== void 0) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY] = modelAttrs.parameters.frequencyPenalty;
       }
-      if (aiSpan.type === aiTracing.AISpanType.MCP_TOOL_CALL) {
-        const mcpAttrs = toolAttrs;
-        if (mcpAttrs.mcpServer) {
-          attributes["mcp.server"] = mcpAttrs.mcpServer;
-        }
-        if (mcpAttrs.serverVersion) {
-          attributes["mcp.server.version"] = mcpAttrs.serverVersion;
-        }
-      } else {
-        if (toolAttrs.toolDescription) {
-          attributes["gen_ai.tool.description"] = toolAttrs.toolDescription;
-        }
+      if (modelAttrs.parameters.stopSequences) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_STOP_SEQUENCES] = JSON.stringify(modelAttrs.parameters.stopSequences);
       }
-      if (toolAttrs.success !== void 0) {
-        attributes["gen_ai.tool.success"] = toolAttrs.success;
+      if (modelAttrs.parameters.seed) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_SEED] = modelAttrs.parameters.seed;
       }
     }
-    if (aiSpan.type === aiTracing.AISpanType.AGENT_RUN && aiSpan.attributes) {
-      const agentAttrs = aiSpan.attributes;
-      if (agentAttrs.agentId) {
-        attributes["agent.id"] = agentAttrs.agentId;
-      }
-      if (agentAttrs.maxSteps) {
-        attributes["agent.max_steps"] = agentAttrs.maxSteps;
-      }
-      if (agentAttrs.availableTools) {
-        attributes["agent.available_tools"] = JSON.stringify(agentAttrs.availableTools);
-      }
+    if (modelAttrs.finishReason) {
+      attributes[incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS] = JSON.stringify([modelAttrs.finishReason]);
     }
-    if (aiSpan.type === aiTracing.AISpanType.WORKFLOW_RUN && aiSpan.attributes) {
-      const workflowAttrs = aiSpan.attributes;
-      if (workflowAttrs.workflowId) {
-        attributes["workflow.id"] = workflowAttrs.workflowId;
-      }
-      if (workflowAttrs.status) {
-        attributes["workflow.status"] = workflowAttrs.status;
-      }
+    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.TOOL_CALL || span.type === observability.SpanType.MCP_TOOL_CALL) && span.attributes) {
+    const toolAttrs = span.attributes;
+    if (toolAttrs.toolId) {
+      attributes[incubating.ATTR_GEN_AI_TOOL_NAME] = toolAttrs.toolId;
     }
-    if (aiSpan.errorInfo) {
-      attributes["error"] = true;
-      attributes["error.type"] = aiSpan.errorInfo.id || "unknown";
-      attributes["error.message"] = aiSpan.errorInfo.message;
-      if (aiSpan.errorInfo.domain) {
-        attributes["error.domain"] = aiSpan.errorInfo.domain;
+    if (span.type === observability.SpanType.MCP_TOOL_CALL) {
+      const mcpAttrs = toolAttrs;
+      if (mcpAttrs.mcpServer) {
+        attributes[incubating.ATTR_SERVER_ADDRESS] = mcpAttrs.mcpServer;
       }
-      if (aiSpan.errorInfo.category) {
-        attributes["error.category"] = aiSpan.errorInfo.category;
+    } else {
+      if (toolAttrs.toolDescription) {
+        attributes[incubating.ATTR_GEN_AI_TOOL_DESCRIPTION] = toolAttrs.toolDescription;
       }
     }
-    if (aiSpan.metadata) {
-      Object.entries(aiSpan.metadata).forEach(([key, value]) => {
-        if (!attributes[key]) {
-          if (value === null || value === void 0) {
-            return;
-          }
-          if (typeof value === "object") {
-            attributes[key] = JSON.stringify(value);
-          } else {
-            attributes[key] = value;
-          }
-        }
-      });
+  }
+  if (span.type === observability.SpanType.AGENT_RUN && span.attributes) {
+    const agentAttrs = span.attributes;
+    if (agentAttrs.agentId) {
+      attributes[incubating.ATTR_GEN_AI_AGENT_ID] = agentAttrs.agentId;
+    }
+    if (agentAttrs.agentName) {
+      attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = agentAttrs.agentName;
+    }
+    if (agentAttrs.conversationId) {
+      attributes[incubating.ATTR_GEN_AI_CONVERSATION_ID] = agentAttrs.conversationId;
     }
-    if (aiSpan.startTime) {
-      attributes["mastra.start_time"] = aiSpan.startTime.toISOString();
+    if (agentAttrs.maxSteps) {
+      attributes[`mastra.${spanType}.max_steps`] = agentAttrs.maxSteps;
     }
-    if (aiSpan.endTime) {
-      attributes["mastra.end_time"] = aiSpan.endTime.toISOString();
-      const duration = aiSpan.endTime.getTime() - aiSpan.startTime.getTime();
-      attributes["mastra.duration_ms"] = duration;
+    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;
+    }
+  }
+  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"]
+};
+function normalizeProviderString(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+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 attributes;
   }
+  return providerName.toLowerCase();
+}
+
+// src/span-converter.ts
+var SpanConverter = class {
+  constructor(params) {
+    this.params = params;
+    this.format = params.format;
+  }
+  resource;
+  scope;
+  initPromise;
+  format;
   /**
-   * Get the operation name based on span type for gen_ai.operation.name
+   * Lazily initialize resource & scope on first use.
+   * Subsequent calls reuse the same promise (no races).
    */
-  getOperationName(aiSpan) {
-    switch (aiSpan.type) {
-      case aiTracing.AISpanType.LLM_GENERATION: {
-        const attrs = aiSpan.attributes;
-        return attrs?.resultType === "tool_selection" ? "tool_selection" : "chat";
-      }
-      case aiTracing.AISpanType.TOOL_CALL:
-      case aiTracing.AISpanType.MCP_TOOL_CALL:
-        return "tool.execute";
-      case aiTracing.AISpanType.AGENT_RUN:
-        return "agent.run";
-      case aiTracing.AISpanType.WORKFLOW_RUN:
-        return "workflow.run";
-      default:
-        return aiSpan.type.replace(/_/g, ".");
+  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;
   }
   /**
-   * Get span kind as string for attribute
+   * Convert a Mastra Span to an OpenTelemetry ReadableSpan
    */
-  getSpanKindString(aiSpan) {
-    const kind = this.getSpanKind(aiSpan);
-    switch (kind) {
-      case api.SpanKind.SERVER:
-        return "server";
-      case api.SpanKind.CLIENT:
-        return "client";
-      case api.SpanKind.INTERNAL:
-        return "internal";
-      case api.SpanKind.PRODUCER:
-        return "producer";
-      case api.SpanKind.CONSUMER:
-        return "consumer";
-      default:
-        return "internal";
+  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: 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;
   }
 };
+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;
+  }
+}
+function getSpanKind(type) {
+  switch (type) {
+    case observability.SpanType.MODEL_GENERATION:
+    case observability.SpanType.MCP_TOOL_CALL:
+      return api.SpanKind.CLIENT;
+    default:
+      return api.SpanKind.INTERNAL;
+  }
+}
+function dateToHrTime(date) {
+  const ms = date.getTime();
+  const seconds = Math.floor(ms / 1e3);
+  const nanoseconds = ms % 1e3 * 1e6;
+  return [seconds, nanoseconds];
+}
+function computeDuration(start, end) {
+  if (!end) return [0, 0];
+  const diffMs = end.getTime() - start.getTime();
+  return [Math.floor(diffMs / 1e3), diffMs % 1e3 * 1e6];
+}
+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
+  };
+}
 
-// src/ai-tracing.ts
-var OtelExporter = class {
+// src/tracing.ts
+var OtelExporter = class extends observability$1.BaseExporter {
   config;
-  tracingConfig;
+  observabilityConfig;
   spanConverter;
   processor;
   exporter;
   isSetup = false;
-  isDisabled = false;
-  logger;
   name = "opentelemetry";
   constructor(config) {
+    super(config);
     this.config = config;
-    this.spanConverter = new SpanConverter();
-    this.logger = new logger.ConsoleLogger({ level: config.logLevel ?? "warn" });
     if (config.logLevel === "debug") {
       api.diag.setLogger(new api.DiagConsoleLogger(), api.DiagLogLevel.DEBUG);
     }
@@ -606,11 +707,11 @@ var OtelExporter = class {
   /**
    * Initialize with tracing configuration
    */
-  init(config) {
-    this.tracingConfig = config;
+  init(options) {
+    this.observabilityConfig = options.config;
   }
   async setupExporter() {
-    if (this.isSetup) return;
+    if (this.isSetup || this.exporter) return;
     if (!this.config.provider) {
       this.logger.error(
         '[OtelExporter] Provider configuration is required. Use the "custom" provider for generic endpoints.'
@@ -625,6 +726,10 @@ var OtelExporter = class {
       this.isSetup = true;
       return;
     }
+    if (this.config.exporter) {
+      this.exporter = this.config.exporter;
+      return;
+    }
     const endpoint = resolved.endpoint;
     const headers = resolved.headers;
     const protocol = resolved.protocol;
@@ -678,15 +783,15 @@ var OtelExporter = class {
       this.isSetup = true;
       return;
     }
-    const resource = resources.resourceFromAttributes({
-      [semanticConventions.ATTR_SERVICE_NAME]: this.tracingConfig?.serviceName || "mastra-service",
-      [semanticConventions.ATTR_SERVICE_VERSION]: "1.0.0",
-      // Add telemetry SDK information
-      [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: "@mastra/otel-exporter",
-      [semanticConventions.ATTR_TELEMETRY_SDK_VERSION]: "1.0.0",
-      [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
+  }
+  async setupProcessor() {
+    if (this.processor || this.isSetup) return;
+    this.spanConverter = new SpanConverter({
+      packageName: "@mastra/otel-exporter",
+      serviceName: this.observabilityConfig?.serviceName,
+      config: this.config,
+      format: "GenAI_v1_38_0"
     });
-    this.spanConverter = new SpanConverter(resource);
     this.processor = new sdkTraceBase.BatchSpanProcessor(this.exporter, {
       maxExportBatchSize: this.config.batchSize || 512,
       // Default batch size
@@ -700,13 +805,15 @@ var OtelExporter = class {
     this.logger.debug(
       `[OtelExporter] Using BatchSpanProcessor (batch size: ${this.config.batchSize || 512}, delay: 5s)`
     );
+  }
+  async setup() {
+    if (this.isSetup) return;
+    await this.setupExporter();
+    await this.setupProcessor();
     this.isSetup = true;
   }
-  async exportEvent(event) {
-    if (this.isDisabled) {
-      return;
-    }
-    if (event.type !== aiTracing.AITracingEventType.SPAN_ENDED) {
+  async _exportTracingEvent(event) {
+    if (event.type !== observability.TracingEventType.SPAN_ENDED) {
       return;
     }
     const span = event.exportedSpan;
@@ -714,15 +821,15 @@ var OtelExporter = class {
   }
   async exportSpan(span) {
     if (!this.isSetup) {
-      await this.setupExporter();
+      await this.setup();
     }
     if (this.isDisabled || !this.processor) {
       return;
     }
     try {
-      const readableSpan = this.spanConverter.convertSpan(span);
+      const otelSpan = await this.spanConverter.convertSpan(span);
       await new Promise((resolve) => {
-        this.processor.onEnd(readableSpan);
+        this.processor.onEnd(otelSpan);
         resolve();
       });
       this.logger.debug(
@@ -740,5 +847,7 @@ var OtelExporter = class {
 };
 
 exports.OtelExporter = OtelExporter;
+exports.SpanConverter = SpanConverter;
+exports.getSpanKind = getSpanKind;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map