@lmnr-ai/lmnr 0.8.46 → 0.8.47

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
-const require_utils = require("./utils-BC1-3ycw.cjs");
+const require_utils = require("./utils-Cibdqbyh.cjs");
 const require_consts = require("./consts-9rSS0oeR.cjs");
 let path = require("path");
 path = require_rolldown_runtime.__toESM(path);
@@ -183,7 +183,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-ChUoEaNR.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-D8HN2emo.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");
@@ -4593,7 +4593,7 @@ const LLM_USAGE_TOTAL_TOKENS = "llm.usage.total_tokens";
 /**
 * Set an attribute on a span only if the value is non-null, non-undefined, and non-empty.
 */
-function safeSetAttribute(span, key, value) {
+function safeSetAttribute$1(span, key, value) {
 	if (value === null || value === void 0) return;
 	if (typeof value === "string" && value.length === 0) return;
 	if (Array.isArray(value) && value.length === 0) return;
@@ -4655,44 +4655,44 @@ function extractToolDefinitions(config) {
 /**
 * Set request attributes on a span from generateContent params.
 */
-function setRequestAttributes(span, params, traceContent) {
-	safeSetAttribute(span, LLM_SYSTEM, "gemini");
-	safeSetAttribute(span, LLM_REQUEST_MODEL, params?.model);
+function setRequestAttributes$1(span, params, traceContent) {
+	safeSetAttribute$1(span, LLM_SYSTEM, "gemini");
+	safeSetAttribute$1(span, LLM_REQUEST_MODEL, params?.model);
 	const config = params?.config;
 	if (config) {
-		safeSetAttribute(span, "gen_ai.request.temperature", config.temperature);
-		safeSetAttribute(span, "gen_ai.request.top_p", config.topP);
-		safeSetAttribute(span, "gen_ai.request.top_k", config.topK);
-		safeSetAttribute(span, "gen_ai.request.max_tokens", config.maxOutputTokens);
-		safeSetAttribute(span, "gen_ai.request.frequency_penalty", config.frequencyPenalty);
-		safeSetAttribute(span, "gen_ai.request.presence_penalty", config.presencePenalty);
-		safeSetAttribute(span, "gen_ai.request.seed", config.seed);
-		safeSetAttribute(span, "gen_ai.request.choice_count", config.candidateCount);
-		if (config.stopSequences && config.stopSequences.length > 0) safeSetAttribute(span, "gen_ai.request.stop_sequences", JSON.stringify(config.stopSequences));
+		safeSetAttribute$1(span, "gen_ai.request.temperature", config.temperature);
+		safeSetAttribute$1(span, "gen_ai.request.top_p", config.topP);
+		safeSetAttribute$1(span, "gen_ai.request.top_k", config.topK);
+		safeSetAttribute$1(span, "gen_ai.request.max_tokens", config.maxOutputTokens);
+		safeSetAttribute$1(span, "gen_ai.request.frequency_penalty", config.frequencyPenalty);
+		safeSetAttribute$1(span, "gen_ai.request.presence_penalty", config.presencePenalty);
+		safeSetAttribute$1(span, "gen_ai.request.seed", config.seed);
+		safeSetAttribute$1(span, "gen_ai.request.choice_count", config.candidateCount);
+		if (config.stopSequences && config.stopSequences.length > 0) safeSetAttribute$1(span, "gen_ai.request.stop_sequences", JSON.stringify(config.stopSequences));
 		const outputSchema = config.responseSchema ?? config.responseJsonSchema;
-		if (outputSchema) safeSetAttribute(span, "gen_ai.request.structured_output_schema", JSON.stringify(toDict(outputSchema)));
+		if (outputSchema) safeSetAttribute$1(span, "gen_ai.request.structured_output_schema", JSON.stringify(toDict(outputSchema)));
 		const toolDefs = extractToolDefinitions(config);
-		if (toolDefs.length > 0) safeSetAttribute(span, "gen_ai.tool.definitions", JSON.stringify(toolDefs));
+		if (toolDefs.length > 0) safeSetAttribute$1(span, "gen_ai.tool.definitions", JSON.stringify(toolDefs));
 	}
 	if (traceContent) {
 		const messages = contentToMessages(params?.contents, config?.systemInstruction);
-		if (messages.length > 0) safeSetAttribute(span, "gen_ai.input.messages", JSON.stringify(messages));
+		if (messages.length > 0) safeSetAttribute$1(span, "gen_ai.input.messages", JSON.stringify(messages));
 	}
 }
 /**
 * Set response attributes on a span from a GenerateContentResponse.
 */
-function setResponseAttributes(span, response, traceContent) {
+function setResponseAttributes$1(span, response, traceContent) {
 	if (!response) return;
-	safeSetAttribute(span, LLM_RESPONSE_MODEL, response.modelVersion);
+	safeSetAttribute$1(span, LLM_RESPONSE_MODEL, response.modelVersion);
 	const usage = response.usageMetadata;
 	if (usage) {
-		safeSetAttribute(span, "gen_ai.usage.input_tokens", usage.promptTokenCount);
+		safeSetAttribute$1(span, "gen_ai.usage.input_tokens", usage.promptTokenCount);
 		const outputTokens = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
-		if (outputTokens > 0) safeSetAttribute(span, "gen_ai.usage.output_tokens", outputTokens);
-		safeSetAttribute(span, LLM_USAGE_TOTAL_TOKENS, usage.totalTokenCount);
-		safeSetAttribute(span, "gen_ai.usage.reasoning_tokens", usage.thoughtsTokenCount);
-		safeSetAttribute(span, "gen_ai.usage.cache_read_input_tokens", usage.cachedContentTokenCount);
+		if (outputTokens > 0) safeSetAttribute$1(span, "gen_ai.usage.output_tokens", outputTokens);
+		safeSetAttribute$1(span, LLM_USAGE_TOTAL_TOKENS, usage.totalTokenCount);
+		safeSetAttribute$1(span, "gen_ai.usage.reasoning_tokens", usage.thoughtsTokenCount);
+		safeSetAttribute$1(span, "gen_ai.usage.cache_read_input_tokens", usage.cachedContentTokenCount);
 	}
 	if (traceContent && response.candidates) {
 		const outputMessages = [];
@@ -4719,7 +4719,7 @@ function setResponseAttributes(span, response, traceContent) {
 				...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
 			});
 		}
-		if (outputMessages.length > 0) safeSetAttribute(span, "gen_ai.output.messages", JSON.stringify(outputMessages));
+		if (outputMessages.length > 0) safeSetAttribute$1(span, "gen_ai.output.messages", JSON.stringify(outputMessages));
 	}
 }
 /**
@@ -4784,7 +4784,7 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 			try {
 				if (modelVersion !== void 0 || role !== void 0 || accumulatedParts.length > 0 || sawUsageMetadata) {
 					const mergedParts = mergeTextParts(accumulatedParts);
-					setResponseAttributes(span, {
+					setResponseAttributes$1(span, {
 						modelVersion,
 						candidates: [{ content: {
 							role: role ?? "model",
@@ -4814,7 +4814,7 @@ function wrapStreamingResponse(span, asyncGen, traceContent) {
 }
 //#endregion
 //#region src/opentelemetry-lib/instrumentation/google-genai/index.ts
-const WRAPPED_SYMBOL = Symbol("lmnr.google-genai.wrapped");
+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) {
@@ -4900,7 +4900,7 @@ var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.In
 		if (!models || typeof models !== "object") return;
 		if (typeof models.generateContent !== "function") return;
 		if (typeof models.generateContentStream !== "function") return;
-		if (models[WRAPPED_SYMBOL]) return;
+		if (models[WRAPPED_SYMBOL$1]) return;
 		const originalGenerateContent = models.generateContent.bind(models);
 		const originalGenerateContentStream = models.generateContentStream.bind(models);
 		models.generateContent = async function(params) {
@@ -4909,11 +4909,11 @@ var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.In
 				name: "gemini.generate_content",
 				spanType: "LLM"
 			});
-			setRequestAttributes(span, params, classPatchData.traceContent);
+			setRequestAttributes$1(span, params, classPatchData.traceContent);
 			return Laminar.withSpan(span, async () => {
 				try {
 					const response = await originalGenerateContent(params);
-					setResponseAttributes(span, response, classPatchData.traceContent);
+					setResponseAttributes$1(span, response, classPatchData.traceContent);
 					return response;
 				} catch (error) {
 					span.setAttribute("error.type", error.constructor?.name ?? "Error");
@@ -4928,7 +4928,7 @@ var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.In
 				name: "gemini.generate_content_stream",
 				spanType: "LLM"
 			});
-			setRequestAttributes(span, params, classPatchData.traceContent);
+			setRequestAttributes$1(span, params, classPatchData.traceContent);
 			try {
 				return wrapStreamingResponse(span, await originalGenerateContentStream(params), classPatchData.traceContent);
 			} catch (error) {
@@ -4939,7 +4939,7 @@ var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.In
 				throw error;
 			}
 		};
-		models[WRAPPED_SYMBOL] = true;
+		models[WRAPPED_SYMBOL$1] = true;
 	}
 };
 //#endregion
@@ -5754,6 +5754,410 @@ var OpencodeInstrumentation = class extends _opentelemetry_instrumentation.Instr
 	}
 };
 //#endregion
+//#region src/opentelemetry-lib/instrumentation/openrouter/utils.ts
+const TERMINAL_RESPONSE_EVENTS = new Set([
+	"response.completed",
+	"response.incomplete",
+	"response.failed"
+]);
+const ERROR_RESPONSE_STATUSES = new Set(["failed", "incomplete"]);
+const safeSetAttribute = (span, key, value) => {
+	if (value === null || value === void 0) return;
+	if (typeof value === "string" && value.length === 0) return;
+	span.setAttribute(key, value);
+};
+const recordError = (span, error) => {
+	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+	span.recordException(error);
+	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+};
+const isAsyncIterable = (value) => typeof value?.[Symbol.asyncIterator] === "function";
+const responsesInputMessages = (request) => {
+	const messages = [];
+	if (request?.instructions) messages.push({
+		role: "system",
+		content: request.instructions
+	});
+	if (typeof request?.input === "string") messages.push({
+		role: "user",
+		content: request.input
+	});
+	else if (Array.isArray(request?.input)) messages.push(...request.input);
+	return messages;
+};
+const structuredOutputSchema = (kind, request) => {
+	const format = kind === "chat" ? request?.responseFormat : request?.text?.format;
+	if (format?.type !== "json_schema") return void 0;
+	return kind === "chat" ? format.jsonSchema?.schema : format.schema;
+};
+/**
+* `input` is either one document or a batch of them. A flat array of numbers is
+* a single token-id sequence, not a batch — the API returns one embedding for it.
+*/
+const embeddingsInputMessages = (input) => {
+	return (Array.isArray(input) && !(input.length > 0 && typeof input[0] === "number") ? input : [input]).map((content) => ({ content }));
+};
+const setRequestAttributes = (span, kind, request, traceContent) => {
+	safeSetAttribute(span, "gen_ai.request.model", request?.model);
+	safeSetAttribute(span, "llm.user", request?.user);
+	if (kind === "embeddings") {
+		if (traceContent && request?.input !== void 0) safeSetAttribute(span, "gen_ai.input.messages", JSON.stringify(embeddingsInputMessages(request.input)));
+		return;
+	}
+	safeSetAttribute(span, "gen_ai.request.temperature", request?.temperature);
+	safeSetAttribute(span, "gen_ai.request.top_p", request?.topP);
+	safeSetAttribute(span, "gen_ai.request.frequency_penalty", request?.frequencyPenalty);
+	safeSetAttribute(span, "gen_ai.request.presence_penalty", request?.presencePenalty);
+	safeSetAttribute(span, "gen_ai.request.reasoning_effort", request?.reasoningEffort ?? request?.reasoning?.effort);
+	safeSetAttribute(span, "gen_ai.request.max_tokens", kind === "chat" ? request?.maxTokens : request?.maxOutputTokens);
+	const schema = structuredOutputSchema(kind, request);
+	if (schema) safeSetAttribute(span, "gen_ai.request.structured_output_schema", JSON.stringify(schema));
+	if (request?.stream) safeSetAttribute(span, "llm.is_streaming", true);
+	if (!traceContent) return;
+	if (Array.isArray(request?.tools) && request.tools.length > 0) safeSetAttribute(span, "gen_ai.tool.definitions", JSON.stringify(request.tools));
+	const messages = kind === "chat" ? request?.messages : responsesInputMessages(request);
+	if (Array.isArray(messages) && messages.length > 0) safeSetAttribute(span, "gen_ai.input.messages", JSON.stringify(messages));
+};
+const setUsageAttributes = (span, usage, inputKey, outputKey, inputCostKey, outputCostKey) => {
+	if (!usage) return;
+	safeSetAttribute(span, "gen_ai.usage.input_tokens", usage[inputKey]);
+	safeSetAttribute(span, "gen_ai.usage.output_tokens", usage[outputKey]);
+	safeSetAttribute(span, "llm.usage.total_tokens", usage.totalTokens);
+	const inputDetails = usage[`${inputKey}Details`];
+	safeSetAttribute(span, "gen_ai.usage.cache_read_input_tokens", inputDetails?.cachedTokens);
+	safeSetAttribute(span, "gen_ai.usage.cache_creation_input_tokens", inputDetails?.cacheWriteTokens);
+	safeSetAttribute(span, "gen_ai.usage.reasoning_tokens", usage[`${outputKey}Details`]?.reasoningTokens);
+	safeSetAttribute(span, "gen_ai.usage.cost", usage.cost);
+	safeSetAttribute(span, "gen_ai.usage.input_cost", usage.costDetails?.[inputCostKey]);
+	safeSetAttribute(span, "gen_ai.usage.output_cost", usage.costDetails?.[outputCostKey]);
+};
+/** Message to fail the span with, or `undefined` if the response succeeded. */
+const responsesErrorMessage = (response) => {
+	if (!ERROR_RESPONSE_STATUSES.has(response?.status)) return void 0;
+	return response.error?.message ?? response.incompleteDetails?.reason ?? response.status;
+};
+const setResponseAttributes = (span, kind, response, traceContent) => {
+	if (!response) return;
+	safeSetAttribute(span, "gen_ai.response.id", response.id);
+	safeSetAttribute(span, "gen_ai.response.model", response.model);
+	if (kind === "responses") {
+		setUsageAttributes(span, response.usage, "inputTokens", "outputTokens", "upstreamInferenceInputCost", "upstreamInferenceOutputCost");
+		const error = responsesErrorMessage(response);
+		if (error) {
+			span.setAttribute("error.type", response.status);
+			span.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: error
+			});
+		}
+	} else setUsageAttributes(span, response.usage, "promptTokens", "completionTokens", "upstreamInferencePromptCost", "upstreamInferenceCompletionsCost");
+	if (!traceContent || kind === "embeddings") return;
+	const output = kind === "chat" ? response.choices : response.output;
+	if (Array.isArray(output) && output.length > 0) safeSetAttribute(span, "gen_ai.output.messages", JSON.stringify(output));
+};
+const aggregateChatChunks = (chunks) => {
+	const result = {
+		id: void 0,
+		model: void 0,
+		usage: void 0
+	};
+	const choices = /* @__PURE__ */ new Map();
+	const toolCalls = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		result.id ??= chunk?.id;
+		result.model ??= chunk?.model;
+		if (chunk?.usage) result.usage = chunk.usage;
+		for (const choice of chunk?.choices ?? []) {
+			const index = choice.index ?? 0;
+			if (!choices.has(index)) choices.set(index, {
+				index,
+				message: {
+					role: "assistant",
+					content: ""
+				},
+				finishReason: void 0
+			});
+			const accumulated = choices.get(index);
+			const delta = choice.delta ?? {};
+			if (delta.role) accumulated.message.role = delta.role;
+			if (delta.content) accumulated.message.content += delta.content;
+			for (const call of delta.toolCalls ?? []) {
+				if (!toolCalls.has(index)) toolCalls.set(index, /* @__PURE__ */ new Map());
+				const calls = toolCalls.get(index);
+				const callIndex = call.index ?? 0;
+				if (!calls.has(callIndex)) calls.set(callIndex, {
+					id: void 0,
+					type: "function",
+					function: {
+						name: "",
+						arguments: ""
+					}
+				});
+				const slot = calls.get(callIndex);
+				slot.id ??= call.id;
+				slot.function.name += call.function?.name ?? "";
+				slot.function.arguments += call.function?.arguments ?? "";
+			}
+			if (choice.finishReason) accumulated.finishReason = choice.finishReason;
+		}
+	}
+	for (const [index, calls] of toolCalls) choices.get(index).message.toolCalls = [...calls.keys()].sort((a, b) => a - b).map((key) => calls.get(key));
+	result.choices = [...choices.keys()].sort((a, b) => a - b).map((key) => choices.get(key));
+	return result;
+};
+const responseFromStreamEvents = (events) => {
+	for (let i = events.length - 1; i >= 0; i--) if (TERMINAL_RESPONSE_EVENTS.has(events[i]?.type)) return events[i].response;
+};
+/**
+* Replaces the stream's async iterator so the span is finalized once the
+* consumer finishes (or abandons) iteration. The stream object is returned as-is.
+*/
+const wrapStream = (span, kind, stream, traceContent) => {
+	const originalIterator = stream[Symbol.asyncIterator].bind(stream);
+	async function* wrapper() {
+		const chunks = [];
+		try {
+			for await (const chunk of { [Symbol.asyncIterator]: originalIterator }) {
+				chunks.push(chunk);
+				yield chunk;
+			}
+		} catch (error) {
+			recordError(span, error);
+			throw error;
+		} finally {
+			try {
+				setResponseAttributes(span, kind, kind === "chat" ? aggregateChatChunks(chunks) : responseFromStreamEvents(chunks), traceContent);
+			} finally {
+				span.end();
+			}
+		}
+	}
+	stream[Symbol.asyncIterator] = wrapper;
+	return stream;
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/openrouter/index.ts
+const WRAPPED_SYMBOL = Symbol("lmnr.openrouter.wrapped");
+const PATCH_STATE_SYMBOL = Symbol("lmnr.openrouter.patch-state");
+/** The method each resource sends on, and the key its request is wrapped in. */
+const RESOURCE_METHODS = {
+	chat: {
+		method: "send",
+		requestKey: "chatRequest"
+	},
+	responses: {
+		method: "send",
+		requestKey: "responsesRequest"
+	},
+	embeddings: {
+		method: "generate",
+		requestKey: "requestBody"
+	}
+};
+const RESOURCE_KINDS = Object.keys(RESOURCE_METHODS);
+var OpenRouterInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/openrouter-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@openrouter/sdk", [">=1.0.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	manuallyInstrument(openRouterModule) {
+		_opentelemetry_api.diag.debug("Manually instrumenting @openrouter/sdk");
+		const OpenRouterClass = this.resolveOpenRouterClass(openRouterModule);
+		if (OpenRouterClass) this.patchOpenRouterClass(OpenRouterClass);
+		else _opentelemetry_api.diag.warn("Could not find OpenRouter class in openrouter manual instrumentation input. Pass either the OpenRouter class or the module object with an OpenRouter export.");
+	}
+	patch(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching @openrouter/sdk");
+		const OpenRouterClass = this.resolveOpenRouterClass(moduleExports);
+		if (OpenRouterClass) this.patchOpenRouterClass(OpenRouterClass);
+		return moduleExports;
+	}
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @openrouter/sdk");
+		const OpenRouterClass = this.resolveOpenRouterClass(moduleExports);
+		if (OpenRouterClass) this.unpatchOpenRouterClass(OpenRouterClass);
+	}
+	resolveOpenRouterClass(moduleOrClass) {
+		if (typeof moduleOrClass === "function") return moduleOrClass;
+		if (typeof moduleOrClass?.OpenRouter === "function") return moduleOrClass.OpenRouter;
+	}
+	patchOpenRouterClass(OpenRouterClass) {
+		const proto = OpenRouterClass.prototype;
+		const existing = proto[PATCH_STATE_SYMBOL];
+		if (existing) {
+			existing.traceContent = this.traceContent;
+			return;
+		}
+		const state = {
+			traceContent: this.traceContent,
+			chat: Object.getOwnPropertyDescriptor(proto, "chat"),
+			responses: Object.getOwnPropertyDescriptor(proto, "responses"),
+			embeddings: Object.getOwnPropertyDescriptor(proto, "embeddings"),
+			callModel: proto.callModel
+		};
+		proto[PATCH_STATE_SYMBOL] = state;
+		for (const kind of RESOURCE_KINDS) patchResourceGetter(proto, kind, state);
+		if (typeof state.callModel === "function") patchCallModel(proto, state);
+	}
+	unpatchOpenRouterClass(OpenRouterClass) {
+		const proto = OpenRouterClass.prototype;
+		const state = proto[PATCH_STATE_SYMBOL];
+		if (!state) return;
+		for (const kind of RESOURCE_KINDS) if (state[kind]) Object.defineProperty(proto, kind, state[kind]);
+		else delete proto[kind];
+		if (state.callModel) proto.callModel = state.callModel;
+		delete proto[PATCH_STATE_SYMBOL];
+	}
+};
+const patchResourceGetter = (proto, kind, state) => {
+	const descriptor = state[kind];
+	if (!descriptor?.get || !descriptor.configurable) {
+		_opentelemetry_api.diag.warn(`Could not patch OpenRouter.prototype.${kind} getter.`);
+		return;
+	}
+	const originalGet = descriptor.get;
+	Object.defineProperty(proto, kind, {
+		configurable: true,
+		enumerable: descriptor.enumerable ?? false,
+		get() {
+			const resource = originalGet.call(this);
+			patchResourceMethod(resource, kind, state);
+			return resource;
+		}
+	});
+};
+const patchResourceMethod = (resource, kind, state) => {
+	if (!resource || resource[WRAPPED_SYMBOL]) return;
+	const { method, requestKey } = RESOURCE_METHODS[kind];
+	if (typeof resource[method] !== "function") return;
+	const original = resource[method].bind(resource);
+	resource[method] = async (request, options) => {
+		if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original(request, options);
+		const { traceContent } = state;
+		const span = Laminar.startSpan({
+			name: `openrouter.${kind}`,
+			spanType: "LLM"
+		});
+		span.setAttribute("gen_ai.system", "openrouter");
+		setRequestAttributes(span, kind, request?.[requestKey], traceContent);
+		try {
+			const response = await Laminar.withSpan(span, () => original(request, options));
+			if (isAsyncIterable(response)) return wrapStream(span, kind, response, traceContent);
+			setResponseAttributes(span, kind, response, traceContent);
+			span.end();
+			return response;
+		} catch (error) {
+			recordError(span, error);
+			span.end();
+			throw error;
+		}
+	};
+	resource[WRAPPED_SYMBOL] = true;
+};
+const patchCallModel = (proto, state) => {
+	const originalCallModel = state.callModel;
+	proto.callModel = function(request, options) {
+		if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return originalCallModel.call(this, request, options);
+		const { traceContent } = state;
+		const span = Laminar.startSpan({
+			name: "openrouter.call_model",
+			input: traceContent ? responsesInputMessages(request) : void 0
+		});
+		const tools = Array.isArray(request?.tools) ? request.tools.map((tool) => wrapTool(tool, span, traceContent)) : void 0;
+		try {
+			const result = Laminar.withSpan(span, () => originalCallModel.call(this, tools ? {
+				...request,
+				tools
+			} : request, options));
+			instrumentModelResult(result, span, traceContent);
+			return result;
+		} catch (error) {
+			recordError(span, error);
+			span.end();
+			throw error;
+		}
+	};
+};
+const wrapTool = (tool, parentSpan, traceContent) => {
+	const fn = tool?.function;
+	if (typeof fn?.execute !== "function" || fn.eventSchema) return tool;
+	const execute = fn.execute;
+	return {
+		...tool,
+		function: {
+			...fn,
+			execute: (input, ctx) => Laminar.withSpan(parentSpan, () => {
+				const span = Laminar.startSpan({
+					name: fn.name,
+					spanType: "TOOL",
+					input: traceContent ? input : void 0
+				});
+				return Laminar.withSpan(span, async () => {
+					try {
+						const result = await execute(input, ctx);
+						if (traceContent) span.setOutput(result);
+						return result;
+					} catch (error) {
+						recordError(span, error);
+						throw error;
+					}
+				}, true);
+			})
+		}
+	};
+};
+/**
+* ModelResult runs lazily on first consumption. Each turn's request goes through
+* getInitialResponse / makeFollowupRequest, and executeToolsIfNeeded is the
+* memoized promise every consumption path awaits.
+*/
+const instrumentModelResult = (result, parentSpan, traceContent) => {
+	if (!result || typeof result.executeToolsIfNeeded !== "function") {
+		parentSpan.end();
+		return;
+	}
+	for (const method of ["getInitialResponse", "makeFollowupRequest"]) {
+		if (typeof result[method] !== "function") continue;
+		const original = result[method].bind(result);
+		result[method] = (...args) => Laminar.withSpan(parentSpan, () => {
+			const span = Laminar.startSpan({
+				name: "openrouter.responses",
+				spanType: "LLM"
+			});
+			span.setAttribute("gen_ai.system", "openrouter");
+			return Laminar.withSpan(span, async () => {
+				try {
+					const response = await original(...args);
+					setRequestAttributes(span, "responses", result.resolvedRequest, traceContent);
+					setResponseAttributes(span, "responses", response, traceContent);
+					return response;
+				} catch (error) {
+					recordError(span, error);
+					throw error;
+				}
+			}, true);
+		});
+	}
+	const originalExecute = result.executeToolsIfNeeded.bind(result);
+	let execution;
+	result.executeToolsIfNeeded = () => {
+		if (execution) return execution;
+		const promise = originalExecute();
+		execution = promise;
+		promise.then(() => {
+			if (traceContent && result.finalResponse?.output) parentSpan.setOutput(result.finalResponse.output);
+			parentSpan.end();
+		}, (error) => {
+			recordError(parentSpan, error);
+			parentSpan.end();
+		});
+		return execution;
+	};
+};
+//#endregion
 //#region src/version.ts
 const getLangVersion = () => {
 	if (process?.versions?.node) return `node@${process.versions.node}`;
@@ -6680,6 +7084,7 @@ const initInstrumentations = (client, suppressContentTracing, sessionRecordingOp
 	instrumentations.push(new ClaudeAgentSDKInstrumentation());
 	instrumentations.push(new OpencodeInstrumentation());
 	instrumentations.push(new OpenAIAgentsInstrumentation());
+	instrumentations.push(new OpenRouterInstrumentation({ traceContent: !suppressContentTracing }));
 	return instrumentations;
 };
 const manuallyInitInstrumentations = (client, instrumentModules, suppressContentTracing, sessionRecordingOptions) => {
@@ -6769,6 +7174,11 @@ const manuallyInitInstrumentations = (client, instrumentModules, suppressContent
 		instrumentations.push(googleGenAiInstrumentation);
 		googleGenAiInstrumentation.manuallyInstrument(instrumentModules.google_genai);
 	}
+	if (instrumentModules?.openrouter) {
+		const openRouterInstrumentation = new OpenRouterInstrumentation({ traceContent: !suppressContentTracing });
+		instrumentations.push(openRouterInstrumentation);
+		openRouterInstrumentation.manuallyInstrument(instrumentModules.openrouter);
+	}
 	if (instrumentModules?.kernel) {
 		const kernelInstrumentation = new KernelInstrumentation();
 		instrumentations.push(kernelInstrumentation);