@lmnr-ai/lmnr 0.8.52 → 0.8.53

package/dist/index.mjs

@@ -1,29 +1,29 @@
 import { r as __require } from "./rolldown-runtime-B4iAMlE-.mjs";
-import { A as SPAN_INSTRUMENTATION_SOURCE, B as LaminarClient, C as PARENT_SPAN_IDS_PATH, D as SPAN_INPUT, E as SPAN_IDS_PATH, F as SPAN_TYPE, H as DEBUG_SESSION_FILE, I as TRACE_HAS_BROWSER_SESSION, L as TRACE_TYPE, M as SPAN_OUTPUT, N as SPAN_PATH, O as SPAN_INSTRUMENTATION_SCOPE_NAME, P as SPAN_SDK_VERSION, R as USER_ID, S as LaminarAttributes, T as SESSION_ID, U as TracingLevel, V as DEBUG_SESSION_DIR, W as errorMessage, _ as tryToOtelSpanContext, a as getFrontendUrl, b as ASSOCIATION_PROPERTIES_OVERRIDES, c as loadEnv, d as normalizeOtelSpanId, f as normalizeOtelTraceId, g as truncateSpanPayload, h as parseOtelHeaders, j as SPAN_LANGUAGE_VERSION, k as SPAN_INSTRUMENTATION_SCOPE_VERSION, l as metadataToAttributes, m as otelTraceIdToUUID, n as Semaphore, o as getOtelEnvVar, p as otelSpanIdToUUID, r as deserializeLaminarSpanContext, s as initializeLogger, t as NIL_UUID, u as newUUID, v as validateTracingConfig, w as PARENT_SPAN_PATH, x as HUMAN_EVALUATOR_OPTIONS, y as ASSOCIATION_PROPERTIES, z as version } from "./utils-C6gt-rSg.mjs";
+import { A as SPAN_INSTRUMENTATION_SOURCE, B as version, C as PARENT_SPAN_IDS_PATH, D as SPAN_INPUT, E as SPAN_IDS_PATH, F as SPAN_SDK_VERSION, G as errorMessage, H as DEBUG_SESSION_DIR, I as SPAN_TYPE, L as TRACE_HAS_BROWSER_SESSION, M as SPAN_OUTPUT, N as SPAN_PATH, O as SPAN_INSTRUMENTATION_SCOPE_NAME, P as SPAN_RELEASE, R as TRACE_TYPE, S as LaminarAttributes, T as SESSION_ID, U as DEBUG_SESSION_FILE, V as LaminarClient, W as TracingLevel, _ as tryToOtelSpanContext, a as getFrontendUrl, b as ASSOCIATION_PROPERTIES_OVERRIDES, c as loadEnv, d as normalizeOtelSpanId, f as normalizeOtelTraceId, g as truncateSpanPayload, h as parseOtelHeaders, j as SPAN_LANGUAGE_VERSION, k as SPAN_INSTRUMENTATION_SCOPE_VERSION, l as metadataToAttributes, m as otelTraceIdToUUID, n as Semaphore, o as getOtelEnvVar, p as otelSpanIdToUUID, r as deserializeLaminarSpanContext, s as initializeLogger, t as NIL_UUID, u as newUUID, v as validateTracingConfig, w as PARENT_SPAN_PATH, x as HUMAN_EVALUATOR_OPTIONS, y as ASSOCIATION_PROPERTIES, z as USER_ID } from "./utils-DavLzQA8.mjs";
 import { n as TRACEPARENT_HEADER, t as LAMINAR_SPAN_CONTEXT_HEADER } from "./consts-CTTu3jhI.mjs";
 import * as path from "path";
 import { DiagConsoleLogger, DiagLogLevel, ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, diag, isSpanContextValid, trace } from "@opentelemetry/api";
 import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
-import { InstrumentationBase, InstrumentationNodeModuleDefinition, registerInstrumentations } from "@opentelemetry/instrumentation";
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile, registerInstrumentations } from "@opentelemetry/instrumentation";
 import { AlwaysOnSampler, BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
 import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
-import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
 import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
 import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
 import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, parse, resolve, sep } from "node:path";
 import * as fs from "fs";
 import * as net from "net";
 import * as os from "os";
 import { AsyncLocalStorage } from "async_hooks";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { hrTime, isTracingSuppressed, suppressTracing } from "@opentelemetry/core";
+import { hrTime, isTracingSuppressed, suppressTracing, unsuppressTracing } from "@opentelemetry/core";
+import { AsyncLocalStorage as AsyncLocalStorage$1 } from "node:async_hooks";
 import { Metadata } from "@grpc/grpc-js";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
 import { OTLPTraceExporter as OTLPTraceExporter$1 } from "@opentelemetry/exporter-trace-otlp-proto";
@@ -188,7 +188,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await import("./file-utils-DaZefKLb.mjs").then((n) => n.t);
+		const { loadFromPaths } = await import("./file-utils-CwqjWMsF.mjs").then((n) => n.t);
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -204,7 +204,7 @@ var LaminarDataset = class extends EvaluationDataset {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/compat.ts
-const logger$30 = initializeLogger();
+const logger$32 = initializeLogger();
 const makeSpanOtelV2Compatible = (span) => {
 	const spanAny = span;
 	if (spanAny.instrumentationScope && !spanAny.instrumentationLibrary) Object.assign(span, { instrumentationLibrary: spanAny.instrumentationScope });
@@ -250,7 +250,7 @@ const createResource = (attributes) => {
 		if (resources.Resource) return new resources.Resource(attributes);
 		throw new Error("Unable to create Resource: neither v1 nor v2 API found");
 	} catch {
-		logger$30.debug("Laminar failed to @opentelemetry/resources, continuing without it");
+		logger$32.debug("Laminar failed to @opentelemetry/resources, continuing without it");
 		return;
 	}
 };
@@ -452,7 +452,7 @@ const consumeResponse = async (response) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/stream-utils.ts
-const logger$29 = initializeLogger();
+const logger$31 = initializeLogger();
 const pendingStreamProcessing = /* @__PURE__ */ new Set();
 /**
 * Wait for all pending stream processing to complete with a timeout
@@ -460,7 +460,7 @@ const pendingStreamProcessing = /* @__PURE__ */ new Set();
 */
 const waitForPendingStreams = async (timeoutMs = 5e3) => {
 	if (pendingStreamProcessing.size === 0) return;
-	logger$29.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
+	logger$31.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
 	const initialCount = pendingStreamProcessing.size;
 	const pendingPromises = Array.from(pendingStreamProcessing);
 	let timedOut = false;
@@ -471,7 +471,7 @@ const waitForPendingStreams = async (timeoutMs = 5e3) => {
 		}, timeoutMs);
 	});
 	await Promise.race([Promise.allSettled(pendingPromises), timeoutPromise]);
-	if (timedOut && pendingStreamProcessing.size > 0) logger$29.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
+	if (timedOut && pendingStreamProcessing.size > 0) logger$31.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
 };
 /**
 * Track a background promise and ensure cleanup
@@ -487,34 +487,34 @@ const trackStreamProcessing = (task) => {
 * while passing through the original result to the caller
 */
 const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, serialize) => {
-	logger$29.debug(`Handling stream result of type: ${streamInfo.type}`);
+	logger$31.debug(`Handling stream result of type: ${streamInfo.type}`);
 	if (streamInfo.type === "aisdk-result") {
 		trackStreamProcessing(async () => {
-			logger$29.debug("Starting background processing for AI SDK result");
+			logger$31.debug("Starting background processing for AI SDK result");
 			let partialOutput = {};
 			try {
 				partialOutput = await consumeAISDKResult(streamInfo.result);
 				if (shouldSendTraces() && !ignoreOutput) try {
 					span.setAttribute(SPAN_OUTPUT, serialize(partialOutput));
 				} catch (error) {
-					logger$29.warn("Failed to serialize AI SDK stream output: " + errorMessage(error));
+					logger$31.warn("Failed to serialize AI SDK stream output: " + errorMessage(error));
 				}
 			} catch (error) {
 				if (Object.keys(partialOutput).length > 0 && shouldSendTraces() && !ignoreOutput) try {
 					span.setAttribute(SPAN_OUTPUT, serialize(partialOutput));
 				} catch (serError) {
-					logger$29.warn("Failed to serialize partial AI SDK output: " + errorMessage(serError));
+					logger$31.warn("Failed to serialize partial AI SDK output: " + errorMessage(serError));
 				}
 				span.recordException(error);
 			} finally {
-				logger$29.debug("Ending span for AI SDK result");
+				logger$31.debug("Ending span for AI SDK result");
 				span.end();
 			}
 		});
 		return originalResult;
 	}
 	if (streamInfo.type === "readable-stream") {
-		logger$29.debug("Setting up background processing for ReadableStream");
+		logger$31.debug("Setting up background processing for ReadableStream");
 		const { stream, dataPromise } = consumeAndTeeReadableStream(streamInfo.stream);
 		trackStreamProcessing(async () => {
 			try {
@@ -526,18 +526,18 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$29.warn("Failed to serialize stream output: " + errorMessage(serError));
+					logger$31.warn("Failed to serialize stream output: " + errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$29.debug("Ending span for ReadableStream");
+				logger$31.debug("Ending span for ReadableStream");
 				span.end();
 			}
 		});
 		return stream;
 	}
 	if (streamInfo.type === "async-iterable") {
-		logger$29.debug("Setting up background processing for AsyncIterable");
+		logger$31.debug("Setting up background processing for AsyncIterable");
 		const { iterable, dataPromise } = consumeAndTeeAsyncIterable(streamInfo.iterable);
 		trackStreamProcessing(async () => {
 			try {
@@ -549,18 +549,18 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$29.warn("Failed to serialize async iterable output: " + errorMessage(serError));
+					logger$31.warn("Failed to serialize async iterable output: " + errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$29.debug("Ending span for AsyncIterable");
+				logger$31.debug("Ending span for AsyncIterable");
 				span.end();
 			}
 		});
 		return iterable;
 	}
 	if (streamInfo.type === "response") {
-		logger$29.debug("Setting up background processing for Response");
+		logger$31.debug("Setting up background processing for Response");
 		const originalResponse = streamInfo.response;
 		if (!originalResponse.body) {
 			span.end();
@@ -583,19 +583,19 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$29.warn("Failed to serialize response output: " + errorMessage(serError));
+					logger$31.warn("Failed to serialize response output: " + errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} catch (err) {
 				span.recordException(err);
 			} finally {
-				logger$29.debug("Ending span for Response");
+				logger$31.debug("Ending span for Response");
 				span.end();
 			}
 		});
 		return newResponse;
 	}
-	logger$29.warn("Stream type not handled, ending span immediately");
+	logger$31.warn("Stream type not handled, ending span immediately");
 	span.end();
 	return originalResult;
 };
@@ -673,7 +673,7 @@ const writeDebugSessionFile = (file, dir = process.cwd()) => {
 * contract. This file is part of the cross-language parity surface — keep its
 * logic line-comparable with the Python `config.py`.
 */
-const logger$28 = initializeLogger();
+const logger$30 = initializeLogger();
 const TRUTHY = /* @__PURE__ */ new Set([
 	"true",
 	"1",
@@ -709,7 +709,7 @@ const parseCacheUntil = (value) => {
 	if (value === void 0 || value === "") return null;
 	const spanId = normalizeSpanId(value);
 	if (spanId !== null) return spanId;
-	logger$28.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
+	logger$30.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
 	return null;
 };
 /**
@@ -1063,7 +1063,7 @@ const resetDebugRuntime = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/span.ts
-const logger$27 = initializeLogger();
+const logger$29 = initializeLogger();
 /**
 * Build the debug block to propagate, or undefined when debug mode is off.
 *
@@ -1213,7 +1213,7 @@ var LaminarSpan = class LaminarSpan {
 				} catch {}
 				metadata[key.replace(`${ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
 			}
-		} else logger$27.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$29.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: otelSpanIdToUUID(this._span.spanContext().spanId),
 			traceId: otelTraceIdToUUID(this._span.spanContext().traceId),
@@ -1240,14 +1240,14 @@ var LaminarSpan = class LaminarSpan {
 	}
 	get tags() {
 		if (!this._span.attributes) {
-			logger$27.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$29.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$27.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$29.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 {
@@ -1443,7 +1443,7 @@ var LaminarContextManager = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/proxy.ts
-const logger$26 = initializeLogger();
+const logger$28 = initializeLogger();
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 const DEFAULT_CC_PROXY_PORT = 45667;
 const CC_PROXY_PORT_ATTEMPTS = 50;
@@ -1697,7 +1697,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$26.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$28.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))) {
@@ -1709,7 +1709,7 @@ const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL,
 			region = getRegionFromAwsConfig(awsProfile) ?? void 0;
 		}
 		if (region) return `https://bedrock-runtime.${region}.amazonaws.com`;
-		logger$26.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$28.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))) {
@@ -1792,11 +1792,11 @@ const waitForPort = (port, timeoutMs = 5e3) => new Promise((resolve) => {
 const registerGlobalProxyShutdown = () => {
 	if (!globalShutdownRegistered) {
 		process.on("exit", () => {
-			logger$26.debug("process.on(\"exit\") called - stopping all active proxies");
+			logger$28.debug("process.on(\"exit\") called - stopping all active proxies");
 			for (const proxyServer of activeProxyServers) try {
 				proxyServer.stopServer();
 			} catch (e) {
-				logger$26.debug(`Failed to stop proxy: ${errorMessage(e)}`);
+				logger$28.debug(`Failed to stop proxy: ${errorMessage(e)}`);
 			}
 			activeProxyServers.clear();
 		});
@@ -1811,28 +1811,28 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 	try {
 		const port = await findAvailablePort(DEFAULT_CC_PROXY_PORT, CC_PROXY_PORT_ATTEMPTS);
 		if (port === null) {
-			logger$26.warn("Unable to allocate port for cc-proxy.");
+			logger$28.warn("Unable to allocate port for cc-proxy.");
 			return null;
 		}
 		const targetUrl = resolvedTargetUrl ?? resolveTargetUrlFromEnv(env, void 0, cwd, settingSources, settings);
 		if (!targetUrl) {
-			logger$26.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
+			logger$28.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
 			return null;
 		}
-		logger$26.debug(`Creating proxy instance on port ${port} targeting: ${targetUrl}`);
+		logger$28.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$26.warn(`cc-proxy failed to start on port ${port}`);
+				logger$28.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$26.info(`Started claude proxy server on: ${proxyBaseUrl}`);
+			logger$28.info(`Started claude proxy server on: ${proxyBaseUrl}`);
 			return {
 				server: proxyServer,
 				baseUrl: proxyBaseUrl,
@@ -1840,11 +1840,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 				targetUrl
 			};
 		} catch (e) {
-			logger$26.warn(`Unable to start cc-proxy: ${errorMessage(e)}`);
+			logger$28.warn(`Unable to start cc-proxy: ${errorMessage(e)}`);
 			return null;
 		}
 	} catch (e) {
-		logger$26.warn(`Failed to create proxy instance: ${errorMessage(e)}`);
+		logger$28.warn(`Failed to create proxy instance: ${errorMessage(e)}`);
 		return null;
 	}
 };
@@ -1854,11 +1854,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 const stopProxyInstance = (instance) => {
 	if (!instance) return;
 	try {
-		logger$26.debug(`Stopping proxy instance on port ${instance.port}`);
+		logger$28.debug(`Stopping proxy instance on port ${instance.port}`);
 		instance.server.stopServer();
 		activeProxyServers.delete(instance.server);
 	} catch (e) {
-		logger$26.debug(`Failed to stop proxy instance: ${errorMessage(e)}`);
+		logger$28.debug(`Failed to stop proxy instance: ${errorMessage(e)}`);
 	}
 };
 /**
@@ -1866,11 +1866,11 @@ const stopProxyInstance = (instance) => {
 * Used during shutdown to ensure cleanup
 */
 const forceReleaseProxy = () => {
-	logger$26.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
+	logger$28.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
 	for (const proxyServer of activeProxyServers) try {
 		proxyServer.stopServer();
 	} catch (e) {
-		logger$26.debug(`Failed to stop proxy: ${errorMessage(e)}`);
+		logger$28.debug(`Failed to stop proxy: ${errorMessage(e)}`);
 	}
 	activeProxyServers.clear();
 };
@@ -1920,14 +1920,14 @@ const setTraceToProxyInstance = async (instance) => {
 			spanPath: payload.span_path,
 			laminarUrl: payload.laminar_url
 		});
-		logger$26.debug(`Set trace context to proxy on port ${instance.port}`);
+		logger$28.debug(`Set trace context to proxy on port ${instance.port}`);
 	} catch (e) {
-		logger$26.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + errorMessage(e));
+		logger$28.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + errorMessage(e));
 	}
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/index.ts
-const logger$25 = initializeLogger();
+const logger$27 = initializeLogger();
 /**
 * Create an instrumented version of the claude-agent-sdk query function.
 * This can be used when importing the query function before Laminar initialization.
@@ -1963,9 +1963,9 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					targetUrl
 				});
 				if (proxyInstance && targetUrl) {
-					logger$25.debug(`Using proxy on port ${proxyInstance.port}`);
+					logger$27.debug(`Using proxy on port ${proxyInstance.port}`);
 					await Laminar.withSpan(span, async () => {
-						logger$25.debug("Setting trace to proxy instance...");
+						logger$27.debug("Setting trace to proxy instance...");
 						await setTraceToProxyInstance(proxyInstance);
 					});
 					const varsToRemove = getEnvVarsToRemove(mergedEnv, sessionCwd, settingSources);
@@ -1980,13 +1980,13 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_BEDROCK")) subprocessEnv.ANTHROPIC_BEDROCK_BASE_URL = proxyInstance.baseUrl;
 					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_VERTEX")) subprocessEnv.ANTHROPIC_VERTEX_BASE_URL = proxyInstance.baseUrl;
 					const flagSettings = buildProxyFlagSettings(callerSettings, proxyInstance.baseUrl, sessionCwd, settingSources);
-					if (flagSettings === null) logger$25.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
+					if (flagSettings === null) logger$27.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
 					else {
 						params.options.settings = flagSettings;
 						const conflicting = Object.entries(readClaudeSettingsEnv(sessionCwd, settingSources)).filter(([key, value]) => PROXY_BASE_URL_ENV_KEYS.includes(key) && value !== "" && value !== proxyInstance?.baseUrl).map(([key]) => key);
-						if (conflicting.length > 0) logger$25.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
+						if (conflicting.length > 0) logger$27.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
 					}
-				} else logger$25.debug("No claude proxy server available. Proceeding without proxy.");
+				} else logger$27.debug("No claude proxy server available. Proceeding without proxy.");
 				const originalGenerator = originalQuery(params);
 				for await (const message of originalGenerator) {
 					collected.push(message);
@@ -2015,7 +2015,7 @@ var ClaudeAgentSDKInstrumentation = class extends InstrumentationBase {
 	}
 	manuallyInstrument(claudeAgentModule) {
 		if (claudeAgentModule.query && typeof claudeAgentModule.query === "function") this._wrap(claudeAgentModule, "query", this.patchQuery());
-		else logger$25.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
+		else logger$27.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
 	}
 	patchQuery() {
 		return (original) => instrumentClaudeAgentQuery(original);
@@ -2031,9 +2031,19 @@ var ClaudeAgentSDKInstrumentation = class extends InstrumentationBase {
 	}
 };
 //#endregion
+//#region src/opentelemetry-lib/instrumentation/langchain/llm-call.ts
+/**
+* Context key carrying the LangChain LLM call currently in progress. Set by the
+* `BaseChatModel` / `BaseLLM` wrappers for the duration of the model call.
+*
+* Kept free of other imports: `Laminar._startSpan` reads it to tell a handed
+* off call that the provider SDK instrumentation did record its span.
+*/
+const LLM_CALL_KEY = createContextKey("lmnr.langchain.llm_call");
+//#endregion
 //#region src/laminar.ts
 loadEnv();
