@lmnr-ai/lmnr 0.8.50 → 0.8.52

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
-const require_utils = require("./utils-CNR1tzh5.cjs");
+const require_utils = require("./utils-vnm5E0kk.cjs");
 const require_consts = require("./consts-9rSS0oeR.cjs");
 let path = require("path");
 path = require_rolldown_runtime.__toESM(path);
@@ -10,12 +10,9 @@ let _opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
 let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 let _opentelemetry_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
-let _traceloop_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
 let _traceloop_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
 let _traceloop_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
-let _traceloop_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
 let _traceloop_instrumentation_langchain = require("@traceloop/instrumentation-langchain");
-let _traceloop_instrumentation_openai = require("@traceloop/instrumentation-openai");
 let _traceloop_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
 let _traceloop_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
 let _traceloop_instrumentation_together = require("@traceloop/instrumentation-together");
@@ -68,6 +65,10 @@ var EvaluationDataset = class {
 		for (let i = Math.max(start, 0); i < Math.min(end, await this.size()); i++) result.push(await this.get(i));
 		return result;
 	}
+	async *[Symbol.asyncIterator]() {
+		const size = await this.size();
+		for (let i = 0; i < size; i++) yield await this.get(i);
+	}
 	sourceDataset() {}
 	take(n) {
 		return new Transformed(this, async (base) => {
@@ -144,14 +145,14 @@ var LaminarDataset = class extends EvaluationDataset {
 	fetchPage(offset) {
 		const existing = this.pages.get(offset);
 		if (existing) return existing;
-		const pending = this.doFetchPage(offset).catch((err) => {
+		const pending = this.pullPage(offset).catch((err) => {
 			this.pages.delete(offset);
 			throw err;
 		});
 		this.pages.set(offset, pending);
 		return pending;
 	}
-	async doFetchPage(offset) {
+	async pullPage(offset) {
 		if (!this.client) throw new Error("Client not set");
 		const identifier = this.id ? { id: this.id } : { name: this.name };
 		const resp = await this.client.datasets.pull({
@@ -175,6 +176,17 @@ var LaminarDataset = class extends EvaluationDataset {
 		if (local >= page.length) throw new Error(`Index ${index} is out of range for dataset of size ${this.len ?? "unknown"}`);
 		return page[local];
 	}
+	async *[Symbol.asyncIterator]() {
+		let offset = 0;
+		let yielded = 0;
+		while (this.len === null || yielded < this.len) {
+			const page = await (this.pages.get(offset) ?? this.pullPage(offset));
+			if (page.length === 0) return;
+			yield* page;
+			yielded += page.length;
+			offset += this.fetchSize;
+		}
+	}
 	/**
 	* Push data from files to this dataset.
 	*
@@ -183,7 +195,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-RXJzJyiI.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-C_q3Dsf2.cjs")).then((n) => n.file_utils_exports);
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -199,7 +211,7 @@ var LaminarDataset = class extends EvaluationDataset {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/compat.ts
-const logger$26 = require_utils.initializeLogger();
+const logger$30 = require_utils.initializeLogger();
 const makeSpanOtelV2Compatible = (span) => {
 	const spanAny = span;
 	if (spanAny.instrumentationScope && !spanAny.instrumentationLibrary) Object.assign(span, { instrumentationLibrary: spanAny.instrumentationScope });
@@ -245,7 +257,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$26.debug("Laminar failed to @opentelemetry/resources, continuing without it");
+		logger$30.debug("Laminar failed to @opentelemetry/resources, continuing without it");
 		return;
 	}
 };
@@ -447,7 +459,7 @@ const consumeResponse = async (response) => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/stream-utils.ts
-const logger$25 = require_utils.initializeLogger();
+const logger$29 = require_utils.initializeLogger();
 const pendingStreamProcessing = /* @__PURE__ */ new Set();
 /**
 * Wait for all pending stream processing to complete with a timeout
@@ -455,7 +467,7 @@ const pendingStreamProcessing = /* @__PURE__ */ new Set();
 */
 const waitForPendingStreams = async (timeoutMs = 5e3) => {
 	if (pendingStreamProcessing.size === 0) return;
-	logger$25.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
+	logger$29.debug(`Waiting for ${pendingStreamProcessing.size} pending stream(s)`);
 	const initialCount = pendingStreamProcessing.size;
 	const pendingPromises = Array.from(pendingStreamProcessing);
 	let timedOut = false;
@@ -466,7 +478,7 @@ const waitForPendingStreams = async (timeoutMs = 5e3) => {
 		}, timeoutMs);
 	});
 	await Promise.race([Promise.allSettled(pendingPromises), timeoutPromise]);
-	if (timedOut && pendingStreamProcessing.size > 0) logger$25.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
+	if (timedOut && pendingStreamProcessing.size > 0) logger$29.warn(`Timeout waiting for ${pendingStreamProcessing.size} pending stream(s) after ${timeoutMs}ms (started with ${initialCount})`);
 };
 /**
 * Track a background promise and ensure cleanup
@@ -482,34 +494,34 @@ const trackStreamProcessing = (task) => {
 * while passing through the original result to the caller
 */
 const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, serialize) => {
-	logger$25.debug(`Handling stream result of type: ${streamInfo.type}`);
+	logger$29.debug(`Handling stream result of type: ${streamInfo.type}`);
 	if (streamInfo.type === "aisdk-result") {
 		trackStreamProcessing(async () => {
-			logger$25.debug("Starting background processing for AI SDK result");
+			logger$29.debug("Starting background processing for AI SDK result");
 			let partialOutput = {};
 			try {
 				partialOutput = await consumeAISDKResult(streamInfo.result);
 				if (shouldSendTraces() && !ignoreOutput) try {
 					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (error) {
-					logger$25.warn("Failed to serialize AI SDK stream output: " + require_utils.errorMessage(error));
+					logger$29.warn("Failed to serialize AI SDK stream output: " + require_utils.errorMessage(error));
 				}
 			} catch (error) {
 				if (Object.keys(partialOutput).length > 0 && shouldSendTraces() && !ignoreOutput) try {
 					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(partialOutput));
 				} catch (serError) {
-					logger$25.warn("Failed to serialize partial AI SDK output: " + require_utils.errorMessage(serError));
+					logger$29.warn("Failed to serialize partial AI SDK output: " + require_utils.errorMessage(serError));
 				}
 				span.recordException(error);
 			} finally {
-				logger$25.debug("Ending span for AI SDK result");
+				logger$29.debug("Ending span for AI SDK result");
 				span.end();
 			}
 		});
 		return originalResult;
 	}
 	if (streamInfo.type === "readable-stream") {
-		logger$25.debug("Setting up background processing for ReadableStream");
+		logger$29.debug("Setting up background processing for ReadableStream");
 		const { stream, dataPromise } = consumeAndTeeReadableStream(streamInfo.stream);
 		trackStreamProcessing(async () => {
 			try {
@@ -521,18 +533,18 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$25.warn("Failed to serialize stream output: " + require_utils.errorMessage(serError));
+					logger$29.warn("Failed to serialize stream output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$25.debug("Ending span for ReadableStream");
+				logger$29.debug("Ending span for ReadableStream");
 				span.end();
 			}
 		});
 		return stream;
 	}
 	if (streamInfo.type === "async-iterable") {
-		logger$25.debug("Setting up background processing for AsyncIterable");
+		logger$29.debug("Setting up background processing for AsyncIterable");
 		const { iterable, dataPromise } = consumeAndTeeAsyncIterable(streamInfo.iterable);
 		trackStreamProcessing(async () => {
 			try {
@@ -544,18 +556,18 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$25.warn("Failed to serialize async iterable output: " + require_utils.errorMessage(serError));
+					logger$29.warn("Failed to serialize async iterable output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} finally {
-				logger$25.debug("Ending span for AsyncIterable");
+				logger$29.debug("Ending span for AsyncIterable");
 				span.end();
 			}
 		});
 		return iterable;
 	}
 	if (streamInfo.type === "response") {
-		logger$25.debug("Setting up background processing for Response");
+		logger$29.debug("Setting up background processing for Response");
 		const originalResponse = streamInfo.response;
 		if (!originalResponse.body) {
 			span.end();
@@ -578,19 +590,19 @@ const handleStreamResult = (originalResult, streamInfo, span, ignoreOutput, seri
 					};
 					span.setAttribute(require_utils.SPAN_OUTPUT, serialize(output));
 				} catch (serError) {
-					logger$25.warn("Failed to serialize response output: " + require_utils.errorMessage(serError));
+					logger$29.warn("Failed to serialize response output: " + require_utils.errorMessage(serError));
 				}
 				if (error) span.recordException(error);
 			} catch (err) {
 				span.recordException(err);
 			} finally {
-				logger$25.debug("Ending span for Response");
+				logger$29.debug("Ending span for Response");
 				span.end();
 			}
 		});
 		return newResponse;
 	}
-	logger$25.warn("Stream type not handled, ending span immediately");
+	logger$29.warn("Stream type not handled, ending span immediately");
 	span.end();
 	return originalResult;
 };
@@ -668,7 +680,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$24 = require_utils.initializeLogger();
+const logger$28 = require_utils.initializeLogger();
 const TRUTHY = /* @__PURE__ */ new Set([
 	"true",
 	"1",
@@ -704,7 +716,7 @@ const parseCacheUntil = (value) => {
 	if (value === void 0 || value === "") return null;
 	const spanId = normalizeSpanId(value);
 	if (spanId !== null) return spanId;
-	logger$24.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
+	logger$28.warn(`LMNR_DEBUG_CACHE_UNTIL=${JSON.stringify(value)} is not a span id; ignoring`);
 	return null;
 };
 /**
@@ -1058,7 +1070,7 @@ const resetDebugRuntime = () => {
 };
 //#endregion
 //#region src/opentelemetry-lib/tracing/span.ts
-const logger$23 = require_utils.initializeLogger();
+const logger$27 = require_utils.initializeLogger();
 /**
 * Build the debug block to propagate, or undefined when debug mode is off.
 *
@@ -1208,7 +1220,7 @@ var LaminarSpan = class LaminarSpan {
 				} catch {}
 				metadata[key.replace(`${require_utils.ASSOCIATION_PROPERTIES}.metadata.`, "")] = value;
 			}
-		} else logger$23.warn("Attributes object is not available. Most likely the span is not a LaminarSpan and not an OpenTelemetry default SDK Span. Span path and ids path will be empty.");
+		} 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.");
 		return {
 			spanId: require_utils.otelSpanIdToUUID(this._span.spanContext().spanId),
 			traceId: require_utils.otelTraceIdToUUID(this._span.spanContext().traceId),
@@ -1235,14 +1247,14 @@ var LaminarSpan = class LaminarSpan {
 	}
 	get tags() {
 		if (!this._span.attributes) {
-			logger$23.warn("[LaminarSpan.tags] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty list. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
+			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.");
 			return [];
 		}
 		return this._span.attributes[`lmnr.association.properties.tags`] ?? [];
 	}
 	get laminarAssociationProperties() {
 		if (!this._span.attributes) {
-			logger$23.warn("[LaminarSpan.laminarAssociationProperties] WARNING. Current span does not have attributes object. Possibly, the span was created with a custom OTel SDK. Returning an empty object. Help: OpenTelemetry API does not guarantee reading attributes from a span, but OTel SDK allows it by default. Laminar SDK allows to read attributes too.");
+			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.");
 			return {};
 		}
 		try {
@@ -1438,7 +1450,7 @@ var LaminarContextManager = class {
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/proxy.ts
-const logger$22 = require_utils.initializeLogger();
+const logger$26 = require_utils.initializeLogger();
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 const DEFAULT_CC_PROXY_PORT = 45667;
 const CC_PROXY_PORT_ATTEMPTS = 50;
@@ -1692,7 +1704,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$22.error(`${FOUNDRY_USE_ENV} is set but neither ${FOUNDRY_BASE_URL_ENV} nor ${FOUNDRY_RESOURCE_ENV} is configured. Microsoft Foundry requires one of these values.`);
+		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.`);
 		return null;
 	}
 	if (isTruthyEnv(getEnvValue(BEDROCK_USE_ENV))) {
@@ -1704,7 +1716,7 @@ const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL,
 			region = getRegionFromAwsConfig(awsProfile) ?? void 0;
 		}
 		if (region) return `https://bedrock-runtime.${region}.amazonaws.com`;
-		logger$22.error(`${BEDROCK_USE_ENV} is set but could not determine AWS region. Set ${BEDROCK_AWS_REGION_ENV} or configure a region in ~/.aws/config for the active profile.`);
+		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.`);
 		return null;
 	}
 	if (isTruthyEnv(getEnvValue(VERTEX_USE_ENV))) {
@@ -1787,11 +1799,11 @@ const waitForPort = (port, timeoutMs = 5e3) => new Promise((resolve) => {
 const registerGlobalProxyShutdown = () => {
 	if (!globalShutdownRegistered) {
 		process.on("exit", () => {
-			logger$22.debug("process.on(\"exit\") called - stopping all active proxies");
+			logger$26.debug("process.on(\"exit\") called - stopping all active proxies");
 			for (const proxyServer of activeProxyServers) try {
 				proxyServer.stopServer();
 			} catch (e) {
-				logger$22.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
+				logger$26.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
 			}
 			activeProxyServers.clear();
 		});
@@ -1806,28 +1818,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$22.warn("Unable to allocate port for cc-proxy.");
+			logger$26.warn("Unable to allocate port for cc-proxy.");
 			return null;
 		}
 		const targetUrl = resolvedTargetUrl ?? resolveTargetUrlFromEnv(env, void 0, cwd, settingSources, settings);
 		if (!targetUrl) {
-			logger$22.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
+			logger$26.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
 			return null;
 		}
-		logger$22.debug(`Creating proxy instance on port ${port} targeting: ${targetUrl}`);
+		logger$26.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$22.warn(`cc-proxy failed to start on port ${port}`);
+				logger$26.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$22.info(`Started claude proxy server on: ${proxyBaseUrl}`);
+			logger$26.info(`Started claude proxy server on: ${proxyBaseUrl}`);
 			return {
 				server: proxyServer,
 				baseUrl: proxyBaseUrl,
@@ -1835,11 +1847,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 				targetUrl
 			};
 		} catch (e) {
-			logger$22.warn(`Unable to start cc-proxy: ${require_utils.errorMessage(e)}`);
+			logger$26.warn(`Unable to start cc-proxy: ${require_utils.errorMessage(e)}`);
 			return null;
 		}
 	} catch (e) {
-		logger$22.warn(`Failed to create proxy instance: ${require_utils.errorMessage(e)}`);
+		logger$26.warn(`Failed to create proxy instance: ${require_utils.errorMessage(e)}`);
 		return null;
 	}
 };
@@ -1849,11 +1861,11 @@ const createProxyInstance = async ({ env, cwd, settingSources, settings, targetU
 const stopProxyInstance = (instance) => {
 	if (!instance) return;
 	try {
-		logger$22.debug(`Stopping proxy instance on port ${instance.port}`);
+		logger$26.debug(`Stopping proxy instance on port ${instance.port}`);
 		instance.server.stopServer();
 		activeProxyServers.delete(instance.server);
 	} catch (e) {
-		logger$22.debug(`Failed to stop proxy instance: ${require_utils.errorMessage(e)}`);
+		logger$26.debug(`Failed to stop proxy instance: ${require_utils.errorMessage(e)}`);
 	}
 };
 /**
@@ -1861,11 +1873,11 @@ const stopProxyInstance = (instance) => {
 * Used during shutdown to ensure cleanup
 */
 const forceReleaseProxy = () => {
-	logger$22.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
+	logger$26.debug(`Force stopping all ${activeProxyServers.size} active proxy servers`);
 	for (const proxyServer of activeProxyServers) try {
 		proxyServer.stopServer();
 	} catch (e) {
-		logger$22.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
+		logger$26.debug(`Failed to stop proxy: ${require_utils.errorMessage(e)}`);
 	}
 	activeProxyServers.clear();
 };
@@ -1915,14 +1927,14 @@ const setTraceToProxyInstance = async (instance) => {
 			spanPath: payload.span_path,
 			laminarUrl: payload.laminar_url
 		});
-		logger$22.debug(`Set trace context to proxy on port ${instance.port}`);
+		logger$26.debug(`Set trace context to proxy on port ${instance.port}`);
 	} catch (e) {
-		logger$22.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_utils.errorMessage(e));
+		logger$26.debug(`Unable to set trace context to proxy on port ${instance.port}: ` + require_utils.errorMessage(e));
 	}
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/claude-agent-sdk/index.ts
-const logger$21 = require_utils.initializeLogger();
+const logger$25 = require_utils.initializeLogger();
 /**
 * Create an instrumented version of the claude-agent-sdk query function.
 * This can be used when importing the query function before Laminar initialization.
@@ -1958,9 +1970,9 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					targetUrl
 				});
 				if (proxyInstance && targetUrl) {
-					logger$21.debug(`Using proxy on port ${proxyInstance.port}`);
+					logger$25.debug(`Using proxy on port ${proxyInstance.port}`);
 					await Laminar.withSpan(span, async () => {
-						logger$21.debug("Setting trace to proxy instance...");
+						logger$25.debug("Setting trace to proxy instance...");
 						await setTraceToProxyInstance(proxyInstance);
 					});
 					const varsToRemove = getEnvVarsToRemove(mergedEnv, sessionCwd, settingSources);
@@ -1975,13 +1987,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$21.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
+					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.`);
 					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$21.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
+						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.`);
 					}
-				} else logger$21.debug("No claude proxy server available. Proceeding without proxy.");
+				} else logger$25.debug("No claude proxy server available. Proceeding without proxy.");
 				const originalGenerator = originalQuery(params);
 				for await (const message of originalGenerator) {
 					collected.push(message);
@@ -2010,7 +2022,7 @@ var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation
 	}
 	manuallyInstrument(claudeAgentModule) {
 		if (claudeAgentModule.query && typeof claudeAgentModule.query === "function") this._wrap(claudeAgentModule, "query", this.patchQuery());
-		else logger$21.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
+		else logger$25.debug("query function not found in claudeAgentSDK module, skipping instrumentation");
 	}
 	patchQuery() {
 		return (original) => instrumentClaudeAgentQuery(original);
@@ -2028,7 +2040,7 @@ var ClaudeAgentSDKInstrumentation = class extends _opentelemetry_instrumentation
 //#endregion
 //#region src/laminar.ts
 require_utils.loadEnv();
-const logger$20 = require_utils.initializeLogger();
+const logger$24 = require_utils.initializeLogger();
 var Laminar = class Laminar {
 	static {
 		this.isInitialized = false;
@@ -2121,7 +2133,7 @@ var Laminar = class Laminar {
 	*/
 	static initialize({ projectApiKey, baseUrl, baseHttpUrl, httpPort, grpcPort, instrumentModules, disableBatch, traceExportTimeoutMillis, logLevel, maxExportBatchSize, maxExportBatchSizeBytes, flushBySize, forceHttp, sessionRecordingOptions, metadata, inheritGlobalContext, spanProcessor } = {}) {
 		if (this.isInitialized) {
-			logger$20.warn("Laminar has already been initialized. Skipping initialization.");
+			logger$24.warn("Laminar has already been initialized. Skipping initialization.");
 			return;
 		}
 		const key = projectApiKey ?? process?.env?.LMNR_PROJECT_API_KEY;
@@ -2145,7 +2157,7 @@ var Laminar = class Laminar {
 			...metadata ?? {}
 		};
 		if (inheritGlobalContext) LaminarContextManager.inheritGlobalContext = true;
-		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$20.warn("Span processor is not a LaminarSpanProcessor. Some functionality may be impaired.");
+		if (spanProcessor && !(spanProcessor instanceof LaminarSpanProcessor)) logger$24.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, "");
@@ -2192,11 +2204,11 @@ var Laminar = class Laminar {
 			try {
 				getRuntime()?.recordTraceId(require_utils.otelTraceIdToUUID(otelSpanContext.traceId));
 			} catch (e) {
-				logger$20.debug("Failed to record debug trace id from env: " + require_utils.errorMessage(e));
+				logger$24.debug("Failed to record debug trace id from env: " + require_utils.errorMessage(e));
 			}
-			logger$20.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
+			logger$24.debug("Initialized Laminar parent context from LMNR_SPAN_CONTEXT.");
 		} catch (e) {
-			logger$20.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_utils.errorMessage(e));
+			logger$24.warn("LMNR_SPAN_CONTEXT is set but could not be used: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2240,7 +2252,7 @@ var Laminar = class Laminar {
 				if (projectId) {
 					runtime.recordProjectId(projectId);
 					const sessionUrl = runtime.debuggerSessionUrl();
-					logger$20.info(`Laminar debugger session: ${sessionUrl}`);
+					logger$24.info(`Laminar debugger session: ${sessionUrl}`);
 					if (runtime.shouldOpenBrowser) {
 						const opener = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
 						(0, node_child_process.spawn)(opener, [sessionUrl], {
@@ -2250,7 +2262,7 @@ var Laminar = class Laminar {
 					}
 				}
 			}).catch((e) => {
-				logger$20.warn("Failed to register debug session: " + require_utils.errorMessage(e));
+				logger$24.warn("Failed to register debug session: " + require_utils.errorMessage(e));
 			});
 			this.globalMetadata = {
 				...this.globalMetadata,
@@ -2260,7 +2272,7 @@ var Laminar = class Laminar {
 			this.debugExitHook = () => runtime.emitPointer();
 			process.once("exit", this.debugExitHook);
 		} catch (e) {
-			logger$20.warn("Failed to initialize debug runtime: " + require_utils.errorMessage(e));
+			logger$24.warn("Failed to initialize debug runtime: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2307,7 +2319,7 @@ var Laminar = class Laminar {
 				runtime.rolloutSessions.register({ sessionId: runtime.sessionId }).then((projectId) => {
 					if (projectId) runtime.recordProjectId(projectId);
 				}).catch((e) => {
-					logger$20.debug("Failed to register downstream debug session: " + require_utils.errorMessage(e));
+					logger$24.debug("Failed to register downstream debug session: " + require_utils.errorMessage(e));
 				});
 				this.globalMetadata = {
 					...this.globalMetadata,
@@ -2316,7 +2328,7 @@ var Laminar = class Laminar {
 				LaminarContextManager.setGlobalMetadata(this.globalMetadata);
 			}
 		} catch (e) {
-			logger$20.debug("Failed to arm debug runtime from context: " + require_utils.errorMessage(e));
+			logger$24.debug("Failed to arm debug runtime from context: " + require_utils.errorMessage(e));
 		}
 	}
 	/**
@@ -2331,7 +2343,7 @@ var Laminar = class Laminar {
 	*/
 	static patch(modules) {
 		if (!this.isInitialized) {
-			logger$20.warn("Laminar must be initialized before patching modules. Skipping patch.");
+			logger$24.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");
@@ -2591,7 +2603,7 @@ var Laminar = class Laminar {
 			const spanContext = require_utils.tryToOtelSpanContext(laminarContext);
 			entityContext = _opentelemetry_api.trace.setSpan(entityContext, _opentelemetry_api.trace.wrapSpanContext(spanContext));
 		} catch (e) {
-			logger$20.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
+			logger$24.warn("Failed to parse parent span context: " + require_utils.errorMessage(e));
 		}
 		const tagProperties = tags ? { [`${require_utils.ASSOCIATION_PROPERTIES}.tags`]: Array.from(new Set(tags)) } : {};
 		const ctxAssociationProperties = LaminarContextManager.getAssociationProperties();
@@ -2695,13 +2707,13 @@ var Laminar = class Laminar {
 	}
 	static async flush() {
 		if (this.isInitialized) {
-			logger$20.debug("Flushing spans");
+			logger$24.debug("Flushing spans");
 			await forceFlush();
 		}
 	}
 	static async shutdown() {
 		if (this.isInitialized) {
-			logger$20.debug("Shutting down Laminar");
+			logger$24.debug("Shutting down Laminar");
 			getRuntime()?.emitPointer();
 			await forceFlush();
 			this.isInitialized = false;
@@ -2836,7 +2848,7 @@ return module.exports;
 //#endregion
 //#region src/browser/utils.ts
 const LMNR_SEND_EVENTS_FUNCTION_NAME = "lmnrSendEvents";
-const logger$19 = require_utils.initializeLogger();
+const logger$23 = require_utils.initializeLogger();
 /**
 * If the first argument is a string, return an object with the name of the method
 * and the argument as the value.
@@ -2859,7 +2871,7 @@ const takeFullSnapshot = async (page) => await page.evaluate(() => {
 		window.lmnrRrweb.record.takeFullSnapshot();
 		return true;
 	} catch (error) {
-		logger$19.error("Error taking full snapshot: " + require_utils.errorMessage(error));
+		logger$23.error("Error taking full snapshot: " + require_utils.errorMessage(error));
 		return false;
 	}
 	return false;
@@ -2870,7 +2882,7 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 			try {
 				return await script();
 			} catch (error) {
-				logger$19.error("Operation " + script.name + " failed: " + require_utils.errorMessage(error));
+				logger$23.error("Operation " + script.name + " failed: " + require_utils.errorMessage(error));
 			}
 			await new Promise((resolve) => setTimeout(resolve, 500));
 		}
@@ -2880,20 +2892,20 @@ const injectSessionRecorder = async (page, sessionRecordingOptions) => {
 	try {
 		isRrwebPresent = await castedPage.evaluate(() => typeof window.lmnrRrweb !== "undefined");
 	} catch (error) {
-		logger$19.debug("Failed to check if session recorder is loaded: " + require_utils.errorMessage(error));
+		logger$23.debug("Failed to check if session recorder is loaded: " + require_utils.errorMessage(error));
 	}
 	if (!isRrwebPresent) {
 		if (!await tryRunScript(async function injectSessionRecorder() {
 			await castedPage.evaluate(RECORDER);
 			return true;
 		})) {
-			logger$19.error("Failed to load session recorder");
+			logger$23.error("Failed to load session recorder");
 			return;
 		}
 		try {
 			await castedPage.evaluate(injectScript, sessionRecordingOptions);
 		} catch (error) {
-			logger$19.debug("Failed to inject session recorder: " + require_utils.errorMessage(error));
+			logger$23.debug("Failed to inject session recorder: " + require_utils.errorMessage(error));
 		}
 	}
 };
@@ -3159,7 +3171,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 	try {
 		const { batchId, chunkIndex, totalChunks, data } = chunk;
 		if (!sessionId || !traceId) {
-			logger$19.debug("Missing sessionId or traceId in chunk");
+			logger$23.debug("Missing sessionId or traceId in chunk");
 			return;
 		}
 		if (!chunkBuffers.has(batchId)) chunkBuffers.set(batchId, {
@@ -3178,7 +3190,7 @@ async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
 				traceId,
 				events
 			}).catch((error) => {
-				logger$19.debug("Failed to send events: " + require_utils.errorMessage(error));
+				logger$23.debug("Failed to send events: " + require_utils.errorMessage(error));
 			});
 			chunkBuffers.delete(batchId);
 		}
@@ -3186,16 +3198,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$19.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
+			logger$23.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
 			chunkBuffers.delete(bid);
 		}
 	} catch (error) {
-		logger$19.debug("Could not send events: " + require_utils.errorMessage(error));
+		logger$23.debug("Could not send events: " + require_utils.errorMessage(error));
 	}
 }
 //#endregion
 //#region src/browser/playwright.ts
-const logger$18 = require_utils.initializeLogger();
+const logger$22 = require_utils.initializeLogger();
 var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/playwright-instrumentation", require_utils.version, { enabled: true });
@@ -3303,7 +3315,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 			try {
 				await injectSessionRecorder(page, this._sessionRecordingOptions);
 			} catch (error) {
-				logger$18.error("Error in onLoad handler: " + require_utils.errorMessage(error));
+				logger$22.error("Error in onLoad handler: " + require_utils.errorMessage(error));
 			}
 		});
 		const chunkBuffers = /* @__PURE__ */ new Map();
@@ -3313,7 +3325,7 @@ var PlaywrightInstrumentation = class extends _opentelemetry_instrumentation.Ins
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$18.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
+			logger$22.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
 		}
 	}
 };
@@ -3738,7 +3750,7 @@ var StagehandV2Instrumentation = class extends _opentelemetry_instrumentation.In
 };
 //#endregion
 //#region src/browser/puppeteer.ts
-const logger$17 = require_utils.initializeLogger();
+const logger$21 = require_utils.initializeLogger();
 var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(client, sessionRecordingOptions) {
 		super("@lmnr/puppeteer-instrumentation", require_utils.version, { enabled: true });
@@ -3783,10 +3795,10 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				context.on("targetcreated", (target) => {
 					target.page().then((page) => {
 						if (page) plugin.patchPage(page, sessionId).catch((error) => {
-							logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+							logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 						});
 					}).catch((error) => {
-						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				});
 				await Promise.all((await context.pages()).map((page) => plugin.patchPage(page, sessionId)));
@@ -3804,19 +3816,19 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			context.on("targetcreated", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+					logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 				});
 			});
 			context.on("targetchanged", (target) => {
 				target.page().then((page) => {
 					if (page) plugin.patchPage(page, sessionId).catch((error) => {
-						logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+						logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 					});
 				}).catch((error) => {
-					logger$17.error("Failed to patch page: " + require_utils.errorMessage(error));
+					logger$21.error("Failed to patch page: " + require_utils.errorMessage(error));
 				});
 			});
 			for (const page of await context.pages()) await plugin.patchPage(page, sessionId);
@@ -3840,7 +3852,7 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		const traceId = otelTraceId ? require_utils.otelTraceIdToUUID(otelTraceId) : require_utils.NIL_UUID;
 		page.on("domcontentloaded", () => {
 			injectSessionRecorder(page, this._sessionRecordingOptions).catch((error) => {
-				logger$17.error("Error in onLoad handler: " + require_utils.errorMessage(error));
+				logger$21.error("Error in onLoad handler: " + require_utils.errorMessage(error));
 			});
 		});
 		await injectSessionRecorder(page, this._sessionRecordingOptions);
@@ -3850,13 +3862,13 @@ var PuppeteerInstrumentation = class extends _opentelemetry_instrumentation.Inst
 				await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
 			});
 		} catch (error) {
-			logger$17.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
+			logger$21.debug("Could not expose function lmnrSendEvents: " + require_utils.errorMessage(error));
 		}
 	}
 };
 //#endregion
 //#region src/browser/stagehand/v3/constants.ts
-const logger$16 = require_utils.initializeLogger();
+const logger$20 = require_utils.initializeLogger();
 const CDP_OPERATION_TIMEOUT_MS = 1e4;
 const SKIP_URL_PATTERNS = [
 	"about:blank",
@@ -3907,7 +3919,7 @@ async function getOrCreateIsolatedWorld(page) {
 			frameId
 		};
 	} catch (error) {
-		logger$16.debug("Failed to create isolated world: " + require_utils.errorMessage(error));
+		logger$20.debug("Failed to create isolated world: " + require_utils.errorMessage(error));
 		return null;
 	}
 }
@@ -3924,7 +3936,7 @@ async function isRecorderPresent(page, contextId) {
 		if (!result) return true;
 		return result.result?.value === true;
 	} catch (error) {
-		logger$16.debug("Failed to check if recorder is present: " + require_utils.errorMessage(error));
+		logger$20.debug("Failed to check if recorder is present: " + require_utils.errorMessage(error));
 		return true;
 	}
 }
@@ -3937,21 +3949,21 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 		try {
 			url = page.url();
 		} catch (error) {
-			logger$16.debug("Failed to get page URL, page might be closed: " + require_utils.errorMessage(error));
+			logger$20.debug("Failed to get page URL, page might be closed: " + require_utils.errorMessage(error));
 			return null;
 		}
 		if (shouldSkipUrl(url)) {
-			logger$16.debug(`Skipping recorder injection for URL: ${url}`);
+			logger$20.debug(`Skipping recorder injection for URL: ${url}`);
 			return null;
 		}
 		const worldResult = await getOrCreateIsolatedWorld(page);
 		if (!worldResult) {
-			logger$16.debug("Failed to get isolated world for page");
+			logger$20.debug("Failed to get isolated world for page");
 			return null;
 		}
 		const { contextId, frameId } = worldResult;
 		if (await isRecorderPresent(page, contextId)) {
-			logger$16.debug("Recorder already present, skipping injection");
+			logger$20.debug("Recorder already present, skipping injection");
 			state.contextIdToSession.set(contextId, {
 				sessionId: state.sessionId,
 				traceId: state.traceId
@@ -3964,7 +3976,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$16.debug("Failed to inject rrweb: " + require_utils.errorMessage(error));
+			logger$20.debug("Failed to inject rrweb: " + require_utils.errorMessage(error));
 			return null;
 		}
 		const optionsJson = JSON.stringify(sessionRecordingOptions ?? {});
@@ -3975,14 +3987,14 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 				contextId
 			});
 		} catch (error) {
-			logger$16.debug("Failed to inject recording setup: " + require_utils.errorMessage(error));
+			logger$20.debug("Failed to inject recording setup: " + require_utils.errorMessage(error));
 			return null;
 		}
 		try {
 			await sendCDP(page, "Runtime.addBinding", { name: "lmnrSendEvents" });
-			logger$16.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
+			logger$20.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
 		} catch (error) {
-			logger$16.debug("Binding may already exist: " + require_utils.errorMessage(error));
+			logger$20.debug("Binding may already exist: " + require_utils.errorMessage(error));
 		}
 		if (bindingHandler) try {
 			const pageTargetId = page.targetId();
@@ -3992,26 +4004,26 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 					const sessionTyped = session;
 					if (sessionTyped.on) {
 						sessionTyped.on("Runtime.bindingCalled", bindingHandler);
-						logger$16.debug(`Set up binding handler on session ${sessionId}`);
+						logger$20.debug(`Set up binding handler on session ${sessionId}`);
 					}
 				} catch (error) {
-					logger$16.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_utils.errorMessage(error));
+					logger$20.debug(`Failed to set up binding handler on session ${sessionId}: ` + require_utils.errorMessage(error));
 				}
 				state.pageSessionHandlers.set(pageTargetId, bindingHandler);
 			}
 		} catch (error) {
-			logger$16.debug("Failed to set up binding handler: " + require_utils.errorMessage(error));
+			logger$20.debug("Failed to set up binding handler: " + require_utils.errorMessage(error));
 		}
 		state.contextIdToSession.set(contextId, {
 			sessionId: state.sessionId,
 			traceId: state.traceId
 		});
