@mastra/datadog 1.3.6-alpha.0 → 1.3.7-alpha.0

package/dist/index.cjs

@@ -1,1233 +1,1168 @@
-'use strict';
-
-var observability$1 = require('@mastra/core/observability');
-var utils = require('@mastra/core/utils');
-var observability = require('@mastra/observability');
-var tracer3 = require('dd-trace');
-var features = require('@mastra/core/features');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var tracer3__default = /*#__PURE__*/_interopDefault(tracer3);
-
-// src/bridge.ts
-var FEATURE = "model-inference-span";
-var observabilityFeatures;
-var featureLoadPromise;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _mastra_core_observability = require("@mastra/core/observability");
+let _mastra_core_utils = require("@mastra/core/utils");
+let _mastra_observability = require("@mastra/observability");
+let dd_trace = require("dd-trace");
+dd_trace = __toESM(dd_trace, 1);
+let _mastra_core_features = require("@mastra/core/features");
+//#region src/features.ts
+/**
+* Feature detection for paired @mastra/core and @mastra/observability versions.
+*
+* `coreFeatures` is a hard peer dependency, so it can be imported statically.
+* `observabilityFeatures` is loaded via dynamic import so this exporter degrades
+* gracefully against older `@mastra/observability` versions that don't export it
+* (per the pattern documented in `observability/mastra/src/features.ts`).
+*
+* Detection runs once at module load. Callers consume the result through the
+* sync `isModelInferenceEnabled()` accessor, which conservatively returns
+* `false` until detection settles — long enough only to cover the microtask
+* window before any spans are emitted in practice.
+*/
+const FEATURE = "model-inference-span";
+let observabilityFeatures;
+let featureLoadPromise;
 function loadObservabilityFeatures() {
-  if (!featureLoadPromise) {
-    featureLoadPromise = import('@mastra/observability').then((mod) => {
-      observabilityFeatures = mod.observabilityFeatures;
-    }).catch(() => {
-    });
-  }
-  return featureLoadPromise;
+	if (!featureLoadPromise) featureLoadPromise = import("@mastra/observability").then((mod) => {
+		observabilityFeatures = mod.observabilityFeatures;
+	}).catch(() => {});
+	return featureLoadPromise;
 }
-void loadObservabilityFeatures();
+loadObservabilityFeatures();
+/**
+* Returns true when both packages report the `model-inference-span` feature,
+* meaning MODEL_INFERENCE spans are emitted by the tracker. Drives the
+* Datadog kind mapping and usage-source switch (legacy: MODEL_STEP carries
+* 'llm' kind + usage; new: MODEL_INFERENCE does).
+*/
 function isModelInferenceEnabled() {
-  return observabilityFeatures?.has(FEATURE) === true && features.coreFeatures.has(FEATURE);
+	return observabilityFeatures?.has(FEATURE) === true && _mastra_core_features.coreFeatures.has(FEATURE);
 }
