@use-lattice/litmus 0.121.3

package/dist/src/slack-DSQ1yXVb.cjs

@@ -0,0 +1,135 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+let _slack_web_api = require("@slack/web-api");
+//#region src/providers/slack.ts
+var SlackProvider = class {
+	client;
+	options;
+	constructor(options = {}) {
+		this.options = options;
+		const token = options.config?.token || process.env.SLACK_BOT_TOKEN;
+		if (!token) throw new Error("Slack provider requires a token. Set SLACK_BOT_TOKEN or provide it in config.");
+		if (!options.config?.channel) throw new Error("Slack provider requires a channel ID");
+		this.client = new _slack_web_api.WebClient(token);
+	}
+	id() {
+		return this.options.id || "slack";
+	}
+	async callApi(prompt, _context, _options) {
+		const config = this.options.config;
+		const channel = config.channel;
+		const timeout = config.timeout || 6e4;
+		const responseStrategy = config.responseStrategy || "first";
+		try {
+			const messageText = config.formatMessage ? config.formatMessage(prompt) : prompt;
+			const startTime = Date.now();
+			const postResult = await this.client.chat.postMessage({
+				channel,
+				text: messageText,
+				thread_ts: config.threadTs,
+				mrkdwn: true
+			});
+			if (!postResult.ok || !postResult.ts) throw new Error("Failed to post message to Slack");
+			const messageTs = postResult.ts;
+			let responseText;
+			const responseMetadata = {
+				messageTs,
+				channel
+			};
+			switch (responseStrategy) {
+				case "timeout":
+					responseText = await this.collectResponsesUntilTimeout(channel, messageTs, timeout);
+					break;
+				case "user":
+					if (!config.waitForUser) throw new Error("waitForUser must be specified when using \"user\" response strategy");
+					responseText = await this.waitForUserResponse(channel, messageTs, config.waitForUser, timeout);
+					responseMetadata.waitForUser = config.waitForUser;
+					break;
+				default:
+					responseText = await this.waitForFirstResponse(channel, messageTs, timeout);
+					break;
+			}
+			if (config.includeThread) responseMetadata.threadTs = messageTs;
+			responseMetadata.responseTime = Date.now() - startTime;
+			return {
+				output: responseText,
+				metadata: responseMetadata
+			};
+		} catch (error) {
+			require_logger.logger.error(`Slack provider error: ${error}`);
+			if (error?.data?.error) {
+				const slackError = error.data.error;
+				switch (slackError) {
+					case "channel_not_found": return { error: `Channel ${channel} not found. Please check the channel ID.` };
+					case "not_in_channel": return { error: `Bot is not in channel ${channel}. Please invite the bot first.` };
+					case "missing_scope": return { error: "Bot token is missing required scopes. Please check permissions." };
+					case "ratelimited": return { error: "Slack API rate limit exceeded. Please try again later." };
+					default: return { error: `Slack API error: ${slackError}` };
+				}
+			}
+			return { error: error instanceof Error ? error.message : "Unknown error" };
+		}
+	}
+	async waitForFirstResponse(channel, afterTs, timeout) {
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 10
+			});
+			if (result.messages && result.messages.length > 0) {
+				const response = result.messages.filter((msg) => msg.ts !== afterTs && msg.type === "message" && !msg.bot_id).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0"))[0];
+				if (response && response.text) return response.text;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			require_logger.logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		throw new Error(`Timeout waiting for Slack response after ${timeout}ms`);
+	}
+	async waitForUserResponse(channel, afterTs, userId, timeout) {
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 20
+			});
+			if (result.messages && result.messages.length > 0) {
+				const response = result.messages.filter((msg) => msg.ts !== afterTs && msg.type === "message" && msg.user === userId).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0"))[0];
+				if (response && response.text) return response.text;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			require_logger.logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		throw new Error(`Timeout waiting for response from user ${userId} after ${timeout}ms`);
+	}
+	async collectResponsesUntilTimeout(channel, afterTs, timeout) {
+		const startTime = Date.now();
+		const responses = [];
+		const seenTimestamps = new Set([afterTs]);
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 50
+			});
+			if (result.messages && result.messages.length > 0) result.messages.filter((msg) => !seenTimestamps.has(msg.ts || "") && msg.type === "message" && !msg.bot_id).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0")).forEach((msg) => {
+				if (msg.ts) seenTimestamps.add(msg.ts);
+				if (msg.text) responses.push(msg.text);
+			});
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			require_logger.logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		return responses.join("\n\n");
+	}
+};
+//#endregion
+exports.SlackProvider = SlackProvider;
+
+//# sourceMappingURL=slack-DSQ1yXVb.cjs.map

