@lmnr-ai/lmnr 0.8.47 → 0.8.49

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-Cibdqbyh.cjs");
+const require_utils = require("./utils-D8kgcFxb.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-D8HN2emo.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-N65ihgSU.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$1(span, key, value) {
+function safeSetAttribute$2(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$1(span, params, traceContent) {
-	safeSetAttribute$1(span, LLM_SYSTEM, "gemini");
-	safeSetAttribute$1(span, LLM_REQUEST_MODEL, params?.model);
+function setRequestAttributes$2(span, params, traceContent) {
+	safeSetAttribute$2(span, LLM_SYSTEM, "gemini");
+	safeSetAttribute$2(span, LLM_REQUEST_MODEL, params?.model);
 	const config = params?.config;
 	if (config) {
-		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));
+		safeSetAttribute$2(span, "gen_ai.request.temperature", config.temperature);
+		safeSetAttribute$2(span, "gen_ai.request.top_p", config.topP);
+		safeSetAttribute$2(span, "gen_ai.request.top_k", config.topK);
+		safeSetAttribute$2(span, "gen_ai.request.max_tokens", config.maxOutputTokens);
+		safeSetAttribute$2(span, "gen_ai.request.frequency_penalty", config.frequencyPenalty);
+		safeSetAttribute$2(span, "gen_ai.request.presence_penalty", config.presencePenalty);
+		safeSetAttribute$2(span, "gen_ai.request.seed", config.seed);
+		safeSetAttribute$2(span, "gen_ai.request.choice_count", config.candidateCount);
+		if (config.stopSequences && config.stopSequences.length > 0) safeSetAttribute$2(span, "gen_ai.request.stop_sequences", JSON.stringify(config.stopSequences));
 		const outputSchema = config.responseSchema ?? config.responseJsonSchema;
-		if (outputSchema) safeSetAttribute$1(span, "gen_ai.request.structured_output_schema", JSON.stringify(toDict(outputSchema)));
+		if (outputSchema) safeSetAttribute$2(span, "gen_ai.request.structured_output_schema", JSON.stringify(toDict(outputSchema)));
 		const toolDefs = extractToolDefinitions(config);
-		if (toolDefs.length > 0) safeSetAttribute$1(span, "gen_ai.tool.definitions", JSON.stringify(toolDefs));
+		if (toolDefs.length > 0) safeSetAttribute$2(span, "gen_ai.tool.definitions", JSON.stringify(toolDefs));
 	}
 	if (traceContent) {
 		const messages = contentToMessages(params?.contents, config?.systemInstruction);
-		if (messages.length > 0) safeSetAttribute$1(span, "gen_ai.input.messages", JSON.stringify(messages));
+		if (messages.length > 0) safeSetAttribute$2(span, "gen_ai.input.messages", JSON.stringify(messages));
 	}
 }
 /**
 * Set response attributes on a span from a GenerateContentResponse.
 */
-function setResponseAttributes$1(span, response, traceContent) {
+function setResponseAttributes$2(span, response, traceContent) {
 	if (!response) return;
-	safeSetAttribute$1(span, LLM_RESPONSE_MODEL, response.modelVersion);
+	safeSetAttribute$2(span, LLM_RESPONSE_MODEL, response.modelVersion);
 	const usage = response.usageMetadata;
 	if (usage) {
-		safeSetAttribute$1(span, "gen_ai.usage.input_tokens", usage.promptTokenCount);
+		safeSetAttribute$2(span, "gen_ai.usage.input_tokens", usage.promptTokenCount);
 		const outputTokens = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
-		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 (outputTokens > 0) safeSetAttribute$2(span, "gen_ai.usage.output_tokens", outputTokens);
+		safeSetAttribute$2(span, LLM_USAGE_TOTAL_TOKENS, usage.totalTokenCount);
+		safeSetAttribute$2(span, "gen_ai.usage.reasoning_tokens", usage.thoughtsTokenCount);
+		safeSetAttribute$2(span, "gen_ai.usage.cache_read_input_tokens", usage.cachedContentTokenCount);
 	}
 	if (traceContent && response.candidates) {
 		const outputMessages = [];
@@ -4719,7 +4719,7 @@ function setResponseAttributes$1(span, response, traceContent) {
 				...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
 			});
 		}
-		if (outputMessages.length > 0) safeSetAttribute$1(span, "gen_ai.output.messages", JSON.stringify(outputMessages));
+		if (outputMessages.length > 0) safeSetAttribute$2(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$1(span, {
+					setResponseAttributes$2(span, {
 						modelVersion,
 						candidates: [{ content: {
 							role: role ?? "model",
@@ -4909,11 +4909,11 @@ var GoogleGenAiInstrumentation = class extends _opentelemetry_instrumentation.In
 				name: "gemini.generate_content",
 				spanType: "LLM"
 			});
-			setRequestAttributes$1(span, params, classPatchData.traceContent);
+			setRequestAttributes$2(span, params, classPatchData.traceContent);
 			return Laminar.withSpan(span, async () => {
 				try {
 					const response = await originalGenerateContent(params);
-					setResponseAttributes$1(span, response, classPatchData.traceContent);
+					setResponseAttributes$2(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$1(span, params, classPatchData.traceContent);
+			setRequestAttributes$2(span, params, classPatchData.traceContent);
 			try {
 				return wrapStreamingResponse(span, await originalGenerateContentStream(params), classPatchData.traceContent);
 			} catch (error) {
@@ -5761,12 +5761,12 @@ const TERMINAL_RESPONSE_EVENTS = new Set([
 	"response.failed"
 ]);
 const ERROR_RESPONSE_STATUSES = new Set(["failed", "incomplete"]);
-const safeSetAttribute = (span, key, value) => {
+const safeSetAttribute$1 = (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) => {
+const recordError$1 = (span, error) => {
 	span.setAttribute("error.type", error?.constructor?.name ?? "Error");
 	span.recordException(error);
 	span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
@@ -5797,49 +5797,49 @@ const structuredOutputSchema = (kind, request) => {
 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);
+const setRequestAttributes$1 = (span, kind, request, traceContent) => {
+	safeSetAttribute$1(span, "gen_ai.request.model", request?.model);
+	safeSetAttribute$1(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)));
+		if (traceContent && request?.input !== void 0) safeSetAttribute$1(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);
+	safeSetAttribute$1(span, "gen_ai.request.temperature", request?.temperature);
+	safeSetAttribute$1(span, "gen_ai.request.top_p", request?.topP);
+	safeSetAttribute$1(span, "gen_ai.request.frequency_penalty", request?.frequencyPenalty);
+	safeSetAttribute$1(span, "gen_ai.request.presence_penalty", request?.presencePenalty);
+	safeSetAttribute$1(span, "gen_ai.request.reasoning_effort", request?.reasoningEffort ?? request?.reasoning?.effort);
+	safeSetAttribute$1(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 (schema) safeSetAttribute$1(span, "gen_ai.request.structured_output_schema", JSON.stringify(schema));
+	if (request?.stream) safeSetAttribute$1(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));
+	if (Array.isArray(request?.tools) && request.tools.length > 0) safeSetAttribute$1(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));
+	if (Array.isArray(messages) && messages.length > 0) safeSetAttribute$1(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);
+	safeSetAttribute$1(span, "gen_ai.usage.input_tokens", usage[inputKey]);
+	safeSetAttribute$1(span, "gen_ai.usage.output_tokens", usage[outputKey]);
+	safeSetAttribute$1(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]);
+	safeSetAttribute$1(span, "gen_ai.usage.cache_read_input_tokens", inputDetails?.cachedTokens);
+	safeSetAttribute$1(span, "gen_ai.usage.cache_creation_input_tokens", inputDetails?.cacheWriteTokens);
+	safeSetAttribute$1(span, "gen_ai.usage.reasoning_tokens", usage[`${outputKey}Details`]?.reasoningTokens);
+	safeSetAttribute$1(span, "gen_ai.usage.cost", usage.cost);
+	safeSetAttribute$1(span, "gen_ai.usage.input_cost", usage.costDetails?.[inputCostKey]);
+	safeSetAttribute$1(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) => {
+const setResponseAttributes$1 = (span, kind, response, traceContent) => {
 	if (!response) return;
-	safeSetAttribute(span, "gen_ai.response.id", response.id);
-	safeSetAttribute(span, "gen_ai.response.model", response.model);
+	safeSetAttribute$1(span, "gen_ai.response.id", response.id);
+	safeSetAttribute$1(span, "gen_ai.response.model", response.model);
 	if (kind === "responses") {
 		setUsageAttributes(span, response.usage, "inputTokens", "outputTokens", "upstreamInferenceInputCost", "upstreamInferenceOutputCost");
 		const error = responsesErrorMessage(response);
@@ -5853,7 +5853,7 @@ const setResponseAttributes = (span, kind, response, traceContent) => {
 	} 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));
+	if (Array.isArray(output) && output.length > 0) safeSetAttribute$1(span, "gen_ai.output.messages", JSON.stringify(output));
 };
 const aggregateChatChunks = (chunks) => {
 	const result = {
@@ -5922,11 +5922,11 @@ const wrapStream = (span, kind, stream, traceContent) => {
 				yield chunk;
 			}
 		} catch (error) {
-			recordError(span, error);
+			recordError$1(span, error);
 			throw error;
 		} finally {
 			try {
-				setResponseAttributes(span, kind, kind === "chat" ? aggregateChatChunks(chunks) : responseFromStreamEvents(chunks), traceContent);
+				setResponseAttributes$1(span, kind, kind === "chat" ? aggregateChatChunks(chunks) : responseFromStreamEvents(chunks), traceContent);
 			} finally {
 				span.end();
 			}
@@ -5938,7 +5938,7 @@ const wrapStream = (span, kind, stream, traceContent) => {
 //#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");
+const PATCH_STATE_SYMBOL$1 = Symbol("lmnr.openrouter.patch-state");
 /** The method each resource sends on, and the key its request is wrapped in. */
 const RESOURCE_METHODS = {
 	chat: {
@@ -5986,7 +5986,7 @@ var OpenRouterInstrumentation = class extends _opentelemetry_instrumentation.Ins
 	}
 	patchOpenRouterClass(OpenRouterClass) {
 		const proto = OpenRouterClass.prototype;
-		const existing = proto[PATCH_STATE_SYMBOL];
+		const existing = proto[PATCH_STATE_SYMBOL$1];
 		if (existing) {
 			existing.traceContent = this.traceContent;
 			return;
@@ -5998,18 +5998,18 @@ var OpenRouterInstrumentation = class extends _opentelemetry_instrumentation.Ins
 			embeddings: Object.getOwnPropertyDescriptor(proto, "embeddings"),
 			callModel: proto.callModel
 		};
-		proto[PATCH_STATE_SYMBOL] = state;
+		proto[PATCH_STATE_SYMBOL$1] = 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];
+		const state = proto[PATCH_STATE_SYMBOL$1];
 		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];
+		delete proto[PATCH_STATE_SYMBOL$1];
 	}
 };
 const patchResourceGetter = (proto, kind, state) => {
@@ -6042,15 +6042,15 @@ const patchResourceMethod = (resource, kind, state) => {
 			spanType: "LLM"
 		});
 		span.setAttribute("gen_ai.system", "openrouter");
-		setRequestAttributes(span, kind, request?.[requestKey], traceContent);
+		setRequestAttributes$1(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);
+			setResponseAttributes$1(span, kind, response, traceContent);
 			span.end();
 			return response;
 		} catch (error) {
-			recordError(span, error);
+			recordError$1(span, error);
 			span.end();
 			throw error;
 		}
@@ -6075,7 +6075,7 @@ const patchCallModel = (proto, state) => {
 			instrumentModelResult(result, span, traceContent);
 			return result;
 		} catch (error) {
-			recordError(span, error);
+			recordError$1(span, error);
 			span.end();
 			throw error;
 		}
@@ -6101,7 +6101,7 @@ const wrapTool = (tool, parentSpan, traceContent) => {
 						if (traceContent) span.setOutput(result);
 						return result;
 					} catch (error) {
-						recordError(span, error);
+						recordError$1(span, error);
 						throw error;
 					}
 				}, true);
@@ -6131,11 +6131,11 @@ const instrumentModelResult = (result, parentSpan, traceContent) => {
 			return Laminar.withSpan(span, async () => {
 				try {
 					const response = await original(...args);
-					setRequestAttributes(span, "responses", result.resolvedRequest, traceContent);
-					setResponseAttributes(span, "responses", response, traceContent);
+					setRequestAttributes$1(span, "responses", result.resolvedRequest, traceContent);
+					setResponseAttributes$1(span, "responses", response, traceContent);
 					return response;
 				} catch (error) {
-					recordError(span, error);
+					recordError$1(span, error);
 					throw error;
 				}
 			}, true);
@@ -6151,7 +6151,7 @@ const instrumentModelResult = (result, parentSpan, traceContent) => {
 			if (traceContent && result.finalResponse?.output) parentSpan.setOutput(result.finalResponse.output);
 			parentSpan.end();
 		}, (error) => {
-			recordError(parentSpan, error);
+			recordError$1(parentSpan, error);
 			parentSpan.end();
 		});
 		return execution;
@@ -7002,6 +7002,140 @@ const LaminarTemporalInterceptors = {
 	ActivityInterceptorFactory
 };
 //#endregion
+//#region src/opentelemetry-lib/instrumentation/typesafe/utils.ts
+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 setRequestAttributes = (span, request, defaultModel, traceContent) => {
+	safeSetAttribute(span, "gen_ai.request.model", request?.model ?? defaultModel);
+	if (!traceContent) return;
+	const state = request?.state;
+	if (state !== null && state !== void 0) {
+		const content = typeof state === "string" ? state : JSON.stringify(state);
+		safeSetAttribute(span, "gen_ai.input.messages", JSON.stringify([{
+			role: "user",
+			content
+		}]));
+	}
+	const questions = request?.questions;
+	if (questions && Object.keys(questions).length > 0) safeSetAttribute(span, "gen_ai.request.structured_output_schema", JSON.stringify(questions));
+};
+/** `body` is the raw `/v1/systemone` JSON: `{ model, usage, answers }`. */
+const setResponseAttributes = (span, body, traceContent) => {
+	if (!body) return;
+	safeSetAttribute(span, "gen_ai.response.model", body.model);
+	safeSetAttribute(span, "gen_ai.usage.input_tokens", body.usage?.input_tokens);
+	safeSetAttribute(span, "gen_ai.usage.output_tokens", body.usage?.output_tokens);
+	if (body.answers && traceContent) safeSetAttribute(span, "gen_ai.output.messages", JSON.stringify([{
+		role: "assistant",
+		content: JSON.stringify(body.answers)
+	}]));
+};
+//#endregion
+//#region src/opentelemetry-lib/instrumentation/typesafe/index.ts
+const PATCH_STATE_SYMBOL = Symbol("lmnr.typesafe.patch-state");
+var TypeSafeInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
+	constructor(config) {
+		super("@lmnr/typesafe-instrumentation", require_utils.version, { enabled: true });
+		this.traceContent = config?.traceContent ?? true;
+	}
+	init() {
+		return new _opentelemetry_instrumentation.InstrumentationNodeModuleDefinition("@typesafe-ai/sdk", [">=0.1.0"], this.patch.bind(this), this.unpatch.bind(this));
+	}
+	manuallyInstrument(typeSafeModule) {
+		_opentelemetry_api.diag.debug("Manually instrumenting @typesafe-ai/sdk");
+		const TypeSafeClientClass = this.resolveClientClass(typeSafeModule);
+		if (TypeSafeClientClass) this.patchClientClass(TypeSafeClientClass);
+		else _opentelemetry_api.diag.warn("Could not find TypeSafeClient class in typesafe manual instrumentation input. Pass either the TypeSafeClient class or the module object with a TypeSafeClient export.");
+	}
+	patch(moduleExports) {
+		_opentelemetry_api.diag.debug("Patching @typesafe-ai/sdk");
+		const TypeSafeClientClass = this.resolveClientClass(moduleExports);
+		if (TypeSafeClientClass) this.patchClientClass(TypeSafeClientClass);
+		return moduleExports;
+	}
+	unpatch(moduleExports) {
+		_opentelemetry_api.diag.debug("Unpatching @typesafe-ai/sdk");
+		const TypeSafeClientClass = this.resolveClientClass(moduleExports);
+		if (TypeSafeClientClass) this.unpatchClientClass(TypeSafeClientClass);
+	}
+	resolveClientClass(moduleOrClass) {
+		if (typeof moduleOrClass === "function") return moduleOrClass;
+		if (typeof moduleOrClass?.TypeSafeClient === "function") return moduleOrClass.TypeSafeClient;
+	}
+	patchClientClass(TypeSafeClientClass) {
+		const proto = TypeSafeClientClass.prototype;
+		const existing = proto[PATCH_STATE_SYMBOL];
+		if (existing) {
+			existing.traceContent = this.traceContent;
+			return;
+		}
+		if (typeof proto.systemOne !== "function") {
+			_opentelemetry_api.diag.warn("Could not patch TypeSafeClient.prototype.systemOne.");
+			return;
+		}
+		const state = {
+			traceContent: this.traceContent,
+			systemOne: proto.systemOne
+		};
+		proto[PATCH_STATE_SYMBOL] = state;
+		proto.systemOne = wrapSystemOne(state);
+	}
+	unpatchClientClass(TypeSafeClientClass) {
+		const proto = TypeSafeClientClass.prototype;
+		const state = proto[PATCH_STATE_SYMBOL];
+		if (!state) return;
+		proto.systemOne = state.systemOne;
+		delete proto[PATCH_STATE_SYMBOL];
+	}
+};
+const wrapSystemOne = (state) => function(request, options) {
+	const original = state.systemOne;
+	if ((0, _opentelemetry_core.isTracingSuppressed)(_opentelemetry_api.context.active())) return original.call(this, request, options);
+	const { traceContent } = state;
+	const span = Laminar.startSpan({
+		name: "typesafe.system_one",
+		spanType: "LLM"
+	});
+	span.setAttribute("gen_ai.system", "typesafe");
+	setRequestAttributes(span, request, this?.defaultModel, traceContent);
+	let promise;
+	try {
+		promise = _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), span), () => original.call(this, request, options));
+	} catch (error) {
+		recordError(span, error);
+		span.end();
+		throw error;
+	}
+	const onError = (error) => {
+		recordError(span, error);
+		span.end();
+	};
+	try {
+		if (typeof promise?.asResponse === "function") promise.asResponse().then(async (response) => {
+			try {
+				setResponseAttributes(span, await response.clone().json(), traceContent);
+			} catch {}
+			span.end();
+		}, onError);
+		else if (typeof promise?.then === "function") promise.then((result) => {
+			setResponseAttributes(span, result, traceContent);
+			span.end();
+		}, onError);
+		else span.end();
+	} catch {
+		span.end();
+	}
+	return promise;
+};
+//#endregion
 //#region src/opentelemetry-lib/tracing/instrumentations.ts
 const logger$7 = require_utils.initializeLogger();
 /**
@@ -7085,6 +7219,7 @@ const initInstrumentations = (client, suppressContentTracing, sessionRecordingOp
 	instrumentations.push(new OpencodeInstrumentation());
 	instrumentations.push(new OpenAIAgentsInstrumentation());
 	instrumentations.push(new OpenRouterInstrumentation({ traceContent: !suppressContentTracing }));
+	instrumentations.push(new TypeSafeInstrumentation({ traceContent: !suppressContentTracing }));
 	return instrumentations;
 };
 const manuallyInitInstrumentations = (client, instrumentModules, suppressContentTracing, sessionRecordingOptions) => {
@@ -7179,6 +7314,11 @@ const manuallyInitInstrumentations = (client, instrumentModules, suppressContent
 		instrumentations.push(openRouterInstrumentation);
 		openRouterInstrumentation.manuallyInstrument(instrumentModules.openrouter);
 	}
+	if (instrumentModules?.typesafe) {
+		const typeSafeInstrumentation = new TypeSafeInstrumentation({ traceContent: !suppressContentTracing });
+		instrumentations.push(typeSafeInstrumentation);
+		typeSafeInstrumentation.manuallyInstrument(instrumentModules.typesafe);
+	}
 	if (instrumentModules?.kernel) {
 		const kernelInstrumentation = new KernelInstrumentation();
 		instrumentations.push(kernelInstrumentation);
@@ -9553,6 +9693,14 @@ var LaminarAiSdkTelemetry = class {
 			}
 			if (typeof event.functionId === "string") span.setAttribute("ai.functionId", event.functionId);
 			if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany" || event.operationId === "ai.rerank") span.setAttribute(require_utils.SPAN_TYPE, "LLM");
+			const { userId, sessionId, tags, ...metadata } = {
+				...event.toolsContext ?? {},
+				...event.runtimeContext ?? {}
+			};
+			if (sessionId) span.setAttribute(require_utils.SESSION_ID, sessionId);
+			if (userId) span.setAttribute(require_utils.USER_ID, userId);
+			if (tags && Array.isArray(tags) && tags.every((tag) => typeof tag === "string")) span.setAttribute(`${require_utils.ASSOCIATION_PROPERTIES}.tags`, tags);
+			span.setAttributes(require_utils.metadataToAttributes(metadata));
 			if (this.recordInputs) {
 				if (Array.isArray(event.messages) || event.system !== void 0 || event.instructions !== void 0) {
 					const msgs = verbatimStandardizedMessages(event);