@lmnr-ai/lmnr 0.8.44 → 0.8.45

package/dist/index.cjs

@@ -1,15 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
-const require_dist = require("./dist-BtB31bk1.cjs");
+const require_utils = require("./utils-CatgN6Pb.cjs");
 const require_consts = require("./consts-9rSS0oeR.cjs");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
 let _opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
 let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 let _opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
-let path = require("path");
-path = require_rolldown_runtime.__toESM(path);
 let _traceloop_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
 let _traceloop_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
 let _traceloop_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
@@ -183,7 +183,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-CMO5MuV9.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-pZG20hHb.cjs")).then((n) => n.file_utils_exports);
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -199,7 +199,7 @@ var LaminarDataset = class extends EvaluationDataset {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/compat.ts
-const logger$25 = require_dist.initializeLogger();
+const logger$26 = require_utils.initializeLogger();
 const makeSpanOtelV2Compatible = (span) => {
 	const spanAny = span;
 	if (spanAny.instrumentationScope && !spanAny.instrumentationLibrary) Object.assign(span, { instrumentationLibrary: spanAny.instrumentationScope });
@@ -245,7 +245,7 @@ const createResource = (attributes) => {
 		if (resources.Resource) return new resources.Resource(attributes);
 		throw new Error("Unable to create Resource: neither v1 nor v2 API found");
 	} catch {
-		logger$25.debug("Laminar failed to @opentelemetry/resources, continuing without it");
+		logger$26.debug("Laminar failed to @opentelemetry/resources, continuing without it");
 		return;
 	}
 };
@@ -278,6 +278,23 @@ function convertUint8ArrayToBase64(array) {
 	return btoa(latin1string);
 }
 /**
+* Checks whether `key` looks like an AI SDK stream property WITHOUT reading it.
+*
+* Reading is not safe here: AI SDK exposes `textStream` / `fullStream` as getters that build a
+* fresh stream on every access. On `streamText` that tees (and mutates) the internal base stream,
+* leaving an abandoned branch that buffers the whole response; on `streamObject` it `pipeThrough`s
+* the base stream directly, permanently LOCKING it so the caller's own access throws. So we only
+* inspect the property descriptor: AI SDK's are accessors, whereas a same-named host API (e.g.
+* Node 26's `Response.prototype.textStream`) is a data property holding a method.
+*/
+const hasStreamAccessor = (obj, key) => {
+	for (let o = obj; o !== null; o = Object.getPrototypeOf(o)) {
+		const descriptor = Object.getOwnPropertyDescriptor(o, key);
+		if (descriptor) return typeof descriptor.value !== "function";
+	}
+	return false;
+};
+/**
 * This function checks if an object is stream or stream-like, and returns information
 * about the stream type and how to handle it.
 * @param response - The result of a function, either an AI SDK result, a raw stream, or any other
@@ -286,10 +303,6 @@ function convertUint8ArrayToBase64(array) {
 */
 const getStream = (response) => {
 	if (!response || typeof response !== "object") return { type: null };
-	if ("textStream" in response || "fullStream" in response) return {
-		type: "aisdk-result",
-		result: response
-	};
 	if (response instanceof Response) return {
 		type: "response",
 		response
@@ -298,6 +311,10 @@ const getStream = (response) => {
 		type: "readable-stream",
 		stream: response
 	};
+	if (hasStreamAccessor(response, "textStream") || hasStreamAccessor(response, "fullStream")) return {
+		type: "aisdk-result",
+		result: response
+	};
 	if (Symbol.asyncIterator in response && !(response instanceof ReadableStream)) return {
 		type: "async-iterable",
 		iterable: response
@@ -318,7 +335,7 @@ const consumeAISDKResult = async (result) => {
 		} catch (error) {
 			errors.push({
 				field: key,
-				error: require_dist.errorMessage(error)
+				error: require_utils.errorMessage(error)
 			});
 		}
 	};
@@ -430,7 +447,7 @@ const consumeResponse = async (response) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/stream-utils.ts
-const logger$24 = require_dist.initializeLogger();
+const logger$25 = require_utils.initializeLogger();
 const pendingStreamProcessing = /* @__PURE__ */ new Set();
 /**
 * Wait for all pending stream processing to complete with a timeout
@@ -438,7 +455,7 @@ const pendingStreamProcessing = /* @__PURE__ */ new Set();
 */
 const waitForPendingStreams = async (timeoutMs = 5e3) => {
 	if (pendingStreamProcessing.size === 0) return;
-	logger$24.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
+	logger$25.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
 	const initialCount = pendingStreamProcessing.size;
 	const pendingPromises = Array.from(pendingStreamProcessing);
 	let timedOut = false;
@@ -449,7 +466,7 @@ const waitForPendingStreams = async (timeoutMs = 5e3) => {
 		}, timeoutMs);
 	});
 	await Promise.race([Promise.allSettled(pendingPromises), timeoutPromise]);
-	if (timedOut && pendingStreamProcessing.size > 0) logger$24.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
+	if (timedOut && pendingStreamProcessing.size > 0) logger$25.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
 };
 /**
 * Track a background promise and ensure cleanup
@@ -465,34 +482,34 @@ const trackStreamProcessing = (task) => {
 * while passing through the original result to the caller
 */
 const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, serialize) => {
-	logger$24.debug(`Handling stream result of type: ${streamInfo.type}`);
+	logger$25.debug(`Handling stream result of type: ${streamInfo.type}`);
 	if (streamInfo.type === "aisdk-result") {
 		trackStreamProcessing(async () => {
-			logger$24.debug("Starting background processing for AI SDK result");
+			logger$25.debug("Starting background processing for AI SDK result");
 			let partialOutput = {};
 			try {
 				partialOutput = await consumeAISDKResult(streamInfo.result);
 				if (shouldSendTraces() && !ignoreOutput) try {
-					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(partialOutput));
+					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (error) {
-					logger$24.warn("Failed to serialize AI SDK stream output: " + require_dist.errorMessage(error));
+					logger$25.warn("Failed to serialize AI SDK stream output: " + require_utils.errorMessage(error));
 				}
 			} catch (error) {
 				if (Object.keys(partialOutput).length > 0 && shouldSendTraces() && !ignoreOutput) try {
-					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(partialOutput));
+					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (serError) {
-					logger$24.warn("Failed to serialize partial AI SDK output: " + require_dist.errorMessage(serError));
+					logger$25.warn("Failed to serialize partial AI SDK output: " + require_utils.errorMessage(serError));
 				}
 				span.recordException(error);
 			} finally {
-				logger$24.debug("Ending span for AI SDK result");
+				logger$25.debug("Ending span for AI SDK result");
 				span.end();
 			}
 		});
 		return originalResult;
 	}
 	if (streamInfo.type === "readable-stream") {
-		logger$24.debug("Setting up background processing for ReadableStream");
+		logger$25.debug("Setting up background processing for ReadableStream");
 		const { stream, dataPromise } = consumeAndTeeReadableStream(streamInfo.stream);
 		trackStreamProcessing(async () => {
 			try {
@@ -502,20 +519,20 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "stream",
 						chunks
 					};
-					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$24.warn("Failed to serialize stream output: " + require_dist.errorMessage(serError));
+					logger$25.warn("Failed to serialize stream output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$24.debug("Ending span for ReadableStream");
+				logger$25.debug("Ending span for ReadableStream");
 				span.end();
 			}
 		});
 		return stream;
 	}
 	if (streamInfo.type === "async-iterable") {
-		logger$24.debug("Setting up background processing for AsyncIterable");
+		logger$25.debug("Setting up background processing for AsyncIterable");
 		const { iterable, dataPromise } = consumeAndTeeAsyncIterable(streamInfo.iterable);
 		trackStreamProcessing(async () => {
 			try {
@@ -525,20 +542,20 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "async-iterable",
 						chunks
 					};
-					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$24.warn("Failed to serialize async iterable output: " + require_dist.errorMessage(serError));
+					logger$25.warn("Failed to serialize async iterable output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$24.debug("Ending span for AsyncIterable");
+				logger$25.debug("Ending span for AsyncIterable");
 				span.end();
 			}
 		});
 		return iterable;
 	}
 	if (streamInfo.type === "response") {
-		logger$24.debug("Setting up background processing for Response");
+		logger$25.debug("Setting up background processing for Response");
 		const originalResponse = streamInfo.response;
 		if (!originalResponse.body) {
 			span.end();
@@ -558,21 +575,21 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "response",
 						chunks
 					};
-					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$24.warn("Failed to serialize response output: " + require_dist.errorMessage(serError));
+					logger$25.warn("Failed to serialize response output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} catch (err) {
 				span.recordException(err);
 			} finally {
-				logger$24.debug("Ending span for Response");
+				logger$25.debug("Ending span for Response");
 				span.end();
 			}
 		});
 		return newResponse;
 	}
-	logger$24.warn("Stream type not handled, ending span immediately");
+	logger$25.warn("Stream type not handled, ending span immediately");
 	span.end();
 	return originalResult;
 };