-
-// src/metrics.ts
+//#endregion
+//#region src/metrics.ts
 function formatUsageMetrics(usage) {
-  if (!usage) return void 0;
-  const result = {};
-  const inputTokens = usage.inputTokens;
-  if (inputTokens !== void 0) result.inputTokens = inputTokens;
-  const outputTokens = usage.outputTokens;
-  if (outputTokens !== void 0) result.outputTokens = outputTokens;
-  if (inputTokens !== void 0 && outputTokens !== void 0) {
-    result.totalTokens = inputTokens + outputTokens;
-  }
-  if (usage?.outputDetails?.reasoning !== void 0) {
-    result.reasoningOutputTokens = usage.outputDetails.reasoning;
-  }
-  const cacheReadTokens = usage?.inputDetails?.cacheRead;
-  if (cacheReadTokens !== void 0) {
-    result.cacheReadTokens = cacheReadTokens;
-  }
-  const cacheWriteTokens = usage?.inputDetails?.cacheWrite;
-  if (cacheWriteTokens !== void 0) {
-    result.cacheWriteTokens = cacheWriteTokens;
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
+	if (!usage) return void 0;
+	const result = {};
+	const inputTokens = usage.inputTokens;
+	if (inputTokens !== void 0) result.inputTokens = inputTokens;
+	const outputTokens = usage.outputTokens;
+	if (outputTokens !== void 0) result.outputTokens = outputTokens;
+	if (inputTokens !== void 0 && outputTokens !== void 0) result.totalTokens = inputTokens + outputTokens;
+	if (usage?.outputDetails?.reasoning !== void 0) result.reasoningOutputTokens = usage.outputDetails.reasoning;
+	const cacheReadTokens = usage?.inputDetails?.cacheRead;
+	if (cacheReadTokens !== void 0) result.cacheReadTokens = cacheReadTokens;
+	const cacheWriteTokens = usage?.inputDetails?.cacheWrite;
+	if (cacheWriteTokens !== void 0) result.cacheWriteTokens = cacheWriteTokens;
+	return Object.keys(result).length > 0 ? result : void 0;
 }
-var SPAN_TYPE_TO_KIND_LEGACY = {
-  [observability$1.SpanType.AGENT_RUN]: "agent",
-  [observability$1.SpanType.MODEL_GENERATION]: "workflow",
-  [observability$1.SpanType.MODEL_STEP]: "llm",
-  [observability$1.SpanType.TOOL_CALL]: "tool",
-  [observability$1.SpanType.MCP_TOOL_CALL]: "tool",
-  [observability$1.SpanType.PROVIDER_TOOL_CALL]: "tool",
-  [observability$1.SpanType.WORKFLOW_RUN]: "workflow"
+//#endregion
+//#region src/utils.ts
+/**
+* Utility functions for Datadog LLM Observability Exporter
+*/
+/**
+* Maps Mastra SpanTypes to Datadog LLMObs span kinds for the legacy hierarchy
+* (no `model-inference-span` feature). MODEL_STEP is the actual API call here
+* because MODEL_INFERENCE doesn't exist.
+*
+* Unmapped types fall back to 'task'.
+*/
+const SPAN_TYPE_TO_KIND_LEGACY = {
+	[_mastra_core_observability.SpanType.AGENT_RUN]: "agent",
+	[_mastra_core_observability.SpanType.MODEL_GENERATION]: "workflow",
+	[_mastra_core_observability.SpanType.MODEL_STEP]: "llm",
+	[_mastra_core_observability.SpanType.TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.MCP_TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.PROVIDER_TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.WORKFLOW_RUN]: "workflow"
 };
-var SPAN_TYPE_TO_KIND_INFERENCE = {
-  [observability$1.SpanType.AGENT_RUN]: "agent",
-  [observability$1.SpanType.MODEL_GENERATION]: "workflow",
-  [observability$1.SpanType.MODEL_STEP]: "workflow",
-  [observability$1.SpanType.MODEL_INFERENCE]: "llm",
-  [observability$1.SpanType.TOOL_CALL]: "tool",
-  [observability$1.SpanType.MCP_TOOL_CALL]: "tool",
-  [observability$1.SpanType.PROVIDER_TOOL_CALL]: "tool",
-  [observability$1.SpanType.WORKFLOW_RUN]: "workflow"
+/**
+* Maps Mastra SpanTypes to Datadog LLMObs span kinds for the new hierarchy
+* (`model-inference-span` feature). MODEL_INFERENCE is the LLM API call;
+* MODEL_STEP wraps processors + inference + tool execution as a workflow.
+*
+* Unmapped types fall back to 'task'.
+*/
+const SPAN_TYPE_TO_KIND_INFERENCE = {
+	[_mastra_core_observability.SpanType.AGENT_RUN]: "agent",
+	[_mastra_core_observability.SpanType.MODEL_GENERATION]: "workflow",
+	[_mastra_core_observability.SpanType.MODEL_STEP]: "workflow",
+	[_mastra_core_observability.SpanType.MODEL_INFERENCE]: "llm",
+	[_mastra_core_observability.SpanType.TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.MCP_TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.PROVIDER_TOOL_CALL]: "tool",
+	[_mastra_core_observability.SpanType.WORKFLOW_RUN]: "workflow"
 };
+/**
+* Resolves the active span-type → Datadog kind mapping based on whether the
+* paired @mastra/core + @mastra/observability emit MODEL_INFERENCE spans.
+* Re-evaluated on each call so tests can flip the feature flag at runtime.
+*/
 function getSpanTypeToKind() {
-  return isModelInferenceEnabled() ? SPAN_TYPE_TO_KIND_INFERENCE : SPAN_TYPE_TO_KIND_LEGACY;
+	return isModelInferenceEnabled() ? SPAN_TYPE_TO_KIND_INFERENCE : SPAN_TYPE_TO_KIND_LEGACY;
 }
-var tracerInitFlag = { done: false };
+/**
+* Singleton flag to prevent multiple tracer initializations.
+* dd-trace should only be initialized once per process.
+*/
+const tracerInitFlag = { done: false };
+/**
+* Ensures dd-trace is initialized exactly once.
+* Respects any existing tracer initialization by the application.
+*/
 function ensureTracer(config) {
-  if (tracerInitFlag.done) return;
-  if (config.site) {
-    process.env.DD_SITE = config.site;
-  }
-  if (config.apiKey) {
-    process.env.DD_API_KEY = config.apiKey;
-  }
-  const alreadyStarted = tracer3__default.default._tracer?.started;
-  if (!alreadyStarted) {
-    tracer3__default.default.init({
-      service: config.service || config.mlApp,
-      env: config.env || process.env.DD_ENV,
-      // Disable automatic integrations by default to avoid surprise instrumentation
-      plugins: config.integrationsEnabled ?? false
-    });
-  }
-  tracer3__default.default.llmobs.enable({
-    mlApp: config.mlApp,
-    agentlessEnabled: config.agentless
-  });
-  tracerInitFlag.done = true;
+	if (tracerInitFlag.done) return;
+	if (config.site) process.env.DD_SITE = config.site;
+	if (config.apiKey) process.env.DD_API_KEY = config.apiKey;
+	if (!dd_trace.default._tracer?.started) dd_trace.default.init({
+		service: config.service || config.mlApp,
+		env: config.env || process.env.DD_ENV,
+		plugins: config.integrationsEnabled ?? false
+	});
+	dd_trace.default.llmobs.enable({
+		mlApp: config.mlApp,
+		agentlessEnabled: config.agentless
+	});
+	tracerInitFlag.done = true;
 }
+/**
+* Returns the Datadog kind for a Mastra span type, using the mapping that
+* matches the active span hierarchy (legacy vs MODEL_INFERENCE).
+*/
 function kindFor(spanType) {
-  return getSpanTypeToKind()[spanType] || "task";
+	return getSpanTypeToKind()[spanType] || "task";
 }
+/**
+* Converts a value to a Date object.
+*/
 function toDate(value) {
-  return value instanceof Date ? value : new Date(value);
+	return value instanceof Date ? value : new Date(value);
 }
+/**
+* Safely stringifies data, handling circular references.
+*/
 function safeStringify(data) {
-  try {
-    return JSON.stringify(data) ?? "";
-  } catch {
-    if (typeof data === "object" && data !== null) {
-      return `[Non-serializable ${data.constructor?.name || "Object"}]`;
-    }
-    return String(data);
-  }
+	try {
+		return JSON.stringify(data) ?? "";
+	} catch {
+		if (typeof data === "object" && data !== null) return `[Non-serializable ${data.constructor?.name || "Object"}]`;
+		return String(data);
+	}
 }
+/**
+* Checks if data is already in message array format ({role, content}[]).
+*/
 function isMessageArray(data) {
-  return Array.isArray(data) && data.every((m) => m?.role && (m?.content !== void 0 || Array.isArray(m.toolCalls)));
+	return Array.isArray(data) && data.every((m) => m?.role && (m?.content !== void 0 || Array.isArray(m.toolCalls)));
 }
 function isModelDataSpan(spanType) {
-  return spanType === observability$1.SpanType.MODEL_GENERATION || spanType === observability$1.SpanType.MODEL_STEP || spanType === observability$1.SpanType.MODEL_INFERENCE;
+	return spanType === _mastra_core_observability.SpanType.MODEL_GENERATION || spanType === _mastra_core_observability.SpanType.MODEL_STEP || spanType === _mastra_core_observability.SpanType.MODEL_INFERENCE;
 }
+/**
+* Checks if data is in Gemini content array format ({role, parts}[]).
+*/
 function isGeminiContentArray(data) {
-  return Array.isArray(data) && data.every((m) => m?.role && Array.isArray(m?.parts));
+	return Array.isArray(data) && data.every((m) => m?.role && Array.isArray(m?.parts));
 }
 function toMessageContent(content) {
-  return typeof content === "string" ? content : safeStringify(content);
+	return typeof content === "string" ? content : safeStringify(content);
 }
+/**
+* Maps a {role, content}[] message array into the Datadog message shape,
+* stringifying any non-string content (e.g. multimodal part arrays).
+*/
 function toDatadogMessages(messages) {
-  return messages.map((m) => {
-    const message = {
-      role: m.role,
-      content: m.content == null ? "" : toMessageContent(m.content)
-    };
-    if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
-      message.toolCalls = toDatadogToolCalls(m.toolCalls);
-    }
-    return message;
-  }).filter((m) => !(m.role === "user" && m.content.trim().length === 0));
+	return messages.map((m) => {
+		const message = {
+			role: m.role,
+			content: m.content == null ? "" : toMessageContent(m.content)
+		};
+		if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) message.toolCalls = toDatadogToolCalls(m.toolCalls);
+		return message;
+	}).filter((m) => !(m.role === "user" && m.content.trim().length === 0));
 }
 function parseToolArguments(args) {
-  if (args == null) return void 0;
-  if (typeof args === "string") {
-    try {
-      const parsed = JSON.parse(args);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {
-    }
-    return { value: args };
-  }
-  if (typeof args === "object" && !Array.isArray(args)) return args;
-  return { value: args };
+	if (args == null) return void 0;
+	if (typeof args === "string") {
+		try {
+			const parsed = JSON.parse(args);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+		return { value: args };
+	}
+	if (typeof args === "object" && !Array.isArray(args)) return args;
+	return { value: args };
 }
 function toDatadogToolCalls(toolCalls) {
-  return toolCalls.map((c) => ({
-    name: c?.toolName ?? c?.name ?? c?.function?.name ?? "unknown",
-    arguments: parseToolArguments(c?.args ?? c?.input ?? c?.arguments ?? c?.function?.arguments),
-    toolId: c?.toolCallId ?? c?.toolId ?? c?.id,
-    type: c?.type === "function" ? c.type : "function"
-  }));
+	return toolCalls.map((c) => ({
+		name: c?.toolName ?? c?.name ?? c?.function?.name ?? "unknown",
+		arguments: parseToolArguments(c?.args ?? c?.input ?? c?.arguments ?? c?.function?.arguments),
+		toolId: c?.toolCallId ?? c?.toolId ?? c?.id,
+		type: c?.type === "function" ? c.type : "function"
+	}));
 }
+/**
+* Converts a Gemini content item to Datadog message format.
+* Extracts text from parts, skips binary data to avoid bloating traces.
+*/
 function geminiContentToMessage(item) {
-  const text = item.parts.map((p) => {
-    if (typeof p === "string") return p;
-    if (p?.text) return p.text;
-    if (p?.inlineData) return `[${p.inlineData.mimeType ?? "binary"}]`;
-    if (p?.functionCall) return `[tool: ${p.functionCall.name ?? "unknown"}]`;
-    return safeStringify(p);
-  }).join("");
-  return { role: item.role, content: text };
+	const text = item.parts.map((p) => {
+		if (typeof p === "string") return p;
+		if (p?.text) return p.text;
+		if (p?.inlineData) return `[${p.inlineData.mimeType ?? "binary"}]`;
+		if (p?.functionCall) return `[tool: ${p.functionCall.name ?? "unknown"}]`;
+		return safeStringify(p);
+	}).join("");
+	return {
+		role: item.role,
+		content: text
+	};
 }
+/**
+* Formats input data for Datadog annotations.
+* Model spans use message array format; others use raw or stringified data.
+*/
 function formatInput(input, spanType) {
-  if (isModelDataSpan(spanType)) {
-    if (isMessageArray(input)) {
-      return toDatadogMessages(input);
-    }
-    if (isGeminiContentArray(input)) {
-      return toDatadogMessages(input.map(geminiContentToMessage));
-    }
-    if (input && typeof input === "object" && !Array.isArray(input)) {
-      if (isMessageArray(input.messages)) {
-        return toDatadogMessages(input.messages);
-      }
-      if (isGeminiContentArray(input.messages)) {
-        return toDatadogMessages(input.messages.map(geminiContentToMessage));
-      }
-      if (isGeminiContentArray(input.contents)) {
-        return toDatadogMessages(input.contents.map(geminiContentToMessage));
-      }
-    }
-    if (typeof input === "string") {
-      return toDatadogMessages([{ role: "user", content: input }]);
-    }
-    return toDatadogMessages([{ role: "user", content: safeStringify(input) }]);
-  }
-  if (typeof input === "string" || Array.isArray(input)) return input;
-  return safeStringify(input);
+	if (isModelDataSpan(spanType)) {
+		if (isMessageArray(input)) return toDatadogMessages(input);
+		if (isGeminiContentArray(input)) return toDatadogMessages(input.map(geminiContentToMessage));
+		if (input && typeof input === "object" && !Array.isArray(input)) {
+			if (isMessageArray(input.messages)) return toDatadogMessages(input.messages);
+			if (isGeminiContentArray(input.messages)) return toDatadogMessages(input.messages.map(geminiContentToMessage));
+			if (isGeminiContentArray(input.contents)) return toDatadogMessages(input.contents.map(geminiContentToMessage));
+		}
+		if (typeof input === "string") return toDatadogMessages([{
+			role: "user",
+			content: input
+		}]);
+		return toDatadogMessages([{
+			role: "user",
+			content: safeStringify(input)
+		}]);
+	}
+	if (typeof input === "string" || Array.isArray(input)) return input;
+	return safeStringify(input);
 }
+/**
+* Formats output data for Datadog annotations.
+* Model spans use message array format; others use raw or stringified data.
+*/
 function formatOutput(output, spanType) {
-  if (isModelDataSpan(spanType)) {
-    if (isMessageArray(output)) {
-      return toDatadogMessages(output);
-    }
-    if (typeof output === "string") {
-      return [{ role: "assistant", content: output }];
-    }
-    if (output && typeof output === "object") {
-      if (Array.isArray(output.toolCalls) && output.toolCalls.length > 0) {
-        return [
-          {
-            role: "assistant",
-            content: typeof output.text === "string" ? output.text : "",
-            toolCalls: toDatadogToolCalls(output.toolCalls)
-          }
-        ];
-      }
-      if (typeof output.text === "string" && output.text.length > 0) {
-        return [{ role: "assistant", content: output.text }];
-      }
-      if (output.object !== void 0) {
-        return [{ role: "assistant", content: safeStringify(output.object) }];
-      }
-    }
-    return [{ role: "assistant", content: safeStringify(output) }];
-  }
-  if (typeof output === "string") return output;
-  return safeStringify(output);
+	if (isModelDataSpan(spanType)) {
+		if (isMessageArray(output)) return toDatadogMessages(output);
+		if (typeof output === "string") return [{
+			role: "assistant",
+			content: output
+		}];
+		if (output && typeof output === "object") {
+			if (Array.isArray(output.toolCalls) && output.toolCalls.length > 0) return [{
+				role: "assistant",
+				content: typeof output.text === "string" ? output.text : "",
+				toolCalls: toDatadogToolCalls(output.toolCalls)
+			}];
+			if (typeof output.text === "string" && output.text.length > 0) return [{
+				role: "assistant",
+				content: output.text
+			}];
+			if (output.object !== void 0) return [{
+				role: "assistant",
+				content: safeStringify(output.object)
+			}];
+		}
+		return [{
+			role: "assistant",
+			content: safeStringify(output)
+		}];
+	}
+	if (typeof output === "string") return output;
+	return safeStringify(output);
 }
-
-// src/bridge.ts
+//#endregion
+//#region src/bridge.ts
 function flushApmExporter() {
-  const exporterFlush = tracer3__default.default?._tracer?._exporter?.flush;
-  if (typeof exporterFlush !== "function") {
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const done = (error) => {
-      if (settled) return;
-      settled = true;
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    };
-    try {
-      exporterFlush.call(tracer3__default.default._tracer._exporter, done);
-    } catch (error) {
-      reject(error);
-    }
-  });
+	const exporterFlush = dd_trace.default?._tracer?._exporter?.flush;
+	if (typeof exporterFlush !== "function") return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const done = (error) => {
+			if (settled) return;
+			settled = true;
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		};
+		try {
+			exporterFlush.call(dd_trace.default._tracer._exporter, done);
+		} catch (error) {
+			reject(error);
+		}
+	});
 }