-const logger$24 = initializeLogger();
+const logger$26 = initializeLogger();
 var Laminar = class Laminar {
 	static {
 		this.isInitialized = false;
@@ -2105,28 +2115,32 @@ var Laminar = class Laminar {
 	* and you want Laminar spans to be children of the existing spans.
 	* @param {SpanProcessor} props.spanProcessor - The span processor to use. If passed, some of
 	* the other options will be ignored.
+	* @param {string} props.release - The release of the running code, usually its git commit
+	* SHA. Laminar groups an agent's traces into versions by release. If not specified, read
+	* from the LMNR_RELEASE environment variable, common deploy platform variables (Vercel,
+	* Render, Railway, Heroku, Cloud Run, ...), or the checked-out git commit.
 	*
 	* @example
 	* import { Laminar } from '@lmnr-ai/lmnr';
 	* import { OpenAI } from 'openai';
-	* import * as ChainsModule from "langchain/chains";
+	* import * as CallbackManagerModule from "@langchain/core/callbacks/manager";
 	*
-	* // Initialize Laminar while auto-instrumenting Langchain and OpenAI modules.
+	* // Initialize Laminar while instrumenting LangChain and OpenAI modules.
 	* Laminar.initialize({
 	*   projectApiKey: "<LMNR_PROJECT_API_KEY>",
 	*   instrumentModules: {
 	*     langchain: {
-	*       chainsModule: ChainsModule
+	*       callbackManagerModule: CallbackManagerModule
 	*     },
-	*     openAI: OpenAI
+	*     OpenAI: OpenAI
 	*   }
 	* });
 	*
 	* @throws {Error} - If project API key is not set
 	*/
-	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, maxExportBatchSizeBytes, flushBySize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor } = {}) {
+	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, maxExportBatchSizeBytes, flushBySize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor, release } = {}) {
 		if (this.isInitialized) {
-			logger$24.warn("Laminar has already been initialized. Skipping initialization.");
+			logger$26.warn("Laminar has already been initialized. Skipping initialization.");
 			return;
 		}
 		const key = projectApiKey ?? process?.env?.LMNR_PROJECT_API_KEY;
@@ -2150,7 +2164,7 @@ var Laminar = class Laminar {
 			...metadata ?? {}
 		};
 		if (inheritGlobalContext) LaminarContextManager.inheritGlobalContext = true;
-		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$24.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
+		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$26.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, "");
@@ -2170,7 +2184,8 @@ var Laminar = class Laminar {
 			flushBySize,
 			traceExportTimeoutMillis,
 			sessionRecordingOptions,
-			spanProcessor
+			spanProcessor,
+			release
 		});
 		this._initDebugRuntime(url, port);
 		LaminarContextManager.setGlobalMetadata(this.globalMetadata);
@@ -2197,11 +2212,11 @@ var Laminar = class Laminar {
 			try {
 				getRuntime()?.recordTraceId(otelTraceIdToUUID(otelSpanContext.traceId));
 			} catch (e) {
-				logger$24.debug("Failed to record debug trace id from env: " + errorMessage(e));
+				logger$26.debug("Failed to record debug trace id from env: " + errorMessage(e));
 			}
-			logger$24.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
+			logger$26.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
 		} catch (e) {
-			logger$24.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + errorMessage(e));
+			logger$26.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + errorMessage(e));
 		}
 	}
 	/**
@@ -2245,7 +2260,7 @@ var Laminar = class Laminar {
 				if (projectId) {
 					runtime.recordProjectId(projectId);
 					const sessionUrl = runtime.debuggerSessionUrl();
-					logger$24.info(`Laminar debugger session: ${sessionUrl}`);
+					logger$26.info(`Laminar debugger session: ${sessionUrl}`);
 					if (runtime.shouldOpenBrowser) {
 						const opener = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
 						spawn(opener, [sessionUrl], {
@@ -2255,7 +2270,7 @@ var Laminar = class Laminar {
 					}
 				}
 			}).catch((e) => {
-				logger$24.warn("Failed to register debug session: " + errorMessage(e));
+				logger$26.warn("Failed to register debug session: " + errorMessage(e));
 			});
 			this.globalMetadata = {
 				...this.globalMetadata,
@@ -2265,7 +2280,7 @@ var Laminar = class Laminar {
 			this.debugExitHook = () => runtime.emitPointer();
 			process.once("exit", this.debugExitHook);
 		} catch (e) {
-			logger$24.warn("Failed to initialize debug runtime: " + errorMessage(e));
+			logger$26.warn("Failed to initialize debug runtime: " + errorMessage(e));
 		}
 	}
 	/**
@@ -2312,7 +2327,7 @@ var Laminar = class Laminar {
 				runtime.rolloutSessions.register({ sessionId: runtime.sessionId }).then((projectId) => {
 					if (projectId) runtime.recordProjectId(projectId);
 				}).catch((e) => {
-					logger$24.debug("Failed to register downstream debug session: " + errorMessage(e));
+					logger$26.debug("Failed to register downstream debug session: " + errorMessage(e));
 				});
 				this.globalMetadata = {
 					...this.globalMetadata,
@@ -2321,7 +2336,7 @@ var Laminar = class Laminar {
 				LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 			}
 		} catch (e) {
-			logger$24.debug("Failed to arm debug runtime from context: " + errorMessage(e));
+			logger$26.debug("Failed to arm debug runtime from context: " + errorMessage(e));
 		}
 	}
 	/**
@@ -2336,7 +2351,7 @@ var Laminar = class Laminar {
 	*/
 	static patch(modules) {
 		if (!this.isInitialized) {
-			logger$24.warn("Laminar must be initialized before patching modules. Skipping patch.");
+			logger$26.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");
@@ -2596,7 +2611,7 @@ var Laminar = class Laminar {
 			const spanContext = tryToOtelSpanContext(laminarContext);
 			entityContext = trace.setSpan(entityContext, trace.wrapSpanContext(spanContext));
 		} catch (e) {
-			logger$24.warn("Failed to parse parent span context: " + errorMessage(e));
+			logger$26.warn("Failed to parse parent span context: " + errorMessage(e));
 		}
 		const tagProperties = tags ? { [`${ASSOCIATION_PROPERTIES}.tags`]: Array.from(new Set(tags)) } : {};
 		const ctxAssociationProperties = LaminarContextManager.getAssociationProperties();
@@ -2632,6 +2647,10 @@ var Laminar = class Laminar {
 			startTime
 		}, entityContext));
 		span.activated = activated ?? false;