-		logger$16.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
+		logger$20.debug(`Registered context mapping: contextId=${contextId}, sessionId=${state.sessionId}`);
 		state.instrumentedPageIds.add(frameId);
-		logger$16.debug(`Successfully injected recorder into page ${frameId}`);
+		logger$20.debug(`Successfully injected recorder into page ${frameId}`);
 		return contextId;
 	} catch (error) {
-		logger$16.debug("Error injecting recorder: " + require_utils.errorMessage(error));
+		logger$20.debug("Error injecting recorder: " + require_utils.errorMessage(error));
 		return null;
 	}
 }
@@ -4025,13 +4037,13 @@ function createBindingHandler(state) {
 		if (event.name !== "lmnrSendEvents") return;
 		const sessionInfo = state.contextIdToSession.get(event.executionContextId);
 		if (!sessionInfo) {
-			logger$16.debug("No session info found for context ID: " + event.executionContextId);
+			logger$20.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$16.debug("Failed to parse binding payload: " + require_utils.errorMessage(error));
+					logger$20.debug("Failed to parse binding payload: " + require_utils.errorMessage(error));
 				}
 			}
 			return;
@@ -4039,7 +4051,7 @@ function createBindingHandler(state) {
 		try {
 			sendEvents(JSON.parse(event.payload), state.client, state.chunkBuffers, sessionInfo.sessionId, sessionInfo.traceId);
 		} catch (error) {
-			logger$16.debug("Failed to handle binding event: " + require_utils.errorMessage(error));
+			logger$20.debug("Failed to handle binding event: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4055,10 +4067,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$16.debug("Error injecting recorder into new page: " + require_utils.errorMessage(error));
+				logger$20.debug("Error injecting recorder into new page: " + require_utils.errorMessage(error));
 			}
 		} catch (error) {
-			logger$16.debug("Error handling target created event: " + require_utils.errorMessage(error));
+			logger$20.debug("Error handling target created event: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4070,7 +4082,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 		if (event.targetInfo.type !== "page") return;
 		const url = event.targetInfo.url;
 		if (shouldSkipUrl(url)) return;
-		logger$16.debug(`Target URL changed to ${url}, checking if recorder injection needed`);
+		logger$20.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) {
@@ -4078,7 +4090,7 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 				break;
 			}
 		} catch (error) {
-			logger$16.debug("Error handling target info change: " + require_utils.errorMessage(error));
+			logger$20.debug("Error handling target info change: " + require_utils.errorMessage(error));
 		}
 	};
 }
@@ -4239,12 +4251,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	*/
 	async setupSessionRecording(stagehandInstance, sessionId, traceId) {
 		if (!this._client) {
-			logger$16.debug("No Laminar client available, skipping session recording setup");
+			logger$20.debug("No Laminar client available, skipping session recording setup");
 			return;
 		}
 		const context = stagehandInstance.context;
 		if (!context || !context.conn) {
-			logger$16.debug("No context or connection available, skipping session recording setup");
+			logger$20.debug("No context or connection available, skipping session recording setup");
 			return;
 		}
 		const recorderState = {
@@ -4274,11 +4286,11 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			for (const page of pages) try {
 				if (await injectRecorderViaCDP(page, recorderState, context.conn, this._sessionRecordingOptions, bindingHandler) !== null) injectedCount++;
 			} catch (error) {
-				logger$16.debug("Error injecting recorder into page: " + require_utils.errorMessage(error));
+				logger$20.debug("Error injecting recorder into page: " + require_utils.errorMessage(error));
 			}
-			logger$16.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
+			logger$20.debug(`Injected session recorder into ${injectedCount} of ${pages.length} existing page(s)`);
 		} catch (error) {
-			logger$16.debug("Error accessing pages for recorder injection: " + require_utils.errorMessage(error));
+			logger$20.debug("Error accessing pages for recorder injection: " + require_utils.errorMessage(error));
 		}
 	}
 	patchStagehandClose() {
@@ -4308,12 +4320,12 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			if (recorderState.targetCreatedHandler) try {
 				context.conn.off("Target.targetCreated", recorderState.targetCreatedHandler);
 			} catch (error) {
-				logger$16.debug("Error removing target created handler: " + require_utils.errorMessage(error));
+				logger$20.debug("Error removing target created handler: " + require_utils.errorMessage(error));
 			}
 			if (recorderState.targetInfoChangedHandler) try {
 				context.conn.off("Target.targetInfoChanged", recorderState.targetInfoChangedHandler);
 			} catch (error) {
-				logger$16.debug("Error removing target info changed handler: " + require_utils.errorMessage(error));
+				logger$20.debug("Error removing target info changed handler: " + require_utils.errorMessage(error));
 			}
 		}
 		recorderState.contextIdToSession.clear();
@@ -4324,7 +4336,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		recorderState.targetCreatedHandler = null;
 		recorderState.targetInfoChangedHandler = null;
 		this.stagehandInstanceToRecorderState.delete(stagehandInstance);
