@lmnr-ai/lmnr 0.8.20 → 0.8.21

package/dist/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_dist = require("./dist-zDtQ_gVq.cjs");
-const require_utils = require("./utils-BmWNkeX5.cjs");
-const require_decorators = require("./decorators-u7xFb_9W.cjs");
+const require_dist = require("./dist-B5cKzRzq.cjs");
+const require_utils = require("./utils-C8Tl1vKD.cjs");
+const require_decorators = require("./decorators-CaTC0lJq.cjs");
 let _opentelemetry_api = require("@opentelemetry/api");
 let cli_progress = require("cli-progress");
 cli_progress = require_chunk.__toESM(cli_progress);
@@ -59,7 +59,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-2hY2DP65.cjs"));
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-IBEBwZxq.cjs"));
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -78,7 +78,7 @@ var LaminarDataset = class extends EvaluationDataset {
 require_utils.loadEnv();
 const DEFAULT_CONCURRENCY = 5;
 const MAX_EXPORT_BATCH_SIZE = 64;
-const logger = require_utils.initializeLogger();
+const logger$1 = require_utils.initializeLogger();
 const getEvaluationUrl = (projectId, evaluationId, baseUrl, frontendPort) => {
 	return `${require_utils.getFrontendUrl(baseUrl, frontendPort)}/project/${projectId}/evaluations/${evaluationId}`;
 };
@@ -151,7 +151,7 @@ var Evaluation = class {
 		this.name = name;
 		if (config) {
 			if (config.concurrencyLimit !== void 0 && config.concurrencyLimit < 1) {
-				logger.warn(`concurrencyLimit must be greater than 0. Setting to default of ${DEFAULT_CONCURRENCY}`);
+				logger$1.warn(`concurrencyLimit must be greater than 0. Setting to default of ${DEFAULT_CONCURRENCY}`);
 				this.concurrencyLimit = DEFAULT_CONCURRENCY;
 			} else this.concurrencyLimit = config.concurrencyLimit ?? DEFAULT_CONCURRENCY;
 			this.traceDisableBatch = config.traceDisableBatch ?? false;
@@ -163,7 +163,7 @@ var Evaluation = class {
 				baseUrl: require_decorators.Laminar.getHttpUrl(),
 				projectApiKey: require_decorators.Laminar.getProjectApiKey()
 			});
-			if (config?.projectApiKey && config.projectApiKey !== require_decorators.Laminar.getProjectApiKey()) logger.warn("Laminar was already initialized with a different project API key. Ignoring the project API key from the evaluation config.");
+			if (config?.projectApiKey && config.projectApiKey !== require_decorators.Laminar.getProjectApiKey()) logger$1.warn("Laminar was already initialized with a different project API key. Ignoring the project API key from the evaluation config.");
 			return;
 		}
 		const key = config?.projectApiKey ?? process.env.LMNR_PROJECT_API_KEY;
@@ -195,9 +195,9 @@ var Evaluation = class {
 			if (!this.data.id) try {
 				const datasets = await this.client.datasets.getDatasetByName(this.data.name);
 				if (datasets.length > 0) this.data.id = datasets[0].id;
-				else logger.warn(`Dataset ${this.data.name} not found`);
+				else logger$1.warn(`Dataset ${this.data.name} not found`);
 			} catch (error) {
-				logger.warn(`Error getting dataset ${this.data.name}: ${error instanceof Error ? error.message : String(error)}`);
+				logger$1.warn(`Error getting dataset ${this.data.name}: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		}
 		let resultDatapoints;
@@ -865,6 +865,559 @@ function wrapLanguageModel(languageModel) {
 	return new LaminarLanguageModelV2(languageModel);
 }
 //#endregion
+//#region src/opentelemetry-lib/instrumentation/mastra/types.ts
+const MastraSpanType = {
+	MODEL_GENERATION: "model_generation",
+	MODEL_STEP: "model_step",
+	MODEL_CHUNK: "model_chunk",
+	TOOL_CALL: "tool_call",
+	MCP_TOOL_CALL: "mcp_tool_call"
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/mastra/utils.ts
+const dateToHrTime = (date) => {
+	const ms = date.getTime();
+	return [Math.floor(ms / 1e3), ms % 1e3 * 1e6];
+};
+const normalizeProvider = (provider) => provider.split(".").shift()?.toLowerCase().trim() || provider.toLowerCase().trim();
+const mapLaminarSpanType = (spanType) => {
+	switch (spanType) {
+		case MastraSpanType.MODEL_STEP: return "LLM";
+		case MastraSpanType.TOOL_CALL:
+		case MastraSpanType.MCP_TOOL_CALL: return "TOOL";
+		default: return "DEFAULT";
+	}
+};
+const serializeJSON = (value) => {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
+};
+const toAttributeValue = (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)) {
+		if (value.every((v) => typeof v === "string")) return value;
+		if (value.every((v) => typeof v === "number")) return value;
+		if (value.every((v) => typeof v === "boolean")) return value;
+	}
+	return serializeJSON(value);
+};
+const extractMessages = (input) => {
+	if (!input) return void 0;
+	if (Array.isArray(input)) return input;
+	if (typeof input === "object") {
+		const asObj = input;
+		if (Array.isArray(asObj.messages)) return asObj.messages;
+		if (Array.isArray(asObj.prompt)) return asObj.prompt;
+		if (Array.isArray(asObj.input)) return asObj.input;
+	}
+};
+const normalizeInputMessages = (raw) => {
+	const out = [];
+	for (const m of raw) {
+		if (m == null) continue;
+		if (typeof m === "object") {
+			out.push(m);
+			continue;
+		}
+		out.push({
+			role: "user",
+			content: typeof m === "string" ? m : serializeJSON(m)
+		});
+	}
+	return out;
+};
+const buildAssistantMessageFromStepOutput = (output) => {
+	if (!output || typeof output !== "object") return null;
+	const outObj = output;
+	const parts = [];
+	if (typeof outObj.text === "string" && outObj.text.length > 0) parts.push({
+		type: "text",
+		text: outObj.text
+	});
+	if (Array.isArray(outObj.toolCalls)) for (const tc of outObj.toolCalls) {
+		if (!tc) continue;
+		parts.push({
+			type: "tool-call",
+			toolCallId: tc.toolCallId,
+			toolName: tc.toolName,
+			input: tc.input ?? tc.args
+		});
+	}
+	if (parts.length === 0) return null;
+	return {
+		role: "assistant",
+		content: parts
+	};
+};
+const extractToolCallId = (span) => {
+	const v = span.attributes?.toolCallId;
+	return typeof v === "string" ? v : void 0;
+};
+const cleanMastraToolName = (name) => name?.replace(/^(?:mcp_tool|tool):\s*'?(.*?)'?(?:\s+on\s+'[^']*')?$/, "$1");
+const stringifyArgs = (raw) => {
+	if (raw === void 0) return void 0;
+	if (typeof raw === "string") return raw;
+	try {
+		return JSON.stringify(raw);
+	} catch {
+		return "[unserializable]";
+	}
+};
+const formatUsage = (usage) => {
+	if (!usage) return {};
+	const out = {};
+	if (typeof usage.inputTokens === "number") out[require_utils.LaminarAttributes.INPUT_TOKEN_COUNT] = usage.inputTokens;
+	if (typeof usage.outputTokens === "number") out[require_utils.LaminarAttributes.OUTPUT_TOKEN_COUNT] = usage.outputTokens;
+	const total = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+	if (total > 0) out[require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT] = total;
+	if (typeof usage.inputDetails?.cacheWrite === "number") out["gen_ai.usage.cache_creation_input_tokens"] = usage.inputDetails.cacheWrite;
+	if (typeof usage.inputDetails?.cacheRead === "number") out["gen_ai.usage.cache_read_input_tokens"] = usage.inputDetails.cacheRead;
+	if (typeof usage.outputDetails?.reasoning === "number") out["gen_ai.usage.reasoning_tokens"] = usage.outputDetails.reasoning;
+	return out;
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/mastra/exporter.ts
+const logger = require_utils.initializeLogger();
+/**
+* Bridges Mastra's ObservabilityExporter contract to Laminar's OTLP ingestion.
+*
+* Span-type mapping:
+* - `model_step` → LLM (atomic LLM call; rendered with message history).
+* - `tool_call`, `mcp_tool_call` → TOOL.
+* - `model_chunk` → dropped (per-delta, noise).
+* - everything else → DEFAULT.
+*
+* Tool-call reconstruction: Mastra's `extractStepInput` collapses prior tool
+* calls/results into empty user messages on MODEL_STEP inputs, so we
+* reconstruct the full conversation by accumulating (baseMessages → step0's
+* assistant message → tool-result message(s) → step1's assistant message →
+* …) using the parent MODEL_GENERATION's input and the children TOOL_CALL
+* spans paired by arrival order with each step's declared toolCalls.
+*
+* For LLM spans we emit `ai.prompt.messages` (stringified AI SDK messages
+* with tool-call / tool-result content parts) and `ai.response.text` +
+* `ai.response.toolCalls` so Laminar's backend parser threads them into
+* the LLM message history view.
+*/
+var MastraExporter = class {
+	constructor(options = {}) {
+		this.name = "laminar";
+		this.traceMap = /* @__PURE__ */ new Map();
+		this.generationStateById = /* @__PURE__ */ new Map();
+		this.generationAttrsById = /* @__PURE__ */ new Map();
+		this.generationIdByStepId = /* @__PURE__ */ new Map();
+		this.stepIndexBySpanId = /* @__PURE__ */ new Map();
+		this.liveOtelSpanByMastraId = /* @__PURE__ */ new Map();
+		this.warnedNotInitialized = false;
+		this.config = {
+			realtime: options.realtime ?? false,
+			linkToActiveContext: options.linkToActiveContext ?? true
+		};
+	}
+	init(_options) {}
+	async exportTracingEvent(event) {
+		const span = event.exportedSpan;
+		if (span.isEvent) return;
+		if (span.type === MastraSpanType.MODEL_GENERATION && span.attributes) {
+			const existing = this.generationAttrsById.get(span.id);
+			this.generationAttrsById.set(span.id, existing ? {
+				...existing,
+				...span.attributes
+			} : { ...span.attributes });
+		}
+		if (event.type === "span_started") {
+			this.handleSpanStarted(span);
+			return;
+		}
+		if (event.type !== "span_ended") return;
+		await this.handleSpanEnded(span);
+	}
+	async onTracingEvent(event) {
+		await this.exportTracingEvent(event);
+	}
+	async flush() {
+		const processor = require_decorators.getSpanProcessor();
+		if (!processor) return;
+		try {
+			await processor.forceFlush();
+		} catch (err) {
+			logger.error(`[MastraExporter] forceFlush failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	shutdown() {
+		this.traceMap.clear();
+		this.generationStateById.clear();
+		this.generationAttrsById.clear();
+		this.generationIdByStepId.clear();
+		this.stepIndexBySpanId.clear();
+		this.liveOtelSpanByMastraId.clear();
+		return Promise.resolve();
+	}
+	handleSpanStarted(span) {
+		if (span.type === MastraSpanType.MODEL_CHUNK) return;
+		const traceState = this.getOrCreateTraceState(span.traceId);
+		const parentId = span.parentSpanId;
+		this.recordSpanPath(span, traceState);
+		traceState.activeSpanIds.add(span.id);
+		if (span.type === MastraSpanType.MODEL_GENERATION) this.initGenerationState(span);
+		else if (span.type === MastraSpanType.MODEL_STEP && parentId) {
+			this.generationIdByStepId.set(span.id, parentId);
+			const stepIndex = typeof span.attributes?.stepIndex === "number" ? span.attributes.stepIndex : 0;
+			this.stepIndexBySpanId.set(span.id, stepIndex);
+		}
+		this.startOtelSpan(span, traceState);
+	}
+	recordSpanPath(span, traceState) {
+		const parentId = span.parentSpanId;
+		const parentPath = parentId ? traceState.spanPathById.get(parentId) : traceState.otelParentSpanPath;
+		const parentIdsPath = parentId ? traceState.spanIdsPathById.get(parentId) : traceState.otelParentSpanIdsPath;
+		const spanUuid = require_utils.otelSpanIdToUUID(require_utils.normalizeOtelSpanId(span.id));
+		const spanPath = parentPath ? [...parentPath, span.name] : [span.name];
+		const spanIdsPath = parentIdsPath ? [...parentIdsPath, spanUuid] : [spanUuid];
+		traceState.spanPathById.set(span.id, spanPath);
+		traceState.spanIdsPathById.set(span.id, spanIdsPath);
+	}
+	async handleSpanEnded(span) {
+		if (span.type === MastraSpanType.MODEL_CHUNK) {
+			this.captureReasoningChunk(span);
+			return;
+		}
+		const traceState = this.getOrCreateTraceState(span.traceId);
+		try {
+			if (!traceState.spanPathById.has(span.id)) {
+				this.recordSpanPath(span, traceState);
+				traceState.activeSpanIds.add(span.id);
+			}
+			if (span.type === MastraSpanType.MODEL_GENERATION && !this.generationStateById.has(span.id)) this.initGenerationState(span);
+			if (span.type === MastraSpanType.MODEL_STEP && !this.generationIdByStepId.has(span.id) && span.parentSpanId) this.generationIdByStepId.set(span.id, span.parentSpanId);
+			if (!this.liveOtelSpanByMastraId.has(span.id)) this.startOtelSpan(span, traceState);
+			this.updateGenerationStateOnSpanEnd(span);
+			const otelSpan = this.liveOtelSpanByMastraId.get(span.id);
+			if (!otelSpan) return;
+			this.applyEndAttributes(span, otelSpan, traceState);
+			if (span.errorInfo) {
+				otelSpan.setStatus({
+					code: _opentelemetry_api.SpanStatusCode.ERROR,
+					message: span.errorInfo.message
+				});
+				otelSpan.recordException({
+					name: span.errorInfo.name ?? "Error",
+					message: span.errorInfo.message,
+					stack: span.errorInfo.stack
+				});
+			}
+			const endTime = span.endTime ? dateToHrTime(span.endTime) : dateToHrTime(span.startTime);
+			otelSpan.end(endTime);
+			if (this.config.realtime) await require_decorators.getSpanProcessor()?.forceFlush();
+		} catch (err) {
+			logger.error(`[MastraExporter] failed to export span ${span.id}: ${err instanceof Error ? err.message : String(err)}`);
+		} finally {
+			traceState.activeSpanIds.delete(span.id);
+			if (traceState.activeSpanIds.size === 0) this.traceMap.delete(span.traceId);
+			if (span.type === MastraSpanType.MODEL_GENERATION) {
+				this.generationStateById.delete(span.id);
+				this.generationAttrsById.delete(span.id);
+			}
+			if (span.type === MastraSpanType.MODEL_STEP) {
+				this.generationIdByStepId.delete(span.id);
+				this.stepIndexBySpanId.delete(span.id);
+			}
+			this.liveOtelSpanByMastraId.delete(span.id);
+		}
+	}
+	initGenerationState(span) {
+		const rawMessages = extractMessages(span.input);
+		const baseMessages = rawMessages ? normalizeInputMessages(rawMessages) : [];
+		this.generationStateById.set(span.id, {
+			baseMessages,
+			turnsByStepIndex: /* @__PURE__ */ new Map(),
+			toolCallChildrenByStepIndex: /* @__PURE__ */ new Map(),
+			reasoningTextByStepIndex: /* @__PURE__ */ new Map()
+		});
+	}
+	captureReasoningChunk(span) {
+		if ((span.attributes ?? {}).chunkType !== "reasoning") return;
+		const output = span.output;
+		if (!output || typeof output !== "object") return;
+		const text = output.text;
+		if (typeof text !== "string" || text.length === 0) return;
+		const stepSpanId = span.parentSpanId;
+		if (!stepSpanId) return;
+		const generationId = this.generationIdByStepId.get(stepSpanId);
+		if (!generationId) return;
+		const gen = this.generationStateById.get(generationId);
+		if (!gen) return;
+		const stepIndex = this.stepIndexBySpanId.get(stepSpanId);
+		if (stepIndex === void 0) return;
+		const existing = gen.reasoningTextByStepIndex.get(stepIndex);
+		gen.reasoningTextByStepIndex.set(stepIndex, existing ? existing + text : text);
+	}
+	updateGenerationStateOnSpanEnd(span) {
+		if (span.type === MastraSpanType.MODEL_STEP) {
+			const generationId = this.generationIdByStepId.get(span.id);
+			if (!generationId) return;
+			const gen = this.generationStateById.get(generationId);
+			if (!gen) return;
+			const stepIndex = this.stepIndexBySpanId.get(span.id) ?? (typeof span.attributes?.stepIndex === "number" ? span.attributes.stepIndex : 0);
+			this.stepIndexBySpanId.set(span.id, stepIndex);
+			const output = span.output;
+			const declaredToolCalls = Array.isArray(output?.toolCalls) ? output.toolCalls : [];
+			const children = gen.toolCallChildrenByStepIndex.get(stepIndex) ?? [];
+			const childrenById = /* @__PURE__ */ new Map();
+			for (const c of children) if (c.toolCallId) childrenById.set(c.toolCallId, c);
+			const consumed = /* @__PURE__ */ new Set();
+			const turnMessages = [];
+			const assistantMsg = buildAssistantMessageFromStepOutput(output);
+			if (assistantMsg) turnMessages.push(assistantMsg);
+			for (const dec of declaredToolCalls) {
+				const toolCallId = dec?.toolCallId ?? dec?.id;
+				let child = toolCallId ? childrenById.get(toolCallId) : void 0;
+				if (child && consumed.has(child)) child = void 0;
+				if (!child) child = children.find((c) => !consumed.has(c));
+				if (!child) continue;
+				consumed.add(child);
+				const resolvedToolCallId = toolCallId ?? child.toolCallId;
+				const toolName = dec?.toolName ?? dec?.name ?? child.toolName;
+				turnMessages.push({
+					role: "tool",
+					tool_call_id: resolvedToolCallId,
+					content: [{
+						type: "tool-result",
+						toolCallId: resolvedToolCallId,
+						toolName,
+						output: child.output
+					}]
+				});
+			}
+			gen.turnsByStepIndex.set(stepIndex, turnMessages);
+		} else if (span.type === MastraSpanType.TOOL_CALL || span.type === MastraSpanType.MCP_TOOL_CALL) {
+			const parentId = span.parentSpanId;
+			if (!parentId) return;
+			const generationId = this.generationIdByStepId.get(parentId);
+			if (!generationId) return;
+			const gen = this.generationStateById.get(generationId);
+			if (!gen) return;
+			const stepIndex = this.stepIndexBySpanId.get(parentId);
+			if (stepIndex === void 0) return;
+			const list = gen.toolCallChildrenByStepIndex.get(stepIndex) ?? [];
+			list.push({
+				toolCallId: extractToolCallId(span),
+				toolName: cleanMastraToolName(span.name) || "tool",
+				input: span.input,
+				output: span.output
+			});
+			gen.toolCallChildrenByStepIndex.set(stepIndex, list);
+		}
+	}
+	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()
+		};
+		if (this.config?.linkToActiveContext) {
+			const activeSpan = _opentelemetry_api.trace.getSpan(require_decorators.LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
+			const ctx = activeSpan?.spanContext();
+			if (ctx && ctx.traceId && ctx.spanId) {
+				created.otelTraceId = require_utils.normalizeOtelTraceId(ctx.traceId);
+				created.otelRootParentSpanId = require_utils.normalizeOtelSpanId(ctx.spanId);
+				const attrs = activeSpan.attributes;
+				if (attrs) {
+					const parentPath = attrs[require_utils.SPAN_PATH];
+					if (Array.isArray(parentPath) && parentPath.every((p) => typeof p === "string")) created.otelParentSpanPath = parentPath;
+					const parentIdsPath = attrs[require_utils.SPAN_IDS_PATH];
+					if (Array.isArray(parentIdsPath) && parentIdsPath.every((p) => typeof p === "string")) created.otelParentSpanIdsPath = parentIdsPath;
+				}
+			}
+		}
+		this.traceMap.set(traceId, created);
+		return created;
+	}
+	startOtelSpan(span, traceState) {
+		const tracer = require_decorators.getTracerProvider().getTracer("@lmnr-ai/lmnr", require_dist.version);
+		const parentCtx = this.buildParentContext(span, traceState);
+		const otelSpan = tracer.startSpan(span.name, {
+			startTime: dateToHrTime(span.startTime),
+			kind: _opentelemetry_api.SpanKind.INTERNAL
+		}, parentCtx);
+		if (!otelSpan.isRecording()) {
+			this.warnNotInitializedOnce();
+			return;
+		}
+		const sdkAllocatedSpanId = otelSpan.spanContext().spanId;
+		const mastraSpanId = require_utils.normalizeOtelSpanId(span.id);
+		const mastraTraceId = traceState.otelTraceId ?? require_utils.normalizeOtelTraceId(span.traceId);
+		Object.assign(otelSpan.spanContext(), {
+			traceId: mastraTraceId,
+			spanId: mastraSpanId
+		});
+		if (sdkAllocatedSpanId !== mastraSpanId) require_decorators.getSpanProcessor()?.dropPathInfo(sdkAllocatedSpanId);
+		const parentSpanIdNormalized = span.parentSpanId ? require_utils.normalizeOtelSpanId(span.parentSpanId) : traceState.otelRootParentSpanId;
+		if (parentSpanIdNormalized) {
+			const parentSpanContext = {
+				traceId: mastraTraceId,
+				spanId: parentSpanIdNormalized,
+				traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+				isRemote: false
+			};
+			Object.assign(otelSpan, {
+				parentSpanId: parentSpanIdNormalized,
+				parentSpanContext
+			});
+		} else Object.assign(otelSpan, {
+			parentSpanId: void 0,
+			parentSpanContext: void 0
+		});
+		const spanPath = traceState.spanPathById.get(span.id);
+		const spanIdsPath = traceState.spanIdsPathById.get(span.id);
+		if (spanPath) otelSpan.setAttribute(require_utils.SPAN_PATH, spanPath);
+		if (spanIdsPath) otelSpan.setAttribute(require_utils.SPAN_IDS_PATH, spanIdsPath);
+		this.liveOtelSpanByMastraId.set(span.id, otelSpan);
+	}
+	warnNotInitializedOnce() {
+		if (this.warnedNotInitialized) return;
+		this.warnedNotInitialized = true;
+		logger.warn("[MastraExporter] Laminar tracer is not initialized — Mastra spans will be dropped. Call `Laminar.initialize({ projectApiKey: ... })` before constructing `MastraExporter`.");
+	}
+	buildParentContext(span, traceState) {
+		const baseCtx = require_decorators.LaminarContextManager.getContext() ?? _opentelemetry_api.context.active();
+		if (span.parentSpanId) {
+			const parentLive = this.liveOtelSpanByMastraId.get(span.parentSpanId);
+			if (parentLive) return _opentelemetry_api.trace.setSpan(baseCtx, parentLive);
+		}
+		if (traceState.otelTraceId && traceState.otelRootParentSpanId) {
+			const wrapped = _opentelemetry_api.trace.wrapSpanContext({
+				traceId: traceState.otelTraceId,
+				spanId: traceState.otelRootParentSpanId,
+				traceFlags: _opentelemetry_api.TraceFlags.SAMPLED,
+				isRemote: false
+			});
+			return _opentelemetry_api.trace.setSpan(baseCtx, wrapped);
+		}
+		return baseCtx;
+	}
+	applyEndAttributes(span, otelSpan, traceState) {
+		const attributes = this.buildLaminarAttributes(span, traceState);
+		delete attributes[require_utils.SPAN_PATH];
+		delete attributes[require_utils.SPAN_IDS_PATH];
+		otelSpan.setAttributes(attributes);
+	}
+	buildLaminarAttributes(span, traceState) {
+		const attributes = {};
+		const spanPath = traceState.spanPathById.get(span.id);
+		const spanIdsPath = traceState.spanIdsPathById.get(span.id);
+		if (spanPath) attributes[require_utils.SPAN_PATH] = spanPath;
+		if (spanIdsPath) attributes[require_utils.SPAN_IDS_PATH] = spanIdsPath;
+		const laminarSpanType = mapLaminarSpanType(span.type);
+		attributes[require_utils.SPAN_TYPE] = laminarSpanType;
+		attributes[require_utils.SPAN_INSTRUMENTATION_SOURCE] = "javascript";
+		attributes[require_utils.SPAN_SDK_VERSION] = require_dist.version;
+		const langVersion = require_decorators.getLangVersion();
+		if (langVersion) attributes[require_utils.SPAN_LANGUAGE_VERSION] = langVersion;
+		attributes["lmnr.internal.mastra.span_type"] = span.type;
+		const metadata = span.metadata ?? {};
+		const sessionId = metadata.sessionId ?? metadata.session_id;
+		if (typeof sessionId === "string" && sessionId.length > 0) attributes[require_utils.SESSION_ID] = sessionId;
+		const userId = metadata.userId ?? metadata.user_id;
+		if (typeof userId === "string" && userId.length > 0) attributes[require_utils.USER_ID] = userId;
+		for (const [key, value] of Object.entries(metadata)) {
+			if (key === "sessionId" || key === "session_id" || key === "userId" || key === "user_id" || value === void 0 || value === null) continue;
+			const av = toAttributeValue(value);
+			if (av !== void 0) attributes[`${require_utils.ASSOCIATION_PROPERTIES}.metadata.${key}`] = av;
+		}
+		if (span.isRootSpan && span.tags?.length) attributes[`${require_utils.ASSOCIATION_PROPERTIES}.tags`] = span.tags;
+		if (laminarSpanType === "LLM") this.applyLlmAttributes(span, attributes);
+		else if (laminarSpanType === "TOOL") this.applyToolAttributes(span, attributes);
+		else {
+			if (span.input !== void 0) attributes[require_utils.SPAN_INPUT] = serializeJSON(span.input);
+			if (span.output !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(span.output);
+		}
+		return attributes;
+	}
+	applyLlmAttributes(span, attributes) {
+		const generationId = this.generationIdByStepId.get(span.id) ?? span.parentSpanId;
+		const gen = generationId ? this.generationStateById.get(generationId) : void 0;
+		const generationAttrs = generationId ? this.generationAttrsById.get(generationId) : void 0;
+		const stepAttrs = span.attributes ?? {};
+		const stepIndex = this.stepIndexBySpanId.get(span.id) ?? (typeof stepAttrs.stepIndex === "number" ? stepAttrs.stepIndex : 0);
+		const provider = generationAttrs?.provider;
+		const model = generationAttrs?.model;
+		const responseModel = generationAttrs?.responseModel;
+		if (provider) attributes[require_utils.LaminarAttributes.PROVIDER] = normalizeProvider(provider);
+		if (model) attributes[require_utils.LaminarAttributes.REQUEST_MODEL] = model;
+		if (responseModel) attributes[require_utils.LaminarAttributes.RESPONSE_MODEL] = responseModel;
+		else if (model) attributes[require_utils.LaminarAttributes.RESPONSE_MODEL] = model;
+		const usage = stepAttrs.usage ?? generationAttrs?.usage;
+		Object.assign(attributes, formatUsage(usage));
+		if (typeof stepAttrs.finishReason === "string") {
+			attributes["gen_ai.response.finish_reason"] = stepAttrs.finishReason;
+			attributes["ai.response.finishReason"] = stepAttrs.finishReason;
+		}
+		const messages = gen ? [...gen.baseMessages] : [];
+		if (gen) for (let i = 0; i < stepIndex; i++) {
+			const turn = gen.turnsByStepIndex.get(i);
+			if (turn) messages.push(...turn);
+		}
+		if (messages.length > 0) attributes["ai.prompt.messages"] = serializeJSON(messages);
+		else if (span.input !== void 0) attributes[require_utils.SPAN_INPUT] = serializeJSON(span.input);
+		const out = span.output;
+		const reasoningText = gen?.reasoningTextByStepIndex.get(stepIndex);
+		if (out && typeof out === "object") {
+			const outObj = out;
+			if (typeof outObj.text === "string" && outObj.text.length > 0) attributes["ai.response.text"] = outObj.text;
+			const normalizedToolCalls = Array.isArray(outObj.toolCalls) && outObj.toolCalls.length > 0 ? outObj.toolCalls.map((tc) => ({
+				toolCallType: tc.toolCallType ?? "function",
+				toolCallId: tc.toolCallId,
+				toolName: tc.toolName,
+				args: stringifyArgs(tc.args ?? tc.input)
+			})) : [];
+			if (normalizedToolCalls.length > 0) attributes["ai.response.toolCalls"] = JSON.stringify(normalizedToolCalls);
+			if (typeof reasoningText === "string" && reasoningText.length > 0) {
+				const parts = [{
+					type: "thinking",
+					content: reasoningText
+				}];
+				if (typeof outObj.text === "string" && outObj.text.length > 0) parts.push({
+					type: "text",
+					content: outObj.text
+				});
+				for (const tc of normalizedToolCalls) {
+					let argsObj = tc.args;
+					if (typeof argsObj === "string") try {
+						argsObj = JSON.parse(argsObj);
+					} catch {}
+					parts.push({
+						type: "tool_call",
+						id: tc.toolCallId,
+						name: tc.toolName,
+						arguments: argsObj
+					});
+				}
+				attributes["gen_ai.output.messages"] = JSON.stringify([{
+					role: "assistant",
+					parts
+				}]);
+			}
+		} else if (out !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(out);
+	}
+	applyToolAttributes(span, attributes) {
+		if (span.input !== void 0) attributes[require_utils.SPAN_INPUT] = serializeJSON(span.input);
+		if (span.output !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(span.output);
+		const toolAttrs = span.attributes ?? {};
+		const cleanedName = cleanMastraToolName(span.name) || span.name;
+		if (cleanedName) attributes["ai.toolCall.name"] = cleanedName;
+		if (typeof toolAttrs.toolType === "string") attributes["ai.toolCall.type"] = toolAttrs.toolType;
+		if (typeof toolAttrs.mcpServer === "string") attributes["mcp.server"] = toolAttrs.mcpServer;
+	}
+};
+//#endregion
 exports.Dataset = EvaluationDataset;
 exports.HumanEvaluator = HumanEvaluator;
 exports.Laminar = require_decorators.Laminar;
@@ -872,6 +1425,7 @@ exports.LaminarAttributes = require_utils.LaminarAttributes;
 exports.LaminarClient = require_dist.LaminarClient;
 exports.LaminarDataset = LaminarDataset;
 exports.LaminarSpanProcessor = require_decorators.LaminarSpanProcessor;
+exports.MastraExporter = MastraExporter;
 exports.TracingLevel = require_decorators.TracingLevel;
 exports.evaluate = evaluate;
 exports.getTracer = require_decorators.getTracer;