+		if (spanType === "LLM") {
+			const llmCall = entityContext.getValue(LLM_CALL_KEY);
+			if (llmCall?.mode === "handoff" && span.isRecording()) llmCall.recorded = true;
+		}
 		if (input) span.setInput(input);
 		if (activated) {
 			entityContext = LaminarContextManager.setAssociationProperties(span, entityContext);
@@ -2700,13 +2719,13 @@ var Laminar = class Laminar {
 	}
 	static async flush() {
 		if (this.isInitialized) {
-			logger$24.debug("Flushing spans");
+			logger$26.debug("Flushing spans");
 			await forceFlush();
 		}
 	}
 	static async shutdown() {
 		if (this.isInitialized) {
-			logger$24.debug("Shutting down Laminar");
+			logger$26.debug("Shutting down Laminar");
 			getRuntime()?.emitPointer();
 			await forceFlush();
 			this.isInitialized = false;
@@ -2841,7 +2860,7 @@ return module.exports;
 //#endregion
 //#region src/browser/utils.ts
 const LMNR_SEND_EVENTS_FUNCTION_NAME = "lmnrSendEvents";
-const logger$23 = initializeLogger();
+const logger$25 = initializeLogger();
 /**
 * If the first argument is a string, return an object with the name of the method
 * and the argument as the value.
@@ -2864,7 +2883,7 @@ const takeFullSnapshot = async (page) => await page.evaluate(() => {
 		window.lmnrRrweb.record.takeFullSnapshot();
 		return true;
 	} catch (error) {
-		logger$23.error("Error taking full snapshot: " + errorMessage(error));
+		logger$25.error("Error taking full snapshot: " + errorMessage(error));
 		return false;
 	}
 	return false;
@@ -2875,7 +2894,7 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 			try {
 				return await script();
 			} catch (error) {
-				logger$23.error("Operation " + script.name + " failed: " + errorMessage(error));
+				logger$25.error("Operation " + script.name + " failed: " + errorMessage(error));
 			}
 			await new Promise((resolve) => setTimeout(resolve, 500));
 		}
@@ -2885,20 +2904,20 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 	try {
 		isRrwebPresent = await castedPage.evaluate(() => typeof window.lmnrRrweb !== "undefined");
 	} catch (error) {
-		logger$23.debug("Failed to check if session recorder is loaded: " + errorMessage(error));
+		logger$25.debug("Failed to check if session recorder is loaded: " + errorMessage(error));
 	}
 	if (!isRrwebPresent) {
 		if (!await tryRunScript(async function injectSessionRecorder() {
 			await castedPage.evaluate(RECORDER);
 			return true;
 		})) {
-			logger$23.error("Failed to load session recorder");
+			logger$25.error("Failed to load session recorder");
 			return;
 		}
 		try {
 			await castedPage.evaluate(injectScript, sessionRecordingOptions);
 		} catch (error) {
-			logger$23.debug("Failed to inject session recorder: " + errorMessage(error));
+			logger$25.debug("Failed to inject session recorder: " + errorMessage(error));
 		}
 	}
 };
@@ -3164,7 +3183,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 	try {
 		const { batchId, chunkIndex, totalChunks, data } = chunk;
 		if (!sessionId || !traceId) {
-			logger$23.debug("Missing sessionId or traceId in chunk");
+			logger$25.debug("Missing sessionId or traceId in chunk");
 			return;
 		}
 		if (!chunkBuffers.has(batchId)) chunkBuffers.set(batchId, {
@@ -3183,7 +3202,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 				traceId,
 				events
 			}).catch((error) => {
-				logger$23.debug("Failed to send events: " + errorMessage(error));
+				logger$25.debug("Failed to send events: " + errorMessage(error));
 			});
 			chunkBuffers.delete(batchId);
 		}
@@ -3191,16 +3210,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$23.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
+			logger$25.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
 			chunkBuffers.delete(bid);
 		}
 	} catch (error) {
-		logger$23.debug("Could not send events: " + errorMessage(error));
+		logger$25.debug("Could not send events: " + errorMessage(error));
 	}
 }
 //#endregion
 //#region src/browser/playwright.ts
-const logger$22 = initializeLogger();
+const logger$24 = initializeLogger();
 var PlaywrightInstrumentation = class extends InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/playwright-instrumentation", version, { enabled: true });
@@ -3308,7 +3327,7 @@ var PlaywrightInstrumentation = class extends InstrumentationBase {
 			try {
 				await injectSessionRecorder(page, this._sessionRecordingOptions);
 			} catch (error) {
-				logger$22.error("Error in onLoad handler: " + errorMessage(error));
+				logger$24.error("Error in onLoad handler: " + errorMessage(error));
 			}
 		});
 		const chunkBuffers = /* @__PURE__ */ new Map();
@@ -3318,7 +3337,7 @@ var PlaywrightInstrumentation = class extends InstrumentationBase {
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$22.debug("Could not expose function lmnrSendEvents: " + errorMessage(error));
+			logger$24.debug("Could not expose function lmnrSendEvents: " + errorMessage(error));
 		}
 	}
 };
@@ -3743,7 +3762,7 @@ var StagehandV2Instrumentation = class extends InstrumentationBase {
 };
 //#endregion
 //#region src/browser/puppeteer.ts
-const logger$21 = initializeLogger();
+const logger$23 = initializeLogger();
 var PuppeteerInstrumentation = class extends InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/puppeteer-instrumentation", version, { enabled: true });
@@ -3788,10 +3807,10 @@ var PuppeteerInstrumentation = class extends InstrumentationBase {
 				context.on("targetcreated", (target) => {
 					target.page().then((page) => {
 						if (page) plugin.patchPage(page, sessionId).catch((error) => {
-							logger$21.error("Failed to patch page: " + errorMessage(error));
+							logger$23.error("Failed to patch page: " + errorMessage(error));
 						});
 					}).catch((error) => {
-						logger$21.error("Failed to patch page: " + errorMessage(error));
+						logger$23.error("Failed to patch page: " + errorMessage(error));
 					});
 				});
 				await Promise.all((await context.pages()).map((page) => plugin.patchPage(page, sessionId)));
@@ -3809,19 +3828,19 @@ var PuppeteerInstrumentation = class extends InstrumentationBase {
 			context.on("targetcreated", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$21.error("Failed to patch page: " + errorMessage(error));
+						logger$23.error("Failed to patch page: " + errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$21.error("Failed to patch page: " + errorMessage(error));
+					logger$23.error("Failed to patch page: " + errorMessage(error));
 				});
 			});
 			context.on("targetchanged", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$21.error("Failed to patch page: " + errorMessage(error));
+						logger$23.error("Failed to patch page: " + errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$21.error("Failed to patch page: " + errorMessage(error));
+					logger$23.error("Failed to patch page: " + errorMessage(error));
 				});
 			});
 			for (const page of await context.pages()) await plugin.patchPage(page, sessionId);
@@ -3845,7 +3864,7 @@ var PuppeteerInstrumentation = class extends InstrumentationBase {
 		const traceId = otelTraceId ? otelTraceIdToUUID(otelTraceId) : NIL_UUID;
 		page.on("domcontentloaded", () => {
 			injectSessionRecorder(page, this._sessionRecordingOptions).catch((error) => {
-				logger$21.error("Error in onLoad handler: " + errorMessage(error));
+				logger$23.error("Error in onLoad handler: " + errorMessage(error));
 			});
 		});
 		await injectSessionRecorder(page, this._sessionRecordingOptions);
@@ -3855,13 +3874,13 @@ var PuppeteerInstrumentation = class extends InstrumentationBase {
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$21.debug("Could not expose function lmnrSendEvents: " + errorMessage(error));
+			logger$23.debug("Could not expose function lmnrSendEvents: " + errorMessage(error));
 		}
 	}
 };
 //#endregion
 //#region src/browser/stagehand/v3/constants.ts
-const logger$20 = initializeLogger();
+const logger$22 = initializeLogger();
 const CDP_OPERATION_TIMEOUT_MS = 1e4;
 const SKIP_URL_PATTERNS = [
 	"about:blank",
@@ -3912,7 +3931,7 @@ async function getOrCreateIsolatedWorld(page) {
 			frameId
 		};
 	} catch (error) {
-		logger$20.debug("Failed to create isolated world: " + errorMessage(error));
+		logger$22.debug("Failed to create isolated world: " + errorMessage(error));
 		return null;
 	}
 }
@@ -3929,7 +3948,7 @@ async function isRecorderPresent(page, contextId) {
 		if (!result) return true;
 		return result.result?.value === true;
 	} catch (error) {
-		logger$20.debug("Failed to check if recorder is present: " + errorMessage(error));
+		logger$22.debug("Failed to check if recorder is present: " + errorMessage(error));
 		return true;
 	}
 }
@@ -3942,21 +3961,21 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 		try {
 			url = page.url();
 		} catch (error) {
-			logger$20.debug("Failed to get page URL, page might be closed: " + errorMessage(error));
+			logger$22.debug("Failed to get page URL, page might be closed: " + errorMessage(error));
 			return null;
 		}
 		if (shouldSkipUrl(url)) {
-			logger$20.debug(`Skipping recorder injection for URL: ${url}`);
+			logger$22.debug(`Skipping recorder injection for URL: ${url}`);
 			return null;
 		}
 		const worldResult = await getOrCreateIsolatedWorld(page);
 		if (!worldResult) {
-			logger$20.debug("Failed to get isolated world for page");
+			logger$22.debug("Failed to get isolated world for page");
 			return null;
 		}
 		const { contextId, frameId } = worldResult;
 		if (await isRecorderPresent(page, contextId)) {
-			logger$20.debug("Recorder already present, skipping injection");
+			logger$22.debug("Recorder already present, skipping injection");
 			state.contextIdToSession.set(contextId, {
 				sessionId: state.sessionId,
 				traceId: state.traceId
@@ -3969,7 +3988,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$20.debug("Failed to inject rrweb: " + errorMessage(error));
+			logger$22.debug("Failed to inject rrweb: " + errorMessage(error));
 			return null;
 		}
 		const optionsJson = JSON.stringify(sessionRecordingOptions ?? {});
@@ -3980,14 +3999,14 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$20.debug("Failed to inject recording setup: " + errorMessage(error));
+			logger$22.debug("Failed to inject recording setup: " + errorMessage(error));
 			return null;
 		}
 		try {
 			await sendCDP(page, "Runtime.addBinding", { name: "lmnrSendEvents" });
-			logger$20.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
+			logger$22.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
 		} catch (error) {
-			logger$20.debug("Binding may already exist: " + errorMessage(error));
+			logger$22.debug("Binding may already exist: " + errorMessage(error));
 		}
 		if (bindingHandler) try {
 			const pageTargetId = page.targetId();
@@ -3997,26 +4016,26 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 					const sessionTyped = session;
 					if (sessionTyped.on) {
 						sessionTyped.on("Runtime.bindingCalled", bindingHandler);
-						logger$20.debug(`Set up binding handler on session ${sessionId}`);
+						logger$22.debug(`Set up binding handler on session ${sessionId}`);
 					}
 				} catch (error) {
-					logger$20.debug(`Failed to set up binding handler on session ${sessionId}: ` + errorMessage(error));
+					logger$22.debug(`Failed to set up binding handler on session ${sessionId}: ` + errorMessage(error));
 				}
 				state.pageSessionHandlers.set(pageTargetId, bindingHandler);
 			}
 		} catch (error) {
-			logger$20.debug("Failed to set up binding handler: " + errorMessage(error));
+			logger$22.debug("Failed to set up binding handler: " + errorMessage(error));
 		}
 		state.contextIdToSession.set(contextId, {
 			sessionId: state.sessionId,
 			traceId: state.traceId
 		});
-		logger$20.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
+		logger$22.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
 		state.instrumentedPageIds.add(frameId);
-		logger$20.debug(`Successfully injected recorder into page ${frameId}`);
+		logger$22.debug(`Successfully injected recorder into page ${frameId}`);
 		return contextId;
 	} catch (error) {
-		logger$20.debug("Error injecting recorder: " + errorMessage(error));
+		logger$22.debug("Error injecting recorder: " + errorMessage(error));
 		return null;
 	}
 }
@@ -4030,13 +4049,13 @@ function createBindingHandler(state) {
 		if (event.name !== "lmnrSendEvents") return;
 		const sessionInfo = state.contextIdToSession.get(event.executionContextId);
 		if (!sessionInfo) {
-			logger$20.debug("No session info found for context ID: " + event.executionContextId);
+			logger$22.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$20.debug("Failed to parse binding payload: " + errorMessage(error));
+					logger$22.debug("Failed to parse binding payload: " + errorMessage(error));
 				}
 			}
 			return;
@@ -4044,7 +4063,7 @@ function createBindingHandler(state) {
 		try {
 			sendEvents(JSON.parse(event.payload), state.client, state.chunkBuffers, sessionInfo.sessionId, sessionInfo.traceId);
 		} catch (error) {
-			logger$20.debug("Failed to handle binding event: " + errorMessage(error));
+			logger$22.debug("Failed to handle binding event: " + errorMessage(error));
 		}
 	};
 }
@@ -4060,10 +4079,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$20.debug("Error injecting recorder into new page: " + errorMessage(error));
+				logger$22.debug("Error injecting recorder into new page: " + errorMessage(error));
 			}
 		} catch (error) {
-			logger$20.debug("Error handling target created event: " + errorMessage(error));
+			logger$22.debug("Error handling target created event: " + errorMessage(error));
 		}
 	};
 }
@@ -4075,7 +4094,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 		if (event.targetInfo.type !== "page") return;
 		const url = event.targetInfo.url;
 		if (shouldSkipUrl(url)) return;
-		logger$20.debug(`Target URL changed to ${url}, checking if recorder injection needed`);
+		logger$22.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) {
@@ -4083,7 +4102,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 				break;
 			}
 		} catch (error) {
-			logger$20.debug("Error handling target info change: " + errorMessage(error));
+			logger$22.debug("Error handling target info change: " + errorMessage(error));
 		}
 	};
 }
@@ -4244,12 +4263,12 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 	*/
 	async setupSessionRecording(stagehandInstance, sessionId, traceId) {
 		if (!this._client) {
-			logger$20.debug("No Laminar client available, skipping session recording setup");
+			logger$22.debug("No Laminar client available, skipping session recording setup");
 			return;
 		}
 		const context = stagehandInstance.context;
 		if (!context || !context.conn) {
-			logger$20.debug("No context or connection available, skipping session recording setup");
+			logger$22.debug("No context or connection available, skipping session recording setup");
 			return;
 		}
 		const recorderState = {
@@ -4279,11 +4298,11 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			for (const page of pages) try {
 				if (await injectRecorderViaCDP(page, recorderState, context.conn, this._sessionRecordingOptions, bindingHandler) !== null) injectedCount++;
 			} catch (error) {
-				logger$20.debug("Error injecting recorder into page: " + errorMessage(error));
+				logger$22.debug("Error injecting recorder into page: " + errorMessage(error));
 			}
-			logger$20.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
+			logger$22.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
 		} catch (error) {
-			logger$20.debug("Error accessing pages for recorder injection: " + errorMessage(error));
+			logger$22.debug("Error accessing pages for recorder injection: " + errorMessage(error));
 		}
 	}
 	patchStagehandClose() {
@@ -4313,12 +4332,12 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			if (recorderState.targetCreatedHandler) try {
 				context.conn.off("Target.targetCreated", recorderState.targetCreatedHandler);
 			} catch (error) {
-				logger$20.debug("Error removing target created handler: " + errorMessage(error));
+				logger$22.debug("Error removing target created handler: " + errorMessage(error));
 			}
 			if (recorderState.targetInfoChangedHandler) try {
 				context.conn.off("Target.targetInfoChanged", recorderState.targetInfoChangedHandler);
 			} catch (error) {
-				logger$20.debug("Error removing target info changed handler: " + errorMessage(error));
+				logger$22.debug("Error removing target info changed handler: " + errorMessage(error));
 			}
 		}
 		recorderState.contextIdToSession.clear();
@@ -4329,7 +4348,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		recorderState.targetCreatedHandler = null;
 		recorderState.targetInfoChangedHandler = null;
 		this.stagehandInstanceToRecorderState.delete(stagehandInstance);
