promptfoo 0.120.27 → 0.121.2

package/dist/src/{store-D7CgQzAR.cjs → store-DLlFCC4h.cjs}

@@ -1,7 +1,6 @@
-const require_logger = require('./logger-B7sBeGa0.cjs');
-const require_tables = require('./tables-BKTmd6u7.cjs');
+const require_logger = require("./logger-Cp1GPUjj.cjs");
+const require_tables = require("./tables-DPi7wKeM.cjs");
 let drizzle_orm = require("drizzle-orm");
-
 //#region src/tracing/store.ts
 const SENSITIVE_ATTRIBUTE_KEYS = [
 	"authorization",
@@ -53,14 +52,14 @@ var TraceStore = class {
 	db = null;
 	getDatabase() {
 		if (!this.db) {
-			require_logger.logger_default.debug("[TraceStore] Initializing database connection");
+			require_logger.logger.debug("[TraceStore] Initializing database connection");
 			this.db = require_tables.getDb();
 		}
 		return this.db;
 	}
 	async createTrace(trace) {
 		try {
-			require_logger.logger_default.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			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,
@@ -68,30 +67,30 @@ var TraceStore = class {
 				testCaseId: trace.testCaseId,
 				metadata: trace.metadata
 			}).onConflictDoNothing({ target: require_tables.tracesTable.traceId });
-			require_logger.logger_default.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+			require_logger.logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to create trace: ${error}`);
+			require_logger.logger.error(`[TraceStore] Failed to create trace: ${error}`);
 			throw error;
 		}
 	}
 	async addSpans(traceId, spans, options) {
 		try {
-			require_logger.logger_default.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			require_logger.logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
 			const db = this.getDatabase();
-			if (options?.skipTraceCheck) require_logger.logger_default.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			if (options?.skipTraceCheck) require_logger.logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
 			else {
-				require_logger.logger_default.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				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_default.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					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_default.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+				require_logger.logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
 			}
 			const spanRecords = spans.map((span) => {
-				require_logger.logger_default.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				require_logger.logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
 				return {
 					id: crypto.randomUUID(),
 					traceId,
@@ -106,73 +105,73 @@ var TraceStore = class {
 				};
 			});
 			await db.insert(require_tables.spansTable).values(spanRecords);
-			require_logger.logger_default.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			require_logger.logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
 			return { stored: true };
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to add spans: ${error}`);
+			require_logger.logger.error(`[TraceStore] Failed to add spans: ${error}`);
 			throw error;
 		}
 	}
 	async getTracesByEvaluation(evaluationId) {
 		try {
-			require_logger.logger_default.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			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_default.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${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_default.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				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_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				require_logger.logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
 				return {
 					...trace,
 					spans
 				};
 			}));
