@lmnr-ai/lmnr 0.8.30 → 0.8.32

package/dist/index.cjs

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chunk = require("./chunk-BN4qSVkS.cjs");
-const require_utils = require("./utils-C_Pf3r64.cjs");
-const require_dist = require("./dist-Cyli7uVF.cjs");
-const require_consts = require("./consts-Cx9iKRmq.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
+const require_dist = require("./dist-CDaxruok.cjs");
+const require_consts = require("./consts-DV6_Ea-8.cjs");
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
 let _opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
@@ -10,7 +9,7 @@ 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_chunk.__toESM(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");
@@ -26,11 +25,11 @@ let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let fs = require("fs");
-fs = require_chunk.__toESM(fs);
+fs = require_rolldown_runtime.__toESM(fs);
 let net = require("net");
-net = require_chunk.__toESM(net);
+net = require_rolldown_runtime.__toESM(net);
 let os = require("os");
-os = require_chunk.__toESM(os);
+os = require_rolldown_runtime.__toESM(os);
 let async_hooks = require("async_hooks");
 let zod_to_json_schema = require("zod-to-json-schema");
 let _opentelemetry_core = require("@opentelemetry/core");
@@ -38,11 +37,11 @@ let _grpc_grpc_js = require("@grpc/grpc-js");
 let _opentelemetry_exporter_trace_otlp_grpc = require("@opentelemetry/exporter-trace-otlp-grpc");
 let _opentelemetry_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
 let cli_progress = require("cli-progress");
-cli_progress = require_chunk.__toESM(cli_progress);
+cli_progress = require_rolldown_runtime.__toESM(cli_progress);
 let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 let node_diagnostics_channel = require("node:diagnostics_channel");
-node_diagnostics_channel = require_chunk.__toESM(node_diagnostics_channel);
+node_diagnostics_channel = require_rolldown_runtime.__toESM(node_diagnostics_channel);
 //#region src/datasets.ts
 const DEFAULT_FETCH_SIZE = 25;
 var EvaluationDataset = class {
@@ -96,7 +95,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-Cysp1Ym1.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-DWqUwg2p.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");
@@ -112,7 +111,7 @@ var LaminarDataset = class extends EvaluationDataset {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/compat.ts
-const logger$24 = require_utils.initializeLogger();
+const logger$24 = require_dist.initializeLogger();
 const makeSpanOtelV2Compatible = (span) => {
 	const spanAny = span;
 	if (spanAny.instrumentationScope && !spanAny.instrumentationLibrary) Object.assign(span, { instrumentationLibrary: spanAny.instrumentationScope });
@@ -228,7 +227,7 @@ const consumeAISDKResult = async (result) => {
 		} catch (error) {
 			errors.push({
 				field: key,
-				error: require_utils.errorMessage(error)
+				error: require_dist.errorMessage(error)
 			});
 		}
 	};
@@ -340,7 +339,7 @@ const consumeResponse = async (response) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/stream-utils.ts
-const logger$23 = require_utils.initializeLogger();
+const logger$23 = require_dist.initializeLogger();
 const pendingStreamProcessing = /* @__PURE__ */ new Set();
 /**
 * Wait for all pending stream processing to complete with a timeout
@@ -383,15 +382,15 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 			try {
 				partialOutput = await consumeAISDKResult(streamInfo.result);
 				if (shouldSendTraces() && !ignoreOutput) try {
-					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
+					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (error) {
-					logger$23.warn("Failed to serialize AI SDK stream output: " + require_utils.errorMessage(error));
+					logger$23.warn("Failed to serialize AI SDK stream output: " + require_dist.errorMessage(error));
 				}
 			} catch (error) {
 				if (Object.keys(partialOutput).length > 0 && shouldSendTraces() && !ignoreOutput) try {
-					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
+					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (serError) {
-					logger$23.warn("Failed to serialize partial AI SDK output: " + require_utils.errorMessage(serError));
+					logger$23.warn("Failed to serialize partial AI SDK output: " + require_dist.errorMessage(serError));
 				}
 				span.recordException(error);
 			} finally {
@@ -412,9 +411,9 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "stream",
 						chunks
 					};
-					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$23.warn("Failed to serialize stream output: " + require_utils.errorMessage(serError));
+					logger$23.warn("Failed to serialize stream output: " + require_dist.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
@@ -435,9 +434,9 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "async-iterable",
 						chunks
 					};
-					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$23.warn("Failed to serialize async iterable output: " + require_utils.errorMessage(serError));
+					logger$23.warn("Failed to serialize async iterable output: " + require_dist.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
@@ -468,9 +467,9 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 						type: "response",
 						chunks
 					};
-					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
+					span.setAttribute(require_dist.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$23.warn("Failed to serialize response output: " + require_utils.errorMessage(serError));
+					logger$23.warn("Failed to serialize response output: " + require_dist.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} catch (err) {
@@ -487,50 +486,67 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 	return originalResult;
 };
 //#endregion
-//#region src/debug/pointer.ts
+//#region src/debug/debug-session-file.ts
+const str = (v) => typeof v === "string" && v.length > 0 ? v : null;
 /**
-* Emit the debug-run pointer (§5, §I).
-*
-* On a debug run we always print one console line prefixed with `LMNR_DEBUG_RUN `
-* followed by compact JSON. When `LMNR_DEBUG_WRITE_LAST_RUN_TO_FILE` is set the
-* same payload is also written to `${CWD}/.lmnr/last-run.json` (best-effort: any
-* IO error is swallowed so a read-only working directory never breaks the run).
-*
-* Part of the cross-language parity surface — keep line-comparable with the
-* Python `pointer.py` (identical key order, prefix, and best-effort semantics).
+* Read `${dir ?? cwd}/.lmnr/debug-session.json`. Best-effort: returns null on a
+* missing / unreadable / malformed file, or one with no usable `session_id`
+* (the caller treats null as "no existing session" and mints a fresh one).
 */
-const logger$22 = require_utils.initializeLogger();
-const CONSOLE_PREFIX = "LMNR_DEBUG_RUN ";
-const POINTER_DIR = ".lmnr";
-const POINTER_FILE = "last-run.json";
+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 r = JSON.parse(raw);
+		const session_id = str(r.session_id);
+		if (!session_id) return null;
+		return {
+			session_id,
+			trace_id: str(r.trace_id),
+			replay_trace_id: str(r.replay_trace_id),
+			cache_until: str(r.cache_until),
+			debugger_url: str(r.debugger_url),
+			started_at: str(r.started_at) ?? (/* @__PURE__ */ new Date()).toISOString()
+		};
+	} catch {
+		return null;
+	}
+};
 /**
-* Build the pointer payload. Key order matches the Python SDK.
-*
-* `startedAt` is the run's start time, captured by `DebugRuntime` at SDK init so
-* the pointer reflects when tracing began rather than when it was emitted
-* (shutdown). Defaults to now for standalone callers.
+* Find the nearest directory (walking up from `startDir` to the filesystem
+* root) whose `.lmnr/debug-session.json` holds a usable session record, so a
+* debug run started from a subdirectory of a project joins the project's
+* session. Returns null when no ancestor (including `startDir`) has one.
 */
-const buildPointer = (args) => ({
-	trace_id: args.traceId,
-	session_id: args.sessionId,
-	replay_trace_id: args.replayTraceId,
-	cache_until: args.cacheUntil,
-	debugger_url: args.debuggerUrl,
-	started_at: args.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-});
-/** Print the console line, then best-effort write the pointer file. */
-const emitPointer = (pointer) => {
-	const payload = JSON.stringify(pointer);
-	console.log(`${CONSOLE_PREFIX}${payload}`);
-	if (process.env.LMNR_DEBUG_WRITE_LAST_RUN_TO_FILE) writePointerFile(payload);
+const findDebugSessionDir = (startDir = process.cwd()) => {
+	let dir = (0, node_path.resolve)(startDir);
+	const root = (0, node_path.parse)(dir).root;
+	while (true) {
+		if (readDebugSessionFile(dir) !== null) return dir;
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir || dir === root) return null;
+		dir = parent;
+	}
 };
-const writePointerFile = (payload) => {
+/**
+* The directory the debug-session file should be read from AND written to: the
+* nearest ancestor (incl. `startDir`) that already has one, else `startDir`
+* itself. Read and write MUST share this anchor — reading from an ancestor but
+* writing to cwd would strand the ancestor's copy stale and shadow it with a
+* nested one.
+*/
+const resolveDebugSessionDir = (startDir = process.cwd()) => findDebugSessionDir(startDir) ?? (0, node_path.resolve)(startDir);
+/**
+* Write the debug-session file (mkdir -p first). Best-effort: swallows any IO
+* error so a read-only working directory never breaks a run.
+*/
+const writeDebugSessionFile = (file, dir = process.cwd()) => {
 	try {
-		const directory = (0, node_path.join)(process.cwd(), POINTER_DIR);
+		const directory = (0, node_path.join)(dir, require_dist.DEBUG_SESSION_DIR);
 		(0, node_fs.mkdirSync)(directory, { recursive: true });
-		(0, node_fs.writeFileSync)((0, node_path.join)(directory, POINTER_FILE), payload, { encoding: "utf-8" });
-	} catch (e) {
-		logger$22.debug(`Could not write debug pointer file: ${String(e)}`);
+		(0, node_fs.writeFileSync)((0, node_path.join)(directory, require_dist.DEBUG_SESSION_FILE), JSON.stringify(file), "utf-8");
+		return true;
+	} catch {
+		return false;
 	}
 };
 //#endregion
@@ -543,7 +559,7 @@ const writePointerFile = (payload) => {
 * contract. This file is part of the cross-language parity surface — keep its
 * logic line-comparable with the Python `config.py`.
 */
-const logger$21 = require_utils.initializeLogger();
+const logger$22 = require_dist.initializeLogger();
 const TRUTHY = new Set([
 	"true",
 	"1",
@@ -579,27 +595,10 @@ const parseCacheUntil = (value) => {
 	if (value === void 0 || value === "") return null;
 	const spanId = normalizeSpanId(value);
 	if (spanId !== null) return spanId;
-	logger$21.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
+	logger$22.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
 	return null;
 };
 /**
-* Read `${CWD}/.lmnr/last-run.json` (the previous run's pointer).
-*
-* Best-effort: a missing / unreadable / malformed file returns {} so the caller
-* silently falls back to env vars. Keep line-comparable with the Python
-* `_load_last_run`.
-*/
-const loadLastRun = () => {
-	try {
-		const path = (0, node_path.join)(process.cwd(), POINTER_DIR, POINTER_FILE);
-		const data = JSON.parse((0, node_fs.readFileSync)(path, { encoding: "utf-8" }));
-		return data !== null && typeof data === "object" ? data : {};
-	} catch (e) {
-		logger$21.debug(`Could not read debug pointer file: ${String(e)}`);
-		return {};
-	}
-};
-/**
 * True when both a replay trace and a cache-until span id are set, i.e. at least
 * one call should consult the cache. The server resolves the span-id window, so
 * the SDK only needs both ids present to arm replay.
@@ -611,25 +610,32 @@ const replayEnabledForConfig = (config) => config.replayTraceId !== null && conf
 * Returns null when debug mode is disabled (LMNR_DEBUG falsey/absent) — the
 * caller treats null as "everything inert".
 *
-* When `LMNR_DEBUG_FROM_LAST_RUN` is truthy, seed the config from the previous
-* run's pointer file (`${CWD}/.lmnr/last-run.json`): the file's `trace_id` (the
-* trace that run produced) becomes this run's `replayTraceId`, and its
-* `session_id` / `cache_until` are reused. Individual `LMNR_DEBUG_*` env vars
-* still override per-field, so the agent can replay the last run without
-* copying its ids into the environment by hand.
+* The `.lmnr/debug-session.json` file is now DEFAULT-ON: it is read
+* unconditionally (no opt-in env gate). The decision tree:
+*
+*  1. Read the file (best-effort → `existing | null`).
+*  2. `sessionId` precedence: `LMNR_DEBUG_SESSION_ID` → `existing.session_id` →
+*     a freshly-minted UUID.
+*  3. `sessionMinted` is true ONLY when we minted (neither env nor file supplied
+*     a session id). A file-present run is a CONTINUATION: it rejoins the same
+*     session silently (no browser).
+*  4. `replayTraceId`: `LMNR_DEBUG_REPLAY_TRACE_ID` → `existing.replay_trace_id`
+*     → null. NOTE: continuation is NOT auto-replay — we do NOT promote the prior
+*     run's `trace_id` into `replayTraceId`. Replay is armed explicitly by the
+*     agent via the env var or the file's `replay_trace_id`.
+*  5. `cacheUntilSpanId`: parsed from `LMNR_DEBUG_CACHE_UNTIL ??
+*     existing.cache_until`.
 */
 const buildDebugConfig = () => {
 	if (!isTruthy(process.env.LMNR_DEBUG)) return null;
-	const lastRun = isTruthy(process.env.LMNR_DEBUG_FROM_LAST_RUN) ? loadLastRun() : {};
-	const providedSessionId = process.env.LMNR_DEBUG_SESSION_ID || lastRun.session_id;
+	const existing = readDebugSessionFile(resolveDebugSessionDir());
+	const providedSessionId = process.env.LMNR_DEBUG_SESSION_ID || existing?.session_id || void 0;
 	const sessionId = providedSessionId || (0, node_crypto.randomUUID)();
-	const sessionMinted = providedSessionId === void 0 && !isTruthy(process.env.LMNR_DEBUG_FROM_LAST_RUN);
-	const replayTraceId = process.env.LMNR_DEBUG_REPLAY_TRACE_ID || lastRun.trace_id || null;
-	const lastRunCacheUntil = typeof lastRun.cache_until === "string" ? lastRun.cache_until : void 0;
+	const sessionMinted = providedSessionId === void 0;
 	return {
 		sessionId,
-		replayTraceId,
-		cacheUntilSpanId: parseCacheUntil(process.env.LMNR_DEBUG_CACHE_UNTIL ?? lastRunCacheUntil),
+		replayTraceId: process.env.LMNR_DEBUG_REPLAY_TRACE_ID || existing?.replay_trace_id || null,
+		cacheUntilSpanId: parseCacheUntil(process.env.LMNR_DEBUG_CACHE_UNTIL ?? existing?.cache_until ?? void 0),
 		localOrigin: true,
 		sessionMinted
 	};
@@ -662,6 +668,46 @@ const buildDebugConfigFromContext = (debug) => {
 	};
 };
 //#endregion
+//#region src/debug/pointer.ts
+const CONSOLE_PREFIX = "LMNR_DEBUG_RUN ";
+/**
+* Build the persisted debug-session record.
+*
+* `startedAt` is the run's start time, captured by `DebugRuntime` at SDK init so
+* the record reflects when tracing began rather than when it was emitted
+* (shutdown). Defaults to now for standalone callers.
+*/
+const buildDebugSessionFile = (args) => ({
+	session_id: args.sessionId,
+	trace_id: args.traceId,
+	replay_trace_id: args.replayTraceId,
+	cache_until: args.cacheUntil,
+	debugger_url: args.debuggerUrl,
+	started_at: args.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+});
+/**
+* Print the console line, then best-effort write the debug-session file.
+*
+* The pointer is emitted at shutdown (via the `exit` hook / `Laminar.shutdown()`),
+* which can be long after the run started. If a newer session was minted in the
+* meantime — e.g. `lmnr-cli debug session new` reset `.lmnr/debug-session.json`
+* while this (older) process was still running — blindly writing our in-memory
+* session would clobber that fresher session id. So skip the file write when the
+* on-disk `session_id` is present and differs from ours; we no longer own the
+* file. The console marker is always printed regardless.
+*
+* The file location is the nearest-ancestor anchor (`resolveDebugSessionDir`),
+* matching where startup (`config.ts`) read the session from — the guard's
+* re-read and the write must hit the SAME file or the guard is meaningless.
+*/
+const emitPointer = (file) => {
+	console.log(`${CONSOLE_PREFIX}${JSON.stringify(file)}`);
+	const dir = resolveDebugSessionDir();
+	const onDisk = readDebugSessionFile(dir);
+	if (onDisk !== null && onDisk.session_id !== file.session_id) return;
+	writeDebugSessionFile(file, dir);
+};
+//#endregion
 //#region src/debug/index.ts
 /**
 * Holds the immutable debug config plus the handle used to look up the
@@ -797,21 +843,22 @@ var DebugRuntime = class {
 		return `${this._debuggerUrl}/project/${this._projectId}/debugger-sessions/${this._config.sessionId}`;
 	}
 	/**
-	* Emit the run pointer once (console line + best-effort file).
+	* Emit the debug-session record once (console line + best-effort file write
+	* to `.lmnr/debug-session.json`).
 	*
 	* No-op on a downstream run (`localOrigin: false`): a runtime armed from a
 	* propagated `DebugContext` joins the upstream replay session and must NOT
-	* write a run pointer — the origin owns it. Gated here (not just at the call
-	* sites) so `shutdown()` and any exit hook stay safe. Mirrors Python's
+	* own/overwrite the file — the origin owns it. Gated here (not just at the
+	* call sites) so `shutdown()` and any exit hook stay safe. Mirrors Python's
 	* `emit_pointer`.
 	*/
 	emitPointer() {
 		if (!this._config.localOrigin) return;
 		if (this._emitted) return;
 		this._emitted = true;
-		emitPointer(buildPointer({
-			traceId: this._traceId ?? "",
+		emitPointer(buildDebugSessionFile({
 			sessionId: this._config.sessionId,
+			traceId: this._traceId,
 			replayTraceId: this._config.replayTraceId,
 			cacheUntil: this._config.cacheUntilSpanId,
 			debuggerUrl: this.debuggerSessionUrl(),
@@ -899,7 +946,7 @@ const resetDebugRuntime = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/span.ts
-const logger$20 = require_utils.initializeLogger();
+const logger$21 = require_dist.initializeLogger();
 /**
 * Build the debug block to propagate, or undefined when debug mode is off.
 *
@@ -1004,24 +1051,24 @@ var LaminarSpan = class LaminarSpan {
 		return this._span.recordException(exception, time);
 	}
 	setTraceSessionId(sessionId) {
-		this._span.setAttribute(require_utils.SESSION_ID, sessionId);
+		this._span.setAttribute(require_dist.SESSION_ID, sessionId);
 	}
 	setTraceUserId(userId) {
-		this._span.setAttribute(require_utils.USER_ID, userId);
+		this._span.setAttribute(require_dist.USER_ID, userId);
 	}
 	setTraceMetadata(metadata) {
-		this._span.setAttributes(require_utils.metadataToAttributes(metadata));
+		this._span.setAttributes(require_dist.metadataToAttributes(metadata));
 	}
 	setInput(input) {
 		const finalInput = typeof input === "string" ? input : JSON.stringify(input);
-		this._span.setAttribute(require_utils.SPAN_INPUT, finalInput);
+		this._span.setAttribute(require_dist.SPAN_INPUT, finalInput);
 	}
 	setOutput(output) {
 		const finalOutput = typeof output === "string" ? output : JSON.stringify(output);
-		this._span.setAttribute(require_utils.SPAN_OUTPUT, finalOutput);
+		this._span.setAttribute(require_dist.SPAN_OUTPUT, finalOutput);
 	}
 	setTags(tags) {
-		this._span.setAttribute(`${require_utils.ASSOCIATION_PROPERTIES}.tags`, Array.from(new Set(tags)));
+		this._span.setAttribute(`${require_dist.ASSOCIATION_PROPERTIES}.tags`, Array.from(new Set(tags)));
 	}
 	addTags(tags) {
 		const currentTags = this.tags;
@@ -1033,26 +1080,26 @@ var LaminarSpan = class LaminarSpan {
 		let userId;
 		let sessionId;
 		let traceType;
-		let tracingLevel = require_utils.TracingLevel.ALL;
+		let tracingLevel = require_dist.TracingLevel.ALL;
 		const metadata = {};
 		if (this._span.attributes) {
-			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;
+			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;
 			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_utils.ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
+				metadata[key.replace(`${require_dist.ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
 			}
-		} else logger$20.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$21.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_utils.otelSpanIdToUUID(this._span.spanContext().spanId),
-			traceId: require_utils.otelTraceIdToUUID(this._span.spanContext().traceId),
+			spanId: require_dist.otelSpanIdToUUID(this._span.spanContext().spanId),
+			traceId: require_dist.otelTraceIdToUUID(this._span.spanContext().traceId),
 			isRemote: this._span.spanContext().isRemote ?? false,
 			spanPath,
 			spanIdsPath,
@@ -1067,23 +1114,23 @@ var LaminarSpan = class LaminarSpan {
 	spanId(format = "otel") {
 		const spanId = this._span.spanContext().spanId;
 		if (format === "otel") return spanId;
-		return require_utils.otelSpanIdToUUID(spanId);
+		return require_dist.otelSpanIdToUUID(spanId);
 	}
 	traceId(format = "otel") {
 		const traceId = this._span.spanContext().traceId;
 		if (format === "otel") return traceId;
-		return require_utils.otelTraceIdToUUID(traceId);
+		return require_dist.otelTraceIdToUUID(traceId);
 	}
 	get tags() {
 		if (!this._span.attributes) {
-			logger$20.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$21.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$20.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$21.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 {
@@ -1093,14 +1140,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_utils.ASSOCIATION_PROPERTIES}.metadata.`, "");
+					const metaKey = key.replace(`${require_dist.ASSOCIATION_PROPERTIES}.metadata.`, "");
 					try {
 						value = JSON.parse(value);
 					} catch {}
 					metadata[metaKey] = value;
 				}
 			}
-			properties.tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_utils.TracingLevel.ALL;
+			properties.tracingLevel = this._span.attributes[`lmnr.association.properties.tracing_level`] ?? require_dist.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;
@@ -1279,7 +1326,7 @@ var LaminarContextManager = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/proxy.ts
-const logger$19 = require_utils.initializeLogger();
+const logger$20 = require_dist.initializeLogger();
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 const DEFAULT_CC_PROXY_PORT = 45667;
 const CC_PROXY_PORT_ATTEMPTS = 50;
@@ -1352,7 +1399,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$19.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$20.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))) {
@@ -1361,7 +1408,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$19.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$20.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))) {
@@ -1443,11 +1490,11 @@ const waitForPort = (port, timeoutMs = 5e3) => new Promise((resolve) => {
 const registerGlobalProxyShutdown = () => {
 	if (!globalShutdownRegistered) {
 		process.on("exit", () => {
-			logger$19.debug("process.on(\"exit\") called - stopping all active proxies");
+			logger$20.debug("process.on(\"exit\") called - stopping all active proxies");
 			for (const proxyServer of activeProxyServers) try {
 				proxyServer.stopServer();
 			} catch (e) {
-				logger$19.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
+				logger$20.debug(`Failed to stop proxy: ${require_dist.errorMessage(e)}`);
 			}
 			activeProxyServers.clear();
 		});
@@ -1462,28 +1509,28 @@ const createProxyInstance = async ({ env }) => {
 	try {
 		const port = await findAvailablePort(DEFAULT_CC_PROXY_PORT, CC_PROXY_PORT_ATTEMPTS);
 		if (port === null) {
-			logger$19.warn("Unable to allocate port for cc-proxy.");
+			logger$20.warn("Unable to allocate port for cc-proxy.");
 			return null;
 		}
 		const targetUrl = resolveTargetUrlFromEnv(env);
 		if (!targetUrl) {
-			logger$19.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
+			logger$20.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
 			return null;
 		}
-		logger$19.debug(`Creating proxy instance on port ${port} targeting: ${targetUrl}`);
+		logger$20.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$19.warn(`cc-proxy failed to start on port ${port}`);
+				logger$20.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$19.info(`Started claude proxy server on: ${proxyBaseUrl}`);
+			logger$20.info(`Started claude proxy server on: ${proxyBaseUrl}`);
 			return {
 				server: proxyServer,
 				baseUrl: proxyBaseUrl,
@@ -1491,11 +1538,11 @@ const createProxyInstance = async ({ env }) => {
 				targetUrl
 			};
 		} catch (e) {
-			logger$19.warn(`Unable to start cc-proxy: ${require_utils.errorMessage(e)}`);
+			logger$20.warn(`Unable to start cc-proxy: ${require_dist.errorMessage(e)}`);
 			return null;
 		}
 	} catch (e) {
-		logger$19.warn(`Failed to create proxy instance: ${require_utils.errorMessage(e)}`);
+		logger$20.warn(`Failed to create proxy instance: ${require_dist.errorMessage(e)}`);
 		return null;
 	}
 };
@@ -1505,11 +1552,11 @@ const createProxyInstance = async ({ env }) => {
 const stopProxyInstance = (instance) => {
 	if (!instance) return;
 	try {
-		logger$19.debug(`Stopping proxy instance on port ${instance.port}`);
+		logger$20.debug(`Stopping proxy instance on port ${instance.port}`);
 		instance.server.stopServer();
 		activeProxyServers.delete(instance.server);
 	} catch (e) {
-		logger$19.debug(`Failed to stop proxy instance: ${require_utils.errorMessage(e)}`);
+		logger$20.debug(`Failed to stop proxy instance: ${require_dist.errorMessage(e)}`);
 	}
 };
 /**
@@ -1517,11 +1564,11 @@ const stopProxyInstance = (instance) => {
 * Used during shutdown to ensure cleanup
 */
 const forceReleaseProxy = () => {
-	logger$19.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
+	logger$20.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
 	for (const proxyServer of activeProxyServers) try {
 		proxyServer.stopServer();
 	} catch (e) {
-		logger$19.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
+		logger$20.debug(`Failed to stop proxy: ${require_dist.errorMessage(e)}`);
 	}
 	activeProxyServers.clear();
 };
@@ -1538,8 +1585,8 @@ const getSpanContextPayload = () => {
 	try {
 		const readableSpan = currentSpan;
 		if (readableSpan.attributes) {
-			const idsPath = readableSpan.attributes[require_utils.SPAN_IDS_PATH];
-			const path$1 = readableSpan.attributes[require_utils.SPAN_PATH];
+			const idsPath = readableSpan.attributes[require_dist.SPAN_IDS_PATH];
+			const path$1 = readableSpan.attributes[require_dist.SPAN_PATH];
 			if (Array.isArray(idsPath)) spanIdsPath = idsPath;
 			if (Array.isArray(path$1)) spanPath = path$1;
 		}
@@ -1571,14 +1618,14 @@ const setTraceToProxyInstance = async (instance) => {
 			spanPath: payload.span_path,
 			laminarUrl: payload.laminar_url
 		});
-		logger$19.debug(`Set trace context to proxy on port ${instance.port}`);
+		logger$20.debug(`Set trace context to proxy on port ${instance.port}`);
 	} catch (e) {
-		logger$19.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_utils.errorMessage(e));
+		logger$20.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_dist.errorMessage(e));
 	}
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/index.ts
-const logger$18 = require_utils.initializeLogger();
+const logger$19 = require_dist.initializeLogger();
 /**
 * Create an instrumented version of the claude-agent-sdk query function.
 * This can be used when importing the query function before Laminar initialization.
@@ -1593,7 +1640,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 			name: "query",
 			spanType: "DEFAULT"
 		});
-		span.setAttribute(require_utils.SPAN_INPUT, JSON.stringify({ prompt: typeof params.prompt === "string" ? params.prompt : "<stream>" }));
+		span.setAttribute(require_dist.SPAN_INPUT, JSON.stringify({ prompt: typeof params.prompt === "string" ? params.prompt : "<stream>" }));
 		const generator = async function* () {
 			const collected = [];
 			let proxyInstance = null;
@@ -1605,9 +1652,9 @@ function instrumentClaudeAgentQuery(originalQuery) {
 				const targetUrl = resolveTargetUrlFromEnv(mergedEnv);
 				proxyInstance = await createProxyInstance({ env: mergedEnv });
 				if (proxyInstance && targetUrl) {
-					logger$18.debug(`Using proxy on port ${proxyInstance.port}`);
+					logger$19.debug(`Using proxy on port ${proxyInstance.port}`);
 					await Laminar.withSpan(span, async () => {
-						logger$18.debug("Setting trace to proxy instance...");
+						logger$19.debug("Setting trace to proxy instance...");
 						await setTraceToProxyInstance(proxyInstance);
 					});
 					const varsToRemove = getEnvVarsToRemove(mergedEnv);
@@ -1620,7 +1667,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					if (params.options.env.CLAUDE_CODE_USE_FOUNDRY === "1") params.options.env.ANTHROPIC_FOUNDRY_BASE_URL = proxyInstance.baseUrl;
 					if (params.options.env.CLAUDE_CODE_USE_BEDROCK === "1") params.options.env.ANTHROPIC_BEDROCK_BASE_URL = proxyInstance.baseUrl;
 					if (params.options.env.CLAUDE_CODE_USE_VERTEX === "1") params.options.env.ANTHROPIC_VERTEX_BASE_URL = proxyInstance.baseUrl;
-				} else logger$18.debug("No claude proxy server available. Proceeding without proxy.");
+				} else logger$19.debug("No claude proxy server available. Proceeding without proxy.");
 				const originalGenerator = originalQuery(params);
 				for await (const message of originalGenerator) {
 					collected.push(message);
@@ -1633,7 +1680,7 @@ function instrumentClaudeAgentQuery(originalQuery) {
 				throw error;
 			} finally {
 				stopProxyInstance(proxyInstance);
-				span.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(collected));
+				span.setAttribute(require_dist.SPAN_OUTPUT, JSON.stringify(collected));
 				span.end();
 			}
 		};
@@ -1649,7 +1696,7 @@ var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation
 	}
 	manuallyInstrument(claudeAgentModule) {
 		if (claudeAgentModule.query && typeof claudeAgentModule.query === "function") this._wrap(claudeAgentModule, "query", this.patchQuery());
-		else logger$18.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
+		else logger$19.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
 	}
 	patchQuery() {
 		return (original) => instrumentClaudeAgentQuery(original);
@@ -1666,8 +1713,8 @@ var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation
 };
 //#endregion
 //#region src/laminar.ts
-require_utils.loadEnv();
-const logger$17 = require_utils.initializeLogger();
+require_dist.loadEnv();
+const logger$18 = require_dist.initializeLogger();
 var Laminar = class Laminar {
 	static {
 		this.isInitialized = false;
@@ -1753,11 +1800,11 @@ var Laminar = class Laminar {
 	*/
 	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor } = {}) {
 		if (this.isInitialized) {
-			logger$17.warn("Laminar has already been initialized. Skipping initialization.");
+			logger$18.warn("Laminar has already been initialized. Skipping initialization.");
 			return;
 		}
 		const key = projectApiKey ?? process?.env?.LMNR_PROJECT_API_KEY;
-		require_utils.validateTracingConfig(key);
+		require_dist.validateTracingConfig(key);
 		this.projectApiKey = key ?? "";
 		let url = baseUrl ?? process?.env?.LMNR_BASE_URL;
 		if (key && !url) url = "https://api.lmnr.ai";
@@ -1777,7 +1824,7 @@ var Laminar = class Laminar {
 			...metadata ?? {}
 		};
 		if (inheritGlobalContext) LaminarContextManager.inheritGlobalContext = true;
-		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$17.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
+		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$18.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, "");
@@ -1810,9 +1857,9 @@ var Laminar = class Laminar {
 		const envContext = process?.env?.LMNR_SPAN_CONTEXT;
 		if (!envContext) return;
 		try {
-			const laminarContext = require_utils.deserializeLaminarSpanContext(envContext);
+			const laminarContext = require_dist.deserializeLaminarSpanContext(envContext);
 			this._armDebugRuntimeFromContext(laminarContext.debug);
-			const otelSpanContext = require_utils.tryToOtelSpanContext(laminarContext);
+			const otelSpanContext = require_dist.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);
@@ -1820,13 +1867,13 @@ var Laminar = class Laminar {
 			const ctx = LaminarContextManager.setRawAssociationProperties(laminarContext, baseContext);
 			LaminarContextManager.pushContext(ctx);
 			try {
-				getRuntime()?.recordTraceId(require_utils.otelTraceIdToUUID(otelSpanContext.traceId));
+				getRuntime()?.recordTraceId(require_dist.otelTraceIdToUUID(otelSpanContext.traceId));
 			} catch (e) {
-				logger$17.debug("Failed to record debug trace id from env: " + require_utils.errorMessage(e));
+				logger$18.debug("Failed to record debug trace id from env: " + require_dist.errorMessage(e));
 			}
-			logger$17.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
+			logger$18.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
 		} catch (e) {
-			logger$17.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_utils.errorMessage(e));
+			logger$18.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_dist.errorMessage(e));
 		}
 	}
 	/**
@@ -1863,21 +1910,21 @@ var Laminar = class Laminar {
 				projectApiKey: this.projectApiKey,
 				port: httpPort
 			});
-			const debuggerUrl = process?.env?.LMNR_FRONTEND_URL ?? require_utils.getFrontendUrl(baseUrl);
+			const debuggerUrl = process?.env?.LMNR_FRONTEND_URL ?? require_dist.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$17.info(`Laminar debugger session: ${sessionUrl}`);
+					logger$18.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$17.warn("Failed to register debug session: " + require_utils.errorMessage(e));
+				logger$18.warn("Failed to register debug session: " + require_dist.errorMessage(e));
 			});
 			this.globalMetadata = {
 				...this.globalMetadata,
@@ -1887,7 +1934,7 @@ var Laminar = class Laminar {
 			this.debugExitHook = () => runtime.emitPointer();
 			process.once("exit", this.debugExitHook);
 		} catch (e) {
-			logger$17.warn("Failed to initialize debug runtime: " + require_utils.errorMessage(e));
+			logger$18.warn("Failed to initialize debug runtime: " + require_dist.errorMessage(e));
 		}
 	}
 	/**
@@ -1925,14 +1972,14 @@ var Laminar = class Laminar {
 				baseUrl: this.baseUrlForDebug,
 				projectApiKey: this.projectApiKey,
 				port: this.httpPortForDebug
-			}).rolloutSessions, process?.env?.LMNR_FRONTEND_URL ?? require_utils.getFrontendUrl(this.baseUrlForDebug));
+			}).rolloutSessions, process?.env?.LMNR_FRONTEND_URL ?? require_dist.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$17.debug("Failed to register downstream debug session: " + require_utils.errorMessage(e));
+					logger$18.debug("Failed to register downstream debug session: " + require_dist.errorMessage(e));
 				});
 				this.globalMetadata = {
 					...this.globalMetadata,
@@ -1941,7 +1988,7 @@ var Laminar = class Laminar {
 				LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 			}
 		} catch (e) {
-			logger$17.debug("Failed to arm debug runtime from context: " + require_utils.errorMessage(e));
+			logger$18.debug("Failed to arm debug runtime from context: " + require_dist.errorMessage(e));
 		}
 	}
 	/**
@@ -1956,7 +2003,7 @@ var Laminar = class Laminar {
 	*/
 	static patch(modules) {
 		if (!this.isInitialized) {
-			logger$17.warn("Laminar must be initialized before patching modules. Skipping patch.");
+			logger$18.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");
@@ -2204,7 +2251,7 @@ var Laminar = class Laminar {
 		let parentUserId;
 		let parentSessionId;
 		if (parentSpanContext) try {
-			const laminarContext = typeof parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+			const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 			parentPath = laminarContext.spanPath;
 			parentIdsPath = laminarContext.spanIdsPath;
 			parentMetadata = laminarContext.metadata;
@@ -2213,38 +2260,38 @@ var Laminar = class Laminar {
 			parentUserId = laminarContext.userId;
 			parentSessionId = laminarContext.sessionId;
 			this._armDebugRuntimeFromContext(laminarContext.debug);
-			const spanContext = require_utils.tryToOtelSpanContext(laminarContext);
+			const spanContext = require_dist.tryToOtelSpanContext(laminarContext);
 			entityContext = _opentelemetry_api.trace.setSpan(entityContext, _opentelemetry_api.trace.wrapSpanContext(spanContext));
 		} catch (e) {
-			logger$17.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
+			logger$18.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
 		}
-		const tagProperties = tags ? { [`${require_utils.ASSOCIATION_PROPERTIES}.tags`]: Array.from(new Set(tags)) } : {};
+		const tagProperties = tags ? { [`${require_dist.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_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({
+		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({
 			...this.globalMetadata,
 			...ctxMetadata,
 			...parentMetadata,
 			...metadata
 		});
 		const attributes = {
-			[require_utils.SPAN_TYPE]: spanType ?? "DEFAULT",
+			[require_dist.SPAN_TYPE]: spanType ?? "DEFAULT",
 			...tagProperties,
 			...userIdProperties,
 			...sessionIdProperties,
 			...metadataProperties,
 			...traceTypeProperties,
 			...tracingLevelProperties,
-			...parentPath ? { [require_utils.PARENT_SPAN_PATH]: parentPath } : {},
-			...parentIdsPath ? { [require_utils.PARENT_SPAN_IDS_PATH]: parentIdsPath } : {}
+			...parentPath ? { [require_dist.PARENT_SPAN_PATH]: parentPath } : {},
+			...parentIdsPath ? { [require_dist.PARENT_SPAN_IDS_PATH]: parentIdsPath } : {}
 		};
 		const span = new LaminarSpan(getTracer().startSpan(name, {
 			attributes,
@@ -2319,13 +2366,13 @@ var Laminar = class Laminar {
 	}
 	static async flush() {
 		if (this.isInitialized) {
-			logger$17.debug("Flushing spans");
+			logger$18.debug("Flushing spans");
 			await forceFlush();
 		}
 	}
 	static async shutdown() {
 		if (this.isInitialized) {
-			logger$17.debug("Shutting down Laminar");
+			logger$18.debug("Shutting down Laminar");
 			getRuntime()?.emitPointer();
 			await forceFlush();
 			this.isInitialized = false;
@@ -2460,7 +2507,7 @@ return module.exports;
 //#endregion
 //#region src/browser/utils.ts
 const LMNR_SEND_EVENTS_FUNCTION_NAME = "lmnrSendEvents";
-const logger$16 = require_utils.initializeLogger();
+const logger$17 = require_dist.initializeLogger();
 /**
 * If the first argument is a string, return an object with the name of the method
 * and the argument as the value.
@@ -2483,7 +2530,7 @@ const takeFullSnapshot = async (page) => await page.evaluate(() => {
 		window.lmnrRrweb.record.takeFullSnapshot();
 		return true;
 	} catch (error) {
-		logger$16.error("Error taking full snapshot: " + require_utils.errorMessage(error));
+		logger$17.error("Error taking full snapshot: " + require_dist.errorMessage(error));
 		return false;
 	}
 	return false;
@@ -2494,7 +2541,7 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 			try {
 				return await script();
 			} catch (error) {
-				logger$16.error("Operation " + script.name + " failed: " + require_utils.errorMessage(error));
+				logger$17.error("Operation " + script.name + " failed: " + require_dist.errorMessage(error));
 			}
 			await new Promise((resolve) => setTimeout(resolve, 500));
 		}
@@ -2504,20 +2551,20 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 	try {
 		isRrwebPresent = await castedPage.evaluate(() => typeof window.lmnrRrweb !== "undefined");
 	} catch (error) {
-		logger$16.debug("Failed to check if session recorder is loaded: " + require_utils.errorMessage(error));
+		logger$17.debug("Failed to check if session recorder is loaded: " + require_dist.errorMessage(error));
 	}
 	if (!isRrwebPresent) {
 		if (!await tryRunScript(async function injectSessionRecorder() {
 			await castedPage.evaluate(RECORDER);
 			return true;
 		})) {
-			logger$16.error("Failed to load session recorder");
+			logger$17.error("Failed to load session recorder");
 			return;
 		}
 		try {
 			await castedPage.evaluate(injectScript, sessionRecordingOptions);
 		} catch (error) {
-			logger$16.debug("Failed to inject session recorder: " + require_utils.errorMessage(error));
+			logger$17.debug("Failed to inject session recorder: " + require_dist.errorMessage(error));
 		}
 	}
 };
@@ -2780,7 +2827,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 	try {
 		const { batchId, chunkIndex, totalChunks, data } = chunk;
 		if (!sessionId || !traceId) {
-			logger$16.debug("Missing sessionId or traceId in chunk");
+			logger$17.debug("Missing sessionId or traceId in chunk");
 			return;
 		}
 		if (!chunkBuffers.has(batchId)) chunkBuffers.set(batchId, {
@@ -2799,7 +2846,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 				traceId,
 				events
 			}).catch((error) => {
-				logger$16.debug("Failed to send events: " + require_utils.errorMessage(error));
+				logger$17.debug("Failed to send events: " + require_dist.errorMessage(error));
 			});
 			chunkBuffers.delete(batchId);
 		}
@@ -2807,16 +2854,16 @@ 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$16.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
+			logger$17.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
 			chunkBuffers.delete(bid);
 		}
 	} catch (error) {
-		logger$16.debug("Could not send events: " + require_utils.errorMessage(error));
+		logger$17.debug("Could not send events: " + require_dist.errorMessage(error));
 	}
 }
 //#endregion
 //#region src/browser/playwright.ts
-const logger$15 = require_utils.initializeLogger();
+const logger$16 = require_dist.initializeLogger();
 var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/playwright-instrumentation", require_dist.version, { enabled: true });
@@ -2880,7 +2927,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_utils.newUUID();
+			const sessionId = require_dist.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);
@@ -2894,7 +2941,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_utils.newUUID();
+			const sessionId = require_dist.newUUID();
 			context.on("page", async (page) => plugin.patchPage(page, sessionId));
 			for (const page of context.pages()) await plugin.patchPage(page, sessionId);
 			return context;
@@ -2917,14 +2964,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_utils.TRACE_HAS_BROWSER_SESSION, true);
+		currentSpan?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
 		const otelTraceId = currentSpan?.spanContext().traceId;
-		const traceId = otelTraceId ? require_utils.otelTraceIdToUUID(otelTraceId) : require_utils.NIL_UUID;
+		const traceId = otelTraceId ? require_dist.otelTraceIdToUUID(otelTraceId) : require_dist.NIL_UUID;
 		page.on("domcontentloaded", async () => {
 			try {
 				await injectSessionRecorder(page, this._sessionRecordingOptions);
 			} catch (error) {
-				logger$15.error("Error in onLoad handler: " + require_utils.errorMessage(error));
+				logger$16.error("Error in onLoad handler: " + require_dist.errorMessage(error));
 			}
 		});
 		const chunkBuffers = /* @__PURE__ */ new Map();
@@ -2934,7 +2981,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$15.debug("Could not expose function " + LMNR_SEND_EVENTS_FUNCTION_NAME + ": " + require_utils.errorMessage(error));
+			logger$16.debug("Could not expose function lmnrSendEvents: " + require_dist.errorMessage(error));
 		}
 	}
 };
@@ -2961,7 +3008,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_utils.SPAN_TYPE]: "LLM",
+			[require_dist.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 } : {},
@@ -3099,7 +3146,7 @@ var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.In
 	patchStagehandInit() {
 		const instrumentation = this;
 		return (original) => async function method() {
-			const sessionId = require_utils.newUUID();
+			const sessionId = require_dist.newUUID();
 			const parentSpan = Laminar.startSpan({ name: "Stagehand" });
 			instrumentation.playwrightInstrumentation.setParentSpanForSession(sessionId, parentSpan);
 			const result = await original.bind(this).apply(this);
@@ -3359,7 +3406,7 @@ var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.In
 };
 //#endregion
 //#region src/browser/puppeteer.ts
-const logger$14 = require_utils.initializeLogger();
+const logger$15 = require_dist.initializeLogger();
 var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/puppeteer-instrumentation", require_dist.version, { enabled: true });
@@ -3399,15 +3446,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_utils.newUUID();
+			const sessionId = require_dist.newUUID();
 			for (const context of browser.browserContexts()) {
 				context.on("targetcreated", (target) => {
 					target.page().then((page) => {
 						if (page) plugin.patchPage(page, sessionId).catch((error) => {
-							logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+							logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 						});
 					}).catch((error) => {
-						logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 					});
 				});
 				await Promise.all((await context.pages()).map((page) => plugin.patchPage(page, sessionId)));
@@ -3421,23 +3468,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_utils.newUUID();
+			const sessionId = require_dist.newUUID();
 			context.on("targetcreated", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+					logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 				});
 			});
 			context.on("targetchanged", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$14.error("Failed to patch page: " + require_utils.errorMessage(error));
+					logger$15.error("Failed to patch page: " + require_dist.errorMessage(error));
 				});
 			});
 			for (const page of await context.pages()) await plugin.patchPage(page, sessionId);
@@ -3456,12 +3503,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_utils.TRACE_HAS_BROWSER_SESSION, true);
+		currentSpan?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
 		const otelTraceId = currentSpan?.spanContext().traceId;
-		const traceId = otelTraceId ? require_utils.otelTraceIdToUUID(otelTraceId) : require_utils.NIL_UUID;
+		const traceId = otelTraceId ? require_dist.otelTraceIdToUUID(otelTraceId) : require_dist.NIL_UUID;
 		page.on("domcontentloaded", () => {
 			injectSessionRecorder(page, this._sessionRecordingOptions).catch((error) => {
-				logger$14.error("Error in onLoad handler: " + require_utils.errorMessage(error));
+				logger$15.error("Error in onLoad handler: " + require_dist.errorMessage(error));
 			});
 		});
 		await injectSessionRecorder(page, this._sessionRecordingOptions);
@@ -3471,13 +3518,13 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$14.debug("Could not expose function " + LMNR_SEND_EVENTS_FUNCTION_NAME + ": " + require_utils.errorMessage(error));
+			logger$15.debug("Could not expose function lmnrSendEvents: " + require_dist.errorMessage(error));
 		}
 	}
 };
 //#endregion
 //#region src/browser/stagehand/v3/constants.ts
-const logger$13 = require_utils.initializeLogger();
+const logger$14 = require_dist.initializeLogger();
 const CDP_OPERATION_TIMEOUT_MS = 1e4;
 const SKIP_URL_PATTERNS = [
 	"about:blank",
@@ -3528,7 +3575,7 @@ async function getOrCreateIsolatedWorld(page) {
 			frameId
 		};
 	} catch (error) {
-		logger$13.debug("Failed to create isolated world: " + require_utils.errorMessage(error));
+		logger$14.debug("Failed to create isolated world: " + require_dist.errorMessage(error));
 		return null;
 	}
 }
@@ -3545,7 +3592,7 @@ async function isRecorderPresent(page, contextId) {
 		if (!result) return true;
 		return result.result?.value === true;
 	} catch (error) {
-		logger$13.debug("Failed to check if recorder is present: " + require_utils.errorMessage(error));
+		logger$14.debug("Failed to check if recorder is present: " + require_dist.errorMessage(error));
 		return true;
 	}
 }
@@ -3558,21 +3605,21 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 		try {
 			url = page.url();
 		} catch (error) {
-			logger$13.debug("Failed to get page URL, page might be closed: " + require_utils.errorMessage(error));
+			logger$14.debug("Failed to get page URL, page might be closed: " + require_dist.errorMessage(error));
 			return null;
 		}
 		if (shouldSkipUrl(url)) {
-			logger$13.debug(`Skipping recorder injection for URL: ${url}`);
+			logger$14.debug(`Skipping recorder injection for URL: ${url}`);
 			return null;
 		}
 		const worldResult = await getOrCreateIsolatedWorld(page);
 		if (!worldResult) {
-			logger$13.debug("Failed to get isolated world for page");
+			logger$14.debug("Failed to get isolated world for page");
 			return null;
 		}
 		const { contextId, frameId } = worldResult;
 		if (await isRecorderPresent(page, contextId)) {
-			logger$13.debug("Recorder already present, skipping injection");
+			logger$14.debug("Recorder already present, skipping injection");
 			state.contextIdToSession.set(contextId, {
 				sessionId: state.sessionId,
 				traceId: state.traceId
@@ -3585,7 +3632,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$13.debug("Failed to inject rrweb: " + require_utils.errorMessage(error));
+			logger$14.debug("Failed to inject rrweb: " + require_dist.errorMessage(error));
 			return null;
 		}
 		const optionsJson = JSON.stringify(sessionRecordingOptions ?? {});
@@ -3596,14 +3643,14 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$13.debug("Failed to inject recording setup: " + require_utils.errorMessage(error));
+			logger$14.debug("Failed to inject recording setup: " + require_dist.errorMessage(error));
 			return null;
 		}
 		try {
 			await sendCDP(page, "Runtime.addBinding", { name: "lmnrSendEvents" });
-			logger$13.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
+			logger$14.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
 		} catch (error) {
-			logger$13.debug("Binding may already exist: " + require_utils.errorMessage(error));
+			logger$14.debug("Binding may already exist: " + require_dist.errorMessage(error));
 		}
 		if (bindingHandler) try {
 			const pageTargetId = page.targetId();
@@ -3613,26 +3660,26 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 					const sessionTyped = session;
 					if (sessionTyped.on) {
 						sessionTyped.on("Runtime.bindingCalled", bindingHandler);
-						logger$13.debug(`Set up binding handler on session ${sessionId}`);
+						logger$14.debug(`Set up binding handler on session ${sessionId}`);
 					}
 				} catch (error) {
-					logger$13.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_utils.errorMessage(error));
+					logger$14.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_dist.errorMessage(error));
 				}
 				state.pageSessionHandlers.set(pageTargetId, bindingHandler);
 			}
 		} catch (error) {
-			logger$13.debug("Failed to set up binding handler: " + require_utils.errorMessage(error));
+			logger$14.debug("Failed to set up binding handler: " + require_dist.errorMessage(error));
 		}
 		state.contextIdToSession.set(contextId, {
 			sessionId: state.sessionId,
 			traceId: state.traceId
 		});
-		logger$13.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
+		logger$14.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
 		state.instrumentedPageIds.add(frameId);
-		logger$13.debug(`Successfully injected recorder into page ${frameId}`);
+		logger$14.debug(`Successfully injected recorder into page ${frameId}`);
 		return contextId;
 	} catch (error) {
-		logger$13.debug("Error injecting recorder: " + require_utils.errorMessage(error));
+		logger$14.debug("Error injecting recorder: " + require_dist.errorMessage(error));
 		return null;
 	}
 }
@@ -3646,13 +3693,13 @@ function createBindingHandler(state) {
 		if (event.name !== "lmnrSendEvents") return;
 		const sessionInfo = state.contextIdToSession.get(event.executionContextId);
 		if (!sessionInfo) {
-			logger$13.debug("No session info found for context ID: " + event.executionContextId);
+			logger$14.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$13.debug("Failed to parse binding payload: " + require_utils.errorMessage(error));
+					logger$14.debug("Failed to parse binding payload: " + require_dist.errorMessage(error));
 				}
 			}
 			return;
@@ -3660,7 +3707,7 @@ function createBindingHandler(state) {
 		try {
 			sendEvents(JSON.parse(event.payload), state.client, state.chunkBuffers, sessionInfo.sessionId, sessionInfo.traceId);
 		} catch (error) {
-			logger$13.debug("Failed to handle binding event: " + require_utils.errorMessage(error));
+			logger$14.debug("Failed to handle binding event: " + require_dist.errorMessage(error));
 		}
 	};
 }
@@ -3676,10 +3723,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$13.debug("Error injecting recorder into new page: " + require_utils.errorMessage(error));
+				logger$14.debug("Error injecting recorder into new page: " + require_dist.errorMessage(error));
 			}
 		} catch (error) {
-			logger$13.debug("Error handling target created event: " + require_utils.errorMessage(error));
+			logger$14.debug("Error handling target created event: " + require_dist.errorMessage(error));
 		}
 	};
 }
@@ -3691,7 +3738,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 		if (event.targetInfo.type !== "page") return;
 		const url = event.targetInfo.url;
 		if (shouldSkipUrl(url)) return;
-		logger$13.debug(`Target URL changed to ${url}, checking if recorder injection needed`);
+		logger$14.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) {
@@ -3699,7 +3746,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 				break;
 			}
 		} catch (error) {
-			logger$13.debug("Error handling target info change: " + require_utils.errorMessage(error));
+			logger$14.debug("Error handling target info change: " + require_dist.errorMessage(error));
 		}
 	};
 }
@@ -3824,13 +3871,13 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	patchStagehandInit() {
 		const instrumentation = this;
 		return (original) => async function method() {
-			const sessionId = require_utils.newUUID();
+			const sessionId = require_dist.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_utils.TRACE_HAS_BROWSER_SESSION, true);
+			(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
 			const otelTraceId = parentSpan.spanContext().traceId;
-			const traceId = require_utils.otelTraceIdToUUID(otelTraceId);
+			const traceId = require_dist.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));
@@ -3860,12 +3907,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	*/
 	async setupSessionRecording(stagehandInstance, sessionId, traceId) {
 		if (!this._client) {
-			logger$13.debug("No Laminar client available, skipping session recording setup");
+			logger$14.debug("No Laminar client available, skipping session recording setup");
 			return;
 		}
 		const context = stagehandInstance.context;
 		if (!context || !context.conn) {
-			logger$13.debug("No context or connection available, skipping session recording setup");
+			logger$14.debug("No context or connection available, skipping session recording setup");
 			return;
 		}
 		const recorderState = {
@@ -3895,11 +3942,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$13.debug("Error injecting recorder into page: " + require_utils.errorMessage(error));
+				logger$14.debug("Error injecting recorder into page: " + require_dist.errorMessage(error));
 			}
-			logger$13.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
+			logger$14.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
 		} catch (error) {
-			logger$13.debug("Error accessing pages for recorder injection: " + require_utils.errorMessage(error));
+			logger$14.debug("Error accessing pages for recorder injection: " + require_dist.errorMessage(error));
 		}
 	}
 	patchStagehandClose() {
@@ -3929,12 +3976,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			if (recorderState.targetCreatedHandler) try {
 				context.conn.off("Target.targetCreated", recorderState.targetCreatedHandler);
 			} catch (error) {
-				logger$13.debug("Error removing target created handler: " + require_utils.errorMessage(error));
+				logger$14.debug("Error removing target created handler: " + require_dist.errorMessage(error));
 			}
 			if (recorderState.targetInfoChangedHandler) try {
 				context.conn.off("Target.targetInfoChanged", recorderState.targetInfoChangedHandler);
 			} catch (error) {
-				logger$13.debug("Error removing target info changed handler: " + require_utils.errorMessage(error));
+				logger$14.debug("Error removing target info changed handler: " + require_dist.errorMessage(error));
 			}
 		}
 		recorderState.contextIdToSession.clear();
@@ -3945,7 +3992,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		recorderState.targetCreatedHandler = null;
 		recorderState.targetInfoChangedHandler = null;
 		this.stagehandInstanceToRecorderState.delete(stagehandInstance);
-		logger$13.debug("Cleaned up session recording for Stagehand instance");
+		logger$14.debug("Cleaned up session recording for Stagehand instance");
 	}
 	patchStagehandGlobalMethod(methodName, sessionId, parentSpan) {
 		return (original) => async function method(...args) {
@@ -3975,7 +4022,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_utils.TRACE_HAS_BROWSER_SESSION, true);
+				(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan())?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
 				return await original.apply(thisArg, rest);
 			}, this, args));
 		};
@@ -4085,7 +4132,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_utils.TRACE_HAS_BROWSER_SESSION, true);
+				span?.setAttribute(require_dist.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);
@@ -4187,7 +4234,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_utils.TRACE_HAS_BROWSER_SESSION, true);
+					span?.setAttribute(require_dist.TRACE_HAS_BROWSER_SESSION, true);
 					if (baseProvider) span?.setAttribute("gen_ai.system", baseProvider);
 					if (baseModel) span?.setAttribute("gen_ai.request.model", baseModel);
 					try {
@@ -4816,10 +4863,10 @@ const normalizeMessages = (data, role = "user") => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/messages.ts
-const logger$12 = require_utils.initializeLogger();
+const logger$13 = require_dist.initializeLogger();
 const setLmnrSpanIo = (lmnrSpan, inputData, 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));
+	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));
 };
 const setGenAiInputMessages = (lmnrSpan, inputData, systemInstructions) => {
 	const hasInput = inputData !== void 0 && inputData !== null;
@@ -4845,7 +4892,7 @@ const setGenAiOutputMessagesFromResponse = (lmnrSpan, response) => {
 	if (!outputItems) return;
 	const id = response.id;
 	if (!Array.isArray(outputItems)) {
-		logger$12.debug("Laminar OpenAI agents instrumentation, failed to parse output items. Expected array");
+		logger$13.debug("Laminar OpenAI agents instrumentation, failed to parse output items. Expected array");
 		outputItems = [];
 	}
 	const result = {
@@ -4882,9 +4929,9 @@ const applyLlmAttributes = (lmnrSpan, data) => {
 	if (!data) return;
 	const model = data.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
 	}
 	const usage = data.usage;
 	if (usage != null) applyUsage$1(lmnrSpan, usage);
@@ -4903,12 +4950,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_utils.LaminarAttributes.INPUT_TOKEN_COUNT, Number(inputTokens));
+	if (inputTokens !== void 0 && inputTokens !== null) lmnrSpan.setAttribute(require_dist.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_utils.LaminarAttributes.OUTPUT_TOKEN_COUNT, Number(outputTokens));
+	if (outputTokens !== void 0 && outputTokens !== null) lmnrSpan.setAttribute(require_dist.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_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));
+	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));
 };
 const responseToLlmData = (response) => {
 	if (response == null) return {};
@@ -5009,9 +5056,9 @@ const applyMcpSpanData = (lmnrSpan, spanData) => {
 const applySpeechSpanData = (lmnrSpan, spanData) => {
 	const model = spanData?.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
 	}
 	const inputText = spanData?.input;
 	if (inputText) setGenAiInputMessages(lmnrSpan, inputText);
@@ -5022,9 +5069,9 @@ const applySpeechSpanData = (lmnrSpan, spanData) => {
 const applyTranscriptionSpanData = (lmnrSpan, spanData) => {
 	const model = spanData?.model;
 	if (model) {
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, model);
-		lmnrSpan.setAttribute(require_utils.LaminarAttributes.PROVIDER, "openai");
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, model);
+		lmnrSpan.setAttribute(require_dist.LaminarAttributes.PROVIDER, "openai");
 	}
 	const inputData = spanData?.input;
 	if (inputData) if (typeof inputData === "object" && !Array.isArray(inputData)) setGenAiInputMessages(lmnrSpan, inputData.data);
@@ -5040,7 +5087,7 @@ const applySpeechGroupSpanData = (lmnrSpan, spanData) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/processor.ts
-const logger$11 = require_utils.initializeLogger();
+const logger$12 = require_dist.initializeLogger();
 var LaminarAgentsTraceProcessor = class {
 	constructor() {
 		this.traces = /* @__PURE__ */ new Map();
@@ -5058,7 +5105,7 @@ var LaminarAgentsTraceProcessor = class {
 			} catch {}
 			this.applyTraceMetadata(state.rootSpan, agentsTrace);
 		} catch (e) {
-			logger$11.debug(`Error in onTraceStart: ${String(e)}`);
+			logger$12.debug(`Error in onTraceStart: ${String(e)}`);
 		}
 	}
 	async onTraceEnd(agentsTrace) {
@@ -5107,7 +5154,7 @@ var LaminarAgentsTraceProcessor = class {
 			});
 			const key = span.spanId;
 			if (!key) {
-				logger$11.debug("Span missing spanId, cannot track");
+				logger$12.debug("Span missing spanId, cannot track");
 				try {
 					lmnrSpan.end();
 				} catch {}
@@ -5126,7 +5173,7 @@ var LaminarAgentsTraceProcessor = class {
 				activationContext
 			});
 		} catch (e) {
-			logger$11.debug(`Error in onSpanStart: ${String(e)}`);
+			logger$12.debug(`Error in onSpanStart: ${String(e)}`);
 			if (lmnrSpan !== void 0) try {
 				lmnrSpan.end();
 			} catch {}
@@ -5244,7 +5291,7 @@ var LaminarAgentsTraceProcessor = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/index.ts
-const logger$10 = require_utils.initializeLogger();
+const logger$11 = require_dist.initializeLogger();
 const wrapGetResponse = (original) => function(request, ...rest) {
 	const systemInstructions = request?.systemInstructions;
 	return runWithSystemInstructions(systemInstructions, () => original.call(this, request, ...rest));
@@ -5264,7 +5311,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 	}
 	manuallyInstrument(agentsModule) {
 		if (!agentsModule) {
-			logger$10.debug("@openai/agents module not provided, skipping");
+			logger$11.debug("@openai/agents module not provided, skipping");
 			return;
 		}
 		this.registerProcessor(agentsModule);
@@ -5274,7 +5321,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 		if (this._processor !== void 0) return;
 		const addTraceProcessor = module.addTraceProcessor;
 		if (typeof addTraceProcessor !== "function") {
-			logger$10.debug("addTraceProcessor not found in @openai/agents module");
+			logger$11.debug("addTraceProcessor not found in @openai/agents module");
 			return;
 		}
 		try {
@@ -5282,7 +5329,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 			addTraceProcessor(processor);
 			this._processor = processor;
 		} catch (e) {
-			logger$10.debug(`Failed to register Laminar Agents processor: ${String(e)}`);
+			logger$11.debug(`Failed to register Laminar Agents processor: ${String(e)}`);
 		}
 	}
 	patchModel(module) {
@@ -5295,7 +5342,7 @@ var OpenAIAgentsInstrumentation = class extends _opentelemetry_instrumentation.I
 				try {
 					this._wrap(cls.prototype, method, wrapper);
 				} catch (e) {
-					logger$10.debug(`Failed to wrap ${method}: ${String(e)}`);
+					logger$11.debug(`Failed to wrap ${method}: ${String(e)}`);
 				}
 			}
 			this._wrappedPrototypes.add(cls.prototype);
@@ -5401,7 +5448,7 @@ const getLangVersion = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/exporter.ts
-const logger$9 = require_utils.initializeLogger();
+const logger$10 = require_dist.initializeLogger();
 var LaminarSpanExporter = class {
 	constructor(options = {}) {
 		let url = options.baseUrl ?? process?.env?.LMNR_BASE_URL;
@@ -5413,15 +5460,15 @@ var LaminarSpanExporter = class {
 			headers = forceHttp ? { "Authorization": `Bearer ${key}` } : { "authorization": `Bearer ${key}` };
 			if (!url) url = "https://api.lmnr.ai";
 		} else {
-			const otelHeaders = require_utils.getOtelEnvVar("HEADERS");
-			if (otelHeaders) headers = require_utils.parseOtelHeaders(otelHeaders);
-			const otelEndpoint = require_utils.getOtelEnvVar("ENDPOINT");
+			const otelHeaders = require_dist.getOtelEnvVar("HEADERS");
+			if (otelHeaders) headers = require_dist.parseOtelHeaders(otelHeaders);
+			const otelEndpoint = require_dist.getOtelEnvVar("ENDPOINT");
 			if (otelEndpoint && !url) {
 				url = otelEndpoint;
-				const otelProtocol = require_utils.getOtelEnvVar("PROTOCOL") || "grpc/protobuf";
+				const otelProtocol = require_dist.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$9.warn("OTEL_ENDPOINT is set, but Laminar base URL is also set. Ignoring OTEL_ENDPOINT.");
+			} else if (otelEndpoint && url) logger$10.warn("OTEL_ENDPOINT is set, but Laminar base URL is also set. Ignoring OTEL_ENDPOINT.");
 		}
 		if (!url) throw new Error("Laminar base URL is not set and OTEL_ENDPOINT is not set. Please either\n- set the LMNR_BASE_URL environment variable\n- set the OTEL_ENDPOINT environment variable (if you are not using a Laminar API key)\n- pass the baseUrl parameter to Laminar.initialize");
 		if (!port) port = url.match(/:\d{1,5}$/g) ? parseInt(url.match(/:\d{1,5}$/g)[0].slice(1)) : forceHttp ? 443 : 8443;
@@ -5475,7 +5522,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 	constructor(options = {}) {
 		this._spanIdToPath = /* @__PURE__ */ new Map();
 		this._spanIdLists = /* @__PURE__ */ new Map();
-		this.logger = require_utils.initializeLogger();
+		this.logger = require_dist.initializeLogger();
 		if (options.spanProcessor && options.spanProcessor instanceof LaminarSpanProcessor) {
 			this.instance = options.spanProcessor.instance;
 			this._spanIdToPath = options.spanProcessor._spanIdToPath;
@@ -5497,37 +5544,37 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 	}
 	onStart(spanArg, parentContext) {
 		const span = spanArg;
-		const parentPathFromAttribute = span.attributes?.[require_utils.PARENT_SPAN_PATH];
-		const parentIdsPathFromAttribute = span.attributes?.[require_utils.PARENT_SPAN_IDS_PATH];
+		const parentPathFromAttribute = span.attributes?.[require_dist.PARENT_SPAN_PATH];
+		const parentIdsPathFromAttribute = span.attributes?.[require_dist.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) : []);
 		const spanPath = parentSpanPath ? [...parentSpanPath, span.name] : [span.name];
-		const spanIdUuid = require_utils.otelSpanIdToUUID(spanId);
+		const spanIdUuid = require_dist.otelSpanIdToUUID(spanId);
 		const spanIdsPath = parentSpanIdsPath ? [...parentSpanIdsPath, spanIdUuid] : [spanIdUuid];
-		span.setAttribute(require_utils.SPAN_IDS_PATH, spanIdsPath);
+		span.setAttribute(require_dist.SPAN_IDS_PATH, spanIdsPath);
 		this._spanIdLists.set(spanId, spanIdsPath);
-		span.setAttribute(require_utils.SPAN_PATH, spanPath);
+		span.setAttribute(require_dist.SPAN_PATH, spanPath);
 		_opentelemetry_api.context.active().setValue(CONTEXT_SPAN_PATH_KEY, spanPath);
 		this._spanIdToPath.set(spanId, spanPath);
-		span.setAttribute(require_utils.SPAN_INSTRUMENTATION_SOURCE, "javascript");
-		span.setAttribute(require_utils.SPAN_SDK_VERSION, require_dist.version);
+		span.setAttribute(require_dist.SPAN_INSTRUMENTATION_SOURCE, "javascript");
+		span.setAttribute(require_dist.SPAN_SDK_VERSION, require_dist.version);
 		const langVersion = getLangVersion();
-		if (langVersion) span.setAttribute(require_utils.SPAN_LANGUAGE_VERSION, langVersion);
+		if (langVersion) span.setAttribute(require_dist.SPAN_LANGUAGE_VERSION, langVersion);
 		const globalMetadata = LaminarContextManager.getGlobalMetadata();
-		if (globalMetadata && Object.keys(globalMetadata).length > 0) span.setAttributes(require_utils.metadataToAttributes(globalMetadata));
+		if (globalMetadata && Object.keys(globalMetadata).length > 0) span.setAttributes(require_dist.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_utils.ASSOCIATION_PROPERTIES_OVERRIDES).includes(key)) span.setAttribute(require_utils.ASSOCIATION_PROPERTIES_OVERRIDES[key], value);
+		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);
 		else if (key === "tracing_level") span.setAttribute("lmnr.internal.tracing_level", value);
 		else if (key === "metadata" && typeof value === "object" && value !== null) {
-			const metadataAttrs = require_utils.metadataToAttributes(value);
+			const metadataAttrs = require_dist.metadataToAttributes(value);
 			span.setAttributes(metadataAttrs);
-		} 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 === "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 === "tracingLevel") span.setAttribute("lmnr.internal.tracing_level", value);
-		else span.setAttribute(`${require_utils.ASSOCIATION_PROPERTIES}.${key}`, value);
+		else span.setAttribute(`${require_dist.ASSOCIATION_PROPERTIES}.${key}`, value);
 		makeSpanOtelV2Compatible(span);
 		if (parentSpanId === void 0) this.recordDebugTraceId(span);
 		this.instance.onStart(span, parentContext);
@@ -5541,7 +5588,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 		try {
 			const runtime = getRuntime();
 			if (runtime === null) return;
-			runtime.recordTraceId(require_utils.otelTraceIdToUUID(span.spanContext().traceId));
+			runtime.recordTraceId(require_dist.otelTraceIdToUUID(span.spanContext().traceId));
 		} catch (e) {
 			this.logger.debug(`Failed to record debug trace id: ${String(e)}`);
 		}
@@ -5582,7 +5629,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/temporal/helpers.ts
-const logger$8 = require_utils.initializeLogger();
+const logger$9 = require_dist.initializeLogger();
 const _enc = new TextEncoder();
 const _dec = new TextDecoder();
 const encodePayload = (value) => ({
@@ -5634,13 +5681,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_utils.deserializeLaminarSpanContext(laminarRaw);
+		const ctx = require_dist.deserializeLaminarSpanContext(laminarRaw);
 		return {
 			laminarCtx: ctx,
 			otelContext: pushLaminarContext(ctx)
 		};
 	} catch (e) {
-		logger$8.warn(`[Laminar] Could not restore ${require_consts.LAMINAR_SPAN_CONTEXT_HEADER}: ${require_utils.errorMessage(e)}`);
+		logger$9.warn(`[Laminar] Could not restore ${require_consts.LAMINAR_SPAN_CONTEXT_HEADER}: ${require_dist.errorMessage(e)}`);
 	}
 	const traceparent = decodePayload(headers[require_consts.TRACEPARENT_HEADER]);
 	if (traceparent) {
@@ -5649,8 +5696,8 @@ const restoreContextFromHeaders = (headers) => {
 			const [, traceHex, spanHex] = parts;
 			try {
 				const ctx = {
-					traceId: require_utils.otelTraceIdToUUID(traceHex),
-					spanId: require_utils.otelSpanIdToUUID(spanHex),
+					traceId: require_dist.otelTraceIdToUUID(traceHex),
+					spanId: require_dist.otelSpanIdToUUID(spanHex),
 					isRemote: true
 				};
 				return {
@@ -5658,7 +5705,7 @@ const restoreContextFromHeaders = (headers) => {
 					otelContext: pushLaminarContext(ctx)
 				};
 			} catch (e) {
-				logger$8.warn(`[Laminar] Could not restore traceparent: ${require_utils.errorMessage(e)}`);
+				logger$9.warn(`[Laminar] Could not restore traceparent: ${require_dist.errorMessage(e)}`);
 			}
 		}
 	}
@@ -5668,7 +5715,7 @@ const restoreContextFromHeaders = (headers) => {
 * return the enriched OTel `Context` that was pushed.
 */
 const pushLaminarContext = (laminarCtx) => {
-	const otelCtx = require_utils.tryToOtelSpanContext(laminarCtx);
+	const otelCtx = require_dist.tryToOtelSpanContext(laminarCtx);
 	otelCtx.isRemote = true;
 	const processor = getSpanProcessor();
 	if (processor instanceof LaminarSpanProcessor && laminarCtx.spanPath && laminarCtx.spanIdsPath) processor.setParentPathInfo(otelCtx.spanId, laminarCtx.spanPath, laminarCtx.spanIdsPath);
@@ -5837,7 +5884,7 @@ var ActivityInboundInterceptor = class {
 				if (this.recordActivityOutput) try {
 					span.setOutput(res);
 				} catch (e) {
-					this.logger.debug(`failed to set output to activity span: ${require_utils.errorMessage(e)}`);
+					this.logger.debug(`failed to set output to activity span: ${require_dist.errorMessage(e)}`);
 				}
 				return res;
 			}, true);
@@ -5846,13 +5893,13 @@ var ActivityInboundInterceptor = class {
 		this.recordActivityArgs = options.recordActivityArgs ?? true;
 		this.recordActivityOutput = options.recordActivityOutput ?? true;
 		this.activityType = activityContext?.info?.activityType;
-		this.logger = require_utils.initializeLogger();
+		this.logger = require_dist.initializeLogger();
 	}
 };
 const ActivityInterceptorFactory = (options) => (ctx) => ({ inbound: new ActivityInboundInterceptor(options, ctx) });
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/temporal/workflow-span.ts
-const logger$7 = require_utils.initializeLogger();
+const logger$8 = require_dist.initializeLogger();
 const _patchedWorkflowClients = /* @__PURE__ */ new WeakSet();
 const workflowName = (args) => {
 	const wf = args[0];
@@ -5876,7 +5923,7 @@ const wrapHandle = (handle, span) => {
 		try {
 			return Laminar.serializeLaminarSpanContext(span) ?? void 0;
 		} catch (e) {
-			logger$7.debug(`failed to derive workflow child span parent: ${require_utils.errorMessage(e)}`);
+			logger$8.debug(`failed to derive workflow child span parent: ${require_dist.errorMessage(e)}`);
 			return;
 		}
 	};
@@ -5888,7 +5935,7 @@ const wrapHandle = (handle, span) => {
 				try {
 					span.setOutput(res);
 				} catch (e) {
-					logger$7.debug(`failed to set workflow span output: ${require_utils.errorMessage(e)}`);
+					logger$8.debug(`failed to set workflow span output: ${require_dist.errorMessage(e)}`);
 				}
 			});
 			return res;
@@ -5965,7 +6012,7 @@ const patchWorkflowClient = (clientModule) => {
 			try {
 				span.setOutput(res);
 			} catch (e) {
-				logger$7.debug(`failed to set workflow span output: ${require_utils.errorMessage(e)}`);
+				logger$8.debug(`failed to set workflow span output: ${require_dist.errorMessage(e)}`);
 			}
 			span.end();
 			return res;
@@ -6049,14 +6096,14 @@ const patchWorkflowClient = (clientModule) => {
 * const client = new temporalClient.Client({ ... });
 * ```
 */
-const logger$6 = require_utils.initializeLogger();
+const logger$7 = require_dist.initializeLogger();
 const _patchedWorkerModules = /* @__PURE__ */ new WeakSet();
 const _patchedClientModules = /* @__PURE__ */ new WeakSet();
 let _warnedWorkflowBundleOnce = false;
 const warnWorkflowBundleOnce = () => {
 	if (_warnedWorkflowBundleOnce) return;
 	_warnedWorkflowBundleOnce = true;
-	logger$6.warn("[Laminar] Temporal Worker.create was called with a pre-built `workflowBundle`; Temporal ignores `interceptors.workflowModules` in that case, so Laminar's workflow interceptor cannot be auto-injected. Trace context from workflow start will NOT propagate to activities or child workflows scheduled inside the workflow. Register the interceptor at bundle time: bundleWorkflowCode({ workflowInterceptorModules: [require.resolve('@lmnr-ai/lmnr/temporal-workflow-interceptors')], ... }).");
+	logger$7.warn("[Laminar] Temporal Worker.create was called with a pre-built `workflowBundle`; Temporal ignores `interceptors.workflowModules` in that case, so Laminar's workflow interceptor cannot be auto-injected. Trace context from workflow start will NOT propagate to activities or child workflows scheduled inside the workflow. Register the interceptor at bundle time: bundleWorkflowCode({ workflowInterceptorModules: [require.resolve('@lmnr-ai/lmnr/temporal-workflow-interceptors')], ... }).");
 };
 /**
 * Patch a `@temporalio/worker` module object so that every `Worker.create()`
@@ -6127,7 +6174,7 @@ const LaminarTemporalInterceptors = {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/instrumentations.ts
-const logger$5 = require_utils.initializeLogger();
+const logger$6 = require_dist.initializeLogger();
 /**
 * Initialize and return Laminar instrumentations.
 * Useful to use with libraries that initialize tracing and can register passed
@@ -6238,7 +6285,7 @@ const manuallyInitInstrumentations = (client, instrumentModules, suppressContent
 		instrumentations.push(anthropicInstrumentation);
 		anthropicInstrumentation.manuallyInstrument(instrumentModules.anthropic);
 	}
-	if (instrumentModules?.azureOpenAI) logger$5.warn("Azure OpenAI instrumentation is no longer supported. Not enabling any instrumentation.");
+	if (instrumentModules?.azureOpenAI) logger$6.warn("Azure OpenAI instrumentation is no longer supported. Not enabling any instrumentation.");
 	if (instrumentModules?.cohere) {
 		const cohereInstrumentation = new _traceloop_instrumentation_cohere.CohereInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(cohereInstrumentation);
@@ -6269,7 +6316,7 @@ const manuallyInitInstrumentations = (client, instrumentModules, suppressContent
 		instrumentations.push(langchainInstrumentation);
 		langchainInstrumentation.manuallyInstrument(instrumentModules.langchain);
 	}
-	if (instrumentModules?.llamaIndex) logger$5.warn("Llamaindex JS is deprecated. Not enabling any instrumentation.");
+	if (instrumentModules?.llamaIndex) logger$6.warn("Llamaindex JS is deprecated. Not enabling any instrumentation.");
 	if (instrumentModules?.chromadb) {
 		const chromadbInstrumentation = new _traceloop_instrumentation_chromadb.ChromaDBInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(chromadbInstrumentation);
@@ -6379,7 +6426,7 @@ const isGlobalContextManagerConfigured = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/index.ts
-const logger$4 = require_utils.initializeLogger();
+const logger$5 = require_dist.initializeLogger();
 let spanProcessor;
 let tracerProvider;
 let _baseHttpUrl = "https://api.lmnr.ai:443";
@@ -6427,10 +6474,10 @@ const startTracing = (options) => {
 		const contextManager = new _opentelemetry_context_async_hooks.AsyncLocalStorageContextManager();
 		contextManager.enable();
 		_opentelemetry_api.context.setGlobalContextManager(contextManager);
-		logger$4.debug("Laminar set global OTel Context Manager");
+		logger$5.debug("Laminar set global OTel Context Manager");
 	}
-	logger$4.debug("Global OTel Context Manager exists");
-	logger$4.debug(`Laminar registering ${instrumentations.length} instrumentations`);
+	logger$5.debug("Global OTel Context Manager exists");
+	logger$5.debug(`Laminar registering ${instrumentations.length} instrumentations`);
 	(0, _opentelemetry_instrumentation.registerInstrumentations)({
 		instrumentations,
 		tracerProvider: newProvider
@@ -6541,17 +6588,17 @@ const _resetConfiguration = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/decorators.ts
-const logger$3 = require_utils.initializeLogger();
+const logger$4 = require_dist.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_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+		const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 		Laminar._armDebugRuntimeFromContext(laminarContext.debug);
-		const spanContext = require_utils.tryToOtelSpanContext(laminarContext);
+		const spanContext = require_dist.tryToOtelSpanContext(laminarContext);
 		entityContext = _opentelemetry_api.trace.setSpan(entityContext, _opentelemetry_api.trace.wrapSpanContext(spanContext));
 	} catch (e) {
-		logger$3.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
+		logger$4.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
 	}
 	try {
 		if (contextProperties && Object.keys(contextProperties).length > 0) {
@@ -6562,16 +6609,16 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 			});
 		}
 	} catch (e) {
-		logger$3.warn("Failed to set context properties: " + require_utils.errorMessage(e));
+		logger$4.warn("Failed to set context properties: " + require_dist.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_utils.SPAN_INPUT, typeof input === "string" ? input : serialize(input));
-			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_utils.SPAN_INPUT, typeof spanInput[0] === "string" ? spanInput[0] : serialize(spanInput[0]));
-			else span.setAttribute(require_utils.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}));
+			if (input !== void 0) span.setAttribute(require_dist.SPAN_INPUT, typeof input === "string" ? input : serialize(input));
+			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_dist.SPAN_INPUT, typeof spanInput[0] === "string" ? spanInput[0] : serialize(spanInput[0]));
+			else span.setAttribute(require_dist.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}));
 		} catch (error) {
-			logger$3.warn("Failed to serialize input: " + require_utils.errorMessage(error));
+			logger$4.warn("Failed to serialize input: " + require_dist.errorMessage(error));
 		}
 		let res;
 		try {
@@ -6581,7 +6628,7 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 				span.recordException(error);
 				span.end();
 			} catch (error) {
-				logger$3.warn("Failed to record exception and end span: " + require_utils.errorMessage(error));
+				logger$4.warn("Failed to record exception and end span: " + require_dist.errorMessage(error));
 			}
 			throw error;
 		}
@@ -6590,18 +6637,18 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 			try {
 				streamInfo = getStream(resolvedRes);
 			} catch (error) {
-				logger$3.warn("Failed to get stream info: " + require_utils.errorMessage(error));
+				logger$4.warn("Failed to get stream info: " + require_dist.errorMessage(error));
 			}
 			if (streamInfo.type !== null) return handleStreamResult(resolvedRes, streamInfo, span, ignoreOutput, serialize);
 			try {
-				if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_utils.SPAN_OUTPUT, serialize(resolvedRes));
+				if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, serialize(resolvedRes));
 			} catch (error) {
-				logger$3.warn("Failed to serialize async output: " + require_utils.errorMessage(error));
+				logger$4.warn("Failed to serialize async output: " + require_dist.errorMessage(error));
 			} finally {
 				try {
 					span.end();
 				} catch (error) {
-					logger$3.warn("Failed to end span: " + require_utils.errorMessage(error));
+					logger$4.warn("Failed to end span: " + require_dist.errorMessage(error));
 				}
 			}
 			return resolvedRes;
@@ -6610,7 +6657,7 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 				span.recordException(error);
 				span.end();
 			} catch (error) {
-				logger$3.warn("Failed to record exception and end span: " + require_utils.errorMessage(error));
+				logger$4.warn("Failed to record exception and end span: " + require_dist.errorMessage(error));
 			}
 			throw error;
 		});
@@ -6618,18 +6665,18 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 		try {
 			streamInfo = getStream(res);
 		} catch (error) {
-			logger$3.warn("Failed to get stream info: " + require_utils.errorMessage(error));
+			logger$4.warn("Failed to get stream info: " + require_dist.errorMessage(error));
 		}
 		if (streamInfo.type !== null) return handleStreamResult(res, streamInfo, span, ignoreOutput, serialize);
 		try {
-			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_utils.SPAN_OUTPUT, typeof res === "string" ? res : serialize(res));
+			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, typeof res === "string" ? res : serialize(res));
 		} catch (error) {
-			logger$3.warn("Failed to serialize output: " + require_utils.errorMessage(error));
+			logger$4.warn("Failed to serialize output: " + require_dist.errorMessage(error));
 		} finally {
 			try {
 				span.end();
 			} catch (error) {
-				logger$3.warn("Failed to end span: " + require_utils.errorMessage(error));
+				logger$4.warn("Failed to end span: " + require_dist.errorMessage(error));
 			}
 		}
 		return res;
@@ -6653,7 +6700,7 @@ const normalizePayload = (payload, seen) => {
 const serialize = (payload) => JSON.stringify(normalizePayload(payload, /* @__PURE__ */ new WeakSet()));
 //#endregion
 //#region src/decorators.ts
-const logger$2 = require_utils.initializeLogger();
+const logger$3 = require_dist.initializeLogger();
 /**
 * The main decorator entrypoint for Laminar. This is used to wrap
 * functions and methods to create spans.
@@ -6759,14 +6806,14 @@ const buildContextProperties = (options) => {
 	let parentUserId;
 	let parentSessionId;
 	if (parentSpanContext) try {
-		const laminarContext = typeof parentSpanContext === "string" ? require_utils.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
+		const laminarContext = typeof parentSpanContext === "string" ? require_dist.deserializeLaminarSpanContext(parentSpanContext) : parentSpanContext;
 		parentMetadata = laminarContext.metadata;
 		parentTraceType = laminarContext.traceType;
 		parentTracingLevel = laminarContext.tracingLevel;
 		parentUserId = laminarContext.userId;
 		parentSessionId = laminarContext.sessionId;
 	} catch (e) {
-		logger$2.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
+		logger$3.warn("Failed to parse parent span context: " + require_dist.errorMessage(e));
 	}
 	const contextProperties = {};
 	const sessionIdValue = options.sessionId ?? parentSessionId ?? ctxAssociationProperties.sessionId;
@@ -6796,14 +6843,14 @@ const buildContextProperties = (options) => {
 */
 const buildSpanAttributes = (options) => {
 	const spanAttributes = {};
-	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.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.parentSpanContext) try {
-		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;
+		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;
 	} catch (e) {
-		logger$2.warn("Failed to parse parent span context for span attributes: " + require_utils.errorMessage(e));
+		logger$3.warn("Failed to parse parent span context for span attributes: " + require_dist.errorMessage(e));
 	}
 	return spanAttributes;
 };
@@ -6935,12 +6982,12 @@ function observeExperimentalDecorator(config) {
 }
 //#endregion
 //#region src/evaluations.ts
-require_utils.loadEnv();
+require_dist.loadEnv();
 const DEFAULT_CONCURRENCY = 5;
 const MAX_EXPORT_BATCH_SIZE = 64;
-const logger$1 = require_utils.initializeLogger();
+const logger$2 = require_dist.initializeLogger();
 const getEvaluationUrl = (projectId, evaluationId, baseUrl, frontendPort) => {
-	return `${require_utils.getFrontendUrl(baseUrl, frontendPort)}/project/${projectId}/evaluations/${evaluationId}`;
+	return `${require_dist.getFrontendUrl(baseUrl, frontendPort)}/project/${projectId}/evaluations/${evaluationId}`;
 };
 const getAverageScores = (results) => {
 	const perScoreValues = {};
@@ -7011,7 +7058,7 @@ var Evaluation = class {
 		this.name = name;
 		if (config) {
 			if (config.concurrencyLimit !== void 0 && config.concurrencyLimit < 1) {
-				logger$1.warn(`concurrencyLimit must be greater than 0. Setting to default of ${DEFAULT_CONCURRENCY}`);
+				logger$2.warn(`concurrencyLimit must be greater than 0. Setting to default of ${DEFAULT_CONCURRENCY}`);
 				this.concurrencyLimit = DEFAULT_CONCURRENCY;
 			} else this.concurrencyLimit = config.concurrencyLimit ?? DEFAULT_CONCURRENCY;
 			this.traceDisableBatch = config.traceDisableBatch ?? false;
@@ -7023,7 +7070,7 @@ var Evaluation = class {
 				baseUrl: Laminar.getHttpUrl(),
 				projectApiKey: Laminar.getProjectApiKey()
 			});
-			if (config?.projectApiKey && config.projectApiKey !== Laminar.getProjectApiKey()) logger$1.warn("Laminar was already initialized with a different project API key. Ignoring the project API key from the evaluation config.");
+			if (config?.projectApiKey && config.projectApiKey !== Laminar.getProjectApiKey()) logger$2.warn("Laminar was already initialized with a different project API key. Ignoring the project API key from the evaluation config.");
 			return;
 		}
 		const key = config?.projectApiKey ?? process.env.LMNR_PROJECT_API_KEY;
@@ -7055,9 +7102,9 @@ var Evaluation = class {
 			if (!this.data.id) try {
 				const datasets = await this.client.datasets.getDatasetByName(this.data.name);
 				if (datasets.length > 0) this.data.id = datasets[0].id;
-				else logger$1.warn(`Dataset ${this.data.name} not found`);
+				else logger$2.warn(`Dataset ${this.data.name} not found`);
 			} catch (error) {
-				logger$1.warn(`Error getting dataset ${this.data.name}: ` + require_utils.errorMessage(error));
+				logger$2.warn(`Error getting dataset ${this.data.name}: ` + require_dist.errorMessage(error));
 			}
 		}
 		let resultDatapoints;
@@ -7090,7 +7137,7 @@ var Evaluation = class {
 				projectId: "",
 				evaluationId: "",
 				url: "",
-				errorMessage: require_utils.errorMessage(e)
+				errorMessage: require_dist.errorMessage(e)
 			};
 		}
 	}
@@ -7105,7 +7152,7 @@ var Evaluation = class {
 			}
 		});
 		return LaminarContextManager.runWithIsolatedContext([entityContext], async () => {
-			const semaphore = new require_utils.Semaphore(this.concurrencyLimit);
+			const semaphore = new require_dist.Semaphore(this.concurrencyLimit);
 			const tasks = [];
 			const evaluateTask = async (datapoint, index) => {
 				try {
@@ -7129,20 +7176,20 @@ var Evaluation = class {
 			name: "evaluation",
 			traceType: "EVALUATION"
 		}, async () => {
-			_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).setAttribute(require_utils.SPAN_TYPE, "EVALUATION");
+			_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).setAttribute(require_dist.SPAN_TYPE, "EVALUATION");
 			const executorSpan = Laminar.startSpan({
 				name: "executor",
 				input: datapoint.data
 			});
-			executorSpan.setAttribute(require_utils.SPAN_TYPE, "EXECUTOR");
-			const executorSpanId = require_utils.otelSpanIdToUUID(executorSpan.spanContext().spanId);
-			const datapointId = require_utils.newUUID();
+			executorSpan.setAttribute(require_dist.SPAN_TYPE, "EXECUTOR");
+			const executorSpanId = require_dist.otelSpanIdToUUID(executorSpan.spanContext().spanId);
+			const datapointId = require_dist.newUUID();
 			const partialDatapoint = {
 				id: datapointId,
 				data: datapoint.data,
 				target: datapoint.target,
 				metadata: datapoint.metadata,
-				traceId: require_utils.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
+				traceId: require_dist.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
 				executorSpanId,
 				index
 			};
@@ -7168,13 +7215,13 @@ var Evaluation = class {
 					if (evaluator instanceof HumanEvaluator) {
 						const activeSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext());
 						if (activeSpan) {
-							activeSpan.setAttribute(require_utils.SPAN_TYPE, "HUMAN_EVALUATOR");
-							if (evaluator.options) activeSpan.setAttribute(require_utils.HUMAN_EVALUATOR_OPTIONS, JSON.stringify(evaluator.options));
+							activeSpan.setAttribute(require_dist.SPAN_TYPE, "HUMAN_EVALUATOR");
+							if (evaluator.options) activeSpan.setAttribute(require_dist.HUMAN_EVALUATOR_OPTIONS, JSON.stringify(evaluator.options));
 						}
 						return null;
 					} else {
 						const activeSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext());
-						if (activeSpan) activeSpan.setAttribute(require_utils.SPAN_TYPE, "EVALUATOR");
+						if (activeSpan) activeSpan.setAttribute(require_dist.SPAN_TYPE, "EVALUATOR");
 						return await evaluator(output, target, data);
 					}
 				}, output, datapoint.target, datapoint.data);
@@ -7197,7 +7244,7 @@ var Evaluation = class {
 				target,
 				metadata: datapoint.metadata,
 				scores,
-				traceId: require_utils.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
+				traceId: require_dist.otelTraceIdToUUID(_opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()).spanContext().traceId),
 				executorSpanId,
 				index
 			};
@@ -8080,6 +8127,62 @@ var LaminarLanguageModelV4 = class extends BaseLaminarLanguageModel {
 	}
 };
 //#endregion
+//#region src/opentelemetry-lib/instrumentation/aisdk/index.ts
+const AI_FUNCTIONS = [
+	"generateText",
+	"generateObject",
+	"streamText",
+	"streamObject",
+	"embed",
+	"embedMany",
+	"rerank"
+];
+/**
+* Detect AI SDK v7 by the presence of `registerTelemetry` (added only in v7).
+* On v7 the wrapper injects `integrations: [laminarTelemetry()]`; on v6 it
+* falls back to the older `experimental_telemetry: { tracer }` path.
+*/
+const isAISDKv7 = (ai) => typeof ai.registerTelemetry === "function";
+const logger$1 = require_dist.initializeLogger();
+let wrapAISDKv7WarnedOnce = false;
+const wrapAISDK = (ai) => {
+	const wrapped = {};
+	if (isAISDKv7(ai)) {
+		if (!wrapAISDKv7WarnedOnce) {
+			wrapAISDKv7WarnedOnce = true;
+			logger$1.warn("wrapAISDK() is not supported for AI SDK v7. Use LaminarAiSdkTelemetry instead:\n  import { LaminarAiSdkTelemetry } from '@lmnr-ai/lmnr';\n  import { registerTelemetry } from 'ai';\n  registerTelemetry(new LaminarAiSdkTelemetry());");
+		}
+		return ai;
+	}
+	Object.entries(ai).forEach(([key, value]) => {
+		if (typeof value === "function" && AI_FUNCTIONS.includes(key)) {
+			const originalFn = value;
+			wrapped[key] = (...args) => {
+				if (args[0] && typeof args[0] === "object") {
+					const defaultTelemetry = {
+						isEnabled: true,
+						tracer: getTracer()
+					};
+					args[0] = {
+						...args[0],
+						experimental_telemetry: {
+							...defaultTelemetry,
+							...args[0].experimental_telemetry
+						}
+					};
+				}
+				return originalFn(...args);
+			};
+		} else wrapped[key] = value;
+	});
+	return wrapped;
+};
+function wrapLanguageModel(languageModel) {
+	if (languageModel.specificationVersion === "v4") return new LaminarLanguageModelV4(languageModel);
+	if (languageModel.specificationVersion === "v3") return new LaminarLanguageModelV3(languageModel);
+	return new LaminarLanguageModelV2(languageModel);
+}
+//#endregion
 //#region src/opentelemetry-lib/instrumentation/aisdk/v7-integration/types.ts
 const stepKey = (callId, stepNumber) => `${callId}:${stepNumber}`;
 //#endregion
@@ -8098,10 +8201,10 @@ const normalizeProvider$1 = (provider) => {
 };
 const applyUsage = (attributes, usage) => {
 	if (!usage || typeof usage !== "object") return;
-	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.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.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;
@@ -8184,11 +8287,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_utils.LaminarAttributes.PROVIDER, provider);
+		if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
 		span.setAttribute("ai.model.provider", event.provider);
 	}
 	if (typeof event.modelId === "string") {
-		span.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
+		span.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, event.modelId);
 		span.setAttribute("ai.model.id", event.modelId);
 	}
 };
@@ -8197,7 +8300,7 @@ const applyPromptMessages = (span, event) => {
 	if (msgs.length === 0) return;
 	const serialized = serializeJSON$1(msgs);
 	span.setAttribute("ai.prompt.messages", serialized);
-	span.setAttribute(require_utils.SPAN_INPUT, serialized);
+	span.setAttribute(require_dist.SPAN_INPUT, serialized);
 };
 const compareHrTime = (a, b) => {
 	if (a[0] !== b[0]) return a[0] - b[0];
@@ -8235,24 +8338,36 @@ var LaminarAiSdkTelemetry = class {
 			const callId = event?.callId;
 			if (!callId) return;
 			const parentCtx = LaminarContextManager.getContext();
-			const span = getTracer().startSpan(event.operationId ?? "unknown", { kind: _opentelemetry_api.SpanKind.CLIENT }, parentCtx);
+			const tracer = getTracer();
+			let spanName = event.operationId ?? "ai.operation";
+			if (typeof event.functionId === "string") spanName += ` ${event.functionId}`;
+			const span = tracer.startSpan(spanName, {
+				kind: _opentelemetry_api.SpanKind.CLIENT,
+				attributes: {
+					[require_dist.SPAN_TYPE]: "DEFAULT",
+					...typeof event.functionId === "string" ? {
+						"operation.name": event.functionId,
+						"ai.prompt": "_"
+					} : {}
+				}
+			}, parentCtx);
 			const spanCtx = _opentelemetry_api.trace.setSpan(parentCtx, span);
-			span.setAttribute(require_utils.SPAN_TYPE, "DEFAULT");
+			span.setAttribute(require_dist.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_utils.LaminarAttributes.PROVIDER, provider);
+				if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
 			}
 			if (typeof event.modelId === "string") {
-				span.setAttribute(require_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
+				span.setAttribute(require_dist.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_utils.SPAN_TYPE, "LLM");
+			if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany" || event.operationId === "ai.rerank") span.setAttribute(require_dist.SPAN_TYPE, "LLM");
 			if (this.recordInputs) {
 				if (Array.isArray(event.messages) || event.system !== void 0 || event.instructions !== void 0) applyPromptMessages(span, event);
-				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({
+				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({
 					query: event.query,
 					documents: event.documents
 				}));
@@ -8272,9 +8387,9 @@ var LaminarAiSdkTelemetry = class {
 			if (!callId) return;
 			const op = this.operationByCallId.get(callId);
 			if (!op) return;
-			const span = getTracer().startSpan(`ai.step ${stepNumber}`, { kind: _opentelemetry_api.SpanKind.CLIENT }, op.ctx);
+			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_utils.SPAN_TYPE, "DEFAULT");
+			span.setAttribute(require_dist.SPAN_TYPE, "DEFAULT");
 			span.setAttribute("ai.step.number", stepNumber);
 			if (this.recordInputs) applyPromptMessages(span, event);
 			this.stepByKey.set(stepKey(callId, stepNumber), {
@@ -8291,7 +8406,7 @@ 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_utils.SPAN_TYPE, "LLM");
+			span.setAttribute(require_dist.SPAN_TYPE, "LLM");
 			applyRequestModelAttributes(span, event);
 			if (this.recordInputs) applyPromptMessages(span, event);
 			this.llmByKey.set(stepKey(callId, stepNumber), {
@@ -8309,9 +8424,9 @@ var LaminarAiSdkTelemetry = class {
 			const span = llm.span;
 			if (typeof event.provider === "string") {
 				const provider = normalizeProvider$1(event.provider);
-				if (provider) span.setAttribute(require_utils.LaminarAttributes.PROVIDER, provider);
+				if (provider) span.setAttribute(require_dist.LaminarAttributes.PROVIDER, provider);
 			}
-			if (typeof event.modelId === "string") span.setAttribute(require_utils.LaminarAttributes.RESPONSE_MODEL, event.modelId);
+			if (typeof event.modelId === "string") span.setAttribute(require_dist.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);
@@ -8378,7 +8493,7 @@ var LaminarAiSdkTelemetry = class {
 					outputPayload.toolCalls = normalizedToolCallsList;
 					step.span.setAttribute("ai.response.toolCalls", serializeJSON$1(normalizedToolCallsList));
 				}
-				if (Object.keys(outputPayload).length > 0) step.span.setAttribute(require_utils.SPAN_OUTPUT, serializeJSON$1(outputPayload));
+				if (Object.keys(outputPayload).length > 0) step.span.setAttribute(require_dist.SPAN_OUTPUT, serializeJSON$1(outputPayload));
 			}
 			step.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 			step.span.end();
@@ -8390,7 +8505,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_utils.SPAN_TYPE, "LLM");
+			span.setAttribute(require_dist.SPAN_TYPE, "LLM");
 			applyRequestModelAttributes(span, event);
 			this.llmByKey.set(stepKey(callId, 0), {
 				span,
@@ -8406,7 +8521,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_utils.LaminarAttributes.RESPONSE_MODEL, response.modelId);
+				if (typeof response.modelId === "string") llm.span.setAttribute(require_dist.LaminarAttributes.RESPONSE_MODEL, response.modelId);
 				if (typeof response.id === "string") llm.span.setAttribute("gen_ai.response.id", response.id);
 			}
 			applyUsageToSpan(llm.span, event.usage);
@@ -8429,13 +8544,13 @@ 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_utils.SPAN_TYPE, "TOOL");
+			span.setAttribute(require_dist.SPAN_TYPE, "TOOL");
 			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_utils.SPAN_INPUT, serialized);
+				span.setAttribute(require_dist.SPAN_INPUT, serialized);
 			}
 			this.toolByCallId.set(toolCallId, {
 				span,
@@ -8460,14 +8575,14 @@ var LaminarAiSdkTelemetry = class {
 						message
 					});
 					if (this.recordOutputs) {
-						tool.span.setAttribute(require_utils.SPAN_OUTPUT, message);
+						tool.span.setAttribute(require_dist.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_utils.SPAN_OUTPUT, serialized);
+						tool.span.setAttribute(require_dist.SPAN_OUTPUT, serialized);
 					}
 					tool.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 				}
@@ -8488,7 +8603,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_utils.LaminarAttributes.REQUEST_MODEL, event.modelId);
+			if (typeof event.modelId === "string") op.span.setAttribute(require_dist.LaminarAttributes.REQUEST_MODEL, event.modelId);
 		};
 		this.onEmbedEnd = (event) => {
 			const callId = event?.callId;
@@ -8510,13 +8625,13 @@ var LaminarAiSdkTelemetry = class {
 				const hasText = typeof event.text === "string" && event.text.length > 0;
 				if (hasText) {
 					op.span.setAttribute("ai.response.text", event.text);
-					op.span.setAttribute(require_utils.SPAN_OUTPUT, event.text);
+					op.span.setAttribute(require_dist.SPAN_OUTPUT, event.text);
 				}
 				const normalizedToolCallsList = normalizeToolCalls(event.toolCalls);
 				if (normalizedToolCallsList.length > 0) {
 					const serialized = serializeJSON$1(normalizedToolCallsList);
 					op.span.setAttribute("ai.response.toolCalls", serialized);
-					if (!hasText) op.span.setAttribute(require_utils.SPAN_OUTPUT, serialized);
+					if (!hasText) op.span.setAttribute(require_dist.SPAN_OUTPUT, serialized);
 				}
 				if (event.embedding !== void 0) {
 					const emb = event.embedding;
@@ -8525,7 +8640,7 @@ var LaminarAiSdkTelemetry = class {
 				}
 				if (Array.isArray(event.ranking)) {
 					op.span.setAttribute("ai.rerank.ranking", serializeJSON$1(event.ranking));
-					op.span.setAttribute(require_utils.SPAN_OUTPUT, serializeJSON$1(event.ranking));
+					op.span.setAttribute(require_dist.SPAN_OUTPUT, serializeJSON$1(event.ranking));
 				}
 			}
 			if (event.finishReason === "error") op.span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
@@ -8574,6 +8689,7 @@ var LaminarAiSdkTelemetry = class {
 		this.recordInputs = options.recordInputs ?? true;
 		this.recordOutputs = options.recordOutputs ?? true;
 		this.createStepSpan = options.createStepSpan ?? false;
+		if (!Laminar.initialized()) Laminar.initialize(options.laminarOptions ?? {});
 	}
 	/** End child spans, end the operation span, and clean up both maps. */
 	closeOperation(callId, op) {
@@ -8692,69 +8808,6 @@ const enableAiSdkTelemetryDebug = (log = (e) => console.log("[aisdk:telemetry]",
 	return () => channel.unsubscribe(handler);
 };
 //#endregion
-//#region src/opentelemetry-lib/instrumentation/aisdk/index.ts
-const AI_FUNCTIONS = [
-	"generateText",
-	"generateObject",
-	"streamText",
-	"streamObject",
-	"embed",
-	"embedMany",
-	"rerank"
-];
-/**
-* Detect AI SDK v7 by the presence of `registerTelemetry` (added only in v7).
-* On v7 the wrapper injects `integrations: [laminarTelemetry()]`; on v6 it
-* falls back to the older `experimental_telemetry: { tracer }` path.
-*/
-const isAISDKv7 = (ai) => typeof ai.registerTelemetry === "function";
-const wrapAISDK = (ai) => {
-	const wrapped = {};
-	const v7 = isAISDKv7(ai);
-	const v7Integration = v7 ? aiSdkTelemetry() : void 0;
-	Object.entries(ai).forEach(([key, value]) => {
-		if (typeof value === "function" && AI_FUNCTIONS.includes(key)) {
-			const originalFn = value;
-			wrapped[key] = (...args) => {
-				if (args[0] && typeof args[0] === "object") if (v7) {
-					const userTelemetry = args[0].telemetry ?? args[0].experimental_telemetry ?? {};
-					const mergedIntegrations = [v7Integration];
-					const userIntegrations = userTelemetry.integrations;
-					if (Array.isArray(userIntegrations)) mergedIntegrations.push(...userIntegrations);
-					else if (userIntegrations) mergedIntegrations.push(userIntegrations);
-					args[0] = {
-						...args[0],
-						telemetry: {
-							isEnabled: true,
-							...userTelemetry,
-							integrations: mergedIntegrations
-						}
-					};
-				} else {
-					const defaultTelemetry = {
-						isEnabled: true,
-						tracer: getTracer()
-					};
-					args[0] = {
-						...args[0],
-						experimental_telemetry: {
-							...defaultTelemetry,
-							...args[0].experimental_telemetry
-						}
-					};
-				}
-				return originalFn(...args);
-			};
-		} else wrapped[key] = value;
-	});
-	return wrapped;
-};
-function wrapLanguageModel(languageModel) {
-	if (languageModel.specificationVersion === "v4") return new LaminarLanguageModelV4(languageModel);
-	if (languageModel.specificationVersion === "v3") return new LaminarLanguageModelV3(languageModel);
-	return new LaminarLanguageModelV2(languageModel);
-}
-//#endregion
 //#region src/opentelemetry-lib/instrumentation/mastra/types.ts
 const MastraSpanType = {
 	MODEL_GENERATION: "model_generation",
@@ -8861,10 +8914,10 @@ const stringifyArgs = (raw) => {
 const formatUsage = (usage) => {
 	if (!usage) return {};
 	const out = {};
-	if (typeof usage.inputTokens === "number") out[require_utils.LaminarAttributes.INPUT_TOKEN_COUNT] = usage.inputTokens;
-	if (typeof usage.outputTokens === "number") out[require_utils.LaminarAttributes.OUTPUT_TOKEN_COUNT] = usage.outputTokens;
+	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;
 	const total = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
-	if (total > 0) out[require_utils.LaminarAttributes.TOTAL_TOKEN_COUNT] = total;
+	if (total > 0) out[require_dist.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;
@@ -8872,7 +8925,7 @@ const formatUsage = (usage) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/mastra/exporter.ts
-const logger = require_utils.initializeLogger();
+const logger = require_dist.initializeLogger();
 /**
 * Bridges Mastra's ObservabilityExporter contract to Laminar's OTLP ingestion.
 *
@@ -8936,7 +8989,7 @@ var MastraExporter = class {
 		try {
 			await processor.forceFlush();
 		} catch (err) {
-			logger.error(`[MastraExporter] forceFlush failed: ${require_utils.errorMessage(err)}`);
+			logger.error(`[MastraExporter] forceFlush failed: ${require_dist.errorMessage(err)}`);
 		}
 	}
 	shutdown() {
@@ -8966,7 +9019,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_utils.otelSpanIdToUUID(require_utils.normalizeOtelSpanId(span.id));
+		const spanUuid = require_dist.otelSpanIdToUUID(require_dist.normalizeOtelSpanId(span.id));
 		const spanPath = parentPath ? [...parentPath, span.name] : [span.name];
 		const spanIdsPath = parentIdsPath ? [...parentIdsPath, spanUuid] : [spanUuid];
 		traceState.spanPathById.set(span.id, spanPath);
@@ -9005,7 +9058,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_utils.errorMessage(err)}`);
+			logger.error(`[MastraExporter] failed to export span ${span.id}: ${require_dist.errorMessage(err)}`);
 		} finally {
 			traceState.activeSpanIds.delete(span.id);
 			if (traceState.activeSpanIds.size === 0) this.traceMap.delete(span.traceId);
@@ -9116,13 +9169,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_utils.normalizeOtelTraceId(ctx.traceId);
-				created.otelRootParentSpanId = require_utils.normalizeOtelSpanId(ctx.spanId);
+				created.otelTraceId = require_dist.normalizeOtelTraceId(ctx.traceId);
+				created.otelRootParentSpanId = require_dist.normalizeOtelSpanId(ctx.spanId);
 				const attrs = activeSpan.attributes;
 				if (attrs) {
-					const parentPath = attrs[require_utils.SPAN_PATH];
+					const parentPath = attrs[require_dist.SPAN_PATH];
 					if (Array.isArray(parentPath) && parentPath.every((p) => typeof p === "string")) created.otelParentSpanPath = parentPath;
-					const parentIdsPath = attrs[require_utils.SPAN_IDS_PATH];
+					const parentIdsPath = attrs[require_dist.SPAN_IDS_PATH];
 					if (Array.isArray(parentIdsPath) && parentIdsPath.every((p) => typeof p === "string")) created.otelParentSpanIdsPath = parentIdsPath;
 				}
 			}
@@ -9142,14 +9195,14 @@ var MastraExporter = class {
 			return;
 		}
 		const sdkAllocatedSpanId = otelSpan.spanContext().spanId;
-		const mastraSpanId = require_utils.normalizeOtelSpanId(span.id);
-		const mastraTraceId = traceState.otelTraceId ?? require_utils.normalizeOtelTraceId(span.traceId);
+		const mastraSpanId = require_dist.normalizeOtelSpanId(span.id);
+		const mastraTraceId = traceState.otelTraceId ?? require_dist.normalizeOtelTraceId(span.traceId);
 		Object.assign(otelSpan.spanContext(), {
 			traceId: mastraTraceId,
 			spanId: mastraSpanId
 		});
 		if (sdkAllocatedSpanId !== mastraSpanId) getSpanProcessor()?.dropPathInfo(sdkAllocatedSpanId);
-		const parentSpanIdNormalized = span.parentSpanId ? require_utils.normalizeOtelSpanId(span.parentSpanId) : traceState.otelRootParentSpanId;
+		const parentSpanIdNormalized = span.parentSpanId ? require_dist.normalizeOtelSpanId(span.parentSpanId) : traceState.otelRootParentSpanId;
 		if (parentSpanIdNormalized) {
 			const parentSpanContext = {
 				traceId: mastraTraceId,
@@ -9167,8 +9220,8 @@ var MastraExporter = class {
 		});
 		const spanPath = traceState.spanPathById.get(span.id);
 		const spanIdsPath = traceState.spanIdsPathById.get(span.id);
-		if (spanPath) otelSpan.setAttribute(require_utils.SPAN_PATH, spanPath);
-		if (spanIdsPath) otelSpan.setAttribute(require_utils.SPAN_IDS_PATH, spanIdsPath);
+		if (spanPath) otelSpan.setAttribute(require_dist.SPAN_PATH, spanPath);
+		if (spanIdsPath) otelSpan.setAttribute(require_dist.SPAN_IDS_PATH, spanIdsPath);
 		this.liveOtelSpanByMastraId.set(span.id, otelSpan);
 	}
 	warnNotInitializedOnce() {
@@ -9195,39 +9248,39 @@ var MastraExporter = class {
 	}
 	applyEndAttributes(span, otelSpan, traceState) {
 		const attributes = this.buildLaminarAttributes(span, traceState);
-		delete attributes[require_utils.SPAN_PATH];
-		delete attributes[require_utils.SPAN_IDS_PATH];
+		delete attributes[require_dist.SPAN_PATH];
+		delete attributes[require_dist.SPAN_IDS_PATH];
 		otelSpan.setAttributes(attributes);
 	}
 	buildLaminarAttributes(span, traceState) {
 		const attributes = {};
 		const spanPath = traceState.spanPathById.get(span.id);
 		const spanIdsPath = traceState.spanIdsPathById.get(span.id);
-		if (spanPath) attributes[require_utils.SPAN_PATH] = spanPath;
-		if (spanIdsPath) attributes[require_utils.SPAN_IDS_PATH] = spanIdsPath;
+		if (spanPath) attributes[require_dist.SPAN_PATH] = spanPath;
+		if (spanIdsPath) attributes[require_dist.SPAN_IDS_PATH] = spanIdsPath;
 		const laminarSpanType = mapLaminarSpanType(span.type);
-		attributes[require_utils.SPAN_TYPE] = laminarSpanType;
-		attributes[require_utils.SPAN_INSTRUMENTATION_SOURCE] = "javascript";
-		attributes[require_utils.SPAN_SDK_VERSION] = require_dist.version;
+		attributes[require_dist.SPAN_TYPE] = laminarSpanType;
+		attributes[require_dist.SPAN_INSTRUMENTATION_SOURCE] = "javascript";
+		attributes[require_dist.SPAN_SDK_VERSION] = require_dist.version;
 		const langVersion = getLangVersion();
-		if (langVersion) attributes[require_utils.SPAN_LANGUAGE_VERSION] = langVersion;
+		if (langVersion) attributes[require_dist.SPAN_LANGUAGE_VERSION] = langVersion;
 		attributes["lmnr.internal.mastra.span_type"] = span.type;
 		const metadata = span.metadata ?? {};
 		const sessionId = metadata.sessionId ?? metadata.session_id;
-		if (typeof sessionId === "string" && sessionId.length > 0) attributes[require_utils.SESSION_ID] = sessionId;
+		if (typeof sessionId === "string" && sessionId.length > 0) attributes[require_dist.SESSION_ID] = sessionId;
 		const userId = metadata.userId ?? metadata.user_id;
-		if (typeof userId === "string" && userId.length > 0) attributes[require_utils.USER_ID] = userId;
+		if (typeof userId === "string" && userId.length > 0) attributes[require_dist.USER_ID] = userId;
 		for (const [key, value] of Object.entries(metadata)) {
 			if (key === "sessionId" || key === "session_id" || key === "userId" || key === "user_id" || value === void 0 || value === null) continue;
 			const av = toAttributeValue(value);
-			if (av !== void 0) attributes[`${require_utils.ASSOCIATION_PROPERTIES}.metadata.${key}`] = av;
+			if (av !== void 0) attributes[`${require_dist.ASSOCIATION_PROPERTIES}.metadata.${key}`] = av;
 		}
-		if (span.isRootSpan && span.tags?.length) attributes[`${require_utils.ASSOCIATION_PROPERTIES}.tags`] = span.tags;
+		if (span.isRootSpan && span.tags?.length) attributes[`${require_dist.ASSOCIATION_PROPERTIES}.tags`] = span.tags;
 		if (laminarSpanType === "LLM") this.applyLlmAttributes(span, attributes);
 		else if (laminarSpanType === "TOOL") this.applyToolAttributes(span, attributes);
 		else {
-			if (span.input !== void 0) attributes[require_utils.SPAN_INPUT] = serializeJSON(span.input);
-			if (span.output !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(span.output);
+			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);
 		}
 		return attributes;
 	}
@@ -9240,10 +9293,10 @@ var MastraExporter = class {
 		const provider = generationAttrs?.provider;
 		const model = generationAttrs?.model;
 		const responseModel = generationAttrs?.responseModel;
-		if (provider) attributes[require_utils.LaminarAttributes.PROVIDER] = normalizeProvider(provider);
-		if (model) attributes[require_utils.LaminarAttributes.REQUEST_MODEL] = model;
-		if (responseModel) attributes[require_utils.LaminarAttributes.RESPONSE_MODEL] = responseModel;
-		else if (model) attributes[require_utils.LaminarAttributes.RESPONSE_MODEL] = model;
+		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;
 		const usage = stepAttrs.usage ?? generationAttrs?.usage;
 		Object.assign(attributes, formatUsage(usage));
 		if (typeof stepAttrs.finishReason === "string") {
@@ -9256,7 +9309,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_utils.SPAN_INPUT] = serializeJSON(span.input);
+		else if (span.input !== void 0) attributes[require_dist.SPAN_INPUT] = serializeJSON(span.input);
 		const out = span.output;
 		const reasoningText = gen?.reasoningTextByStepIndex.get(stepIndex);
 		if (out && typeof out === "object") {
@@ -9295,11 +9348,11 @@ var MastraExporter = class {
 					parts
 				}]);
 			}
-		} else if (out !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(out);
+		} else if (out !== void 0) attributes[require_dist.SPAN_OUTPUT] = serializeJSON(out);
 	}
 	applyToolAttributes(span, attributes) {
-		if (span.input !== void 0) attributes[require_utils.SPAN_INPUT] = serializeJSON(span.input);
-		if (span.output !== void 0) attributes[require_utils.SPAN_OUTPUT] = serializeJSON(span.output);
+		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);
 		const toolAttrs = span.attributes ?? {};
 		const cleanedName = cleanMastraToolName(span.name) || span.name;
 		if (cleanedName) attributes["ai.toolCall.name"] = cleanedName;
@@ -9315,7 +9368,7 @@ 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_utils.LaminarAttributes;
+exports.LaminarAttributes = require_dist.LaminarAttributes;
 exports.LaminarClient = require_dist.LaminarClient;
 exports.LaminarDataset = LaminarDataset;
 exports.LaminarSpanProcessor = LaminarSpanProcessor;
@@ -9325,7 +9378,7 @@ exports.LaminarTemporalInterceptors = LaminarTemporalInterceptors;
 exports.LaminarTemporalScheduleClientInterceptor = ScheduleClientInterceptor;
 exports.LaminarTemporalWorkflowClientInterceptor = WorkflowClientInterceptor;
 exports.MastraExporter = MastraExporter;
-exports.TracingLevel = require_utils.TracingLevel;
+exports.TracingLevel = require_dist.TracingLevel;
 exports.aiSdkTelemetry = aiSdkTelemetry;
 exports.enableAiSdkTelemetryDebug = enableAiSdkTelemetryDebug;
 exports.evaluate = evaluate;