-		logger$20.debug("Cleaned up session recording for Stagehand instance");
+		logger$22.debug("Cleaned up session recording for Stagehand instance");
 	}
 	patchStagehandGlobalMethod(methodName, sessionId, parentSpan) {
 		return (original) => async function method(...args) {
@@ -4680,7 +4699,7 @@ function extractToolDefinitions(config) {
 * Also used by the google-aiplatform (Vertex AI) instrumentation, which
 * reshapes its requests into the same `{model, contents, config}` form.
 */
-function setRequestAttributes$5(span, params, traceContent, system = "gemini") {
+function setRequestAttributes$6(span, params, traceContent, system = "gemini") {
 	safeSetAttribute$2(span, LLM_SYSTEM, system);
 	safeSetAttribute$2(span, LLM_REQUEST_MODEL, params?.model);
 	const config = params?.config;
@@ -4707,7 +4726,7 @@ function setRequestAttributes$5(span, params, traceContent, system = "gemini") {
 /**
 * Set response attributes on a span from a GenerateContentResponse.
 */
-function setResponseAttributes$5(span, response, traceContent) {
+function setResponseAttributes$6(span, response, traceContent) {
 	if (!response) return;
 	safeSetAttribute$2(span, LLM_RESPONSE_MODEL, response.modelVersion);
 	const usage = response.usageMetadata;
@@ -4809,7 +4828,7 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 			try {
 				if (modelVersion !== void 0 || role !== void 0 || accumulatedParts.length > 0 || sawUsageMetadata) {
 					const mergedParts = mergeTextParts(accumulatedParts);
-					setResponseAttributes$5(span, {
+					setResponseAttributes$6(span, {
 						modelVersion,
 						candidates: [{ content: {
 							role: role ?? "model",
@@ -4840,22 +4859,22 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/anthropic/utils.ts
 const ANTHROPIC_SYSTEM = "anthropic";
-const INPUT_MESSAGES$2 = "gen_ai.input.messages";
-const OUTPUT_MESSAGES$2 = "gen_ai.output.messages";
+const INPUT_MESSAGES$3 = "gen_ai.input.messages";
+const OUTPUT_MESSAGES$3 = "gen_ai.output.messages";
 const createStreamState$1 = () => ({
 	usage: {},
 	blocks: [],
 	completion: ""
 });
-const toJson$1 = (value) => {
+const toJson$2 = (value) => {
 	if (value === void 0 || value === null) return void 0;
 	return JSON.stringify(value);
 };
 const extractStructuredOutputSchema$1 = (params) => {
 	const outputFormat = params?.output_format;
-	if (outputFormat && typeof outputFormat === "object") return toJson$1(outputFormat.schema ?? outputFormat);
+	if (outputFormat && typeof outputFormat === "object") return toJson$2(outputFormat.schema ?? outputFormat);
 	const schema = params?.output_config?.format?.schema;
-	if (schema && typeof schema === "object") return toJson$1(schema);
+	if (schema && typeof schema === "object") return toJson$2(schema);
 };
 const buildInputMessages$1 = (params) => {
 	if (params?.prompt !== void 0 && params?.prompt !== null) return [{
@@ -4871,7 +4890,7 @@ const buildInputMessages$1 = (params) => {
 	messages.push(...params.messages);
 	return messages;
 };
-const setRequestAttributes$4 = (span, params, traceContent) => {
+const setRequestAttributes$5 = (span, params, traceContent) => {
 	safeSetAttribute$2(span, "gen_ai.system", ANTHROPIC_SYSTEM);
 	safeSetAttribute$2(span, "gen_ai.request.model", params?.model);
 	safeSetAttribute$2(span, "gen_ai.request.max_tokens", params?.max_tokens ?? params?.max_tokens_to_sample);
@@ -4882,8 +4901,8 @@ const setRequestAttributes$4 = (span, params, traceContent) => {
 	safeSetAttribute$2(span, "llm.is_streaming", params?.stream);
 	safeSetAttribute$2(span, "anthropic.request.service_tier", params?.service_tier);
 	if (traceContent) {
-		safeSetAttribute$2(span, INPUT_MESSAGES$2, toJson$1(buildInputMessages$1(params)));
-		safeSetAttribute$2(span, "gen_ai.tool.definitions", toJson$1(params?.tools));
+		safeSetAttribute$2(span, INPUT_MESSAGES$3, toJson$2(buildInputMessages$1(params)));
+		safeSetAttribute$2(span, "gen_ai.tool.definitions", toJson$2(params?.tools));
 	}
 	safeSetAttribute$2(span, "gen_ai.request.structured_output_schema", extractStructuredOutputSchema$1(params));
 };
@@ -4903,7 +4922,7 @@ const setUsageAttributes$1 = (span, usage, includeTotal) => {
 /**
 * Response attributes for a non-streaming `Message` (or legacy `Completion`).
 */
-const setResponseAttributes$4 = (span, response, traceContent) => {
+const setResponseAttributes$5 = (span, response, traceContent) => {
 	if (!response || typeof response !== "object") return;
 	safeSetAttribute$2(span, "gen_ai.response.model", response.model);
 	safeSetAttribute$2(span, "gen_ai.response.id", response.id);
@@ -4920,7 +4939,7 @@ const setResponseAttributes$4 = (span, response, traceContent) => {
 			text: response.completion
 		});
 		else if (Array.isArray(response.content)) output.content.push(...response.content);
-		safeSetAttribute$2(span, OUTPUT_MESSAGES$2, toJson$1([output]));
+		safeSetAttribute$2(span, OUTPUT_MESSAGES$3, toJson$2([output]));
 	}
 	span.setStatus({ code: SpanStatusCode.OK });
 };
@@ -5013,14 +5032,14 @@ const setStreamingResponseAttributes = (span, state, traceContent) => {
 			content: buildStreamedContent(state)
 		};
 		if (state.stopReason) output.stop_reason = state.stopReason;
-		safeSetAttribute$2(span, OUTPUT_MESSAGES$2, toJson$1([output]));
+		safeSetAttribute$2(span, OUTPUT_MESSAGES$3, toJson$2([output]));
 	}
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/anthropic/index.ts
-const logger$19 = initializeLogger();
-const PATCH_DATA_SYMBOL$3 = Symbol("lmnr.anthropic.patchData");
-const hasOwnPatchData$2 = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$3) !== void 0;
+const logger$21 = initializeLogger();
+const PATCH_DATA_SYMBOL$4 = Symbol("lmnr.anthropic.patchData");
+const hasOwnPatchData$3 = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$4) !== void 0;
 const markSpanError$3 = (span, error) => {
 	span.recordException(error);
 	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
@@ -5033,7 +5052,7 @@ const safely$3 = (fn) => {
 	try {
 		fn();
 	} catch (error) {
-		logger$19.debug(`Failed to set anthropic span attributes: ${String(error)}`);
+		logger$21.debug(`Failed to set anthropic span attributes: ${String(error)}`);
 	}
 };
 const isAsyncIterable$3 = (value) => value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
@@ -5084,9 +5103,9 @@ var AnthropicInstrumentation = class extends InstrumentationBase {
 	unpatch(moduleExports) {
 		diag.debug("Unpatching @anthropic-ai/sdk");
 		for (const proto of this.resourcePrototypes(moduleExports)) {
-			if (!proto || !hasOwnPatchData$2(proto)) continue;
-			proto.create = proto[PATCH_DATA_SYMBOL$3].original;
-			delete proto[PATCH_DATA_SYMBOL$3];
+			if (!proto || !hasOwnPatchData$3(proto)) continue;
+			proto.create = proto[PATCH_DATA_SYMBOL$4].original;
+			delete proto[PATCH_DATA_SYMBOL$4];
 		}
 	}
 	/**
@@ -5108,15 +5127,15 @@ var AnthropicInstrumentation = class extends InstrumentationBase {
 	*/
 	patchCreate(proto, spanName) {
 		if (!proto || typeof proto.create !== "function") return;
-		if (hasOwnPatchData$2(proto)) {
-			proto[PATCH_DATA_SYMBOL$3].traceContent = this.traceContent;
+		if (hasOwnPatchData$3(proto)) {
+			proto[PATCH_DATA_SYMBOL$4].traceContent = this.traceContent;
 			return;
 		}
 		const patchData = {
 			traceContent: this.traceContent,
 			original: proto.create
 		};
-		Object.defineProperty(proto, PATCH_DATA_SYMBOL$3, {
+		Object.defineProperty(proto, PATCH_DATA_SYMBOL$4, {
 			value: patchData,
 			writable: true,
 			configurable: true,
@@ -5133,7 +5152,7 @@ const wrapCreate = (patchData, spanName) => function(params, ...rest) {
 		name: spanName,
 		spanType: "LLM"
 	});
-	safely$3(() => setRequestAttributes$4(span, params, traceContent));
+	safely$3(() => setRequestAttributes$5(span, params, traceContent));
 	let result;
 	try {
 		result = Laminar.withSpan(span, () => ({ value: original.call(this, params, ...rest) })).value;
@@ -5157,7 +5176,7 @@ const wrapCreate = (patchData, spanName) => function(params, ...rest) {
 			return data;
 		}
 		ended = true;
-		safely$3(() => setResponseAttributes$4(span, data, traceContent));
+		safely$3(() => setResponseAttributes$5(span, data, traceContent));
 		span.end();
 		return data;
 	};
@@ -5207,8 +5226,8 @@ const instrumentStream$2 = (stream, span, traceContent) => {
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/cohere/utils.ts
 const COHERE_SYSTEM = "cohere";
-const INPUT_MESSAGES$1 = "gen_ai.input.messages";
-const OUTPUT_MESSAGES$1 = "gen_ai.output.messages";
+const INPUT_MESSAGES$2 = "gen_ai.input.messages";
+const OUTPUT_MESSAGES$2 = "gen_ai.output.messages";
 const OPERATION_NAMES = {
 	chat: "chat",
 	completion: "text_completion",
@@ -5223,7 +5242,7 @@ const V1_ROLES = {
 };
 const asList = (value) => Array.isArray(value) ? value : [];
 const asInt = (value) => typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : void 0;
-const maybeJson = (value) => {
+const maybeJson$1 = (value) => {
 	if (typeof value !== "string") return value;
 	try {
 		return JSON.parse(value);
@@ -5291,7 +5310,7 @@ const v2ToolCallParts = (toolCalls) => asList(toolCalls).map((toolCall) => {
 		name: toolCall?.function?.name ?? ""
 	};
 	const args = toolCall?.function?.arguments;
-	if (args !== void 0 && args !== null) part.arguments = maybeJson(args);
+	if (args !== void 0 && args !== null) part.arguments = maybeJson$1(args);
 	return part;
 });
 const v1ToolCallParts = (toolCalls) => asList(toolCalls).map((toolCall) => ({
@@ -5381,7 +5400,7 @@ const toolDefinitions = (tools) => asList(tools).map((tool) => {
 	if (parameters) definition.parameters = parameters;
 	return definition;
 });
-const setRequestAttributes$3 = (span, params, requestType, isV2, isStreaming, traceContent) => {
+const setRequestAttributes$4 = (span, params, requestType, isV2, isStreaming, traceContent) => {
 	safeSetAttribute$2(span, "gen_ai.system", COHERE_SYSTEM);
 	safeSetAttribute$2(span, "gen_ai.operation.name", OPERATION_NAMES[requestType]);
 	safeSetAttribute$2(span, "gen_ai.request.model", params?.model);
@@ -5406,12 +5425,12 @@ const setRequestAttributes$3 = (span, params, requestType, isV2, isStreaming, tr
 	}] : [];
 	else if (requestType === "rerank") messages = rerankInput(params);
 	else messages = embedInput(params);
-	if (messages.length > 0) span.setAttribute(INPUT_MESSAGES$1, JSON.stringify(messages));
+	if (messages.length > 0) span.setAttribute(INPUT_MESSAGES$2, JSON.stringify(messages));
 };
 /**
 * `usage` (v2) / `meta` (v1): actual `tokens`, falling back to `billedUnits`.
 */
-const setUsage = (span, usage) => {
+const setUsage$1 = (span, usage) => {
 	const inputTokens = asInt(usage?.tokens?.inputTokens) ?? asInt(usage?.billedUnits?.inputTokens);
 	const outputTokens = asInt(usage?.tokens?.outputTokens) ?? asInt(usage?.billedUnits?.outputTokens);
 	safeSetAttribute$2(span, "gen_ai.usage.input_tokens", inputTokens);
@@ -5447,9 +5466,9 @@ const rerankOutput = (response) => {
 		parts
 	}] : [];
 };
-const setResponseAttributes$3 = (span, response, requestType, isV2, traceContent) => {
+const setResponseAttributes$4 = (span, response, requestType, isV2, traceContent) => {
 	safeSetAttribute$2(span, "gen_ai.response.id", response?.responseId ?? response?.id);
-	setUsage(span, response?.usage ?? response?.meta);
+	setUsage$1(span, response?.usage ?? response?.meta);
 	let output = [];
 	if (requestType === "chat") {
 		const message = isV2 ? v2ChatOutput(response) : v1ChatOutput(response);
@@ -5461,7 +5480,7 @@ const setResponseAttributes$3 = (span, response, requestType, isV2, traceContent
 		output = [message];
 	} else if (requestType === "completion") output = completionOutput(response);
 	else if (requestType === "rerank") output = rerankOutput(response);
-	if (output.length > 0 && traceContent) span.setAttribute(OUTPUT_MESSAGES$1, JSON.stringify(output));
+	if (output.length > 0 && traceContent) span.setAttribute(OUTPUT_MESSAGES$2, JSON.stringify(output));
 };
 /**
 * v1 `chatStream`: the `stream-end` event carries the full response.
@@ -5578,8 +5597,8 @@ const createV2ChatStreamAccumulator = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/cohere/index.ts
-const logger$18 = initializeLogger();
-const PATCH_DATA_SYMBOL$2 = Symbol("lmnr.cohere.patchData");
+const logger$20 = initializeLogger();
+const PATCH_DATA_SYMBOL$3 = Symbol("lmnr.cohere.patchData");
 const SPAN_NAMES = {
 	chat: "cohere.chat",
 	completion: "cohere.completion",
@@ -5635,7 +5654,7 @@ const V2_METHODS = [
 		streaming: false
 	}
 ];
-const ownPatchData = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$2)?.value;
+const ownPatchData = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$3)?.value;
 const markSpanError$2 = (span, error) => {
 	span.recordException(error);
 	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
@@ -5651,7 +5670,7 @@ const safely$2 = (fn) => {
 	try {
 		fn();
 	} catch (error) {
-		logger$18.debug(`Failed to set cohere span attributes: ${String(error)}`);
+		logger$20.debug(`Failed to set cohere span attributes: ${String(error)}`);
 	}
 };
 const isAsyncIterable$2 = (value) => value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
@@ -5758,7 +5777,7 @@ var CohereInstrumentation = class extends InstrumentationBase {
 		}
 		if (!patched) {
 			patched = {};
-			Object.defineProperty(proto, PATCH_DATA_SYMBOL$2, {
+			Object.defineProperty(proto, PATCH_DATA_SYMBOL$3, {
 				value: patched,
 				writable: true,
 				configurable: true,
@@ -5783,7 +5802,7 @@ const wrapMethod$1 = (patchData) => function(request, ...rest) {
 		name: SPAN_NAMES[requestType],
 		spanType: "LLM"
 	});
-	safely$2(() => setRequestAttributes$3(span, request, requestType, isV2, streaming, traceContent));
+	safely$2(() => setRequestAttributes$4(span, request, requestType, isV2, streaming, traceContent));
 	let result;
 	try {
 		result = Laminar.withSpan(span, () => ({ value: original.call(this, request, ...rest) })).value;
@@ -5807,7 +5826,7 @@ const wrapMethod$1 = (patchData) => function(request, ...rest) {
 			instrumentStream$1(data, span, accumulator, isV2, traceContent);
 			return data;
 		}
-		safely$2(() => setResponseAttributes$3(span, data, requestType, isV2, traceContent));
+		safely$2(() => setResponseAttributes$4(span, data, requestType, isV2, traceContent));
 		span.end();
 		return data;
 	};
@@ -5832,7 +5851,7 @@ const instrumentStream$1 = (stream, span, accumulator, isV2, traceContent) => {
 	const end = (error) => {
 		if (ended) return;
 		ended = true;
-		safely$2(() => setResponseAttributes$3(span, accumulator.response(), "chat", isV2, traceContent));
+		safely$2(() => setResponseAttributes$4(span, accumulator.response(), "chat", isV2, traceContent));
 		if (error !== void 0) markSpanError$2(span, error);
 		else span.setStatus({ code: SpanStatusCode.OK });
 		span.end();
@@ -5882,7 +5901,7 @@ const fromValue = (value) => {
 		default: return;
 	}
 };
-const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+const asRecord$1 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 const asNumber = (value) => typeof value === "number" && !Number.isNaN(value) ? value : void 0;
 /**
 * Strip resource prefixes, e.g.
@@ -5903,7 +5922,7 @@ const toInputMessages = (instance) => {
 		content: instance.prompt
 	});
 	if (Array.isArray(instance.messages)) for (const message of instance.messages) {
-		const record = asRecord(message);
+		const record = asRecord$1(message);
 		if (!record) continue;
 		const author = typeof record.author === "string" ? record.author : "user";
 		messages.push({
@@ -5920,7 +5939,7 @@ const toInputMessages = (instance) => {
 const setPredictRequestAttributes = (span, request, traceContent) => {
 	safeSetAttribute$2(span, "gen_ai.system", VERTEX_AI_SYSTEM);
 	safeSetAttribute$2(span, "gen_ai.request.model", lastPathSegment(request?.endpoint));
-	const parameters = asRecord(fromValue(request?.parameters));
+	const parameters = asRecord$1(fromValue(request?.parameters));
 	if (parameters) {
 		safeSetAttribute$2(span, "gen_ai.request.max_tokens", asNumber(parameters.maxOutputTokens));
 		safeSetAttribute$2(span, "gen_ai.request.temperature", asNumber(parameters.temperature));
@@ -5929,16 +5948,16 @@ const setPredictRequestAttributes = (span, request, traceContent) => {
 	}
 	if (!traceContent || !Array.isArray(request?.instances)) return;
 	const messages = request.instances.flatMap((instance) => {
-		const record = asRecord(fromValue(instance));
+		const record = asRecord$1(fromValue(instance));
 		return record ? toInputMessages(record) : [];
 	});
 	if (messages.length > 0) safeSetAttribute$2(span, "gen_ai.input.messages", JSON.stringify(messages));
 };
 const predictionContent = (prediction) => {
-	const record = asRecord(fromValue(prediction));
+	const record = asRecord$1(fromValue(prediction));
 	if (!record) return void 0;
 	if (typeof record.content === "string") return record.content;
-	const firstCandidate = Array.isArray(record.candidates) ? asRecord(record.candidates[0]) : void 0;
+	const firstCandidate = Array.isArray(record.candidates) ? asRecord$1(record.candidates[0]) : void 0;
 	if (typeof firstCandidate?.content === "string") return firstCandidate.content;
 };
 /**
@@ -5947,10 +5966,10 @@ const predictionContent = (prediction) => {
 const setPredictResponseAttributes = (span, response, traceContent) => {
 	if (!response) return;
 	safeSetAttribute$2(span, "gen_ai.response.model", lastPathSegment(response.model));
-	const metadata = asRecord(fromValue(response.metadata));
-	const tokenMetadata = asRecord(metadata?.tokenMetadata);
-	const inputTokens = asNumber(asRecord(tokenMetadata?.inputTokenCount)?.totalTokens);
-	const outputTokens = asNumber(asRecord(tokenMetadata?.outputTokenCount)?.totalTokens);
+	const metadata = asRecord$1(fromValue(response.metadata));
+	const tokenMetadata = asRecord$1(metadata?.tokenMetadata);
+	const inputTokens = asNumber(asRecord$1(tokenMetadata?.inputTokenCount)?.totalTokens);
+	const outputTokens = asNumber(asRecord$1(tokenMetadata?.outputTokenCount)?.totalTokens);
 	safeSetAttribute$2(span, "gen_ai.usage.input_tokens", inputTokens);
 	safeSetAttribute$2(span, "gen_ai.usage.output_tokens", outputTokens);
 	if (inputTokens !== void 0 && outputTokens !== void 0) safeSetAttribute$2(span, "llm.usage.total_tokens", inputTokens + outputTokens);
@@ -5982,9 +6001,9 @@ const toGenAiParams = (model, request) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/google-aiplatform/index.ts
-const logger$17 = initializeLogger();
-const PATCH_DATA_SYMBOL$1 = Symbol("lmnr.google-aiplatform.patchData");
-const hasOwnPatchData$1 = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$1) !== void 0;
+const logger$19 = initializeLogger();
+const PATCH_DATA_SYMBOL$2 = Symbol("lmnr.google-aiplatform.patchData");
+const hasOwnPatchData$2 = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$2) !== void 0;
 const GENERATIVE_MODEL_CLASSES = ["GenerativeModel", "GenerativeModelPreview"];
 const markSpanError$1 = (span, error) => {
 	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
@@ -5997,7 +6016,7 @@ const safely$1 = (fn) => {
 	try {
 		fn();
 	} catch (error) {
-		logger$17.debug(`Failed to set google-aiplatform span attributes: ${String(error)}`);
+		logger$19.debug(`Failed to set google-aiplatform span attributes: ${String(error)}`);
 	}
 };
 /**
@@ -6087,13 +6106,13 @@ var GoogleAIPlatformInstrumentation = class extends InstrumentationBase {
 	*/
 	patchMethod(proto, method, makeWrapper) {
 		if (!proto || typeof proto[method] !== "function") return;
-		if (!hasOwnPatchData$1(proto)) Object.defineProperty(proto, PATCH_DATA_SYMBOL$1, {
+		if (!hasOwnPatchData$2(proto)) Object.defineProperty(proto, PATCH_DATA_SYMBOL$2, {
 			value: {},
 			writable: true,
 			configurable: true,
 			enumerable: false
 		});
-		const patches = proto[PATCH_DATA_SYMBOL$1];
+		const patches = proto[PATCH_DATA_SYMBOL$2];
 		const existing = patches[method];
 		if (existing) {
 			existing.traceContent = this.traceContent;
@@ -6107,10 +6126,10 @@ var GoogleAIPlatformInstrumentation = class extends InstrumentationBase {
 		proto[method] = makeWrapper(patchData.original, patchData);
 	}
 	unpatchMethods(proto) {
-		if (!proto || !hasOwnPatchData$1(proto)) return;
-		const patches = proto[PATCH_DATA_SYMBOL$1];
+		if (!proto || !hasOwnPatchData$2(proto)) return;
+		const patches = proto[PATCH_DATA_SYMBOL$2];
 		for (const [method, patchData] of Object.entries(patches)) proto[method] = patchData.original;
-		delete proto[PATCH_DATA_SYMBOL$1];
+		delete proto[PATCH_DATA_SYMBOL$2];
 	}
 	wrapGenerateContent(original, patchData) {
 		return function(request, ...rest) {
@@ -6120,7 +6139,7 @@ var GoogleAIPlatformInstrumentation = class extends InstrumentationBase {
 				spanType: "LLM"
 			});
 			const params = toGenAiParams(this, request);
-			safely$1(() => setRequestAttributes$5(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
+			safely$1(() => setRequestAttributes$6(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
 			return Laminar.withSpan(span, async () => {
 				try {
 					const result = await original.call(this, request, ...rest);
@@ -6141,7 +6160,7 @@ var GoogleAIPlatformInstrumentation = class extends InstrumentationBase {
 				spanType: "LLM"
 			});
 			const params = toGenAiParams(this, request);
-			safely$1(() => setRequestAttributes$5(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
+			safely$1(() => setRequestAttributes$6(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
 			let result;
 			try {
 				result = await Laminar.withSpan(span, () => original.call(this, request, ...rest));
@@ -6205,7 +6224,7 @@ var GoogleAIPlatformInstrumentation = class extends InstrumentationBase {
 	}
 };
 const setGenerateContentResponseAttributes = (span, response, requestModel, traceContent) => {
-	setResponseAttributes$5(span, response, traceContent);
+	setResponseAttributes$6(span, response, traceContent);
 	if (!response?.modelVersion) safeSetAttribute$2(span, "gen_ai.response.model", requestModel);
 };
 //#endregion
@@ -6305,11 +6324,11 @@ var GoogleGenAiInstrumentation = class extends InstrumentationBase {
 				name: "gemini.generate_content",
 				spanType: "LLM"
 			});
-			setRequestAttributes$5(span, params, classPatchData.traceContent);
+			setRequestAttributes$6(span, params, classPatchData.traceContent);
 			return Laminar.withSpan(span, async () => {
 				try {
 					const response = await originalGenerateContent(params);
-					setResponseAttributes$5(span, response, classPatchData.traceContent);
+					setResponseAttributes$6(span, response, classPatchData.traceContent);
 					return response;
 				} catch (error) {
 					span.setAttribute("error.type", error.constructor?.name ?? "Error");
@@ -6324,7 +6343,7 @@ var GoogleGenAiInstrumentation = class extends InstrumentationBase {
 				name: "gemini.generate_content_stream",
 				spanType: "LLM"
 			});
-			setRequestAttributes$5(span, params, classPatchData.traceContent);
+			setRequestAttributes$6(span, params, classPatchData.traceContent);
 			try {
 				return wrapStreamingResponse(span, await originalGenerateContentStream(params), classPatchData.traceContent);
 			} catch (error) {
@@ -6482,6 +6501,1053 @@ var KernelInstrumentation = class extends InstrumentationBase {
 		this._unwrap(moduleExports.Kernel.prototype, "app");
 	}
 };
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/langchain/span-utils.ts
+const INPUT_MESSAGES$1 = "gen_ai.input.messages";
+const OUTPUT_MESSAGES$1 = "gen_ai.output.messages";
+const ROLE_BY_MESSAGE_TYPE = {
+	human: "user",
+	system: "system",
+	ai: "assistant",
+	tool: "tool",
+	function: "tool"
+};
+const FINISH_REASON_MAP = {
+	stop: "stop",
+	length: "length",
+	tool_calls: "tool_call",
+	function_call: "tool_call",
+	content_filter: "content_filter",
+	end_turn: "stop",
+	stop_sequence: "stop",
+	tool_use: "tool_call",
+	max_tokens: "length"
+};
+const MODEL_KEYS = [
+	"model",
+	"model_name",
+	"model_id",
+	"modelName"
+];
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const asRecord = (value) => isRecord(value) ? value : {};
+const isInt = (value) => typeof value === "number" && Number.isInteger(value);
+/**
+* `JSON.stringify` that never throws: cycles become `"[Circular]"` and bigints
+* strings.
+*/
+const toJson$1 = (value) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_key, item) => {
+			if (typeof item === "bigint") return item.toString();
+			if (item !== null && typeof item === "object") {
+				if (seen.has(item)) return "[Circular]";
+				seen.add(item);
+			}
+			return item;
+		}) ?? "null";
+	} catch {
+		return String(value);
+	}
+};
+const maybeJson = (value) => {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+};
+const setIfPresent = (span, key, value) => {
+	if (value === void 0 || value === null) return;
+	if (typeof value === "string" && value.length === 0) return;
+	span.setAttribute(key, value);
+};
+const messageType = (message) => {
+	const type = message?.type ?? message?._getType?.() ?? message?.getType?.();
+	return typeof type === "string" ? type : "";
+};
+const messageRole = (type) => ROLE_BY_MESSAGE_TYPE[type] ?? (type || "unknown");
+/**
+* Convert LangChain message content (string or list of blocks) into GenAI
+* parts.
+*/
+const contentToParts = (content) => {
+	if (typeof content === "string") return content ? [{
+		type: "text",
+		content
+	}] : [];
+	if (!Array.isArray(content)) return content ? [{
+		type: "text",
+		content: String(content)
+	}] : [];
+	const parts = [];
+	for (const block of content) {
+		if (typeof block === "string") {
+			if (block) parts.push({
+				type: "text",
+				content: block
+			});
+			continue;
+		}
+		if (!isRecord(block)) {
+			parts.push({
+				type: "text",
+				content: String(block)
+			});
+			continue;
+		}
+		if (block.type === "text") {
+			if (block.text) parts.push({
+				type: "text",
+				content: block.text
+			});
+		} else if (block.type === "image_url") {
+			const url = isRecord(block.image_url) ? block.image_url.url : block.image_url;
+			if (url) parts.push({
+				type: "uri",
+				modality: "image",
+				uri: url
+			});
+		} else if (block.type === "image" && block.url) parts.push({
+			type: "uri",
+			modality: "image",
+			uri: block.url
+		});
+		else if (block.type === "image") parts.push({
+			type: "blob",
+			modality: "image",
+			mime_type: block.mime_type || block.mimeType || block.media_type || "",
+			content: block.data || block.base64 || ""
+		});
+		else parts.push(block);
+	}
+	return parts;
+};
+const toolCallsToParts = (toolCalls) => {
+	if (!Array.isArray(toolCalls)) return [];
+	const parts = [];
+	for (const toolCall of toolCalls) {
+		if (!isRecord(toolCall)) continue;
+		const fn = asRecord(toolCall.function);
+		const part = {
+			type: "tool_call",
+			id: toolCall.id || "",
+			name: toolCall.name || fn.name || ""
+		};
+		const args = toolCall.args ?? fn.arguments;
+		if (args !== void 0 && args !== null) part.arguments = maybeJson(args);
+		parts.push(part);
+	}
+	return parts;
+};
+const messageToolCalls = (message) => {
+	if (Array.isArray(message?.tool_calls) && message.tool_calls.length > 0) return message.tool_calls;
+	return message?.additional_kwargs?.tool_calls;
+};
+const messageToDict = (message) => {
+	const role = messageRole(messageType(message));
+	const toolCallId = message?.tool_call_id;
+	if (role === "tool" && toolCallId) return {
+		role,
+		parts: [{
+			type: "tool_call_response",
+			id: toolCallId,
+			response: message.content
+		}]
+	};
+	const parts = [...contentToParts(message?.content), ...toolCallsToParts(messageToolCalls(message))];
+	const functionCall = message?.additional_kwargs?.function_call;
+	if (isRecord(functionCall)) parts.push({
+		type: "tool_call",
+		id: "",
+		name: functionCall.name || "",
+		arguments: maybeJson(functionCall.arguments)
+	});
+	return {
+		role,
+		parts
+	};
+};
+const firstModel = (...sources) => {
+	for (const source of sources) for (const key of MODEL_KEYS) {
+		const model = source[key];
+		if (typeof model === "string" && model) return model;
+	}
+};
+/**
+* Record the request model and sampling params. Returns the request model.
+*/
+const setRequestAttributes$3 = (span, serialized, metadata, extraParams, traceContent) => {
+	const invocationParams = asRecord(extraParams?.invocation_params);
+	const nested = asRecord(invocationParams.params);
+	const params = Object.keys(nested).length > 0 ? nested : invocationParams;
+	const serializedKwargs = asRecord(serialized?.kwargs);
+	let model = firstModel(params, invocationParams, serializedKwargs);
+	if (model === void 0) {
+		const lsModelName = metadata?.ls_model_name;
+		model = typeof lsModelName === "string" && lsModelName ? lsModelName : void 0;
+	}
+	setIfPresent(span, "gen_ai.request.model", model);
+	const param = (...keys) => {
+		for (const source of [params, serializedKwargs]) for (const key of keys) if (source[key] !== void 0 && source[key] !== null) return source[key];
+	};
+	const maxTokens = param("max_tokens", "max_completion_tokens", "max_new_tokens", "maxTokens");
+	const temperature = param("temperature");
+	const topP = param("top_p", "topP");
+	if (isInt(maxTokens)) span.setAttribute("gen_ai.request.max_tokens", maxTokens);
+	if (typeof temperature === "number") span.setAttribute("gen_ai.request.temperature", temperature);
+	if (typeof topP === "number") span.setAttribute("gen_ai.request.top_p", topP);
+	const tools = params.tools || params.functions;
+	if (traceContent && Array.isArray(tools) && tools.length > 0) {
+		const definitions = tools.map((tool) => {
+			const record = asRecord(tool);
+			const fn = isRecord(record.function) ? record.function : record;
+			const definition = { name: fn.name };
+			if (fn.description) definition.description = fn.description;
+			const parameters = fn.parameters || record.input_schema;
+			if (parameters) definition.parameters = parameters;
+			return definition;
+		});
+		span.setAttribute("gen_ai.tool.definitions", toJson$1(definitions));
+	}
+	return model;
+};
+const setChatRequest$1 = (span, messages, traceContent) => {
+	if (!traceContent) return;
+	const inputMessages = (messages ?? []).flatMap((batch) => (batch ?? []).map(messageToDict));
+	if (inputMessages.length > 0) span.setAttribute(INPUT_MESSAGES$1, toJson$1(inputMessages));
+};
+const setCompletionRequest$1 = (span, prompts, traceContent) => {
+	if (!traceContent) return;
+	const inputMessages = (prompts ?? []).map((prompt) => ({
+		role: "user",
+		parts: [{
+			type: "text",
+			content: prompt
+		}]
+	}));
+	if (inputMessages.length > 0) span.setAttribute(INPUT_MESSAGES$1, toJson$1(inputMessages));
+};
+const allGenerations = (response) => Array.isArray(response?.generations) ? response.generations.flatMap((batch) => Array.isArray(batch) ? batch : []) : [];
+const setUsage = (span, response) => {
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let cacheReadTokens;
+	let cacheCreationTokens;
+	let found = false;
+	for (const generation of allGenerations(response)) {
+		const usage = asRecord(generation?.message?.usage_metadata);
+		if (Object.keys(usage).length === 0) continue;
+		found = true;
+		inputTokens += isInt(usage.input_tokens) ? usage.input_tokens : 0;
+		outputTokens += isInt(usage.output_tokens) ? usage.output_tokens : 0;
+		const details = asRecord(usage.input_token_details);
+		if (isInt(details.cache_read)) cacheReadTokens = (cacheReadTokens ?? 0) + details.cache_read;
+		if (isInt(details.cache_creation)) cacheCreationTokens = (cacheCreationTokens ?? 0) + details.cache_creation;
+	}
+	if (!found) {
+		const llmOutput = asRecord(response?.llmOutput);
+		const tokenUsage = asRecord(llmOutput.tokenUsage ?? llmOutput.token_usage ?? llmOutput.usage);
+		if (Object.keys(tokenUsage).length === 0) return;
+		const pick = (...keys) => {
+			for (const key of keys) if (isInt(tokenUsage[key]) && tokenUsage[key] !== 0) return tokenUsage[key];
+			return 0;
+		};
+		inputTokens = pick("promptTokens", "prompt_tokens", "input_tokens", "input_token_count");
+		outputTokens = pick("completionTokens", "completion_tokens", "output_tokens", "generated_token_count");
+	}
+	span.setAttribute("gen_ai.usage.input_tokens", inputTokens);
+	span.setAttribute("gen_ai.usage.output_tokens", outputTokens);
+	span.setAttribute("llm.usage.total_tokens", inputTokens + outputTokens);
+	setIfPresent(span, "gen_ai.usage.cache_read_input_tokens", cacheReadTokens);
+	setIfPresent(span, "gen_ai.usage.cache_creation_input_tokens", cacheCreationTokens);
+};
+const responseModelAndId = (response) => {
+	const llmOutput = asRecord(response?.llmOutput);
+	let model = firstModel(llmOutput);
+	let id = llmOutput.id;
+	for (const generation of allGenerations(response)) {
+		const message = generation?.message;
+		if (model === void 0) model = firstModel(asRecord(message?.response_metadata));
+		if (id === void 0 || id === null) id = message?.id;
+	}
+	return {
+		model,
+		id: typeof id === "string" && id ? id : void 0
+	};
+};
+const finishReasonOf = (generation) => {
+	const info = asRecord(generation?.generationInfo);
+	const metadata = asRecord(generation?.message?.response_metadata);
+	const raw = info.finish_reason || info.stop_reason || metadata.finish_reason || metadata.stop_reason;
+	return typeof raw === "string" ? FINISH_REASON_MAP[raw] ?? raw : void 0;
+};
+const setResponseAttributes$3 = (span, response, requestModel, traceContent) => {
+	const { model, id } = responseModelAndId(response);
+	setIfPresent(span, "gen_ai.response.model", model ?? requestModel);
+	if (requestModel === void 0) setIfPresent(span, "gen_ai.request.model", model);
+	setIfPresent(span, "gen_ai.response.id", id);
+	setUsage(span, response);
+	const outputMessages = [];
+	const finishReasons = [];
+	for (const generation of allGenerations(response)) {
+		const finishReason = finishReasonOf(generation);
+		if (finishReason && !finishReasons.includes(finishReason)) finishReasons.push(finishReason);
+		if (!traceContent) continue;
+		const message = generation?.message;
+		const outputMessage = message && typeof message === "object" ? messageToDict(message) : {
+			role: "assistant",
+			parts: contentToParts(generation?.text)
+		};
+		outputMessage.finish_reason = finishReason ?? "";
+		outputMessages.push(outputMessage);
+	}
+	if (finishReasons.length > 0) span.setAttribute("gen_ai.response.finish_reasons", finishReasons);
+	if (outputMessages.length > 0) span.setAttribute(OUTPUT_MESSAGES$1, toJson$1(outputMessages));
+};
+/**
+* Return plain-data metadata as is, or undefined for anything else.
+*
+* Class instances are dropped rather than stringified: a model, client or
+* config object routinely carries credentials the caller never meant to
+* export.
+*/
+const metadataValue = (value) => {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? void 0 : value.toISOString();
+	if (Array.isArray(value)) return value.map(metadataValue).filter((item) => item !== void 0);
+	if (isRecord(value)) {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) return void 0;
+		const kept = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, metadataValue(item)]).filter(([, item]) => item !== void 0));
+		return Object.keys(kept).length > 0 ? kept : void 0;
+	}
+};
+const sanitizeMetadata = (metadata) => {
+	if (!isRecord(metadata)) return {};
+	return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, metadataValue(value)]).filter(([, value]) => value !== void 0));
+};
+const retrieverOutput = (documents) => {
+	if (!Array.isArray(documents)) return [];
+	return documents.map((document) => {
+		const pageContent = document?.pageContent ?? document?.page_content;
+		if (pageContent === void 0 || pageContent === null) return document;
+		return {
+			page_content: pageContent,
+			metadata: document?.metadata ?? {}
+		};
+	});
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/langchain/vendor-detection.ts
+const DEFAULT_VENDOR = "langchain";
+/**
+* Lower-cased class-name substrings → `gen_ai.system` vendor, in priority
+* order (`AzureChatOpenAI` must match azure before openai).
+*/
+const VENDOR_RULES = [
+	[["azure"], "azure.ai.openai"],
+	[["openai"], "openai"],
+	[["bedrock", "aws"], "aws.bedrock"],
+	[["anthropic"], "anthropic"],
+	[["vertex"], "gcp.vertex_ai"],
+	[["google", "gemini"], "gcp.gen_ai"],
+	[["cohere"], "cohere"],
+	[["huggingface"], "hugging_face"],
+	[["ollama"], "ollama"],
+	[["together"], "together_ai"],
+	[["replicate"], "replicate"],
+	[["fireworks"], "fireworks"],
+	[["groq"], "groq"],
+	[["mistral"], "mistral_ai"]
+];
+/**
+* Map a LangChain model class name (e.g. `ChatOpenAI`) onto the
+* `gen_ai.system` vendor string, or `"langchain"` when unknown.
+*/
+const detectVendorFromClass = (className) => {
+	if (!className) return DEFAULT_VENDOR;
+	const lower = className.toLowerCase();
+	for (const [patterns, vendor] of VENDOR_RULES) if (patterns.some((pattern) => lower.includes(pattern))) return vendor;
+	return DEFAULT_VENDOR;
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/langchain/callback-handler.ts
+const logger$18 = initializeLogger();
+const HANDLER_NAME = "laminar_callback_handler";
+/**
+* Callback handlers must never break the user's chain.
+*/
+const dontThrow = (fn) => {
+	try {
+		fn();
+	} catch (error) {
+		logger$18.debug(`Failed to record LangChain run: ${String(error)}`);
+	}
+};
+const className = (serialized) => {
+	const id = serialized?.id;
+	if (Array.isArray(id) && id.length > 0) return String(id[id.length - 1]);
+	return typeof id === "string" ? id : "";
+};
+const runNameOf = (serialized, runName) => {
+	for (const name of [
+		runName,
+		serialized?.kwargs?.name,
+		serialized?.name
+	]) if (typeof name === "string" && name) return name;
+	return className(serialized) || "unknown";
+};
+/**
+* LangGraph's `configurable.thread_id`, the conversation id.
+*/
+const threadIdOf = (metadata, extra) => {
+	const threadId = metadata?.thread_id ?? extra?.config?.configurable?.thread_id;
+	return threadId === void 0 || threadId === null ? void 0 : String(threadId);
+};
+/**
+* Drop what only applies to the context a callback fired in (an open LLM
+* call's marker and its suppression) before parenting a new run from it.
+*/
+const cleanContext = (ctx) => unsuppressTracing(ctx).deleteValue(LLM_CALL_KEY);
+/**
+* Records LangChain runs as Laminar spans.
+*
+* A single instance is injected into every LangChain `CallbackManager`, so all
+* state is keyed by LangChain's `runId`. Callbacks only start and end spans:
+* JavaScript callbacks cannot change the context of the code they observe, so
+* the instrumentation wrappers read `contextFor(runId)` to run user code (a
+* lambda, a tool, a graph node) and provider SDK calls under the right span.
+*
+* Duck-types LangChain's `BaseCallbackHandler` (`name`, `awaitHandlers`,
+* `copy`), as `@langchain/core` is not a runtime dependency of this package.
+*/
+var LaminarCallbackHandler = class {
+	constructor(traceContent) {
+		this.name = HANDLER_NAME;
+		this.awaitHandlers = true;
+		this.raiseError = false;
+		this.ignoreLLM = false;
+		this.ignoreChain = false;
+		this.ignoreAgent = false;
+		this.ignoreRetriever = false;
+		this.ignoreCustomEvent = true;
+		this.lc_serializable = false;
+		this.takeTopology = () => void 0;
+		this.runs = /* @__PURE__ */ new Map();
+		this.handedOff = /* @__PURE__ */ new Map();
+		this.traceContent = traceContent;
+	}
+	copy() {
+		return this;
+	}
+	/**
+	* Context of an open run (or of a handed-off LLM run's parent), for code
+	* that runs under it.
+	*/
+	contextFor(runId) {
+		if (!runId) return void 0;
+		return this.runs.get(runId)?.context ?? this.handedOff.get(runId)?.context;
+	}
+	handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, _runType, runName, extra) {
+		dontThrow(() => {
+			const name = runNameOf(chain, runName);
+			const isRoot = !parentRunId || !this.runs.has(parentRunId) && !this.handedOff.has(parentRunId);
+			const attributes = {};
+			let spanName;
+			if (isRoot) {
+				spanName = `${name}.workflow`;
+				attributes["gen_ai.operation.name"] = "invoke_agent";
+				attributes["gen_ai.agent.name"] = name;
+				attributes["gen_ai.agent.id"] = String(runId);
+			} else {
+				spanName = `execute_task ${name}`;
+				attributes["gen_ai.operation.name"] = "execute_task";
+			}
+			const threadId = threadIdOf(metadata, extra);
+			if (threadId) attributes["gen_ai.conversation.id"] = threadId;
+			const topology = this.takeTopology();
+			if (topology && isRoot) for (const [key, value] of Object.entries(topology)) attributes[`lmnr.association.properties.${key}`] = value;
+			const span = this.startRun(runId, parentRunId, spanName, {
+				attributes,
+				tags,
+				metadata
+			});
+			if (span && this.traceContent) span.setInput(toJson$1(inputs));
+		});
+	}
+	handleChainEnd(outputs, runId) {
+		dontThrow(() => {
+			try {
+				this.setOutput(runId, outputs);
+			} finally {
+				this.endRun(runId);
+			}
+		});
+	}
+	handleChainError(error, runId) {
+		dontThrow(() => this.handleError(error, runId));
+	}
+	handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, runName) {
+		dontThrow(() => this.startLlm(llm, messages, "chat", runId, parentRunId, {
+			extraParams,
+			tags,
+			metadata,
+			runName
+		}));
+	}
+	handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
+		dontThrow(() => this.startLlm(llm, prompts, "text_completion", runId, parentRunId, {
+			extraParams,
+			tags,
+			metadata,
+			runName
+		}));
+	}
+	handleLLMEnd(output, runId) {
+		dontThrow(() => {
+			try {
+				const run = this.runs.get(runId);
+				if (run) setResponseAttributes$3(run.span, output, run.requestModel, this.traceContent);
+				else this.recordUnrecordedHandoff(runId, (span, requestModel) => setResponseAttributes$3(span, output, requestModel, this.traceContent));
+			} finally {
+				this.endRun(runId);
+			}
+		});
+	}
+	handleLLMError(error, runId) {
+		dontThrow(() => this.handleError(error, runId));
+	}
+	handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName, toolCallId) {
+		dontThrow(() => {
+			const name = runNameOf(tool, runName);
+			const attributes = {
+				"gen_ai.operation.name": "execute_tool",
+				"gen_ai.tool.name": name,
+				"gen_ai.tool.type": "function"
+			};
+			const description = tool?.description ?? tool?.kwargs?.description;
+			if (typeof description === "string" && description) attributes["gen_ai.tool.description"] = description;
+			if (typeof toolCallId === "string" && toolCallId) attributes["gen_ai.tool.call.id"] = toolCallId;
+			const span = this.startRun(runId, parentRunId, `execute_tool ${name}`, {
+				spanType: "TOOL",
+				attributes,
+				tags,
+				metadata
+			});
+			if (span && this.traceContent) span.setInput(toJson$1(parseJsonObject(input)));
+		});
+	}
+	handleToolEnd(output, runId) {
+		dontThrow(() => {
+			try {
+				this.setOutput(runId, output);
+			} finally {
+				this.endRun(runId);
+			}
+		});
+	}
+	handleToolError(error, runId) {
+		dontThrow(() => this.handleError(error, runId));
+	}
+	handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, runName) {
+		dontThrow(() => {
+			const name = runNameOf(retriever, runName);
+			const span = this.startRun(runId, parentRunId, `vector_db_retrieve ${name}`, {
+				attributes: { "gen_ai.operation.name": "vector_db_retrieve" },
+				tags,
+				metadata
+			});
+			if (span && this.traceContent) span.setInput(toJson$1(query));
+		});
+	}
+	handleRetrieverEnd(documents, runId) {
+		dontThrow(() => {
+			try {
+				this.setOutput(runId, retrieverOutput(documents));
+			} finally {
+				this.endRun(runId);
+			}
+		});
+	}
+	handleRetrieverError(error, runId) {
+		dontThrow(() => this.handleError(error, runId));
+	}
+	parentContext(parentRunId) {
+		return cleanContext(this.contextFor(parentRunId) ?? LaminarContextManager.getContext());
+	}
+	startRun(runId, parentRunId, name, { spanType = "DEFAULT", attributes, tags, metadata, startTime }) {
+		const active = context.active();
+		if (isTracingSuppressed(active) && active.getValue(LLM_CALL_KEY)?.mode !== "own") return;
+		const parentContext = this.parentContext(parentRunId);
+		const span = this.startSpan(name, spanType, parentContext, {
+			attributes,
+			tags,
+			metadata,
+			startTime
+		});
+		const run = {
+			span,
+			context: trace.setSpan(LaminarContextManager.setAssociationProperties(span, parentContext), span),
+			children: []
+		};
+		if (parentRunId) this.runs.get(parentRunId)?.children.push(runId);
+		const stale = this.runs.get(runId);
+		if (stale) {
+			this.runs.delete(runId);
+			stale.span.end();
+		}
+		this.runs.set(runId, run);
+		return span;
+	}
+	startSpan(name, spanType, parentContext, { attributes, tags, metadata, startTime }) {
+		const span = Laminar.startSpan({
+			name,
+			spanType,
+			context: parentContext,
+			startTime
+		});
+		if (attributes) span.setAttributes(attributes);
+		if (tags && tags.length > 0) span.setAttribute("langchain.tags", tags);
+		const sanitized = sanitizeMetadata(metadata);
+		if (Object.keys(sanitized).length > 0) span.setAttribute("langchain.metadata", toJson$1(sanitized));
+		return span;
+	}
+	startLlm(llm, input, operation, runId, parentRunId, { extraParams, tags, metadata, runName }) {
+		const name = runNameOf(llm, runName);
+		const call = context.active().getValue(LLM_CALL_KEY);
+		if (call?.mode === "handoff") {
+			this.handedOff.set(runId, {
+				context: this.parentContext(parentRunId),
+				call,
+				name,
+				operation,
+				serialized: llm,
+				input,
+				extraParams,
+				tags,
+				metadata,
+				startTime: hrTime()
+			});
+			if (parentRunId) this.runs.get(parentRunId)?.children.push(runId);
+			return;
+		}
+		const span = this.startRun(runId, parentRunId, llmSpanName(name, operation), {
+			spanType: "LLM",
+			attributes: llmAttributes(llm, operation),
+			tags,
+			metadata
+		});
+		if (!span) return;
+		const run = this.runs.get(runId);
+		run.requestModel = this.setLlmRequest(span, {
+			serialized: llm,
+			input,
+			operation,
+			extraParams,
+			metadata
+		});
+	}
+	setLlmRequest(span, { serialized, input, operation, extraParams, metadata }) {
+		const requestModel = setRequestAttributes$3(span, serialized, metadata, extraParams, this.traceContent);
+		if (operation === "chat") setChatRequest$1(span, input, this.traceContent);
+		else setCompletionRequest$1(span, input, this.traceContent);
+		return requestModel;
+	}
+	/**
+	* A handed-off LLM run whose provider instrumentation did not record the
+	* call (it is disabled, or the integration bundles its own copy of the
+	* provider SDK) gets its LangChain span after all, spanning the run.
+	*/
+	recordUnrecordedHandoff(runId, finish) {
+		const pending = this.handedOff.get(runId);
+		if (!pending || pending.call.recorded) return;
+		const span = this.startSpan(llmSpanName(pending.name, pending.operation), "LLM", pending.context, {
+			attributes: llmAttributes(pending.serialized, pending.operation),
+			tags: pending.tags,
+			metadata: pending.metadata,
+			startTime: pending.startTime
+		});
+		try {
+			finish(span, this.setLlmRequest(span, pending));
+		} finally {
+			span.end();
+		}
+	}
+	setOutput(runId, output) {
+		const run = this.runs.get(runId);
+		if (run && this.traceContent) run.span.setOutput(toJson$1(output));
+	}
+	handleError(error, runId) {
+		const run = this.runs.get(runId);
+		if (!run) {
+			try {
+				this.recordUnrecordedHandoff(runId, (span) => markError(span, error));
+			} finally {
+				this.handedOff.delete(runId);
+			}
+			return;
+		}
+		try {
+			markError(run.span, error);
+		} finally {
+			this.endRun(runId);
+		}
+	}
+	endRun(runId) {
+		this.handedOff.delete(runId);
+		const run = this.runs.get(runId);
+		if (!run) return;
+		this.runs.delete(runId);
+		for (const childId of run.children) this.endRun(childId);
+		run.span.end();
+	}
+};
+const llmSpanName = (name, operation) => `${name}.${operation === "chat" ? "chat" : "completion"}`;
+const llmAttributes = (serialized, operation) => {
+	const vendor = detectVendorFromClass(className(serialized));
+	return {
+		"gen_ai.operation.name": operation,
+		"gen_ai.system": vendor,
+		"gen_ai.provider.name": vendor
+	};
+};
+const markError = (span, error) => {
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.recordException(error);
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: error?.message ?? String(error)
+	});
+};
+const parseJsonObject = (input) => {
+	if (typeof input !== "string") return input;
+	try {
+		const parsed = JSON.parse(input);
+		return parsed !== null && typeof parsed === "object" ? parsed : input;
+	} catch {
+		return input;
+	}
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/langchain/index.ts
+const logger$17 = initializeLogger();
+const PATCH_DATA_SYMBOL$1 = Symbol("lmnr.langchain.patchData");
+const hasOwnPatchData$1 = (target) => Object.getOwnPropertyDescriptor(target, PATCH_DATA_SYMBOL$1) !== void 0;
+/**
+* Model classes whose provider SDK Laminar instruments itself (`_llmType()`).
+* Their LLM calls are handed off: the provider span is the LLM span, with the
+* provider-specific attributes, and LangChain opens none of its own.
+*/
+const HANDOFF_LLM_TYPES = /* @__PURE__ */ new Set([
+	"openai",
+	"azure_openai",
+	"anthropic"
+]);
+/**
+* The single handler injected into every LangChain `CallbackManager`. All its
+* state is keyed by LangChain run id, so it is shared by every instrumentation
+* instance (auto and manual) and patched module copy.
+*/
+const handler = new LaminarCallbackHandler(true);
+const topologyStorage = new AsyncLocalStorage$1();
+handler.takeTopology = () => {
+	const holder = topologyStorage.getStore();
+	const topology = holder?.topology;
+	if (holder) holder.topology = void 0;
+	return topology;
+};
+/**
+* Run `fn` with `ctx` current in both the OTel context (read by OTel-aware
+* code) and Laminar's context stack (read by `Laminar.startSpan` and
+* Laminar's own provider instrumentations).
+*/
+const runUnder = (ctx, fn) => context.with(ctx, () => LaminarContextManager.runWithIsolatedContext([...LaminarContextManager.getContextStack(), ctx], fn));
+/**
+* Wrap an async iterator so each step runs through `run`.
+* `AsyncLocalStorage.run` and `context.with` only cover the synchronous part
+* of the call, so every `next` / `return` / `throw` needs its own.
+*/
+const wrapIterator = (iterator, run) => ({
+	next: (...args) => run(() => iterator.next(...args)),
+	return: (value) => run(() => typeof iterator.return === "function" ? iterator.return(value) : Promise.resolve({
+		done: true,
+		value
+	})),
+	throw: (error) => run(() => typeof iterator.throw === "function" ? iterator.throw(error) : Promise.reject(error)),
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+});
+/**
+* Replace the own method `target[method]` with `wrap(original)`. Already
+* patched methods are left alone, so repeated initialization never
+* double-wraps.
+*/
+const patchMethod = (target, method, wrap) => {
+	if (!target || !Object.getOwnPropertyDescriptor(target, method) || typeof target[method] !== "function") return;
+	if (!hasOwnPatchData$1(target)) Object.defineProperty(target, PATCH_DATA_SYMBOL$1, {
+		value: {},
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+	const patchData = target[PATCH_DATA_SYMBOL$1];
+	if (patchData[method]) return;
+	const original = target[method];
+	patchData[method] = original;
+	target[method] = wrap(original);
+};
+const unpatchMethod = (target, method) => {
+	if (!target || !hasOwnPatchData$1(target)) return;
+	const patchData = target[PATCH_DATA_SYMBOL$1];
+	const original = patchData[method];
+	if (!original) return;
+	target[method] = original;
+	delete patchData[method];
+	if (Object.keys(patchData).length === 0) delete target[PATCH_DATA_SYMBOL$1];
+};
+/**
+* Inject the handler into every `CallbackManager` LangChain configures.
+* `configure` delegates to the static `_configureSync`, and LangGraph calls
+* `_configureSync` directly, so this one method covers both.
+*/
+const wrapConfigureSync = (original) => function(inheritableHandlers, ...rest) {
+	const manager = original.call(this, inheritableHandlers, ...rest);
+	if (!manager) return original.call(this, [handler], ...rest);
+	try {
+		if (!manager.handlers?.some((h) => h?.name === "laminar_callback_handler") && typeof manager.addHandler === "function") manager.addHandler(handler, true);
+	} catch (error) {
+		logger$17.debug(`Failed to add the Laminar LangChain handler: ${error}`);
+	}
+	return manager;
+};
+/**
+* Run user code that LangChain runs for a run (a lambda, a tool, a graph
+* node) under that run's span. LangChain passes it the run's child config,
+* whose callback manager's parent run id is that run.
+*/
+const wrapRunWithConfig = (original) => function(config, ...rest) {
+	let ctx;
+	try {
+		ctx = handler.contextFor(config?.callbacks?.getParentRunId?.());
+	} catch {
+		ctx = void 0;
+	}
+	if (!ctx) return original.call(this, config, ...rest);
+	return runUnder(ctx, () => original.call(this, config, ...rest));
+};
+/**
+* The context an LLM call runs under, or undefined to run it untouched (it is
+* nested in another LLM call, or tracing is suppressed).
+*
+* The call is handed off to Laminar's provider instrumentation when the model
+* wraps a provider SDK it instruments. Otherwise the handler records the LLM
+* span and provider instrumentations underneath are suppressed, so a call is
+* never recorded twice.
+*/
+const llmCallContext = (model, callbacks, startedRunManagers) => {
+	const active = context.active();
+	if (active.getValue(LLM_CALL_KEY) || isTracingSuppressed(active)) return;
+	let parentRunId;
+	let llmType;
+	try {
+		parentRunId = callbacks?.getParentRunId?.();
+		llmType = model?._llmType?.();
+	} catch {}
+	const base = handler.contextFor(parentRunId) ?? LaminarContextManager.getContext();
+	const mode = llmType && HANDOFF_LLM_TYPES.has(llmType) && !startedRunManagers ? "handoff" : "own";
+	const call = {
+		mode,
+		recorded: false
+	};
+	const ctx = base.setValue(LLM_CALL_KEY, call);
+	return mode === "own" ? suppressTracing(ctx) : ctx;
+};
+const wrapGenerateUncached = (original) => function(input, parsedOptions, handledOptions, startedRunManagers, ...rest) {
+	const call = () => original.call(this, input, parsedOptions, handledOptions, startedRunManagers, ...rest);
+	const ctx = llmCallContext(this, handledOptions?.callbacks, startedRunManagers);
+	return ctx ? runUnder(ctx, call) : call();
+};
+const wrapModelStreamIterator = (original) => function(input, options, ...rest) {
+	const ctx = llmCallContext(this, options?.callbacks);
+	if (!ctx) return original.call(this, input, options, ...rest);
+	const iterator = runUnder(ctx, () => original.call(this, input, options, ...rest));
+	return wrapIterator(iterator, (fn) => runUnder(ctx, fn));
+};
+/**
+* The graph topology, recorded on the graph's root span the way the Python
+* SDK does. Only the synchronous `getGraph` is used: it runs before the
+* graph does, and an async drawing would hold the run back.
+*/
+const topologyCache = /* @__PURE__ */ new WeakMap();
+const graphTopology = (pregel, config) => {
+	const cached = topologyCache.get(pregel);
+	if (cached) return cached;
+	if (typeof pregel?.getGraph !== "function") return void 0;
+	const graph = pregel.getGraph(config);
+	if (!graph || graph instanceof Promise) return void 0;
+	const nodes = Object.values(graph.nodes ?? {}).map((node) => ({
+		id: node.id,
+		name: node.name,
+		metadata: node.metadata ?? null
+	}));
+	const edges = (graph.edges ?? []).map((edge) => ({
+		source: edge.source,
+		target: edge.target,
+		conditional: Boolean(edge.conditional)
+	}));
+	const topology = {
+		"langgraph.nodes": JSON.stringify(nodes),
+		"langgraph.edges": JSON.stringify(edges)
+	};
+	topologyCache.set(pregel, topology);
+	return topology;
+};
+/**
+* Publish the graph topology for the graph's own run, which the handler
+* starts in the iterator's first step. Each iterator gets its own holder, so
+* concurrent graph runs never read each other's topology.
+*/
+const wrapPregelStreamIterator = (original) => function(input, options, ...rest) {
+	let topology;
+	try {
+		topology = graphTopology(this, options);
+	} catch (error) {
+		logger$17.debug(`Failed to read the LangGraph topology: ${error}`);
+	}
+	const iterator = original.call(this, input, options, ...rest);
+	if (!topology) return iterator;
+	const holder = { topology };
+	return wrapIterator(iterator, (fn) => topologyStorage.run(holder, fn));
+};
+/**
+* `Pregel.prototype` from `@langchain/langgraph/pregel`, or the first
+* prototype that owns `_streamIterator` above a compiled graph class.
+*/
+const pregelPrototype = (module) => {
+	if (typeof module?.Pregel === "function") return module.Pregel.prototype;
+	const graphClass = module?.CompiledStateGraph ?? module?.CompiledGraph ?? module;
+	let proto = typeof graphClass === "function" ? graphClass.prototype : null;
+	while (proto && proto !== Object.prototype) {
+		if (Object.getOwnPropertyDescriptor(proto, "_streamIterator")) return proto;
+		proto = Object.getPrototypeOf(proto);
+	}
+};
+const singletonPrototype = (module) => {
+	const singleton = module?.AsyncLocalStorageProviderSingleton;
+	return singleton ? Object.getPrototypeOf(singleton) : void 0;
+};
+const CORE_FILES = {
+	callbackManager: ["@langchain/core/dist/callbacks/manager"],
+	singletons: ["@langchain/core/dist/singletons/async_local_storage/index", "@langchain/core/dist/singletons/index"],
+	chatModels: ["@langchain/core/dist/language_models/chat_models"],
+	llms: ["@langchain/core/dist/language_models/llms"]
+};
+/**
+* Instruments LangChain (`@langchain/core`) and LangGraph
+* (`@langchain/langgraph`) through a callback handler injected into every
+* callback manager, with wrappers that run user code and provider SDK calls
+* under the right span.
+*
+* Calls made through LangChain's OpenAI and Anthropic integrations are left to
+* Laminar's OpenAI and Anthropic instrumentations, which record them as the
+* LLM span. Other model calls are recorded by the handler, with provider
+* instrumentations underneath suppressed.
+*/
+var LangChainInstrumentation = class extends InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/langchain-instrumentation", version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		const coreFiles = (names, patch, unpatch) => names.flatMap((name) => [".cjs", ".js"].map((extension) => new InstrumentationNodeModuleFile(`${name}${extension}`, [">=0.3.0"], (exports) => {
+			patch.call(this, exports);
+			return exports;
+		}, (exports) => {
+			if (exports) unpatch.call(this, exports);
+		})));
+		return [new InstrumentationNodeModuleDefinition("@langchain/core", [">=0.3.0"], void 0, void 0, [
+			...coreFiles(CORE_FILES.callbackManager, this.patchCallbackManager, this.unpatchCallbackManager),
+			...coreFiles(CORE_FILES.singletons, this.patchSingletons, this.unpatchSingletons),
+			...coreFiles(CORE_FILES.chatModels, this.patchChatModels, this.unpatchChatModels),
+			...coreFiles(CORE_FILES.llms, this.patchLlms, this.unpatchLlms)
+		]), new InstrumentationNodeModuleDefinition("@langchain/langgraph", [">=0.2.0"], void 0, void 0, [".cjs", ".js"].map((extension) => new InstrumentationNodeModuleFile(`@langchain/langgraph/dist/pregel/index${extension}`, [">=0.2.0"], (exports) => {
+			this.patchLanggraph(exports);
+			return exports;
+		}, (exports) => {
+			if (exports) this.unpatchLanggraph(exports);
+		})))];
+	}
+	/**
+	* Pass every module you use; a module left out is not traced. The model
+	* modules are what lets OpenAI and Anthropic calls be recorded once, by the
+	* provider instrumentation, instead of twice.
+	*/
+	manuallyInstrument(modules) {
+		const { callbackManagerModule, singletonsModule, chatModelsModule, llmsModule, langgraphModule } = modules ?? {};
+		if (!callbackManagerModule && !singletonsModule && !chatModelsModule && !llmsModule && !langgraphModule) {
+			diag.warn("No modules in langchain manual instrumentation input. Pass at least @langchain/core/callbacks/manager as callbackManagerModule.");
+			return;
+		}
+		diag.debug("Manually instrumenting LangChain");
+		if (callbackManagerModule && !chatModelsModule) diag.warn("LangChain chatModelsModule is missing from manual instrumentation input. Chat model calls may be recorded twice. Pass @langchain/core/language_models/chat_models as chatModelsModule.");
+		if (callbackManagerModule) this.patchCallbackManager(callbackManagerModule);
+		if (singletonsModule) this.patchSingletons(singletonsModule);
+		if (chatModelsModule) this.patchChatModels(chatModelsModule);
+		if (llmsModule) this.patchLlms(llmsModule);
+		if (langgraphModule) {
+			if (!pregelPrototype(langgraphModule)) diag.warn("Could not find Pregel in langchain manual instrumentation input. Pass the @langchain/langgraph module as langgraphModule.");
+			else this.patchLanggraph(langgraphModule);
+		}
+	}
+	patchCallbackManager(moduleExports) {
+		diag.debug("Patching @langchain/core CallbackManager");
+		handler.traceContent = this.traceContent;
+		patchMethod(moduleExports?.CallbackManager, "_configureSync", wrapConfigureSync);
+	}
+	unpatchCallbackManager(moduleExports) {
+		unpatchMethod(moduleExports?.CallbackManager, "_configureSync");
+	}
+	patchSingletons(moduleExports) {
+		diag.debug("Patching @langchain/core AsyncLocalStorageProvider");
+		patchMethod(singletonPrototype(moduleExports), "runWithConfig", wrapRunWithConfig);
+	}
+	unpatchSingletons(moduleExports) {
+		unpatchMethod(singletonPrototype(moduleExports), "runWithConfig");
+	}
+	patchChatModels(moduleExports) {
+		diag.debug("Patching @langchain/core BaseChatModel");
+		this.patchModel(moduleExports?.BaseChatModel?.prototype);
+	}
+	unpatchChatModels(moduleExports) {
+		this.unpatchModel(moduleExports?.BaseChatModel?.prototype);
+	}
+	patchLlms(moduleExports) {
+		diag.debug("Patching @langchain/core BaseLLM");
+		this.patchModel(moduleExports?.BaseLLM?.prototype);
+	}
+	unpatchLlms(moduleExports) {
+		this.unpatchModel(moduleExports?.BaseLLM?.prototype);
+	}
+	patchModel(proto) {
+		patchMethod(proto, "_generateUncached", wrapGenerateUncached);
+		patchMethod(proto, "_streamIterator", wrapModelStreamIterator);
+	}
+	unpatchModel(proto) {
+		unpatchMethod(proto, "_generateUncached");
+		unpatchMethod(proto, "_streamIterator");
+	}
+	patchLanggraph(moduleExports) {
+		diag.debug("Patching @langchain/langgraph Pregel");
+		patchMethod(pregelPrototype(moduleExports), "_streamIterator", wrapPregelStreamIterator);
+	}
+	unpatchLanggraph(moduleExports) {
+		unpatchMethod(pregelPrototype(moduleExports), "_streamIterator");
+	}
+};
 const DISABLE_OPENAI_RESPONSES_INSTRUMENTATION_CONTEXT_KEY = createContextKey("LMNR_DISABLE_OPENAI_RESPONSES_INSTRUMENTATION");
 const systemInstructionsStorage = new AsyncLocalStorage();
 const getCurrentSystemInstructions = () => systemInstructionsStorage.getStore();
@@ -8578,6 +9644,107 @@ var LaminarSpanExporter = class {
 		return this.exporter.forceFlush?.();
 	}
 };
+const RELEASE_ENV_VARS = [
+	"GITHUB_SHA",
+	"SENTRY_RELEASE",
+	"VERCEL_GIT_COMMIT_SHA",
+	"RENDER_GIT_COMMIT",
+	"RAILWAY_GIT_COMMIT_SHA",
+	"HEROKU_BUILD_COMMIT",
+	"SOURCE_VERSION",
+	"CODEBUILD_RESOLVED_SOURCE_VERSION",
+	"CIRCLE_SHA1",
+	"K_REVISION",
+	"GAE_DEPLOYMENT_ID",
+	"FLY_IMAGE_REF"
+];
+/**
+* The first available of: `explicit`, `LMNR_RELEASE`, a known platform
+* variable, a numeric AWS Lambda version, the checked-out git commit.
+*/
+const detectRelease = (explicit) => {
+	const candidates = [
+		() => explicit,
+		() => env("LMNR_RELEASE"),
+		...RELEASE_ENV_VARS.map((name) => () => env(name)),
+		lambdaVersion,
+		gitHead
+	];
+	for (const candidate of candidates) {
+		const release = clean(candidate());
+		if (release) return release;
+	}
+};
+const env = (name) => {
+	try {
+		return process.env[name];
+	} catch {
+		return;
+	}
+};
+const clean = (value) => {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	const chars = Array.from(trimmed);
+	return chars.length > 128 ? chars.slice(0, 128).join("") : trimmed;
+};
+const lambdaVersion = () => {
+	const version = env("AWS_LAMBDA_FUNCTION_VERSION");
+	const fn = env("AWS_LAMBDA_FUNCTION_NAME");
+	if (!version || !/^\d+$/.test(version) || !fn) return;
+	return `${fn}:${version}`;
+};
+const isFile = (path) => {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+};
+const isDirectory = (path) => {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+};
+/** The commit `.git/HEAD` points at, read from disk without running git. */
+const gitHead = () => {
+	try {
+		const gitDir = findGitDir(process.cwd());
+		if (gitDir === void 0) return;
+		const head = readFileSync(join(gitDir, "HEAD"), "utf8").trim();
+		if (!head.startsWith("ref:")) return head;
+		const ref = head.slice(4).trim();
+		const commonFile = join(gitDir, "commondir");
+		const commonDir = isFile(commonFile) ? resolve(gitDir, readFileSync(commonFile, "utf8").trim()) : gitDir;
+		for (const refsDir of /* @__PURE__ */ new Set([gitDir, commonDir])) {
+			const refFile = join(refsDir, ref);
+			if (isFile(refFile)) return readFileSync(refFile, "utf8").trim();
+		}
+		const packedRefs = join(commonDir, "packed-refs");
+		if (isFile(packedRefs)) for (const line of readFileSync(packedRefs, "utf8").split("\n")) {
+			const space = line.indexOf(" ");
+			if (space !== -1 && line.slice(space + 1).trim() === ref) return line.slice(0, space);
+		}
+	} catch {
+		return;
+	}
+};
+const findGitDir = (start) => {
+	let directory = resolve(start);
+	for (;;) {
+		const dotGit = join(directory, ".git");
+		if (isDirectory(dotGit)) return dotGit;
+		if (isFile(dotGit)) {
+			const content = readFileSync(dotGit, "utf8").trim();
+			if (content.startsWith("gitdir:")) return resolve(directory, content.slice(7).trim());
+		}
+		const parent = dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+};
 //#endregion
 //#region src/opentelemetry-lib/tracing/processor.ts
 var LaminarSpanProcessor = class LaminarSpanProcessor {
@@ -8595,11 +9762,15 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 	* @param {boolean} options.forceHttp - Whether to force HTTP and use OpenTelemetry
 	* HTTP/protobuf exporter.
 	* Not recommended with Laminar backends.
+	* @param {string} options.release - The release of the running code, usually
+	* its git commit SHA. Detected from the environment if not provided.
 	*/
 	constructor(options = {}) {
 		this._spanIdToPath = /* @__PURE__ */ new Map();
 		this._spanIdLists = /* @__PURE__ */ new Map();
 		this.logger = initializeLogger();
+		const wrapped = options.spanProcessor instanceof LaminarSpanProcessor ? options.spanProcessor.release : void 0;
+		this.release = detectRelease(options.release ?? wrapped);
 		if (options.spanProcessor && options.spanProcessor instanceof LaminarSpanProcessor) {
 			this.instance = options.spanProcessor.instance;
 			this._spanIdToPath = options.spanProcessor._spanIdToPath;
@@ -8645,6 +9816,7 @@ var LaminarSpanProcessor = class LaminarSpanProcessor {
 		span.setAttribute(SPAN_SDK_VERSION, version);
 		const langVersion = getLangVersion();
 		if (langVersion) span.setAttribute(SPAN_LANGUAGE_VERSION, langVersion);
+		if (this.release) span.setAttribute(SPAN_RELEASE, this.release);
 		const globalMetadata = LaminarContextManager.getGlobalMetadata();
 		if (globalMetadata && Object.keys(globalMetadata).length > 0) span.setAttributes(metadataToAttributes(globalMetadata));
 		const associationProperties = context.active().getValue(ASSOCIATION_PROPERTIES_KEY);
@@ -9677,7 +10849,8 @@ const startTracing = (options) => {
 		maxExportBatchSizeBytes: options.maxExportBatchSizeBytes,
 		flushBySize: options.flushBySize,
 		exporter: options.exporter,
-		disableBatch: options.disableBatch
+		disableBatch: options.disableBatch,
+		release: options.release
 	});
 	const newProvider = new NodeTracerProvider({
 		spanProcessors: [spanProcessor],