@@ -586,7 +603,7 @@ const str = (v) => typeof v === "string" && v.length > 0 ? v : null;
 */
 const readDebugSessionFile = (dir = process.cwd()) => {
 	try {
-		const raw = (0, node_fs.readFileSync)((0, node_path.join)(dir, require_dist.DEBUG_SESSION_DIR, require_dist.DEBUG_SESSION_FILE), "utf-8");
+		const raw = (0, node_fs.readFileSync)((0, node_path.join)(dir, require_utils.DEBUG_SESSION_DIR, require_utils.DEBUG_SESSION_FILE), "utf-8");
 		const r = JSON.parse(raw);
 		const session_id = str(r.session_id);
 		if (!session_id) return null;
@@ -632,9 +649,9 @@ const resolveDebugSessionDir = (startDir = process.cwd()) => findDebugSessionDir
 */
 const writeDebugSessionFile = (file, dir = process.cwd()) => {
 	try {
-		const directory = (0, node_path.join)(dir, require_dist.DEBUG_SESSION_DIR);
+		const directory = (0, node_path.join)(dir, require_utils.DEBUG_SESSION_DIR);
 		(0, node_fs.mkdirSync)(directory, { recursive: true });
-		(0, node_fs.writeFileSync)((0, node_path.join)(directory, require_dist.DEBUG_SESSION_FILE), JSON.stringify(file), "utf-8");
+		(0, node_fs.writeFileSync)((0, node_path.join)(directory, require_utils.DEBUG_SESSION_FILE), JSON.stringify(file), "utf-8");
 		return true;
 	} catch {
 		return false;
@@ -650,7 +667,7 @@ const writeDebugSessionFile = (file, dir = process.cwd()) => {
 * contract. This file is part of the cross-language parity surface — keep its
 * logic line-comparable with the Python `config.py`.
 */
-const logger$23 = require_dist.initializeLogger();
+const logger$24 = require_utils.initializeLogger();
 const TRUTHY = new Set([
 	"true",
 	"1",
@@ -686,7 +703,7 @@ const parseCacheUntil = (value) => {
 	if (value === void 0 || value === "") return null;
 	const spanId = normalizeSpanId(value);
 	if (spanId !== null) return spanId;
-	logger$23.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
+	logger$24.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
 	return null;
 };
 /**
@@ -1037,7 +1054,7 @@ const resetDebugRuntime = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/span.ts
-const logger$22 = require_dist.initializeLogger();
+const logger$23 = require_utils.initializeLogger();
 /**
 * Build the debug block to propagate, or undefined when debug mode is off.
 *
@@ -1142,24 +1159,24 @@ var LaminarSpan = class LaminarSpan {
 		return this._span.recordException(exception, time);
 	}
 	setTraceSessionId(sessionId) {
-		this._span.setAttribute(require_dist.SESSION_ID, sessionId);
+		this._span.setAttribute(require_utils.SESSION_ID, sessionId);
 	}
 	setTraceUserId(userId) {
-		this._span.setAttribute(require_dist.USER_ID, userId);
+		this._span.setAttribute(require_utils.USER_ID, userId);
 	}
 	setTraceMetadata(metadata) {
-		this._span.setAttributes(require_dist.metadataToAttributes(metadata));
+		this._span.setAttributes(require_utils.metadataToAttributes(metadata));
 	}
 	setInput(input) {
 		const finalInput = typeof input === "string" ? input : JSON.stringify(input);
-		this._span.setAttribute(require_dist.SPAN_INPUT, require_dist.truncateSpanPayload(finalInput, "input"));
+		this._span.setAttribute(require_utils.SPAN_INPUT, require_utils.truncateSpanPayload(finalInput, "input"));
 	}
 	setOutput(output) {
 		const finalOutput = typeof output === "string" ? output : JSON.stringify(output);
-		this._span.setAttribute(require_dist.SPAN_OUTPUT, require_dist.truncateSpanPayload(finalOutput, "output"));
+		this._span.setAttribute(require_utils.SPAN_OUTPUT, require_utils.truncateSpanPayload(finalOutput, "output"));
 	}
 	setTags(tags) {
-		this._span.setAttribute(`${require_dist.ASSOCIATION_PROPERTIES}.tags`, Array.from(new Set(tags)));
+		this._span.setAttribute(`${require_utils.ASSOCIATION_PROPERTIES}.tags`, Array.from(new Set(tags)));
 	}
 	addTags(tags) {
 		const currentTags = this.tags;
@@ -1171,26 +1188,26 @@ var LaminarSpan = class LaminarSpan {
 		let userId;
 		let sessionId;
 		let traceType;
-		let tracingLevel = require_dist.TracingLevel.ALL;
+		let tracingLevel = require_utils.TracingLevel.ALL;
 		const metadata = {};
 		if (this._span.attributes) {
-			spanPath = this._span.attributes[require_dist.SPAN_PATH];
-			spanIdsPath = this._span.attributes[require_dist.SPAN_IDS_PATH];
-			userId = this._span.attributes[require_dist.USER_ID];
-			sessionId = this._span.attributes[require_dist.SESSION_ID];
-			traceType = this._span.attributes[require_dist.TRACE_TYPE];
-			tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_dist.TracingLevel.ALL;
+			spanPath = this._span.attributes[require_utils.SPAN_PATH];
+			spanIdsPath = this._span.attributes[require_utils.SPAN_IDS_PATH];
+			userId = this._span.attributes[require_utils.USER_ID];
+			sessionId = this._span.attributes[require_utils.SESSION_ID];
+			traceType = this._span.attributes[require_utils.TRACE_TYPE];
+			tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_utils.TracingLevel.ALL;
 			for (const [key, rawValue] of Object.entries(this._span.attributes)) if (key.startsWith(`lmnr.association.properties.metadata.`)) {
 				let value = rawValue;
 				try {
 					value = JSON.parse(value);
 				} catch {}
-				metadata[key.replace(`${require_dist.ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
+				metadata[key.replace(`${require_utils.ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
 			}
-		} else logger$22.warn("Attributes object is not available. Most likely the span is not a LaminarSpan and not an OpenTelemetry default SDK Span. Span path and ids path will be empty.");
+		} else logger$23.warn("Attributes object is not available. Most likely the span is not a LaminarSpan and not an OpenTelemetry default SDK Span. Span path and ids path will be empty.");
 		return {
-			spanId: require_dist.otelSpanIdToUUID(this._span.spanContext().spanId),
-			traceId: require_dist.otelTraceIdToUUID(this._span.spanContext().traceId),
+			spanId: require_utils.otelSpanIdToUUID(this._span.spanContext().spanId),
+			traceId: require_utils.otelTraceIdToUUID(this._span.spanContext().traceId),
 			isRemote: this._span.spanContext().isRemote ?? false,
 			spanPath,
 			spanIdsPath,
@@ -1205,23 +1222,23 @@ var LaminarSpan = class LaminarSpan {
 	spanId(format = "otel") {
 		const spanId = this._span.spanContext().spanId;
 		if (format === "otel") return spanId;
-		return require_dist.otelSpanIdToUUID(spanId);
+		return require_utils.otelSpanIdToUUID(spanId);
 	}
 	traceId(format = "otel") {
 		const traceId = this._span.spanContext().traceId;
 		if (format === "otel") return traceId;
-		return require_dist.otelTraceIdToUUID(traceId);
+		return require_utils.otelTraceIdToUUID(traceId);
 	}
 	get tags() {
 		if (!this._span.attributes) {
-			logger$22.warn("[LaminarSpan.tags] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty list. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
+			logger$23.warn("[LaminarSpan.tags] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty list. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
 			return [];
 		}
 		return this._span.attributes[`lmnr.association.properties.tags`] ?? [];
 	}
 	get laminarAssociationProperties() {
 		if (!this._span.attributes) {
-			logger$22.warn("[LaminarSpan.laminarAssociationProperties] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty object. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
+			logger$23.warn("[LaminarSpan.laminarAssociationProperties] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty object. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
 			return {};
 		}
 		try {
@@ -1231,14 +1248,14 @@ var LaminarSpan = class LaminarSpan {
 				if (!key.startsWith(`lmnr.association.properties.`)) continue;
 				let value = rawValue;
 				if (key.startsWith(`lmnr.association.properties.metadata.`)) {
-					const metaKey = key.replace(`${require_dist.ASSOCIATION_PROPERTIES}.metadata.`, "");
+					const metaKey = key.replace(`${require_utils.ASSOCIATION_PROPERTIES}.metadata.`, "");
 					try {
 						value = JSON.parse(value);
 					} catch {}
 					metadata[metaKey] = value;
 				}
 			}
-			properties.tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_dist.TracingLevel.ALL;
+			properties.tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_utils.TracingLevel.ALL;
 			properties.userId = this._span.attributes["lmnr.association.properties.user_id"] ?? void 0;
 			properties.sessionId = this._span.attributes["lmnr.association.properties.session_id"] ?? void 0;
 			properties.traceType = this._span.attributes["lmnr.association.properties.trace_type"] ?? void 0;
@@ -1417,7 +1434,7 @@ var LaminarContextManager = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/proxy.ts
-const logger$21 = require_dist.initializeLogger();
+const logger$22 = require_utils.initializeLogger();
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 const DEFAULT_CC_PROXY_PORT = 45667;
 const CC_PROXY_PORT_ATTEMPTS = 50;
@@ -1669,7 +1686,7 @@ const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL,
 		if (foundryBaseUrl) return foundryBaseUrl.replace(/\/$/, "");
 		const foundryResource = getEnvValue(FOUNDRY_RESOURCE_ENV);
 		if (foundryResource) return `https://${foundryResource}.services.ai.azure.com/anthropic`;
-		logger$21.error(`${FOUNDRY_USE_ENV} is set but neither ${FOUNDRY_BASE_URL_ENV} nor ${FOUNDRY_RESOURCE_ENV} is configured. Microsoft Foundry requires one of these values.`);
+		logger$22.error(`${FOUNDRY_USE_ENV} is set but neither ${FOUNDRY_BASE_URL_ENV} nor ${FOUNDRY_RESOURCE_ENV} is configured. Microsoft Foundry requires one of these values.`);
 		return null;
 	}
 	if (isTruthyEnv(getEnvValue(BEDROCK_USE_ENV))) {
@@ -1678,7 +1695,7 @@ const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL,
 		let region = getEnvValue(BEDROCK_AWS_REGION_ENV);
 		if (!region) region = getRegionFromAwsConfig(getEnvValue("AWS_PROFILE") || "default") ?? void 0;
 		if (region) return `https://bedrock-runtime.${region}.amazonaws.com`;
-		logger$21.error(`${BEDROCK_USE_ENV} is set but could not determine AWS region. Set ${BEDROCK_AWS_REGION_ENV} or configure a region in ~/.aws/config for the active profile.`);
+		logger$22.error(`${BEDROCK_USE_ENV} is set but could not determine AWS region. Set ${BEDROCK_AWS_REGION_ENV} or configure a region in ~/.aws/config for the active profile.`);
 		return null;
 	}
 	if (isTruthyEnv(getEnvValue(VERTEX_USE_ENV))) {
@@ -1761,11 +1778,11 @@ const waitForPort = (port, timeoutMs = 5e3) => new Promise((resolve) => {
 const registerGlobalProxyShutdown = () => {
 	if (!globalShutdownRegistered) {
 		process.on("exit", () => {
-			logger$21.debug("process.on(\"exit\") called - stopping all active proxies");
+			logger$22.debug("process.on(\"exit\") called - stopping all active proxies");
 			for (const proxyServer of activeProxyServers) try {
 				proxyServer.stopServer();
 			} catch (e) {
-				logger$21.debug(`Failed to stop proxy: ${require_dist.errorMessage(e)}`);
+				logger$22.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
 			}
 			activeProxyServers.clear();
 		});
@@ -1780,28 +1797,28 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 	try {
 		const port = await findAvailablePort(DEFAULT_CC_PROXY_PORT, CC_PROXY_PORT_ATTEMPTS);
 		if (port === null) {
-			logger$21.warn("Unable to allocate port for cc-proxy.");
+			logger$22.warn("Unable to allocate port for cc-proxy.");
 			return null;
 		}
 		const targetUrl = resolvedTargetUrl ?? resolveTargetUrlFromEnv(env, void 0, cwd, settingSources, settings);
 		if (!targetUrl) {
-			logger$21.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
+			logger$22.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
 			return null;
 		}
-		logger$21.debug(`Creating proxy instance on port ${port} targeting: ${targetUrl}`);
+		logger$22.debug(`Creating proxy instance on port ${port} targeting: ${targetUrl}`);
 		try {
 			const { ProxyServer } = require("@lmnr-ai/claude-code-proxy");
 			const proxyServer = new ProxyServer(port);
 			proxyServer.runServer(targetUrl);
 			if (!await waitForPort(port)) {
-				logger$21.warn(`cc-proxy failed to start on port ${port}`);
+				logger$22.warn(`cc-proxy failed to start on port ${port}`);
 				proxyServer.stopServer();
 				return null;
 			}
 			const proxyBaseUrl = `http://127.0.0.1:${port}`;
 			activeProxyServers.add(proxyServer);
 			registerGlobalProxyShutdown();
-			logger$21.info(`Started claude proxy server on: ${proxyBaseUrl}`);
+			logger$22.info(`Started claude proxy server on: ${proxyBaseUrl}`);
 			return {
 				server: proxyServer,
 				baseUrl: proxyBaseUrl,
@@ -1809,11 +1826,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 				targetUrl
 			};
 		} catch (e) {
-			logger$21.warn(`Unable to start cc-proxy: ${require_dist.errorMessage(e)}`);
+			logger$22.warn(`Unable to start cc-proxy: ${require_utils.errorMessage(e)}`);
 			return null;
 		}
 	} catch (e) {
-		logger$21.warn(`Failed to create proxy instance: ${require_dist.errorMessage(e)}`);
+		logger$22.warn(`Failed to create proxy instance: ${require_utils.errorMessage(e)}`);
 		return null;
 	}
 };
@@ -1823,11 +1840,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 const stopProxyInstance = (instance) => {
 	if (!instance) return;
 	try {
-		logger$21.debug(`Stopping proxy instance on port ${instance.port}`);
+		logger$22.debug(`Stopping proxy instance on port ${instance.port}`);
 		instance.server.stopServer();
 		activeProxyServers.delete(instance.server);
 	} catch (e) {
-		logger$21.debug(`Failed to stop proxy instance: ${require_dist.errorMessage(e)}`);
+		logger$22.debug(`Failed to stop proxy instance: ${require_utils.errorMessage(e)}`);
 	}
 };
 /**
@@ -1835,11 +1852,11 @@ const stopProxyInstance = (instance) => {
 * Used during shutdown to ensure cleanup
 */
 const forceReleaseProxy = () => {
-	logger$21.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
+	logger$22.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
 	for (const proxyServer of activeProxyServers) try {
 		proxyServer.stopServer();
 	} catch (e) {
-		logger$21.debug(`Failed to stop proxy: ${require_dist.errorMessage(e)}`);
+		logger$22.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
 	}
 	activeProxyServers.clear();
 };
@@ -1856,8 +1873,8 @@ const getSpanContextPayload = () => {
 	try {
 		const readableSpan = currentSpan;
 		if (readableSpan.attributes) {
-			const idsPath = readableSpan.attributes[require_dist.SPAN_IDS_PATH];
-			const path$1 = readableSpan.attributes[require_dist.SPAN_PATH];
+			const idsPath = readableSpan.attributes[require_utils.SPAN_IDS_PATH];
+			const path$1 = readableSpan.attributes[require_utils.SPAN_PATH];
 			if (Array.isArray(idsPath)) spanIdsPath = idsPath;
 			if (Array.isArray(path$1)) spanPath = path$1;
 		}
@@ -1889,14 +1906,14 @@ const setTraceToProxyInstance = async (instance) => {
 			spanPath: payload.span_path,
 			laminarUrl: payload.laminar_url
 		});
-		logger$21.debug(`Set trace context to proxy on port ${instance.port}`);
+		logger$22.debug(`Set trace context to proxy on port ${instance.port}`);
 	} catch (e) {
-		logger$21.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_dist.errorMessage(e));
+		logger$22.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_utils.errorMessage(e));
 	}
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/index.ts
-const logger$20 = require_dist.initializeLogger();
+const logger$21 = require_utils.initializeLogger();
 /**
 * Create an instrumented version of the claude-agent-sdk query function.
 * This can be used when importing the query function before Laminar initialization.
@@ -1911,7 +1928,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 			name: "query",
 			spanType: "DEFAULT"
 		});
-		span.setAttribute(require_dist.SPAN_INPUT, JSON.stringify({ prompt: typeof params.prompt === "string" ? params.prompt : "<stream>" }));
+		span.setAttribute(require_utils.SPAN_INPUT, JSON.stringify({ prompt: typeof params.prompt === "string" ? params.prompt : "<stream>" }));
 		const generator = async function* () {
 			const collected = [];
 			let proxyInstance = null;
@@ -1932,9 +1949,9 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					targetUrl
 				});
 				if (proxyInstance && targetUrl) {
-					logger$20.debug(`Using proxy on port ${proxyInstance.port}`);
+					logger$21.debug(`Using proxy on port ${proxyInstance.port}`);
 					await Laminar.withSpan(span, async () => {
-						logger$20.debug("Setting trace to proxy instance...");
+						logger$21.debug("Setting trace to proxy instance...");
 						await setTraceToProxyInstance(proxyInstance);
 					});
 					const varsToRemove = getEnvVarsToRemove(mergedEnv, sessionCwd, settingSources);
@@ -1949,13 +1966,13 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_BEDROCK")) subprocessEnv.ANTHROPIC_BEDROCK_BASE_URL = proxyInstance.baseUrl;
 					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_VERTEX")) subprocessEnv.ANTHROPIC_VERTEX_BASE_URL = proxyInstance.baseUrl;
 					const flagSettings = buildProxyFlagSettings(callerSettings, proxyInstance.baseUrl, sessionCwd, settingSources);
-					if (flagSettings === null) logger$20.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
+					if (flagSettings === null) logger$21.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
 					else {
 						params.options.settings = flagSettings;
-						const conflicting = Object.entries(readClaudeSettingsEnv(sessionCwd, settingSources)).filter(([key, value]) => PROXY_BASE_URL_ENV_KEYS.includes(key) && value !== "" && value !== proxyInstance.baseUrl).map(([key]) => key);
-						if (conflicting.length > 0) logger$20.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
+						const conflicting = Object.entries(readClaudeSettingsEnv(sessionCwd, settingSources)).filter(([key, value]) => PROXY_BASE_URL_ENV_KEYS.includes(key) && value !== "" && value !== proxyInstance?.baseUrl).map(([key]) => key);
+						if (conflicting.length > 0) logger$21.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
 					}
-				} else logger$20.debug("No claude proxy server available. Proceeding without proxy.");
+				} else logger$21.debug("No claude proxy server available. Proceeding without proxy.");
 				const originalGenerator = originalQuery(params);
 				for await (const message of originalGenerator) {
 					collected.push(message);
@@ -1968,7 +1985,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 				throw error;
 			} finally {
 				stopProxyInstance(proxyInstance);
-				span.setAttribute(require_dist.SPAN_OUTPUT, JSON.stringify(collected));
+				span.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(collected));
 				span.end();
 			}
 		};
@@ -1977,14 +1994,14 @@ function instrumentClaudeAgentQuery(originalQuery) {
 }
 var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor() {
-		super("@lmnr/claude-agent-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/claude-agent-instrumentation", require_utils.version, { enabled: true });
 	}
 	init() {
 		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@anthropic-ai/claude-agent-sdk", [">=0.1.0"], this.patch.bind(this), this.unpatch.bind(this));
 	}
 	manuallyInstrument(claudeAgentModule) {
 		if (claudeAgentModule.query && typeof claudeAgentModule.query === "function") this._wrap(claudeAgentModule, "query", this.patchQuery());
-		else logger$20.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
+		else logger$21.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
 	}
 	patchQuery() {
 		return (original) => instrumentClaudeAgentQuery(original);
@@ -2001,8 +2018,8 @@ var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation
 };
 //#endregion
 //#region src/laminar.ts
-require_dist.loadEnv();
-const logger$19 = require_dist.initializeLogger();
+require_utils.loadEnv();
+const logger$20 = require_utils.initializeLogger();
 var Laminar = class Laminar {
 	static {
 		this.isInitialized = false;
@@ -2054,6 +2071,13 @@ var Laminar = class Laminar {
 	* @param {string} props.logLevel - OTel log level. Defaults to "error".
 	* @param {number} props.maxExportBatchSize - Maximum number of spans to export in a single batch.
 	* Ignored when `disableBatch` is true.
+	* @param {boolean} props.flushBySize - Whether to also flush batches by approximate payload
+	* size, not just by span count and schedule delay. The batch is flushed when the next span
+	* would push it past `maxExportBatchSizeBytes`, so a few large spans are exported without
+	* waiting for `maxExportBatchSize` spans to accumulate. Useful when spans carry large prompts
+	* or completions and exports get rejected for being too big. Defaults to false.
+	* @param {number} props.maxExportBatchSizeBytes - Approximate maximum size, in bytes, of the
+	* spans buffered in one batch. Only used when `flushBySize` is true. Defaults to 32 MiB.
 	* @param {boolean} props.forceHttp - Whether to force HTTP export. Not recommended.
 	* @param {SessionRecordingOptions} props.sessionRecordingOptions - Options for browser
 	* session recording.
@@ -2086,13 +2110,13 @@ var Laminar = class Laminar {
 	*
 	* @throws {Error} - If project API key is not set
 	*/
-	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor } = {}) {
+	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, maxExportBatchSizeBytes, flushBySize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor } = {}) {
 		if (this.isInitialized) {
-			logger$19.warn("Laminar has already been initialized. Skipping initialization.");
+			logger$20.warn("Laminar has already been initialized. Skipping initialization.");
 			return;
 		}
 		const key = projectApiKey ?? process?.env?.LMNR_PROJECT_API_KEY;
-		require_dist.validateTracingConfig(key);
+		require_utils.validateTracingConfig(key);
 		this.projectApiKey = key ?? "";
 		let url = baseUrl ?? process?.env?.LMNR_BASE_URL;
 		if (key && !url) url = "https://api.lmnr.ai";
@@ -2112,7 +2136,7 @@ var Laminar = class Laminar {
 			...metadata ?? {}
 		};
 		if (inheritGlobalContext) LaminarContextManager.inheritGlobalContext = true;
-		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$19.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
+		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$20.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
 		this.isInitialized = true;
 		const urlWithoutSlash = url?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "");
 		const httpUrlWithoutSlash = httpUrl?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "");
@@ -2128,6 +2152,8 @@ var Laminar = class Laminar {
 			logLevel: logLevel ?? "error",
 			disableBatch,
 			maxExportBatchSize,
+			maxExportBatchSizeBytes,
+			flushBySize,
 			traceExportTimeoutMillis,
 			sessionRecordingOptions,
 			spanProcessor
@@ -2145,9 +2171,9 @@ var Laminar = class Laminar {
 		const envContext = process?.env?.LMNR_SPAN_CONTEXT;
 		if (!envContext) return;
 		try {
-			const laminarContext = require_dist.deserializeLaminarSpanContext(envContext);
+			const laminarContext = require_utils.deserializeLaminarSpanContext(envContext);
 			this._armDebugRuntimeFromContext(laminarContext.debug);
-			const otelSpanContext = require_dist.tryToOtelSpanContext(laminarContext);
+			const otelSpanContext = require_utils.tryToOtelSpanContext(laminarContext);
 			otelSpanContext.isRemote = true;
 			const processor = getSpanProcessor();
 			if (processor && processor instanceof LaminarSpanProcessor && laminarContext.spanPath && laminarContext.spanIdsPath) processor.setParentPathInfo(otelSpanContext.spanId, laminarContext.spanPath, laminarContext.spanIdsPath);
@@ -2155,13 +2181,13 @@ var Laminar = class Laminar {
 			const ctx = LaminarContextManager.setRawAssociationProperties(laminarContext, baseContext);
 			LaminarContextManager.pushContext(ctx);
 			try {
-				getRuntime()?.recordTraceId(require_dist.otelTraceIdToUUID(otelSpanContext.traceId));
+				getRuntime()?.recordTraceId(require_utils.otelTraceIdToUUID(otelSpanContext.traceId));
 			} catch (e) {
-				logger$19.debug("Failed to record debug trace id from env: " + require_dist.errorMessage(e));
+				logger$20.debug("Failed to record debug trace id from env: " + require_utils.errorMessage(e));
 			}
-			logger$19.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
+			logger$20.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
 		} catch (e) {
-			logger$19.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_dist.errorMessage(e));
+			logger$20.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2184,7 +2210,7 @@ var Laminar = class Laminar {
 					"rollout.session_id": armedRuntime.sessionId
 				};
 				if (!armedRuntime.localOrigin) {
-					const debugClient = new require_dist.LaminarClient({
+					const debugClient = new require_utils.LaminarClient({
 						baseUrl,
 						projectApiKey: this.projectApiKey,
 						port: httpPort
@@ -2193,26 +2219,26 @@ var Laminar = class Laminar {
 				}
 			}
 			if (!isTruthy(process.env.LMNR_DEBUG)) return;
-			const client = new require_dist.LaminarClient({
+			const client = new require_utils.LaminarClient({
 				baseUrl,
 				projectApiKey: this.projectApiKey,
 				port: httpPort
 			});
-			const debuggerUrl = process?.env?.LMNR_FRONTEND_URL ?? require_dist.getFrontendUrl(baseUrl);
+			const debuggerUrl = process?.env?.LMNR_FRONTEND_URL ?? require_utils.getFrontendUrl(baseUrl);
 			const { runtime } = initDebugRuntime(client.rolloutSessions, debuggerUrl);
 			if (runtime === null) return;
 			client.rolloutSessions.register({ sessionId: runtime.sessionId }).then((projectId) => {
 				if (projectId) {
 					runtime.recordProjectId(projectId);
 					const sessionUrl = runtime.debuggerSessionUrl();
-					logger$19.info(`Laminar debugger session: ${sessionUrl}`);
+					logger$20.info(`Laminar debugger session: ${sessionUrl}`);
 					if (runtime.shouldOpenBrowser) (0, node_child_process.spawn)(process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open", [sessionUrl], {
 						detached: true,
 						stdio: "ignore"
 					}).unref();
 				}
 			}).catch((e) => {
-				logger$19.warn("Failed to register debug session: " + require_dist.errorMessage(e));
+				logger$20.warn("Failed to register debug session: " + require_utils.errorMessage(e));
 			});
 			this.globalMetadata = {
 				...this.globalMetadata,
@@ -2222,7 +2248,7 @@ var Laminar = class Laminar {
 			this.debugExitHook = () => runtime.emitPointer();
 			process.once("exit", this.debugExitHook);
 		} catch (e) {
-			logger$19.warn("Failed to initialize debug runtime: " + require_dist.errorMessage(e));
+			logger$20.warn("Failed to initialize debug runtime: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2256,18 +2282,18 @@ var Laminar = class Laminar {
 			if (!debug || debug.enabled !== true || !debug.sessionId) return;
 			const existing = getRuntime();
 			if (existing !== null && existing.localOrigin) return;
-			const { runtime, configChanged } = initDebugRuntimeFromContext(debug, existing?.rolloutSessions ?? new require_dist.LaminarClient({
+			const { runtime, configChanged } = initDebugRuntimeFromContext(debug, existing?.rolloutSessions ?? new require_utils.LaminarClient({
 				baseUrl: this.baseUrlForDebug,
 				projectApiKey: this.projectApiKey,
 				port: this.httpPortForDebug
-			}).rolloutSessions, process?.env?.LMNR_FRONTEND_URL ?? require_dist.getFrontendUrl(this.baseUrlForDebug));
+			}).rolloutSessions, process?.env?.LMNR_FRONTEND_URL ?? require_utils.getFrontendUrl(this.baseUrlForDebug));
 			if (runtime === null) return;
 			if (configChanged) {
 				this.debugRunLive = false;
 				runtime.rolloutSessions.register({ sessionId: runtime.sessionId }).then((projectId) => {
 					if (projectId) runtime.recordProjectId(projectId);
 				}).catch((e) => {
-					logger$19.debug("Failed to register downstream debug session: " + require_dist.errorMessage(e));
+					logger$20.debug("Failed to register downstream debug session: " + require_utils.errorMessage(e));
 				});
 				this.globalMetadata = {
 					...this.globalMetadata,
@@ -2276,7 +2302,7 @@ var Laminar = class Laminar {
 				LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 			}
 		} catch (e) {
-			logger$19.debug("Failed to arm debug runtime from context: " + require_dist.errorMessage(e));
+			logger$20.debug("Failed to arm debug runtime from context: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2291,7 +2317,7 @@ var Laminar = class Laminar {
 	*/
 	static patch(modules) {
 		if (!this.isInitialized) {
-			logger$19.warn("Laminar must be initialized before patching modules. Skipping patch.");
+			logger$20.warn("Laminar must be initialized before patching modules. Skipping patch.");
 			return;
 		}
 		if (!modules || Object.keys(modules).length === 0) throw new Error("Pass at least one module to patch");
@@ -2539,7 +2565,7 @@ var Laminar = class Laminar {
 		let parentUserId;
 		let parentSessionId;
 		if (parentSpanContext) try {
-			const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+			const laminarContext = typeof parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 			parentPath = laminarContext.spanPath;
 			parentIdsPath = laminarContext.spanIdsPath;
 			parentMetadata = laminarContext.metadata;
@@ -2548,38 +2574,38 @@ var Laminar = class Laminar {
 			parentUserId = laminarContext.userId;
 			parentSessionId = laminarContext.sessionId;
 			this._armDebugRuntimeFromContext(laminarContext.debug);
-			const spanContext = require_dist.tryToOtelSpanContext(laminarContext);
+			const spanContext = require_utils.tryToOtelSpanContext(laminarContext);
 			entityContext = _opentelemetry_api.trace.setSpan(entityContext, _opentelemetry_api.trace.wrapSpanContext(spanContext));
 		} catch (e) {
-			logger$19.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
+			logger$20.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
 		}
-		const tagProperties = tags ? { [`${require_dist.ASSOCIATION_PROPERTIES}.tags`]: Array.from(new Set(tags)) } : {};
+		const tagProperties = tags ? { [`${require_utils.ASSOCIATION_PROPERTIES}.tags`]: Array.from(new Set(tags)) } : {};
 		const ctxAssociationProperties = LaminarContextManager.getAssociationProperties();
 		const userIdValue = userId ?? parentUserId ?? ctxAssociationProperties.userId;
 		const sessionIdValue = sessionId ?? parentSessionId ?? ctxAssociationProperties.sessionId;
 		const traceTypeValue = parentTraceType ?? (spanType === "EVALUATION" ? "EVALUATION" : void 0) ?? ctxAssociationProperties.traceType;
 		const tracingLevelValue = parentTracingLevel ?? ctxAssociationProperties.tracingLevel;
 		const ctxMetadata = ctxAssociationProperties.metadata;
-		const userIdProperties = userIdValue ? { [require_dist.USER_ID]: userIdValue } : {};
-		const sessionIdProperties = sessionIdValue ? { [require_dist.SESSION_ID]: sessionIdValue } : {};
-		const traceTypeProperties = traceTypeValue ? { [require_dist.TRACE_TYPE]: traceTypeValue } : {};
-		const tracingLevelProperties = tracingLevelValue ? { [`${require_dist.ASSOCIATION_PROPERTIES}.tracing_level`]: tracingLevelValue } : {};
-		const metadataProperties = require_dist.metadataToAttributes({
+		const userIdProperties = userIdValue ? { [require_utils.USER_ID]: userIdValue } : {};
+		const sessionIdProperties = sessionIdValue ? { [require_utils.SESSION_ID]: sessionIdValue } : {};
+		const traceTypeProperties = traceTypeValue ? { [require_utils.TRACE_TYPE]: traceTypeValue } : {};
+		const tracingLevelProperties = tracingLevelValue ? { [`${require_utils.ASSOCIATION_PROPERTIES}.tracing_level`]: tracingLevelValue } : {};
+		const metadataProperties = require_utils.metadataToAttributes({
 			...this.globalMetadata,
 			...ctxMetadata,
 			...parentMetadata,
 			...metadata
 		});
 		const attributes = {
-			[require_dist.SPAN_TYPE]: spanType ?? "DEFAULT",
+			[require_utils.SPAN_TYPE]: spanType ?? "DEFAULT",
 			...tagProperties,
 			...userIdProperties,
 			...sessionIdProperties,
 			...metadataProperties,
 			...traceTypeProperties,
 			...tracingLevelProperties,
-			...parentPath ? { [require_dist.PARENT_SPAN_PATH]: parentPath } : {},
-			...parentIdsPath ? { [require_dist.PARENT_SPAN_IDS_PATH]: parentIdsPath } : {}
+			...parentPath ? { [require_utils.PARENT_SPAN_PATH]: parentPath } : {},
+			...parentIdsPath ? { [require_utils.PARENT_SPAN_IDS_PATH]: parentIdsPath } : {}
 		};
 		const span = new LaminarSpan(getTracer().startSpan(name, {
 			attributes,
@@ -2654,13 +2680,13 @@ var Laminar = class Laminar {
 	}
 	static async flush() {
 		if (this.isInitialized) {
-			logger$19.debug("Flushing spans");
+			logger$20.debug("Flushing spans");
 			await forceFlush();
 		}
 	}
 	static async shutdown() {
 		if (this.isInitialized) {
-			logger$19.debug("Shutting down Laminar");
+			logger$20.debug("Shutting down Laminar");
 			getRuntime()?.emitPointer();
 			await forceFlush();
 			this.isInitialized = false;
@@ -2795,7 +2821,7 @@ return module.exports;
 //#endregion
 //#region src/browser/utils.ts
 const LMNR_SEND_EVENTS_FUNCTION_NAME = "lmnrSendEvents";
-const logger$18 = require_dist.initializeLogger();
+const logger$19 = require_utils.initializeLogger();
 /**
 * If the first argument is a string, return an object with the name of the method
 * and the argument as the value.
@@ -2818,7 +2844,7 @@ const takeFullSnapshot = async (page) => await page.evaluate(() => {
 		window.lmnrRrweb.record.takeFullSnapshot();
 		return true;
 	} catch (error) {
-		logger$18.error("Error taking full snapshot: " + require_dist.errorMessage(error));
+		logger$19.error("Error taking full snapshot: " + require_utils.errorMessage(error));
 		return false;
 	}
 	return false;
@@ -2829,7 +2855,7 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 			try {
 				return await script();
 			} catch (error) {
-				logger$18.error("Operation " + script.name + " failed: " + require_dist.errorMessage(error));
+				logger$19.error("Operation " + script.name + " failed: " + require_utils.errorMessage(error));
 			}
 			await new Promise((resolve) => setTimeout(resolve, 500));
 		}
@@ -2839,20 +2865,20 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 	try {
 		isRrwebPresent = await castedPage.evaluate(() => typeof window.lmnrRrweb !== "undefined");
 	} catch (error) {
-		logger$18.debug("Failed to check if session recorder is loaded: " + require_dist.errorMessage(error));
+		logger$19.debug("Failed to check if session recorder is loaded: " + require_utils.errorMessage(error));
 	}
 	if (!isRrwebPresent) {
 		if (!await tryRunScript(async function injectSessionRecorder() {
 			await castedPage.evaluate(RECORDER);
 			return true;
 		})) {
-			logger$18.error("Failed to load session recorder");
+			logger$19.error("Failed to load session recorder");
 			return;
 		}
 		try {
 			await castedPage.evaluate(injectScript, sessionRecordingOptions);
 		} catch (error) {
-			logger$18.debug("Failed to inject session recorder: " + require_dist.errorMessage(error));
+			logger$19.debug("Failed to inject session recorder: " + require_utils.errorMessage(error));
 		}
 	}
 };
@@ -2941,9 +2967,9 @@ const modelToProviderMap = {
 	"gpt-4.1-mini": "openai",
 	"gpt-4.1-nano": "openai",
 	"o4-mini": "openai",
-	"o3": "openai",
+	o3: "openai",
 	"o3-mini": "openai",
-	"o1": "openai",
+	o1: "openai",
 	"o1-mini": "openai",
 	"gpt-4o": "openai",
 	"gpt-4o-mini": "openai",
@@ -3115,7 +3141,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 	try {
 		const { batchId, chunkIndex, totalChunks, data } = chunk;
 		if (!sessionId || !traceId) {
-			logger$18.debug("Missing sessionId or traceId in chunk");
+			logger$19.debug("Missing sessionId or traceId in chunk");
 			return;
 		}
 		if (!chunkBuffers.has(batchId)) chunkBuffers.set(batchId, {
@@ -3134,7 +3160,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 				traceId,
 				events
 			}).catch((error) => {
-				logger$18.debug("Failed to send events: " + require_dist.errorMessage(error));
+				logger$19.debug("Failed to send events: " + require_utils.errorMessage(error));
 			});
 			chunkBuffers.delete(batchId);
 		}
@@ -3142,19 +3168,19 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 		const toDelete = [];
 		for (const [bid, buffer] of chunkBuffers.entries()) if (currentTime - buffer.timestamp > OLD_BUFFER_TIMEOUT) toDelete.push(bid);
 		for (const bid of toDelete) {
-			logger$18.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
+			logger$19.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
 			chunkBuffers.delete(bid);
 		}
 	} catch (error) {
-		logger$18.debug("Could not send events: " + require_dist.errorMessage(error));
+		logger$19.debug("Could not send events: " + require_utils.errorMessage(error));
 	}
 }
 //#endregion
 //#region src/browser/playwright.ts
-const logger$17 = require_dist.initializeLogger();
+const logger$18 = require_utils.initializeLogger();
 var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
-		super("@lmnr/playwright-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/playwright-instrumentation", require_utils.version, { enabled: true });
 		this._patchedBrowsers = /* @__PURE__ */ new Set();
 		this._parentSpans = /* @__PURE__ */ new Map();
 		this._client = client;
@@ -3215,7 +3241,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 		const plugin = this;
 		return (original) => async function method(...args) {
 			const browser = await original.call(this, ...args);
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			for (const context of browser.contexts()) {
 				context.on("page", (page) => plugin.patchPage(page, sessionId));
 				for (const page of context.pages()) await plugin.patchPage(page, sessionId);
@@ -3229,7 +3255,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 		const plugin = this;
 		return (original) => async function method(...args) {
 			const context = await original.bind(this).apply(this, args);
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			context.on("page", async (page) => plugin.patchPage(page, sessionId));
 			for (const page of context.pages()) await plugin.patchPage(page, sessionId);
 			return context;
@@ -3252,14 +3278,14 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 			await takeFullSnapshot(page);
 		};
 		const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-		currentSpan?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+		currentSpan?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 		const otelTraceId = currentSpan?.spanContext().traceId;
-		const traceId = otelTraceId ? require_dist.otelTraceIdToUUID(otelTraceId) : require_dist.NIL_UUID;
+		const traceId = otelTraceId ? require_utils.otelTraceIdToUUID(otelTraceId) : require_utils.NIL_UUID;
 		page.on("domcontentloaded", async () => {
 			try {
 				await injectSessionRecorder(page, this._sessionRecordingOptions);
 			} catch (error) {
-				logger$17.error("Error in onLoad handler: " + require_dist.errorMessage(error));
+				logger$18.error("Error in onLoad handler: " + require_utils.errorMessage(error));
 			}
 		});
 		const chunkBuffers = /* @__PURE__ */ new Map();
@@ -3269,7 +3295,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$17.debug("Could not expose function lmnrSendEvents: " + require_dist.errorMessage(error));
+			logger$18.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
 		}
 	}
 };
@@ -3296,7 +3322,7 @@ const createLLMClientCreateChatCompletionWrapper = (globalLLMClientOptions) => (
 		const recordedProvider = globalLLMClientOptions.get(this)?.provider;
 		const provider = recordedProvider === "aisdk" && globalLLMClientOptions.get(this)?.model ? modelToProvider(globalLLMClientOptions.get(this).model) ?? "aisdk" : recordedProvider;
 		span.setAttributes({
-			[require_dist.SPAN_TYPE]: "LLM",
+			[require_utils.SPAN_TYPE]: "LLM",
 			...innerOptions.temperature ? { "gen_ai.request.temperature": innerOptions.temperature } : {},
 			...innerOptions.top_p ? { "gen_ai.request.top_p": innerOptions.top_p } : {},
 			...innerOptions.frequency_penalty ? { "gen_ai.request.frequency_penalty": innerOptions.frequency_penalty } : {},
@@ -3360,7 +3386,7 @@ const createLLMClientCreateChatCompletionWrapper = (globalLLMClientOptions) => (
 //#region src/browser/stagehand/v2.ts
 var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(playwrightInstrumentation) {
-		super("@lmnr/browserbase-stagehand-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/browserbase-stagehand-instrumentation", require_utils.version, { enabled: true });
 		this.globalLLMClientOptions = /* @__PURE__ */ new WeakMap();
 		this.globalAgentOptions = /* @__PURE__ */ new WeakMap();
 		this.stagehandInstanceToSessionId = /* @__PURE__ */ new WeakMap();
@@ -3434,7 +3460,7 @@ var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.In
 	patchStagehandInit() {
 		const instrumentation = this;
 		return (original) => async function method() {
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			const parentSpan = Laminar.startSpan({ name: "Stagehand" });
 			instrumentation.playwrightInstrumentation.setParentSpanForSession(sessionId, parentSpan);
 			const result = await original.bind(this).apply(this);
@@ -3694,10 +3720,10 @@ var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.In
 };
 //#endregion
 //#region src/browser/puppeteer.ts
-const logger$16 = require_dist.initializeLogger();
+const logger$17 = require_utils.initializeLogger();
 var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
-		super("@lmnr/puppeteer-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/puppeteer-instrumentation", require_utils.version, { enabled: true });
 		this._patchedBrowsers = /* @__PURE__ */ new Set();
 		this._client = client;
 		this._sessionRecordingOptions = sessionRecordingOptions;
@@ -3734,15 +3760,15 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		const plugin = this;
 		return (original) => async function method(...args) {
 			const browser = await original.call(this, ...args);
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			for (const context of browser.browserContexts()) {
 				context.on("targetcreated", (target) => {
 					target.page().then((page) => {
 						if (page) plugin.patchPage(page, sessionId).catch((error) => {
-							logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+							logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 						});
 					}).catch((error) => {
-						logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				});
 				await Promise.all((await context.pages()).map((page) => plugin.patchPage(page, sessionId)));
@@ -3756,23 +3782,23 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		const plugin = this;
 		return (original) => async function method(...args) {
 			const context = await original.bind(this).apply(this, args);
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			context.on("targetcreated", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+					logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 				});
 			});
 			context.on("targetchanged", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$16.error("Failed to patch page: " + require_dist.errorMessage(error));
+					logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
 				});
 			});
 			for (const page of await context.pages()) await plugin.patchPage(page, sessionId);
@@ -3791,12 +3817,12 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			await takeFullSnapshot(page);
 		};
 		const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-		currentSpan?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+		currentSpan?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 		const otelTraceId = currentSpan?.spanContext().traceId;
-		const traceId = otelTraceId ? require_dist.otelTraceIdToUUID(otelTraceId) : require_dist.NIL_UUID;
+		const traceId = otelTraceId ? require_utils.otelTraceIdToUUID(otelTraceId) : require_utils.NIL_UUID;
 		page.on("domcontentloaded", () => {
 			injectSessionRecorder(page, this._sessionRecordingOptions).catch((error) => {
-				logger$16.error("Error in onLoad handler: " + require_dist.errorMessage(error));
+				logger$17.error("Error in onLoad handler: " + require_utils.errorMessage(error));
 			});
 		});
 		await injectSessionRecorder(page, this._sessionRecordingOptions);
@@ -3806,13 +3832,13 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$16.debug("Could not expose function lmnrSendEvents: " + require_dist.errorMessage(error));
+			logger$17.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
 		}
 	}
 };
 //#endregion
 //#region src/browser/stagehand/v3/constants.ts
-const logger$15 = require_dist.initializeLogger();
+const logger$16 = require_utils.initializeLogger();
 const CDP_OPERATION_TIMEOUT_MS = 1e4;
 const SKIP_URL_PATTERNS = [
 	"about:blank",
@@ -3863,7 +3889,7 @@ async function getOrCreateIsolatedWorld(page) {
 			frameId
 		};
 	} catch (error) {
-		logger$15.debug("Failed to create isolated world: " + require_dist.errorMessage(error));
+		logger$16.debug("Failed to create isolated world: " + require_utils.errorMessage(error));
 		return null;
 	}
 }
@@ -3880,7 +3906,7 @@ async function isRecorderPresent(page, contextId) {
 		if (!result) return true;
 		return result.result?.value === true;
 	} catch (error) {
-		logger$15.debug("Failed to check if recorder is present: " + require_dist.errorMessage(error));
+		logger$16.debug("Failed to check if recorder is present: " + require_utils.errorMessage(error));
 		return true;
 	}
 }
@@ -3893,21 +3919,21 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 		try {
 			url = page.url();
 		} catch (error) {
-			logger$15.debug("Failed to get page URL, page might be closed: " + require_dist.errorMessage(error));
+			logger$16.debug("Failed to get page URL, page might be closed: " + require_utils.errorMessage(error));
 			return null;
 		}
 		if (shouldSkipUrl(url)) {
-			logger$15.debug(`Skipping recorder injection for URL: ${url}`);
+			logger$16.debug(`Skipping recorder injection for URL: ${url}`);
 			return null;
 		}
 		const worldResult = await getOrCreateIsolatedWorld(page);
 		if (!worldResult) {
-			logger$15.debug("Failed to get isolated world for page");
+			logger$16.debug("Failed to get isolated world for page");
 			return null;
 		}
 		const { contextId, frameId } = worldResult;
 		if (await isRecorderPresent(page, contextId)) {
-			logger$15.debug("Recorder already present, skipping injection");
+			logger$16.debug("Recorder already present, skipping injection");
 			state.contextIdToSession.set(contextId, {
 				sessionId: state.sessionId,
 				traceId: state.traceId
@@ -3920,7 +3946,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$15.debug("Failed to inject rrweb: " + require_dist.errorMessage(error));
+			logger$16.debug("Failed to inject rrweb: " + require_utils.errorMessage(error));
 			return null;
 		}
 		const optionsJson = JSON.stringify(sessionRecordingOptions ?? {});
@@ -3931,14 +3957,14 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$15.debug("Failed to inject recording setup: " + require_dist.errorMessage(error));
+			logger$16.debug("Failed to inject recording setup: " + require_utils.errorMessage(error));
 			return null;
 		}
 		try {
 			await sendCDP(page, "Runtime.addBinding", { name: "lmnrSendEvents" });
-			logger$15.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
+			logger$16.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
 		} catch (error) {
-			logger$15.debug("Binding may already exist: " + require_dist.errorMessage(error));
+			logger$16.debug("Binding may already exist: " + require_utils.errorMessage(error));
 		}
 		if (bindingHandler) try {
 			const pageTargetId = page.targetId();
@@ -3948,26 +3974,26 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 					const sessionTyped = session;
 					if (sessionTyped.on) {
 						sessionTyped.on("Runtime.bindingCalled", bindingHandler);
-						logger$15.debug(`Set up binding handler on session ${sessionId}`);
+						logger$16.debug(`Set up binding handler on session ${sessionId}`);
 					}
 				} catch (error) {
-					logger$15.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_dist.errorMessage(error));
+					logger$16.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_utils.errorMessage(error));
 				}
 				state.pageSessionHandlers.set(pageTargetId, bindingHandler);
 			}
 		} catch (error) {
-			logger$15.debug("Failed to set up binding handler: " + require_dist.errorMessage(error));
+			logger$16.debug("Failed to set up binding handler: " + require_utils.errorMessage(error));
 		}
 		state.contextIdToSession.set(contextId, {
 			sessionId: state.sessionId,
 			traceId: state.traceId
 		});
-		logger$15.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
+		logger$16.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
 		state.instrumentedPageIds.add(frameId);
-		logger$15.debug(`Successfully injected recorder into page ${frameId}`);
+		logger$16.debug(`Successfully injected recorder into page ${frameId}`);
 		return contextId;
 	} catch (error) {
-		logger$15.debug("Error injecting recorder: " + require_dist.errorMessage(error));
+		logger$16.debug("Error injecting recorder: " + require_utils.errorMessage(error));
 		return null;
 	}
 }
@@ -3981,13 +4007,13 @@ function createBindingHandler(state) {
 		if (event.name !== "lmnrSendEvents") return;
 		const sessionInfo = state.contextIdToSession.get(event.executionContextId);
 		if (!sessionInfo) {
-			logger$15.debug("No session info found for context ID: " + event.executionContextId);
+			logger$16.debug("No session info found for context ID: " + event.executionContextId);
 			if (state.contextIdToSession.size > 0) {
 				const [, fallbackInfo] = state.contextIdToSession.entries().next().value;
 				if (fallbackInfo) try {
 					sendEvents(JSON.parse(event.payload), state.client, state.chunkBuffers, fallbackInfo.sessionId, fallbackInfo.traceId);
 				} catch (error) {
-					logger$15.debug("Failed to parse binding payload: " + require_dist.errorMessage(error));
+					logger$16.debug("Failed to parse binding payload: " + require_utils.errorMessage(error));
 				}
 			}
 			return;
@@ -3995,7 +4021,7 @@ function createBindingHandler(state) {
 		try {
 			sendEvents(JSON.parse(event.payload), state.client, state.chunkBuffers, sessionInfo.sessionId, sessionInfo.traceId);
 		} catch (error) {
-			logger$15.debug("Failed to handle binding event: " + require_dist.errorMessage(error));
+			logger$16.debug("Failed to handle binding event: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4011,10 +4037,10 @@ function createTargetCreatedHandler(context, state, sessionRecordingOptions) {
 				const pageId = page.mainFrameId();
 				if (!state.instrumentedPageIds.has(pageId)) await injectRecorderViaCDP(page, state, context.conn, sessionRecordingOptions, state.bindingHandler ?? void 0);
 			} catch (error) {
-				logger$15.debug("Error injecting recorder into new page: " + require_dist.errorMessage(error));
+				logger$16.debug("Error injecting recorder into new page: " + require_utils.errorMessage(error));
 			}
 		} catch (error) {
-			logger$15.debug("Error handling target created event: " + require_dist.errorMessage(error));
+			logger$16.debug("Error handling target created event: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4026,7 +4052,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 		if (event.targetInfo.type !== "page") return;
 		const url = event.targetInfo.url;
 		if (shouldSkipUrl(url)) return;
-		logger$15.debug(`Target URL changed to ${url}, checking if recorder injection needed`);
+		logger$16.debug(`Target URL changed to ${url}, checking if recorder injection needed`);
 		await new Promise((resolve) => setTimeout(resolve, 150));
 		try {
 			for (const page of context.pages()) if (page.targetId() === event.targetInfo.targetId) {
@@ -4034,7 +4060,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 				break;
 			}
 		} catch (error) {
-			logger$15.debug("Error handling target info change: " + require_dist.errorMessage(error));
+			logger$16.debug("Error handling target info change: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4065,7 +4091,7 @@ const safeUnwrap = (instrumentation, target, methodName) => {
 };
 var StagehandInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(sessionRecordingOptions) {
-		super("@lmnr/browserbase-stagehand-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/browserbase-stagehand-instrumentation", require_utils.version, { enabled: true });
 		this.stagehandInstanceToSessionId = /* @__PURE__ */ new WeakMap();
 		this.globalLLMClientOptions = /* @__PURE__ */ new WeakMap();
 		this.globalAgentOptions = /* @__PURE__ */ new WeakMap();
@@ -4159,13 +4185,13 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	patchStagehandInit() {
 		const instrumentation = this;
 		return (original) => async function method() {
-			const sessionId = require_dist.newUUID();
+			const sessionId = require_utils.newUUID();
 			const parentSpan = Laminar.startSpan({ name: "Stagehand" });
 			instrumentation.sessionIdToParentSpan.set(sessionId, parentSpan);
 			instrumentation.stagehandInstanceToSessionId.set(this, sessionId);
-			(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+			(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 			const otelTraceId = parentSpan.spanContext().traceId;
-			const traceId = require_dist.otelTraceIdToUUID(otelTraceId);
+			const traceId = require_utils.otelTraceIdToUUID(otelTraceId);
 			const result = await original.bind(this).apply(this);
 			safeWrap(instrumentation, this, "act", instrumentation.patchStagehandGlobalMethod("act", sessionId, parentSpan));
 			safeWrap(instrumentation, this, "extract", instrumentation.patchStagehandGlobalMethod("extract", sessionId, parentSpan));
@@ -4195,12 +4221,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	*/
 	async setupSessionRecording(stagehandInstance, sessionId, traceId) {
 		if (!this._client) {
-			logger$15.debug("No Laminar client available, skipping session recording setup");
+			logger$16.debug("No Laminar client available, skipping session recording setup");
 			return;
 		}
 		const context = stagehandInstance.context;
 		if (!context || !context.conn) {
-			logger$15.debug("No context or connection available, skipping session recording setup");
+			logger$16.debug("No context or connection available, skipping session recording setup");
 			return;
 		}
 		const recorderState = {
@@ -4230,11 +4256,11 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			for (const page of pages) try {
 				if (await injectRecorderViaCDP(page, recorderState, context.conn, this._sessionRecordingOptions, bindingHandler) !== null) injectedCount++;
 			} catch (error) {
-				logger$15.debug("Error injecting recorder into page: " + require_dist.errorMessage(error));
+				logger$16.debug("Error injecting recorder into page: " + require_utils.errorMessage(error));
 			}
-			logger$15.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
+			logger$16.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
 		} catch (error) {
-			logger$15.debug("Error accessing pages for recorder injection: " + require_dist.errorMessage(error));
+			logger$16.debug("Error accessing pages for recorder injection: " + require_utils.errorMessage(error));
 		}
 	}
 	patchStagehandClose() {
@@ -4264,12 +4290,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			if (recorderState.targetCreatedHandler) try {
 				context.conn.off("Target.targetCreated", recorderState.targetCreatedHandler);
 			} catch (error) {
-				logger$15.debug("Error removing target created handler: " + require_dist.errorMessage(error));
+				logger$16.debug("Error removing target created handler: " + require_utils.errorMessage(error));
 			}
 			if (recorderState.targetInfoChangedHandler) try {
 				context.conn.off("Target.targetInfoChanged", recorderState.targetInfoChangedHandler);
 			} catch (error) {
-				logger$15.debug("Error removing target info changed handler: " + require_dist.errorMessage(error));
+				logger$16.debug("Error removing target info changed handler: " + require_utils.errorMessage(error));
 			}
 		}
 		recorderState.contextIdToSession.clear();
@@ -4280,7 +4306,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		recorderState.targetCreatedHandler = null;
 		recorderState.targetInfoChangedHandler = null;
 		this.stagehandInstanceToRecorderState.delete(stagehandInstance);
-		logger$15.debug("Cleaned up session recording for Stagehand instance");
+		logger$16.debug("Cleaned up session recording for Stagehand instance");
 	}
 	patchStagehandGlobalMethod(methodName, sessionId, parentSpan) {
 		return (original) => async function method(...args) {
@@ -4310,7 +4336,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				name: `stagehand.${methodName}`,
 				input
 			}, async (thisArg, rest) => {
-				(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+				(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 				return await original.apply(thisArg, rest);
 			}, this, args));
 		};
@@ -4420,7 +4446,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				spanType: "LLM"
 			}, async () => {
 				const span = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-				span?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+				span?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 				const agentOptions = instrumentation.globalAgentOptions.get(this);
 				const maybeModelName = agentOptions?.model?.modelName ?? (typeof agentOptions?.model === "string" ? agentOptions.model : void 0);
 				const provider = agentOptions?.model?.provider ?? (maybeModelName?.includes("/") ? maybeModelName?.split("/")[0] : instrumentation.globalLLMClientOptions.get(this)?.provider);
@@ -4505,12 +4531,11 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	* LLM-backed calls and surface token usage from the response where available.
 	*/
 	patchStagehandApiClient(apiClient, parentSpan, stagehandInstance) {
-		const instrumentation = this;
 		let baseProvider = stagehandInstance?.llmClient?.type;
 		const baseModel = stagehandInstance?.llmClient?.modelName;
 		if (baseModel && !baseProvider) baseProvider = modelToProvider(baseModel) ?? "aisdk";
 		const wrapApiMethod = (methodName) => {
-			safeWrap(instrumentation, apiClient, methodName, (original) => async function method(...args) {
+			safeWrap(this, apiClient, methodName, (original) => async function method(...args) {
 				const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
 				const input = nameArgsOrCopy(args);
 				const spanName = `stagehand.apiClient.${methodName}`;
@@ -4522,7 +4547,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 					ignoreOutput: true
 				}, async () => {
 					const span = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-					span?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
+					span?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
 					if (baseProvider) span?.setAttribute("gen_ai.system", baseProvider);
 					if (baseModel) span?.setAttribute("gen_ai.request.model", baseModel);
 					try {
@@ -4793,7 +4818,7 @@ const WRAPPED_SYMBOL = Symbol("lmnr.google-genai.wrapped");
 const CLASS_PATCH_DATA_SYMBOL = Symbol("lmnr.google-genai.classPatchData");
 var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(config) {
-		super("@lmnr/google-genai-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/google-genai-instrumentation", require_utils.version, { enabled: true });
 		this.traceContent = config?.traceContent ?? true;
 	}
 	init() {
@@ -4923,7 +4948,6 @@ const WRAPPED_BROWSER_METHODS = [
 	"create",
 	"retrieve",
 	"list",
-	"delete",
 	"deleteByID",
 	"loadExtensions"
 ];
@@ -4946,7 +4970,7 @@ const WRAPPED_PROCESS_METHODS = [
 ];
 var KernelInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor() {
-		super("@lmnr/kernel-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/kernel-instrumentation", require_utils.version, { enabled: true });
 	}
 	init() {
 		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@onkernel/sdk", [">=0.7.0"], this.patch.bind(this), this.unpatch.bind(this));
@@ -5151,10 +5175,10 @@ const normalizeMessages = (data, role = "user") => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/messages.ts
-const logger$14 = require_dist.initializeLogger();
+const logger$15 = require_utils.initializeLogger();
 const setLmnrSpanIo = (lmnrSpan, inputData, outputData) => {
-	if (inputData !== void 0 && inputData !== null) lmnrSpan.setAttribute(require_dist.SPAN_INPUT, JSON.stringify(inputData));
-	if (outputData !== void 0 && outputData !== null) lmnrSpan.setAttribute(require_dist.SPAN_OUTPUT, JSON.stringify(outputData));
+	if (inputData !== void 0 && inputData !== null) lmnrSpan.setAttribute(require_utils.SPAN_INPUT, JSON.stringify(inputData));
+	if (outputData !== void 0 && outputData !== null) lmnrSpan.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(outputData));
 };
 const setGenAiInputMessages = (lmnrSpan, inputData, systemInstructions) => {
 	const hasInput = inputData !== void 0 && inputData !== null;
@@ -5180,7 +5204,7 @@ const setGenAiOutputMessagesFromResponse = (lmnrSpan, response) => {
 	if (!outputItems) return;
 	const id = response.id;
 	if (!Array.isArray(outputItems)) {
-		logger$14.debug("Laminar OpenAI agents instrumentation, failed to parse output items. Expected array");
+		logger$15.debug("Laminar OpenAI agents instrumentation, failed to parse output items. Expected array");
 		outputItems = [];
 	}
 	const result = {
@@ -5217,9 +5241,9 @@ const applyLlmAttributes = (lmnrSpan, data) => {
 	if (!data) return;
 	const model = data.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
 	}
 	const usage = data.usage;
 	if (usage != null) applyUsage$1(lmnrSpan, usage);
@@ -5238,12 +5262,12 @@ const applyUsage$1 = (lmnrSpan, usage) => {
 	let reasoningOutputTokens;
 	if (inputTokensDetails?.cached_tokens !== void 0 && inputTokensDetails?.cached_tokens !== null) cachedInputTokens = Number(inputTokensDetails.cached_tokens);
 	if (outputTokensDetails?.reasoning_tokens !== void 0 && outputTokensDetails?.reasoning_tokens !== null) reasoningOutputTokens = Number(outputTokensDetails.reasoning_tokens);
-	if (inputTokens !== void 0 && inputTokens !== null) lmnrSpan.setAttribute(require_dist.LaminarAttributes.INPUT_TOKEN_COUNT, Number(inputTokens));
+	if (inputTokens !== void 0 && inputTokens !== null) lmnrSpan.setAttribute(require_utils.LaminarAttributes.INPUT_TOKEN_COUNT, Number(inputTokens));
 	if (cachedInputTokens !== void 0) lmnrSpan.setAttribute("gen_ai.usage.cache_read_input_tokens", cachedInputTokens);
-	if (outputTokens !== void 0 && outputTokens !== null) lmnrSpan.setAttribute(require_dist.LaminarAttributes.OUTPUT_TOKEN_COUNT, Number(outputTokens));
+	if (outputTokens !== void 0 && outputTokens !== null) lmnrSpan.setAttribute(require_utils.LaminarAttributes.OUTPUT_TOKEN_COUNT, Number(outputTokens));
 	if (reasoningOutputTokens !== void 0) lmnrSpan.setAttribute("gen_ai.usage.reasoning_output_tokens", reasoningOutputTokens);
-	if (totalTokens !== void 0 && totalTokens !== null) lmnrSpan.setAttribute(require_dist.LaminarAttributes.TOTAL_TOKEN_COUNT, Number(totalTokens));
-	else if (inputTokens !== void 0 && inputTokens !== null && outputTokens !== void 0 && outputTokens !== null) lmnrSpan.setAttribute(require_dist.LaminarAttributes.TOTAL_TOKEN_COUNT, Number(inputTokens) + Number(outputTokens));
+	if (totalTokens !== void 0 && totalTokens !== null) lmnrSpan.setAttribute(require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT, Number(totalTokens));
+	else if (inputTokens !== void 0 && inputTokens !== null && outputTokens !== void 0 && outputTokens !== null) lmnrSpan.setAttribute(require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT, Number(inputTokens) + Number(outputTokens));
 };
 const responseToLlmData = (response) => {
 	if (response == null) return {};
@@ -5344,9 +5368,9 @@ const applyMcpSpanData = (lmnrSpan, spanData) => {
 const applySpeechSpanData = (lmnrSpan, spanData) => {
 	const model = spanData?.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
 	}
 	const inputText = spanData?.input;
 	if (inputText) setGenAiInputMessages(lmnrSpan, inputText);
@@ -5357,9 +5381,9 @@ const applySpeechSpanData = (lmnrSpan, spanData) => {
 const applyTranscriptionSpanData = (lmnrSpan, spanData) => {
 	const model = spanData?.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
 	}
 	const inputData = spanData?.input;
 	if (inputData) if (typeof inputData === "object" && !Array.isArray(inputData)) setGenAiInputMessages(lmnrSpan, inputData.data);
@@ -5375,7 +5399,7 @@ const applySpeechGroupSpanData = (lmnrSpan, spanData) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/processor.ts
-const logger$13 = require_dist.initializeLogger();
+const logger$14 = require_utils.initializeLogger();
 var LaminarAgentsTraceProcessor = class {
 	constructor() {
 		this.traces = /* @__PURE__ */ new Map();
@@ -5393,7 +5417,7 @@ var LaminarAgentsTraceProcessor = class {
 			} catch {}
 			this.applyTraceMetadata(state.rootSpan, agentsTrace);
 		} catch (e) {
-			logger$13.debug(`Error in onTraceStart: ${String(e)}`);
+			logger$14.debug(`Error in onTraceStart: ${String(e)}`);
 		}
 	}
 	async onTraceEnd(agentsTrace) {
@@ -5442,7 +5466,7 @@ var LaminarAgentsTraceProcessor = class {
 			});
 			const key = span.spanId;
 			if (!key) {
-				logger$13.debug("Span missing spanId, cannot track");
+				logger$14.debug("Span missing spanId, cannot track");
 				try {
 					lmnrSpan.end();
 				} catch {}
@@ -5461,7 +5485,7 @@ var LaminarAgentsTraceProcessor = class {
 				activationContext
 			});
 		} catch (e) {
-			logger$13.debug(`Error in onSpanStart: ${String(e)}`);
+			logger$14.debug(`Error in onSpanStart: ${String(e)}`);
 			if (lmnrSpan !== void 0) try {
 				lmnrSpan.end();
 			} catch {}
@@ -5579,7 +5603,7 @@ var LaminarAgentsTraceProcessor = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/index.ts
-const logger$12 = require_dist.initializeLogger();
+const logger$13 = require_utils.initializeLogger();
 const wrapGetResponse = (original) => function(request, ...rest) {
 	const systemInstructions = request?.systemInstructions;
 	return runWithSystemInstructions(systemInstructions, () => original.call(this, request, ...rest));
@@ -5591,7 +5615,7 @@ const wrapGetStreamedResponse = (original) => function(request, ...rest) {
 const MODEL_METHODS = ["getResponse", "getStreamedResponse"];
 var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor() {
-		super("@lmnr/openai-agents-instrumentation", require_dist.version, { enabled: true });
+		super("@lmnr/openai-agents-instrumentation", require_utils.version, { enabled: true });
 		this._wrappedPrototypes = /* @__PURE__ */ new WeakSet();
 	}
 	init() {
@@ -5599,7 +5623,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 	}
 	manuallyInstrument(agentsModule) {
 		if (!agentsModule) {
-			logger$12.debug("@openai/agents module not provided, skipping");
+			logger$13.debug("@openai/agents module not provided, skipping");
 			return;
 		}
 		this.registerProcessor(agentsModule);
@@ -5609,7 +5633,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 		if (this._processor !== void 0) return;
 		const addTraceProcessor = module.addTraceProcessor;
 		if (typeof addTraceProcessor !== "function") {
-			logger$12.debug("addTraceProcessor not found in @openai/agents module");
+			logger$13.debug("addTraceProcessor not found in @openai/agents module");
 			return;
 		}
 		try {
@@ -5617,7 +5641,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 			addTraceProcessor(processor);
 			this._processor = processor;
 		} catch (e) {
-			logger$12.debug(`Failed to register Laminar Agents processor: ${String(e)}`);
+			logger$13.debug(`Failed to register Laminar Agents processor: ${String(e)}`);
 		}
 	}
 	patchModel(module) {
@@ -5630,7 +5654,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 				try {
 					this._wrap(cls.prototype, method, wrapper);
 				} catch (e) {
-					logger$12.debug(`Failed to wrap ${method}: ${String(e)}`);
+					logger$13.debug(`Failed to wrap ${method}: ${String(e)}`);
 				}
 			}
 			this._wrappedPrototypes.add(cls.prototype);
@@ -5670,7 +5694,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 //#region src/opentelemetry-lib/instrumentation/opencode.ts
 var OpencodeInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor() {
-		super("lmnr-opencode-instrumentation", require_dist.version, { enabled: true });
+		super("lmnr-opencode-instrumentation", require_utils.version, { enabled: true });
 	}
 	init() {
 		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@opencode-ai/sdk", [">=1.0.0"], this.patch.bind(this), this.unpatch.bind(this));
@@ -5735,8 +5759,115 @@ const getLangVersion = () => {
 	if (process?.versions?.node) return `node@${process.versions.node}`;
 };
 //#endregion
+//#region src/opentelemetry-lib/tracing/batch-processor.ts
+const logger$12 = require_utils.initializeLogger();
+/**
+* Non-string attribute values (numbers, booleans) are counted as a flat 8 bytes
+* instead of being measured — they never dominate a GenAI payload.
+*/
+const FIXED_ATTRIBUTE_VALUE_SIZE = 8;
+const valueSize = (value) => {
+	if (typeof value === "string") return utf8Size(value);
+	if (Array.isArray(value)) return value.reduce((total, item) => total + valueSize(item), 0);
+	return FIXED_ATTRIBUTE_VALUE_SIZE;
+};
+const attributesSize = (attributes) => {
+	if (!attributes) return 0;
+	return Object.entries(attributes).reduce((total, [key, value]) => total + utf8Size(key) + valueSize(value), 0);
+};
+/**
+* Byte length of `value` encoded as UTF-8.
+*
+* `.length` counts UTF-16 code units, which undercounts CJK by ~3x and
+* Cyrillic/Arabic/emoji by ~2x — on GenAI payloads that made a batch several
+* times the configured limit, the exact oversized-export case this limit exists
+* to prevent.
+*
+* Unlike the Python SDK, which samples a strided subset of long strings, this
+* measures exactly. `Buffer.byteLength` walks the string in native code without
+* allocating the encoded bytes, so it is both cheaper and more accurate than
+* sampling here: measured ~27us on a 20k-character CJK string, against ~16us for
+* a sampled estimate that was also *wrong* for emoji (+11.7%, because indexing a
+* string splits surrogate pairs and each half encodes as U+FFFD). Python has no
+* equivalent primitive — `len(s.encode())` allocates the whole encoded copy —
+* which is the only reason it samples.
+*/
+const utf8Size = (value) => Buffer.byteLength(value, "utf8");
+/**
+* Approximate the exported size of a span, in bytes.
+*
+* Deliberately an underestimate: protobuf framing, ids and timestamps are
+* ignored, and non-string values are counted flat. Underestimating small spans
+* is fine — the count and schedule-delay limits fire first for those. What
+* matters is that a span carrying a large prompt or completion is measured close
+* to its real weight.
+*/
+const approximateSpanSize = (span) => {
+	let total = utf8Size(span.name ?? "");
+	total += attributesSize(span.attributes);
+	for (const event of span.events ?? []) total += utf8Size(event.name ?? "") + attributesSize(event.attributes);
+	for (const link of span.links ?? []) total += attributesSize(link.attributes);
+	if (span.status?.message) total += utf8Size(span.status.message);
+	return total;
+};
+/**
+* `BatchSpanProcessor` with a third, size-based flush trigger.
+*
+* Opt-in via `Laminar.initialize({ flushBySize: true })`; the default transport
+* is the plain upstream `BatchSpanProcessor`.
+*
+* Upstream flushes on whichever comes first: `maxExportBatchSize` spans
+* buffered, or `scheduledDelayMillis` elapsed. Neither bounds the *payload*, so
+* a handful of large GenAI spans can produce an export big enough for the
+* backend to reject. This adds `maxExportBatchSizeBytes`: when the span being
+* ended would push the buffer past the limit, the buffer is flushed first and
+* the span then starts a fresh batch.
+*
+* The Python SDK needs considerably more machinery for this — a dedicated flush
+* thread, a lock around the running total, a fork handler, and an inline
+* fallback for backpressure — none of which is needed here, because the two
+* runtimes behave differently in three ways:
+*
+* 1. `forceFlush()` moves the buffered spans out synchronously and only *awaits*
+*    the network, so calling it from `onEnd` never blocks the caller (measured:
+*    0.34ms worst case against a 300ms export). Python's `force_flush` performs
+*    the export itself on the calling thread, which load testing measured at a
+*    p99 of ~664ms and is why it needs a background thread.
+* 2. Because the flush is synchronous with respect to the buffer, the batch stays
+*    bounded even when a producer emits in a tight loop, so no inline-fallback
+*    backpressure path is needed. Python's asynchronous handoff can be outrun.
+* 3. `onEnd` calls `super.onEnd(span)` *after* flushing, so the triggering span
+*    is genuinely excluded from the batch it caused. Python cannot do this — its
+*    flush is asynchronous, so the triggering span rides along, which is why it
+*    needs a separate "span is at least half the limit" rule to bound overshoot.
+*    Here a batch never exceeds the limit by more than the last span under it.
+*
+* Single-threaded event loop, so no lock guards the running total, and there is
+* no `fork` story to handle.
+*/
+var SizeLimitedBatchSpanProcessor = class extends _opentelemetry_sdk_trace_base.BatchSpanProcessor {
+	constructor(exporter, config) {
+		super(exporter, config);
+		this.pendingSizeBytes = 0;
+		this.maxExportBatchSizeBytes = config?.maxExportBatchSizeBytes ?? 33554432;
+	}
+	onEnd(span) {
+		if ((span.spanContext().traceFlags & _opentelemetry_api.TraceFlags.SAMPLED) === 0) {
+			super.onEnd(span);
+			return;
+		}
+		const size = approximateSpanSize(span);
+		const shouldFlush = this.pendingSizeBytes > 0 && this.pendingSizeBytes + size > this.maxExportBatchSizeBytes;
+		this.pendingSizeBytes = shouldFlush ? size : this.pendingSizeBytes + size;
+		if (shouldFlush) this.forceFlush().catch((error) => {
+			logger$12.debug(`Size-triggered span flush failed: ${String(error)}`);
+		});
+		super.onEnd(span);
+	}
+};
+//#endregion
 //#region src/opentelemetry-lib/tracing/exporter.ts
-const logger$11 = require_dist.initializeLogger();
+const logger$11 = require_utils.initializeLogger();
 var LaminarSpanExporter = class {
 	constructor(options = {}) {
 		let url = options.baseUrl ?? process?.env?.LMNR_BASE_URL;
@@ -5745,15 +5876,15 @@ var LaminarSpanExporter = class {
 		const key = options.apiKey ?? process?.env?.LMNR_PROJECT_API_KEY;
 		let headers = {};
 		if (key) {
-			headers = forceHttp ? { "Authorization": `Bearer ${key}` } : { "authorization": `Bearer ${key}` };
+			headers = forceHttp ? { Authorization: `Bearer ${key}` } : { authorization: `Bearer ${key}` };
 			if (!url) url = "https://api.lmnr.ai";
 		} else {
-			const otelHeaders = require_dist.getOtelEnvVar("HEADERS");
-			if (otelHeaders) headers = require_dist.parseOtelHeaders(otelHeaders);
-			const otelEndpoint = require_dist.getOtelEnvVar("ENDPOINT");
+			const otelHeaders = require_utils.getOtelEnvVar("HEADERS");
+			if (otelHeaders) headers = require_utils.parseOtelHeaders(otelHeaders);
+			const otelEndpoint = require_utils.getOtelEnvVar("ENDPOINT");
 			if (otelEndpoint && !url) {
 				url = otelEndpoint;
-				const otelProtocol = require_dist.getOtelEnvVar("PROTOCOL") || "grpc/protobuf";
+				const otelProtocol = require_utils.getOtelEnvVar("PROTOCOL") || "grpc/protobuf";
 				const otelExporter = process?.env?.OTEL_EXPORTER;
 				forceHttp = otelProtocol === "http/protobuf" || otelProtocol === "http/json" || otelExporter === "otlp_http";
 			} else if (otelEndpoint && url) logger$11.warn("OTEL_ENDPOINT is set, but Laminar base URL is also set. Ignoring OTEL_ENDPOINT.");
@@ -5810,7 +5941,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 	constructor(options = {}) {
 		this._spanIdToPath = /* @__PURE__ */ new Map();
 		this._spanIdLists = /* @__PURE__ */ new Map();
-		this.logger = require_dist.initializeLogger();
+		this.logger = require_utils.initializeLogger();
 		if (options.spanProcessor && options.spanProcessor instanceof LaminarSpanProcessor) {
 			this.instance = options.spanProcessor.instance;
 			this._spanIdToPath = options.spanProcessor._spanIdToPath;
@@ -5818,10 +5949,16 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 		} else if (options.spanProcessor) this.instance = options.spanProcessor;
 		else {
 			const exporter = options.exporter ?? new LaminarSpanExporter(options);
-			this.instance = options.disableBatch ? new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter) : new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter, {
+			const batchConfig = {
 				maxExportBatchSize: options.maxExportBatchSize ?? 512,
 				exportTimeoutMillis: options.traceExportTimeoutMillis ?? 3e4
+			};
+			if (options.disableBatch) this.instance = new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter);
+			else if (options.flushBySize) this.instance = new SizeLimitedBatchSpanProcessor(exporter, {
+				...batchConfig,
+				maxExportBatchSizeBytes: options.maxExportBatchSizeBytes
 			});
+			else this.instance = new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter, batchConfig);
 		}
 	}
 	forceFlush() {
@@ -5832,37 +5969,37 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 	}
 	onStart(spanArg, parentContext) {
 		const span = spanArg;
-		const parentPathFromAttribute = span.attributes?.[require_dist.PARENT_SPAN_PATH];
-		const parentIdsPathFromAttribute = span.attributes?.[require_dist.PARENT_SPAN_IDS_PATH];
+		const parentPathFromAttribute = span.attributes?.[require_utils.PARENT_SPAN_PATH];
+		const parentIdsPathFromAttribute = span.attributes?.[require_utils.PARENT_SPAN_IDS_PATH];
 		const parentSpanId = getParentSpanId(span);
 		const parentSpanPath = parentPathFromAttribute ?? (parentSpanId !== void 0 ? this._spanIdToPath.get(parentSpanId) : void 0);
 		const spanId = span.spanContext().spanId;
-		const parentSpanIdsPath = parentIdsPathFromAttribute ?? (parentSpanId ? this._spanIdLists.get(parentSpanId) ?? [require_dist.otelSpanIdToUUID(parentSpanId)] : []);
+		const parentSpanIdsPath = parentIdsPathFromAttribute ?? (parentSpanId ? this._spanIdLists.get(parentSpanId) ?? [require_utils.otelSpanIdToUUID(parentSpanId)] : []);
 		const spanPath = parentSpanPath ? [...parentSpanPath, span.name] : [span.name];
-		const spanIdUuid = require_dist.otelSpanIdToUUID(spanId);
+		const spanIdUuid = require_utils.otelSpanIdToUUID(spanId);
 		const spanIdsPath = parentSpanIdsPath ? [...parentSpanIdsPath, spanIdUuid] : [spanIdUuid];
-		span.setAttribute(require_dist.SPAN_IDS_PATH, spanIdsPath);
+		span.setAttribute(require_utils.SPAN_IDS_PATH, spanIdsPath);
 		this._spanIdLists.set(spanId, spanIdsPath);
-		span.setAttribute(require_dist.SPAN_PATH, spanPath);
+		span.setAttribute(require_utils.SPAN_PATH, spanPath);
 		_opentelemetry_api.context.active().setValue(CONTEXT_SPAN_PATH_KEY, spanPath);
 		this._spanIdToPath.set(spanId, spanPath);
-		span.setAttribute(require_dist.SPAN_INSTRUMENTATION_SOURCE, "javascript");
-		span.setAttribute(require_dist.SPAN_SDK_VERSION, require_dist.version);
+		span.setAttribute(require_utils.SPAN_INSTRUMENTATION_SOURCE, "javascript");
+		span.setAttribute(require_utils.SPAN_SDK_VERSION, require_utils.version);
 		const langVersion = getLangVersion();
-		if (langVersion) span.setAttribute(require_dist.SPAN_LANGUAGE_VERSION, langVersion);
+		if (langVersion) span.setAttribute(require_utils.SPAN_LANGUAGE_VERSION, langVersion);
 		const globalMetadata = LaminarContextManager.getGlobalMetadata();
-		if (globalMetadata && Object.keys(globalMetadata).length > 0) span.setAttributes(require_dist.metadataToAttributes(globalMetadata));
+		if (globalMetadata && Object.keys(globalMetadata).length > 0) span.setAttributes(require_utils.metadataToAttributes(globalMetadata));
 		const associationProperties = _opentelemetry_api.context.active().getValue(ASSOCIATION_PROPERTIES_KEY);
-		if (associationProperties) for (const [key, value] of Object.entries(associationProperties)) if (Object.keys(require_dist.ASSOCIATION_PROPERTIES_OVERRIDES).includes(key)) span.setAttribute(require_dist.ASSOCIATION_PROPERTIES_OVERRIDES[key], value);
+		if (associationProperties) for (const [key, value] of Object.entries(associationProperties)) if (Object.keys(require_utils.ASSOCIATION_PROPERTIES_OVERRIDES).includes(key)) span.setAttribute(require_utils.ASSOCIATION_PROPERTIES_OVERRIDES[key], value);
 		else if (key === "tracing_level") span.setAttribute("lmnr.internal.tracing_level", value);
 		else if (key === "metadata" && typeof value === "object" && value !== null) {
-			const metadataAttrs = require_dist.metadataToAttributes(value);
+			const metadataAttrs = require_utils.metadataToAttributes(value);
 			span.setAttributes(metadataAttrs);
-		} else if (key === "userId") span.setAttribute(require_dist.USER_ID, value);
-		else if (key === "sessionId") span.setAttribute(require_dist.SESSION_ID, value);
-		else if (key === "traceType") span.setAttribute(require_dist.TRACE_TYPE, value);
+		} else if (key === "userId") span.setAttribute(require_utils.USER_ID, value);
+		else if (key === "sessionId") span.setAttribute(require_utils.SESSION_ID, value);
+		else if (key === "traceType") span.setAttribute(require_utils.TRACE_TYPE, value);
 		else if (key === "tracingLevel") span.setAttribute("lmnr.internal.tracing_level", value);
-		else span.setAttribute(`${require_dist.ASSOCIATION_PROPERTIES}.${key}`, value);
+		else span.setAttribute(`${require_utils.ASSOCIATION_PROPERTIES}.${key}`, value);
 		makeSpanOtelV2Compatible(span);
 		if (parentSpanId === void 0) this.recordDebugTraceId(span);
 		this.instance.onStart(span, parentContext);
@@ -5876,7 +6013,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 		try {
 			const runtime = getRuntime();
 			if (runtime === null) return;
-			runtime.recordTraceId(require_dist.otelTraceIdToUUID(span.spanContext().traceId));
+			runtime.recordTraceId(require_utils.otelTraceIdToUUID(span.spanContext().traceId));
 		} catch (e) {
 			this.logger.debug(`Failed to record debug trace id: ${String(e)}`);
 		}
@@ -5917,7 +6054,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/temporal/helpers.ts
-const logger$10 = require_dist.initializeLogger();
+const logger$10 = require_utils.initializeLogger();
 const _enc = new TextEncoder();
 const _dec = new TextDecoder();
 const encodePayload = (value) => ({
@@ -5969,13 +6106,13 @@ const restoreContextFromHeaders = (headers) => {
 	if (!headers) return void 0;
 	const laminarRaw = decodePayload(headers[require_consts.LAMINAR_SPAN_CONTEXT_HEADER]);
 	if (laminarRaw) try {
-		const ctx = require_dist.deserializeLaminarSpanContext(laminarRaw);
+		const ctx = require_utils.deserializeLaminarSpanContext(laminarRaw);
 		return {
 			laminarCtx: ctx,
 			otelContext: pushLaminarContext(ctx)
 		};
 	} catch (e) {
-		logger$10.warn(`[Laminar] Could not restore ${require_consts.LAMINAR_SPAN_CONTEXT_HEADER}: ${require_dist.errorMessage(e)}`);
+		logger$10.warn(`[Laminar] Could not restore ${require_consts.LAMINAR_SPAN_CONTEXT_HEADER}: ${require_utils.errorMessage(e)}`);
 	}
 	const traceparent = decodePayload(headers[require_consts.TRACEPARENT_HEADER]);
 	if (traceparent) {
@@ -5984,8 +6121,8 @@ const restoreContextFromHeaders = (headers) => {
 			const [, traceHex, spanHex] = parts;
 			try {
 				const ctx = {
-					traceId: require_dist.otelTraceIdToUUID(traceHex),
-					spanId: require_dist.otelSpanIdToUUID(spanHex),
+					traceId: require_utils.otelTraceIdToUUID(traceHex),
+					spanId: require_utils.otelSpanIdToUUID(spanHex),
 					isRemote: true
 				};
 				return {
@@ -5993,7 +6130,7 @@ const restoreContextFromHeaders = (headers) => {
 					otelContext: pushLaminarContext(ctx)
 				};
 			} catch (e) {
-				logger$10.warn(`[Laminar] Could not restore traceparent: ${require_dist.errorMessage(e)}`);
+				logger$10.warn(`[Laminar] Could not restore traceparent: ${require_utils.errorMessage(e)}`);
 			}
 		}
 	}
@@ -6003,7 +6140,7 @@ const restoreContextFromHeaders = (headers) => {
 * return the enriched OTel `Context` that was pushed.
 */
 const pushLaminarContext = (laminarCtx) => {
-	const otelCtx = require_dist.tryToOtelSpanContext(laminarCtx);
+	const otelCtx = require_utils.tryToOtelSpanContext(laminarCtx);
 	otelCtx.isRemote = true;
 	const processor = getSpanProcessor();
 	if (processor instanceof LaminarSpanProcessor && laminarCtx.spanPath && laminarCtx.spanIdsPath) processor.setParentPathInfo(otelCtx.spanId, laminarCtx.spanPath, laminarCtx.spanIdsPath);
@@ -6172,7 +6309,7 @@ var ActivityInboundInterceptor = class {
 				if (this.recordActivityOutput) try {
 					span.setOutput(res);
 				} catch (e) {
-					this.logger.debug(`failed to set output to activity span: ${require_dist.errorMessage(e)}`);
+					this.logger.debug(`failed to set output to activity span: ${require_utils.errorMessage(e)}`);
 				}
 				return res;
 			}, true);
@@ -6181,13 +6318,13 @@ var ActivityInboundInterceptor = class {
 		this.recordActivityArgs = options.recordActivityArgs ?? true;
 		this.recordActivityOutput = options.recordActivityOutput ?? true;
 		this.activityType = activityContext?.info?.activityType;
-		this.logger = require_dist.initializeLogger();
+		this.logger = require_utils.initializeLogger();
 	}
 };
 const ActivityInterceptorFactory = (options) => (ctx) => ({ inbound: new ActivityInboundInterceptor(options, ctx) });
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/temporal/workflow-span.ts
-const logger$9 = require_dist.initializeLogger();
+const logger$9 = require_utils.initializeLogger();
 const _patchedWorkflowClients = /* @__PURE__ */ new WeakSet();
 const workflowName = (args) => {
 	const wf = args[0];
@@ -6211,7 +6348,7 @@ const wrapHandle = (handle, span) => {
 		try {
 			return Laminar.serializeLaminarSpanContext(span) ?? void 0;
 		} catch (e) {
-			logger$9.debug(`failed to derive workflow child span parent: ${require_dist.errorMessage(e)}`);
+			logger$9.debug(`failed to derive workflow child span parent: ${require_utils.errorMessage(e)}`);
 			return;
 		}
 	};
@@ -6223,7 +6360,7 @@ const wrapHandle = (handle, span) => {
 				try {
 					span.setOutput(res);
 				} catch (e) {
-					logger$9.debug(`failed to set workflow span output: ${require_dist.errorMessage(e)}`);
+					logger$9.debug(`failed to set workflow span output: ${require_utils.errorMessage(e)}`);
 				}
 			});
 			return res;
@@ -6300,7 +6437,7 @@ const patchWorkflowClient = (clientModule) => {
 			try {
 				span.setOutput(res);
 			} catch (e) {
-				logger$9.debug(`failed to set workflow span output: ${require_dist.errorMessage(e)}`);
+				logger$9.debug(`failed to set workflow span output: ${require_utils.errorMessage(e)}`);
 			}
 			span.end();
 			return res;
@@ -6384,7 +6521,7 @@ const patchWorkflowClient = (clientModule) => {
 * const client = new temporalClient.Client({ ... });
 * ```
 */
-const logger$8 = require_dist.initializeLogger();
+const logger$8 = require_utils.initializeLogger();
 const _patchedWorkerModules = /* @__PURE__ */ new WeakSet();
 const _patchedClientModules = /* @__PURE__ */ new WeakSet();
 let _warnedWorkflowBundleOnce = false;
@@ -6462,7 +6599,7 @@ const LaminarTemporalInterceptors = {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/instrumentations.ts
-const logger$7 = require_dist.initializeLogger();
+const logger$7 = require_utils.initializeLogger();
 /**
 * Initialize and return Laminar instrumentations.
 * Useful to use with libraries that initialize tracing and can register passed
@@ -6493,7 +6630,7 @@ const initializeLaminarInstrumentations = (options = {}) => {
 	if (apiKey) {
 		const url = options.baseUrl ?? process?.env?.LMNR_BASE_URL ?? "https://api.lmnr.ai";
 		const port = options.httpPort ?? (url.match(/:\d{1,5}$/g) ? parseInt(url.match(/:\d{1,5}$/g)[0].slice(1)) : 443);
-		client = new require_dist.LaminarClient({
+		client = new require_utils.LaminarClient({
 			baseUrl: `${url.replace(/\/$/, "").replace(/:\d{1,5}$/g, "")}:${port}`,
 			projectApiKey: apiKey
 		});
@@ -6702,7 +6839,7 @@ const isGlobalContextManagerConfigured = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/index.ts
-const logger$6 = require_dist.initializeLogger();
+const logger$6 = require_utils.initializeLogger();
 let spanProcessor;
 let tracerProvider;
 let _baseHttpUrl = "https://api.lmnr.ai:443";
@@ -6734,6 +6871,8 @@ const startTracing = (options) => {
 		forceHttp: options.forceHttp,
 		traceExportTimeoutMillis: options.traceExportTimeoutMillis,
 		maxExportBatchSize: options.maxExportBatchSize,
+		maxExportBatchSizeBytes: options.maxExportBatchSizeBytes,
+		flushBySize: options.flushBySize,
 		exporter: options.exporter,
 		disableBatch: options.disableBatch
 	});
@@ -6742,7 +6881,7 @@ const startTracing = (options) => {
 		sampler: new _opentelemetry_sdk_trace_base.AlwaysOnSampler(),
 		resource: createResource({
 			[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: "laminar-tracer-resource",
-			[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: require_dist.version
+			[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: require_utils.version
 		})
 	});
 	tracerProvider = newProvider;
@@ -6871,17 +7010,17 @@ const _resetConfiguration = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/decorators.ts
-const logger$5 = require_dist.initializeLogger();
+const logger$5 = require_utils.initializeLogger();
 function observeBase({ name, contextProperties, spanAttributes, input, ignoreInput, ignoreOutput, inputParameters, suppressTracing: shouldSuppressTracing, parentSpanContext }, fn, thisArg, ...args) {
 	let entityContext = LaminarContextManager.getContext();
 	if (shouldSuppressTracing) entityContext = (0, _opentelemetry_core.suppressTracing)(entityContext);
 	if (parentSpanContext) try {
-		const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+		const laminarContext = typeof parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 		Laminar._armDebugRuntimeFromContext(laminarContext.debug);
-		const spanContext = require_dist.tryToOtelSpanContext(laminarContext);
+		const spanContext = require_utils.tryToOtelSpanContext(laminarContext);
 		entityContext = _opentelemetry_api.trace.setSpan(entityContext, _opentelemetry_api.trace.wrapSpanContext(spanContext));
 	} catch (e) {
-		logger$5.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
+		logger$5.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
 	}
 	try {
 		if (contextProperties && Object.keys(contextProperties).length > 0) {
@@ -6892,16 +7031,16 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 			});
 		}
 	} catch (e) {
-		logger$5.warn("Failed to set context properties: " + require_dist.errorMessage(e));
+		logger$5.warn("Failed to set context properties: " + require_utils.errorMessage(e));
 	}
 	return _opentelemetry_api.context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: spanAttributes }, entityContext, (span) => {
 		if (shouldSendTraces() && !ignoreInput) try {
 			const spanInput = inputParameters ?? args;
-			if (input !== void 0) span.setAttribute(require_dist.SPAN_INPUT, typeof input === "string" ? require_dist.truncateSpanPayload(input, "input") : serialize(input, "input"));
-			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_dist.SPAN_INPUT, typeof spanInput[0] === "string" ? require_dist.truncateSpanPayload(spanInput[0], "input") : serialize(spanInput[0], "input"));
-			else span.setAttribute(require_dist.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}, "input"));
+			if (input !== void 0) span.setAttribute(require_utils.SPAN_INPUT, typeof input === "string" ? require_utils.truncateSpanPayload(input, "input") : serialize(input, "input"));
+			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_utils.SPAN_INPUT, typeof spanInput[0] === "string" ? require_utils.truncateSpanPayload(spanInput[0], "input") : serialize(spanInput[0], "input"));
+			else span.setAttribute(require_utils.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}, "input"));
 		} catch (error) {
-			logger$5.warn("Failed to serialize input: " + require_dist.errorMessage(error));
+			logger$5.warn("Failed to serialize input: " + require_utils.errorMessage(error));
 		}
 		let res;
 		try {
@@ -6911,7 +7050,7 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 				span.recordException(error);
 				span.end();
 			} catch (error) {
-				logger$5.warn("Failed to record exception and end span: " + require_dist.errorMessage(error));
+				logger$5.warn("Failed to record exception and end span: " + require_utils.errorMessage(error));
 			}
 			throw error;
 		}
@@ -6920,18 +7059,18 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 			try {
 				streamInfo = getStream(resolvedRes);
 			} catch (error) {
-				logger$5.warn("Failed to get stream info: " + require_dist.errorMessage(error));
+				logger$5.warn("Failed to get stream info: " + require_utils.errorMessage(error));
 			}
 			if (streamInfo.type !== null) return handleStreamResult(resolvedRes, streamInfo, span, ignoreOutput, serialize);
 			try {
-				if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, serialize(resolvedRes));
+				if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_utils.SPAN_OUTPUT, serialize(resolvedRes));
 			} catch (error) {
-				logger$5.warn("Failed to serialize async output: " + require_dist.errorMessage(error));
+				logger$5.warn("Failed to serialize async output: " + require_utils.errorMessage(error));
 			} finally {
 				try {
 					span.end();
 				} catch (error) {
-					logger$5.warn("Failed to end span: " + require_dist.errorMessage(error));
+					logger$5.warn("Failed to end span: " + require_utils.errorMessage(error));
 				}
 			}
 			return resolvedRes;
@@ -6940,7 +7079,7 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 				span.recordException(error);
 				span.end();
 			} catch (error) {
-				logger$5.warn("Failed to record exception and end span: " + require_dist.errorMessage(error));
+				logger$5.warn("Failed to record exception and end span: " + require_utils.errorMessage(error));
 			}
 			throw error;
 		});
@@ -6948,18 +7087,18 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 		try {
 			streamInfo = getStream(res);
 		} catch (error) {
-			logger$5.warn("Failed to get stream info: " + require_dist.errorMessage(error));
+			logger$5.warn("Failed to get stream info: " + require_utils.errorMessage(error));
 		}
 		if (streamInfo.type !== null) return handleStreamResult(res, streamInfo, span, ignoreOutput, serialize);
 		try {
-			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, typeof res === "string" ? require_dist.truncateSpanPayload(res, "output") : serialize(res));
+			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_utils.SPAN_OUTPUT, typeof res === "string" ? require_utils.truncateSpanPayload(res, "output") : serialize(res));
 		} catch (error) {
-			logger$5.warn("Failed to serialize output: " + require_dist.errorMessage(error));
+			logger$5.warn("Failed to serialize output: " + require_utils.errorMessage(error));
 		} finally {
 			try {
 				span.end();
 			} catch (error) {
-				logger$5.warn("Failed to end span: " + require_dist.errorMessage(error));
+				logger$5.warn("Failed to end span: " + require_utils.errorMessage(error));
 			}
 		}
 		return res;
@@ -6980,10 +7119,10 @@ const normalizePayload = (payload, seen) => {
 	}
 	return payload;
 };
-const serialize = (payload, kind = "output") => require_dist.truncateSpanPayload(JSON.stringify(normalizePayload(payload, /* @__PURE__ */ new WeakSet())), kind);
+const serialize = (payload, kind = "output") => require_utils.truncateSpanPayload(JSON.stringify(normalizePayload(payload, /* @__PURE__ */ new WeakSet())), kind);
 //#endregion
 //#region src/decorators.ts
-const logger$4 = require_dist.initializeLogger();
+const logger$4 = require_utils.initializeLogger();
 /**
 * The main decorator entrypoint for Laminar. This is used to wrap
 * functions and methods to create spans.
@@ -7066,7 +7205,7 @@ function withTracingLevel(tracingLevel, fn, ...args) {
 	const currentAssociationProperties = entityContext.getValue(ASSOCIATION_PROPERTIES_KEY) ?? {};
 	entityContext = entityContext.setValue(ASSOCIATION_PROPERTIES_KEY, {
 		...currentAssociationProperties,
-		"tracing_level": tracingLevel
+		tracing_level: tracingLevel
 	});
 	const result = LaminarContextManager.runWithIsolatedContext([entityContext], () => fn(...args));
 	const newAssociationProperties = entityContext.getValue(ASSOCIATION_PROPERTIES_KEY) ?? {};
@@ -7089,14 +7228,14 @@ const buildContextProperties = (options) => {
 	let parentUserId;
 	let parentSessionId;
 	if (parentSpanContext) try {
-		const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+		const laminarContext = typeof parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 		parentMetadata = laminarContext.metadata;
 		parentTraceType = laminarContext.traceType;
 		parentTracingLevel = laminarContext.tracingLevel;
 		parentUserId = laminarContext.userId;
 		parentSessionId = laminarContext.sessionId;
 	} catch (e) {
-		logger$4.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
+		logger$4.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
 	}
 	const contextProperties = {};
 	const sessionIdValue = options.sessionId ?? parentSessionId ?? ctxAssociationProperties.sessionId;
@@ -7126,14 +7265,14 @@ const buildContextProperties = (options) => {
 */
 const buildSpanAttributes = (options) => {
 	const spanAttributes = {};
-	if (options.spanType) spanAttributes[require_dist.SPAN_TYPE] = options.spanType;
-	if (options.tags) spanAttributes[`${require_dist.ASSOCIATION_PROPERTIES}.tags`] = Array.from(new Set(options.tags));
+	if (options.spanType) spanAttributes[require_utils.SPAN_TYPE] = options.spanType;
+	if (options.tags) spanAttributes[`${require_utils.ASSOCIATION_PROPERTIES}.tags`] = Array.from(new Set(options.tags));
 	if (options.parentSpanContext) try {
-		const laminarContext = typeof options.parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(options.parentSpanContext) : options.parentSpanContext;
-		if (laminarContext.spanPath) spanAttributes[require_dist.PARENT_SPAN_PATH] = laminarContext.spanPath;
-		if (laminarContext.spanIdsPath) spanAttributes[require_dist.PARENT_SPAN_IDS_PATH] = laminarContext.spanIdsPath;
+		const laminarContext = typeof options.parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(options.parentSpanContext) : options.parentSpanContext;
+		if (laminarContext.spanPath) spanAttributes[require_utils.PARENT_SPAN_PATH] = laminarContext.spanPath;
+		if (laminarContext.spanIdsPath) spanAttributes[require_utils.PARENT_SPAN_IDS_PATH] = laminarContext.spanIdsPath;
 	} catch (e) {
-		logger$4.warn("Failed to parse parent span context for span attributes: " + require_dist.errorMessage(e));
+		logger$4.warn("Failed to parse parent span context for span attributes: " + require_utils.errorMessage(e));
 	}
 	return spanAttributes;
 };
@@ -7265,12 +7404,12 @@ function observeExperimentalDecorator(config) {
 }
 //#endregion
 //#region src/evaluations.ts
-require_dist.loadEnv();
+require_utils.loadEnv();
 const DEFAULT_CONCURRENCY = 5;
 const MAX_EXPORT_BATCH_SIZE = 64;
-const logger$3 = require_dist.initializeLogger();
+const logger$3 = require_utils.initializeLogger();
 const getEvaluationUrl = (projectId, evaluationId, baseUrl, frontendPort) => {
-	return `${require_dist.getFrontendUrl(baseUrl, frontendPort)}/project/${projectId}/evaluations/${evaluationId}`;
+	return `${require_utils.getFrontendUrl(baseUrl, frontendPort)}/project/${projectId}/evaluations/${evaluationId}`;
 };
 const SESSION_METADATA_KEY = "rollout.session_id";
 /**
@@ -7373,7 +7512,7 @@ var Evaluation = class {
 			this.traceExportBatchSize = config.traceExportBatchSize ?? MAX_EXPORT_BATCH_SIZE;
 		}
 		if (Laminar.initialized()) {
-			this.client = new require_dist.LaminarClient({
+			this.client = new require_utils.LaminarClient({
 				baseUrl: Laminar.getHttpUrl(),
 				projectApiKey: Laminar.getProjectApiKey()
 			});
@@ -7386,7 +7525,7 @@ var Evaluation = class {
 		const httpUrl = config?.baseHttpUrl ?? url;
 		const httpPort = config?.httpPort ?? (httpUrl.match(/:\d{1,5}$/g) ? parseInt(httpUrl.match(/:\d{1,5}$/g)[0].slice(1)) : 443);
 		const baseHttpUrl = `${httpUrl.replace(/\/$/, "").replace(/:\d{1,5}$/g, "")}:${httpPort}`;
-		this.client = new require_dist.LaminarClient({
+		this.client = new require_utils.LaminarClient({
 			baseUrl: baseHttpUrl,
 			projectApiKey: key
 		});
@@ -7412,7 +7551,7 @@ var Evaluation = class {
 				if (datasets.length > 0) source.id = datasets[0].id;
 				else logger$3.warn(`Dataset ${source.name} not found`);
 			} catch (error) {
-				logger$3.warn(`Error getting dataset ${source.name}: ` + require_dist.errorMessage(error));
+				logger$3.warn(`Error getting dataset ${source.name}: ` + require_utils.errorMessage(error));
 			}
 		}
 		let resultDatapoints;
@@ -7446,7 +7585,7 @@ var Evaluation = class {
 				projectId: "",
 				evaluationId: "",
 				url: "",
-				errorMessage: require_dist.errorMessage(e)
+				errorMessage: require_utils.errorMessage(e)
 			};
 		}
 	}
@@ -7461,7 +7600,7 @@ var Evaluation = class {
 			}
 		});
 		return LaminarContextManager.runWithIsolatedContext([entityContext], async () => {
-			const semaphore = new require_dist.Semaphore(this.concurrencyLimit);
+			const semaphore = new require_utils.Semaphore(this.concurrencyLimit);
 			const tasks = [];
 			const evaluateTask = async (datapoint, index) => {
 				try {
@@ -7485,20 +7624,20 @@ var Evaluation = class {
 			name: "evaluation",
 			traceType: "EVALUATION"
 		}, async () => {
-			_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).setAttribute(require_dist.SPAN_TYPE, "EVALUATION");
+			_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).setAttribute(require_utils.SPAN_TYPE, "EVALUATION");
 			const executorSpan = Laminar.startSpan({
 				name: "executor",
 				input: datapoint.data
 			});
-			executorSpan.setAttribute(require_dist.SPAN_TYPE, "EXECUTOR");
-			const executorSpanId = require_dist.otelSpanIdToUUID(executorSpan.spanContext().spanId);
-			const datapointId = require_dist.newUUID();
+			executorSpan.setAttribute(require_utils.SPAN_TYPE, "EXECUTOR");
+			const executorSpanId = require_utils.otelSpanIdToUUID(executorSpan.spanContext().spanId);
+			const datapointId = require_utils.newUUID();
 			const partialDatapoint = {
 				id: datapointId,
 				data: datapoint.data,
 				target: datapoint.target,
 				metadata: datapoint.metadata,
-				traceId: require_dist.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
+				traceId: require_utils.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
 				executorSpanId,
 				index
 			};
@@ -7524,13 +7663,13 @@ var Evaluation = class {
 					if (evaluator instanceof HumanEvaluator) {
 						const activeSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext());
 						if (activeSpan) {
-							activeSpan.setAttribute(require_dist.SPAN_TYPE, "HUMAN_EVALUATOR");
-							if (evaluator.options) activeSpan.setAttribute(require_dist.HUMAN_EVALUATOR_OPTIONS, JSON.stringify(evaluator.options));
+							activeSpan.setAttribute(require_utils.SPAN_TYPE, "HUMAN_EVALUATOR");
+							if (evaluator.options) activeSpan.setAttribute(require_utils.HUMAN_EVALUATOR_OPTIONS, JSON.stringify(evaluator.options));
 						}
 						return null;
 					} else {
 						const activeSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext());
-						if (activeSpan) activeSpan.setAttribute(require_dist.SPAN_TYPE, "EVALUATOR");
+						if (activeSpan) activeSpan.setAttribute(require_utils.SPAN_TYPE, "EVALUATOR");
 						return await evaluator(output, target, data);
 					}
 				}, output, datapoint.target, datapoint.data);
@@ -7553,7 +7692,7 @@ var Evaluation = class {
 				target,
 				metadata: datapoint.metadata,
 				scores,
-				traceId: require_dist.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
+				traceId: require_utils.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
 				executorSpanId,
 				index
 			};
@@ -7612,7 +7751,7 @@ async function evaluate({ data, executor, evaluators, groupName, name, metadata,
 }
 //#endregion
 //#region src/integrations/eve.ts
-const logger$2 = require_dist.initializeLogger();
+const logger$2 = require_utils.initializeLogger();
 const EVE_REPORTER_TRACER_NAME = "@lmnr-ai/lmnr/eve-reporter";
 const EVE_CLIENT_MODULE = "eve/client";
 const TRACEPARENT_HEADER$1 = "traceparent";
@@ -7660,7 +7799,7 @@ const openSessionTrace = (clientSession) => {
 		if (minted) traceByClientSession.set(clientSession, minted);
 		return minted;
 	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to open a session trace: ` + require_dist.errorMessage(error));
+		logger$2.warn(`Laminar eve reporter: failed to open a session trace: ` + require_utils.errorMessage(error));
 		return;
 	}
 };
@@ -7688,11 +7827,11 @@ const recordEveSessionId = (response, sessionTrace) => {
 const buildTraceHeaders = (rootSpan, executorSpan) => {
 	const spanContext = executorSpan.spanContext();
 	const laminarContext = {
-		traceId: require_dist.otelTraceIdToUUID(spanContext.traceId),
-		spanId: require_dist.otelSpanIdToUUID(spanContext.spanId),
+		traceId: require_utils.otelTraceIdToUUID(spanContext.traceId),
+		spanId: require_utils.otelSpanIdToUUID(spanContext.spanId),
 		isRemote: true,
 		spanPath: [ROOT_SPAN_NAME, EXECUTOR_SPAN_NAME],
-		spanIdsPath: [require_dist.otelSpanIdToUUID(rootSpan.spanContext().spanId), require_dist.otelSpanIdToUUID(spanContext.spanId)]
+		spanIdsPath: [require_utils.otelSpanIdToUUID(rootSpan.spanContext().spanId), require_utils.otelSpanIdToUUID(spanContext.spanId)]
 	};
 	return {
 		[TRACEPARENT_HEADER$1]: `00-${spanContext.traceId}-${spanContext.spanId}-01`,
@@ -7729,7 +7868,7 @@ const bindEvalContext = (sessionTrace) => {
 	try {
 		LaminarContextManager.pushContext(_opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, sessionTrace.rootSpan));
 	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to bind the eval context: ` + require_dist.errorMessage(error));
+		logger$2.warn(`Laminar eve reporter: failed to bind the eval context: ` + require_utils.errorMessage(error));
 	}
 };
 /**
@@ -7752,7 +7891,7 @@ const patchEveClientSession = (sessionClass) => {
 		try {
 			recordEveSessionId(response, sessionTrace);
 		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to record the eve session id: ` + require_dist.errorMessage(error));
+			logger$2.warn(`Laminar eve reporter: failed to record the eve session id: ` + require_utils.errorMessage(error));
 		}
 		return response;
 	};
@@ -7814,7 +7953,7 @@ const failedAssertionsMetadata = (assertions) => {
 	}));
 	return failed.length > 0 ? { failedAssertions: failed } : {};
 };
-const traceIdFromSpan = (span) => require_dist.otelTraceIdToUUID(span.spanContext().traceId);
+const traceIdFromSpan = (span) => require_utils.otelTraceIdToUUID(span.spanContext().traceId);
 /**
 * A Laminar reporter for eve evals. Register it globally in `evals.config.ts`
 * or per-eval via the `reporters` field — eve runs and grades each eval, then
@@ -7878,7 +8017,7 @@ var LaminarReporter = class {
 		this.index = 0;
 		this.finishOpenSessionTraces();
 		try {
-			this.client = this.options.client ?? new require_dist.LaminarClient({
+			this.client = this.options.client ?? new require_utils.LaminarClient({
 				baseUrl: this.options.baseUrl,
 				projectApiKey: this.options.projectApiKey
 			});
@@ -7895,10 +8034,10 @@ var LaminarReporter = class {
 				evalCount: evaluations.length
 			});
 			this.evalId = evaluation.id;
-			const url = require_dist.getFrontendUrl(this.client.configuredBaseUrl ?? this.options.baseUrl) + `/project/${evaluation.projectId}/evaluations/${evaluation.id}`;
+			const url = require_utils.getFrontendUrl(this.client.configuredBaseUrl ?? this.options.baseUrl) + `/project/${evaluation.projectId}/evaluations/${evaluation.id}`;
 			process.stdout.write(`\nLaminar: check eve eval results at ${url}\n`);
 		} catch (error) {
-			logger$2.error(`Laminar eve reporter: failed to start run: ${require_dist.errorMessage(error)}`);
+			logger$2.error(`Laminar eve reporter: failed to start run: ${require_utils.errorMessage(error)}`);
 			if (!this.evalId) {
 				this.client = void 0;
 				if (activeSessionTraceFactory === this.sessionTraceFactory) activeSessionTraceFactory = null;
@@ -7954,7 +8093,7 @@ var LaminarReporter = class {
 			});
 		} catch (error) {
 			if (traceResolution.source === "reporter-fallback") traceResolution.span.recordException(error);
-			logger$2.error(`Laminar eve reporter: failed to report eval "${result.id ?? index}": ${require_dist.errorMessage(error)}`);
+			logger$2.error(`Laminar eve reporter: failed to report eval "${result.id ?? index}": ${require_utils.errorMessage(error)}`);
 		} finally {
 			if (traceResolution.source === "reporter-fallback") traceResolution.span.end();
 			if (traceResolution.source === "propagated") this.finishSessionTrace(traceResolution.sessionTrace, {
@@ -8008,7 +8147,7 @@ var LaminarReporter = class {
 		try {
 			await Laminar.flush();
 		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to flush spans: ` + require_dist.errorMessage(error));
+			logger$2.warn(`Laminar eve reporter: failed to flush spans: ` + require_utils.errorMessage(error));
 		}
 	}
 	/**
@@ -8019,16 +8158,16 @@ var LaminarReporter = class {
 	mintSessionTrace() {
 		const tracer = getTracer();
 		const rootSpan = tracer.startSpan(ROOT_SPAN_NAME, { attributes: {
-			[require_dist.SPAN_TYPE]: "EVALUATION",
-			[require_dist.TRACE_TYPE]: "EVALUATION",
+			[require_utils.SPAN_TYPE]: "EVALUATION",
+			[require_utils.TRACE_TYPE]: "EVALUATION",
 			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME
 		} }, _opentelemetry_api.ROOT_CONTEXT);
 		const executorSpan = tracer.startSpan(EXECUTOR_SPAN_NAME, { attributes: {
-			[require_dist.SPAN_TYPE]: "EXECUTOR",
-			[require_dist.TRACE_TYPE]: "EVALUATION"
+			[require_utils.SPAN_TYPE]: "EXECUTOR",
+			[require_utils.TRACE_TYPE]: "EVALUATION"
 		} }, _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, rootSpan));
 		const sessionTrace = {
-			traceId: require_dist.otelTraceIdToUUID(rootSpan.spanContext().traceId),
+			traceId: require_utils.otelTraceIdToUUID(rootSpan.spanContext().traceId),
 			rootSpan,
 			executorSpan,
 			tracer,
@@ -8050,12 +8189,12 @@ var LaminarReporter = class {
 				"lmnr.eve.eval.id": grade.evalId ?? "",
 				"lmnr.eve.eval.verdict": grade.verdict ?? "",
 				"lmnr.eve.eval.status": grade.status ?? "",
-				[require_dist.SPAN_INPUT]: JSON.stringify({
+				[require_utils.SPAN_INPUT]: JSON.stringify({
 					evalId: grade.evalId,
 					description: grade.description
 				}),
-				[require_dist.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null),
-				...require_dist.metadataToAttributes({
+				[require_utils.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null),
+				...require_utils.metadataToAttributes({
 					source: "eve",
 					eveEvalId: grade.evalId ?? "",
 					eveEvalDescription: grade.description ?? "",
@@ -8063,12 +8202,12 @@ var LaminarReporter = class {
 					eveSessionId: [...sessionTrace.sessionIds].join(",")
 				})
 			});
-			sessionTrace.executorSpan.setAttribute(require_dist.SPAN_OUTPUT, JSON.stringify(grade.output ?? null));
+			sessionTrace.executorSpan.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(grade.output ?? null));
 			this.recordEvaluatorSpans(sessionTrace, grade.assertions ?? []);
 			sessionTrace.executorSpan.end();
 			sessionTrace.rootSpan.end();
 		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to finish the session trace: ` + require_dist.errorMessage(error));
+			logger$2.warn(`Laminar eve reporter: failed to finish the session trace: ` + require_utils.errorMessage(error));
 		}
 	}
 	/**
@@ -8089,9 +8228,9 @@ var LaminarReporter = class {
 				message: assertion.message
 			});
 			sessionTrace.tracer.startSpan(name, { attributes: {
-				[require_dist.SPAN_TYPE]: "EVALUATOR",
-				[require_dist.TRACE_TYPE]: "EVALUATION",
-				[require_dist.SPAN_OUTPUT]: output
+				[require_utils.SPAN_TYPE]: "EVALUATOR",
+				[require_utils.TRACE_TYPE]: "EVALUATION",
+				[require_utils.SPAN_OUTPUT]: output
 			} }, rootContext).end();
 		}
 	}
@@ -8111,14 +8250,14 @@ var LaminarReporter = class {
 			sessionTrace
 		};
 		const span = getTracer().startSpan(`eve eval ${evalId}`, { attributes: {
-			[require_dist.SPAN_TYPE]: "EVALUATION",
-			[require_dist.TRACE_TYPE]: "EVALUATION",
+			[require_utils.SPAN_TYPE]: "EVALUATION",
+			[require_utils.TRACE_TYPE]: "EVALUATION",
 			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME,
 			"lmnr.eve.eval.id": evalId,
 			"lmnr.eve.eval.verdict": verdict ?? "",
 			...sessionId ? { "lmnr.eve.session.id": sessionId } : {},
 			"lmnr.eve.trace_resolution": "reporter-fallback",
-			...require_dist.metadataToAttributes({
+			...require_utils.metadataToAttributes({
 				source: "eve",
 				eveEvalId: evalId,
 				eveEvalDescription: description ?? "",
@@ -8261,10 +8400,10 @@ const normalizeProvider$1 = (provider) => {
 };
 const applyUsage = (attributes, usage) => {
 	if (!usage || typeof usage !== "object") return;
-	if (typeof usage.inputTokens === "number") attributes[require_dist.LaminarAttributes.INPUT_TOKEN_COUNT] = usage.inputTokens;
-	if (typeof usage.outputTokens === "number") attributes[require_dist.LaminarAttributes.OUTPUT_TOKEN_COUNT] = usage.outputTokens;
-	if (typeof usage.totalTokens === "number") attributes[require_dist.LaminarAttributes.TOTAL_TOKEN_COUNT] = usage.totalTokens;
-	else if (typeof usage.inputTokens === "number" || typeof usage.outputTokens === "number") attributes[require_dist.LaminarAttributes.TOTAL_TOKEN_COUNT] = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+	if (typeof usage.inputTokens === "number") attributes[require_utils.LaminarAttributes.INPUT_TOKEN_COUNT] = usage.inputTokens;
+	if (typeof usage.outputTokens === "number") attributes[require_utils.LaminarAttributes.OUTPUT_TOKEN_COUNT] = usage.outputTokens;
+	if (typeof usage.totalTokens === "number") attributes[require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT] = usage.totalTokens;
+	else if (typeof usage.inputTokens === "number" || typeof usage.outputTokens === "number") attributes[require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT] = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
 	if (typeof usage.reasoningTokens === "number") attributes["gen_ai.usage.reasoning_tokens"] = usage.reasoningTokens;
 	else if (typeof usage.outputTokenDetails?.reasoningTokens === "number") attributes["gen_ai.usage.reasoning_tokens"] = usage.outputTokenDetails.reasoningTokens;
 	if (typeof usage.cachedInputTokens === "number") attributes["gen_ai.usage.cache_read_input_tokens"] = usage.cachedInputTokens;
@@ -8310,11 +8449,11 @@ const applyFinishReason = (span, finishReason) => {
 const applyRequestModelAttributes = (span, event) => {
 	if (typeof event.provider === "string") {
 		const provider = normalizeProvider$1(event.provider);
-		if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
+		if (provider) span.setAttribute(require_utils.LaminarAttributes.PROVIDER, provider);
 		span.setAttribute("ai.model.provider", event.provider);
 	}
 	if (typeof event.modelId === "string") {
-		span.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, event.modelId);
+		span.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
 		span.setAttribute("ai.model.id", event.modelId);
 	}
 };
@@ -8822,7 +8961,7 @@ const AI_FUNCTIONS = [
 * falls back to the older `experimental_telemetry: { tracer }` path.
 */
 const isAISDKv7 = (ai) => typeof ai.registerTelemetry === "function";
-const logger$1 = require_dist.initializeLogger();
+const logger$1 = require_utils.initializeLogger();
 let wrapAISDKv7WarnedOnce = false;
 const wrapAISDK = (ai) => {
 	const wrapped = {};
@@ -8941,8 +9080,8 @@ const getAiSdkPackageVersions = () => {
 */
 const buildAiSdkInstrumentationAttributes = () => {
 	const { aiVersion, aiSdkPackages } = getAiSdkPackageVersions();
-	const attributes = { [require_dist.SPAN_INSTRUMENTATION_SCOPE_NAME]: "ai" };
-	if (aiVersion) attributes[require_dist.SPAN_INSTRUMENTATION_SCOPE_VERSION] = aiVersion;
+	const attributes = { [require_utils.SPAN_INSTRUMENTATION_SCOPE_NAME]: "ai" };
+	if (aiVersion) attributes[require_utils.SPAN_INSTRUMENTATION_SCOPE_VERSION] = aiVersion;
 	for (const [pkg, version] of Object.entries(aiSdkPackages)) attributes[`lmnr.span.instrumentation.${pkg}.version`] = version;
 	return attributes;
 };
@@ -8972,7 +9111,7 @@ var LaminarAiSdkTelemetry = class {
 		this.toolByCallId = /* @__PURE__ */ new Map();
 		this.activeStreamStepByCallId = /* @__PURE__ */ new Map();
 		this.promptByCallId = /* @__PURE__ */ new Map();
-		this.logger = require_dist.initializeLogger();
+		this.logger = require_utils.initializeLogger();
 		this.onStart = (event) => {
 			const callId = event?.callId;
 			if (!callId) return;
@@ -8983,7 +9122,7 @@ var LaminarAiSdkTelemetry = class {
 			const span = tracer.startSpan(spanName, {
 				kind: _opentelemetry_api.SpanKind.CLIENT,
 				attributes: {
-					[require_dist.SPAN_TYPE]: "DEFAULT",
+					[require_utils.SPAN_TYPE]: "DEFAULT",
 					...buildAiSdkInstrumentationAttributes(),
 					...typeof event.functionId === "string" ? {
 						"operation.name": event.functionId,
@@ -8992,24 +9131,24 @@ var LaminarAiSdkTelemetry = class {
 				}
 			}, parentCtx);
 			const spanCtx = _opentelemetry_api.trace.setSpan(parentCtx, span);
-			span.setAttribute(require_dist.SPAN_TYPE, "DEFAULT");
+			span.setAttribute(require_utils.SPAN_TYPE, "DEFAULT");
 			if (typeof event.operationId === "string") span.setAttribute("ai.operation", event.operationId);
 			if (typeof event.provider === "string") {
 				const provider = normalizeProvider$1(event.provider);
-				if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
+				if (provider) span.setAttribute(require_utils.LaminarAttributes.PROVIDER, provider);
 			}
 			if (typeof event.modelId === "string") {
-				span.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, event.modelId);
+				span.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
 				span.setAttribute("ai.model.id", event.modelId);
 			}
 			if (typeof event.functionId === "string") span.setAttribute("ai.functionId", event.functionId);
-			if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany" || event.operationId === "ai.rerank") span.setAttribute(require_dist.SPAN_TYPE, "LLM");
+			if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany" || event.operationId === "ai.rerank") span.setAttribute(require_utils.SPAN_TYPE, "LLM");
 			if (this.recordInputs) {
 				if (Array.isArray(event.messages) || event.system !== void 0 || event.instructions !== void 0) {
 					const msgs = verbatimStandardizedMessages(event);
-					if (msgs.length > 0) span.setAttribute(require_dist.SPAN_INPUT, serializeJSON$1(msgs));
-				} else if (event.value !== void 0) span.setAttribute(require_dist.SPAN_INPUT, serializeJSON$1(event.value));
-				else if (event.query !== void 0 || event.documents !== void 0) span.setAttribute(require_dist.SPAN_INPUT, serializeJSON$1({
+					if (msgs.length > 0) span.setAttribute(require_utils.SPAN_INPUT, serializeJSON$1(msgs));
+				} else if (event.value !== void 0) span.setAttribute(require_utils.SPAN_INPUT, serializeJSON$1(event.value));
+				else if (event.query !== void 0 || event.documents !== void 0) span.setAttribute(require_utils.SPAN_INPUT, serializeJSON$1({
 					query: event.query,
 					documents: event.documents
 				}));
@@ -9035,12 +9174,12 @@ var LaminarAiSdkTelemetry = class {
 			if (!op) return;
 			const span = getTracer().startSpan(`ai.step`, { kind: _opentelemetry_api.SpanKind.CLIENT }, op.ctx);
 			const spanCtx = _opentelemetry_api.trace.setSpan(op.ctx, span);
-			span.setAttribute(require_dist.SPAN_TYPE, "DEFAULT");
+			span.setAttribute(require_utils.SPAN_TYPE, "DEFAULT");
 			span.setAttributes(buildAiSdkInstrumentationAttributes());
 			span.setAttribute("ai.step.number", stepNumber);
 			if (this.recordInputs) {
 				const msgs = verbatimStandardizedMessages(event);
-				if (msgs.length > 0) span.setAttribute(require_dist.SPAN_INPUT, serializeJSON$1(msgs));
+				if (msgs.length > 0) span.setAttribute(require_utils.SPAN_INPUT, serializeJSON$1(msgs));
 			}
 			this.stepByKey.set(stepKey(callId, stepNumber), {
 				span,
@@ -9056,14 +9195,14 @@ var LaminarAiSdkTelemetry = class {
 			const parentCtx = step?.ctx ?? this.operationByCallId.get(callId)?.ctx;
 			if (!parentCtx) return;
 			const span = getTracer().startSpan(`ai.llm ${event.provider ?? ""}:${event.modelId ?? ""}`, { kind: _opentelemetry_api.SpanKind.CLIENT }, parentCtx);
-			span.setAttribute(require_dist.SPAN_TYPE, "LLM");
+			span.setAttribute(require_utils.SPAN_TYPE, "LLM");
 			span.setAttributes(buildAiSdkInstrumentationAttributes());
 			applyRequestModelAttributes(span, event);
 			if (this.recordInputs) {
 				if (event.tools) try {
 					span.setAttribute("gen_ai.tool.definitions", JSON.stringify(event.tools));
 				} catch (e) {
-					this.logger.debug(`Failed to record span tool definitions: ${require_dist.errorMessage(e)}`);
+					this.logger.debug(`Failed to record span tool definitions: ${require_utils.errorMessage(e)}`);
 				}
 				const serialized = this.promptByCallId.get(callId);
 				if (serialized !== void 0) span.setAttribute("gen_ai.input.messages", serialized);
@@ -9083,9 +9222,9 @@ var LaminarAiSdkTelemetry = class {
 			const span = llm.span;
 			if (typeof event.provider === "string") {
 				const provider = normalizeProvider$1(event.provider);
-				if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
+				if (provider) span.setAttribute(require_utils.LaminarAttributes.PROVIDER, provider);
 			}
-			if (typeof event.modelId === "string") span.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, event.modelId);
+			if (typeof event.modelId === "string") span.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, event.modelId);
 			if (typeof event.finishReason === "string") applyFinishReason(span, event.finishReason);
 			if (typeof event.responseId === "string") span.setAttribute("gen_ai.response.id", event.responseId);
 			applyUsageToSpan(span, event.usage);
@@ -9140,7 +9279,7 @@ var LaminarAiSdkTelemetry = class {
 			if (typeof event.finishReason === "string") applyFinishReason(step.span, event.finishReason);
 			if (this.recordOutputs) {
 				const outputMessages = buildVerbatimOutputMessages(Array.isArray(event.content) ? event.content : void 0);
-				if (outputMessages) step.span.setAttribute(require_dist.SPAN_OUTPUT, outputMessages);
+				if (outputMessages) step.span.setAttribute(require_utils.SPAN_OUTPUT, outputMessages);
 			}
 			step.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 			step.span.end();
@@ -9152,7 +9291,7 @@ var LaminarAiSdkTelemetry = class {
 			const op = this.operationByCallId.get(callId);
 			if (!op) return;
 			const span = getTracer().startSpan(`ai.llm ${event.provider ?? ""}:${event.modelId ?? ""}`, { kind: _opentelemetry_api.SpanKind.CLIENT }, op.ctx);
-			span.setAttribute(require_dist.SPAN_TYPE, "LLM");
+			span.setAttribute(require_utils.SPAN_TYPE, "LLM");
 			span.setAttributes(buildAiSdkInstrumentationAttributes());
 			applyRequestModelAttributes(span, event);
 			if (this.recordInputs && Array.isArray(event?.promptMessages)) {
@@ -9173,7 +9312,7 @@ var LaminarAiSdkTelemetry = class {
 			if (typeof event.finishReason === "string") applyFinishReason(llm.span, event.finishReason);
 			const response = event?.response;
 			if (response && typeof response === "object") {
-				if (typeof response.modelId === "string") llm.span.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, response.modelId);
+				if (typeof response.modelId === "string") llm.span.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, response.modelId);
 				if (typeof response.id === "string") llm.span.setAttribute("gen_ai.response.id", response.id);
 			}
 			applyUsageToSpan(llm.span, event.usage);
@@ -9196,14 +9335,14 @@ var LaminarAiSdkTelemetry = class {
 			if (!parentCtx) return;
 			const span = getTracer().startSpan(`ai.tool ${toolName ?? "unknown"}`, { kind: _opentelemetry_api.SpanKind.CLIENT }, parentCtx);
 			const spanCtx = _opentelemetry_api.trace.setSpan(parentCtx, span);
-			span.setAttribute(require_dist.SPAN_TYPE, "TOOL");
+			span.setAttribute(require_utils.SPAN_TYPE, "TOOL");
 			span.setAttributes(buildAiSdkInstrumentationAttributes());
 			if (toolName) span.setAttribute("ai.toolCall.name", toolName);
 			span.setAttribute("ai.toolCall.id", toolCallId);
 			if (this.recordInputs && toolCall?.input !== void 0) {
 				const serialized = serializeJSON$1(toolCall.input);
 				span.setAttribute("ai.toolCall.args", serialized);
-				span.setAttribute(require_dist.SPAN_INPUT, serialized);
+				span.setAttribute(require_utils.SPAN_INPUT, serialized);
 			}
 			this.toolByCallId.set(toolCallId, {
 				span,
@@ -9228,14 +9367,14 @@ var LaminarAiSdkTelemetry = class {
 						message
 					});
 					if (this.recordOutputs) {
-						tool.span.setAttribute(require_dist.SPAN_OUTPUT, message);
+						tool.span.setAttribute(require_utils.SPAN_OUTPUT, message);
 						tool.span.setAttribute("ai.toolCall.error", message);
 					}
 				} else if (output.type === "tool-result") {
 					if (this.recordOutputs && output.output !== void 0) {
 						const serialized = serializeJSON$1(output.output);
 						tool.span.setAttribute("ai.toolCall.result", serialized);
-						tool.span.setAttribute(require_dist.SPAN_OUTPUT, serialized);
+						tool.span.setAttribute(require_utils.SPAN_OUTPUT, serialized);
 					}
 					tool.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 				}
@@ -9256,7 +9395,7 @@ var LaminarAiSdkTelemetry = class {
 			if (!callId) return;
 			const op = this.operationByCallId.get(callId);
 			if (!op) return;
-			if (typeof event.modelId === "string") op.span.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, event.modelId);
+			if (typeof event.modelId === "string") op.span.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
 		};
 		this.onEmbedEnd = (event) => {
 			const callId = event?.callId;
@@ -9276,7 +9415,7 @@ var LaminarAiSdkTelemetry = class {
 			if (op.operationId === "ai.embed" || op.operationId === "ai.embedMany" || op.operationId === "ai.rerank") applyUsageToSpan(op.span, event.totalUsage ?? event.usage);
 			if (this.recordOutputs) {
 				const outputMessages = buildVerbatimOutputMessages(Array.isArray(event.content) ? event.content : void 0);
-				if (outputMessages) op.span.setAttribute(require_dist.SPAN_OUTPUT, outputMessages);
+				if (outputMessages) op.span.setAttribute(require_utils.SPAN_OUTPUT, outputMessages);
 				if (event.embedding !== void 0) {
 					const emb = event.embedding;
 					if (Array.isArray(emb) && Array.isArray(emb[0])) op.span.setAttribute("ai.embed.count", emb.length);
@@ -9284,7 +9423,7 @@ var LaminarAiSdkTelemetry = class {
 				}
 				if (Array.isArray(event.ranking)) {
 					op.span.setAttribute("ai.rerank.ranking", serializeJSON$1(event.ranking));
-					op.span.setAttribute(require_dist.SPAN_OUTPUT, serializeJSON$1(event.ranking));
+					op.span.setAttribute(require_utils.SPAN_OUTPUT, serializeJSON$1(event.ranking));
 				}
 			}
 			if (event.finishReason === "error") op.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
@@ -9559,10 +9698,10 @@ const stringifyArgs = (raw) => {
 const formatUsage = (usage) => {
 	if (!usage) return {};
 	const out = {};
-	if (typeof usage.inputTokens === "number") out[require_dist.LaminarAttributes.INPUT_TOKEN_COUNT] = usage.inputTokens;
-	if (typeof usage.outputTokens === "number") out[require_dist.LaminarAttributes.OUTPUT_TOKEN_COUNT] = usage.outputTokens;
+	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_dist.LaminarAttributes.TOTAL_TOKEN_COUNT] = total;
+	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;
@@ -9570,7 +9709,7 @@ const formatUsage = (usage) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/mastra/exporter.ts
-const logger = require_dist.initializeLogger();
+const logger = require_utils.initializeLogger();
 /**
 * Bridges Mastra's ObservabilityExporter contract to Laminar's OTLP ingestion.
 *
@@ -9634,7 +9773,7 @@ var MastraExporter = class {
 		try {
 			await processor.forceFlush();
 		} catch (err) {
-			logger.error(`[MastraExporter] forceFlush failed: ${require_dist.errorMessage(err)}`);
+			logger.error(`[MastraExporter] forceFlush failed: ${require_utils.errorMessage(err)}`);
 		}
 	}
 	shutdown() {
@@ -9664,7 +9803,7 @@ var MastraExporter = class {
 		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_dist.otelSpanIdToUUID(require_dist.normalizeOtelSpanId(span.id));
+		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);
@@ -9703,7 +9842,7 @@ var MastraExporter = class {
 			otelSpan.end(endTime);
 			if (this.config.realtime) await getSpanProcessor()?.forceFlush();
 		} catch (err) {
-			logger.error(`[MastraExporter] failed to export span ${span.id}: ${require_dist.errorMessage(err)}`);
+			logger.error(`[MastraExporter] failed to export span ${span.id}: ${require_utils.errorMessage(err)}`);
 		} finally {
 			traceState.activeSpanIds.delete(span.id);
 			if (traceState.activeSpanIds.size === 0) this.traceMap.delete(span.traceId);
@@ -9814,13 +9953,13 @@ var MastraExporter = class {
 			const activeSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
 			const ctx = activeSpan?.spanContext();
 			if (ctx && ctx.traceId && ctx.spanId) {
-				created.otelTraceId = require_dist.normalizeOtelTraceId(ctx.traceId);
-				created.otelRootParentSpanId = require_dist.normalizeOtelSpanId(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_dist.SPAN_PATH];
+					const parentPath = attrs[require_utils.SPAN_PATH];
 					if (Array.isArray(parentPath) && parentPath.every((p) => typeof p === "string")) created.otelParentSpanPath = parentPath;
-					const parentIdsPath = attrs[require_dist.SPAN_IDS_PATH];
+					const parentIdsPath = attrs[require_utils.SPAN_IDS_PATH];
 					if (Array.isArray(parentIdsPath) && parentIdsPath.every((p) => typeof p === "string")) created.otelParentSpanIdsPath = parentIdsPath;
 				}
 			}
@@ -9829,7 +9968,7 @@ var MastraExporter = class {
 		return created;
 	}
 	startOtelSpan(span, traceState) {
-		const tracer = getTracerProvider().getTracer("@lmnr-ai/lmnr", require_dist.version);
+		const tracer = getTracerProvider().getTracer("@lmnr-ai/lmnr", require_utils.version);
 		const parentCtx = this.buildParentContext(span, traceState);
 		const otelSpan = tracer.startSpan(span.name, {
 			startTime: dateToHrTime(span.startTime),
@@ -9840,14 +9979,14 @@ var MastraExporter = class {
 			return;
 		}
 		const sdkAllocatedSpanId = otelSpan.spanContext().spanId;
-		const mastraSpanId = require_dist.normalizeOtelSpanId(span.id);
-		const mastraTraceId = traceState.otelTraceId ?? require_dist.normalizeOtelTraceId(span.traceId);
+		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) getSpanProcessor()?.dropPathInfo(sdkAllocatedSpanId);
-		const parentSpanIdNormalized = span.parentSpanId ? require_dist.normalizeOtelSpanId(span.parentSpanId) : traceState.otelRootParentSpanId;
+		const parentSpanIdNormalized = span.parentSpanId ? require_utils.normalizeOtelSpanId(span.parentSpanId) : traceState.otelRootParentSpanId;
 		if (parentSpanIdNormalized) {
 			const parentSpanContext = {
 				traceId: mastraTraceId,
@@ -9865,8 +10004,8 @@ var MastraExporter = class {
 		});
 		const spanPath = traceState.spanPathById.get(span.id);
 		const spanIdsPath = traceState.spanIdsPathById.get(span.id);
-		if (spanPath) otelSpan.setAttribute(require_dist.SPAN_PATH, spanPath);
-		if (spanIdsPath) otelSpan.setAttribute(require_dist.SPAN_IDS_PATH, spanIdsPath);
+		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() {
@@ -9893,39 +10032,39 @@ var MastraExporter = class {
 	}
 	applyEndAttributes(span, otelSpan, traceState) {
 		const attributes = this.buildLaminarAttributes(span, traceState);
-		delete attributes[require_dist.SPAN_PATH];
-		delete attributes[require_dist.SPAN_IDS_PATH];
+		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_dist.SPAN_PATH] = spanPath;
-		if (spanIdsPath) attributes[require_dist.SPAN_IDS_PATH] = spanIdsPath;
+		if (spanPath) attributes[require_utils.SPAN_PATH] = spanPath;
+		if (spanIdsPath) attributes[require_utils.SPAN_IDS_PATH] = spanIdsPath;
 		const laminarSpanType = mapLaminarSpanType(span.type);
-		attributes[require_dist.SPAN_TYPE] = laminarSpanType;
-		attributes[require_dist.SPAN_INSTRUMENTATION_SOURCE] = "javascript";
-		attributes[require_dist.SPAN_SDK_VERSION] = require_dist.version;
+		attributes[require_utils.SPAN_TYPE] = laminarSpanType;
+		attributes[require_utils.SPAN_INSTRUMENTATION_SOURCE] = "javascript";
+		attributes[require_utils.SPAN_SDK_VERSION] = require_utils.version;
 		const langVersion = getLangVersion();
-		if (langVersion) attributes[require_dist.SPAN_LANGUAGE_VERSION] = langVersion;
+		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_dist.SESSION_ID] = sessionId;
+		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_dist.USER_ID] = userId;
+		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_dist.ASSOCIATION_PROPERTIES}.metadata.${key}`] = av;
+			if (av !== void 0) attributes[`${require_utils.ASSOCIATION_PROPERTIES}.metadata.${key}`] = av;
 		}
-		if (span.isRootSpan && span.tags?.length) attributes[`${require_dist.ASSOCIATION_PROPERTIES}.tags`] = span.tags;
+		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_dist.SPAN_INPUT] = serializeJSON(span.input);
-			if (span.output !== void 0) attributes[require_dist.SPAN_OUTPUT] = serializeJSON(span.output);
+			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;
 	}
@@ -9938,10 +10077,10 @@ var MastraExporter = class {
 		const provider = generationAttrs?.provider;
 		const model = generationAttrs?.model;
 		const responseModel = generationAttrs?.responseModel;
-		if (provider) attributes[require_dist.LaminarAttributes.PROVIDER] = normalizeProvider(provider);
-		if (model) attributes[require_dist.LaminarAttributes.REQUEST_MODEL] = model;
-		if (responseModel) attributes[require_dist.LaminarAttributes.RESPONSE_MODEL] = responseModel;
-		else if (model) attributes[require_dist.LaminarAttributes.RESPONSE_MODEL] = model;
+		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") {
@@ -9954,7 +10093,7 @@ var MastraExporter = class {
 			if (turn) messages.push(...turn);
 		}
 		if (messages.length > 0) attributes["ai.prompt.messages"] = serializeJSON(messages);
-		else if (span.input !== void 0) attributes[require_dist.SPAN_INPUT] = serializeJSON(span.input);
+		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") {
@@ -9993,11 +10132,11 @@ var MastraExporter = class {
 					parts
 				}]);
 			}
-		} else if (out !== void 0) attributes[require_dist.SPAN_OUTPUT] = serializeJSON(out);
+		} else if (out !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(out);
 	}
 	applyToolAttributes(span, attributes) {
-		if (span.input !== void 0) attributes[require_dist.SPAN_INPUT] = serializeJSON(span.input);
-		if (span.output !== void 0) attributes[require_dist.SPAN_OUTPUT] = serializeJSON(span.output);
+		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;
@@ -10013,8 +10152,8 @@ exports.LAMINAR_TEMPORAL_SPAN_CONTEXT_HEADER = require_consts.LAMINAR_SPAN_CONTE
 exports.LAMINAR_TEMPORAL_TRACEPARENT_HEADER = require_consts.TRACEPARENT_HEADER;
 exports.Laminar = Laminar;
 exports.LaminarAiSdkTelemetry = LaminarAiSdkTelemetry;
-exports.LaminarAttributes = require_dist.LaminarAttributes;
-exports.LaminarClient = require_dist.LaminarClient;
+exports.LaminarAttributes = require_utils.LaminarAttributes;
+exports.LaminarClient = require_utils.LaminarClient;
 exports.LaminarDataset = LaminarDataset;
 exports.LaminarReporter = LaminarReporter;
 exports.LaminarSpanProcessor = LaminarSpanProcessor;
@@ -10024,7 +10163,7 @@ exports.LaminarTemporalInterceptors = LaminarTemporalInterceptors;
 exports.LaminarTemporalScheduleClientInterceptor = ScheduleClientInterceptor;
 exports.LaminarTemporalWorkflowClientInterceptor = WorkflowClientInterceptor;
 exports.MastraExporter = MastraExporter;
-exports.TracingLevel = require_dist.TracingLevel;
+exports.TracingLevel = require_utils.TracingLevel;
 exports.aiSdkTelemetry = aiSdkTelemetry;
 exports.enableAiSdkTelemetryDebug = enableAiSdkTelemetryDebug;
 exports.evaluate = evaluate;