@lmnr-ai/client 0.8.1

package/dist/index.cjs

@@ -0,0 +1,692 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let dotenv = require("dotenv");
+let path = require("path");
+path = __toESM(path);
+let pino = require("pino");
+pino = __toESM(pino);
+let pino_pretty = require("pino-pretty");
+let uuid = require("uuid");
+
+//#region package.json
+var version = "0.8.1";
+
+//#endregion
+//#region src/version.ts
+function getLangVersion() {
+	if (typeof process !== "undefined" && process.versions && process.versions.node) return `node-${process.versions.node}`;
+	if (typeof navigator !== "undefined" && navigator.userAgent) return `browser-${navigator.userAgent}`;
+	return null;
+}
+
+//#endregion
+//#region src/resources/index.ts
+var BaseResource = class {
+	constructor(baseHttpUrl, projectApiKey) {
+		this.baseHttpUrl = baseHttpUrl;
+		this.projectApiKey = projectApiKey;
+	}
+	headers() {
+		return {
+			Authorization: `Bearer ${this.projectApiKey}`,
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		};
+	}
+	async handleError(response) {
+		const errorMsg = await response.text();
+		throw new Error(`${response.status} ${errorMsg}`);
+	}
+};
+
+//#endregion
+//#region src/resources/browser-events.ts
+var BrowserEventsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	async send({ sessionId, traceId, events }) {
+		const payload = {
+			sessionId,
+			traceId,
+			events,
+			source: getLangVersion() ?? "javascript",
+			sdkVersion: version
+		};
+		const jsonString = JSON.stringify(payload);
+		const compressedStream = new Blob([jsonString], { type: "application/json" }).stream().pipeThrough(new CompressionStream("gzip"));
+		const compressedData = await new Response(compressedStream).arrayBuffer();
+		const response = await fetch(this.baseHttpUrl + "/v1/browser-sessions/events", {
+			method: "POST",
+			headers: {
+				...this.headers(),
+				"Content-Encoding": "gzip"
+			},
+			body: compressedData
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+function initializeLogger(options) {
+	const colorize = options?.colorize ?? true;
+	const level = options?.level ?? process.env.LMNR_LOG_LEVEL?.toLowerCase()?.trim() ?? "info";
+	return (0, pino.default)({ level }, (0, pino_pretty.PinoPretty)({
+		colorize,
+		minimumLevel: level
+	}));
+}
+const logger$2 = initializeLogger();
+const isStringUUID = (id) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id);
+const newUUID = () => {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	else return (0, uuid.v4)();
+};
+const otelSpanIdToUUID = (spanId) => {
+	let id = spanId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	if (id.length !== 16) logger$2.warn(`Span ID ${spanId} is not 16 hex chars long. This is not a valid OpenTelemetry span ID.`);
+	if (!/^[0-9a-f]+$/.test(id)) {
+		logger$2.error(`Span ID ${spanId} is not a valid hex string. Generating a random UUID instead.`);
+		return newUUID();
+	}
+	return id.padStart(32, "0").replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+};
+const otelTraceIdToUUID = (traceId) => {
+	let id = traceId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	if (id.length !== 32) logger$2.warn(`Trace ID ${traceId} is not 32 hex chars long. This is not a valid OpenTelemetry trace ID.`);
+	if (!/^[0-9a-f]+$/.test(id)) {
+		logger$2.error(`Trace ID ${traceId} is not a valid hex string. Generating a random UUID instead.`);
+		return newUUID();
+	}
+	return id.replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+};
+const slicePayload = (value, length) => {
+	if (value === null || value === void 0) return value;
+	const str = JSON.stringify(value);
+	if (str.length <= length) return value;
+	return str.slice(0, length) + "...";
+};
+const loadEnv = (options) => {
+	const nodeEnv = process.env.NODE_ENV || "development";
+	const envDir = process.cwd();
+	const envFiles = [
+		".env",
+		".env.local",
+		`.env.${nodeEnv}`,
+		`.env.${nodeEnv}.local`
+	];
+	const logLevel = process.env.LMNR_LOG_LEVEL ?? "info";
+	const verbose = ["debug", "trace"].includes(logLevel.trim().toLowerCase());
+	const quiet = options?.quiet ?? !verbose;
+	(0, dotenv.config)({
+		path: options?.paths ?? envFiles.map((envFile) => path.resolve(envDir, envFile)),
+		quiet
+	});
+};
+
+//#endregion
+//#region src/resources/datasets.ts
+const logger$1 = initializeLogger();
+const DEFAULT_DATASET_PULL_LIMIT = 100;
+const DEFAULT_DATASET_PUSH_BATCH_SIZE = 100;
+var DatasetsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* List all datasets.
+	*
+	* @returns {Promise<Dataset[]>} Array of datasets
+	*/
+	async listDatasets() {
+		const response = await fetch(this.baseHttpUrl + "/v1/datasets", {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Get a dataset by name.
+	*
+	* @param {string} name - Name of the dataset
+	* @returns {Promise<Dataset[]>} Array of datasets with matching name
+	*/
+	async getDatasetByName(name) {
+		const params = new URLSearchParams({ name });
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Push datapoints to a dataset.
+	*
+	* @param {Object} options - Push options
+	* @param {Datapoint<D, T>[]} options.points - Datapoints to push
+	* @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+	* @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+	* @param {number} [options.batchSize] - Batch size for pushing (default: 100)
+	* @param {boolean} [options.createDataset] - Whether to create the dataset if it doesn't exist
+	* @returns {Promise<PushDatapointsResponse | undefined>}
+	*/
+	async push({ points, name, id, batchSize = DEFAULT_DATASET_PUSH_BATCH_SIZE, createDataset = false }) {
+		if (!name && !id) throw new Error("Either name or id must be provided");
+		if (name && id) throw new Error("Only one of name or id must be provided");
+		if (createDataset && !name) throw new Error("Name must be provided when creating a new dataset");
+		const identifier = name ? { name } : { datasetId: id };
+		const totalBatches = Math.ceil(points.length / batchSize);
+		let response;
+		for (let i = 0; i < points.length; i += batchSize) {
+			const batchNum = Math.floor(i / batchSize) + 1;
+			logger$1.debug(`Pushing batch ${batchNum} of ${totalBatches}`);
+			const batch = points.slice(i, i + batchSize);
+			const fetchResponse = await fetch(this.baseHttpUrl + "/v1/datasets/datapoints", {
+				method: "POST",
+				headers: this.headers(),
+				body: JSON.stringify({
+					...identifier,
+					datapoints: batch.map((point) => ({
+						data: point.data,
+						target: point.target ?? {},
+						metadata: point.metadata ?? {}
+					})),
+					createDataset
+				})
+			});
+			if (fetchResponse.status !== 200 && fetchResponse.status !== 201) await this.handleError(fetchResponse);
+			response = await fetchResponse.json();
+		}
+		return response;
+	}
+	/**
+	* Pull datapoints from a dataset.
+	*
+	* @param {Object} options - Pull options
+	* @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+	* @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+	* @param {number} [options.limit] - Maximum number of datapoints to return (default: 100)
+	* @param {number} [options.offset] - Offset for pagination (default: 0)
+	* @returns {Promise<GetDatapointsResponse<D, T>>}
+	*/
+	async pull({ name, id, limit = DEFAULT_DATASET_PULL_LIMIT, offset = 0 }) {
+		if (!name && !id) throw new Error("Either name or id must be provided");
+		if (name && id) throw new Error("Only one of name or id must be provided");
+		const paramsObj = {
+			offset: offset.toString(),
+			limit: limit.toString()
+		};
+		if (name) paramsObj.name = name;
+		else paramsObj.datasetId = id;
+		const params = new URLSearchParams(paramsObj);
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets/datapoints?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+};
+
+//#endregion
+//#region src/resources/evals.ts
+const logger = initializeLogger();
+const INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 16e6;
+var EvalsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Initialize an evaluation.
+	*
+	* @param {string} name - Name of the evaluation
+	* @param {string} groupName - Group name of the evaluation
+	* @param {Record<string, any>} metadata - Optional metadata
+	* @returns {Promise<InitEvaluationResponse>} Response from the evaluation initialization
+	*/
+	async init(name, groupName, metadata) {
+		const response = await fetch(this.baseHttpUrl + "/v1/evals", {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				name: name ?? null,
+				groupName: groupName ?? null,
+				metadata: metadata ?? null
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Create a new evaluation and return its ID.
+	*
+	* @param {string} [name] - Optional name of the evaluation
+	* @param {string} [groupName] - An identifier to group evaluations
+	* @param {Record<string, any>} [metadata] - Optional metadata
+	* @returns {Promise<StringUUID>} The evaluation ID
+	*/
+	async create(args) {
+		return (await this.init(args?.name, args?.groupName, args?.metadata)).id;
+	}
+	/**
+	* Create a new evaluation and return its ID.
+	* @deprecated use `create` instead.
+	*/
+	async createEvaluation(name, groupName, metadata) {
+		return (await this.init(name, groupName, metadata)).id;
+	}
+	/**
+	* Create a datapoint for an evaluation.
+	*
+	* @param {Object} options - Create datapoint options
+	* @param {string} options.evalId - The evaluation ID
+	* @param {D} options.data - The input data for the executor
+	* @param {T} [options.target] - The target/expected output for evaluators
+	* @param {Record<string, any>} [options.metadata] - Optional metadata
+	* @param {number} [options.index] - Optional index of the datapoint
+	* @param {string} [options.traceId] - Optional trace ID
+	* @returns {Promise<StringUUID>} The datapoint ID
+	*/
+	async createDatapoint({ evalId, data, target, metadata, index, traceId }) {
+		const datapointId = newUUID();
+		const partialDatapoint = {
+			id: datapointId,
+			data,
+			target,
+			index: index ?? 0,
+			traceId: traceId ?? newUUID(),
+			executorSpanId: newUUID(),
+			metadata
+		};
+		await this.saveDatapoints({
+			evalId,
+			datapoints: [partialDatapoint]
+		});
+		return datapointId;
+	}
+	/**
+	* Update a datapoint with evaluation results.
+	*
+	* @param {Object} options - Update datapoint options
+	* @param {string} options.evalId - The evaluation ID
+	* @param {string} options.datapointId - The datapoint ID
+	* @param {Record<string, number>} options.scores - The scores
+	* @param {O} [options.executorOutput] - The executor output
+	* @returns {Promise<void>}
+	*/
+	async updateDatapoint({ evalId, datapointId, scores, executorOutput }) {
+		const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints/${datapointId}`, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				executorOutput,
+				scores
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	/**
+	* Save evaluation datapoints.
+	*
+	* @param {Object} options - Save datapoints options
+	* @param {string} options.evalId - ID of the evaluation
+	* @param {EvaluationDatapoint<D, T, O>[]} options.datapoints - Datapoint to add
+	* @param {string} [options.groupName] - Group name of the evaluation
+	* @returns {Promise<void>} Response from the datapoint addition
+	*/
+	async saveDatapoints({ evalId, datapoints, groupName }) {
+		const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints`, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				points: datapoints.map((d) => ({
+					...d,
+					data: slicePayload(d.data, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH),
+					target: slicePayload(d.target, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH),
+					executorOutput: slicePayload(d.executorOutput, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH)
+				})),
+				groupName: groupName ?? null
+			})
+		});
+		if (response.status === 413) return await this.retrySaveDatapoints({
+			evalId,
+			datapoints,
+			groupName
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	/**
+	* Get evaluation datapoints.
+	*
+	* @deprecated Use `client.datasets.pull()` instead.
+	* @param {Object} options - Get datapoints options
+	* @param {string} options.datasetName - Name of the dataset
+	* @param {number} options.offset - Offset at which to start the query
+	* @param {number} options.limit - Maximum number of datapoints to return
+	* @returns {Promise<GetDatapointsResponse>} Response from the datapoint retrieval
+	*/
+	async getDatapoints({ datasetName, offset, limit }) {
+		logger.warn("evals.getDatapoints() is deprecated. Use client.datasets.pull() instead.");
+		const params = new URLSearchParams({
+			name: datasetName,
+			offset: offset.toString(),
+			limit: limit.toString()
+		});
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets/datapoints?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return await response.json();
+	}
+	async retrySaveDatapoints({ evalId, datapoints, groupName, maxRetries = 25, initialLength = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH }) {
+		let length = initialLength;
+		let lastResponse = null;
+		for (let i = 0; i < maxRetries; i++) {
+			logger.debug(`Retrying save datapoints... ${i + 1} of ${maxRetries}, length: ${length}`);
+			const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints`, {
+				method: "POST",
+				headers: this.headers(),
+				body: JSON.stringify({
+					points: datapoints.map((d) => ({
+						...d,
+						data: slicePayload(d.data, length),
+						target: slicePayload(d.target, length),
+						executorOutput: slicePayload(d.executorOutput, length)
+					})),
+					groupName: groupName ?? null
+				})
+			});
+			lastResponse = response;
+			length = Math.floor(length / 2);
+			if (response.status !== 413) break;
+		}
+		if (lastResponse && !lastResponse.ok) await this.handleError(lastResponse);
+	}
+};
+
+//#endregion
+//#region src/resources/evaluators.ts
+var EvaluatorScoreSourceType = /* @__PURE__ */ function(EvaluatorScoreSourceType$1) {
+	EvaluatorScoreSourceType$1["Evaluator"] = "Evaluator";
+	EvaluatorScoreSourceType$1["Code"] = "Code";
+	return EvaluatorScoreSourceType$1;
+}(EvaluatorScoreSourceType || {});
+/**
+* Resource for creating evaluator scores
+*/
+var EvaluatorsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Create a score for a span or trace
+	*
+	* @param {ScoreOptions} options - Score creation options
+	* @param {string} options.name - Name of the score
+	* @param {string} [options.traceId] - The trace ID to score (will be attached to top-level span)
+	* @param {string} [options.spanId] - The span ID to score
+	* @param {Record<string, any>} [options.metadata] - Additional metadata
+	* @param {number} options.score - The score value (float)
+	* @returns {Promise<void>}
+	*
+	* @example
+	* // Score by trace ID (will attach to root span)
+	* await evaluators.score({
+	*   name: "quality",
+	*   traceId: "trace-id-here",
+	*   score: 0.95,
+	*   metadata: { model: "gpt-4" }
+	* });
+	*
+	* @example
+	* // Score by span ID
+	* await evaluators.score({
+	*   name: "relevance",
+	*   spanId: "span-id-here",
+	*   score: 0.87
+	* });
+	*/
+	async score(options) {
+		const { name, metadata, score } = options;
+		let payload;
+		if ("traceId" in options && options.traceId) {
+			const formattedTraceId = isStringUUID(options.traceId) ? options.traceId : otelTraceIdToUUID(options.traceId);
+			payload = {
+				name,
+				metadata,
+				score,
+				source: EvaluatorScoreSourceType.Code,
+				traceId: formattedTraceId
+			};
+		} else if ("spanId" in options && options.spanId) {
+			const formattedSpanId = isStringUUID(options.spanId) ? options.spanId : otelSpanIdToUUID(options.spanId);
+			payload = {
+				name,
+				metadata,
+				score,
+				source: EvaluatorScoreSourceType.Code,
+				spanId: formattedSpanId
+			};
+		} else throw new Error("Either 'traceId' or 'spanId' must be provided.");
+		const response = await fetch(this.baseHttpUrl + "/v1/evaluators/score", {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify(payload)
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+
+//#endregion
+//#region src/resources/rollout-sessions.ts
+var RolloutSessionsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Connects to the SSE stream for rollout debugging sessions
+	* Returns the Response object for streaming SSE events
+	*/
+	async connect({ sessionId, name, params, signal }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}`, {
+			method: "POST",
+			headers: {
+				...this.headers(),
+				"Accept": "text/event-stream"
+			},
+			body: JSON.stringify({
+				name,
+				params
+			}),
+			signal
+		});
+		if (!response.ok) throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+		if (!response.body) throw new Error("No response body");
+		return response;
+	}
+	async delete({ sessionId }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}`, {
+			method: "DELETE",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	async setStatus({ sessionId, status }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}/status`, {
+			method: "PATCH",
+			headers: this.headers(),
+			body: JSON.stringify({ status })
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	async sendSpanUpdate({ sessionId, span }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}/update`, {
+			method: "PATCH",
+			headers: this.headers(),
+			body: JSON.stringify({
+				type: "spanStart",
+				spanId: otelSpanIdToUUID(span.spanId),
+				traceId: otelTraceIdToUUID(span.traceId),
+				parentSpanId: span.parentSpanId ? otelSpanIdToUUID(span.parentSpanId) : void 0,
+				attributes: span.attributes,
+				startTime: span.startTime,
+				name: span.name,
+				spanType: span.spanType
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+
+//#endregion
+//#region src/resources/sql.ts
+var SqlResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	async query(sql, parameters = {}) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/sql/query`, {
+			method: "POST",
+			headers: { ...this.headers() },
+			body: JSON.stringify({
+				query: sql,
+				parameters
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+		return (await response.json()).data;
+	}
+};
+
+//#endregion
+//#region src/resources/tags.ts
+/** Resource for tagging traces. */
+var TagsResource = class extends BaseResource {
+	/** Resource for tagging traces. */
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Tag a trace with a list of tags. Note that the trace must be ended before
+	* tagging it. You may want to call `await Laminar.flush()` after the trace
+	* that you want to tag.
+	*
+	* @param {string | StringUUID} trace_id - The trace id to tag.
+	* @param {string[] | string} tags - The tag or list of tags to add to the trace.
+	* @returns {Promise<any>} The response from the server.
+	* @example
+	* ```javascript
+	* import { Laminar, observe, LaminarClient } from "@lmnr-ai/lmnr";
+	* Laminar.initialize();
+	* const client = new LaminarClient();
+	* let traceId: StringUUID | null = null;
+	* // Make sure this is called outside of traced context.
+	* await observe(
+	*   {
+	*     name: "my-trace",
+	*   },
+	*   async () => {
+	*     traceId = await Laminar.getTraceId();
+	*     await foo();
+	*   },
+	* );
+	*
+	* // or make sure the trace is ended by this point.
+	* await Laminar.flush();
+	* if (traceId) {
+	*   await client.tags.tag(traceId, ["tag1", "tag2"]);
+	* }
+	* ```
+	*/
+	async tag(trace_id, tags) {
+		const traceTags = Array.isArray(tags) ? tags : [tags];
+		const formattedTraceId = isStringUUID(trace_id) ? trace_id : otelTraceIdToUUID(trace_id);
+		const url = this.baseHttpUrl + "/v1/tag";
+		const payload = {
+			"traceId": formattedTraceId,
+			"names": traceTags
+		};
+		const response = await fetch(url, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify(payload)
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+};
+
+//#endregion
+//#region src/index.ts
+var LaminarClient = class {
+	constructor({ baseUrl, projectApiKey, port } = {}) {
+		loadEnv();
+		this.projectApiKey = projectApiKey ?? process.env.LMNR_PROJECT_API_KEY;
+		const httpPort = port ?? (baseUrl?.match(/:\d{1,5}$/g) ? parseInt(baseUrl.match(/:\d{1,5}$/g)[0].slice(1)) : 443);
+		this.baseUrl = `${(baseUrl ?? process.env.LMNR_BASE_URL)?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "") ?? "https://api.lmnr.ai"}:${httpPort}`;
+		this._browserEvents = new BrowserEventsResource(this.baseUrl, this.projectApiKey);
+		this._datasets = new DatasetsResource(this.baseUrl, this.projectApiKey);
+		this._evals = new EvalsResource(this.baseUrl, this.projectApiKey);
+		this._evaluators = new EvaluatorsResource(this.baseUrl, this.projectApiKey);
+		this._rolloutSessions = new RolloutSessionsResource(this.baseUrl, this.projectApiKey);
+		this._sql = new SqlResource(this.baseUrl, this.projectApiKey);
+		this._tags = new TagsResource(this.baseUrl, this.projectApiKey);
+	}
+	get browserEvents() {
+		return this._browserEvents;
+	}
+	get datasets() {
+		return this._datasets;
+	}
+	get evals() {
+		return this._evals;
+	}
+	get evaluators() {
+		return this._evaluators;
+	}
+	get rolloutSessions() {
+		return this._rolloutSessions;
+	}
+	get sql() {
+		return this._sql;
+	}
+	get tags() {
+		return this._tags;
+	}
+};
+
+//#endregion
+exports.LaminarClient = LaminarClient;
+//# sourceMappingURL=index.cjs.map