@mastra/laminar 1.3.5 → 1.3.6

package/dist/index.cjs

@@ -1,521 +1,453 @@
-'use strict';
-
-var observability$1 = require('@mastra/core/observability');
-var observability = require('@mastra/observability');
-var api = require('@opentelemetry/api');
-var exporterTraceOtlpProto = require('@opentelemetry/exporter-trace-otlp-proto');
-var resources = require('@opentelemetry/resources');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
-
-// src/tracing.ts
-var LMNR_SPAN_INPUT = "lmnr.span.input";
-var LMNR_SPAN_OUTPUT = "lmnr.span.output";
-var LMNR_SPAN_TYPE = "lmnr.span.type";
-var LMNR_SPAN_PATH = "lmnr.span.path";
-var LMNR_SPAN_IDS_PATH = "lmnr.span.ids_path";
-var LMNR_SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source";
-var LMNR_SPAN_SDK_VERSION = "lmnr.span.sdk_version";
-var LMNR_SPAN_LANGUAGE_VERSION = "lmnr.span.language_version";
-var LMNR_ASSOCIATION_PREFIX = "lmnr.association.properties";
-var LMNR_SESSION_ID = `${LMNR_ASSOCIATION_PREFIX}.session_id`;
-var LMNR_USER_ID = `${LMNR_ASSOCIATION_PREFIX}.user_id`;
-var LMNR_TAGS = `${LMNR_ASSOCIATION_PREFIX}.tags`;
-var GEN_AI_SYSTEM = "gen_ai.system";
-var GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
-var GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
-var GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
-var GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
-var GEN_AI_CACHE_WRITE_INPUT_TOKENS = "gen_ai.usage.cache_creation_input_tokens";
-var GEN_AI_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read_input_tokens";
-var LaminarExporter = class extends observability.BaseExporter {
-  name = "laminar";
-  config;
-  traceMap = /* @__PURE__ */ new Map();
-  resource;
-  scope;
-  processor;
-  exporter;
-  isSetup = false;
-  constructor(config = {}) {
-    super(config);
-    const apiKey = config.apiKey ?? process.env.LMNR_PROJECT_API_KEY;
-    if (!apiKey) {
-      this.setDisabled(
-        "Missing required API key. Set LMNR_PROJECT_API_KEY environment variable or pass apiKey in config."
-      );
-      this.config = null;
-      return;
-    }
-    const envEndpoint = process.env.LAMINAR_ENDPOINT;
-    const baseUrl = stripTrailingSlash(config.baseUrl ?? process.env.LMNR_BASE_URL ?? "https://api.lmnr.ai");
-    const endpoint = config.endpoint ?? envEndpoint ?? `${baseUrl}/v1/traces`;
-    const headers = {
-      ...config.headers,
-      Authorization: `Bearer ${apiKey}`
-    };
-    this.config = {
-      apiKey,
-      baseUrl,
-      endpoint,
-      headers,
-      realtime: config.realtime ?? false,
-      disableBatch: config.disableBatch ?? false,
-      batchSize: config.batchSize ?? 512,
-      timeoutMillis: config.timeoutMillis ?? 3e4
-    };
-  }
-  init(options) {
-    const serviceName = options.config?.serviceName || "mastra-service";
-    this.resource = resources.resourceFromAttributes({
-      [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
-      [semanticConventions.ATTR_SERVICE_VERSION]: "unknown",
-      [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: "@mastra/laminar",
-      [semanticConventions.ATTR_TELEMETRY_SDK_VERSION]: "unknown",
-      [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
-    });
-    this.scope = {
-      name: "@mastra/laminar",
-      version: "unknown"
-    };
-  }
-  async _exportTracingEvent(event) {
-    if (event.type === observability$1.TracingEventType.SPAN_STARTED && !event.exportedSpan.isEvent) {
-      this.handleSpanStarted(event.exportedSpan);
-      return;
-    }
-    if (event.type !== observability$1.TracingEventType.SPAN_ENDED) {
-      return;
-    }
-    await this.handleSpanEnded(event.exportedSpan);
-  }
-  handleSpanStarted(span) {
-    const traceState = this.getOrCreateTraceState(span.traceId);
-    const name = span.name;
-    const parentId = span.parentSpanId;
-    const parentPath = parentId ? traceState.spanPathById.get(parentId) : void 0;
-    const parentIdsPath = parentId ? traceState.spanIdsPathById.get(parentId) : void 0;
-    const spanPath = parentPath ? [...parentPath, name] : [name];
-    const spanIdsPath = parentIdsPath ? [...parentIdsPath, otelSpanIdToUUID(span.id)] : [otelSpanIdToUUID(span.id)];
-    traceState.spanPathById.set(span.id, spanPath);
-    traceState.spanIdsPathById.set(span.id, spanIdsPath);
-    traceState.activeSpanIds.add(span.id);
-  }
-  async handleSpanEnded(span) {
-    if (!this.config) {
-      return;
-    }
-    await this.setupIfNeeded();
-    if (!this.processor || !this.exporter) {
-      return;
-    }
-    const traceState = this.getOrCreateTraceState(span.traceId);
-    if (!traceState.spanPathById.has(span.id) || !traceState.spanIdsPathById.has(span.id)) {
-      const name = span.name;
-      const parentId = span.parentSpanId;
-      const parentPath = parentId ? traceState.spanPathById.get(parentId) : void 0;
-      const parentIdsPath = parentId ? traceState.spanIdsPathById.get(parentId) : void 0;
-      const spanPath = parentPath ? [...parentPath, name] : [name];
-      const spanIdsPath = parentIdsPath ? [...parentIdsPath, otelSpanIdToUUID(span.id)] : [otelSpanIdToUUID(span.id)];
-      traceState.spanPathById.set(span.id, spanPath);
-      traceState.spanIdsPathById.set(span.id, spanIdsPath);
-    }
-    try {
-      const otelSpan = this.convertSpanToOtel(span, traceState);
-      this.processor.onEnd(otelSpan);
-      if (this.config.realtime) {
-        await this.processor.forceFlush();
-      }
-    } catch (error) {
-      this.logger.error("[LaminarExporter] Failed to export span", { error, spanId: span.id, traceId: span.traceId });
-    } finally {
-      traceState.activeSpanIds.delete(span.id);
-      if (traceState.activeSpanIds.size === 0) {
-        this.traceMap.delete(span.traceId);
-      }
-    }
-  }
-  getOrCreateTraceState(traceId) {
-    const existing = this.traceMap.get(traceId);
-    if (existing) return existing;
-    const created = {
-      spanPathById: /* @__PURE__ */ new Map(),
-      spanIdsPathById: /* @__PURE__ */ new Map(),
-      activeSpanIds: /* @__PURE__ */ new Set()
-    };
-    this.traceMap.set(traceId, created);
-    return created;
-  }
-  convertSpanToOtel(span, traceState) {
-    if (!this.resource || !this.scope) {
-      this.resource = resources.resourceFromAttributes({
-        [semanticConventions.ATTR_SERVICE_NAME]: "mastra-service",
-        [semanticConventions.ATTR_SERVICE_VERSION]: "unknown",
-        [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: "@mastra/laminar",
-        [semanticConventions.ATTR_TELEMETRY_SDK_VERSION]: "unknown",
-        [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
-      });
-      this.scope = { name: "@mastra/laminar", version: "unknown" };
-    }
-    const name = span.name;
-    const kind = getSpanKind(span.type);
-    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 traceId = normalizeTraceId(span.traceId);
-    const spanId = normalizeSpanId(span.id);
-    const spanContext = {
-      traceId,
-      spanId,
-      traceFlags: api.TraceFlags.SAMPLED,
-      isRemote: false
-    };
-    const parentSpanContext = span.parentSpanId ? {
-      traceId,
-      spanId: normalizeSpanId(span.parentSpanId),
-      traceFlags: api.TraceFlags.SAMPLED,
-      isRemote: false
-    } : void 0;
-    const attributes = buildLaminarAttributes(span, traceState);
-    const links = [];
-    const readable = {
-      name,
-      kind,
-      spanContext: () => spanContext,
-      parentSpanContext,
-      startTime,
-      endTime,
-      status,
-      attributes,
-      links,
-      events,
-      duration,
-      ended: true,
-      resource: this.resource,
-      instrumentationScope: this.scope,
-      droppedAttributesCount: 0,
-      droppedEventsCount: 0,
-      droppedLinksCount: 0
-    };
-    return readable;
-  }
-  async setupIfNeeded() {
-    if (this.isSetup || !this.config) {
-      return;
-    }
-    this.exporter = new exporterTraceOtlpProto.OTLPTraceExporter({
-      url: this.config.endpoint,
-      headers: this.config.headers,
-      timeoutMillis: this.config.timeoutMillis
-    });
-    this.processor = this.config.disableBatch ? new sdkTraceBase.SimpleSpanProcessor(this.exporter) : new sdkTraceBase.BatchSpanProcessor(this.exporter, {
-      maxExportBatchSize: this.config.batchSize,
-      exportTimeoutMillis: this.config.timeoutMillis
-    });
-    this.isSetup = true;
-  }
-  async submitScore(args) {
-    if (!this.config) return;
-    const { traceId, spanId, name, score, reason, metadata } = args;
-    const payload = {
-      name,
-      score,
-      source: "Code",
-      metadata: { ...metadata ?? {}, ...reason ? { reason } : {} }
-    };
-    if (spanId) {
-      payload.spanId = otelSpanIdToUUID(spanId);
-    } else {
-      payload.traceId = otelTraceIdToUUID(traceId);
-    }
-    const headers = {
-      Authorization: `Bearer ${this.config.apiKey}`,
-      "content-type": "application/json"
-    };
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.config.timeoutMillis);
-    try {
-      const response = await fetch(`${stripTrailingSlash(this.config.baseUrl)}/v1/evaluators/score`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(payload),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        this.logger.warn("[LaminarExporter] Failed to attach score to trace/span", {
-          status: response.status,
-          statusText: response.statusText,
-          traceId,
-          spanId,
-          name
-        });
-      }
-    } catch (error) {
-      const isAbort = error instanceof Error && error.name === "AbortError";
-      this.logger.error("[LaminarExporter] Error attaching score to trace/span", {
-        error,
-        timedOut: isAbort,
-        timeoutMillis: this.config.timeoutMillis,
-        traceId,
-        spanId,
-        name
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  async onScoreEvent(event) {
-    const { score } = event;
-    if (!score.traceId) return;
-    await this.submitScore({
-      traceId: score.traceId,
-      spanId: score.spanId,
-      name: score.scorerName ?? score.scorerId,
-      score: score.score,
-      reason: score.reason,
-      metadata: score.metadata
-    });
-  }
-  /**
-   * @deprecated Use the observability score event pipeline (`mastra.observability.addScore`)
-   * instead. Preserved for backwards compatibility; forwards to the same Laminar score endpoint
-   * as `onScoreEvent`.
-   */
-  async _addScoreToTrace(args) {
-    await this.submitScore({
-      traceId: args.traceId,
-      spanId: args.spanId,
-      name: args.scorerName,
-      score: args.score,
-      reason: args.reason,
-      metadata: args.metadata
-    });
-  }
-  /**
-   * 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 || !this.processor) return;
-    try {
-      await this.processor.forceFlush();
-      this.logger.debug("[LaminarExporter] Flushed pending spans");
-    } catch (error) {
-      this.logger.error("[LaminarExporter] Error flushing spans", { error });
-    }
-  }
-  async shutdown() {
-    try {
-      await this.processor?.shutdown();
-    } finally {
-      this.traceMap.clear();
-      await super.shutdown();
-    }
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _mastra_core_observability = require("@mastra/core/observability");
+let _mastra_observability = require("@mastra/observability");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
+let _opentelemetry_resources = require("@opentelemetry/resources");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+//#region src/tracing.ts
+const LMNR_SPAN_INPUT = "lmnr.span.input";
+const LMNR_SPAN_OUTPUT = "lmnr.span.output";
+const LMNR_SPAN_TYPE = "lmnr.span.type";
+const LMNR_SPAN_PATH = "lmnr.span.path";
+const LMNR_SPAN_IDS_PATH = "lmnr.span.ids_path";
+const LMNR_SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source";
+const LMNR_SPAN_SDK_VERSION = "lmnr.span.sdk_version";
+const LMNR_SPAN_LANGUAGE_VERSION = "lmnr.span.language_version";
+const LMNR_ASSOCIATION_PREFIX = "lmnr.association.properties";
+const LMNR_SESSION_ID = `${LMNR_ASSOCIATION_PREFIX}.session_id`;
+const LMNR_USER_ID = `${LMNR_ASSOCIATION_PREFIX}.user_id`;
+const LMNR_TAGS = `${LMNR_ASSOCIATION_PREFIX}.tags`;
+const GEN_AI_SYSTEM = "gen_ai.system";
+const GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+const GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+const GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+const GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+const GEN_AI_CACHE_WRITE_INPUT_TOKENS = "gen_ai.usage.cache_creation_input_tokens";
+const GEN_AI_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read_input_tokens";
+var LaminarExporter = class extends _mastra_observability.BaseExporter {
+	name = "laminar";
+	config;
+	traceMap = /* @__PURE__ */ new Map();
+	resource;
+	scope;
+	processor;
+	exporter;
+	isSetup = false;
+	constructor(config = {}) {
+		super(config);
+		const apiKey = config.apiKey ?? process.env.LMNR_PROJECT_API_KEY;
+		if (!apiKey) {
+			this.setDisabled("Missing required API key. Set LMNR_PROJECT_API_KEY environment variable or pass apiKey in config.");
+			this.config = null;
+			return;
+		}
+		const envEndpoint = process.env.LAMINAR_ENDPOINT;
+		const baseUrl = stripTrailingSlash(config.baseUrl ?? process.env.LMNR_BASE_URL ?? "https://api.lmnr.ai");
+		const endpoint = config.endpoint ?? envEndpoint ?? `${baseUrl}/v1/traces`;
+		const headers = {
+			...config.headers,
+			Authorization: `Bearer ${apiKey}`
+		};
+		this.config = {
+			apiKey,
+			baseUrl,
+			endpoint,
+			headers,
+			realtime: config.realtime ?? false,
+			disableBatch: config.disableBatch ?? false,
+			batchSize: config.batchSize ?? 512,
+			timeoutMillis: config.timeoutMillis ?? 3e4
+		};
+	}
+	init(options) {
+		const serviceName = options.config?.serviceName || "mastra-service";
+		this.resource = (0, _opentelemetry_resources.resourceFromAttributes)({
+			[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+			[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: "unknown",
+			[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: "@mastra/laminar",
+			[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: "unknown",
+			[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
+		});
+		this.scope = {
+			name: "@mastra/laminar",
+			version: "unknown"
+		};
+	}
+	async _exportTracingEvent(event) {
+		if (event.type === _mastra_core_observability.TracingEventType.SPAN_STARTED && !event.exportedSpan.isEvent) {
+			this.handleSpanStarted(event.exportedSpan);
+			return;
+		}
+		if (event.type !== _mastra_core_observability.TracingEventType.SPAN_ENDED) return;
+		await this.handleSpanEnded(event.exportedSpan);
+	}
+	handleSpanStarted(span) {
+		const traceState = this.getOrCreateTraceState(span.traceId);
+		const name = span.name;
+		const parentId = span.parentSpanId;
+		const parentPath = parentId ? traceState.spanPathById.get(parentId) : void 0;
+		const parentIdsPath = parentId ? traceState.spanIdsPathById.get(parentId) : void 0;
+		const spanPath = parentPath ? [...parentPath, name] : [name];
+		const spanIdsPath = parentIdsPath ? [...parentIdsPath, otelSpanIdToUUID(span.id)] : [otelSpanIdToUUID(span.id)];
+		traceState.spanPathById.set(span.id, spanPath);
+		traceState.spanIdsPathById.set(span.id, spanIdsPath);
+		traceState.activeSpanIds.add(span.id);
+	}
+	async handleSpanEnded(span) {
+		if (!this.config) return;
+		await this.setupIfNeeded();
+		if (!this.processor || !this.exporter) return;
+		const traceState = this.getOrCreateTraceState(span.traceId);
+		if (!traceState.spanPathById.has(span.id) || !traceState.spanIdsPathById.has(span.id)) {
+			const name = span.name;
+			const parentId = span.parentSpanId;
+			const parentPath = parentId ? traceState.spanPathById.get(parentId) : void 0;
+			const parentIdsPath = parentId ? traceState.spanIdsPathById.get(parentId) : void 0;
+			const spanPath = parentPath ? [...parentPath, name] : [name];
+			const spanIdsPath = parentIdsPath ? [...parentIdsPath, otelSpanIdToUUID(span.id)] : [otelSpanIdToUUID(span.id)];
+			traceState.spanPathById.set(span.id, spanPath);
+			traceState.spanIdsPathById.set(span.id, spanIdsPath);
+		}
+		try {
+			const otelSpan = this.convertSpanToOtel(span, traceState);
+			this.processor.onEnd(otelSpan);
+			if (this.config.realtime) await this.processor.forceFlush();
+		} catch (error) {
+			this.logger.error("[LaminarExporter] Failed to export span", {
+				error,
+				spanId: span.id,
+				traceId: span.traceId
+			});
+		} finally {
+			traceState.activeSpanIds.delete(span.id);
+			if (traceState.activeSpanIds.size === 0) this.traceMap.delete(span.traceId);
+		}
+	}
+	getOrCreateTraceState(traceId) {
+		const existing = this.traceMap.get(traceId);
+		if (existing) return existing;
+		const created = {
+			spanPathById: /* @__PURE__ */ new Map(),
+			spanIdsPathById: /* @__PURE__ */ new Map(),
+			activeSpanIds: /* @__PURE__ */ new Set()
+		};
+		this.traceMap.set(traceId, created);
+		return created;
+	}
+	convertSpanToOtel(span, traceState) {
+		if (!this.resource || !this.scope) {
+			this.resource = (0, _opentelemetry_resources.resourceFromAttributes)({
+				[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: "mastra-service",
+				[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: "unknown",
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_NAME]: "@mastra/laminar",
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_VERSION]: "unknown",
+				[_opentelemetry_semantic_conventions.ATTR_TELEMETRY_SDK_LANGUAGE]: "nodejs"
+			});
+			this.scope = {
+				name: "@mastra/laminar",
+				version: "unknown"
+			};
+		}
+		const name = span.name;
+		const kind = getSpanKind(span.type);
+		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 traceId = normalizeTraceId(span.traceId);
+		const spanContext = {
+			traceId,
+			spanId: normalizeSpanId(span.id),
+			traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+			isRemote: false
+		};
+		return {
+			name,
+			kind,
+			spanContext: () => spanContext,
+			parentSpanContext: span.parentSpanId ? {
+				traceId,
+				spanId: normalizeSpanId(span.parentSpanId),
+				traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+				isRemote: false
+			} : void 0,
+			startTime,
+			endTime,
+			status,
+			attributes: buildLaminarAttributes(span, traceState),
+			links: [],
+			events,
+			duration,
+			ended: true,
+			resource: this.resource,
+			instrumentationScope: this.scope,
+			droppedAttributesCount: 0,
+			droppedEventsCount: 0,
+			droppedLinksCount: 0
+		};
+	}
+	async setupIfNeeded() {
+		if (this.isSetup || !this.config) return;
+		this.exporter = new _opentelemetry_exporter_trace_otlp_proto.OTLPTraceExporter({
+			url: this.config.endpoint,
+			headers: this.config.headers,
+			timeoutMillis: this.config.timeoutMillis
+		});
+		this.processor = this.config.disableBatch ? new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(this.exporter) : new _opentelemetry_sdk_trace_base.BatchSpanProcessor(this.exporter, {
+			maxExportBatchSize: this.config.batchSize,
+			exportTimeoutMillis: this.config.timeoutMillis
+		});
+		this.isSetup = true;
+	}
+	async submitScore(args) {
+		if (!this.config) return;
+		const { traceId, spanId, name, score, reason, metadata } = args;
+		const payload = {
+			name,
+			score,
+			source: "Code",
+			metadata: {
+				...metadata ?? {},
+				...reason ? { reason } : {}
+			}
+		};
+		if (spanId) payload.spanId = otelSpanIdToUUID(spanId);
+		else payload.traceId = otelTraceIdToUUID(traceId);
+		const headers = {
+			Authorization: `Bearer ${this.config.apiKey}`,
+			"content-type": "application/json"
+		};
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.config.timeoutMillis);
+		try {
+			const response = await fetch(`${stripTrailingSlash(this.config.baseUrl)}/v1/evaluators/score`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(payload),
+				signal: controller.signal
+			});
+			if (!response.ok) this.logger.warn("[LaminarExporter] Failed to attach score to trace/span", {
+				status: response.status,
+				statusText: response.statusText,
+				traceId,
+				spanId,
+				name
+			});
+		} catch (error) {
+			const isAbort = error instanceof Error && error.name === "AbortError";
+			this.logger.error("[LaminarExporter] Error attaching score to trace/span", {
+				error,
+				timedOut: isAbort,
+				timeoutMillis: this.config.timeoutMillis,
+				traceId,
+				spanId,
+				name
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async onScoreEvent(event) {
+		const { score } = event;
+		if (!score.traceId) return;
+		await this.submitScore({
+			traceId: score.traceId,
+			spanId: score.spanId,
+			name: score.scorerName ?? score.scorerId,
+			score: score.score,
+			reason: score.reason,
+			metadata: score.metadata
+		});
+	}
+	/**
+	* @deprecated Use the observability score event pipeline (`mastra.observability.addScore`)
+	* instead. Preserved for backwards compatibility; forwards to the same Laminar score endpoint
+	* as `onScoreEvent`.
+	*/
+	async _addScoreToTrace(args) {
+		await this.submitScore({
+			traceId: args.traceId,
+			spanId: args.spanId,
+			name: args.scorerName,
+			score: args.score,
+			reason: args.reason,
+			metadata: args.metadata
+		});
+	}
+	/**
+	* 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 || !this.processor) return;
+		try {
+			await this.processor.forceFlush();
+			this.logger.debug("[LaminarExporter] Flushed pending spans");
+		} catch (error) {
+			this.logger.error("[LaminarExporter] Error flushing spans", { error });
+		}
+	}
+	async shutdown() {
+		try {
+			await this.processor?.shutdown();
+		} finally {
+			this.traceMap.clear();
+			await super.shutdown();
+		}
+	}
 };
 function buildLaminarAttributes(span, traceState) {
-  const attributes = {};
-  const spanPath = traceState.spanPathById.get(span.id);
-  const spanIdsPath = traceState.spanIdsPathById.get(span.id);
-  if (spanPath) {
-    attributes[LMNR_SPAN_PATH] = spanPath;
-  }
-  if (spanIdsPath) {
-    attributes[LMNR_SPAN_IDS_PATH] = spanIdsPath;
-  }
-  attributes[LMNR_SPAN_TYPE] = mapLaminarSpanType(span.type);
-  attributes[LMNR_SPAN_INSTRUMENTATION_SOURCE] = "javascript";
-  attributes[LMNR_SPAN_SDK_VERSION] = "unknown";
-  attributes[LMNR_SPAN_LANGUAGE_VERSION] = process.version;
-  const sessionId = span.metadata?.sessionId;
-  if (typeof sessionId === "string" && sessionId.length > 0) {
-    attributes[LMNR_SESSION_ID] = sessionId;
-  }
-  const userId = span.metadata?.userId;
-  if (typeof userId === "string" && userId.length > 0) {
-    attributes[LMNR_USER_ID] = userId;
-  }
-  if (span.metadata) {
-    for (const [key, value] of Object.entries(span.metadata)) {
-      if (key === "sessionId" || key === "userId" || value === void 0 || value === null) {
-        continue;
-      }
-      const attributeValue = toLaminarAttributeValue(value);
-      if (attributeValue === void 0) {
-        continue;
-      }
-      attributes[`${LMNR_ASSOCIATION_PREFIX}.metadata.${key}`] = attributeValue;
-    }
-  }
-  if (span.isRootSpan && span.tags?.length) {
-    attributes[LMNR_TAGS] = span.tags;
-  }
-  if (span.input !== void 0) {
-    attributes[LMNR_SPAN_INPUT] = serializeForLaminar(getLaminarSpanInput(span));
-  }
-  if (span.output !== void 0) {
-    attributes[LMNR_SPAN_OUTPUT] = serializeForLaminar(span.output);
-  }
-  if (span.type === observability$1.SpanType.MODEL_GENERATION) {
-    const modelAttrs = span.attributes ?? {};
-    if (modelAttrs.provider) {
-      attributes[GEN_AI_SYSTEM] = normalizeProvider(modelAttrs.provider);
-    }
-    if (modelAttrs.model) {
-      attributes[GEN_AI_REQUEST_MODEL] = modelAttrs.model;
-    }
-    if (modelAttrs.responseModel) {
-      attributes[GEN_AI_RESPONSE_MODEL] = modelAttrs.responseModel;
-    }
-    Object.assign(attributes, formatLaminarUsage(modelAttrs.usage));
-  }
-  return attributes;
+	const attributes = {};
+	const spanPath = traceState.spanPathById.get(span.id);
+	const spanIdsPath = traceState.spanIdsPathById.get(span.id);
+	if (spanPath) attributes[LMNR_SPAN_PATH] = spanPath;
+	if (spanIdsPath) attributes[LMNR_SPAN_IDS_PATH] = spanIdsPath;
+	attributes[LMNR_SPAN_TYPE] = mapLaminarSpanType(span.type);
+	attributes[LMNR_SPAN_INSTRUMENTATION_SOURCE] = "javascript";
+	attributes[LMNR_SPAN_SDK_VERSION] = "unknown";
+	attributes[LMNR_SPAN_LANGUAGE_VERSION] = process.version;
+	const sessionId = span.metadata?.sessionId;
+	if (typeof sessionId === "string" && sessionId.length > 0) attributes[LMNR_SESSION_ID] = sessionId;
+	const userId = span.metadata?.userId;
+	if (typeof userId === "string" && userId.length > 0) attributes[LMNR_USER_ID] = userId;
+	if (span.metadata) for (const [key, value] of Object.entries(span.metadata)) {
+		if (key === "sessionId" || key === "userId" || value === void 0 || value === null) continue;
+		const attributeValue = toLaminarAttributeValue(value);
+		if (attributeValue === void 0) continue;
+		attributes[`${LMNR_ASSOCIATION_PREFIX}.metadata.${key}`] = attributeValue;
+	}
+	if (span.isRootSpan && span.tags?.length) attributes[LMNR_TAGS] = span.tags;
+	if (span.input !== void 0) attributes[LMNR_SPAN_INPUT] = serializeForLaminar(getLaminarSpanInput(span));
+	if (span.output !== void 0) attributes[LMNR_SPAN_OUTPUT] = serializeForLaminar(span.output);
+	if (span.type === _mastra_core_observability.SpanType.MODEL_GENERATION) {
+		const modelAttrs = span.attributes ?? {};
+		if (modelAttrs.provider) attributes[GEN_AI_SYSTEM] = normalizeProvider(modelAttrs.provider);
+		if (modelAttrs.model) attributes[GEN_AI_REQUEST_MODEL] = modelAttrs.model;
+		if (modelAttrs.responseModel) attributes[GEN_AI_RESPONSE_MODEL] = modelAttrs.responseModel;
+		Object.assign(attributes, formatLaminarUsage(modelAttrs.usage));
+	}
+	return attributes;
 }
 function mapLaminarSpanType(spanType) {
-  switch (spanType) {
-    case observability$1.SpanType.MODEL_GENERATION:
-    case observability$1.SpanType.MODEL_STEP:
-    case observability$1.SpanType.MODEL_CHUNK:
-      return "LLM";
-    case observability$1.SpanType.TOOL_CALL:
-    case observability$1.SpanType.MCP_TOOL_CALL:
-    case observability$1.SpanType.PROVIDER_TOOL_CALL:
-      return "TOOL";
-    default:
-      return "DEFAULT";
-  }
+	switch (spanType) {
+		case _mastra_core_observability.SpanType.MODEL_GENERATION:
+		case _mastra_core_observability.SpanType.MODEL_STEP:
+		case _mastra_core_observability.SpanType.MODEL_CHUNK: return "LLM";
+		case _mastra_core_observability.SpanType.TOOL_CALL:
+		case _mastra_core_observability.SpanType.MCP_TOOL_CALL:
+		case _mastra_core_observability.SpanType.PROVIDER_TOOL_CALL: return "TOOL";
+		default: return "DEFAULT";
+	}
 }
 function formatLaminarUsage(usage) {
-  if (!usage) return {};
-  const out = {};
-  if (usage.inputTokens !== void 0) {
-    out[GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
-  }
-  if (usage.outputTokens !== void 0) {
-    out[GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
-  }
-  if (usage.inputDetails?.cacheWrite !== void 0) {
-    out[GEN_AI_CACHE_WRITE_INPUT_TOKENS] = usage.inputDetails.cacheWrite;
-  }
-  if (usage.inputDetails?.cacheRead !== void 0) {
-    out[GEN_AI_CACHE_READ_INPUT_TOKENS] = usage.inputDetails.cacheRead;
-  }
-  return out;
+	if (!usage) return {};
+	const out = {};
+	if (usage.inputTokens !== void 0) out[GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
+	if (usage.outputTokens !== void 0) out[GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
+	if (usage.inputDetails?.cacheWrite !== void 0) out[GEN_AI_CACHE_WRITE_INPUT_TOKENS] = usage.inputDetails.cacheWrite;
+	if (usage.inputDetails?.cacheRead !== void 0) out[GEN_AI_CACHE_READ_INPUT_TOKENS] = usage.inputDetails.cacheRead;
+	return out;
 }
 function serializeForLaminar(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "[unserializable]";
-  }
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
 }
 function getLaminarSpanInput(span) {
-  if (span.type !== observability$1.SpanType.MODEL_GENERATION) {
-    return span.input;
-  }
-  const input = span.input;
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    return input;
-  }
-  const maybeMessages = input.messages;
-  return Array.isArray(maybeMessages) ? maybeMessages : input;
+	if (span.type !== _mastra_core_observability.SpanType.MODEL_GENERATION) return span.input;
+	const input = span.input;
+	if (!input || typeof input !== "object" || Array.isArray(input)) return input;
+	const maybeMessages = input.messages;
+	return Array.isArray(maybeMessages) ? maybeMessages : input;
 }
 function toLaminarAttributeValue(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const isHomogeneous = value.every((v) => typeof v === "string") || value.every((v) => typeof v === "number") || value.every((v) => typeof v === "boolean");
-    if (isHomogeneous) return value;
-  }
-  return serializeForLaminar(value);
+	if (value === void 0 || value === null) return;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		if (value.every((v) => typeof v === "string") || value.every((v) => typeof v === "number") || value.every((v) => typeof v === "boolean")) return value;
+	}
+	return serializeForLaminar(value);
 }
+/**
+* Convert JavaScript Date to hrtime format
+*/
 function dateToHrTime(date) {
-  const ms = date.getTime();
-  const seconds = Math.floor(ms / 1e3);
-  const nanoseconds = ms % 1e3 * 1e6;
-  return [seconds, nanoseconds];
+	const ms = date.getTime();
+	return [Math.floor(ms / 1e3), ms % 1e3 * 1e6];
 }
 function computeDuration(start, end) {
-  if (!end) return [0, 0];
-  const diffMs = end.getTime() - start.getTime();
-  return [Math.floor(diffMs / 1e3), diffMs % 1e3 * 1e6];
+	if (!end) return [0, 0];
+	const diffMs = end.getTime() - start.getTime();
+	return [Math.floor(diffMs / 1e3), diffMs % 1e3 * 1e6];
 }
 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 };
-  }
-  return {
-    status: { code: api.SpanStatusCode.OK },
-    events
-  };
+	const events = [];
+	if (span.errorInfo) {
+		const status = {
+			code: _opentelemetry_api.SpanStatusCode.ERROR,
+			message: span.errorInfo.message
+		};
+		events.push({
+			name: "exception",
+			attributes: {
+				"exception.message": span.errorInfo.message,
+				"exception.type": "Error",
+				...span.errorInfo.details?.stack && { "exception.stacktrace": span.errorInfo.details.stack }
+			},
+			time: defaultTime,
+			droppedAttributesCount: 0
+		});
+		return {
+			status,
+			events
+		};
+	}
+	return {
+		status: { code: _opentelemetry_api.SpanStatusCode.OK },
+		events
+	};
 }
 function getSpanKind(type) {
-  switch (type) {
-    case observability$1.SpanType.MODEL_GENERATION:
-    case observability$1.SpanType.MCP_TOOL_CALL:
-      return api.SpanKind.CLIENT;
-    default:
-      return api.SpanKind.INTERNAL;
-  }
+	switch (type) {
+		case _mastra_core_observability.SpanType.MODEL_GENERATION:
+		case _mastra_core_observability.SpanType.MCP_TOOL_CALL: return _opentelemetry_api.SpanKind.CLIENT;
+		default: return _opentelemetry_api.SpanKind.INTERNAL;
+	}
 }
 function stripTrailingSlash(url) {
-  let end = url.length;
-  while (end > 0 && url.charCodeAt(end - 1) === 47) {
-    end--;
-  }
-  return end === url.length ? url : url.slice(0, end);
+	let end = url.length;
+	while (end > 0 && url.charCodeAt(end - 1) === 47) end--;
+	return end === url.length ? url : url.slice(0, end);
 }
 function normalizeTraceId(traceId) {
-  let id = traceId.toLowerCase();
-  if (id.startsWith("0x")) id = id.slice(2);
-  return id.padStart(32, "0").slice(-32);
+	let id = traceId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	return id.padStart(32, "0").slice(-32);
 }
 function normalizeSpanId(spanId) {
-  let id = spanId.toLowerCase();
-  if (id.startsWith("0x")) id = id.slice(2);
-  return id.padStart(16, "0").slice(-16);
+	let id = spanId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	return id.padStart(16, "0").slice(-16);
 }
 function otelSpanIdToUUID(spanId) {
-  const normalized = normalizeSpanId(spanId);
-  return normalized.padStart(32, "0").replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+	return normalizeSpanId(spanId).padStart(32, "0").replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
 }
 function otelTraceIdToUUID(traceId) {
-  const normalized = normalizeTraceId(traceId);
-  return normalized.replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+	return normalizeTraceId(traceId).replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
 }
 function normalizeProvider(provider) {
-  return provider.split(".").shift()?.toLowerCase().trim() || provider.toLowerCase().trim();
+	return provider.split(".").shift()?.toLowerCase().trim() || provider.toLowerCase().trim();
 }
-
+//#endregion
 exports.LaminarExporter = LaminarExporter;
 exports.otelSpanIdToUUID = otelSpanIdToUUID;
 exports.otelTraceIdToUUID = otelTraceIdToUUID;
 exports.stripTrailingSlash = stripTrailingSlash;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map