-var DatadogBridge = class extends observability.BaseExporter {
-  name = "datadog-bridge";
-  config;
-  ddSpanMap = /* @__PURE__ */ new Map();
-  traceContext = /* @__PURE__ */ new Map();
-  openSpanCounts = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    super(config);
-    const mlApp = config.mlApp ?? process.env.DD_LLMOBS_ML_APP;
-    const apiKey = config.apiKey ?? process.env.DD_API_KEY;
-    const site = config.site ?? process.env.DD_SITE ?? "datadoghq.com";
-    const env = config.env ?? process.env.DD_ENV;
-    const envAgentless = process.env.DD_LLMOBS_AGENTLESS_ENABLED?.toLowerCase();
-    const agentless = config.agentless ?? (envAgentless === "true" || envAgentless === "1" ? true : false);
-    if (!mlApp) {
-      this.setDisabled(`Missing required mlApp. Set DD_LLMOBS_ML_APP environment variable or pass mlApp in config.`);
-      this.config = config;
-      return;
-    }
-    if (agentless && !apiKey) {
-      this.setDisabled(
-        `Missing required apiKey for agentless mode. Set DD_API_KEY environment variable or pass apiKey in config.`
-      );
-      this.config = config;
-      return;
-    }
-    this.config = {
-      ...config,
-      mlApp,
-      site,
-      apiKey,
-      agentless,
-      env
-    };
-    ensureTracer({
-      mlApp,
-      site,
-      apiKey,
-      agentless,
-      service: config.service,
-      env,
-      integrationsEnabled: config.integrationsEnabled ?? true
-    });
-    this.logger.info("Datadog bridge initialized", { mlApp, site, agentless });
-  }
-  /**
-   * Create a dd-trace span eagerly when a Mastra span is constructed.
-   */
-  createSpan(options) {
-    if (this.isDisabled) return void 0;
-    try {
-      let apmParentDdSpan = void 0;
-      let llmobsParentDdSpan = void 0;
-      let parentSource = "none";
-      const externalParentId = observability.getExternalParentId(options);
-      if (externalParentId) {
-        apmParentDdSpan = this.ddSpanMap.get(externalParentId);
-        llmobsParentDdSpan = apmParentDdSpan;
-        if (apmParentDdSpan) {
-          parentSource = "external-parent";
-        }
-      }
-      if (!apmParentDdSpan) {
-        apmParentDdSpan = tracer3__default.default.scope().active() ?? void 0;
-        if (apmParentDdSpan) {
-          parentSource = "active-scope";
-        }
-      }
-      if (!llmobsParentDdSpan && externalParentId) {
-        llmobsParentDdSpan = apmParentDdSpan;
-      }
-      const ddSpan = tracer3__default.default.startSpan(options.name, {
-        ...apmParentDdSpan ? { childOf: apmParentDdSpan } : {},
-        ...options.startTime ? { startTime: toDate(options.startTime).getTime() } : {}
-      });
-      const ddContext = ddSpan.context?.();
-      const spanId = ddContext?.toSpanId?.(true) ?? generateSpanId();
-      const traceId = ddContext?.toTraceId?.(true) ?? (externalParentId ? options.parent?.traceId ?? generateTraceId() : generateTraceId());
-      const parentContext = apmParentDdSpan?.context?.();
-      const parentSpanId = parentContext?.toSpanId?.(true) ?? externalParentId;
-      this.captureTraceContext(traceId, options);
-      this.openSpanCounts.set(traceId, (this.openSpanCounts.get(traceId) ?? 0) + 1);
-      this.ddSpanMap.set(spanId, ddSpan);
-      this.registerLlmObsSpan(ddSpan, traceId, options, llmobsParentDdSpan);
-      this.logger.debug(
-        `[DatadogBridge.createSpan] Created APM span [spanId=${spanId}] [traceId=${traceId}] [parentSpanId=${parentSpanId}] [type=${options.type}] [mapSize=${this.ddSpanMap.size}] [parentSource=${parentSource}] [externalParentId=${externalParentId ?? "none"}]`
-      );
-      return { spanId, traceId, parentSpanId };
-    } catch (error) {
-      this.logger.error("[DatadogBridge] Failed to create span:", error);
-      return void 0;
-    }
-  }
-  /**
-   * Execute an async function within the dd-trace context of a Mastra span.
-   */
-  executeInContext(spanId, fn) {
-    return this.executeWithSpanContext(spanId, fn);
-  }
-  /**
-   * Execute a synchronous function within the dd-trace context of a Mastra span.
-   */
-  executeInContextSync(spanId, fn) {
-    return this.executeWithSpanContext(spanId, fn);
-  }
-  async onScoreEvent(event) {
-    if (this.isDisabled || !tracer3__default.default.llmobs?.submitEvaluation) return;
-    const { score } = event;
-    if (!score.traceId || !score.spanId) {
-      this.logger.warn("Datadog bridge: dropping score with no traceId/spanId", {
-        scorerId: score.scorerId
-      });
-      return;
-    }
-    try {
-      tracer3__default.default.llmobs.submitEvaluation(
-        { traceId: score.traceId, spanId: toDatadogSpanId(score.spanId) },
-        {
-          label: score.scorerName ?? score.scorerId,
-          value: score.score,
-          metricType: "score",
-          mlApp: this.config.mlApp,
-          timestampMs: score.timestamp instanceof Date ? score.timestamp.getTime() : Date.now(),
-          ...score.reason ? { reasoning: score.reason } : {},
-          ...score.metadata ? { metadata: score.metadata } : {}
-        }
-      );
-    } catch (error) {
-      this.logger.error("Datadog bridge: Failed to submit evaluation", {
-        error,
-        traceId: score.traceId,
-        spanId: score.spanId,
-        scorerId: score.scorerId
-      });
-    }
-  }
-  executeWithSpanContext(spanId, fn) {
-    const ddSpan = this.ddSpanMap.get(spanId);
-    if (ddSpan) {
-      return tracer3__default.default.scope().activate(ddSpan, () => {
-        const llmobs = tracer3__default.default.llmobs;
-        if (typeof llmobs?._activate === "function") {
-          return llmobs._activate(ddSpan, void 0, fn);
-        }
-        return fn();
-      });
-    }
-    return fn();
-  }
-  /**
-   * Handle tracing events from the observability bus.
-   */
-  async _exportTracingEvent(event) {
-    if (this.isDisabled) return;
-    try {
-      const span = event.exportedSpan;
-      if (span.isEvent) {
-        if (event.type === "span_started" || event.type === "span_ended") {
-          this.annotateAndFinishSpan(span);
-        }
-        return;
-      }
-      switch (event.type) {
-        case "span_started":
-        case "span_updated":
-          return;
-        case "span_ended":
-          this.annotateAndFinishSpan(span);
-          return;
-      }
-    } catch (error) {
-      this.logger.error("Datadog bridge error", {
-        error,
-        eventType: event.type,
-        spanId: event.exportedSpan?.id,
-        spanName: event.exportedSpan?.name
-      });
-    }
-  }
-  registerLlmObsSpan(ddSpan, traceId, options, parentDdSpan) {
-    const tagger = this.getLlmObsTagger();
-    if (!tagger) return;
-    try {
-      const kind = kindFor(options.type);
-      const ownAttrs = options.attributes;
-      const inheritedModelAttrs = options.parent?.type === observability$1.SpanType.MODEL_GENERATION ? options.parent.attributes : void 0;
-      const traceCtx = this.resolveTraceContext(traceId, options);
-      tagger.registerLLMObsSpan(ddSpan, {
-        parent: parentDdSpan,
-        kind,
-        name: options.name,
-        userId: traceCtx.userId,
-        sessionId: traceCtx.sessionId,
-        ...kind === "llm" && (ownAttrs?.model ?? inheritedModelAttrs?.model) ? { modelName: ownAttrs?.model ?? inheritedModelAttrs?.model } : {},
-        ...kind === "llm" && (ownAttrs?.provider ?? inheritedModelAttrs?.provider) ? { modelProvider: ownAttrs?.provider ?? inheritedModelAttrs?.provider } : {}
-      });
-    } catch (error) {
-      this.logger.warn("[DatadogBridge] Failed to register LLMObs span", {
-        error,
-        spanName: options.name,
-        spanType: options.type
-      });
-    }
-  }
-  getLlmObsTagger() {
-    const tagger = tracer3__default.default.llmobs?._tagger;
-    if (tagger && typeof tagger.registerLLMObsSpan === "function") {
-      return tagger;
-    }
-    return void 0;
-  }
-  /**
-   * Annotate the eagerly-created dd span and finish it using the final Mastra
-   * span state.
-   */
-  annotateAndFinishSpan(span) {
-    const ddSpan = this.ddSpanMap.get(span.id);
-    if (!ddSpan) {
-      this.logger.warn("[DatadogBridge] No dd span found when finalizing Mastra span", {
-        spanId: span.id,
-        spanName: span.name,
-        spanType: span.type,
-        mapSize: this.ddSpanMap.size
-      });
-      return;
-    }
-    const endTime = span.endTime ? toDate(span.endTime) : span.isEvent ? toDate(span.startTime) : /* @__PURE__ */ new Date();
-    const annotations = this.buildAnnotations(span);
-    try {
-      if (Object.keys(annotations).length > 0 && tracer3__default.default.llmobs?.annotate) {
-        tracer3__default.default.llmobs.annotate(ddSpan, annotations);
-      }
-    } catch (error) {
-      this.logger.error("[DatadogBridge] Failed to annotate span before finish", {
-        error,
-        spanId: span.id,
-        spanName: span.name
-      });
-    }
-    try {
-      if (span.errorInfo) {
-        this.setErrorTags(ddSpan, span.errorInfo);
-      }
-    } catch (error) {
-      this.logger.error("[DatadogBridge] Failed to set error tags on dd span", {
-        error,
-        spanId: span.id,
-        spanName: span.name
-      });
-    }
-    try {
-      if (typeof ddSpan.finish === "function") {
-        ddSpan.finish(endTime.getTime());
-      }
-    } catch (error) {
-      this.logger.error("[DatadogBridge] Failed to finish dd span", {
-        error,
-        spanId: span.id,
-        spanName: span.name
-      });
-    } finally {
-      this.ddSpanMap.delete(span.id);
-      this.releaseTraceContext(span.traceId);
-    }
-  }
-  captureTraceContext(traceId, options) {
-    const existing = this.traceContext.get(traceId);
-    const next = {
-      userId: firstString(options.metadata?.userId, options.parent?.metadata?.userId, existing?.userId),
-      sessionId: firstString(options.metadata?.sessionId, options.parent?.metadata?.sessionId, existing?.sessionId)
-    };
-    if (next.userId || next.sessionId) {
-      this.traceContext.set(traceId, next);
-    }
-  }
-  resolveTraceContext(traceId, options) {
-    const stored = this.traceContext.get(traceId);
-    return {
-      userId: firstString(options.metadata?.userId, options.parent?.metadata?.userId, stored?.userId),
-      sessionId: firstString(options.metadata?.sessionId, options.parent?.metadata?.sessionId, stored?.sessionId)
-    };
-  }
-  releaseTraceContext(traceId) {
-    const nextCount = (this.openSpanCounts.get(traceId) ?? 1) - 1;
-    if (nextCount > 0) {
-      this.openSpanCounts.set(traceId, nextCount);
-      return;
-    }
-    this.openSpanCounts.delete(traceId);
-    this.traceContext.delete(traceId);
-  }
-  buildAnnotations(span) {
-    const annotations = {};
-    if (span.input !== void 0) {
-      annotations.inputData = formatInput(span.input, span.type);
-    }
-    if (span.output !== void 0) {
-      annotations.outputData = formatOutput(span.output, span.type);
-    }
-    const usageSpanType = isModelInferenceEnabled() ? observability$1.SpanType.MODEL_INFERENCE : observability$1.SpanType.MODEL_STEP;
-    if (span.type === usageSpanType) {
-      const usage = span.attributes?.usage;
-      const metrics = formatUsageMetrics(usage);
-      if (metrics) {
-        annotations.metrics = metrics;
-      }
-    }
-    const knownFields = ["usage", "model", "provider"];
-    const otherAttributes = utils.omitKeys(span.attributes ?? {}, knownFields);
-    const contextKeySet = new Set(this.config.requestContextKeys ?? []);
-    const flatContextTags = {};
-    const remainingMetadata = {};
-    for (const [key, value] of Object.entries(span.metadata ?? {})) {
-      if (contextKeySet.has(key)) {
-        flatContextTags[key] = value;
-      } else {
-        remainingMetadata[key] = value;
-      }
-    }
-    const remainingAttributes = {};
-    for (const [key, value] of Object.entries(otherAttributes)) {
-      if (contextKeySet.has(key)) {
-        if (!(key in flatContextTags)) {
-          flatContextTags[key] = value;
-        }
-      } else {
-        remainingAttributes[key] = value;
-      }
-    }
-    const combinedMetadata = {
-      ...remainingMetadata,
-      ...remainingAttributes
-    };
-    if (span.errorInfo) {
-      combinedMetadata["error.message"] = span.errorInfo.message;
-    }
-    if (Object.keys(combinedMetadata).length > 0) {
-      annotations.metadata = combinedMetadata;
-    }
-    const tags = {
-      ...flatContextTags
-    };
-    if (span.tags?.length) {
-      for (const tag of span.tags) {
-        const colonIndex = tag.indexOf(":");
-        if (colonIndex > 0) {
-          tags[tag.substring(0, colonIndex)] = tag.substring(colonIndex + 1);
-        } else {
-          tags[tag] = true;
-        }
-      }
-    }
-    if (span.errorInfo) {
-      tags.error = true;
-      if (span.errorInfo.id) {
-        tags["error.id"] = span.errorInfo.id;
-      }
-      if (span.errorInfo.domain) {
-        tags["error.domain"] = span.errorInfo.domain;
-      }
-      if (span.errorInfo.category) {
-        tags["error.category"] = span.errorInfo.category;
-      }
-    }
-    if (Object.keys(tags).length > 0) {
-      annotations.tags = tags;
-    }
-    return annotations;
-  }
-  setErrorTags(ddSpan, errorInfo) {
-    ddSpan.setTag("error", true);
-    ddSpan.setTag("error.message", errorInfo.message);
-    ddSpan.setTag("error.type", errorInfo.name ?? errorInfo.category ?? "Error");
-    if (errorInfo.stack) {
-      ddSpan.setTag("error.stack", errorInfo.stack);
-    }
-  }
-  async flush() {
-    if (this.isDisabled) return;
-    if (tracer3__default.default.llmobs?.flush) {
-      try {
-        await tracer3__default.default.llmobs.flush();
-        this.logger.debug("Datadog llmobs flushed");
-      } catch (e) {
-        this.logger.error("Error flushing llmobs", { error: e });
-      }
-    }
-    try {
-      await flushApmExporter();
-      this.logger.debug("Datadog APM exporter flushed");
-    } catch (e) {
-      this.logger.error("Error flushing Datadog APM exporter", { error: e });
-    }
-  }
-  async shutdown() {
-    for (const [spanId, ddSpan] of this.ddSpanMap) {
-      this.logger.warn(`[DatadogBridge] Force-finishing APM span that was not properly closed [id=${spanId}]`);
-      try {
-        if (typeof ddSpan.finish === "function") {
-          ddSpan.finish();
-        }
-      } catch {
-      }
-    }
-    this.ddSpanMap.clear();
-    this.openSpanCounts.clear();
-    this.traceContext.clear();
-    await this.flush();
-    if (tracer3__default.default.llmobs?.disable) {
-      try {
-        tracer3__default.default.llmobs.disable();
-      } catch (e) {
-        this.logger.error("Error disabling llmobs", { error: e });
-      }
-    }
-    await super.shutdown();
-  }
+/**
+* Datadog Bridge for Mastra Observability.
+*
+* Creates native dd-trace spans in real time during execution for proper APM
+* context propagation, and uses the same live dd span for Datadog LLMObs
+* tagging and annotations.
+*/
+var DatadogBridge = class extends _mastra_observability.BaseExporter {
+	name = "datadog-bridge";
+	config;
+	ddSpanMap = /* @__PURE__ */ new Map();
+	traceContext = /* @__PURE__ */ new Map();
+	openSpanCounts = /* @__PURE__ */ new Map();
+	constructor(config = {}) {
+		super(config);
+		const mlApp = config.mlApp ?? process.env.DD_LLMOBS_ML_APP;
+		const apiKey = config.apiKey ?? process.env.DD_API_KEY;
+		const site = config.site ?? process.env.DD_SITE ?? "datadoghq.com";
+		const env = config.env ?? process.env.DD_ENV;
+		const envAgentless = process.env.DD_LLMOBS_AGENTLESS_ENABLED?.toLowerCase();
+		const agentless = config.agentless ?? (envAgentless === "true" || envAgentless === "1" ? true : false);
+		if (!mlApp) {
+			this.setDisabled(`Missing required mlApp. Set DD_LLMOBS_ML_APP environment variable or pass mlApp in config.`);
+			this.config = config;
+			return;
+		}
+		if (agentless && !apiKey) {
+			this.setDisabled(`Missing required apiKey for agentless mode. Set DD_API_KEY environment variable or pass apiKey in config.`);
+			this.config = config;
+			return;
+		}
+		this.config = {
+			...config,
+			mlApp,
+			site,
+			apiKey,
+			agentless,
+			env
+		};
+		ensureTracer({
+			mlApp,
+			site,
+			apiKey,
+			agentless,
+			service: config.service,
+			env,
+			integrationsEnabled: config.integrationsEnabled ?? true
+		});
+		this.logger.info("Datadog bridge initialized", {
+			mlApp,
+			site,
+			agentless
+		});
+	}
+	/**
+	* Create a dd-trace span eagerly when a Mastra span is constructed.
+	*/
+	createSpan(options) {
+		if (this.isDisabled) return void 0;
+		try {
+			let apmParentDdSpan = void 0;
+			let llmobsParentDdSpan = void 0;
+			let parentSource = "none";
+			const externalParentId = (0, _mastra_observability.getExternalParentId)(options);
+			if (externalParentId) {
+				apmParentDdSpan = this.ddSpanMap.get(externalParentId);
+				llmobsParentDdSpan = apmParentDdSpan;
+				if (apmParentDdSpan) parentSource = "external-parent";
+			}
+			if (!apmParentDdSpan) {
+				apmParentDdSpan = dd_trace.default.scope().active() ?? void 0;
+				if (apmParentDdSpan) parentSource = "active-scope";
+			}
+			if (!llmobsParentDdSpan && externalParentId) llmobsParentDdSpan = apmParentDdSpan;
+			const ddSpan = dd_trace.default.startSpan(options.name, {
+				...apmParentDdSpan ? { childOf: apmParentDdSpan } : {},
+				...options.startTime ? { startTime: toDate(options.startTime).getTime() } : {}
+			});
+			const ddContext = ddSpan.context?.();
+			const spanId = ddContext?.toSpanId?.(true) ?? generateSpanId();
+			const traceId = ddContext?.toTraceId?.(true) ?? (externalParentId ? options.parent?.traceId ?? generateTraceId() : generateTraceId());
+			const parentSpanId = (apmParentDdSpan?.context?.())?.toSpanId?.(true) ?? externalParentId;
+			this.captureTraceContext(traceId, options);
+			this.openSpanCounts.set(traceId, (this.openSpanCounts.get(traceId) ?? 0) + 1);
+			this.ddSpanMap.set(spanId, ddSpan);
+			this.registerLlmObsSpan(ddSpan, traceId, options, llmobsParentDdSpan);
+			this.logger.debug(`[DatadogBridge.createSpan] Created APM span [spanId=${spanId}] [traceId=${traceId}] [parentSpanId=${parentSpanId}] [type=${options.type}] [mapSize=${this.ddSpanMap.size}] [parentSource=${parentSource}] [externalParentId=${externalParentId ?? "none"}]`);
+			return {
+				spanId,
+				traceId,
+				parentSpanId
+			};
+		} catch (error) {
+			this.logger.error("[DatadogBridge] Failed to create span:", error);
+			return;
+		}
+	}
+	/**
+	* Execute an async function within the dd-trace context of a Mastra span.
+	*/
+	executeInContext(spanId, fn) {
+		return this.executeWithSpanContext(spanId, fn);
+	}
+	/**
+	* Execute a synchronous function within the dd-trace context of a Mastra span.
+	*/
+	executeInContextSync(spanId, fn) {
+		return this.executeWithSpanContext(spanId, fn);
+	}
+	async onScoreEvent(event) {
+		if (this.isDisabled || !dd_trace.default.llmobs?.submitEvaluation) return;
+		const { score } = event;
+		if (!score.traceId || !score.spanId) {
+			this.logger.warn("Datadog bridge: dropping score with no traceId/spanId", { scorerId: score.scorerId });
+			return;
+		}
+		try {
+			dd_trace.default.llmobs.submitEvaluation({
+				traceId: score.traceId,
+				spanId: toDatadogSpanId(score.spanId)
+			}, {
+				label: score.scorerName ?? score.scorerId,
+				value: score.score,
+				metricType: "score",
+				mlApp: this.config.mlApp,
+				timestampMs: score.timestamp instanceof Date ? score.timestamp.getTime() : Date.now(),
+				...score.reason ? { reasoning: score.reason } : {},
+				...score.metadata ? { metadata: score.metadata } : {}
+			});
+		} catch (error) {
+			this.logger.error("Datadog bridge: Failed to submit evaluation", {
+				error,
+				traceId: score.traceId,
+				spanId: score.spanId,
+				scorerId: score.scorerId
+			});
+		}
+	}
+	executeWithSpanContext(spanId, fn) {
+		const ddSpan = this.ddSpanMap.get(spanId);
+		if (ddSpan) return dd_trace.default.scope().activate(ddSpan, () => {
+			const llmobs = dd_trace.default.llmobs;
+			if (typeof llmobs?._activate === "function") return llmobs._activate(ddSpan, void 0, fn);
+			return fn();
+		});
+		return fn();
+	}
+	/**
+	* Handle tracing events from the observability bus.
+	*/
+	async _exportTracingEvent(event) {
+		if (this.isDisabled) return;
+		try {
+			const span = event.exportedSpan;
+			if (span.isEvent) {
+				if (event.type === "span_started" || event.type === "span_ended") this.annotateAndFinishSpan(span);
+				return;
+			}
+			switch (event.type) {
+				case "span_started":
+				case "span_updated": return;
+				case "span_ended":
+					this.annotateAndFinishSpan(span);
+					return;
+			}
+		} catch (error) {
+			this.logger.error("Datadog bridge error", {
+				error,
+				eventType: event.type,
+				spanId: event.exportedSpan?.id,
+				spanName: event.exportedSpan?.name
+			});
+		}
+	}
+	registerLlmObsSpan(ddSpan, traceId, options, parentDdSpan) {
+		const tagger = this.getLlmObsTagger();
+		if (!tagger) return;
+		try {
+			const kind = kindFor(options.type);
+			const ownAttrs = options.attributes;
+			const inheritedModelAttrs = options.parent?.type === _mastra_core_observability.SpanType.MODEL_GENERATION ? options.parent.attributes : void 0;
+			const traceCtx = this.resolveTraceContext(traceId, options);
+			tagger.registerLLMObsSpan(ddSpan, {
+				parent: parentDdSpan,
+				kind,
+				name: options.name,
+				userId: traceCtx.userId,
+				sessionId: traceCtx.sessionId,
+				...kind === "llm" && (ownAttrs?.model ?? inheritedModelAttrs?.model) ? { modelName: ownAttrs?.model ?? inheritedModelAttrs?.model } : {},
+				...kind === "llm" && (ownAttrs?.provider ?? inheritedModelAttrs?.provider) ? { modelProvider: ownAttrs?.provider ?? inheritedModelAttrs?.provider } : {}
+			});
+		} catch (error) {
+			this.logger.warn("[DatadogBridge] Failed to register LLMObs span", {
+				error,
+				spanName: options.name,
+				spanType: options.type
+			});
+		}
+	}
+	getLlmObsTagger() {
+		const tagger = dd_trace.default.llmobs?._tagger;
+		if (tagger && typeof tagger.registerLLMObsSpan === "function") return tagger;
+	}
+	/**
+	* Annotate the eagerly-created dd span and finish it using the final Mastra
+	* span state.
+	*/
+	annotateAndFinishSpan(span) {
+		const ddSpan = this.ddSpanMap.get(span.id);
+		if (!ddSpan) {
+			this.logger.warn("[DatadogBridge] No dd span found when finalizing Mastra span", {
+				spanId: span.id,
+				spanName: span.name,
+				spanType: span.type,
+				mapSize: this.ddSpanMap.size
+			});
+			return;
+		}
+		const endTime = span.endTime ? toDate(span.endTime) : span.isEvent ? toDate(span.startTime) : /* @__PURE__ */ new Date();
+		const annotations = this.buildAnnotations(span);
+		try {
+			if (Object.keys(annotations).length > 0 && dd_trace.default.llmobs?.annotate) dd_trace.default.llmobs.annotate(ddSpan, annotations);
+		} catch (error) {
+			this.logger.error("[DatadogBridge] Failed to annotate span before finish", {
+				error,
+				spanId: span.id,
+				spanName: span.name
+			});
+		}
+		try {
+			if (span.errorInfo) this.setErrorTags(ddSpan, span.errorInfo);
+		} catch (error) {
+			this.logger.error("[DatadogBridge] Failed to set error tags on dd span", {
+				error,
+				spanId: span.id,
+				spanName: span.name
+			});
+		}
+		try {
+			if (typeof ddSpan.finish === "function") ddSpan.finish(endTime.getTime());
+		} catch (error) {
+			this.logger.error("[DatadogBridge] Failed to finish dd span", {
+				error,
+				spanId: span.id,
+				spanName: span.name
+			});
+		} finally {
+			this.ddSpanMap.delete(span.id);
+			this.releaseTraceContext(span.traceId);
+		}
+	}
+	captureTraceContext(traceId, options) {
+		const existing = this.traceContext.get(traceId);
+		const next = {
+			userId: firstString(options.metadata?.userId, options.parent?.metadata?.userId, existing?.userId),
+			sessionId: firstString(options.metadata?.sessionId, options.parent?.metadata?.sessionId, existing?.sessionId)
+		};
+		if (next.userId || next.sessionId) this.traceContext.set(traceId, next);
+	}
+	resolveTraceContext(traceId, options) {
+		const stored = this.traceContext.get(traceId);
+		return {
+			userId: firstString(options.metadata?.userId, options.parent?.metadata?.userId, stored?.userId),
+			sessionId: firstString(options.metadata?.sessionId, options.parent?.metadata?.sessionId, stored?.sessionId)
+		};
+	}
+	releaseTraceContext(traceId) {
+		const nextCount = (this.openSpanCounts.get(traceId) ?? 1) - 1;
+		if (nextCount > 0) {
+			this.openSpanCounts.set(traceId, nextCount);
+			return;
+		}
+		this.openSpanCounts.delete(traceId);
+		this.traceContext.delete(traceId);
+	}
+	buildAnnotations(span) {
+		const annotations = {};
+		if (span.input !== void 0) annotations.inputData = formatInput(span.input, span.type);
+		if (span.output !== void 0) annotations.outputData = formatOutput(span.output, span.type);
+		const usageSpanType = isModelInferenceEnabled() ? _mastra_core_observability.SpanType.MODEL_INFERENCE : _mastra_core_observability.SpanType.MODEL_STEP;
+		if (span.type === usageSpanType) {
+			const usage = span.attributes?.usage;
+			const metrics = formatUsageMetrics(usage);
+			if (metrics) annotations.metrics = metrics;
+		}
+		const otherAttributes = (0, _mastra_core_utils.omitKeys)(span.attributes ?? {}, [
+			"usage",
+			"model",
+			"provider"
+		]);
+		const contextKeySet = new Set(this.config.requestContextKeys ?? []);
+		const flatContextTags = {};
+		const remainingMetadata = {};
+		for (const [key, value] of Object.entries(span.metadata ?? {})) if (contextKeySet.has(key)) flatContextTags[key] = value;
+		else remainingMetadata[key] = value;
+		const remainingAttributes = {};
+		for (const [key, value] of Object.entries(otherAttributes)) if (contextKeySet.has(key)) {
+			if (!(key in flatContextTags)) flatContextTags[key] = value;
+		} else remainingAttributes[key] = value;
+		const combinedMetadata = {
+			...remainingMetadata,
+			...remainingAttributes
+		};
+		if (span.errorInfo) combinedMetadata["error.message"] = span.errorInfo.message;
+		if (Object.keys(combinedMetadata).length > 0) annotations.metadata = combinedMetadata;
+		const tags = { ...flatContextTags };
+		if (span.tags?.length) for (const tag of span.tags) {
+			const colonIndex = tag.indexOf(":");
+			if (colonIndex > 0) tags[tag.substring(0, colonIndex)] = tag.substring(colonIndex + 1);
+			else tags[tag] = true;
+		}
+		if (span.errorInfo) {
+			tags.error = true;
+			if (span.errorInfo.id) tags["error.id"] = span.errorInfo.id;
+			if (span.errorInfo.domain) tags["error.domain"] = span.errorInfo.domain;
+			if (span.errorInfo.category) tags["error.category"] = span.errorInfo.category;
+		}
+		if (Object.keys(tags).length > 0) annotations.tags = tags;
+		return annotations;
+	}
+	setErrorTags(ddSpan, errorInfo) {
+		ddSpan.setTag("error", true);
+		ddSpan.setTag("error.message", errorInfo.message);
+		ddSpan.setTag("error.type", errorInfo.name ?? errorInfo.category ?? "Error");
+		if (errorInfo.stack) ddSpan.setTag("error.stack", errorInfo.stack);
+	}
+	async flush() {
+		if (this.isDisabled) return;
+		if (dd_trace.default.llmobs?.flush) try {
+			await dd_trace.default.llmobs.flush();
+			this.logger.debug("Datadog llmobs flushed");
+		} catch (e) {
+			this.logger.error("Error flushing llmobs", { error: e });
+		}
+		try {
+			await flushApmExporter();
+			this.logger.debug("Datadog APM exporter flushed");
+		} catch (e) {
+			this.logger.error("Error flushing Datadog APM exporter", { error: e });
+		}
+	}
+	async shutdown() {
+		for (const [spanId, ddSpan] of this.ddSpanMap) {
+			this.logger.warn(`[DatadogBridge] Force-finishing APM span that was not properly closed [id=${spanId}]`);
+			try {
+				if (typeof ddSpan.finish === "function") ddSpan.finish();
+			} catch {}
+		}
+		this.ddSpanMap.clear();
+		this.openSpanCounts.clear();
+		this.traceContext.clear();
+		await this.flush();
+		if (dd_trace.default.llmobs?.disable) try {
+			dd_trace.default.llmobs.disable();
+		} catch (e) {
+			this.logger.error("Error disabling llmobs", { error: e });
+		}
+		await super.shutdown();
+	}
 };
 function firstString(...values) {
-  for (const value of values) {
-    if (typeof value === "string") {
-      return value;
-    }
-  }
-  return void 0;
+	for (const value of values) if (typeof value === "string") return value;
 }
 function fillRandomBytes(bytes) {
-  try {
-    const webCrypto = globalThis.crypto;
-    if (webCrypto?.getRandomValues) {
-      webCrypto.getRandomValues.call(webCrypto, bytes);
-      return;
-    }
-  } catch {
-  }
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Math.floor(Math.random() * 256);
-  }
+	try {
+		const webCrypto = globalThis.crypto;
+		if (webCrypto?.getRandomValues) {
+			webCrypto.getRandomValues.call(webCrypto, bytes);
+			return;
+		}
+	} catch {}
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
 }
 function toDatadogSpanId(spanId) {
-  if (/^[0-9a-f]{16}$/i.test(spanId)) {
-    return BigInt(`0x${spanId}`).toString(10);
-  }
-  return spanId;
+	if (/^[0-9a-f]{16}$/i.test(spanId)) return BigInt(`0x${spanId}`).toString(10);
+	return spanId;
 }
 function generateSpanId() {
-  const bytes = new Uint8Array(8);
-  fillRandomBytes(bytes);
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	const bytes = /* @__PURE__ */ new Uint8Array(8);
+	fillRandomBytes(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function generateTraceId() {
-  const bytes = new Uint8Array(16);
-  fillRandomBytes(bytes);
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	fillRandomBytes(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-var MAX_TRACE_LIFETIME_MS = 30 * 60 * 1e3;
-var REGULAR_CLEANUP_INTERVAL_MS = 1 * 60 * 1e3;
-var DatadogExporter = class extends observability.BaseExporter {
-  name = "datadog";
-  config;
-  traceContext = /* @__PURE__ */ new Map();
-  traceState = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    super(config);
-    const mlApp = config.mlApp ?? process.env.DD_LLMOBS_ML_APP;
-    const apiKey = config.apiKey ?? process.env.DD_API_KEY;
-    const site = config.site ?? process.env.DD_SITE ?? "datadoghq.com";
-    const env = config.env ?? process.env.DD_ENV;
-    const envAgentless = process.env.DD_LLMOBS_AGENTLESS_ENABLED?.toLowerCase();
-    const agentless = config.agentless ?? (envAgentless === "false" || envAgentless === "0" ? false : true);
-    if (!mlApp) {
-      this.setDisabled(`Missing required mlApp. Set DD_LLMOBS_ML_APP environment variable or pass mlApp in config.`);
-      this.config = config;
-      return;
-    }
-    if (agentless && !apiKey) {
-      this.setDisabled(
-        `Missing required apiKey for agentless mode. Set DD_API_KEY environment variable or pass apiKey in config.`
-      );
-      this.config = config;
-      return;
-    }
-    this.config = { ...config, mlApp, site, apiKey, agentless, env };
-    ensureTracer({
-      mlApp,
-      site,
-      apiKey,
-      agentless,
-      service: config.service,
-      env,
-      integrationsEnabled: config.integrationsEnabled
-    });
-    this.logger.info("Datadog exporter initialized", { mlApp, site, agentless });
-  }
-  /**
-   * Main entry point for tracing events from Mastra.
-   */
-  async _exportTracingEvent(event) {
-    if (this.isDisabled || !tracer3__default.default.llmobs) return;
-    try {
-      const span = event.exportedSpan;
-      if (span.isEvent) {
-        if (event.type === "span_started") {
-          this.captureTraceContext(span);
-          this.enqueueSpan(span);
-        }
-        return;
-      }
-      switch (event.type) {
-        case "span_started":
-          this.captureTraceContext(span);
-          return;
-        case "span_updated":
-          return;
-        case "span_ended":
-          this.enqueueSpan(span);
-          return;
-      }
-    } catch (error) {
-      this.logger.error("Datadog exporter error", {
-        error,
-        eventType: event.type,
-        spanId: event.exportedSpan?.id,
-        spanName: event.exportedSpan?.name
-      });
-    }
-  }
-  /**
-   * Captures user/session context from root spans for tagging all spans in the trace.
-   */
-  captureTraceContext(span) {
-    if (span.isRootSpan && !this.traceContext.has(span.traceId)) {
-      this.traceContext.set(span.traceId, {
-        userId: span.metadata?.userId,
-        sessionId: span.metadata?.sessionId
-      });
-    }
-  }
-  /**
-   * Queue span until its parent context is available, then emit spans parent-first.
-   */
-  enqueueSpan(span) {
-    const state = this.getOrCreateTraceState(span.traceId);
-    if (span.isRootSpan) {
-      state.rootEnded = true;
-    }
-    state.buffer.set(span.id, span);
-    this.tryEmitReadySpans(span.traceId);
-  }
-  /**
-   * Sets native dd-trace error tags required by Datadog's Error Tracking UI.
-   */
-  setErrorTags(ddSpan, errorInfo) {
-    ddSpan.setTag("error", true);
-    ddSpan.setTag("error.message", errorInfo.message);
-    ddSpan.setTag("error.type", errorInfo.name ?? errorInfo.category ?? "Error");
-    if (errorInfo.stack) {
-      ddSpan.setTag("error.stack", errorInfo.stack);
-    }
-  }
-  /**
-   * Builds annotations object for llmobs.annotate().
-   * Uses dd-trace's expected property names: inputData, outputData, metadata, tags, metrics.
-   */
-  buildAnnotations(span) {
-    const annotations = {};
-    if (span.input !== void 0) {
-      annotations.inputData = formatInput(span.input, span.type);
-    }
-    if (span.output !== void 0) {
-      annotations.outputData = formatOutput(span.output, span.type);
-    }
-    const usageSpanType = isModelInferenceEnabled() ? observability$1.SpanType.MODEL_INFERENCE : observability$1.SpanType.MODEL_STEP;
-    if (span.type === usageSpanType) {
-      const usage = span.attributes?.usage;
-      const metrics = formatUsageMetrics(usage);
-      if (metrics) {
-        annotations.metrics = metrics;
-      }
-    }
-    const knownFields = ["usage", "model", "provider"];
-    const otherAttributes = utils.omitKeys(span.attributes ?? {}, knownFields);
-    const contextKeySet = new Set(this.config.requestContextKeys ?? []);
-    const flatContextTags = {};
-    const remainingMetadata = {};
-    for (const [key, value] of Object.entries(span.metadata ?? {})) {
-      if (contextKeySet.has(key)) {
-        flatContextTags[key] = value;
-      } else {
-        remainingMetadata[key] = value;
-      }
-    }
-    const remainingAttributes = {};
-    for (const [key, value] of Object.entries(otherAttributes)) {
-      if (contextKeySet.has(key)) {
-        if (!(key in flatContextTags)) {
-          flatContextTags[key] = value;
-        }
-      } else {
-        remainingAttributes[key] = value;
-      }
-    }
-    const combinedMetadata = {
-      ...remainingMetadata,
-      ...remainingAttributes
-    };
-    if (span.errorInfo) {
-      combinedMetadata["error.message"] = span.errorInfo.message;
-    }
-    if (Object.keys(combinedMetadata).length > 0) {
-      annotations.metadata = combinedMetadata;
-    }
-    const tags = {
-      // Promote requestContextKeys values to flat, searchable LLM Observability tags
-      ...flatContextTags
-    };
-    if (span.tags?.length) {
-      for (const tag of span.tags) {
-        const colonIndex = tag.indexOf(":");
-        if (colonIndex > 0) {
-          tags[tag.substring(0, colonIndex)] = tag.substring(colonIndex + 1);
-        } else {
-          tags[tag] = true;
-        }
-      }
-    }
-    if (span.errorInfo) {
-      tags.error = true;
-      if (span.errorInfo.id) {
-        tags["error.id"] = span.errorInfo.id;
-      }
-      if (span.errorInfo.domain) {
-        tags["error.domain"] = span.errorInfo.domain;
-      }
-      if (span.errorInfo.category) {
-        tags["error.category"] = span.errorInfo.category;
-      }
-    }
-    if (Object.keys(tags).length > 0) {
-      annotations.tags = tags;
-    }
-    return annotations;
-  }
-  /**
-   * Submit an eval score to Datadog LLM Observability for the matching ddSpan.
-   *
-   * Ordering constraint: the matching span must have already been emitted to dd-trace
-   * (i.e. its `SPAN_ENDED` event must have been processed and the trace tree flushed).
-   * On Mastra's normal scoring path this is always true — scorer hooks fire after the
-   * scored entity completes, so the root span has ended by the time `onScoreEvent` runs.
-   *
-   * If a score arrives for an unexported span (either before `SPAN_ENDED` or after the
-   * `traceState` entry has been cleaned up), the event is dropped and a warning is logged
-   * so the misuse is observable. Scores must therefore only be submitted for spans whose
-   * lifecycle has completed.
-   */
-  async onScoreEvent(event) {
-    if (this.isDisabled || !tracer3__default.default.llmobs?.submitEvaluation) return;
-    const { score } = event;
-    if (!score.traceId || !score.spanId) {
-      this.logger.warn("Datadog exporter: dropping score with no traceId/spanId", {
-        scorerId: score.scorerId
-      });
-      return;
-    }
-    const ctx = this.traceState.get(score.traceId)?.contexts.get(score.spanId);
-    const exported = ctx?.exported;
-    if (!exported) {
-      this.logger.warn(
-        "Datadog exporter: dropping score for span that has not been emitted to dd-trace yet (span_ended must be processed before submitting a score for it)",
-        {
-          traceId: score.traceId,
-          spanId: score.spanId,
-          scorerId: score.scorerId
-        }
-      );
-      return;
-    }
-    try {
-      tracer3__default.default.llmobs.submitEvaluation(
-        { traceId: exported.traceId, spanId: exported.spanId },
-        {
-          label: score.scorerName ?? score.scorerId,
-          value: score.score,
-          metricType: "score",
-          mlApp: this.config.mlApp,
-          timestampMs: score.timestamp instanceof Date ? score.timestamp.getTime() : Date.now(),
-          ...score.reason ? { reasoning: score.reason } : {},
-          ...score.metadata ? { metadata: score.metadata } : {}
-        }
-      );
-    } catch (err) {
-      this.logger.error("Datadog exporter: Failed to submit evaluation", {
-        error: err,
-        traceId: score.traceId,
-        spanId: score.spanId,
-        scorerId: score.scorerId
-      });
-    }
-  }
-  /**
-   * Force flush any buffered spans without shutting down the exporter.
-   * This is useful in serverless environments where you need to ensure spans
-   * are exported before the runtime instance is terminated.
-   */
-  async flush() {
-    if (this.isDisabled || !tracer3__default.default.llmobs) return;
-    if (tracer3__default.default.llmobs?.flush) {
-      try {
-        await tracer3__default.default.llmobs.flush();
-        this.logger.debug("Datadog llmobs flushed");
-      } catch (e) {
-        this.logger.error("Error flushing llmobs", { error: e });
-      }
-    }
-  }
-  /**
-   * Gracefully shuts down the exporter.
-   */
-  async shutdown() {
-    for (const [traceId, state] of this.traceState) {
-      if (state.cleanupTimer) {
-        clearTimeout(state.cleanupTimer);
-      }
-      if (state.maxLifetimeTimer) {
-        clearTimeout(state.maxLifetimeTimer);
-      }
-      if (state.buffer.size > 0) {
-        this.logger.warn("Shutdown with pending spans", {
-          traceId,
-          pendingCount: state.buffer.size,
-          spanIds: Array.from(state.buffer.keys())
-        });
-      }
-    }
-    this.traceState.clear();
-    await this.flush();
-    if (tracer3__default.default.llmobs?.disable) {
-      try {
-        tracer3__default.default.llmobs.disable();
-      } catch (e) {
-        this.logger.error("Error disabling llmobs", { error: e });
-      }
-    }
-    this.traceContext.clear();
-    await super.shutdown();
-  }
-  /**
-   * Retrieve or initialize trace state for buffering and parent tracking.
-   */
-  getOrCreateTraceState(traceId) {
-    const existing = this.traceState.get(traceId);
-    if (existing) {
-      if (existing.cleanupTimer) {
-        clearTimeout(existing.cleanupTimer);
-        existing.cleanupTimer = void 0;
-      }
-      return existing;
-    }
-    const created = {
-      buffer: /* @__PURE__ */ new Map(),
-      contexts: /* @__PURE__ */ new Map(),
-      rootEnded: false,
-      treeEmitted: false,
-      createdAt: Date.now(),
-      cleanupTimer: void 0,
-      maxLifetimeTimer: void 0
-    };
-    const maxLifetimeTimer = setTimeout(() => {
-      const state = this.traceState.get(traceId);
-      if (state) {
-        if (state.buffer.size > 0 || state.contexts.size > 0) {
-          this.logger.warn("Discarding trace due to max lifetime exceeded", {
-            traceId,
-            bufferedSpans: state.buffer.size,
-            emittedSpans: state.contexts.size,
-            lifetimeMs: Date.now() - state.createdAt
-          });
-        }
-        if (state.cleanupTimer) {
-          clearTimeout(state.cleanupTimer);
-        }
-        this.traceState.delete(traceId);
-        this.traceContext.delete(traceId);
-      }
-    }, MAX_TRACE_LIFETIME_MS);
-    maxLifetimeTimer.unref?.();
-    created.maxLifetimeTimer = maxLifetimeTimer;
-    this.traceState.set(traceId, created);
-    return created;
-  }
-  /**
-   * Attempt to emit spans from the buffer.
-   *
-   * Two modes of operation:
-   * 1. Initial tree emission: When root span ends and tree hasn't been emitted yet,
-   *    build a tree from all buffered spans and emit recursively using nested
-   *    llmobs.trace() calls. This ensures proper parent-child relationships in Datadog.
-   * 2. Late-arriving spans: After the tree has been emitted, emit individual spans
-   *    with their parent context for proper linking.
-   */
-  tryEmitReadySpans(traceId) {
-    const state = this.traceState.get(traceId);
-    if (!state) return;
-    if (!state.treeEmitted) {
-      if (!state.rootEnded) return;
-      const tree = this.buildSpanTree(state.buffer);
-      if (tree) {
-        this.emitSpanTree(tree, state);
-      }
-      state.buffer.clear();
-      state.treeEmitted = true;
-    } else {
-      let emitted = false;
-      do {
-        emitted = false;
-        for (const [spanId, span] of state.buffer) {
-          const parentCtx = span.parentSpanId ? state.contexts.get(span.parentSpanId) : void 0;
-          if (span.parentSpanId && !parentCtx) {
-            continue;
-          }
-          this.emitSingleSpan(span, state, parentCtx?.ddSpan);
-          state.buffer.delete(spanId);
-          emitted = true;
-        }
-      } while (emitted);
-    }
-    if (state.rootEnded && state.buffer.size === 0 && !state.cleanupTimer) {
-      const timer = setTimeout(() => {
-        const currentState = this.traceState.get(traceId);
-        if (currentState) {
-          if (currentState.buffer.size > 0) {
-            this.logger.warn("Discarding orphaned spans during cleanup", {
-              traceId,
-              orphanedCount: currentState.buffer.size,
-              spanIds: Array.from(currentState.buffer.keys())
-            });
-          }
-          if (currentState.maxLifetimeTimer) {
-            clearTimeout(currentState.maxLifetimeTimer);
-          }
-        }
-        this.traceState.delete(traceId);
-        this.traceContext.delete(traceId);
-      }, REGULAR_CLEANUP_INTERVAL_MS);
-      timer.unref?.();
-      state.cleanupTimer = timer;
-    }
-  }
-  /**
-   * Builds a tree structure from buffered spans based on parentSpanId relationships.
-   * Returns the root node of the tree, or undefined if no root span is found.
-   */
-  buildSpanTree(buffer) {
-    const nodes = /* @__PURE__ */ new Map();
-    let rootNode;
-    for (const span of buffer.values()) {
-      nodes.set(span.id, { span, children: [] });
-    }
-    for (const node of nodes.values()) {
-      if (node.span.isRootSpan) {
-        rootNode = node;
-      } else if (node.span.parentSpanId) {
-        const parentNode = nodes.get(node.span.parentSpanId);
-        if (parentNode) {
-          parentNode.children.push(node);
-        } else {
-          this.logger.warn("Orphaned span detected during tree build", {
-            spanId: node.span.id,
-            parentSpanId: node.span.parentSpanId,
-            traceId: node.span.traceId
-          });
-        }
-      }
-    }
-    for (const node of nodes.values()) {
-      node.children.sort((a, b) => {
-        const aTime = a.span.startTime instanceof Date ? a.span.startTime.getTime() : new Date(a.span.startTime).getTime();
-        const bTime = b.span.startTime instanceof Date ? b.span.startTime.getTime() : new Date(b.span.startTime).getTime();
-        return aTime - bTime;
-      });
-    }
-    return rootNode;
-  }
-  /**
-   * Builds LLMObs span options from a Mastra span.
-   * Handles trace context, timestamps, and conditional model information for LLM spans.
-   */
-  buildSpanOptions(span, inheritedModelAttrs) {
-    const traceCtx = this.traceContext.get(span.traceId) || {
-      userId: span.metadata?.userId,
-      sessionId: span.metadata?.sessionId
-    };
-    const kind = kindFor(span.type);
-    const ownAttrs = span.attributes;
-    const attrs = {
-      model: ownAttrs?.model ?? inheritedModelAttrs?.model,
-      provider: ownAttrs?.provider ?? inheritedModelAttrs?.provider
-    };
-    const startTime = toDate(span.startTime);
-    const endTime = span.endTime ? toDate(span.endTime) : span.isEvent ? startTime : /* @__PURE__ */ new Date();
-    return {
-      traceOptions: {
-        kind,
-        name: span.name,
-        sessionId: traceCtx.sessionId,
-        userId: traceCtx.userId,
-        startTime,
-        ...kind === "llm" && attrs?.model ? { modelName: attrs.model } : {},
-        ...kind === "llm" && attrs?.provider ? { modelProvider: attrs.provider } : {}
-      },
-      // endTime as milliseconds for ddSpan.finish() — dd-trace's llmobs.trace() does not
-      // honor endTime in options, so we must call finish(ms) explicitly on the span.
-      endTimeMs: endTime.getTime()
-    };
-  }
-  /**
-   * Recursively emits a span tree using nested llmobs.trace() calls.
-   * This ensures parent-child relationships are properly established in Datadog
-   * because child spans are created while their parent span is active in scope.
-   */
-  emitSpanTree(node, state, inheritedModelAttrs) {
-    const span = node.span;
-    const { traceOptions, endTimeMs } = this.buildSpanOptions(span, inheritedModelAttrs);
-    const childInheritedModelAttrs = span.type === observability$1.SpanType.MODEL_GENERATION ? {
-      model: span.attributes?.model,
-      provider: span.attributes?.provider
-    } : inheritedModelAttrs;
-    tracer3__default.default.llmobs.trace(traceOptions, (ddSpan) => {
-      const annotations = this.buildAnnotations(span);
-      if (Object.keys(annotations).length > 0) {
-        tracer3__default.default.llmobs.annotate(ddSpan, annotations);
-      }
-      if (span.errorInfo) {
-        this.setErrorTags(ddSpan, span.errorInfo);
-      }
-      const exported = tracer3__default.default.llmobs.exportSpan ? tracer3__default.default.llmobs.exportSpan(ddSpan) : void 0;
-      state.contexts.set(span.id, { ddSpan, exported });
-      for (const child of node.children) {
-        this.emitSpanTree(child, state, childInheritedModelAttrs);
-      }
-      if (typeof ddSpan.finish === "function") {
-        ddSpan.finish(endTimeMs);
-      }
-    });
-  }
-  /**
-   * Emit a single span with the proper Datadog parent context.
-   * Used for late-arriving spans after the main tree has been emitted.
-   */
-  emitSingleSpan(span, state, parent) {
-    const { traceOptions, endTimeMs } = this.buildSpanOptions(span);
-    const runTrace = () => tracer3__default.default.llmobs.trace(traceOptions, (ddSpan) => {
-      const annotations = this.buildAnnotations(span);
-      if (Object.keys(annotations).length > 0) {
-        tracer3__default.default.llmobs.annotate(ddSpan, annotations);
-      }
-      if (span.errorInfo) {
-        this.setErrorTags(ddSpan, span.errorInfo);
-      }
-      const exported = tracer3__default.default.llmobs.exportSpan ? tracer3__default.default.llmobs.exportSpan(ddSpan) : void 0;
-      state.contexts.set(span.id, { ddSpan, exported });
-      if (typeof ddSpan.finish === "function") {
-        ddSpan.finish(endTimeMs);
-      }
-    });
-    if (parent) {
-      tracer3__default.default.scope().activate(parent, runTrace);
-    } else {
-      runTrace();
-    }
-  }
+//#endregion
+//#region src/tracing.ts
+/**
+* Maximum lifetime for a trace state entry (30 minutes).
+* This is a fallback cleanup mechanism for traces that never receive a root span
+* or have all spans marked as non-root, preventing unbounded memory growth.
+*/
+const MAX_TRACE_LIFETIME_MS = 1800 * 1e3;
+/**
+* Regular cleanup interval for trace state entries (1 minute).
+*/
+const REGULAR_CLEANUP_INTERVAL_MS = 60 * 1e3;
+/**
+* Datadog LLM Observability Exporter for Mastra.
+*
+* Exports observability data to Datadog's LLM Observability product using
+* a completion-only pattern where spans are emitted on span_ended events.
+*/
+var DatadogExporter = class extends _mastra_observability.BaseExporter {
+	name = "datadog";
+	config;
+	traceContext = /* @__PURE__ */ new Map();
+	traceState = /* @__PURE__ */ new Map();
+	constructor(config = {}) {
+		super(config);
+		const mlApp = config.mlApp ?? process.env.DD_LLMOBS_ML_APP;
+		const apiKey = config.apiKey ?? process.env.DD_API_KEY;
+		const site = config.site ?? process.env.DD_SITE ?? "datadoghq.com";
+		const env = config.env ?? process.env.DD_ENV;
+		const envAgentless = process.env.DD_LLMOBS_AGENTLESS_ENABLED?.toLowerCase();
+		const agentless = config.agentless ?? (envAgentless === "false" || envAgentless === "0" ? false : true);
+		if (!mlApp) {
+			this.setDisabled(`Missing required mlApp. Set DD_LLMOBS_ML_APP environment variable or pass mlApp in config.`);
+			this.config = config;
+			return;
+		}
+		if (agentless && !apiKey) {
+			this.setDisabled(`Missing required apiKey for agentless mode. Set DD_API_KEY environment variable or pass apiKey in config.`);
+			this.config = config;
+			return;
+		}
+		this.config = {
+			...config,
+			mlApp,
+			site,
+			apiKey,
+			agentless,
+			env
+		};
+		ensureTracer({
+			mlApp,
+			site,
+			apiKey,
+			agentless,
+			service: config.service,
+			env,
+			integrationsEnabled: config.integrationsEnabled
+		});
+		this.logger.info("Datadog exporter initialized", {
+			mlApp,
+			site,
+			agentless
+		});
+	}
+	/**
+	* Main entry point for tracing events from Mastra.
+	*/
+	async _exportTracingEvent(event) {
+		if (this.isDisabled || !dd_trace.default.llmobs) return;
+		try {
+			const span = event.exportedSpan;
+			if (span.isEvent) {
+				if (event.type === "span_started") {
+					this.captureTraceContext(span);
+					this.enqueueSpan(span);
+				}
+				return;
+			}
+			switch (event.type) {
+				case "span_started":
+					this.captureTraceContext(span);
+					return;
+				case "span_updated": return;
+				case "span_ended":
+					this.enqueueSpan(span);
+					return;
+			}
+		} catch (error) {
+			this.logger.error("Datadog exporter error", {
+				error,
+				eventType: event.type,
+				spanId: event.exportedSpan?.id,
+				spanName: event.exportedSpan?.name
+			});
+		}
+	}
+	/**
+	* Captures user/session context from root spans for tagging all spans in the trace.
+	*/
+	captureTraceContext(span) {
+		if (span.isRootSpan && !this.traceContext.has(span.traceId)) this.traceContext.set(span.traceId, {
+			userId: span.metadata?.userId,
+			sessionId: span.metadata?.sessionId
+		});
+	}
+	/**
+	* Queue span until its parent context is available, then emit spans parent-first.
+	*/
+	enqueueSpan(span) {
+		const state = this.getOrCreateTraceState(span.traceId);
+		if (span.isRootSpan) state.rootEnded = true;
+		state.buffer.set(span.id, span);
+		this.tryEmitReadySpans(span.traceId);
+	}
+	/**
+	* Sets native dd-trace error tags required by Datadog's Error Tracking UI.
+	*/
+	setErrorTags(ddSpan, errorInfo) {
+		ddSpan.setTag("error", true);
+		ddSpan.setTag("error.message", errorInfo.message);
+		ddSpan.setTag("error.type", errorInfo.name ?? errorInfo.category ?? "Error");
+		if (errorInfo.stack) ddSpan.setTag("error.stack", errorInfo.stack);
+	}
+	/**
+	* Builds annotations object for llmobs.annotate().
+	* Uses dd-trace's expected property names: inputData, outputData, metadata, tags, metrics.
+	*/
+	buildAnnotations(span) {
+		const annotations = {};
+		if (span.input !== void 0) annotations.inputData = formatInput(span.input, span.type);
+		if (span.output !== void 0) annotations.outputData = formatOutput(span.output, span.type);
+		const usageSpanType = isModelInferenceEnabled() ? _mastra_core_observability.SpanType.MODEL_INFERENCE : _mastra_core_observability.SpanType.MODEL_STEP;
+		if (span.type === usageSpanType) {
+			const usage = span.attributes?.usage;
+			const metrics = formatUsageMetrics(usage);
+			if (metrics) annotations.metrics = metrics;
+		}
+		const otherAttributes = (0, _mastra_core_utils.omitKeys)(span.attributes ?? {}, [
+			"usage",
+			"model",
+			"provider"
+		]);
+		const contextKeySet = new Set(this.config.requestContextKeys ?? []);
+		const flatContextTags = {};
+		const remainingMetadata = {};
+		for (const [key, value] of Object.entries(span.metadata ?? {})) if (contextKeySet.has(key)) flatContextTags[key] = value;
+		else remainingMetadata[key] = value;
+		const remainingAttributes = {};
+		for (const [key, value] of Object.entries(otherAttributes)) if (contextKeySet.has(key)) {
+			if (!(key in flatContextTags)) flatContextTags[key] = value;
+		} else remainingAttributes[key] = value;
+		const combinedMetadata = {
+			...remainingMetadata,
+			...remainingAttributes
+		};
+		if (span.errorInfo) combinedMetadata["error.message"] = span.errorInfo.message;
+		if (Object.keys(combinedMetadata).length > 0) annotations.metadata = combinedMetadata;
+		const tags = { ...flatContextTags };
+		if (span.tags?.length) for (const tag of span.tags) {
+			const colonIndex = tag.indexOf(":");
+			if (colonIndex > 0) tags[tag.substring(0, colonIndex)] = tag.substring(colonIndex + 1);
+			else tags[tag] = true;
+		}
+		if (span.errorInfo) {
+			tags.error = true;
+			if (span.errorInfo.id) tags["error.id"] = span.errorInfo.id;
+			if (span.errorInfo.domain) tags["error.domain"] = span.errorInfo.domain;
+			if (span.errorInfo.category) tags["error.category"] = span.errorInfo.category;
+		}
+		if (Object.keys(tags).length > 0) annotations.tags = tags;
+		return annotations;
+	}
+	/**
+	* Submit an eval score to Datadog LLM Observability for the matching ddSpan.
+	*
+	* Ordering constraint: the matching span must have already been emitted to dd-trace
+	* (i.e. its `SPAN_ENDED` event must have been processed and the trace tree flushed).
+	* On Mastra's normal scoring path this is always true — scorer hooks fire after the
+	* scored entity completes, so the root span has ended by the time `onScoreEvent` runs.
+	*
+	* If a score arrives for an unexported span (either before `SPAN_ENDED` or after the
+	* `traceState` entry has been cleaned up), the event is dropped and a warning is logged
+	* so the misuse is observable. Scores must therefore only be submitted for spans whose
+	* lifecycle has completed.
+	*/
+	async onScoreEvent(event) {
+		if (this.isDisabled || !dd_trace.default.llmobs?.submitEvaluation) return;
+		const { score } = event;
+		if (!score.traceId || !score.spanId) {
+			this.logger.warn("Datadog exporter: dropping score with no traceId/spanId", { scorerId: score.scorerId });
+			return;
+		}
+		const exported = (this.traceState.get(score.traceId)?.contexts.get(score.spanId))?.exported;
+		if (!exported) {
+			this.logger.warn("Datadog exporter: dropping score for span that has not been emitted to dd-trace yet (span_ended must be processed before submitting a score for it)", {
+				traceId: score.traceId,
+				spanId: score.spanId,
+				scorerId: score.scorerId
+			});
+			return;
+		}
+		try {
+			dd_trace.default.llmobs.submitEvaluation({
+				traceId: exported.traceId,
+				spanId: exported.spanId
+			}, {
+				label: score.scorerName ?? score.scorerId,
+				value: score.score,
+				metricType: "score",
+				mlApp: this.config.mlApp,
+				timestampMs: score.timestamp instanceof Date ? score.timestamp.getTime() : Date.now(),
+				...score.reason ? { reasoning: score.reason } : {},
+				...score.metadata ? { metadata: score.metadata } : {}
+			});
+		} catch (err) {
+			this.logger.error("Datadog exporter: Failed to submit evaluation", {
+				error: err,
+				traceId: score.traceId,
+				spanId: score.spanId,
+				scorerId: score.scorerId
+			});
+		}
+	}
+	/**
+	* Force flush any buffered spans without shutting down the exporter.
+	* This is useful in serverless environments where you need to ensure spans
+	* are exported before the runtime instance is terminated.
+	*/
+	async flush() {
+		if (this.isDisabled || !dd_trace.default.llmobs) return;
+		if (dd_trace.default.llmobs?.flush) try {
+			await dd_trace.default.llmobs.flush();
+			this.logger.debug("Datadog llmobs flushed");
+		} catch (e) {
+			this.logger.error("Error flushing llmobs", { error: e });
+		}
+	}
+	/**
+	* Gracefully shuts down the exporter.
+	*/
+	async shutdown() {
+		for (const [traceId, state] of this.traceState) {
+			if (state.cleanupTimer) clearTimeout(state.cleanupTimer);
+			if (state.maxLifetimeTimer) clearTimeout(state.maxLifetimeTimer);
+			if (state.buffer.size > 0) this.logger.warn("Shutdown with pending spans", {
+				traceId,
+				pendingCount: state.buffer.size,
+				spanIds: Array.from(state.buffer.keys())
+			});
+		}
+		this.traceState.clear();
+		await this.flush();
+		if (dd_trace.default.llmobs?.disable) try {
+			dd_trace.default.llmobs.disable();
+		} catch (e) {
+			this.logger.error("Error disabling llmobs", { error: e });
+		}
+		this.traceContext.clear();
+		await super.shutdown();
+	}
+	/**
+	* Retrieve or initialize trace state for buffering and parent tracking.
+	*/
+	getOrCreateTraceState(traceId) {
+		const existing = this.traceState.get(traceId);
+		if (existing) {
+			if (existing.cleanupTimer) {
+				clearTimeout(existing.cleanupTimer);
+				existing.cleanupTimer = void 0;
+			}
+			return existing;
+		}
+		const created = {
+			buffer: /* @__PURE__ */ new Map(),
+			contexts: /* @__PURE__ */ new Map(),
+			rootEnded: false,
+			treeEmitted: false,
+			createdAt: Date.now(),
+			cleanupTimer: void 0,
+			maxLifetimeTimer: void 0
+		};
+		const maxLifetimeTimer = setTimeout(() => {
+			const state = this.traceState.get(traceId);
+			if (state) {
+				if (state.buffer.size > 0 || state.contexts.size > 0) this.logger.warn("Discarding trace due to max lifetime exceeded", {
+					traceId,
+					bufferedSpans: state.buffer.size,
+					emittedSpans: state.contexts.size,
+					lifetimeMs: Date.now() - state.createdAt
+				});
+				if (state.cleanupTimer) clearTimeout(state.cleanupTimer);
+				this.traceState.delete(traceId);
+				this.traceContext.delete(traceId);
+			}
+		}, MAX_TRACE_LIFETIME_MS);
+		maxLifetimeTimer.unref?.();
+		created.maxLifetimeTimer = maxLifetimeTimer;
+		this.traceState.set(traceId, created);
+		return created;
+	}
+	/**
+	* Attempt to emit spans from the buffer.
+	*
+	* Two modes of operation:
+	* 1. Initial tree emission: When root span ends and tree hasn't been emitted yet,
+	*    build a tree from all buffered spans and emit recursively using nested
+	*    llmobs.trace() calls. This ensures proper parent-child relationships in Datadog.
+	* 2. Late-arriving spans: After the tree has been emitted, emit individual spans
+	*    with their parent context for proper linking.
+	*/
+	tryEmitReadySpans(traceId) {
+		const state = this.traceState.get(traceId);
+		if (!state) return;
+		if (!state.treeEmitted) {
+			if (!state.rootEnded) return;
+			const tree = this.buildSpanTree(state.buffer);
+			if (tree) this.emitSpanTree(tree, state);
+			state.buffer.clear();
+			state.treeEmitted = true;
+		} else {
+			let emitted = false;
+			do {
+				emitted = false;
+				for (const [spanId, span] of state.buffer) {
+					const parentCtx = span.parentSpanId ? state.contexts.get(span.parentSpanId) : void 0;
+					if (span.parentSpanId && !parentCtx) continue;
+					this.emitSingleSpan(span, state, parentCtx?.ddSpan);
+					state.buffer.delete(spanId);
+					emitted = true;
+				}
+			} while (emitted);
+		}
+		if (state.rootEnded && state.buffer.size === 0 && !state.cleanupTimer) {
+			const timer = setTimeout(() => {
+				const currentState = this.traceState.get(traceId);
+				if (currentState) {
+					if (currentState.buffer.size > 0) this.logger.warn("Discarding orphaned spans during cleanup", {
+						traceId,
+						orphanedCount: currentState.buffer.size,
+						spanIds: Array.from(currentState.buffer.keys())
+					});
+					if (currentState.maxLifetimeTimer) clearTimeout(currentState.maxLifetimeTimer);
+				}
+				this.traceState.delete(traceId);
+				this.traceContext.delete(traceId);
+			}, REGULAR_CLEANUP_INTERVAL_MS);
+			timer.unref?.();
+			state.cleanupTimer = timer;
+		}
+	}
+	/**
+	* Builds a tree structure from buffered spans based on parentSpanId relationships.
+	* Returns the root node of the tree, or undefined if no root span is found.
+	*/
+	buildSpanTree(buffer) {
+		const nodes = /* @__PURE__ */ new Map();
+		let rootNode;
+		for (const span of buffer.values()) nodes.set(span.id, {
+			span,
+			children: []
+		});
+		for (const node of nodes.values()) if (node.span.isRootSpan) rootNode = node;
+		else if (node.span.parentSpanId) {
+			const parentNode = nodes.get(node.span.parentSpanId);
+			if (parentNode) parentNode.children.push(node);
+			else this.logger.warn("Orphaned span detected during tree build", {
+				spanId: node.span.id,
+				parentSpanId: node.span.parentSpanId,
+				traceId: node.span.traceId
+			});
+		}
+		for (const node of nodes.values()) node.children.sort((a, b) => {
+			return (a.span.startTime instanceof Date ? a.span.startTime.getTime() : new Date(a.span.startTime).getTime()) - (b.span.startTime instanceof Date ? b.span.startTime.getTime() : new Date(b.span.startTime).getTime());
+		});
+		return rootNode;
+	}
+	/**
+	* Builds LLMObs span options from a Mastra span.
+	* Handles trace context, timestamps, and conditional model information for LLM spans.
+	*/
+	buildSpanOptions(span, inheritedModelAttrs) {
+		const traceCtx = this.traceContext.get(span.traceId) || {
+			userId: span.metadata?.userId,
+			sessionId: span.metadata?.sessionId
+		};
+		const kind = kindFor(span.type);
+		const ownAttrs = span.attributes;
+		const attrs = {
+			model: ownAttrs?.model ?? inheritedModelAttrs?.model,
+			provider: ownAttrs?.provider ?? inheritedModelAttrs?.provider
+		};
+		const startTime = toDate(span.startTime);
+		const endTime = span.endTime ? toDate(span.endTime) : span.isEvent ? startTime : /* @__PURE__ */ new Date();
+		return {
+			traceOptions: {
+				kind,
+				name: span.name,
+				sessionId: traceCtx.sessionId,
+				userId: traceCtx.userId,
+				startTime,
+				...kind === "llm" && attrs?.model ? { modelName: attrs.model } : {},
+				...kind === "llm" && attrs?.provider ? { modelProvider: attrs.provider } : {}
+			},
+			endTimeMs: endTime.getTime()
+		};
+	}
+	/**
+	* Recursively emits a span tree using nested llmobs.trace() calls.
+	* This ensures parent-child relationships are properly established in Datadog
+	* because child spans are created while their parent span is active in scope.
+	*/
+	emitSpanTree(node, state, inheritedModelAttrs) {
+		const span = node.span;
+		const { traceOptions, endTimeMs } = this.buildSpanOptions(span, inheritedModelAttrs);
+		const childInheritedModelAttrs = span.type === _mastra_core_observability.SpanType.MODEL_GENERATION ? {
+			model: span.attributes?.model,
+			provider: span.attributes?.provider
+		} : inheritedModelAttrs;
+		dd_trace.default.llmobs.trace(traceOptions, (ddSpan) => {
+			const annotations = this.buildAnnotations(span);
+			if (Object.keys(annotations).length > 0) dd_trace.default.llmobs.annotate(ddSpan, annotations);
+			if (span.errorInfo) this.setErrorTags(ddSpan, span.errorInfo);
+			const exported = dd_trace.default.llmobs.exportSpan ? dd_trace.default.llmobs.exportSpan(ddSpan) : void 0;
+			state.contexts.set(span.id, {
+				ddSpan,
+				exported
+			});
+			for (const child of node.children) this.emitSpanTree(child, state, childInheritedModelAttrs);
+			if (typeof ddSpan.finish === "function") ddSpan.finish(endTimeMs);
+		});
+	}
+	/**
+	* Emit a single span with the proper Datadog parent context.
+	* Used for late-arriving spans after the main tree has been emitted.
+	*/
+	emitSingleSpan(span, state, parent) {
+		const { traceOptions, endTimeMs } = this.buildSpanOptions(span);
+		const runTrace = () => dd_trace.default.llmobs.trace(traceOptions, (ddSpan) => {
+			const annotations = this.buildAnnotations(span);
+			if (Object.keys(annotations).length > 0) dd_trace.default.llmobs.annotate(ddSpan, annotations);
+			if (span.errorInfo) this.setErrorTags(ddSpan, span.errorInfo);
+			const exported = dd_trace.default.llmobs.exportSpan ? dd_trace.default.llmobs.exportSpan(ddSpan) : void 0;
+			state.contexts.set(span.id, {
+				ddSpan,
+				exported
+			});
+			if (typeof ddSpan.finish === "function") ddSpan.finish(endTimeMs);
+		});
+		if (parent) dd_trace.default.scope().activate(parent, runTrace);
+		else runTrace();
+	}
 };
-
+//#endregion
 exports.DatadogBridge = DatadogBridge;
 exports.DatadogExporter = DatadogExporter;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map