-		logger$16.debug("Cleaned up session recording for Stagehand instance");
+		logger$20.debug("Cleaned up session recording for Stagehand instance");
 	}
 	patchStagehandGlobalMethod(methodName, sessionId, parentSpan) {
 		return (original) => async function method(...args) {
@@ -4672,9 +4684,11 @@ function extractToolDefinitions(config) {
 }
 /**
 * Set request attributes on a span from generateContent params.
+* Also used by the google-aiplatform (Vertex AI) instrumentation, which
+* reshapes its requests into the same `{model, contents, config}` form.
 */
-function setRequestAttributes$2(span, params, traceContent) {
-	safeSetAttribute$2(span, LLM_SYSTEM, "gemini");
+function setRequestAttributes$5(span, params, traceContent, system = "gemini") {
+	safeSetAttribute$2(span, LLM_SYSTEM, system);
 	safeSetAttribute$2(span, LLM_REQUEST_MODEL, params?.model);
 	const config = params?.config;
 	if (config) {
@@ -4700,7 +4714,7 @@ function setRequestAttributes$2(span, params, traceContent) {
 /**
 * Set response attributes on a span from a GenerateContentResponse.
 */
-function setResponseAttributes$2(span, response, traceContent) {
+function setResponseAttributes$5(span, response, traceContent) {
 	if (!response) return;
 	safeSetAttribute$2(span, LLM_RESPONSE_MODEL, response.modelVersion);
 	const usage = response.usageMetadata;
@@ -4802,7 +4816,7 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 			try {
 				if (modelVersion !== void 0 || role !== void 0 || accumulatedParts.length > 0 || sawUsageMetadata) {
 					const mergedParts = mergeTextParts(accumulatedParts);
-					setResponseAttributes$2(span, {
+					setResponseAttributes$5(span, {
 						modelVersion,
 						candidates: [{ content: {
 							role: role ?? "model",
@@ -4831,177 +4845,1548 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 	return wrapper();
 }
 //#endregion
-//#region src/opentelemetry-lib/instrumentation/google-genai/index.ts
-const WRAPPED_SYMBOL$1 = Symbol("lmnr.google-genai.wrapped");
-const CLASS_PATCH_DATA_SYMBOL = Symbol("lmnr.google-genai.classPatchData");
-var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+//#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 createStreamState$1 = () => ({
+	usage: {},
+	blocks: [],
+	completion: ""
+});
+const toJson$1 = (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);
+	const schema = params?.output_config?.format?.schema;
+	if (schema && typeof schema === "object") return toJson$1(schema);
+};
+const buildInputMessages$1 = (params) => {
+	if (params?.prompt !== void 0 && params?.prompt !== null) return [{
+		role: "user",
+		content: params.prompt
+	}];
+	if (!Array.isArray(params?.messages)) return void 0;
+	const messages = [];
+	if (params.system) messages.push({
+		role: "system",
+		content: params.system
+	});
+	messages.push(...params.messages);
+	return messages;
+};
+const setRequestAttributes$4 = (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);
+	safeSetAttribute$2(span, "gen_ai.request.temperature", params?.temperature);
+	safeSetAttribute$2(span, "gen_ai.request.top_p", params?.top_p);
+	safeSetAttribute$2(span, "gen_ai.request.frequency_penalty", params?.frequency_penalty);
+	safeSetAttribute$2(span, "gen_ai.request.presence_penalty", params?.presence_penalty);
+	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, "gen_ai.request.structured_output_schema", extractStructuredOutputSchema$1(params));
+};
+const setUsageAttributes$1 = (span, usage, includeTotal) => {
+	if (!usage || typeof usage !== "object" || !Object.keys(usage).length) return;
+	const promptTokens = usage.input_tokens ?? 0;
+	const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+	const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+	const outputTokens = usage.output_tokens ?? 0;
+	const inputTokens = promptTokens + cacheReadTokens + cacheCreationTokens;
+	span.setAttribute("gen_ai.usage.input_tokens", inputTokens);
+	span.setAttribute("gen_ai.usage.output_tokens", outputTokens);
+	if (includeTotal) span.setAttribute("llm.usage.total_tokens", inputTokens + outputTokens);
+	span.setAttribute("gen_ai.usage.cache_read_input_tokens", cacheReadTokens);
+	span.setAttribute("gen_ai.usage.cache_creation_input_tokens", cacheCreationTokens);
+};
+/**
+* Response attributes for a non-streaming `Message` (or legacy `Completion`).
+*/
+const setResponseAttributes$4 = (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);
+	safeSetAttribute$2(span, "anthropic.response.service_tier", response.usage?.service_tier);
+	setUsageAttributes$1(span, response.usage, true);
+	if (traceContent) {
+		const output = {
+			role: response.role ?? "assistant",
+			content: []
+		};
+		if (response.stop_reason) output.stop_reason = response.stop_reason;
+		if (response.completion) output.content.push({
+			type: "text",
+			text: response.completion
+		});
+		else if (Array.isArray(response.content)) output.content.push(...response.content);
+		safeSetAttribute$2(span, OUTPUT_MESSAGES$2, toJson$1([output]));
+	}
+	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+};
+const mergeUsage = (state, usage) => {
+	if (!usage || typeof usage !== "object") return;
+	for (const [key, value] of Object.entries(usage)) if (value !== null && value !== void 0) state.usage[key] = value;
+};
+/**
+* Fold one raw stream event (`RawMessageStreamEvent`, or a legacy completion
+* chunk) into the accumulated state.
+*/
+const processStreamEvent$1 = (state, event) => {
+	switch (event?.type) {
+		case "message_start": {
+			const message = event.message ?? {};
+			state.id = message.id;
+			state.model = message.model;
+			mergeUsage(state, message.usage);
+			state.serviceTier = message.usage?.service_tier ?? void 0;
+			break;
+		}
+		case "content_block_start": {
+			const block = { ...event.content_block };
+			if ("input" in block) block.input = "";
+			state.blocks[event.index] = block;
+			break;
+		}
+		case "content_block_delta": {
+			const block = state.blocks[event.index];
+			const delta = event.delta ?? {};
+			if (!block) break;
+			if (delta.type === "text_delta") block.text = (block.text ?? "") + (delta.text ?? "");
+			else if (delta.type === "thinking_delta") block.thinking = (block.thinking ?? "") + (delta.thinking ?? "");
+			else if (delta.type === "input_json_delta") block.input = (block.input ?? "") + (delta.partial_json ?? "");
+			break;
+		}
+		case "message_delta":
+			if (event.delta?.stop_reason) state.stopReason = event.delta.stop_reason;
+			mergeUsage(state, event.usage);
+			break;
+		case "completion":
+			state.id = event.id ?? state.id;
+			state.model = event.model ?? state.model;
+			state.completion += event.completion ?? "";
+			if (event.stop_reason) state.stopReason = event.stop_reason;
+	}
+};
+const parseToolInput = (input) => {
+	if (typeof input !== "string") return input;
+	if (input === "") return {};
+	try {
+		return JSON.parse(input);
+	} catch {
+		return input;
+	}
+};
+const buildStreamedContent = (state) => {
+	if (state.completion) return [{
+		type: "text",
+		text: state.completion
+	}];
+	const content = [];
+	for (const block of state.blocks) {
+		if (!block) continue;
+		if (block.type === "text") {
+			if (block.text) content.push({
+				type: "text",
+				text: block.text
+			});
+		} else if (block.type === "thinking") content.push({
+			type: "thinking",
+			thinking: block.thinking ?? ""
+		});
+		else if ("input" in block) content.push({
+			...block,
+			input: parseToolInput(block.input)
+		});
+		else content.push(block);
+	}
+	return content;
+};
+const setStreamingResponseAttributes = (span, state, traceContent) => {
+	safeSetAttribute$2(span, "gen_ai.response.id", state.id);
+	safeSetAttribute$2(span, "gen_ai.response.model", state.model);
+	safeSetAttribute$2(span, "anthropic.response.service_tier", state.usage.service_tier ?? state.serviceTier);
+	setUsageAttributes$1(span, state.usage, false);
+	if (traceContent) {
+		const output = {
+			role: "assistant",
+			content: buildStreamedContent(state)
+		};
+		if (state.stopReason) output.stop_reason = state.stopReason;
+		safeSetAttribute$2(span, OUTPUT_MESSAGES$2, toJson$1([output]));
+	}
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/anthropic/index.ts
+const logger$19 = require_utils.initializeLogger();
+const PATCH_DATA_SYMBOL$3 = Symbol("lmnr.anthropic.patchData");
+const hasOwnPatchData$2 = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$3) !== void 0;
+const markSpanError$3 = (span, error) => {
+	span.recordException(error);
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+};
+/**
+* Attribute extraction must never break the user's call.
+*/
+const safely$3 = (fn) => {
+	try {
+		fn();
+	} catch (error) {
+		logger$19.debug(`Failed to set anthropic span attributes: ${String(error)}`);
+	}
+};
+const isAsyncIterable$3 = (value) => value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+/**
+* Resolve the `Anthropic` client class from the module namespace, its default
+* export, or the class itself.
+*/
+const resolveClientClass$1 = (mod) => {
+	for (const candidate of [
+		mod?.Anthropic,
+		mod?.default,
+		mod
+	]) if (typeof candidate?.Messages === "function") return candidate;
+};
+/**
+* Instruments `@anthropic-ai/sdk`: `messages.create`, `beta.messages.create`
+* and the legacy `completions.create`. `messages.parse()` and
+* `messages.stream()` (and their beta counterparts) delegate to `create`, so
+* they are traced through it without nesting a second span.
+*/
+var AnthropicInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(config) {
-		super("@lmnr/google-genai-instrumentation", require_utils.version, { enabled: true });
+		super("@lmnr/anthropic-instrumentation", require_utils.version, { enabled: true });
 		this.traceContent = config?.traceContent ?? true;
 	}
 	init() {
-		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@google/genai", [">=1.0.0"], this.patch.bind(this), this.unpatch.bind(this));
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@anthropic-ai/sdk", [">=0.9.1"], this.patch.bind(this), this.unpatch.bind(this));
 	}
-	manuallyInstrument(genaiModule) {
-		_opentelemetry_api.diag.debug("Manually instrumenting @google/genai");
-		const GoogleGenAIClass = this.resolveGoogleGenAIClass(genaiModule);
-		if (GoogleGenAIClass) this.patchGoogleGenAIClass(GoogleGenAIClass);
-		else _opentelemetry_api.diag.warn("Could not find GoogleGenAI class in google_genai manual instrumentation input. Pass either GoogleGenAI class or module object with GoogleGenAI export.");
+	/**
+	* Accepts the `@anthropic-ai/sdk` module namespace or the `Anthropic`
+	* class (the module's default export).
+	*/
+	manuallyInstrument(module) {
+		if (!resolveClientClass$1(module)) {
+			_opentelemetry_api.diag.warn("Could not find the Anthropic client in anthropic manual instrumentation input. Pass the @anthropic-ai/sdk module.");
+			return;
+		}
+		_opentelemetry_api.diag.debug("Manually instrumenting @anthropic-ai/sdk");
+		this.patch(module);
 	}
 	patch(moduleExports) {
-		_opentelemetry_api.diag.debug("Patching @google/genai");
-		const GoogleGenAIClass = this.resolveGoogleGenAIClass(moduleExports);
-		if (GoogleGenAIClass) this.patchGoogleGenAIClass(GoogleGenAIClass);
+		_opentelemetry_api.diag.debug("Patching @anthropic-ai/sdk");
+		const [completions, ...messages] = this.resourcePrototypes(moduleExports);
+		this.patchCreate(completions, "anthropic.completion");
+		for (const proto of messages) this.patchCreate(proto, "anthropic.chat");
 		return moduleExports;
 	}
 	unpatch(moduleExports) {
-		_opentelemetry_api.diag.debug("Unpatching @google/genai");
-		const GoogleGenAIClass = this.resolveGoogleGenAIClass(moduleExports);
-		if (GoogleGenAIClass) this.unpatchGoogleGenAIClass(GoogleGenAIClass);
+		_opentelemetry_api.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];
+		}
 	}
-	resolveGoogleGenAIClass(moduleOrClass) {
-		if (typeof moduleOrClass === "function") return moduleOrClass;
-		if (moduleOrClass?.GoogleGenAI && typeof moduleOrClass.GoogleGenAI === "function") return moduleOrClass.GoogleGenAI;
+	/**
+	* `[Completions, Messages, Beta.Messages]` prototypes; entries are
+	* undefined where the installed SDK version lacks the resource.
+	*/
+	resourcePrototypes(moduleExports) {
+		const client = resolveClientClass$1(moduleExports);
+		return [
+			client?.Completions?.prototype,
+			client?.Messages?.prototype,
+			client?.Beta?.Messages?.prototype
+		];
 	}
-	patchGoogleGenAIClass(GoogleGenAIClass) {
-		const classPatchData = GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
-		if (classPatchData) {
-			classPatchData.instrumentation = this;
-			classPatchData.traceContent = this.traceContent;
-			return;
-		}
-		const originalModelsDescriptor = Object.getOwnPropertyDescriptor(GoogleGenAIClass.prototype, "models");
-		if (originalModelsDescriptor && !originalModelsDescriptor.configurable) {
-			_opentelemetry_api.diag.warn("Could not patch GoogleGenAI.prototype.models: descriptor is non-configurable.");
+	/**
+	* Replace `proto.create` with a traced wrapper. Re-patching an already
+	* patched prototype only refreshes `traceContent`, so repeated
+	* initialization never double-wraps.
+	*/
+	patchCreate(proto, spanName) {
+		if (!proto || typeof proto.create !== "function") return;
+		if (hasOwnPatchData$2(proto)) {
+			proto[PATCH_DATA_SYMBOL$3].traceContent = this.traceContent;
 			return;
 		}
 		const patchData = {
-			instrumentation: this,
 			traceContent: this.traceContent,
-			originalModelsDescriptor
+			original: proto.create
 		};
-		Object.defineProperty(GoogleGenAIClass, CLASS_PATCH_DATA_SYMBOL, {
+		Object.defineProperty(proto, PATCH_DATA_SYMBOL$3, {
 			value: patchData,
 			writable: true,
 			configurable: true,
 			enumerable: false
 		});
-		Object.defineProperty(GoogleGenAIClass.prototype, "models", {
-			configurable: true,
-			enumerable: originalModelsDescriptor?.enumerable ?? true,
-			get: function() {
-				if (originalModelsDescriptor?.get) return originalModelsDescriptor.get.call(this);
-			},
-			set: function(value) {
-				patchData.instrumentation.patchModelsInstance(value, patchData);
-				if (originalModelsDescriptor?.set) {
-					originalModelsDescriptor.set.call(this, value);
-					return;
-				}
-				Object.defineProperty(this, "models", {
-					value,
-					writable: true,
-					configurable: true,
-					enumerable: true
-				});
-			}
-		});
+		proto.create = wrapCreate(patchData, spanName);
 	}
-	unpatchGoogleGenAIClass(GoogleGenAIClass) {
-		const classPatchData = GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
-		if (!classPatchData) return;
-		if (classPatchData.originalModelsDescriptor) Object.defineProperty(GoogleGenAIClass.prototype, "models", classPatchData.originalModelsDescriptor);
-		else delete GoogleGenAIClass.prototype.models;
-		delete GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
+};
+const wrapCreate = (patchData, spanName) => function(params, ...rest) {
+	const { original } = patchData;
+	if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.call(this, params, ...rest);
+	const traceContent = patchData.traceContent;
+	const span = Laminar.startSpan({
+		name: spanName,
+		spanType: "LLM"
+	});
+	safely$3(() => setRequestAttributes$4(span, params, traceContent));
+	let result;
+	try {
+		result = Laminar.withSpan(span, () => ({ value: original.call(this, params, ...rest) })).value;
+	} catch (error) {
+		markSpanError$3(span, error);
+		span.end();
+		throw error;
 	}
-	patchModelsInstance(models, classPatchData) {
-		if (!models || typeof models !== "object") return;
-		if (typeof models.generateContent !== "function") return;
-		if (typeof models.generateContentStream !== "function") return;
-		if (models[WRAPPED_SYMBOL$1]) return;
-		const originalGenerateContent = models.generateContent.bind(models);
-		const originalGenerateContentStream = models.generateContentStream.bind(models);
-		models.generateContent = async function(params) {
-			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return originalGenerateContent(params);
-			const span = Laminar.startSpan({
-				name: "gemini.generate_content",
-				spanType: "LLM"
-			});
-			setRequestAttributes$2(span, params, classPatchData.traceContent);
-			return Laminar.withSpan(span, async () => {
-				try {
-					const response = await originalGenerateContent(params);
-					setResponseAttributes$2(span, response, classPatchData.traceContent);
-					return response;
-				} catch (error) {
-					span.setAttribute("error.type", error.constructor?.name ?? "Error");
-					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
-					throw error;
-				}
-			}, true);
-		};
-		models.generateContentStream = async function(params) {
-			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return originalGenerateContentStream(params);
-			const span = Laminar.startSpan({
-				name: "gemini.generate_content_stream",
-				spanType: "LLM"
-			});
-			setRequestAttributes$2(span, params, classPatchData.traceContent);
-			try {
-				return wrapStreamingResponse(span, await originalGenerateContentStream(params), classPatchData.traceContent);
-			} catch (error) {
-				span.setAttribute("error.type", error.constructor?.name ?? "Error");
-				span.recordException(error);
-				span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
-				span.end();
-				throw error;
-			}
-		};
-		models[WRAPPED_SYMBOL$1] = true;
+	let ended = false;
+	const fail = (error) => {
+		if (ended) return;
+		ended = true;
+		markSpanError$3(span, error);
+		span.end();
+	};
+	const succeed = (data) => {
+		if (ended) return data;
+		if (params?.stream && isAsyncIterable$3(data)) {
+			ended = true;
+			instrumentStream$2(data, span, traceContent);
+			return data;
+		}
+		ended = true;
+		safely$3(() => setResponseAttributes$4(span, data, traceContent));
+		span.end();
+		return data;
+	};
+	if (typeof result?._thenUnwrap === "function") {
+		const responsePromise = typeof result._responseProps === "function" ? result._responseProps() : result.responsePromise;
+		if (typeof responsePromise?.then === "function") responsePromise.then(void 0, fail);
+		return result._thenUnwrap(succeed);
 	}
+	if (typeof result?.then === "function") return result.then(succeed, (error) => {
+		fail(error);
+		throw error;
+	});
+	return succeed(result);
+};
+/**
+* Aggregate the events of an SDK `Stream` as the caller iterates it, and end
+* the span when iteration finishes. The stream object itself is kept, so
+* `tee()`, `toReadableStream()` and `controller` keep working.
+*/
+const instrumentStream$2 = (stream, span, traceContent) => {
+	const originalIterator = stream[Symbol.asyncIterator].bind(stream);
+	const state = createStreamState$1();
+	let ended = false;
+	const end = (error) => {
+		if (ended) return;
+		ended = true;
+		safely$3(() => setStreamingResponseAttributes(span, state, traceContent));
+		if (error !== void 0) markSpanError$3(span, error);
+		else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+		span.end();
+	};
+	stream[Symbol.asyncIterator] = async function* () {
+		const iterable = { [Symbol.asyncIterator]: originalIterator };
+		try {
+			for await (const event of iterable) {
+				safely$3(() => processStreamEvent$1(state, event));
+				yield event;
+			}
+		} catch (error) {
+			end(error);
+			throw error;
+		} finally {
+			end();
+		}
+	};
 };
 //#endregion
-//#region src/opentelemetry-lib/instrumentation/kernel.ts
-const WRAPPED_BROWSER_METHODS = [
-	"create",
-	"retrieve",
-	"list",
-	"deleteByID",
-	"loadExtensions"
-];
-const WRAPPED_COMPUTER_METHODS = [
-	"captureScreenshot",
-	"clickMouse",
-	"dragMouse",
-	"moveMouse",
-	"pressKey",
-	"scroll",
-	"typeText"
-];
-const WRAPPED_PROCESS_METHODS = [
-	"exec",
-	"kill",
-	"spawn",
-	"status",
-	"stdin",
-	"stdoutStream"
-];
-var KernelInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
-	constructor() {
-		super("@lmnr/kernel-instrumentation", require_utils.version, { enabled: true });
-	}
-	init() {
-		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@onkernel/sdk", [">=0.7.0"], this.patch.bind(this), this.unpatch.bind(this));
-	}
-	manuallyInstrument(kernelModule) {
-		for (const wrappedMethod of WRAPPED_BROWSER_METHODS) this._wrap(kernelModule.Kernel.Browsers.prototype, wrappedMethod, this.patchMethod("Browser", wrappedMethod, "DEFAULT"));
-		for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) if (wrappedMethod === "captureScreenshot") this._wrap(kernelModule.Kernel.Browsers.Computer.prototype, wrappedMethod, this.patchTakeScreenshot());
-		else this._wrap(kernelModule.Kernel.Browsers.Computer.prototype, wrappedMethod, this.patchMethod("Computer", wrappedMethod, "TOOL"));
-		for (const wrappedMethod of WRAPPED_PROCESS_METHODS) this._wrap(kernelModule.Kernel.Browsers.Process.prototype, wrappedMethod, this.patchProcessMethod(wrappedMethod));
-		this._wrap(kernelModule.Kernel.prototype, "app", this.patchAppFactory());
+//#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 OPERATION_NAMES = {
+	chat: "chat",
+	completion: "text_completion",
+	rerank: "rerank",
+	embedding: "embeddings"
+};
+const V1_ROLES = {
+	USER: "user",
+	CHATBOT: "assistant",
+	SYSTEM: "system",
+	TOOL: "tool"
+};
+const asList = (value) => Array.isArray(value) ? value : [];
+const asInt = (value) => typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : void 0;
+const maybeJson = (value) => {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
 	}
-	patchMethod(className, method, spanType) {
-		const plugin = this;
+};
+const textPart = (text) => ({
+	type: "text",
+	content: typeof text === "string" ? text : JSON.stringify(text)
+});
+const imagePart = (url) => {
+	const comma = url.indexOf(",");
+	if (url.startsWith("data:") && comma !== -1) return {
+		type: "blob",
+		modality: "image",
+		mime_type: url.slice(5, comma).split(";")[0],
+		content: url.slice(comma + 1)
+	};
+	return {
+		type: "uri",
+		modality: "image",
+		uri: url
+	};
+};
+/**
+* Convert v2 message content (a string or a list of content items) into parts.
+*/
+const contentParts = (content) => {
+	if (typeof content === "string") return content ? [textPart(content)] : [];
+	const parts = [];
+	for (const item of asList(content)) {
+		if (typeof item === "string") {
+			if (item) parts.push(textPart(item));
+			continue;
+		}
+		if (!item || typeof item !== "object") continue;
+		const url = item.imageUrl?.url;
+		if (item.type === "text") parts.push(textPart(item.text ?? ""));
+		else if (item.type === "thinking") parts.push({
+			type: "thinking",
+			content: item.thinking ?? ""
+		});
+		else if (item.type === "image_url" && typeof url === "string") parts.push(imagePart(url));
+		else parts.push(item);
+	}
+	return parts;
+};
+/**
+* v2 tool message content: a string, or a list of text / document items.
+*/
+const toolResult = (content) => {
+	if (typeof content === "string") return content;
+	const results = asList(content).map((item) => {
+		if (item?.type === "text") return item.text;
+		if (item?.type === "document") return item.document?.data;
+		return item;
+	});
+	return results.length === 1 ? results[0] : results;
+};
+const v2ToolCallParts = (toolCalls) => asList(toolCalls).map((toolCall) => {
+	const part = {
+		type: "tool_call",
+		id: toolCall?.id ?? "",
+		name: toolCall?.function?.name ?? ""
+	};
+	const args = toolCall?.function?.arguments;
+	if (args !== void 0 && args !== null) part.arguments = maybeJson(args);
+	return part;
+});
+const v1ToolCallParts = (toolCalls) => asList(toolCalls).map((toolCall) => ({
+	type: "tool_call",
+	name: toolCall?.name ?? "",
+	arguments: toolCall?.parameters
+}));
+const v1ToolResultParts = (toolResults) => asList(toolResults).map((toolResult) => ({
+	type: "tool_call_response",
+	name: toolResult?.call?.name ?? "",
+	result: toolResult?.outputs
+}));
+const v1Message = (message) => {
+	const role = String(message?.role ?? "USER");
+	const parts = [];
+	if (message?.message) parts.push(textPart(message.message));
+	parts.push(...v1ToolCallParts(message?.toolCalls));
+	parts.push(...v1ToolResultParts(message?.toolResults));
+	return {
+		role: V1_ROLES[role.toUpperCase()] ?? role.toLowerCase(),
+		parts
+	};
+};
+const v2Message = (message) => {
+	const role = message?.role ?? "user";
+	if (role === "tool") return {
+		role: "tool",
+		parts: [{
+			type: "tool_call_response",
+			id: message?.toolCallId ?? "",
+			result: toolResult(message?.content)
+		}]
+	};
+	const parts = contentParts(message?.content);
+	if (message?.toolPlan) parts.push(textPart(message.toolPlan));
+	parts.push(...v2ToolCallParts(message?.toolCalls));
+	return {
+		role,
+		parts
+	};
+};
+const v1ChatInput = (params) => {
+	const messages = [];
+	if (params?.preamble) messages.push({
+		role: "system",
+		parts: [textPart(params.preamble)]
+	});
+	messages.push(...asList(params?.chatHistory).map(v1Message));
+	const toolResults = v1ToolResultParts(params?.toolResults);
+	if (toolResults.length > 0) messages.push({
+		role: "tool",
+		parts: toolResults
+	});
+	if (params?.message) messages.push({
+		role: "user",
+		parts: [textPart(params.message)]
+	});
+	return messages;
+};
+const rerankInput = (params) => {
+	const messages = asList(params?.documents).map((document) => {
+		const text = typeof document === "string" ? document : document?.text;
+		return {
+			role: "system",
+			parts: [textPart(text ?? document)]
+		};
+	});
+	if (params?.query) messages.push({
+		role: "user",
+		parts: [textPart(params.query)]
+	});
+	return messages;
+};
+const embedInput = (params) => {
+	const parts = [...asList(params?.texts).filter((text) => typeof text === "string").map(textPart), ...asList(params?.images).filter((image) => typeof image === "string").map(imagePart)];
+	for (const input of asList(params?.inputs)) parts.push(...contentParts(input?.content));
+	return parts.length > 0 ? [{
+		role: "user",
+		parts
+	}] : [];
+};
+const toolDefinitions = (tools) => asList(tools).map((tool) => {
+	const fn = tool?.function ?? tool;
+	const definition = { name: fn?.name };
+	if (fn?.description) definition.description = fn.description;
+	const parameters = fn?.parameters ?? fn?.parameterDefinitions;
+	if (parameters) definition.parameters = parameters;
+	return definition;
+});
+const setRequestAttributes$3 = (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);
+	safeSetAttribute$2(span, "gen_ai.request.max_tokens", asInt(params?.maxTokens));
+	safeSetAttribute$2(span, "gen_ai.request.temperature", params?.temperature);
+	safeSetAttribute$2(span, "gen_ai.request.top_p", params?.p);
+	safeSetAttribute$2(span, "gen_ai.request.top_k", params?.k);
+	safeSetAttribute$2(span, "gen_ai.request.frequency_penalty", params?.frequencyPenalty);
+	safeSetAttribute$2(span, "gen_ai.request.presence_penalty", params?.presencePenalty);
+	safeSetAttribute$2(span, "gen_ai.request.seed", asInt(params?.seed));
+	safeSetAttribute$2(span, "gen_ai.request.stop_sequences", asList(params?.stopSequences).filter((s) => typeof s === "string"));
+	span.setAttribute("llm.is_streaming", isStreaming);
+	if (!traceContent) return;
+	let messages;
+	if (requestType === "chat") {
+		messages = isV2 ? asList(params?.messages).map(v2Message) : v1ChatInput(params);
+		const tools = toolDefinitions(params?.tools);
+		if (tools.length > 0) span.setAttribute("gen_ai.tool.definitions", JSON.stringify(tools));
+	} else if (requestType === "completion") messages = params?.prompt ? [{
+		role: "user",
+		parts: [textPart(params.prompt)]
+	}] : [];
+	else if (requestType === "rerank") messages = rerankInput(params);
+	else messages = embedInput(params);
+	if (messages.length > 0) span.setAttribute(INPUT_MESSAGES$1, JSON.stringify(messages));
+};
+/**
+* `usage` (v2) / `meta` (v1): actual `tokens`, falling back to `billedUnits`.
+*/
+const setUsage = (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);
+	safeSetAttribute$2(span, "gen_ai.usage.output_tokens", outputTokens);
+	if (inputTokens !== void 0 || outputTokens !== void 0) span.setAttribute("llm.usage.total_tokens", (inputTokens ?? 0) + (outputTokens ?? 0));
+	safeSetAttribute$2(span, "gen_ai.usage.cache_read_input_tokens", asInt(usage?.cachedTokens));
+};
+const v1ChatOutput = (response) => {
+	const parts = [];
+	if (response?.text) parts.push(textPart(response.text));
+	parts.push(...v1ToolCallParts(response?.toolCalls));
+	return {
+		role: "assistant",
+		parts
+	};
+};
+const v2ChatOutput = (response) => ({
+	...v2Message(response?.message ?? {}),
+	role: "assistant"
+});
+const completionOutput = (response) => asList(response?.generations).map((generation) => ({
+	role: "assistant",
+	parts: [textPart(generation?.text ?? "")]
+}));
+const rerankOutput = (response) => {
+	const parts = asList(response?.results).map((result) => {
+		let text = `Doc ${result?.index}, Score: ${result?.relevanceScore}`;
+		if (result?.document?.text) text += `\n${result.document.text}`;
+		return textPart(text);
+	});
+	return parts.length > 0 ? [{
+		role: "assistant",
+		parts
+	}] : [];
+};
+const setResponseAttributes$3 = (span, response, requestType, isV2, traceContent) => {
+	safeSetAttribute$2(span, "gen_ai.response.id", response?.responseId ?? response?.id);
+	setUsage(span, response?.usage ?? response?.meta);
+	let output = [];
+	if (requestType === "chat") {
+		const message = isV2 ? v2ChatOutput(response) : v1ChatOutput(response);
+		if (response?.finishReason) {
+			const finishReason = String(response.finishReason);
+			message.finish_reason = finishReason;
+			span.setAttribute("gen_ai.response.finish_reasons", [finishReason]);
+		}
+		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));
+};
+/**
+* v1 `chatStream`: the `stream-end` event carries the full response.
+*/
+const createV1ChatStreamAccumulator = () => {
+	let final;
+	let text = "";
+	const toolCalls = [];
+	return {
+		add: (event) => {
+			if (event?.eventType === "text-generation") text += event.text ?? "";
+			else if (event?.eventType === "tool-calls-generation") toolCalls.push(...asList(event.toolCalls));
+			else if (event?.eventType === "stream-end") final = event.response;
+		},
+		response: () => final ?? {
+			text,
+			toolCalls
+		}
+	};
+};
+/**
+* v2 `chatStream`: rebuilds a `V2ChatResponse`-shaped object from the events.
+*/
+const createV2ChatStreamAccumulator = () => {
+	let id;
+	let toolPlan = "";
+	let finishReason;
+	let usage;
+	const content = /* @__PURE__ */ new Map();
+	const toolCalls = /* @__PURE__ */ new Map();
+	const indexOf = (event, items, isNew) => {
+		if (typeof event?.index === "number") return event.index;
+		if (isNew || items.size === 0) return items.size;
+		return Math.max(...items.keys());
+	};
+	const sorted = (items) => [...items.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+	return {
+		add: (event) => {
+			const message = event?.delta?.message;
+			switch (event?.type) {
+				case "message-start":
+					id = event.id ?? id;
+					break;
+				case "content-start":
+					content.set(indexOf(event, content, true), {
+						type: message?.content?.type ?? "text",
+						text: message?.content?.text ?? "",
+						thinking: message?.content?.thinking ?? ""
+					});
+					break;
+				case "content-delta": {
+					const index = indexOf(event, content, false);
+					const item = content.get(index) ?? {
+						type: "text",
+						text: "",
+						thinking: ""
+					};
+					item.text += message?.content?.text ?? "";
+					item.thinking += message?.content?.thinking ?? "";
+					content.set(index, item);
+					break;
+				}
+				case "tool-plan-delta":
+					toolPlan += message?.toolPlan ?? "";
+					break;
+				case "tool-call-start":
+					toolCalls.set(indexOf(event, toolCalls, true), {
+						id: message?.toolCalls?.id ?? "",
+						type: "function",
+						function: {
+							name: message?.toolCalls?.function?.name ?? "",
+							arguments: message?.toolCalls?.function?.arguments ?? ""
+						}
+					});
+					break;
+				case "tool-call-delta": {
+					const index = indexOf(event, toolCalls, false);
+					const toolCall = toolCalls.get(index) ?? {
+						id: "",
+						type: "function",
+						function: {
+							name: "",
+							arguments: ""
+						}
+					};
+					toolCall.function.arguments += message?.toolCalls?.function?.arguments ?? "";
+					toolCalls.set(index, toolCall);
+					break;
+				}
+				case "message-end":
+					id = event.id ?? id;
+					finishReason = event.delta?.finishReason;
+					usage = event.delta?.usage;
+			}
+		},
+		response: () => ({
+			id,
+			finishReason,
+			usage,
+			message: {
+				role: "assistant",
+				content: sorted(content).map((item) => item.type === "thinking" ? {
+					type: "thinking",
+					thinking: item.thinking
+				} : {
+					type: "text",
+					text: item.text
+				}),
+				toolPlan: toolPlan || void 0,
+				toolCalls: sorted(toolCalls)
+			}
+		})
+	};
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/cohere/index.ts
+const logger$18 = require_utils.initializeLogger();
+const PATCH_DATA_SYMBOL$2 = Symbol("lmnr.cohere.patchData");
+const SPAN_NAMES = {
+	chat: "cohere.chat",
+	completion: "cohere.completion",
+	rerank: "cohere.rerank",
+	embedding: "cohere.embed"
+};
+const V1_METHODS = [
+	{
+		method: "chat",
+		requestType: "chat",
+		streaming: false
+	},
+	{
+		method: "chatStream",
+		requestType: "chat",
+		streaming: true
+	},
+	{
+		method: "generate",
+		requestType: "completion",
+		streaming: false
+	},
+	{
+		method: "rerank",
+		requestType: "rerank",
+		streaming: false
+	},
+	{
+		method: "embed",
+		requestType: "embedding",
+		streaming: false
+	}
+];
+const V2_METHODS = [
+	{
+		method: "chat",
+		requestType: "chat",
+		streaming: false
+	},
+	{
+		method: "chatStream",
+		requestType: "chat",
+		streaming: true
+	},
+	{
+		method: "rerank",
+		requestType: "rerank",
+		streaming: false
+	},
+	{
+		method: "embed",
+		requestType: "embedding",
+		streaming: false
+	}
+];
+const ownPatchData = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL$2)?.value;
+const markSpanError$2 = (span, error) => {
+	span.recordException(error);
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.setStatus({
+		code: _opentelemetry_api.SpanStatusCode.ERROR,
+		message: error?.message
+	});
+};
+/**
+* Attribute extraction must never break the user's call.
+*/
+const safely$2 = (fn) => {
+	try {
+		fn();
+	} catch (error) {
+		logger$18.debug(`Failed to set cohere span attributes: ${String(error)}`);
+	}
+};
+const isAsyncIterable$2 = (value) => value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+/**
+* The prototype in `proto`'s chain that defines `method`, so subclasses
+* (`CohereClient` is a thin `CustomClient` subclass) share one wrapper.
+*/
+const definingPrototype = (proto, method) => {
+	for (let p = proto; p && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
+		const descriptor = Object.getOwnPropertyDescriptor(p, method);
+		if (descriptor) return typeof descriptor.value === "function" ? p : void 0;
+	}
+};
+/**
+* Resolve the `cohere-ai` module namespace from the namespace itself or its
+* default export (ESM default import of the CJS package).
+*/
+const resolveModule = (mod) => {
+	for (const candidate of [mod, mod?.default]) if (typeof candidate?.CohereClient === "function") return candidate;
+};
+/**
+* `V2Client` is not exported from the package root, so read its prototype
+* off a throwaway client: `CohereClient#v2` (lazy getter) or
+* `CohereClientV2#clientV2`. Constructing a client does no I/O.
+*/
+const v2ClientPrototype = (mod) => {
+	const probes = [() => new mod.CohereClient({ token: "lmnr" }).v2, () => new mod.CohereClientV2({ token: "lmnr" }).clientV2];
+	for (const probe of probes) try {
+		const client = probe();
+		if (client && typeof client === "object") return Object.getPrototypeOf(client);
+	} catch {}
+};
+/**
+* Instruments `cohere-ai`: v1 `chat`, `chatStream`, `generate`, `rerank` and
+* `embed` on `CohereClient`, and v2 `chat`, `chatStream`, `rerank` and
+* `embed` on `V2Client` (behind `CohereClientV2` and `CohereClient#v2`).
+*
+* `CohereClientV2` binds its methods as instance fields in its constructor,
+* so clients created before instrumentation are not traced.
+*/
+var CohereInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/cohere-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("cohere-ai", [">=7.0.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	/**
+	* Accepts the `cohere-ai` module namespace (`import * as cohere from
+	* "cohere-ai"`) or its default export.
+	*/
+	manuallyInstrument(module) {
+		if (!resolveModule(module)) {
+			_opentelemetry_api.diag.warn("Could not find CohereClient in cohere manual instrumentation input. Pass the cohere-ai module.");
+			return;
+		}
+		_opentelemetry_api.diag.debug("Manually instrumenting cohere-ai");
+		this.patch(module);
+	}
+	patch(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching cohere-ai");
+		for (const { proto, specs, isV2 } of this.targets(moduleExports)) for (const spec of specs) this.patchMethod(definingPrototype(proto, spec.method), spec, isV2);
+		return moduleExports;
+	}
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching cohere-ai");
+		for (const { proto, specs } of this.targets(moduleExports)) for (const { method } of specs) {
+			const owner = definingPrototype(proto, method);
+			const patched = owner && ownPatchData(owner);
+			if (!patched?.[method]) continue;
+			owner[method] = patched[method].original;
+			delete patched[method];
+		}
+	}
+	targets(moduleExports) {
+		const mod = resolveModule(moduleExports);
+		if (!mod) return [];
+		const v1 = mod.CohereClient.prototype;
+		const v2 = v2ClientPrototype(mod);
+		const targets = [{
+			proto: v1,
+			specs: V1_METHODS,
+			isV2: false
+		}];
+		if (v2 && definingPrototype(v2, "chat") !== definingPrototype(v1, "chat")) targets.push({
+			proto: v2,
+			specs: V2_METHODS,
+			isV2: true
+		});
+		return targets;
+	}
+	/**
+	* Replace `proto[method]` with a traced wrapper. Re-patching an already
+	* patched method only refreshes `traceContent`, so repeated initialization
+	* never double-wraps.
+	*/
+	patchMethod(proto, spec, isV2) {
+		if (!proto) return;
+		let patched = ownPatchData(proto);
+		if (patched?.[spec.method]) {
+			patched[spec.method].traceContent = this.traceContent;
+			return;
+		}
+		if (!patched) {
+			patched = {};
+			Object.defineProperty(proto, PATCH_DATA_SYMBOL$2, {
+				value: patched,
+				writable: true,
+				configurable: true,
+				enumerable: false
+			});
+		}
+		const patchData = {
+			...spec,
+			isV2,
+			traceContent: this.traceContent,
+			original: proto[spec.method]
+		};
+		patched[spec.method] = patchData;
+		proto[spec.method] = wrapMethod$1(patchData);
+	}
+};
+const wrapMethod$1 = (patchData) => function(request, ...rest) {
+	const { original, requestType, streaming, isV2 } = patchData;
+	if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.call(this, request, ...rest);
+	const traceContent = patchData.traceContent;
+	const span = Laminar.startSpan({
+		name: SPAN_NAMES[requestType],
+		spanType: "LLM"
+	});
+	safely$2(() => setRequestAttributes$3(span, request, requestType, isV2, streaming, traceContent));
+	let result;
+	try {
+		result = Laminar.withSpan(span, () => ({ value: original.call(this, request, ...rest) })).value;
+	} catch (error) {
+		markSpanError$2(span, error);
+		span.end();
+		throw error;
+	}
+	let ended = false;
+	const fail = (error) => {
+		if (ended) return;
+		ended = true;
+		markSpanError$2(span, error);
+		span.end();
+	};
+	const succeed = (data) => {
+		if (ended) return data;
+		ended = true;
+		if (streaming && isAsyncIterable$2(data)) {
+			const accumulator = isV2 ? createV2ChatStreamAccumulator() : createV1ChatStreamAccumulator();
+			instrumentStream$1(data, span, accumulator, isV2, traceContent);
+			return data;
+		}
+		safely$2(() => setResponseAttributes$3(span, data, requestType, isV2, traceContent));
+		span.end();
+		return data;
+	};
+	const rethrow = (error) => {
+		fail(error);
+		throw error;
+	};
+	if (typeof result?.withRawResponse === "function" && typeof result.constructor?.fromPromise === "function") return result.constructor.fromPromise(result.withRawResponse().then((raw) => ({
+		...raw,
+		data: succeed(raw?.data)
+	}), rethrow));
+	if (typeof result?.then === "function") return result.then(succeed, rethrow);
+	return succeed(result);
+};
+/**
+* Aggregate the events of an SDK `Stream` as the caller iterates it, and end
+* the span when iteration finishes, fails, or is abandoned early.
+*/
+const instrumentStream$1 = (stream, span, accumulator, isV2, traceContent) => {
+	const originalIterator = stream[Symbol.asyncIterator].bind(stream);
+	let ended = false;
+	const end = (error) => {
+		if (ended) return;
+		ended = true;
+		safely$2(() => setResponseAttributes$3(span, accumulator.response(), "chat", isV2, traceContent));
+		if (error !== void 0) markSpanError$2(span, error);
+		else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+		span.end();
+	};
+	stream[Symbol.asyncIterator] = async function* () {
+		const iterable = { [Symbol.asyncIterator]: originalIterator };
+		try {
+			for await (const event of iterable) {
+				safely$2(() => accumulator.add(event));
+				yield event;
+			}
+		} catch (error) {
+			end(error);
+			throw error;
+		} finally {
+			end();
+		}
+	};
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/google-aiplatform/utils.ts
+const VERTEX_AI_SYSTEM = "vertex_ai";
+const VALUE_KINDS = [
+	"stringValue",
+	"numberValue",
+	"boolValue",
+	"structValue",
+	"listValue",
+	"nullValue"
+];
+/**
+* Decode a `google.protobuf.Value` (either a protobufjs message instance or
+* a plain object, e.g. produced by `aiplatform.helpers.toValue`) into a plain
+* JS value. Unset oneof members on protobufjs messages default to `null`, so
+* we prefer the `kind` virtual field when it is available.
+*/
+const fromValue = (value) => {
+	if (value === null || value === void 0 || typeof value !== "object") return value;
+	const kind = typeof value.kind === "string" ? value.kind : VALUE_KINDS.find((k) => value[k] !== void 0 && value[k] !== null);
+	switch (kind) {
+		case "stringValue":
+		case "numberValue":
+		case "boolValue": return value[kind];
+		case "structValue": return Object.fromEntries(Object.entries(value.structValue?.fields ?? {}).map(([k, v]) => [k, fromValue(v)]));
+		case "listValue": return (value.listValue?.values ?? []).map(fromValue);
+		case "nullValue": return null;
+		default: return;
+	}
+};
+const asRecord = (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.
+* `projects/p/locations/l/publishers/google/models/text-bison` -> `text-bison`.
+*/
+const lastPathSegment = (value) => {
+	if (typeof value !== "string" || value.length === 0) return void 0;
+	return value.split("/").pop() || void 0;
+};
+const toInputMessages = (instance) => {
+	const messages = [];
+	if (typeof instance.context === "string" && instance.context.length > 0) messages.push({
+		role: "system",
+		content: instance.context
+	});
+	if (typeof instance.prompt === "string") messages.push({
+		role: "user",
+		content: instance.prompt
+	});
+	if (Array.isArray(instance.messages)) for (const message of instance.messages) {
+		const record = asRecord(message);
+		if (!record) continue;
+		const author = typeof record.author === "string" ? record.author : "user";
+		messages.push({
+			role: author === "bot" ? "assistant" : author,
+			content: record.content
+		});
+	}
+	return messages;
+};
+/**
+* Set request attributes on a span from a `PredictionServiceClient.predict`
+* request (PaLM-style text / chat models served through Vertex AI).
+*/
+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));
+	if (parameters) {
+		safeSetAttribute$2(span, "gen_ai.request.max_tokens", asNumber(parameters.maxOutputTokens));
+		safeSetAttribute$2(span, "gen_ai.request.temperature", asNumber(parameters.temperature));
+		safeSetAttribute$2(span, "gen_ai.request.top_p", asNumber(parameters.topP));
+		safeSetAttribute$2(span, "gen_ai.request.top_k", asNumber(parameters.topK));
+	}
+	if (!traceContent || !Array.isArray(request?.instances)) return;
+	const messages = request.instances.flatMap((instance) => {
+		const record = asRecord(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));
+	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;
+	if (typeof firstCandidate?.content === "string") return firstCandidate.content;
+};
+/**
+* Set response attributes on a span from a `PredictResponse`.
+*/
+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);
+	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);
+	if (!traceContent || !Array.isArray(response.predictions)) return;
+	const outputMessages = response.predictions.map(predictionContent).filter((content) => content !== void 0).map((content) => ({
+		role: "assistant",
+		content
+	}));
+	if (outputMessages.length > 0) safeSetAttribute$2(span, "gen_ai.output.messages", JSON.stringify(outputMessages));
+};
+/**
+* Reshape a Vertex AI `GenerativeModel` request into the
+* `{model, contents, config}` form the google-genai helpers understand.
+* Request-level `generationConfig`, `systemInstruction`, and `tools` fully
+* override the model-level ones, mirroring the Vertex AI SDK.
+*/
+const toGenAiParams = (model, request) => {
+	const isStringRequest = typeof request === "string";
+	const req = isStringRequest ? {} : request ?? {};
+	return {
+		model: lastPathSegment(model?.model),
+		contents: isStringRequest ? request : req.contents,
+		config: {
+			...req.generationConfig ?? model?.generationConfig ?? {},
+			systemInstruction: req.systemInstruction ?? model?.systemInstruction,
+			tools: req.tools ?? model?.tools
+		}
+	};
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/google-aiplatform/index.ts
+const logger$17 = require_utils.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 GENERATIVE_MODEL_CLASSES = ["GenerativeModel", "GenerativeModelPreview"];
+const markSpanError$1 = (span, error) => {
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+};
+/**
+* Attribute extraction must never break the user's call.
+*/
+const safely$1 = (fn) => {
+	try {
+		fn();
+	} catch (error) {
+		logger$17.debug(`Failed to set google-aiplatform span attributes: ${String(error)}`);
+	}
+};
+/**
+* Instruments Google Cloud Vertex AI:
+* - `@google-cloud/vertexai`: `GenerativeModel` (and `GenerativeModelPreview`)
+*   `generateContent` / `generateContentStream`.
+* - `@google-cloud/aiplatform`: `PredictionServiceClient.predict`.
+*/
+var GoogleAIPlatformInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/google-aiplatform-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return [new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@google-cloud/vertexai", [">=1.1.0"], this.patchVertexAI.bind(this), this.unpatchVertexAI.bind(this)), new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@google-cloud/aiplatform", [">=3.10.0"], this.patchAIPlatform.bind(this), this.unpatchAIPlatform.bind(this))];
+	}
+	/**
+	* Accepts the `@google-cloud/vertexai` module (or its `GenerativeModel`
+	* class) and/or the `@google-cloud/aiplatform` module (or its
+	* `PredictionServiceClient` class).
+	*/
+	manuallyInstrument(module) {
+		const modules = Array.isArray(module) ? module : [module];
+		for (const mod of modules) if (this.isVertexAIModule(mod)) {
+			_opentelemetry_api.diag.debug("Manually instrumenting @google-cloud/vertexai");
+			this.patchVertexAI(mod);
+		} else if (this.isAIPlatformModule(mod)) {
+			_opentelemetry_api.diag.debug("Manually instrumenting @google-cloud/aiplatform");
+			this.patchAIPlatform(mod);
+		} else if (typeof mod?.prototype?.generateContent === "function") {
+			_opentelemetry_api.diag.debug("Manually instrumenting Vertex AI GenerativeModel class");
+			this.patchGenerativeModelClass(mod);
+		} else if (typeof mod?.prototype?.predict === "function") {
+			_opentelemetry_api.diag.debug("Manually instrumenting PredictionServiceClient class");
+			this.patchPredictionServiceClass(mod);
+		} else _opentelemetry_api.diag.warn("Could not find GenerativeModel or PredictionServiceClient in google_aiplatform manual instrumentation input. Pass the @google-cloud/vertexai or @google-cloud/aiplatform module.");
+	}
+	isVertexAIModule(mod) {
+		return typeof mod?.GenerativeModel === "function";
+	}
+	isAIPlatformModule(mod) {
+		return typeof mod?.PredictionServiceClient === "function";
+	}
+	patchVertexAI(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching @google-cloud/vertexai");
+		for (const className of GENERATIVE_MODEL_CLASSES) {
+			const cls = moduleExports?.[className];
+			if (typeof cls === "function") this.patchGenerativeModelClass(cls);
+		}
+		return moduleExports;
+	}
+	unpatchVertexAI(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @google-cloud/vertexai");
+		for (const className of GENERATIVE_MODEL_CLASSES) {
+			const cls = moduleExports?.[className];
+			if (typeof cls === "function") this.unpatchMethods(cls.prototype);
+		}
+	}
+	patchAIPlatform(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching @google-cloud/aiplatform");
+		for (const cls of this.predictionServiceClasses(moduleExports)) this.patchPredictionServiceClass(cls);
+		return moduleExports;
+	}
+	unpatchAIPlatform(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @google-cloud/aiplatform");
+		for (const cls of this.predictionServiceClasses(moduleExports)) this.unpatchMethods(cls.prototype);
+	}
+	predictionServiceClasses(moduleExports) {
+		const classes = [
+			moduleExports?.PredictionServiceClient,
+			moduleExports?.v1?.PredictionServiceClient,
+			moduleExports?.v1beta1?.PredictionServiceClient
+		].filter((cls) => typeof cls === "function");
+		return [...new Set(classes)];
+	}
+	patchGenerativeModelClass(cls) {
+		this.patchMethod(cls.prototype, "generateContent", (original, data) => this.wrapGenerateContent(original, data));
+		this.patchMethod(cls.prototype, "generateContentStream", (original, data) => this.wrapGenerateContentStream(original, data));
+	}
+	patchPredictionServiceClass(cls) {
+		this.patchMethod(cls.prototype, "predict", (original, data) => this.wrapPredict(original, data));
+	}
+	/**
+	* Replace `proto[method]` with a traced wrapper. Re-patching an already
+	* patched prototype only refreshes `traceContent`, so repeated
+	* initialization never double-wraps.
+	*/
+	patchMethod(proto, method, makeWrapper) {
+		if (!proto || typeof proto[method] !== "function") return;
+		if (!hasOwnPatchData$1(proto)) Object.defineProperty(proto, PATCH_DATA_SYMBOL$1, {
+			value: {},
+			writable: true,
+			configurable: true,
+			enumerable: false
+		});
+		const patches = proto[PATCH_DATA_SYMBOL$1];
+		const existing = patches[method];
+		if (existing) {
+			existing.traceContent = this.traceContent;
+			return;
+		}
+		const patchData = {
+			traceContent: this.traceContent,
+			original: proto[method]
+		};
+		patches[method] = patchData;
+		proto[method] = makeWrapper(patchData.original, patchData);
+	}
+	unpatchMethods(proto) {
+		if (!proto || !hasOwnPatchData$1(proto)) return;
+		const patches = proto[PATCH_DATA_SYMBOL$1];
+		for (const [method, patchData] of Object.entries(patches)) proto[method] = patchData.original;
+		delete proto[PATCH_DATA_SYMBOL$1];
+	}
+	wrapGenerateContent(original, patchData) {
+		return function(request, ...rest) {
+			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.call(this, request, ...rest);
+			const span = Laminar.startSpan({
+				name: "vertexai.generate_content",
+				spanType: "LLM"
+			});
+			const params = toGenAiParams(this, request);
+			safely$1(() => setRequestAttributes$5(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
+			return Laminar.withSpan(span, async () => {
+				try {
+					const result = await original.call(this, request, ...rest);
+					safely$1(() => setGenerateContentResponseAttributes(span, result?.response, params.model, patchData.traceContent));
+					return result;
+				} catch (error) {
+					markSpanError$1(span, error);
+					throw error;
+				}
+			}, true);
+		};
+	}
+	wrapGenerateContentStream(original, patchData) {
+		return async function(request, ...rest) {
+			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.call(this, request, ...rest);
+			const span = Laminar.startSpan({
+				name: "vertexai.generate_content_stream",
+				spanType: "LLM"
+			});
+			const params = toGenAiParams(this, request);
+			safely$1(() => setRequestAttributes$5(span, params, patchData.traceContent, VERTEX_AI_SYSTEM));
+			let result;
+			try {
+				result = await Laminar.withSpan(span, () => original.call(this, request, ...rest));
+			} catch (error) {
+				markSpanError$1(span, error);
+				span.end();
+				throw error;
+			}
+			const aggregated = result?.response;
+			if (aggregated && typeof aggregated.then === "function") aggregated.then((response) => {
+				safely$1(() => setGenerateContentResponseAttributes(span, response, params.model, patchData.traceContent));
+				span.end();
+			}, (error) => {
+				span.recordException(error);
+				markSpanError$1(span, error);
+				span.end();
+			});
+			else span.end();
+			return result;
+		};
+	}
+	wrapPredict(original, patchData) {
+		return function(...args) {
+			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.apply(this, args);
+			const span = Laminar.startSpan({
+				name: "aiplatform.predict",
+				spanType: "LLM"
+			});
+			safely$1(() => setPredictRequestAttributes(span, args[0], patchData.traceContent));
+			const callbackIndex = args.length - 1;
+			const callback = args[callbackIndex];
+			if (typeof callback === "function") {
+				const wrappedArgs = [...args];
+				wrappedArgs[callbackIndex] = function(error, response, ...rest) {
+					if (error) {
+						span.recordException(error);
+						markSpanError$1(span, error);
+					} else safely$1(() => setPredictResponseAttributes(span, response, patchData.traceContent));
+					span.end();
+					return callback.call(this, error, response, ...rest);
+				};
+				try {
+					return Laminar.withSpan(span, () => original.apply(this, wrappedArgs));
+				} catch (error) {
+					markSpanError$1(span, error);
+					span.end();
+					throw error;
+				}
+			}
+			return Laminar.withSpan(span, async () => {
+				try {
+					const result = await original.apply(this, args);
+					safely$1(() => setPredictResponseAttributes(span, Array.isArray(result) ? result[0] : result, patchData.traceContent));
+					return result;
+				} catch (error) {
+					markSpanError$1(span, error);
+					throw error;
+				}
+			}, true);
+		};
+	}
+};
+const setGenerateContentResponseAttributes = (span, response, requestModel, traceContent) => {
+	setResponseAttributes$5(span, response, traceContent);
+	if (!response?.modelVersion) safeSetAttribute$2(span, "gen_ai.response.model", requestModel);
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/google-genai/index.ts
+const WRAPPED_SYMBOL$1 = Symbol("lmnr.google-genai.wrapped");
+const CLASS_PATCH_DATA_SYMBOL = Symbol("lmnr.google-genai.classPatchData");
+var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/google-genai-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@google/genai", [">=1.0.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	manuallyInstrument(genaiModule) {
+		_opentelemetry_api.diag.debug("Manually instrumenting @google/genai");
+		const GoogleGenAIClass = this.resolveGoogleGenAIClass(genaiModule);
+		if (GoogleGenAIClass) this.patchGoogleGenAIClass(GoogleGenAIClass);
+		else _opentelemetry_api.diag.warn("Could not find GoogleGenAI class in google_genai manual instrumentation input. Pass either GoogleGenAI class or module object with GoogleGenAI export.");
+	}
+	patch(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching @google/genai");
+		const GoogleGenAIClass = this.resolveGoogleGenAIClass(moduleExports);
+		if (GoogleGenAIClass) this.patchGoogleGenAIClass(GoogleGenAIClass);
+		return moduleExports;
+	}
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @google/genai");
+		const GoogleGenAIClass = this.resolveGoogleGenAIClass(moduleExports);
+		if (GoogleGenAIClass) this.unpatchGoogleGenAIClass(GoogleGenAIClass);
+	}
+	resolveGoogleGenAIClass(moduleOrClass) {
+		if (typeof moduleOrClass === "function") return moduleOrClass;
+		if (moduleOrClass?.GoogleGenAI && typeof moduleOrClass.GoogleGenAI === "function") return moduleOrClass.GoogleGenAI;
+	}
+	patchGoogleGenAIClass(GoogleGenAIClass) {
+		const classPatchData = GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
+		if (classPatchData) {
+			classPatchData.instrumentation = this;
+			classPatchData.traceContent = this.traceContent;
+			return;
+		}
+		const originalModelsDescriptor = Object.getOwnPropertyDescriptor(GoogleGenAIClass.prototype, "models");
+		if (originalModelsDescriptor && !originalModelsDescriptor.configurable) {
+			_opentelemetry_api.diag.warn("Could not patch GoogleGenAI.prototype.models: descriptor is non-configurable.");
+			return;
+		}
+		const patchData = {
+			instrumentation: this,
+			traceContent: this.traceContent,
+			originalModelsDescriptor
+		};
+		Object.defineProperty(GoogleGenAIClass, CLASS_PATCH_DATA_SYMBOL, {
+			value: patchData,
+			writable: true,
+			configurable: true,
+			enumerable: false
+		});
+		Object.defineProperty(GoogleGenAIClass.prototype, "models", {
+			configurable: true,
+			enumerable: originalModelsDescriptor?.enumerable ?? true,
+			get: function() {
+				if (originalModelsDescriptor?.get) return originalModelsDescriptor.get.call(this);
+			},
+			set: function(value) {
+				patchData.instrumentation.patchModelsInstance(value, patchData);
+				if (originalModelsDescriptor?.set) {
+					originalModelsDescriptor.set.call(this, value);
+					return;
+				}
+				Object.defineProperty(this, "models", {
+					value,
+					writable: true,
+					configurable: true,
+					enumerable: true
+				});
+			}
+		});
+	}
+	unpatchGoogleGenAIClass(GoogleGenAIClass) {
+		const classPatchData = GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
+		if (!classPatchData) return;
+		if (classPatchData.originalModelsDescriptor) Object.defineProperty(GoogleGenAIClass.prototype, "models", classPatchData.originalModelsDescriptor);
+		else delete GoogleGenAIClass.prototype.models;
+		delete GoogleGenAIClass[CLASS_PATCH_DATA_SYMBOL];
+	}
+	patchModelsInstance(models, classPatchData) {
+		if (!models || typeof models !== "object") return;
+		if (typeof models.generateContent !== "function") return;
+		if (typeof models.generateContentStream !== "function") return;
+		if (models[WRAPPED_SYMBOL$1]) return;
+		const originalGenerateContent = models.generateContent.bind(models);
+		const originalGenerateContentStream = models.generateContentStream.bind(models);
+		models.generateContent = async function(params) {
+			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return originalGenerateContent(params);
+			const span = Laminar.startSpan({
+				name: "gemini.generate_content",
+				spanType: "LLM"
+			});
+			setRequestAttributes$5(span, params, classPatchData.traceContent);
+			return Laminar.withSpan(span, async () => {
+				try {
+					const response = await originalGenerateContent(params);
+					setResponseAttributes$5(span, response, classPatchData.traceContent);
+					return response;
+				} catch (error) {
+					span.setAttribute("error.type", error.constructor?.name ?? "Error");
+					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+					throw error;
+				}
+			}, true);
+		};
+		models.generateContentStream = async function(params) {
+			if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return originalGenerateContentStream(params);
+			const span = Laminar.startSpan({
+				name: "gemini.generate_content_stream",
+				spanType: "LLM"
+			});
+			setRequestAttributes$5(span, params, classPatchData.traceContent);
+			try {
+				return wrapStreamingResponse(span, await originalGenerateContentStream(params), classPatchData.traceContent);
+			} catch (error) {
+				span.setAttribute("error.type", error.constructor?.name ?? "Error");
+				span.recordException(error);
+				span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+				span.end();
+				throw error;
+			}
+		};
+		models[WRAPPED_SYMBOL$1] = true;
+	}
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/kernel.ts
+const WRAPPED_BROWSER_METHODS = [
+	"create",
+	"retrieve",
+	"list",
+	"deleteByID",
+	"loadExtensions"
+];
+const WRAPPED_COMPUTER_METHODS = [
+	"captureScreenshot",
+	"clickMouse",
+	"dragMouse",
+	"moveMouse",
+	"pressKey",
+	"scroll",
+	"typeText"
+];
+const WRAPPED_PROCESS_METHODS = [
+	"exec",
+	"kill",
+	"spawn",
+	"status",
+	"stdin",
+	"stdoutStream"
+];
+var KernelInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor() {
+		super("@lmnr/kernel-instrumentation", require_utils.version, { enabled: true });
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@onkernel/sdk", [">=0.7.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	manuallyInstrument(kernelModule) {
+		for (const wrappedMethod of WRAPPED_BROWSER_METHODS) this._wrap(kernelModule.Kernel.Browsers.prototype, wrappedMethod, this.patchMethod("Browser", wrappedMethod, "DEFAULT"));
+		for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) if (wrappedMethod === "captureScreenshot") this._wrap(kernelModule.Kernel.Browsers.Computer.prototype, wrappedMethod, this.patchTakeScreenshot());
+		else this._wrap(kernelModule.Kernel.Browsers.Computer.prototype, wrappedMethod, this.patchMethod("Computer", wrappedMethod, "TOOL"));
+		for (const wrappedMethod of WRAPPED_PROCESS_METHODS) this._wrap(kernelModule.Kernel.Browsers.Process.prototype, wrappedMethod, this.patchProcessMethod(wrappedMethod));
+		this._wrap(kernelModule.Kernel.prototype, "app", this.patchAppFactory());
+	}
+	patchMethod(className, method, spanType) {
+		const plugin = this;
 		return (original) => async function(...args) {
 			return await observe({
 				name: `${className}.${method}`,
@@ -5096,100 +6481,950 @@ var KernelInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 		this.manuallyInstrument(moduleExports);
 		return moduleExports;
 	}
-	unpatch(moduleExports) {
-		_opentelemetry_api.diag.debug("Unpatching @onkernel/sdk");
-		for (const wrappedMethod of WRAPPED_BROWSER_METHODS) this._unwrap(moduleExports.Kernel.Browsers.prototype, wrappedMethod);
-		for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) this._unwrap(moduleExports.Kernel.Browsers.Computer.prototype, wrappedMethod);
-		for (const wrappedMethod of WRAPPED_PROCESS_METHODS) this._unwrap(moduleExports.Kernel.Browsers.Process.prototype, wrappedMethod);
-		this._unwrap(moduleExports.Kernel.prototype, "app");
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @onkernel/sdk");
+		for (const wrappedMethod of WRAPPED_BROWSER_METHODS) this._unwrap(moduleExports.Kernel.Browsers.prototype, wrappedMethod);
+		for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) this._unwrap(moduleExports.Kernel.Browsers.Computer.prototype, wrappedMethod);
+		for (const wrappedMethod of WRAPPED_PROCESS_METHODS) this._unwrap(moduleExports.Kernel.Browsers.Process.prototype, wrappedMethod);
+		this._unwrap(moduleExports.Kernel.prototype, "app");
+	}
+};
+const DISABLE_OPENAI_RESPONSES_INSTRUMENTATION_CONTEXT_KEY = (0, _opentelemetry_api.createContextKey)("LMNR_DISABLE_OPENAI_RESPONSES_INSTRUMENTATION");
+const systemInstructionsStorage = new async_hooks.AsyncLocalStorage();
+const getCurrentSystemInstructions = () => systemInstructionsStorage.getStore();
+const runWithSystemInstructions = (value, fn) => systemInstructionsStorage.run(value, fn);
+const wrapStreamWithSystemInstructions = (value, source) => ({ [Symbol.asyncIterator]() {
+	let iterator;
+	const getIterator = () => {
+		if (iterator === void 0) iterator = systemInstructionsStorage.run(value, () => source[Symbol.asyncIterator]());
+		return iterator;
+	};
+	return {
+		next: (..._args) => systemInstructionsStorage.run(value, () => getIterator().next()),
+		return: (returnValue) => {
+			const it = getIterator();
+			return it.return ? systemInstructionsStorage.run(value, () => it.return(returnValue)) : Promise.resolve({
+				done: true,
+				value: returnValue
+			});
+		},
+		throw: (err) => {
+			const it = getIterator();
+			return it.throw ? systemInstructionsStorage.run(value, () => it.throw(err)) : Promise.reject(err);
+		}
+	};
+} });
+const spanKind = (spanData) => {
+	if (spanData == null) return "";
+	return typeof spanData.type === "string" ? spanData.type : "";
+};
+const spanName = (span, spanData) => {
+	const name = span?.name;
+	if (typeof name === "string" && name) return name;
+	const kind = spanKind(spanData);
+	if (kind) {
+		if (kind === "agent" || kind === "custom" || kind === "function" || kind === "tool") return nameFromSpanData(spanData) || `agents.${kind}`;
+		return `agents.${kind}`;
+	}
+	return "agents.span";
+};
+const mapSpanType = (spanData) => {
+	const kind = spanKind(spanData);
+	if (kind === "generation" || kind === "response" || kind === "transcription" || kind === "speech" || kind === "speech_group") return "LLM";
+	if (kind === "function" || kind === "tool" || kind === "mcp_list_tools" || kind === "mcp_tools" || kind === "handoff") return "TOOL";
+	return "DEFAULT";
+};
+const nameFromSpanData = (agent) => {
+	if (agent == null) return "";
+	if (typeof agent === "string") return agent;
+	if (typeof agent === "object") {
+		if (typeof agent.name === "string") return agent.name;
+	}
+	return "";
+};
+const getFirstNotNull = (d, ...keys) => {
+	if (d == null) return;
+	for (const key of keys) {
+		const v = d[key];
+		if (v !== void 0 && v !== null) return v;
+	}
+};
+const modelAsDict = (obj) => {
+	if (obj == null) return;
+	if (typeof obj !== "object") return;
+	if (Array.isArray(obj)) return;
+	return obj;
+};
+const normalizeMessages = (data, role = "user") => {
+	if (data == null) return [];
+	if (typeof data === "string") return [{
+		role,
+		content: data
+	}];
+	if (Array.isArray(data)) {
+		const messages = [];
+		for (const item of data) if (item != null && typeof item === "object" && !Array.isArray(item)) messages.push(item);
+		else messages.push({
+			role,
+			content: String(item)
+		});
+		return messages;
+	}
+	if (typeof data === "object") return [data];
+	return [{
+		role,
+		content: String(data)
+	}];
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/openai/utils.ts
+const INPUT_MESSAGES = "gen_ai.input.messages";
+const OUTPUT_MESSAGES = "gen_ai.output.messages";
+const TOOL_DEFINITIONS = "gen_ai.tool.definitions";
+const STRUCTURED_OUTPUT_SCHEMA = "gen_ai.request.structured_output_schema";
+const toJson = (value) => {
+	if (value === void 0 || value === null) return void 0;
+	return JSON.stringify(value);
+};
+/**
+* Base URL of the client behind a resource instance. openai >= 4 resources
+* hold the client in `_client`; the v3 `OpenAIApi` keeps `basePath` itself.
+*/
+const getBaseUrl = (instance) => {
+	const baseUrl = instance?._client?.baseURL ?? instance?.basePath ?? instance?.configuration?.basePath;
+	return typeof baseUrl === "string" ? baseUrl : void 0;
+};
+const getVendorFromUrl = (baseUrl) => {
+	if (!baseUrl) return "openai";
+	if (baseUrl.includes("openai.azure.com")) return "Azure";
+	if (baseUrl.includes("amazonaws.com") || baseUrl.includes("bedrock")) return "AWS";
+	if (baseUrl.includes("googleapis.com") || baseUrl.includes("vertex")) return "Google";
+	if (baseUrl.includes("openrouter.ai")) return "OpenRouter";
+	return "openai";
+};
+/**
+* Bedrock model ids carry a vendor (`anthropic.claude-...`) and optionally a
+* cross-region prefix (`us.anthropic.claude-...`); keep only the model.
+*/
+const crossRegionCheck = (model) => {
+	if (!model.includes(".")) return model;
+	const parts = model.split(".");
+	if ([
+		"us",
+		"us-gov",
+		"eu",
+		"apac"
+	].includes(parts[0])) return parts.length > 2 ? parts.slice(2).join(".") : model;
+	return parts.slice(1).join(".");
+};
+/**
+* Client attributes shared by every span: the vendor (from the base URL) as
+* `gen_ai.system`, the base URL itself and, for Azure, the API version.
+*/
+const setClientAttributes = (span, instance) => {
+	const baseUrl = getBaseUrl(instance);
+	const vendor = getVendorFromUrl(baseUrl);
+	safeSetAttribute$2(span, "gen_ai.system", vendor);
+	safeSetAttribute$2(span, "gen_ai.request.base_url", baseUrl);
+	const client = instance?._client;
+	safeSetAttribute$2(span, "gen_ai.openai.api_version", client?.apiVersion ?? client?._options?.defaultQuery?.["api-version"]);
+	return vendor;
+};
+const extractStructuredOutputSchema = (params) => {
+	const responseFormat = params?.response_format;
+	if (responseFormat?.type === "json_schema") return toJson(responseFormat.json_schema?.schema);
+};
+/**
+* Request attributes common to chat and legacy completions.
+*/
+const setRequestAttributes$2 = (span, params, instance) => {
+	const vendor = setClientAttributes(span, instance);
+	let model = params?.model;
+	if (vendor === "AWS" && typeof model === "string") model = crossRegionCheck(model);
+	safeSetAttribute$2(span, "gen_ai.request.model", model);
+	safeSetAttribute$2(span, "gen_ai.request.max_tokens", params?.max_tokens);
+	safeSetAttribute$2(span, "gen_ai.request.temperature", params?.temperature);
+	safeSetAttribute$2(span, "gen_ai.request.top_p", params?.top_p);
+	safeSetAttribute$2(span, "gen_ai.request.frequency_penalty", params?.frequency_penalty);
+	safeSetAttribute$2(span, "gen_ai.request.presence_penalty", params?.presence_penalty);
+	safeSetAttribute$2(span, "llm.user", params?.user);
+	span.setAttribute("llm.is_streaming", Boolean(params?.stream));
+	safeSetAttribute$2(span, "gen_ai.request.reasoning_effort", params?.reasoning_effort);
+	safeSetAttribute$2(span, "openai.request.service_tier", params?.service_tier);
+	safeSetAttribute$2(span, STRUCTURED_OUTPUT_SCHEMA, extractStructuredOutputSchema(params));
+};
+const setChatPromptAttributes = (span, params) => {
+	safeSetAttribute$2(span, INPUT_MESSAGES, toJson(params?.messages));
+	safeSetAttribute$2(span, TOOL_DEFINITIONS, toJson(params?.functions ?? params?.tools));
+};
+const setCompletionPromptAttributes = (span, params) => {
+	const prompt = params?.prompt;
+	if (prompt !== void 0 && prompt !== null) safeSetAttribute$2(span, INPUT_MESSAGES, toJson((Array.isArray(prompt) ? prompt : [prompt]).map((content) => ({
+		role: "user",
+		content
+	}))));
+	safeSetAttribute$2(span, TOOL_DEFINITIONS, toJson(params?.functions));
+};
+const setEmbeddingsPromptAttributes = (span, params) => {
+	const input = params?.input;
+	if (input === void 0 || input === null) return;
+	safeSetAttribute$2(span, INPUT_MESSAGES, toJson((Array.isArray(input) ? input : [input]).map((content) => ({ content }))));
+};
+/**
+* Response attributes for chat completions, legacy completions and
+* embeddings (and accumulated stream responses, which share the shape).
+*/
+const setResponseAttributes$2 = (span, response) => {
+	if (!response || typeof response !== "object") return;
+	if (response.error) {
+		safeSetAttribute$2(span, "gen_ai.prompt.prompt_error", toJson(response.error));
+		return;
+	}
+	safeSetAttribute$2(span, "gen_ai.response.model", response.model);
+	safeSetAttribute$2(span, "gen_ai.response.id", response.id);
+	safeSetAttribute$2(span, "openai.response.system_fingerprint", response.system_fingerprint);
+	safeSetAttribute$2(span, "gen_ai.prompt.prompt_filter_results", toJson(response.prompt_filter_results));
+	safeSetAttribute$2(span, "openai.response.service_tier", response.service_tier);
+	const usage = response.usage;
+	if (!usage || typeof usage !== "object") return;
+	span.setAttribute("llm.usage.total_tokens", usage.total_tokens ?? 0);
+	span.setAttribute("gen_ai.usage.output_tokens", usage.completion_tokens ?? 0);
+	span.setAttribute("gen_ai.usage.input_tokens", usage.prompt_tokens ?? 0);
+	span.setAttribute("gen_ai.usage.cache_read_input_tokens", usage.prompt_tokens_details?.cached_tokens ?? 0);
+	if (usage.completion_tokens_details) span.setAttribute("gen_ai.usage.reasoning_tokens", usage.completion_tokens_details.reasoning_tokens ?? 0);
+};
+const setChoicesAttributes = (span, response) => {
+	if (Array.isArray(response?.choices)) safeSetAttribute$2(span, OUTPUT_MESSAGES, toJson(response.choices));
+};
+/**
+* Fold a chat completion chunk into the accumulated `ChatCompletion`.
+*/
+const accumulateChatChunk = (complete, chunk) => {
+	if (!chunk || typeof chunk !== "object") return;
+	complete.id ??= chunk.id;
+	complete.model ??= chunk.model;
+	complete.created ??= chunk.created;
+	complete.service_tier = chunk.service_tier ?? complete.service_tier;
+	complete.system_fingerprint = chunk.system_fingerprint ?? complete.system_fingerprint;
+	if (chunk.prompt_filter_results) complete.prompt_filter_results = chunk.prompt_filter_results;
+	const usage = chunk.usage ?? chunk.choices?.[0]?.usage;
+	if (usage) complete.usage = usage;
+	for (const choice of chunk.choices ?? []) {
+		const index = choice.index ?? 0;
+		complete.choices[index] ??= {
+			index,
+			message: {
+				role: "",
+				content: ""
+			}
+		};
+		const target = complete.choices[index];
+		if (choice.finish_reason) target.finish_reason = choice.finish_reason;
+		if (choice.content_filter_results) target.content_filter_results = choice.content_filter_results;
+		const delta = choice.delta ?? {};
+		if (delta.role) target.message.role = delta.role;
+		if (delta.content) target.message.content += delta.content;
+		if (delta.refusal) target.message.refusal = (target.message.refusal ?? "") + delta.refusal;
+		if (delta.function_call) {
+			target.message.function_call ??= {
+				name: "",
+				arguments: ""
+			};
+			target.message.function_call.name += delta.function_call.name ?? "";
+			target.message.function_call.arguments += delta.function_call.arguments ?? "";
+		}
+		for (const toolCall of delta.tool_calls ?? []) {
+			target.message.tool_calls ??= [];
+			const toolIndex = toolCall.index ?? 0;
+			target.message.tool_calls[toolIndex] ??= {
+				id: "",
+				type: "function",
+				function: {
+					name: "",
+					arguments: ""
+				}
+			};
+			const call = target.message.tool_calls[toolIndex];
+			if (toolCall.id) call.id = toolCall.id;
+			if (toolCall.function?.name) call.function.name = toolCall.function.name;
+			call.function.arguments += toolCall.function?.arguments ?? "";
+		}
+	}
+};
+/**
+* Fold a legacy completion chunk into the accumulated `Completion`.
+*/
+const accumulateCompletionChunk = (complete, chunk) => {
+	if (!chunk || typeof chunk !== "object") return;
+	complete.id ??= chunk.id;
+	complete.model ??= chunk.model;
+	complete.created ??= chunk.created;
+	if (chunk.usage) complete.usage = chunk.usage;
+	for (const choice of chunk.choices ?? []) {
+		const index = choice.index ?? 0;
+		complete.choices[index] ??= {
+			index,
+			text: ""
+		};
+		const target = complete.choices[index];
+		target.text += choice.text ?? "";
+		if (choice.finish_reason) target.finish_reason = choice.finish_reason;
+	}
+};
+/**
+* `decisions.create` request attributes.
+*/
+const setDecisionRequestAttributes = (span, params, instance, traceContent) => {
+	setClientAttributes(span, instance);
+	safeSetAttribute$2(span, "gen_ai.request.model", params?.model);
+	safeSetAttribute$2(span, "llm.user", params?.safety_identifier);
+	if (!traceContent) return;
+	const input = params?.input;
+	if (typeof input === "string") safeSetAttribute$2(span, INPUT_MESSAGES, toJson([{
+		role: "user",
+		content: input
+	}]));
+	else if (Array.isArray(input)) safeSetAttribute$2(span, INPUT_MESSAGES, toJson(input));
+	if (Array.isArray(params?.questions)) safeSetAttribute$2(span, STRUCTURED_OUTPUT_SCHEMA, toJson(params.questions));
+};
+const setDecisionResponseAttributes = (span, response, traceContent) => {
+	if (!response || typeof response !== "object") return;
+	safeSetAttribute$2(span, "gen_ai.response.model", response.model);
+	const usage = response.usage;
+	if (usage && typeof usage === "object") {
+		safeSetAttribute$2(span, "gen_ai.usage.input_tokens", usage.input_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.output_tokens", usage.output_tokens);
+		safeSetAttribute$2(span, "llm.usage.total_tokens", usage.total_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.cache_read_input_tokens", usage.input_tokens_details?.cached_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.cache_creation_input_tokens", usage.input_tokens_details?.cache_write_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.reasoning_tokens", usage.output_tokens_details?.reasoning_tokens);
+	}
+	if (traceContent && Array.isArray(response.answers)) safeSetAttribute$2(span, OUTPUT_MESSAGES, toJson([{
+		role: "assistant",
+		content: toJson(response.answers)
+	}]));
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/openai/responses.ts
+const RESPONSE_SPAN_NAME = "openai.response";
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"incomplete",
+	"failed",
+	"cancelled"
+]);
+const pendingResponses = /* @__PURE__ */ new Map();
+const recordedResponses = /* @__PURE__ */ new Set();
+const MAX_RECORDED_RESPONSES = 1e3;
+const markRecorded = (responseId) => {
+	if (!responseId) return;
+	recordedResponses.delete(responseId);
+	recordedResponses.add(responseId);
+	if (recordedResponses.size > MAX_RECORDED_RESPONSES) {
+		const [oldest] = recordedResponses;
+		recordedResponses.delete(oldest);
+	}
+};
+const createStreamState = () => ({
+	outputText: "",
+	outputBlocks: {}
+});
+const getFunctionTools = (params) => Array.isArray(params?.tools) ? params.tools.filter((tool) => tool?.type === "function") : [];
+const outputBlocksOf = (response) => {
+	const blocks = {};
+	if (!Array.isArray(response?.output)) return blocks;
+	response.output.forEach((block, index) => {
+		blocks[block?.id ?? `output_${index}`] = block;
+	});
+	return blocks;
+};
+/**
+* Data for a call that produced no response to read from (a request error,
+* or a stream that ended before any snapshot), merged with anything stashed
+* under `params.response_id`.
+*/
+const tracedDataFromRequest = (startTime, params) => {
+	const responseId = params?.response_id ?? "";
+	const existing = pendingResponses.get(responseId);
+	const tools = getFunctionTools(params);
+	return {
+		startTime: existing?.startTime ?? startTime,
+		responseId,
+		input: params?.input ?? existing?.input,
+		instructions: params?.instructions ?? existing?.instructions,
+		tools: tools.length ? tools : existing?.tools,
+		outputBlocks: { ...existing?.outputBlocks },
+		outputText: existing?.outputText,
+		usage: existing?.usage,
+		requestModel: params?.model ?? existing?.requestModel,
+		responseModel: existing?.responseModel,
+		requestReasoningSummary: params?.reasoning?.summary ?? existing?.requestReasoningSummary,
+		requestReasoningEffort: params?.reasoning?.effort ?? existing?.requestReasoningEffort,
+		requestServiceTier: params?.service_tier ?? existing?.requestServiceTier
+	};
+};
+/**
+* Merge a response into the data stashed under its id: request fields prefer
+* the stash (a `retrieve` carries no request body), response fields and
+* output blocks prefer the new response.
+*/
+const tracedDataFromResponse = (startTime, response, params) => {
+	const responseId = response?.id;
+	if (!responseId) return void 0;
+	const existing = pendingResponses.get(responseId);
+	const tools = [...existing?.tools ?? [], ...getFunctionTools(params)];
+	return {
+		startTime: existing?.startTime ?? startTime,
+		responseId,
+		input: existing?.input ?? params?.input,
+		instructions: existing?.instructions ?? params?.instructions,
+		tools: tools.length ? tools : void 0,
+		outputBlocks: {
+			...existing?.outputBlocks,
+			...outputBlocksOf(response)
+		},
+		outputText: response.output_text || existing?.outputText,
+		usage: response.usage ?? existing?.usage,
+		requestModel: existing?.requestModel ?? params?.model,
+		responseModel: response.model ?? existing?.responseModel,
+		requestReasoningSummary: existing?.requestReasoningSummary ?? params?.reasoning?.summary,
+		requestReasoningEffort: existing?.requestReasoningEffort ?? params?.reasoning?.effort,
+		requestServiceTier: existing?.requestServiceTier ?? params?.service_tier,
+		responseServiceTier: response.service_tier ?? existing?.responseServiceTier
+	};
+};
+const buildInputMessages = (data) => {
+	const messages = [];
+	if (typeof data.instructions === "string" && data.instructions) messages.push({
+		role: "system",
+		content: data.instructions
+	});
+	if (typeof data.input === "string") messages.push({
+		role: "user",
+		content: data.input
+	});
+	else if (Array.isArray(data.input)) for (const item of data.input) messages.push(item && typeof item === "object" && !("type" in item) ? {
+		...item,
+		type: "message"
+	} : item);
+	return messages.length ? messages : void 0;
+};
+const buildOutputMessages = (data) => {
+	const blocks = Object.values(data.outputBlocks).filter(Boolean);
+	if (!blocks.length && data.outputText) return [{
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: data.outputText
+		}]
+	}];
+	return blocks;
+};
+const setDataAttributes = (span, data, instance, traceContent) => {
+	setClientAttributes(span, instance);
+	safeSetAttribute$2(span, "gen_ai.request.model", data.requestModel);
+	safeSetAttribute$2(span, "gen_ai.response.id", data.responseId);
+	safeSetAttribute$2(span, "gen_ai.response.model", data.responseModel);
+	const usage = data.usage;
+	if (usage && typeof usage === "object") {
+		safeSetAttribute$2(span, "gen_ai.usage.input_tokens", usage.input_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.output_tokens", usage.output_tokens);
+		safeSetAttribute$2(span, "llm.usage.total_tokens", usage.total_tokens);
+		safeSetAttribute$2(span, "gen_ai.usage.cache_read_input_tokens", usage.input_tokens_details?.cached_tokens);
+		span.setAttribute("gen_ai.usage.reasoning_tokens", usage.output_tokens_details?.reasoning_tokens ?? 0);
+	}
+	safeSetAttribute$2(span, "gen_ai.request.reasoning_summary", data.requestReasoningSummary);
+	safeSetAttribute$2(span, "gen_ai.request.reasoning_effort", data.requestReasoningEffort);
+	safeSetAttribute$2(span, "openai.request.service_tier", data.requestServiceTier);
+	safeSetAttribute$2(span, "openai.response.service_tier", data.responseServiceTier);
+	if (traceContent) {
+		safeSetAttribute$2(span, INPUT_MESSAGES, toJson(buildInputMessages(data)));
+		safeSetAttribute$2(span, OUTPUT_MESSAGES, toJson(buildOutputMessages(data)));
+		safeSetAttribute$2(span, TOOL_DEFINITIONS, toJson(data.tools));
+	}
+};
+const isDuplicate = (responseId, options) => Boolean(options.isRetrieve) && recordedResponses.has(responseId);
+const startResponseSpan = (data, options) => {
+	const span = Laminar.startSpan({
+		name: RESPONSE_SPAN_NAME,
+		spanType: "LLM",
+		startTime: data.startTime,
+		context: options.parentContext
+	});
+	setDataAttributes(span, data, options.instance, options.traceContent);
+	return span;
+};
+const markFailed = (span, message) => {
+	span.recordException(new Error(message));
+	span.setStatus({
+		code: _opentelemetry_api.SpanStatusCode.ERROR,
+		message
+	});
+};
+const failureMessage = (response) => {
+	switch (response?.status) {
+		case "failed": return response.error?.message ?? "Response failed";
+		case "cancelled": return "Response cancelled";
+		default: return;
+	}
+};
+/**
+* A `create` / `retrieve` that returned a response object. The span is
+* emitted once the response is final; until then (background mode) its
+* request data waits in the stash.
+*/
+const processResponse = (startTime, response, params, options) => {
+	const data = tracedDataFromResponse(startTime, response, params);
+	if (!data) return;
+	const status = response?.status;
+	if (status && !TERMINAL_STATUSES.has(status)) {
+		pendingResponses.set(data.responseId, data);
+		return;
+	}
+	pendingResponses.delete(data.responseId);
+	if (isDuplicate(data.responseId, options)) return;
+	markRecorded(data.responseId);
+	const span = startResponseSpan(data, options);
+	const failure = failureMessage(response);
+	if (failure !== void 0) markFailed(span, failure);
+	else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+	span.end();
+};
+/**
+* Start the span of a call that failed before returning a response; the
+* caller records the error and ends it.
+*/
+const processRequestError = (startTime, params, options) => {
+	const data = tracedDataFromRequest(startTime, params);
+	pendingResponses.delete(data.responseId);
+	return startResponseSpan(data, options);
+};
+/**
+* `cancel` of a background response we were tracking: emit its span.
+*/
+const processCancel = (response, options) => {
+	const responseId = response?.id;
+	const existing = responseId ? pendingResponses.get(responseId) : void 0;
+	if (!existing) return;
+	pendingResponses.delete(responseId);
+	markRecorded(responseId);
+	const data = tracedDataFromResponse(existing.startTime, response, {}) ?? existing;
+	const span = startResponseSpan(data, options);
+	markFailed(span, "Response cancelled");
+	span.end();
+};
+/**
+* Fold one `ResponseStreamEvent` into the stream state.
+*/
+const processStreamEvent = (state, event) => {
+	switch (event?.type) {
+		case "response.output_text.delta":
+			state.outputText += event.delta ?? "";
+			break;
+		case "response.output_item.done":
+			if (event.item) state.outputBlocks[event.item.id ?? `output_${event.output_index}`] = event.item;
+			break;
+		case "error": state.errorMessage = event.message ?? "Response stream error";
+	}
+	if (event?.response && typeof event.response === "object") state.snapshot = event.response;
+};
+/**
+* Emit the span of a finished (or abandoned) stream. Returns the span so the
+* caller can record a thrown iteration error before ending it, or undefined
+* when no span is due: the stream re-read a response that already has one,
+* or it left a background response unfinished, which is stashed for the
+* `retrieve` / `cancel` that sees it finish.
+*/
+const finishStream = (startTime, state, params, options) => {
+	const snapshot = state.snapshot;
+	if (isDuplicate(snapshot?.id ?? params?.response_id ?? "", options)) return;
+	let data = snapshot && tracedDataFromResponse(startTime, snapshot, params) || tracedDataFromRequest(startTime, params);
+	data = {
+		...data,
+		outputBlocks: {
+			...state.outputBlocks,
+			...data.outputBlocks
+		},
+		outputText: data.outputText || state.outputText || void 0
+	};
+	if (snapshot && data.responseId) {
+		if ((params?.background || options.isRetrieve) && !TERMINAL_STATUSES.has(snapshot.status) && state.errorMessage === void 0) {
+			pendingResponses.set(data.responseId, data);
+			return;
+		}
+		pendingResponses.delete(data.responseId);
+		markRecorded(data.responseId);
+	}
+	const span = startResponseSpan(data, options);
+	const failure = state.errorMessage ?? failureMessage(snapshot);
+	if (failure !== void 0) markFailed(span, failure);
+	else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+	return span;
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/openai/index.ts
+const logger$16 = require_utils.initializeLogger();
+const PATCH_DATA_SYMBOL = Symbol("lmnr.openai.patchData");
+const hasOwnPatchData = (proto) => Object.getOwnPropertyDescriptor(proto, PATCH_DATA_SYMBOL) !== void 0;
+const markSpanError = (span, error) => {
+	span.recordException(error);
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+};
+/**
+* Attribute extraction must never break the user's call.
+*/
+const safely = (fn) => {
+	try {
+		fn();
+	} catch (error) {
+		logger$16.debug(`Failed to set openai span attributes: ${String(error)}`);
+	}
+};
+const isAsyncIterable$1 = (value) => value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+/**
+* Calls made by the OpenAI Agents SDK are already traced by its trace
+* processor, which sets this key around the model call.
+*/
+const isDisabledByAgents = () => Boolean(LaminarContextManager.getContext().getValue(DISABLE_OPENAI_RESPONSES_INSTRUMENTATION_CONTEXT_KEY) ?? _opentelemetry_api.context.active().getValue(DISABLE_OPENAI_RESPONSES_INSTRUMENTATION_CONTEXT_KEY));
+const stripUndefined = (value) => {
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+};
+/**
+* Wrap the events of an SDK `Stream` as the caller iterates them. The stream
+* object itself is kept, so `tee()`, `toReadableStream()`, `controller` and
+* the SDK's stream helpers (`ChatCompletionStream`, `ResponseStream`) keep
+* working. `onDone` runs exactly once: on completion, on an iteration error,
+* or when the caller stops early.
+*/
+const instrumentStream = (stream, onEvent, onDone) => {
+	let done = false;
+	const finish = (error) => {
+		if (done) return;
+		done = true;
+		onDone(error);
+	};
+	const wrap = (makeIterator) => async function* () {
+		const iterable = { [Symbol.asyncIterator]: makeIterator };
+		try {
+			for await (const event of iterable) {
+				safely(() => onEvent(event));
+				yield event;
+			}
+		} catch (error) {
+			finish(error);
+			throw error;
+		} finally {
+			finish();
+		}
+	};
+	if (typeof stream.iterator === "function") {
+		stream.iterator = wrap(stream.iterator);
+		return;
+	}
+	stream[Symbol.asyncIterator] = wrap(stream[Symbol.asyncIterator].bind(stream));
+};
+/**
+* Hand the result of the original call to `succeed` / `fail`. An
+* `APIPromise` stays one, so the caller keeps `withResponse()` /
+* `asResponse()`.
+*/
+const settle = (result, succeed, fail) => {
+	if (typeof result?._thenUnwrap === "function") {
+		const responsePromise = typeof result._responseProps === "function" ? result._responseProps() : result.responsePromise;
+		if (typeof responsePromise?.then === "function") responsePromise.then(void 0, fail);
+		return result._thenUnwrap(succeed);
+	}
+	if (typeof result?.then === "function") return result.then(succeed, (error) => {
+		fail(error);
+		throw error;
+	});
+	return succeed(result);
+};
+const setChatRequest = (span, params, instance, traceContent) => {
+	setRequestAttributes$2(span, params, instance);
+	if (traceContent) setChatPromptAttributes(span, params);
+};
+const setCompletionRequest = (span, params, instance, traceContent) => {
+	setRequestAttributes$2(span, params, instance);
+	if (traceContent) setCompletionPromptAttributes(span, params);
+};
+const setChoicesResponse = (span, response, traceContent) => {
+	setResponseAttributes$2(span, response);
+	if (traceContent && !response?.error) setChoicesAttributes(span, response);
+};
+const CHAT = {
+	spanName: "openai.chat",
+	skipForAgents: true,
+	setRequest: setChatRequest,
+	setResponse: setChoicesResponse,
+	accumulate: accumulateChatChunk
+};
+const COMPLETION = {
+	spanName: "openai.completion",
+	setRequest: setCompletionRequest,
+	setResponse: setChoicesResponse,
+	accumulate: accumulateCompletionChunk
+};
+const EMBEDDINGS = {
+	spanName: "openai.embeddings",
+	setRequest: (span, params, instance, traceContent) => {
+		setRequestAttributes$2(span, params, instance);
+		if (traceContent) setEmbeddingsPromptAttributes(span, params);
+	},
+	setResponse: (span, response) => setResponseAttributes$2(span, response)
+};
+const DECISION = {
+	spanName: "openai.decision",
+	setRequest: setDecisionRequestAttributes,
+	setResponse: setDecisionResponseAttributes
+};
+const unwrapAxiosBody = (result) => result?.data;
+const V3_CHAT = {
+	...CHAT,
+	accumulate: void 0,
+	unwrapBody: unwrapAxiosBody
+};
+const V3_COMPLETION = {
+	...COMPLETION,
+	accumulate: void 0,
+	unwrapBody: unwrapAxiosBody
+};
+const wrapMethod = (patchData, handler) => function(params, ...rest) {
+	const { original } = patchData;
+	if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active()) || handler.skipForAgents && isDisabledByAgents()) return original.call(this, params, ...rest);
+	const traceContent = patchData.traceContent;
+	const span = Laminar.startSpan({
+		name: handler.spanName,
+		spanType: "LLM"
+	});
+	safely(() => handler.setRequest(span, params, this, traceContent));
+	let result;
+	try {
+		result = Laminar.withSpan(span, () => ({ value: original.call(this, params, ...rest) })).value;
+	} catch (error) {
+		markSpanError(span, error);
+		span.end();
+		throw error;
+	}
+	let ended = false;
+	const fail = (error) => {
+		if (ended) return;
+		ended = true;
+		markSpanError(span, error);
+		span.end();
+	};
+	const succeed = (data) => {
+		if (ended) return data;
+		ended = true;
+		const body = handler.unwrapBody ? handler.unwrapBody(data) : data;
+		if (params?.stream) {
+			const { accumulate } = handler;
+			if (accumulate && isAsyncIterable$1(body)) {
+				const complete = { choices: [] };
+				instrumentStream(body, (chunk) => accumulate(complete, chunk), (error) => {
+					safely(() => handler.setResponse(span, complete, traceContent));
+					if (error !== void 0) markSpanError(span, error);
+					else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+					span.end();
+				});
+				return data;
+			}
+		} else safely(() => handler.setResponse(span, body, traceContent));
+		span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
+		span.end();
+		return data;
+	};
+	return settle(result, succeed, fail);
+};
+const responsesParams = (kind, args) => {
+	switch (kind) {
+		case "create": return stripUndefined(args[0]) ?? {};
+		case "retrieve": return {
+			response_id: args[0],
+			...stripUndefined(args[1] ?? {})
+		};
+		case "cancel": return { response_id: args[0] };
 	}
 };
-const DISABLE_OPENAI_RESPONSES_INSTRUMENTATION_CONTEXT_KEY = (0, _opentelemetry_api.createContextKey)("LMNR_DISABLE_OPENAI_RESPONSES_INSTRUMENTATION");
-const systemInstructionsStorage = new async_hooks.AsyncLocalStorage();
-const getCurrentSystemInstructions = () => systemInstructionsStorage.getStore();
-const runWithSystemInstructions = (value, fn) => systemInstructionsStorage.run(value, fn);
-const wrapStreamWithSystemInstructions = (value, source) => ({ [Symbol.asyncIterator]() {
-	let iterator;
-	const getIterator = () => {
-		if (iterator === void 0) iterator = systemInstructionsStorage.run(value, () => source[Symbol.asyncIterator]());
-		return iterator;
+/**
+* `responses.create` / `retrieve` / `cancel`. Unlike the other APIs, the
+* span is built after the fact from the final response (see
+* `responses.ts`), so a background response spans from its `create` to the
+* `retrieve` / `cancel` that sees it finish.
+*/
+const wrapResponsesMethod = (patchData, kind) => function(...args) {
+	const { original } = patchData;
+	if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active()) || isDisabledByAgents()) return original.apply(this, args);
+	const startTime = (0, _opentelemetry_core.hrTime)();
+	const params = responsesParams(kind, args);
+	const options = {
+		instance: this,
+		traceContent: patchData.traceContent,
+		parentContext: LaminarContextManager.getContext(),
+		isRetrieve: kind === "retrieve"
 	};
-	return {
-		next: (..._args) => systemInstructionsStorage.run(value, () => getIterator().next()),
-		return: (returnValue) => {
-			const it = getIterator();
-			return it.return ? systemInstructionsStorage.run(value, () => it.return(returnValue)) : Promise.resolve({
-				done: true,
-				value: returnValue
-			});
-		},
-		throw: (err) => {
-			const it = getIterator();
-			return it.throw ? systemInstructionsStorage.run(value, () => it.throw(err)) : Promise.reject(err);
-		}
+	let ended = false;
+	const fail = (error) => {
+		if (ended || kind === "cancel") return;
+		ended = true;
+		safely(() => {
+			const span = processRequestError(startTime, params, options);
+			markSpanError(span, error);
+			span.end();
+		});
 	};
-} });
-const spanKind = (spanData) => {
-	if (spanData == null) return "";
-	return typeof spanData.type === "string" ? spanData.type : "";
-};
-const spanName = (span, spanData) => {
-	const name = span?.name;
-	if (typeof name === "string" && name) return name;
-	const kind = spanKind(spanData);
-	if (kind) {
-		if (kind === "agent" || kind === "custom" || kind === "function" || kind === "tool") return nameFromSpanData(spanData) || `agents.${kind}`;
-		return `agents.${kind}`;
+	const succeed = (data) => {
+		if (ended) return data;
+		ended = true;
+		if (kind === "cancel") safely(() => processCancel(data, options));
+		else if (isAsyncIterable$1(data)) {
+			const state = createStreamState();
+			instrumentStream(data, (event) => processStreamEvent(state, event), (error) => safely(() => {
+				const span = finishStream(startTime, state, params, options);
+				if (!span) return;
+				if (error !== void 0) markSpanError(span, error);
+				span.end();
+			}));
+		} else safely(() => processResponse(startTime, data, params, options));
+		return data;
+	};
+	let result;
+	try {
+		result = original.apply(this, args);
+	} catch (error) {
+		fail(error);
+		throw error;
 	}
-	return "agents.span";
+	return settle(result, succeed, fail);
 };
-const mapSpanType = (spanData) => {
-	const kind = spanKind(spanData);
-	if (kind === "generation" || kind === "response" || kind === "transcription" || kind === "speech" || kind === "speech_group") return "LLM";
-	if (kind === "function" || kind === "tool" || kind === "mcp_list_tools" || kind === "mcp_tools" || kind === "handoff") return "TOOL";
-	return "DEFAULT";
+/**
+* Resolve the `OpenAI` client class from the module namespace, its default
+* export, or the class itself.
+*/
+const resolveClientClass = (mod) => {
+	for (const candidate of [
+		mod?.OpenAI,
+		mod?.default,
+		mod
+	]) if (typeof candidate?.Chat?.Completions === "function") return candidate;
 };
-const nameFromSpanData = (agent) => {
-	if (agent == null) return "";
-	if (typeof agent === "string") return agent;
-	if (typeof agent === "object") {
-		if (typeof agent.name === "string") return agent.name;
-	}
-	return "";
+/**
+* Resolve the openai v3 `OpenAIApi` class from the module namespace, its
+* default export, or the class itself.
+*/
+const resolveV3ApiClass = (mod) => {
+	for (const candidate of [
+		mod?.OpenAIApi,
+		mod?.default?.OpenAIApi,
+		mod
+	]) if (typeof candidate?.prototype?.createChatCompletion === "function") return candidate;
 };
-const getFirstNotNull = (d, ...keys) => {
-	if (d == null) return;
-	for (const key of keys) {
-		const v = d[key];
-		if (v !== void 0 && v !== null) return v;
+const handlerTarget = (proto, method, handler) => ({
+	proto,
+	method,
+	wrap: (patchData) => wrapMethod(patchData, handler)
+});
+const responsesTarget = (proto, kind) => ({
+	proto,
+	method: kind,
+	wrap: (patchData) => wrapResponsesMethod(patchData, kind)
+});
+/**
+* Everything to patch in the given module; prototypes are undefined where
+* the installed SDK version lacks the resource.
+*/
+const patchTargets = (moduleExports) => {
+	const client = resolveClientClass(moduleExports);
+	if (client) {
+		const responses = client.Responses?.prototype;
+		return [
+			handlerTarget(client.Chat?.Completions?.prototype, "create", CHAT),
+			handlerTarget(client.Completions?.prototype, "create", COMPLETION),
+			handlerTarget(client.Embeddings?.prototype, "create", EMBEDDINGS),
+			handlerTarget(client.Decisions?.prototype, "create", DECISION),
+			responsesTarget(responses, "create"),
+			responsesTarget(responses, "retrieve"),
+			responsesTarget(responses, "cancel")
+		];
 	}
+	const v3Api = resolveV3ApiClass(moduleExports)?.prototype;
+	if (v3Api) return [handlerTarget(v3Api, "createChatCompletion", V3_CHAT), handlerTarget(v3Api, "createCompletion", V3_COMPLETION)];
+	return [];
 };
-const modelAsDict = (obj) => {
-	if (obj == null) return;
-	if (typeof obj !== "object") return;
-	if (Array.isArray(obj)) return;
-	return obj;
-};
-const normalizeMessages = (data, role = "user") => {
-	if (data == null) return [];
-	if (typeof data === "string") return [{
-		role,
-		content: data
-	}];
-	if (Array.isArray(data)) {
-		const messages = [];
-		for (const item of data) if (item != null && typeof item === "object" && !Array.isArray(item)) messages.push(item);
-		else messages.push({
-			role,
-			content: String(item)
+/**
+* Instruments the `openai` package:
+* - openai >= 4: `chat.completions.create`, `completions.create`,
+*   `embeddings.create`, `decisions.create` and `responses.create` /
+*   `retrieve` / `cancel`. `chat.completions.parse()` / `stream()` /
+*   `runTools()` and `responses.parse()` / `stream()` delegate to `create`,
+*   so they are traced through it without nesting a second span.
+* - openai v3: `OpenAIApi#createChatCompletion` / `createCompletion`.
+*/
+var OpenAIInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/openai-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("openai", [">=3.1.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	/**
+	* Accepts the `openai` module namespace or the `OpenAI` class (the
+	* module's default export). For openai v3, the module or its `OpenAIApi`
+	* class.
+	*/
+	manuallyInstrument(module) {
+		if (!patchTargets(module).length) {
+			_opentelemetry_api.diag.warn("Could not find the OpenAI client in openai manual instrumentation input. Pass the openai module.");
+			return;
+		}
+		_opentelemetry_api.diag.debug("Manually instrumenting openai");
+		this.patch(module);
+	}
+	patch(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching openai");
+		for (const target of patchTargets(moduleExports)) this.patchMethod(target);
+		return moduleExports;
+	}
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching openai");
+		for (const { proto, method } of patchTargets(moduleExports)) {
+			if (!proto || !hasOwnPatchData(proto)) continue;
+			const patchData = proto[PATCH_DATA_SYMBOL];
+			if (!patchData[method]) continue;
+			proto[method] = patchData[method].original;
+			delete patchData[method];
+			if (!Object.keys(patchData).length) delete proto[PATCH_DATA_SYMBOL];
+		}
+	}
+	/**
+	* Replace `proto[method]` with a traced wrapper. Re-patching an already
+	* patched method only refreshes `traceContent`, so repeated
+	* initialization never double-wraps.
+	*/
+	patchMethod({ proto, method, wrap }) {
+		if (!proto || typeof proto[method] !== "function") return;
+		if (!hasOwnPatchData(proto)) Object.defineProperty(proto, PATCH_DATA_SYMBOL, {
+			value: {},
+			writable: true,
+			configurable: true,
+			enumerable: false
 		});
-		return messages;
+		const existing = proto[PATCH_DATA_SYMBOL][method];
+		if (existing) {
+			existing.traceContent = this.traceContent;
+			return;
+		}
+		const patchData = {
+			traceContent: this.traceContent,
+			original: proto[method]
+		};
+		proto[PATCH_DATA_SYMBOL][method] = patchData;
+		proto[method] = wrap(patchData);
 	}
-	if (typeof data === "object") return [data];
-	return [{
-		role,
-		content: String(data)
-	}];
 };
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/openai-agents/messages.ts
@@ -7223,14 +9458,10 @@ const getStagehandInstrumentation = (playwrightInstrumentation, client, sessionR
 	return stagehandInstrumentation;
 };
 const initInstrumentations = (client, suppressContentTracing, sessionRecordingOptions) => {
-	const enrichTokens = false;
 	const instrumentations = [];
-	instrumentations.push(new _traceloop_instrumentation_openai.OpenAIInstrumentation({
-		enrichTokens,
-		traceContent: !suppressContentTracing
-	}));
-	instrumentations.push(new _traceloop_instrumentation_anthropic.AnthropicInstrumentation({ traceContent: !suppressContentTracing }));
-	instrumentations.push(new _traceloop_instrumentation_cohere.CohereInstrumentation({ traceContent: !suppressContentTracing }));
+	instrumentations.push(new OpenAIInstrumentation({ traceContent: !suppressContentTracing }));
+	instrumentations.push(new AnthropicInstrumentation({ traceContent: !suppressContentTracing }));
+	instrumentations.push(new CohereInstrumentation({ traceContent: !suppressContentTracing }));
 	instrumentations.push(new _traceloop_instrumentation_bedrock.BedrockInstrumentation({ traceContent: !suppressContentTracing }));
 	instrumentations.push(new _traceloop_instrumentation_pinecone.PineconeInstrumentation());
 	instrumentations.push(new _traceloop_instrumentation_langchain.LangChainInstrumentation({ traceContent: !suppressContentTracing }));
@@ -7244,6 +9475,7 @@ const initInstrumentations = (client, suppressContentTracing, sessionRecordingOp
 		instrumentations.push(new PuppeteerInstrumentation(client, sessionRecordingOptions));
 	}
 	instrumentations.push(new GoogleGenAiInstrumentation({ traceContent: !suppressContentTracing }));
+	instrumentations.push(new GoogleAIPlatformInstrumentation({ traceContent: !suppressContentTracing }));
 	instrumentations.push(new KernelInstrumentation());
 	instrumentations.push(new ClaudeAgentSDKInstrumentation());
 	instrumentations.push(new OpencodeInstrumentation());
@@ -7253,34 +9485,27 @@ const initInstrumentations = (client, suppressContentTracing, sessionRecordingOp
 	return instrumentations;
 };
 const manuallyInitInstrumentations = (client, instrumentModules, suppressContentTracing, sessionRecordingOptions) => {
-	const enrichTokens = false;
 	const instrumentations = [];
 	let playwrightInstrumentation;
 	if (instrumentModules?.OpenAI && instrumentModules?.openAI) throw new Error("`openAI` is deprecated, but both `OpenAI` and `openAI` are provided. Please use `OpenAI` only.");
 	if (instrumentModules?.openAI) {
-		const openAIInstrumentation = new _traceloop_instrumentation_openai.OpenAIInstrumentation({
-			enrichTokens,
-			traceContent: !suppressContentTracing
-		});
+		const openAIInstrumentation = new OpenAIInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(openAIInstrumentation);
 		openAIInstrumentation.manuallyInstrument(instrumentModules.openAI);
 	}
 	if (instrumentModules?.OpenAI) {
-		const openAIInstrumentation = new _traceloop_instrumentation_openai.OpenAIInstrumentation({
-			enrichTokens,
-			traceContent: !suppressContentTracing
-		});
+		const openAIInstrumentation = new OpenAIInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(openAIInstrumentation);
 		openAIInstrumentation.manuallyInstrument(instrumentModules.OpenAI);
 	}
 	if (instrumentModules?.anthropic) {
-		const anthropicInstrumentation = new _traceloop_instrumentation_anthropic.AnthropicInstrumentation({ traceContent: !suppressContentTracing });
+		const anthropicInstrumentation = new AnthropicInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(anthropicInstrumentation);
 		anthropicInstrumentation.manuallyInstrument(instrumentModules.anthropic);
 	}
 	if (instrumentModules?.azureOpenAI) logger$7.warn("Azure OpenAI instrumentation is no longer supported. Not enabling any instrumentation.");
 	if (instrumentModules?.cohere) {
-		const cohereInstrumentation = new _traceloop_instrumentation_cohere.CohereInstrumentation({ traceContent: !suppressContentTracing });
+		const cohereInstrumentation = new CohereInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(cohereInstrumentation);
 		cohereInstrumentation.manuallyInstrument(instrumentModules.cohere);
 	}
@@ -7339,6 +9564,11 @@ const manuallyInitInstrumentations = (client, instrumentModules, suppressContent
 		instrumentations.push(googleGenAiInstrumentation);
 		googleGenAiInstrumentation.manuallyInstrument(instrumentModules.google_genai);
 	}
+	if (instrumentModules?.google_aiplatform) {
+		const googleAIPlatformInstrumentation = new GoogleAIPlatformInstrumentation({ traceContent: !suppressContentTracing });
+		instrumentations.push(googleAIPlatformInstrumentation);
+		googleAIPlatformInstrumentation.manuallyInstrument(instrumentModules.google_aiplatform);
+	}
 	if (instrumentModules?.openrouter) {
 		const openRouterInstrumentation = new OpenRouterInstrumentation({ traceContent: !suppressContentTracing });
 		instrumentations.push(openRouterInstrumentation);
@@ -8015,17 +10245,6 @@ const withSessionMetadata = (metadata) => {
 		[SESSION_METADATA_KEY]: sessionId
 	};
 };
-const getAverageScores = (results) => {
-	const perScoreValues = {};
-	for (const result of results) for (const key in result.scores) {
-		const score = result.scores[key];
-		if (perScoreValues[key] && score !== null) perScoreValues[key].push(score);
-		else perScoreValues[key] = score !== null ? [score] : [];
-	}
-	const averageScores = {};
-	for (const key in perScoreValues) averageScores[key] = perScoreValues[key].reduce((a, b) => a + b, 0) / perScoreValues[key].length;
-	return averageScores;
-};
 /**
 * HumanEvaluator is a class to register a human evaluator.
 */
@@ -8070,7 +10289,7 @@ var Evaluation = class {
 		this.concurrencyLimit = DEFAULT_CONCURRENCY;
 		this.traceDisableBatch = false;
 		this.traceExportBatchSize = MAX_EXPORT_BATCH_SIZE;
-		this.uploadPromises = [];
+		this.uploadPromises = /* @__PURE__ */ new Set();
 		if (Object.keys(evaluators).length === 0) throw new Error("No evaluators provided");
 		const evaluatorNameRegex = /^[\w\s-]+$/;
 		for (const key in evaluators) if (!evaluatorNameRegex.test(key)) throw new Error(`Invalid evaluator key: "${key}".Keys must only contain letters, digits, hyphens, underscores, or spaces.`);
@@ -8135,16 +10354,15 @@ var Evaluation = class {
 				logger$3.warn(`Error getting dataset ${source.name}: ` + require_utils.errorMessage(error));
 			}
 		}
-		let resultDatapoints;
 		try {
 			const length = await this.getLength();
 			const evaluation = await this.client.evals.init(this.name, this.groupName, withSessionMetadata(this.metadata));
 			const url = getEvaluationUrl(evaluation.projectId, evaluation.id, this.progressReporter.baseUrl, this.frontendPort);
 			process.stdout.write(`\nCheck results at ${url}\n`);
 			this.progressReporter.start({ length });
-			resultDatapoints = await this.evaluateInBatches(evaluation.id);
-			const averageScores = getAverageScores(resultDatapoints);
-			if (this.uploadPromises.length > 0) await Promise.all(this.uploadPromises);
+			const averageScores = await this.evaluateInBatches(evaluation.id);
+			if (this.uploadPromises.size > 0) await Promise.all(this.uploadPromises);
+			if (this.uploadError) throw this.uploadError.error;
 			this.progressReporter.stop({
 				averageScores,
 				projectId: evaluation.projectId,
@@ -8182,24 +10400,42 @@ var Evaluation = class {
 		});
 		return LaminarContextManager.runWithIsolatedContext([entityContext], async () => {
 			const semaphore = new require_utils.Semaphore(this.concurrencyLimit);
-			const tasks = [];
+			const inFlight = /* @__PURE__ */ new Set();
+			const scoreSums = {};
+			const scoreCounts = {};
+			let firstError;
 			const evaluateTask = async (datapoint, index) => {
 				try {
 					const result = await this.evaluateDatapoint(evalId, datapoint, index);
+					for (const [key, value] of Object.entries(result.scores ?? {})) {
+						if (value === null) continue;
+						scoreSums[key] = (scoreSums[key] ?? 0) + value;
+						scoreCounts[key] = (scoreCounts[key] ?? 0) + 1;
+					}
 					this.progressReporter.update(1);
-					return [index, result];
+				} catch (error) {
+					firstError ??= { error };
 				} finally {
 					semaphore.release();
 				}
 			};
-			for (let i = 0; i < await this.getLength(); i++) {
+			let index = 0;
+			for await (const datapoint of this.data) {
 				await semaphore.acquire();
-				const datapoint = Array.isArray(this.data) ? this.data[i] : await this.data.get(i);
-				tasks.push(evaluateTask(datapoint, i));
+				const task = evaluateTask(datapoint, index++).finally(() => inFlight.delete(task));
+				inFlight.add(task);
 			}
-			return (await Promise.all(tasks)).sort((a, b) => a[0] - b[0]).map(([, result]) => result);
+			await Promise.all(inFlight);
+			if (firstError) throw firstError.error;
+			return Object.fromEntries(Object.keys(scoreSums).map((key) => [key, scoreSums[key] / scoreCounts[key]]));
 		});
 	}
+	trackUpload(upload) {
+		const tracked = upload.then(() => void 0, (error) => {
+			this.uploadError ??= { error };
+		}).finally(() => this.uploadPromises.delete(tracked));
+		this.uploadPromises.add(tracked);
+	}
 	async evaluateDatapoint(evalId, datapoint, index) {
 		return observe({
 			name: "evaluation",
@@ -8282,12 +10518,11 @@ var Evaluation = class {
 				datapointId: datapoint.id,
 				createdAt: datapoint.createdAt
 			};
-			const uploadPromise = this.client.evals.saveDatapoints({
+			this.trackUpload(this.client.evals.saveDatapoints({
 				evalId,
 				datapoints: [resultDatapoint],
 				groupName: this.groupName
-			});
-			this.uploadPromises.push(uploadPromise);
+			}));
 			return resultDatapoint;
 		});
 	}
@@ -8334,165 +10569,10 @@ async function evaluate({ data, executor, evaluators, groupName, name, metadata,
 //#region src/integrations/eve.ts
 const logger$2 = require_utils.initializeLogger();
 const EVE_REPORTER_TRACER_NAME = "@lmnr-ai/lmnr/eve-reporter";
-const EVE_CLIENT_MODULE = "eve/client";
-const TRACEPARENT_HEADER$1 = "traceparent";
-/** Same wire name the Temporal instrumentation uses (`temporal/consts.ts`). */
-const LAMINAR_SPAN_CONTEXT_HEADER$1 = "x-lmnr-span-context";
-/**
-* Root span name for every propagated eval, and it never changes. eve calls
-* `ClientSession.send` before any hook that knows which eval is in flight, and
-* eve exposes no `onEvalStart`, so the id simply is not knowable here. Renaming
-* the span later would invalidate the `lmnr.span.path` the processor already
-* stamped on it and on every descendant, and would make the path we propagate
-* to the agent stale. The eval id rides on `lmnr.eve.eval.id`, on the trace
-* metadata, and on the datapoint instead.
-*/
-const ROOT_SPAN_NAME = "eve eval";
-const EXECUTOR_SPAN_NAME = "executor";
-/** Prototypes already patched — `send` must never be wrapped twice. */
-const patchedSendPrototypes = /* @__PURE__ */ new WeakSet();
-/**
-* Per-eve-client-session state. Keyed off the `ClientSession` instance rather
-* than an AsyncLocalStorage frame or a "current eval" global: eve runs up to
-* `maxConcurrency` evals at once, and each eval builds its own `ClientSession`
-* (`EvalSessionManager` calls `client.session()` per `EvalSessionDriver`), so
-* the instance is the only correct correlation key available inside `send`.
-*/
-const traceByClientSession = /* @__PURE__ */ new WeakMap();
-/** eve session id -> trace, read by `onEvalComplete` via `result.sessionId`. */
-const traceByEveSessionId = /* @__PURE__ */ new Map();
-/** Set by the running reporter's `onRunStart`; cleared by `onRunComplete`. */
-let activeSessionTraceFactory = null;
-/** Mirrors eve's own `normalizeSendTurnInput`, then merges the trace headers. */
-const withTraceHeaders = (input, headers) => {
-	const payload = typeof input === "string" ? { message: input } : { ...input };
-	payload.headers = {
-		...payload.headers ?? {},
-		...headers
-	};
-	return payload;
-};
-const openSessionTrace = (clientSession) => {
-	try {
-		const existing = traceByClientSession.get(clientSession);
-		if (existing) return existing;
-		const minted = activeSessionTraceFactory?.();
-		if (minted) traceByClientSession.set(clientSession, minted);
-		return minted;
-	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to open a session trace: ` + require_utils.errorMessage(error));
-		return;
-	}
-};
-/**
-* eve assigns the session id on the POST that `send` awaits, so the returned
-* `MessageResponse` is the earliest place the runner can bind the eve session
-* id to the trace it minted.
-*/
-const recordEveSessionId = (response, sessionTrace) => {
-	const sessionId = response?.sessionId;
-	if (typeof sessionId !== "string" || sessionId.length === 0) return;
-	sessionTrace.sessionIds.add(sessionId);
-	traceByEveSessionId.set(sessionId, sessionTrace);
-};
-/**
-* Build the propagation headers for the EXECUTOR span. Plain HTTP strings — eve
-* forwards `SendTurnPayload.headers` verbatim to `fetch`.
-*
-* The Laminar context carries the full path. Laminar nests spans by
-* `lmnr.span.ids_path`, not by OTel `parentSpanId`, so a receiver that adopts
-* only the ids lands its spans as a second root on our trace. The path is what
-* makes the agent's subtree render UNDER the executor. Both paths are constants
-* here — neither the root nor the executor span is ever renamed.
-*/
-const buildTraceHeaders = (rootSpan, executorSpan) => {
-	const spanContext = executorSpan.spanContext();
-	const laminarContext = {
-		traceId: require_utils.otelTraceIdToUUID(spanContext.traceId),
-		spanId: require_utils.otelSpanIdToUUID(spanContext.spanId),
-		isRemote: true,
-		spanPath: [ROOT_SPAN_NAME, EXECUTOR_SPAN_NAME],
-		spanIdsPath: [require_utils.otelSpanIdToUUID(rootSpan.spanContext().spanId), require_utils.otelSpanIdToUUID(spanContext.spanId)]
-	};
-	return {
-		[TRACEPARENT_HEADER$1]: `00-${spanContext.traceId}-${spanContext.spanId}-01`,
-		[LAMINAR_SPAN_CONTEXT_HEADER$1]: JSON.stringify(laminarContext)
-	};
-};
-/**
-* Bind this session's ROOT span into the calling eval's async context, so work
-* the eval does in the RUNNER process after `send` resolves lands on this trace
-* instead of opening its own. The concrete case is `t.judge.autoevals.*`: eve
-* runs the judge's model call in the runner, and Laminar's AI SDK integration
-* parents it to `LaminarContextManager.getContext()`.
-*
-* The root — not a pre-opened judge span — is the binding target on purpose.
-* An eval may record any number of judge assertions, and each one runs its own
-* model call. Binding the root gives every judge its own child of the root; a
-* single pre-opened parent would collect all of them under whichever judge
-* happened to run first.
-*
-* `pushContext` uses `AsyncLocalStorage.enterWith`, so this MUST run
-* synchronously before `send`'s first `await` — at that point we are still
-* executing in the caller's async context, so the store we set is the one
-* `test(t)` continues with. Each eval's `test(t)` runs in its own async chain,
-* so concurrent evals never see each other's root span; do NOT replace this
-* with the process-global context stack, which would cross-attribute.
-*
-* Judge spans reach Laminar only when the runner opts in — `Laminar.initialize()`
-* plus a globally registered AI SDK telemetry integration. Without that the
-* binding is inert, never wrong.
-*
-* Never popped: the store dies with the eval's async chain.
-*/
-const bindEvalContext = (sessionTrace) => {
-	try {
-		LaminarContextManager.pushContext(_opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, sessionTrace.rootSpan));
-	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to bind the eval context: ` + require_utils.errorMessage(error));
-	}
-};
-/**
-* Wrap `ClientSession.prototype.send` so every eve turn carries the trace
-* context of a runner-minted Laminar span. Idempotent per prototype.
-*
-* @internal Exported for tests, which drive it with a stub class so the suite
-* keeps no dependency on eve.
-*/
-const patchEveClientSession = (sessionClass) => {
-	const prototype = sessionClass?.prototype;
-	const original = prototype?.send;
-	if (!prototype || typeof original !== "function") return false;
-	if (patchedSendPrototypes.has(prototype)) return true;
-	prototype.send = async function(input) {
-		const sessionTrace = openSessionTrace(this);
-		if (!sessionTrace) return original.call(this, input);
-		bindEvalContext(sessionTrace);
-		const response = await original.call(this, withTraceHeaders(input, sessionTrace.headers));
-		try {
-			recordEveSessionId(response, sessionTrace);
-		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to record the eve session id: ` + require_utils.errorMessage(error));
-		}
-		return response;
-	};
-	patchedSendPrototypes.add(prototype);
-	return true;
-};
-/**
-* Load eve's `ClientSession` without depending on eve. Mirrors the guarded
-* dynamic import in eve's own Braintrust reporter (`loadBraintrustSdk`), except
-* a missing eve degrades instead of throwing — the reporter must keep working
-* when it is registered outside an eve run.
-*/
-const loadEveClientSession = async () => {
-	try {
-		const sessionClass = (await import(EVE_CLIENT_MODULE)).ClientSession;
-		return typeof sessionClass === "function" ? sessionClass : void 0;
-	} catch {
-		return;
-	}
-};
+const OTEL_TRACE_ID_RE = /^[0-9a-f]{32}$/iu;
+const OTEL_SPAN_ID_RE = /^[0-9a-f]{16}$/iu;
+const ZERO_TRACE_ID = "0".repeat(32);
+const ZERO_SPAN_ID = "0".repeat(16);
 const didAssertionPass = (assertion) => {
 	if (typeof assertion.passed === "boolean") return assertion.passed;
 	if (typeof assertion.score === "number") {
@@ -8501,14 +10581,8 @@ const didAssertionPass = (assertion) => {
 	}
 	return true;
 };
-/**
-* Keep Laminar's top-level score columns stable across heterogeneous eve evals.
-* Detailed assertion outcomes live in metadata; sparse per-assertion score keys
-* make Laminar's eval UI look incomplete when different eval files assert
-* different things.
-*/
-const resultToScores = (result) => {
-	const assertions = result.assertions ?? [];
+/** Keep Laminar's score columns stable across heterogeneous eve evals. */
+const resultToScores = (result, assertions) => {
 	const gateAssertions = assertions.filter((assertion) => assertion.severity === "gate");
 	const thresholdedSoftAssertions = assertions.filter((assertion) => assertion.severity === "soft" && typeof assertion.threshold === "number");
 	return {
@@ -8526,7 +10600,6 @@ const assertionsMetadata = (assertions) => assertions.map((assertion) => ({
 	message: assertion.message,
 	metadata: assertion.metadata
 }));
-/** Surface failed assertions in metadata so a failing run is debuggable. */
 const failedAssertionsMetadata = (assertions) => {
 	const failed = assertions.filter((assertion) => !didAssertionPass(assertion)).map((assertion) => ({
 		name: assertion.name,
@@ -8534,79 +10607,62 @@ const failedAssertionsMetadata = (assertions) => {
 	}));
 	return failed.length > 0 ? { failedAssertions: failed } : {};
 };
-const traceIdFromSpan = (span) => require_utils.otelTraceIdToUUID(span.spanContext().traceId);
+const validTraceContext = (context) => context != null && typeof context.traceId === "string" && OTEL_TRACE_ID_RE.test(context.traceId) && context.traceId !== ZERO_TRACE_ID && typeof context.spanId === "string" && OTEL_SPAN_ID_RE.test(context.spanId) && context.spanId !== ZERO_SPAN_ID && typeof context.traceFlags === "number" && Number.isInteger(context.traceFlags) && context.traceFlags >= 0 && context.traceFlags <= 255;
+const normalizeTraceContexts = (contexts) => Array.isArray(contexts) ? contexts.filter(validTraceContext) : [];
+const isSampledTraceContext = (context) => (context.traceFlags & 1) === 1;
+const selectTraceContext = (contexts) => contexts.find((context) => context.primary === true && isSampledTraceContext(context)) ?? contexts.find(isSampledTraceContext);
+const traceContextMetadata = (contexts) => contexts.map((context) => ({
+	traceId: context.traceId,
+	spanId: context.spanId,
+	traceFlags: context.traceFlags,
+	primary: context.primary,
+	sessionId: context.sessionId
+}));
 /**
-* A Laminar reporter for eve evals. Register it globally in `evals.config.ts`
-* or per-eval via the `reporters` field — eve runs and grades each eval, then
-* hands the graded result here, and this reporter ships it to Laminar as an
-* evaluation run with one datapoint per eval.
+* Reports eve eval results to Laminar.
 *
-* The datapoint's trace id is never looked up — the reporter OWNS the trace.
-* `patchEveClientSession` wraps eve's `ClientSession.send` and mints the
-* EVALUATION root + EXECUTOR child on the first turn of each session, so the
-* runner already knows the trace id and pushes it to the agent as a
-* `traceparent` header. The eve session id is only the in-process key that ties
-* the send we instrumented to the graded result eve hands back later.
+* Eve 0.35+ gives reporters every native trace context observed during an eval.
+* The reporter links the datapoint to the first sampled primary trace (or the
+* first sampled trace when there is no sampled primary), records every valid
+* context in metadata, and adds
+* a small EVALUATION span to the selected native trace for the grade. When eve
+* reports no usable context, a reporter-owned fallback trace preserves the
+* result without pretending it contains agent work.
 *
-* Two outcomes, recorded on `metadata.traceResolution`:
+* The agent must export its native OpenTelemetry spans to the same Laminar
+* project. In the eve agent, declare a destination like:
 *
-* 1. `"propagated"` — the normal path, above. The agent joins the trace only
-*    when `agent/instrumentation.ts` sets `traceChannelRequests: true` and the
-*    agent process runs with `WORKFLOW_TRACE_MODE=continuous`.
-* 2. `"reporter-fallback"` — no session trace was minted (propagation disabled,
-*    or eve produced no session id). The reporter opens its own EVALUATION span
-*    so the grade still lands somewhere debuggable; it holds no agent work.
-*
-* `t.judge.autoevals.*` model calls run in the RUNNER process, and they reach
-* Laminar only when the runner registers an AI SDK telemetry integration. eve
-* imports `generateText` inside its own bundle, so `wrapAISDK` cannot reach it —
-* but AI SDK v7 reads registered integrations off `globalThis`, which does. One
-* line in `evals.config.ts`:
-*
-* ```ts
-* registerTelemetry(new LaminarAiSdkTelemetry());
-* ```
-*
-* Judge spans and eve eval spans then share ONE tracer provider — whichever of
-* the two initialized Laminar first (see {@link LaminarReporter.ensureTracing}).
-* Each judge gets its own span under the eval's root — see
-* {@link bindEvalContext}, and {@link LaminarReporter.flush} for how spans ship.
-* Without that line the reporter still records every assertion's score as an
-* EVALUATOR span; only the model call is missing.
-*
-* @example
 * ```ts
-* import { defineEvalConfig } from "eve/evals";
-* import { LaminarReporter } from "@lmnr-ai/lmnr";
+* import { LaminarSpanProcessor } from "@lmnr-ai/lmnr";
+* import { otelIntegration } from "eve/instrumentation/otel";
 *
-* export default defineEvalConfig({
-*   reporters: [new LaminarReporter({ name: "weather-agent" })],
+* export default otelIntegration({
+*   spanProcessors: [new LaminarSpanProcessor()],
 * });
 * ```
 */
 var LaminarReporter = class {
 	constructor(options = {}) {
 		this.evalsById = /* @__PURE__ */ new Map();
-		this.index = 0;
-		this.openSessionTraces = /* @__PURE__ */ new Set();
-		this.sessionTraceFactory = () => this.mintSessionTrace();
+		this.evalIndexById = /* @__PURE__ */ new Map();
+		this.nextFallbackIndex = 0;
 		this.options = options;
 	}
 	async onRunStart(evaluations, target) {
 		this.evalId = void 0;
-		this.evalsById = new Map(evaluations.filter((evaluation) => typeof evaluation.id === "string").map((evaluation) => [evaluation.id, evaluation]));
-		this.index = 0;
-		this.finishOpenSessionTraces();
+		const identifiedEvaluations = evaluations.map((evaluation, index) => ({
+			evaluation,
+			index
+		})).filter((item) => typeof item.evaluation.id === "string");
+		this.evalsById = new Map(identifiedEvaluations.map(({ evaluation }) => [evaluation.id, evaluation]));
+		this.evalIndexById = new Map(identifiedEvaluations.map(({ evaluation, index }) => [evaluation.id, index]));
+		this.nextFallbackIndex = evaluations.length;
 		try {
 			this.client = this.options.client ?? new require_utils.LaminarClient({
 				baseUrl: this.options.baseUrl,
 				projectApiKey: this.options.projectApiKey
 			});
 			this.ensureTracing();
-			if (this.options.propagateTraceContext !== false) {
-				activeSessionTraceFactory = this.sessionTraceFactory;
-				patchEveClientSession(await loadEveClientSession());
-			}
 			const evaluation = await this.client.evals.init(this.options.name, this.options.groupName, {
 				...this.options.metadata ?? {},
 				source: "eve",
@@ -8619,26 +10675,25 @@ var LaminarReporter = class {
 			process.stdout.write(`\nLaminar: check eve eval results at ${url}\n`);
 		} catch (error) {
 			logger$2.error(`Laminar eve reporter: failed to start run: ${require_utils.errorMessage(error)}`);
-			if (!this.evalId) {
-				this.client = void 0;
-				if (activeSessionTraceFactory === this.sessionTraceFactory) activeSessionTraceFactory = null;
-			}
+			if (!this.evalId) this.client = void 0;
 		}
 	}
-	async onEvalComplete(result) {
+	async onEvalComplete(result, context) {
 		const client = this.client;
 		const evalId = this.evalId;
 		if (!client || !evalId) return;
-		const index = this.index++;
+		const index = typeof result.id === "string" ? this.evalIndexById.get(result.id) ?? this.nextFallbackIndex++ : this.nextFallbackIndex++;
 		const task = result.result ?? {};
 		const derived = task.derived ?? {};
-		const assertions = result.assertions ?? [];
-		const evalDescription = (typeof result.id === "string" ? this.evalsById.get(result.id) : void 0)?.description;
-		const traceResolution = this.resolveDatapointTrace({
-			evalId: result.id ?? String(index),
+		const assertions = Array.isArray(result.assertions) ? result.assertions.filter((assertion) => assertion != null && typeof assertion === "object") : [];
+		const evalDefinition = typeof result.id === "string" ? this.evalsById.get(result.id) : void 0;
+		const evalDescription = context?.evaluation?.description ?? evalDefinition?.description;
+		const contexts = normalizeTraceContexts(context?.traceContexts ?? task.traceContexts ?? []);
+		const gradeTrace = this.openGradeTrace({
+			contexts,
 			description: evalDescription,
-			verdict: result.verdict,
-			sessionId: task.sessionId
+			evalId: result.id ?? String(index),
+			verdict: result.verdict
 		});
 		try {
 			const datapointId = await client.evals.createDatapoint({
@@ -8646,17 +10701,19 @@ var LaminarReporter = class {
 				data: result.id ?? null,
 				target: task.finalMessage ?? null,
 				index,
-				traceId: traceResolution.traceId,
+				traceId: gradeTrace.traceId,
 				metadata: {
 					name: result.id,
 					verdict: result.verdict,
 					status: task.status,
 					description: evalDescription,
 					sessionId: task.sessionId,
-					traceResolution: traceResolution.source,
+					traceResolution: gradeTrace.source,
+					selectedTraceContext: gradeTrace.selected ? traceContextMetadata([gradeTrace.selected])[0] : void 0,
+					traceContexts: traceContextMetadata(gradeTrace.contexts),
 					skipReason: result.skipReason,
 					error: result.error,
-					toolCalls: (derived.toolCalls ?? []).map((call) => call.name).filter((name) => typeof name === "string"),
+					toolCalls: (Array.isArray(derived.toolCalls) ? derived.toolCalls : []).map((call) => call?.name).filter((name) => typeof name === "string"),
 					toolCallCount: derived.toolCallCount,
 					parked: derived.parked,
 					failureCode: derived.failureCode,
@@ -8665,44 +10722,30 @@ var LaminarReporter = class {
 					...failedAssertionsMetadata(assertions)
 				}
 			});
-			const executorOutput = task.output ?? task.finalMessage ?? null;
 			await client.evals.updateDatapoint({
 				evalId,
 				datapointId,
-				scores: resultToScores(result),
-				executorOutput
+				scores: resultToScores(result, assertions),
+				executorOutput: task.output ?? task.finalMessage ?? null
 			});
 		} catch (error) {
-			if (traceResolution.source === "reporter-fallback") traceResolution.span.recordException(error);
+			gradeTrace.span.recordException(error);
 			logger$2.error(`Laminar eve reporter: failed to report eval "${result.id ?? index}": ${require_utils.errorMessage(error)}`);
 		} finally {
-			if (traceResolution.source === "reporter-fallback") traceResolution.span.end();
-			if (traceResolution.source === "propagated") this.finishSessionTrace(traceResolution.sessionTrace, {
-				evalId: result.id,
-				description: evalDescription,
-				verdict: result.verdict,
-				status: task.status,
+			this.finishGradeTrace(gradeTrace, {
+				assertions,
 				output: task.output ?? task.finalMessage ?? null,
-				assertions
+				status: task.status
 			});
 			await this.flush();
 		}
 	}
-	async onRunComplete() {
-		this.finishOpenSessionTraces();
-		if (activeSessionTraceFactory === this.sessionTraceFactory) activeSessionTraceFactory = null;
+	async onRunComplete(_summary) {
 		await this.flush();
 		this.evalId = void 0;
 		this.evalsById.clear();
+		this.evalIndexById.clear();
 	}
-	/**
-	* Point the process's Laminar tracing at this reporter's project, unless
-	* something already initialized it. Mirrors `LaminarAiSdkTelemetry`, which
-	* initializes the same way for judge spans — so eve eval spans and judge
-	* spans share ONE tracer provider however the run was set up. Without this,
-	* `getTracer()` returns a noop whenever nobody registered the AI SDK
-	* integration, and every eve span would be dropped silently.
-	*/
 	ensureTracing() {
 		if (Laminar.initialized()) {
 			const ourKey = this.client?.apiKey ?? this.options.projectApiKey;
@@ -8718,140 +10761,79 @@ var LaminarReporter = class {
 			disableBatch: true
 		});
 	}
-	/**
-	* Flush the process's Laminar pipeline — eve eval spans AND judge spans, which
-	* now share one provider. eve ends `eve eval` with `process.exit()` (skipping
-	* `beforeExit`), so these calls are the only points at which spans ship.
-	* Never `shutdown()`: the pipeline may belong to the host, not to us.
-	*/
 	async flush() {
 		try {
 			await Laminar.flush();
 		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to flush spans: ` + require_utils.errorMessage(error));
+			logger$2.warn(`Laminar eve reporter: failed to flush spans: ${require_utils.errorMessage(error)}`);
 		}
 	}
-	/**
-	* Open the eval's Laminar spans for one eve client session: an EVALUATION
-	* root plus the EXECUTOR child the agent's turn is parented to. Called from
-	* the patched `send`, so it must never throw into the user's eval.
-	*/
-	mintSessionTrace() {
+	openGradeTrace({ contexts, description, evalId, verdict }) {
+		const selected = selectTraceContext(contexts);
 		const tracer = getTracer();
-		const rootSpan = tracer.startSpan(ROOT_SPAN_NAME, { attributes: {
-			[require_utils.SPAN_TYPE]: "EVALUATION",
-			[require_utils.TRACE_TYPE]: "EVALUATION",
-			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME
-		} }, _opentelemetry_api.ROOT_CONTEXT);
-		const executorSpan = tracer.startSpan(EXECUTOR_SPAN_NAME, { attributes: {
-			[require_utils.SPAN_TYPE]: "EXECUTOR",
-			[require_utils.TRACE_TYPE]: "EVALUATION"
-		} }, _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, rootSpan));
-		const sessionTrace = {
-			traceId: require_utils.otelTraceIdToUUID(rootSpan.spanContext().traceId),
-			rootSpan,
-			executorSpan,
-			tracer,
-			headers: buildTraceHeaders(rootSpan, executorSpan),
-			sessionIds: /* @__PURE__ */ new Set(),
-			ended: false
-		};
-		this.openSessionTraces.add(sessionTrace);
-		return sessionTrace;
-	}
-	/** Grade, close and release one session trace. Idempotent. */
-	finishSessionTrace(sessionTrace, grade) {
-		if (sessionTrace.ended) return;
-		sessionTrace.ended = true;
-		this.openSessionTraces.delete(sessionTrace);
-		for (const sessionId of sessionTrace.sessionIds) traceByEveSessionId.delete(sessionId);
-		try {
-			sessionTrace.rootSpan.setAttributes({
-				"lmnr.eve.eval.id": grade.evalId ?? "",
-				"lmnr.eve.eval.verdict": grade.verdict ?? "",
-				"lmnr.eve.eval.status": grade.status ?? "",
-				[require_utils.SPAN_INPUT]: JSON.stringify({
-					evalId: grade.evalId,
-					description: grade.description
-				}),
-				[require_utils.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null),
-				...require_utils.metadataToAttributes({
-					source: "eve",
-					eveEvalId: grade.evalId ?? "",
-					eveEvalDescription: grade.description ?? "",
-					eveEvalVerdict: grade.verdict ?? "",
-					eveSessionId: [...sessionTrace.sessionIds].join(",")
-				})
-			});
-			sessionTrace.executorSpan.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(grade.output ?? null));
-			this.recordEvaluatorSpans(sessionTrace, grade.assertions ?? []);
-			sessionTrace.executorSpan.end();
-			sessionTrace.rootSpan.end();
-		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to finish the session trace: ` + require_utils.errorMessage(error));
-		}
-	}
-	/**
-	* One EVALUATOR span per eve assertion, judge or not. They are created at
-	* grade time (the assertions only exist then) as short children of the
-	* still-open root. No explicit parent path is needed: the root keeps the name
-	* it was minted with, so the processor's cached path for it is still correct.
-	*/
-	recordEvaluatorSpans(sessionTrace, assertions) {
-		const rootContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, sessionTrace.rootSpan);
-		for (const assertion of assertions) {
-			const name = assertion.name ?? "assertion";
-			const output = JSON.stringify({
-				score: assertion.score ?? null,
-				passed: didAssertionPass(assertion),
-				severity: assertion.severity,
-				threshold: assertion.threshold,
-				message: assertion.message
-			});
-			sessionTrace.tracer.startSpan(name, { attributes: {
-				[require_utils.SPAN_TYPE]: "EVALUATOR",
-				[require_utils.TRACE_TYPE]: "EVALUATION",
-				[require_utils.SPAN_OUTPUT]: output
-			} }, rootContext).end();
-		}
-	}
-	finishOpenSessionTraces() {
-		for (const sessionTrace of [...this.openSessionTraces]) this.finishSessionTrace(sessionTrace, {});
-	}
-	/**
-	* Resolve the trace this datapoint links to. There is no lookup: either
-	* `patchEveClientSession` already minted the session's trace (and we know its
-	* id), or we open a reporter-owned EVALUATION span to hold the grade.
-	*/
-	resolveDatapointTrace({ evalId, description, verdict, sessionId }) {
-		const sessionTrace = sessionId ? traceByEveSessionId.get(sessionId) : void 0;
-		if (sessionTrace) return {
-			traceId: sessionTrace.traceId,
-			source: "propagated",
-			sessionTrace
-		};
-		const span = getTracer().startSpan(`eve eval ${evalId}`, { attributes: {
+		const parentContext = selected ? _opentelemetry_api.trace.setSpanContext(_opentelemetry_api.ROOT_CONTEXT, this.toSpanContext(selected)) : _opentelemetry_api.ROOT_CONTEXT;
+		const source = selected ? "eve-native" : "reporter-fallback";
+		const span = tracer.startSpan(`eve eval ${evalId}`, { attributes: {
 			[require_utils.SPAN_TYPE]: "EVALUATION",
 			[require_utils.TRACE_TYPE]: "EVALUATION",
 			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME,
 			"lmnr.eve.eval.id": evalId,
 			"lmnr.eve.eval.verdict": verdict ?? "",
-			...sessionId ? { "lmnr.eve.session.id": sessionId } : {},
-			"lmnr.eve.trace_resolution": "reporter-fallback",
+			"lmnr.eve.trace_resolution": source,
 			...require_utils.metadataToAttributes({
 				source: "eve",
 				eveEvalId: evalId,
 				eveEvalDescription: description ?? "",
 				eveEvalVerdict: verdict ?? "",
-				eveSessionId: sessionId ?? ""
+				eveSessionId: selected?.sessionId ?? "",
+				eveTraceCount: contexts.length
+			}),
+			[require_utils.SPAN_INPUT]: JSON.stringify({
+				evalId,
+				description
 			})
-		} }, _opentelemetry_api.ROOT_CONTEXT);
+		} }, parentContext);
+		return {
+			traceId: require_utils.otelTraceIdToUUID(span.spanContext().traceId),
+			source,
+			span,
+			tracer,
+			selected,
+			contexts
+		};
+	}
+	toSpanContext(context) {
 		return {
-			traceId: traceIdFromSpan(span),
-			source: "reporter-fallback",
-			span
+			traceId: context.traceId.toLowerCase(),
+			spanId: context.spanId.toLowerCase(),
+			traceFlags: context.traceFlags,
+			isRemote: true
 		};
 	}
+	finishGradeTrace(gradeTrace, grade) {
+		try {
+			gradeTrace.span.setAttributes({
+				"lmnr.eve.eval.status": grade.status ?? "",
+				[require_utils.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null)
+			});
+			const parentContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, gradeTrace.span);
+			for (const assertion of grade.assertions) gradeTrace.tracer.startSpan(assertion.name ?? "assertion", { attributes: {
+				[require_utils.SPAN_TYPE]: "EVALUATOR",
+				[require_utils.TRACE_TYPE]: "EVALUATION",
+				[require_utils.SPAN_OUTPUT]: JSON.stringify({
+					score: assertion.score ?? null,
+					passed: didAssertionPass(assertion),
+					severity: assertion.severity,
+					threshold: assertion.threshold,
+					message: assertion.message
+				})
+			} }, parentContext).end();
+		} catch (error) {
+			logger$2.warn(`Laminar eve reporter: failed to finish the grade trace: ${require_utils.errorMessage(error)}`);
+		} finally {
+			gradeTrace.span.end();
+		}
+	}
 };
 //#endregion
 //#region src/debug/hash.ts