-			require_logger.logger_default.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			require_logger.logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
 			return tracesWithSpans;
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			require_logger.logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
 			throw error;
 		}
 	}
 	async getTrace(traceId) {
 		try {
-			require_logger.logger_default.debug(`[TraceStore] Fetching trace ${traceId}`);
+			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_default.debug(`[TraceStore] Trace ${traceId} not found`);
+				require_logger.logger.debug(`[TraceStore] Trace ${traceId} not found`);
 				return null;
 			}
 			const trace = traces[0];
-			require_logger.logger_default.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			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_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			require_logger.logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
 			return {
 				...trace,
 				spans
 			};
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to get trace: ${error}`);
+			require_logger.logger.error(`[TraceStore] Failed to get trace: ${error}`);
 			throw error;
 		}
 	}
 	async deleteOldTraces(retentionDays) {
 		try {
-			require_logger.logger_default.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			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_default.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+			require_logger.logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to delete old traces: ${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_default.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			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();
@@ -202,10 +201,10 @@ var TraceStore = class {
 			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_default.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			require_logger.logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
 			return spans;
 		} catch (error) {
-			require_logger.logger_default.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			require_logger.logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
 			throw error;
 		}
 	}
@@ -213,23 +212,23 @@ var TraceStore = class {
 let traceStore = null;
 function getTraceStore() {
 	if (!traceStore) {
-		require_logger.logger_default.debug("[TraceStore] Creating new TraceStore instance");
+		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, "TraceStore", {
+	enumerable: true,
+	get: function() {
+		return TraceStore;
+	}
 });
-Object.defineProperty(exports, 'getTraceStore', {
-  enumerable: true,
-  get: function () {
-    return getTraceStore;
-  }
+Object.defineProperty(exports, "getTraceStore", {
+	enumerable: true,
+	get: function() {
+		return getTraceStore;
+	}
 });
-//# sourceMappingURL=store-D7CgQzAR.cjs.map
+
+//# sourceMappingURL=store-DLlFCC4h.cjs.map

package/dist/src/{store-DJNsD1iC.js → store-DXilxTl-.js}

@@ -1,8 +1,12 @@
-import { i as logger_default } from "./logger-CG1uZPbQ.js";
-import { f as tracesTable, p as getDb, u as spansTable } from "./tables-DfTsNN7X.js";
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { i as logger } from "./logger-CT3IKMKA.js";
+import { f as tracesTable, p as getDb, u as spansTable } from "./tables-6YKwjN9-.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",
@@ -53,14 +57,14 @@ var TraceStore = class {
 	db = null;
 	getDatabase() {
 		if (!this.db) {
-			logger_default.debug("[TraceStore] Initializing database connection");
+			logger.debug("[TraceStore] Initializing database connection");
 			this.db = getDb();
 		}
 		return this.db;
 	}
 	async createTrace(trace) {
 		try {
-			logger_default.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			logger.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
 			await this.getDatabase().insert(tracesTable).values({
 				id: crypto.randomUUID(),
 				traceId: trace.traceId,
@@ -68,30 +72,30 @@ var TraceStore = class {
 				testCaseId: trace.testCaseId,
 				metadata: trace.metadata
 			}).onConflictDoNothing({ target: tracesTable.traceId });
-			logger_default.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+			logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to create trace: ${error}`);
+			logger.error(`[TraceStore] Failed to create trace: ${error}`);
 			throw error;
 		}
 	}
 	async addSpans(traceId, spans, options) {
 		try {
-			logger_default.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
 			const db = this.getDatabase();
-			if (options?.skipTraceCheck) logger_default.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			if (options?.skipTraceCheck) logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
 			else {
-				logger_default.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				logger.debug(`[TraceStore] Verifying trace ${traceId} exists`);
 				if ((await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1)).length === 0) {
-					logger_default.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					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_default.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+				logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
 			}
 			const spanRecords = spans.map((span) => {
-				logger_default.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
 				return {
 					id: crypto.randomUUID(),
 					traceId,
@@ -106,73 +110,73 @@ var TraceStore = class {
 				};
 			});
 			await db.insert(spansTable).values(spanRecords);
-			logger_default.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
 			return { stored: true };
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to add spans: ${error}`);
+			logger.error(`[TraceStore] Failed to add spans: ${error}`);
 			throw error;
 		}
 	}
 	async getTracesByEvaluation(evaluationId) {
 		try {
-			logger_default.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			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_default.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
+			logger.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
 			const tracesWithSpans = await Promise.all(traces.map(async (trace) => {
-				logger_default.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				logger.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
 				const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, trace.traceId));
-				logger_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
 				return {
 					...trace,
 					spans
 				};
 			}));
-			logger_default.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
 			return tracesWithSpans;
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
 			throw error;
 		}
 	}
 	async getTrace(traceId) {
 		try {
-			logger_default.debug(`[TraceStore] Fetching trace ${traceId}`);
+			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_default.debug(`[TraceStore] Trace ${traceId} not found`);
+				logger.debug(`[TraceStore] Trace ${traceId} not found`);
 				return null;
 			}
 			const trace = traces[0];
-			logger_default.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			logger.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
 			const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, traceId));
-			logger_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
 			return {
 				...trace,
 				spans
 			};
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to get trace: ${error}`);
+			logger.error(`[TraceStore] Failed to get trace: ${error}`);
 			throw error;
 		}
 	}
 	async deleteOldTraces(retentionDays) {
 		try {
-			logger_default.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			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_default.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+			logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to delete old traces: ${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_default.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			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();
@@ -202,10 +206,10 @@ var TraceStore = class {
 			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_default.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
 			return spans;
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
 			throw error;
 		}
 	}
@@ -213,12 +217,12 @@ var TraceStore = class {
 let traceStore = null;
 function getTraceStore() {
 	if (!traceStore) {
-		logger_default.debug("[TraceStore] Creating new TraceStore instance");
+		logger.debug("[TraceStore] Creating new TraceStore instance");
 		traceStore = new TraceStore();
 	}
 	return traceStore;
 }
-
 //#endregion
-export { getTraceStore as n, TraceStore as t };
-//# sourceMappingURL=store-DJNsD1iC.js.map
+export { store_exports as n, getTraceStore as t };
+
+//# sourceMappingURL=store-DXilxTl-.js.map

package/dist/src/{store-s3SftUwF.js → store-Dim__MDd.js}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { o as logger_default } from "./logger-LSBxlt7a.js";
-import { f as spansTable, g as getDb, m as tracesTable } from "./tables-DMegD0Xf.js";
+import { o as logger } from "./logger-KkObSCzq.js";
+import { f as spansTable, g as getDb, m as tracesTable } from "./tables-gftXzE9I.js";
 import { asc, eq, lt } from "drizzle-orm";
-
 //#region src/tracing/store.ts
 const SENSITIVE_ATTRIBUTE_KEYS = [
 	"authorization",
@@ -54,14 +53,14 @@ var TraceStore = class {
 	db = null;
 	getDatabase() {
 		if (!this.db) {
-			logger_default.debug("[TraceStore] Initializing database connection");
+			logger.debug("[TraceStore] Initializing database connection");
 			this.db = getDb();
 		}
 		return this.db;
 	}
 	async createTrace(trace) {
 		try {
-			logger_default.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			logger.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
 			await this.getDatabase().insert(tracesTable).values({
 				id: crypto.randomUUID(),
 				traceId: trace.traceId,
@@ -69,30 +68,30 @@ var TraceStore = class {
 				testCaseId: trace.testCaseId,
 				metadata: trace.metadata
 			}).onConflictDoNothing({ target: tracesTable.traceId });
-			logger_default.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+			logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to create trace: ${error}`);
+			logger.error(`[TraceStore] Failed to create trace: ${error}`);
 			throw error;
 		}
 	}
 	async addSpans(traceId, spans, options) {
 		try {
-			logger_default.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
 			const db = this.getDatabase();
-			if (options?.skipTraceCheck) logger_default.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			if (options?.skipTraceCheck) logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
 			else {
-				logger_default.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				logger.debug(`[TraceStore] Verifying trace ${traceId} exists`);
 				if ((await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1)).length === 0) {
-					logger_default.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					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_default.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+				logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
 			}
 			const spanRecords = spans.map((span) => {
-				logger_default.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
 				return {
 					id: crypto.randomUUID(),
 					traceId,
@@ -107,73 +106,73 @@ var TraceStore = class {
 				};
 			});
 			await db.insert(spansTable).values(spanRecords);
-			logger_default.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
 			return { stored: true };
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to add spans: ${error}`);
+			logger.error(`[TraceStore] Failed to add spans: ${error}`);
 			throw error;
 		}
 	}
 	async getTracesByEvaluation(evaluationId) {
 		try {
-			logger_default.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			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_default.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
+			logger.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
 			const tracesWithSpans = await Promise.all(traces.map(async (trace) => {
-				logger_default.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				logger.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
 				const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, trace.traceId));
-				logger_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
 				return {
 					...trace,
 					spans
 				};
 			}));
-			logger_default.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
 			return tracesWithSpans;
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
 			throw error;
 		}
 	}
 	async getTrace(traceId) {
 		try {
-			logger_default.debug(`[TraceStore] Fetching trace ${traceId}`);
+			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_default.debug(`[TraceStore] Trace ${traceId} not found`);
+				logger.debug(`[TraceStore] Trace ${traceId} not found`);
 				return null;
 			}
 			const trace = traces[0];
-			logger_default.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			logger.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
 			const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, traceId));
-			logger_default.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
 			return {
 				...trace,
 				spans
 			};
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to get trace: ${error}`);
+			logger.error(`[TraceStore] Failed to get trace: ${error}`);
 			throw error;
 		}
 	}
 	async deleteOldTraces(retentionDays) {
 		try {
-			logger_default.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			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_default.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+			logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to delete old traces: ${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_default.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			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();
@@ -203,10 +202,10 @@ var TraceStore = class {
 			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_default.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
 			return spans;
 		} catch (error) {
-			logger_default.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
 			throw error;
 		}
 	}
@@ -214,12 +213,12 @@ var TraceStore = class {
 let traceStore = null;
 function getTraceStore() {
 	if (!traceStore) {
-		logger_default.debug("[TraceStore] Creating new TraceStore instance");
+		logger.debug("[TraceStore] Creating new TraceStore instance");
 		traceStore = new TraceStore();
 	}
 	return traceStore;
 }
-
 //#endregion
 export { getTraceStore as n, TraceStore as t };
-//# sourceMappingURL=store-s3SftUwF.js.map
+
+//# sourceMappingURL=store-Dim__MDd.js.map

package/dist/src/store-eYkaKMwq.cjs

@@ -0,0 +1,5 @@
+require("./logger-Cp1GPUjj.cjs");
+require("./types-C_7nyzr1.cjs");
+require("./tables-DPi7wKeM.cjs");
+const require_store = require("./store-DLlFCC4h.cjs");
+exports.getTraceStore = require_store.getTraceStore;