package/dist/src/store-BwDDaBjb.cjs

@@ -0,0 +1,246 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_tables = require("./tables-3Q2cL7So.cjs");
+let drizzle_orm = require("drizzle-orm");
+//#region src/tracing/store.ts
+const SENSITIVE_ATTRIBUTE_KEYS = [
+	"authorization",
+	"cookie",
+	"set-cookie",
+	"token",
+	"api_key",
+	"apikey",
+	"secret",
+	"password",
+	"passphrase"
+];
+function sanitizeAttributes(attributes) {
+	if (!attributes) return {};
+	const sanitizeValue = (value) => {
+		if (typeof value === "string") return value.length > 400 ? `${value.slice(0, 400)}…` : value;
+		if (Array.isArray(value)) return value.map(sanitizeValue);
+		if (value && typeof value === "object") return sanitizeAttributes(value);
+		return value;
+	};
+	const sanitized = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		const lowerKey = key.toLowerCase();
+		if (SENSITIVE_ATTRIBUTE_KEYS.some((sensitiveKey) => lowerKey.includes(sensitiveKey))) {
+			sanitized[key] = "<redacted>";
+			continue;
+		}
+		sanitized[key] = sanitizeValue(value);
+	}
+	return sanitized;
+}
+function computeDepth(span, spanMap, depthCache) {
+	if (depthCache.has(span.spanId)) return depthCache.get(span.spanId);
+	if (!span.parentSpanId || !spanMap.has(span.parentSpanId)) {
+		depthCache.set(span.spanId, 0);
+		return 0;
+	}
+	const currentDepth = computeDepth(spanMap.get(span.parentSpanId), spanMap, depthCache) + 1;
+	depthCache.set(span.spanId, currentDepth);
+	return currentDepth;
+}
+function deriveSpanKind(span) {
+	const attributes = span.attributes || {};
+	const attributeKind = attributes["span.kind"] || attributes["otel.span.kind"] || attributes["spanKind"];
+	if (typeof attributeKind === "string") return attributeKind.toLowerCase();
+	return "internal";
+}
+var TraceStore = class {
+	db = null;
+	getDatabase() {
+		if (!this.db) {
+			require_logger.logger.debug("[TraceStore] Initializing database connection");
+			this.db = require_tables.getDb();
+		}
+		return this.db;
+	}
+	async createTrace(trace) {
+		try {
+			require_logger.logger.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			await this.getDatabase().insert(require_tables.tracesTable).values({
+				id: crypto.randomUUID(),
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata
+			}).onConflictDoNothing({ target: require_tables.tracesTable.traceId });
+			require_logger.logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to create trace: ${error}`);
+			throw error;
+		}
+	}
+	async addSpans(traceId, spans, options) {
+		try {
+			require_logger.logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			const db = this.getDatabase();
+			if (options?.skipTraceCheck) require_logger.logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			else {
+				require_logger.logger.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				if ((await db.select().from(require_tables.tracesTable).where((0, drizzle_orm.eq)(require_tables.tracesTable.traceId, traceId)).limit(1)).length === 0) {
+					require_logger.logger.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					return {
+						stored: false,
+						reason: `Trace ${traceId} not found`
+					};
+				}
+				require_logger.logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+			}
+			const spanRecords = spans.map((span) => {
+				require_logger.logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				return {
+					id: crypto.randomUUID(),
+					traceId,
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId,
+					name: span.name,
+					startTime: span.startTime,
+					endTime: span.endTime,
+					attributes: span.attributes,
+					statusCode: span.statusCode,
+					statusMessage: span.statusMessage
+				};
+			});
+			await db.insert(require_tables.spansTable).values(spanRecords);
+			require_logger.logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			return { stored: true };
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to add spans: ${error}`);
+			throw error;
+		}
+	}
+	async getTracesByEvaluation(evaluationId) {
+		try {
+			require_logger.logger.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(require_tables.tracesTable).where((0, drizzle_orm.eq)(require_tables.tracesTable.evaluationId, evaluationId));
+			require_logger.logger.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
+			const tracesWithSpans = await Promise.all(traces.map(async (trace) => {
+				require_logger.logger.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				const spans = await db.select().from(require_tables.spansTable).where((0, drizzle_orm.eq)(require_tables.spansTable.traceId, trace.traceId));
+				require_logger.logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				return {
+					...trace,
+					spans
+				};
+			}));
+			require_logger.logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			return tracesWithSpans;
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			throw error;
+		}
+	}
+	async getTrace(traceId) {
+		try {
+			require_logger.logger.debug(`[TraceStore] Fetching trace ${traceId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(require_tables.tracesTable).where((0, drizzle_orm.eq)(require_tables.tracesTable.traceId, traceId)).limit(1);
+			if (traces.length === 0) {
+				require_logger.logger.debug(`[TraceStore] Trace ${traceId} not found`);
+				return null;
+			}
+			const trace = traces[0];
+			require_logger.logger.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			const spans = await db.select().from(require_tables.spansTable).where((0, drizzle_orm.eq)(require_tables.spansTable.traceId, traceId));
+			require_logger.logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			return {
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata ?? void 0,
+				spans: spans.map((span) => ({
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId ?? void 0,
+					name: span.name,
+					startTime: span.startTime,
+					endTime: span.endTime ?? void 0,
+					attributes: span.attributes ?? void 0,
+					statusCode: span.statusCode ?? void 0,
+					statusMessage: span.statusMessage ?? void 0
+				}))
+			};
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to get trace: ${error}`);
+			throw error;
+		}
+	}
+	async deleteOldTraces(retentionDays) {
+		try {
+			require_logger.logger.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			const db = this.getDatabase();
+			const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+			await db.delete(require_tables.tracesTable).where((0, drizzle_orm.lt)(require_tables.tracesTable.createdAt, cutoffTime));
+			require_logger.logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to delete old traces: ${error}`);
+			throw error;
+		}
+	}
+	async getSpans(traceId, options = {}) {
+		const { earliestStartTime, maxSpans, maxDepth, includeInternalSpans = true, spanFilter, sanitizeAttributes: shouldSanitize = true } = options;
+		try {
+			require_logger.logger.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			const rows = await this.getDatabase().select().from(require_tables.spansTable).where((0, drizzle_orm.eq)(require_tables.spansTable.traceId, traceId)).orderBy((0, drizzle_orm.asc)(require_tables.spansTable.startTime));
+			const spanMap = /* @__PURE__ */ new Map();
+			const depthCache = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				if (earliestStartTime && row.startTime < earliestStartTime) continue;
+				const rawAttributes = row.attributes ?? {};
+				const spanData = {
+					spanId: row.spanId,
+					parentSpanId: row.parentSpanId ?? void 0,
+					name: row.name,
+					startTime: row.startTime,
+					endTime: row.endTime ?? void 0,
+					attributes: shouldSanitize ? sanitizeAttributes(rawAttributes) : rawAttributes,
+					statusCode: row.statusCode ?? void 0,
+					statusMessage: row.statusMessage ?? void 0
+				};
+				const spanKind = deriveSpanKind({
+					...spanData,
+					attributes: rawAttributes
+				});
+				if (!includeInternalSpans && spanKind === "internal") continue;
+				if (spanFilter && spanFilter.length > 0) {
+					if (!spanFilter.some((filterName) => spanData.name.toLowerCase().includes(filterName.toLowerCase()))) continue;
+				}
+				spanMap.set(spanData.spanId, spanData);
+			}
+			let spans = Array.from(spanMap.values());
+			if (maxDepth !== void 0) spans = spans.filter((span) => computeDepth(span, spanMap, depthCache) < maxDepth);
+			if (maxSpans !== void 0) spans = spans.slice(0, maxSpans);
+			require_logger.logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			return spans;
+		} catch (error) {
+			require_logger.logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			throw error;
+		}
+	}
+};
+let traceStore = null;
+function getTraceStore() {
+	if (!traceStore) {
+		require_logger.logger.debug("[TraceStore] Creating new TraceStore instance");
+		traceStore = new TraceStore();
+	}
+	return traceStore;
+}
+//#endregion
+Object.defineProperty(exports, "TraceStore", {
+	enumerable: true,
+	get: function() {
+		return TraceStore;
+	}
+});
+Object.defineProperty(exports, "getTraceStore", {
+	enumerable: true,
+	get: function() {
+		return getTraceStore;
+	}
+});
+
+//# sourceMappingURL=store-BwDDaBjb.cjs.map

package/dist/src/store-DcbLC593.cjs

@@ -0,0 +1,2 @@
+const require_store = require("./store-BwDDaBjb.cjs");
+exports.getTraceStore = require_store.getTraceStore;

package/dist/src/store-IGpqMIkv.js

@@ -0,0 +1,240 @@
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { r as logger } from "./logger-C40ZGil9.js";
+import { f as tracesTable, p as getDb, u as spansTable } from "./tables-Bi2fjr4W.js";
+import { asc, eq, lt } from "drizzle-orm";
+//#region src/tracing/store.ts
+var store_exports = /* @__PURE__ */ __exportAll({
+	TraceStore: () => TraceStore,
+	getTraceStore: () => getTraceStore
+});
+const SENSITIVE_ATTRIBUTE_KEYS = [
+	"authorization",
+	"cookie",
+	"set-cookie",
+	"token",
+	"api_key",
+	"apikey",
+	"secret",
+	"password",
+	"passphrase"
+];
+function sanitizeAttributes(attributes) {
+	if (!attributes) return {};
+	const sanitizeValue = (value) => {
+		if (typeof value === "string") return value.length > 400 ? `${value.slice(0, 400)}…` : value;
+		if (Array.isArray(value)) return value.map(sanitizeValue);
+		if (value && typeof value === "object") return sanitizeAttributes(value);
+		return value;
+	};
+	const sanitized = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		const lowerKey = key.toLowerCase();
+		if (SENSITIVE_ATTRIBUTE_KEYS.some((sensitiveKey) => lowerKey.includes(sensitiveKey))) {
+			sanitized[key] = "<redacted>";
+			continue;
+		}
+		sanitized[key] = sanitizeValue(value);
+	}
+	return sanitized;
+}
+function computeDepth(span, spanMap, depthCache) {
+	if (depthCache.has(span.spanId)) return depthCache.get(span.spanId);
+	if (!span.parentSpanId || !spanMap.has(span.parentSpanId)) {
+		depthCache.set(span.spanId, 0);
+		return 0;
+	}
+	const currentDepth = computeDepth(spanMap.get(span.parentSpanId), spanMap, depthCache) + 1;
+	depthCache.set(span.spanId, currentDepth);
+	return currentDepth;
+}
+function deriveSpanKind(span) {
+	const attributes = span.attributes || {};
+	const attributeKind = attributes["span.kind"] || attributes["otel.span.kind"] || attributes["spanKind"];
+	if (typeof attributeKind === "string") return attributeKind.toLowerCase();
+	return "internal";
+}
+var TraceStore = class {
+	db = null;
+	getDatabase() {
+		if (!this.db) {
+			logger.debug("[TraceStore] Initializing database connection");
+			this.db = getDb();
+		}
+		return this.db;
+	}
+	async createTrace(trace) {
+		try {
+			logger.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			await this.getDatabase().insert(tracesTable).values({
+				id: crypto.randomUUID(),
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata
+			}).onConflictDoNothing({ target: tracesTable.traceId });
+			logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to create trace: ${error}`);
+			throw error;
+		}
+	}
+	async addSpans(traceId, spans, options) {
+		try {
+			logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			const db = this.getDatabase();
+			if (options?.skipTraceCheck) logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			else {
+				logger.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				if ((await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1)).length === 0) {
+					logger.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					return {
+						stored: false,
+						reason: `Trace ${traceId} not found`
+					};
+				}
+				logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+			}
+			const spanRecords = spans.map((span) => {
+				logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				return {
+					id: crypto.randomUUID(),
+					traceId,
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId,
+					name: span.name,
+					startTime: span.startTime,
+					endTime: span.endTime,
+					attributes: span.attributes,
+					statusCode: span.statusCode,
+					statusMessage: span.statusMessage
+				};
+			});
+			await db.insert(spansTable).values(spanRecords);
+			logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			return { stored: true };
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to add spans: ${error}`);
+			throw error;
+		}
+	}
+	async getTracesByEvaluation(evaluationId) {
+		try {
+			logger.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(tracesTable).where(eq(tracesTable.evaluationId, evaluationId));
+			logger.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
+			const tracesWithSpans = await Promise.all(traces.map(async (trace) => {
+				logger.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, trace.traceId));
+				logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				return {
+					...trace,
+					spans
+				};
+			}));
+			logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			return tracesWithSpans;
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			throw error;
+		}
+	}
+	async getTrace(traceId) {
+		try {
+			logger.debug(`[TraceStore] Fetching trace ${traceId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1);
+			if (traces.length === 0) {
+				logger.debug(`[TraceStore] Trace ${traceId} not found`);
+				return null;
+			}
+			const trace = traces[0];
+			logger.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, traceId));
+			logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			return {
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata ?? void 0,
+				spans: spans.map((span) => ({
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId ?? void 0,
+					name: span.name,
+					startTime: span.startTime,
+					endTime: span.endTime ?? void 0,
+					attributes: span.attributes ?? void 0,
+					statusCode: span.statusCode ?? void 0,
+					statusMessage: span.statusMessage ?? void 0
+				}))
+			};
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to get trace: ${error}`);
+			throw error;
+		}
+	}
+	async deleteOldTraces(retentionDays) {
+		try {
+			logger.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			const db = this.getDatabase();
+			const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+			await db.delete(tracesTable).where(lt(tracesTable.createdAt, cutoffTime));
+			logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to delete old traces: ${error}`);
+			throw error;
+		}
+	}
+	async getSpans(traceId, options = {}) {
+		const { earliestStartTime, maxSpans, maxDepth, includeInternalSpans = true, spanFilter, sanitizeAttributes: shouldSanitize = true } = options;
+		try {
+			logger.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			const rows = await this.getDatabase().select().from(spansTable).where(eq(spansTable.traceId, traceId)).orderBy(asc(spansTable.startTime));
+			const spanMap = /* @__PURE__ */ new Map();
+			const depthCache = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				if (earliestStartTime && row.startTime < earliestStartTime) continue;
+				const rawAttributes = row.attributes ?? {};
+				const spanData = {
+					spanId: row.spanId,
+					parentSpanId: row.parentSpanId ?? void 0,
+					name: row.name,
+					startTime: row.startTime,
+					endTime: row.endTime ?? void 0,
+					attributes: shouldSanitize ? sanitizeAttributes(rawAttributes) : rawAttributes,
+					statusCode: row.statusCode ?? void 0,
+					statusMessage: row.statusMessage ?? void 0
+				};
+				const spanKind = deriveSpanKind({
+					...spanData,
+					attributes: rawAttributes
+				});
+				if (!includeInternalSpans && spanKind === "internal") continue;
+				if (spanFilter && spanFilter.length > 0) {
+					if (!spanFilter.some((filterName) => spanData.name.toLowerCase().includes(filterName.toLowerCase()))) continue;
+				}
+				spanMap.set(spanData.spanId, spanData);
+			}
+			let spans = Array.from(spanMap.values());
+			if (maxDepth !== void 0) spans = spans.filter((span) => computeDepth(span, spanMap, depthCache) < maxDepth);
+			if (maxSpans !== void 0) spans = spans.slice(0, maxSpans);
+			logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			return spans;
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			throw error;
+		}
+	}
+};
+let traceStore = null;
+function getTraceStore() {
+	if (!traceStore) {
+		logger.debug("[TraceStore] Creating new TraceStore instance");
+		traceStore = new TraceStore();
+	}
+	return traceStore;
+}
+//#endregion
+export { store_exports as n, getTraceStore as t };
+
+//# sourceMappingURL=store-IGpqMIkv.js.map