@llmops/core 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('./db-D3WDjcvd.cjs');
-const require_neon_dialect = require('./neon-dialect-DMClTHvw.cjs');
+const require_db = require('./db-DZv0NtMm.cjs');
+const require_neon_dialect = require('./neon-dialect-ByrFa9iy.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let kysely = require("kysely");
@@ -1387,754 +1387,247 @@ const createDatasetsDataLayer = (db) => {
 };
 
 //#endregion
-//#region src/datalayer/guardrailConfigs.ts
-const createGuardrailConfig = require_db.zod_default.object({
-	name: require_db.zod_default.string().min(1),
-	pluginId: require_db.zod_default.string().min(1),
-	functionId: require_db.zod_default.string().min(1),
-	hookType: require_db.zod_default.enum(["beforeRequestHook", "afterRequestHook"]),
-	parameters: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional().default({}),
-	enabled: require_db.zod_default.boolean().optional().default(true),
-	priority: require_db.zod_default.number().int().optional().default(0),
-	onFail: require_db.zod_default.enum(["block", "log"]).optional().default("block")
+//#region src/datalayer/playgrounds.ts
+const createNewPlayground = require_db.zod_default.object({
+	name: require_db.zod_default.string(),
+	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
+	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
 });
-const updateGuardrailConfig = require_db.zod_default.object({
-	id: require_db.zod_default.string().uuid(),
-	name: require_db.zod_default.string().min(1).optional(),
-	hookType: require_db.zod_default.enum(["beforeRequestHook", "afterRequestHook"]).optional(),
-	parameters: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional(),
-	enabled: require_db.zod_default.boolean().optional(),
-	priority: require_db.zod_default.number().int().optional(),
-	onFail: require_db.zod_default.enum(["block", "log"]).optional()
+const updatePlayground = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.uuidv4(),
+	name: require_db.zod_default.string().optional(),
+	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
+	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
 });
-const getGuardrailConfigById = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const deleteGuardrailConfig = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const listGuardrailConfigs = require_db.zod_default.object({
+const getPlaygroundById = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
+const deletePlayground = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
+const listPlaygrounds = require_db.zod_default.object({
 	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional(),
-	hookType: require_db.zod_default.enum(["beforeRequestHook", "afterRequestHook"]).optional(),
-	enabled: require_db.zod_default.boolean().optional()
+	offset: require_db.zod_default.number().int().nonnegative().optional()
 });
-const createGuardrailConfigsDataLayer = (db) => {
+const createPlaygroundDataLayer = (db) => {
 	return {
-		createGuardrailConfig: async (params) => {
-			const value = await createGuardrailConfig.safeParseAsync(params);
+		createNewPlayground: async (params) => {
+			const value = await createNewPlayground.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { name, pluginId, functionId, hookType, parameters, enabled, priority, onFail } = value.data;
-			return db.insertInto("guardrail_configs").values({
+			const { name, datasetId, columns } = value.data;
+			return db.insertInto("playgrounds").values({
 				id: (0, node_crypto.randomUUID)(),
 				name,
-				pluginId,
-				functionId,
-				hookType,
-				parameters: JSON.stringify(parameters),
-				enabled,
-				priority,
-				onFail,
+				datasetId: datasetId ?? null,
+				columns: columns ? JSON.stringify(columns) : null,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 			}).returningAll().executeTakeFirst();
 		},
-		updateGuardrailConfig: async (params) => {
-			const value = await updateGuardrailConfig.safeParseAsync(params);
+		updatePlayground: async (params) => {
+			const value = await updatePlayground.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, name, hookType, parameters, enabled, priority, onFail } = value.data;
+			const { playgroundId, name, datasetId, columns } = value.data;
 			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 			if (name !== void 0) updateData.name = name;
-			if (hookType !== void 0) updateData.hookType = hookType;
-			if (parameters !== void 0) updateData.parameters = JSON.stringify(parameters);
-			if (enabled !== void 0) updateData.enabled = enabled;
-			if (priority !== void 0) updateData.priority = priority;
-			if (onFail !== void 0) updateData.onFail = onFail;
-			return db.updateTable("guardrail_configs").set(updateData).where("id", "=", id).returningAll().executeTakeFirst();
+			if (datasetId !== void 0) updateData.datasetId = datasetId;
+			if (columns !== void 0) updateData.columns = columns ? JSON.stringify(columns) : null;
+			return db.updateTable("playgrounds").set(updateData).where("id", "=", playgroundId).returningAll().executeTakeFirst();
 		},
-		getGuardrailConfigById: async (params) => {
-			const value = await getGuardrailConfigById.safeParseAsync(params);
+		getPlaygroundById: async (params) => {
+			const value = await getPlaygroundById.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("guardrail_configs").selectAll().where("id", "=", id).executeTakeFirst();
+			const { playgroundId } = value.data;
+			return db.selectFrom("playgrounds").selectAll().where("id", "=", playgroundId).executeTakeFirst();
 		},
-		deleteGuardrailConfig: async (params) => {
-			const value = await deleteGuardrailConfig.safeParseAsync(params);
+		deletePlayground: async (params) => {
+			const value = await deletePlayground.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("guardrail_configs").where("id", "=", id).returningAll().executeTakeFirst();
+			const { playgroundId } = value.data;
+			return db.deleteFrom("playgrounds").where("id", "=", playgroundId).returningAll().executeTakeFirst();
 		},
-		listGuardrailConfigs: async (params) => {
-			const value = await listGuardrailConfigs.safeParseAsync(params || {});
+		listPlaygrounds: async (params) => {
+			const value = await listPlaygrounds.safeParseAsync(params || {});
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0, hookType, enabled } = value.data;
-			let query = db.selectFrom("guardrail_configs").selectAll().orderBy("priority", "desc").orderBy("createdAt", "desc").limit(limit).offset(offset);
-			if (hookType !== void 0) query = query.where("hookType", "=", hookType);
-			if (enabled !== void 0) query = query.where("enabled", "=", enabled);
-			return query.execute();
+			const { limit = 100, offset = 0 } = value.data;
+			return db.selectFrom("playgrounds").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
 		},
-		countGuardrailConfigs: async () => {
-			const result = await db.selectFrom("guardrail_configs").select(db.fn.countAll().as("count")).executeTakeFirst();
+		countPlaygrounds: async () => {
+			const result = await db.selectFrom("playgrounds").select(db.fn.countAll().as("count")).executeTakeFirst();
 			return Number(result?.count ?? 0);
-		},
-		getEnabledGuardrailsByHookType: async (hookType) => {
-			return db.selectFrom("guardrail_configs").selectAll().where("hookType", "=", hookType).where("enabled", "=", true).orderBy("priority", "desc").execute();
 		}
 	};
 };
 
 //#endregion
-//#region src/datalayer/llmRequests.ts
-/**
-* Schema for individual guardrail result in telemetry
-*/
-const guardrailResultSchema = require_db.zod_default.object({
-	checkId: require_db.zod_default.string(),
-	functionId: require_db.zod_default.string(),
-	hookType: require_db.zod_default.enum(["beforeRequestHook", "afterRequestHook"]),
-	verdict: require_db.zod_default.boolean(),
-	latencyMs: require_db.zod_default.number()
-});
-/**
-* Schema for guardrail results aggregate
-*/
-const guardrailResultsSchema = require_db.zod_default.object({
-	results: require_db.zod_default.array(guardrailResultSchema),
-	action: require_db.zod_default.enum([
-		"allowed",
-		"blocked",
-		"logged"
-	]),
-	totalLatencyMs: require_db.zod_default.number()
-});
-/**
-* Schema for inserting a new LLM request log
-*/
-const insertLLMRequestSchema = require_db.zod_default.object({
-	requestId: require_db.zod_default.string().uuid(),
-	configId: require_db.zod_default.string().uuid().nullable().optional(),
-	variantId: require_db.zod_default.string().uuid().nullable().optional(),
-	environmentId: require_db.zod_default.string().uuid().nullable().optional(),
-	providerConfigId: require_db.zod_default.string().uuid().nullable().optional(),
-	provider: require_db.zod_default.string(),
-	model: require_db.zod_default.string(),
-	promptTokens: require_db.zod_default.number().int().default(0),
-	completionTokens: require_db.zod_default.number().int().default(0),
-	totalTokens: require_db.zod_default.number().int().default(0),
-	cachedTokens: require_db.zod_default.number().int().default(0),
-	cacheCreationTokens: require_db.zod_default.number().int().default(0),
-	cost: require_db.zod_default.number().int().default(0),
-	cacheSavings: require_db.zod_default.number().int().default(0),
-	inputCost: require_db.zod_default.number().int().default(0),
-	outputCost: require_db.zod_default.number().int().default(0),
-	endpoint: require_db.zod_default.string(),
-	statusCode: require_db.zod_default.number().int(),
-	latencyMs: require_db.zod_default.number().int().default(0),
-	isStreaming: require_db.zod_default.boolean().default(false),
-	userId: require_db.zod_default.string().nullable().optional(),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
-	guardrailResults: guardrailResultsSchema.nullable().optional(),
-	traceId: require_db.zod_default.string().nullable().optional(),
-	spanId: require_db.zod_default.string().nullable().optional(),
-	parentSpanId: require_db.zod_default.string().nullable().optional(),
-	sessionId: require_db.zod_default.string().nullable().optional()
-});
-/**
-* Schema for listing LLM requests
-*/
-const listRequestsSchema = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().max(1e3).default(100),
-	offset: require_db.zod_default.number().int().nonnegative().default(0),
-	configId: require_db.zod_default.string().uuid().optional(),
-	variantId: require_db.zod_default.string().uuid().optional(),
-	environmentId: require_db.zod_default.string().uuid().optional(),
-	providerConfigId: require_db.zod_default.string().uuid().optional(),
-	provider: require_db.zod_default.string().optional(),
-	model: require_db.zod_default.string().optional(),
-	startDate: require_db.zod_default.date().optional(),
-	endDate: require_db.zod_default.date().optional(),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+//#region src/datalayer/playgroundResults.ts
+const createPlaygroundResult = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	columnId: require_db.zod_default.string().uuid(),
+	datasetRecordId: require_db.zod_default.string().uuid().nullable().optional(),
+	inputVariables: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({}),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]).default("pending")
 });
-/**
-* Schema for date range queries with optional filters
-*/
-const dateRangeSchema = require_db.zod_default.object({
-	startDate: require_db.zod_default.date(),
-	endDate: require_db.zod_default.date(),
-	configId: require_db.zod_default.string().uuid().optional(),
-	variantId: require_db.zod_default.string().uuid().optional(),
-	environmentId: require_db.zod_default.string().uuid().optional(),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+const createPlaygroundResultsBatch = require_db.zod_default.object({ results: require_db.zod_default.array(createPlaygroundResult) });
+const updatePlaygroundResult = require_db.zod_default.object({
+	resultId: require_db.zod_default.string().uuid(),
+	outputContent: require_db.zod_default.string().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]).optional(),
+	error: require_db.zod_default.string().nullable().optional(),
+	latencyMs: require_db.zod_default.number().int().nullable().optional(),
+	promptTokens: require_db.zod_default.number().int().nullable().optional(),
+	completionTokens: require_db.zod_default.number().int().nullable().optional(),
+	totalTokens: require_db.zod_default.number().int().nullable().optional(),
+	cost: require_db.zod_default.number().int().nullable().optional()
 });
-/**
-* Valid groupBy values for cost summary queries
-*/
-const COST_SUMMARY_GROUP_BY = [
-	"day",
-	"hour",
-	"model",
-	"provider",
-	"endpoint",
-	"tags"
-];
-/**
-* Schema for cost summary with grouping
-*/
-const costSummarySchema = require_db.zod_default.object({
-	startDate: require_db.zod_default.date(),
-	endDate: require_db.zod_default.date(),
-	configId: require_db.zod_default.string().uuid().optional(),
-	variantId: require_db.zod_default.string().uuid().optional(),
-	environmentId: require_db.zod_default.string().uuid().optional(),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional(),
-	groupBy: require_db.zod_default.enum(COST_SUMMARY_GROUP_BY).optional(),
-	tagKeys: require_db.zod_default.array(require_db.zod_default.string()).optional()
+const getPlaygroundResultById = require_db.zod_default.object({ resultId: require_db.zod_default.string().uuid() });
+const listPlaygroundResults = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	columnId: require_db.zod_default.string().uuid().optional(),
+	limit: require_db.zod_default.number().int().positive().optional(),
+	offset: require_db.zod_default.number().int().nonnegative().optional()
 });
-/**
-* Helper to create column reference for SQL
-* Uses sql.ref() to properly quote column names for the database
-*/
-const col$1 = (name) => kysely.sql.ref(name);
-const createLLMRequestsDataLayer = (db) => {
+const deletePlaygroundResultsByRunId = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const createPlaygroundResultsDataLayer = (db) => {
 	return {
-		batchInsertRequests: async (requests) => {
-			if (requests.length === 0) return { count: 0 };
-			const validatedRequests = await Promise.all(requests.map(async (req) => {
-				const result = await insertLLMRequestSchema.safeParseAsync(req);
-				if (!result.success) throw new LLMOpsError(`Invalid request data: ${result.error.message}`);
-				return result.data;
-			}));
+		createPlaygroundResult: async (params) => {
+			const value = await createPlaygroundResult.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId, columnId, datasetRecordId, inputVariables, status } = value.data;
+			return db.insertInto("playground_results").values({
+				id: (0, node_crypto.randomUUID)(),
+				runId,
+				columnId,
+				datasetRecordId: datasetRecordId ?? null,
+				inputVariables: JSON.stringify(inputVariables),
+				outputContent: null,
+				status,
+				error: null,
+				latencyMs: null,
+				promptTokens: null,
+				completionTokens: null,
+				totalTokens: null,
+				cost: null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+		},
+		createPlaygroundResultsBatch: async (params) => {
+			const value = await createPlaygroundResultsBatch.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { results } = value.data;
+			if (results.length === 0) return [];
 			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const values = validatedRequests.map((req) => ({
+			const values = results.map((result) => ({
 				id: (0, node_crypto.randomUUID)(),
-				requestId: req.requestId,
-				configId: req.configId ?? null,
-				variantId: req.variantId ?? null,
-				environmentId: req.environmentId ?? null,
-				providerConfigId: req.providerConfigId ?? null,
-				provider: req.provider,
-				model: req.model,
-				promptTokens: req.promptTokens,
-				completionTokens: req.completionTokens,
-				totalTokens: req.totalTokens,
-				cachedTokens: req.cachedTokens,
-				cacheCreationTokens: req.cacheCreationTokens,
-				cost: req.cost,
-				cacheSavings: req.cacheSavings,
-				inputCost: req.inputCost,
-				outputCost: req.outputCost,
-				endpoint: req.endpoint,
-				statusCode: req.statusCode,
-				latencyMs: req.latencyMs,
-				isStreaming: req.isStreaming,
-				userId: req.userId ?? null,
-				tags: JSON.stringify(req.tags),
-				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
-				traceId: req.traceId ?? null,
-				spanId: req.spanId ?? null,
-				parentSpanId: req.parentSpanId ?? null,
-				sessionId: req.sessionId ?? null,
+				runId: result.runId,
+				columnId: result.columnId,
+				datasetRecordId: result.datasetRecordId ?? null,
+				inputVariables: JSON.stringify(result.inputVariables),
+				outputContent: null,
+				status: result.status,
+				error: null,
+				latencyMs: null,
+				promptTokens: null,
+				completionTokens: null,
+				totalTokens: null,
+				cost: null,
 				createdAt: now,
 				updatedAt: now
 			}));
-			await db.insertInto("llm_requests").values(values).execute();
-			return { count: values.length };
+			return db.insertInto("playground_results").values(values).returningAll().execute();
 		},
-		insertRequest: async (request) => {
-			const result = await insertLLMRequestSchema.safeParseAsync(request);
-			if (!result.success) throw new LLMOpsError(`Invalid request data: ${result.error.message}`);
-			const req = result.data;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			return db.insertInto("llm_requests").values({
-				id: (0, node_crypto.randomUUID)(),
-				requestId: req.requestId,
-				configId: req.configId ?? null,
-				variantId: req.variantId ?? null,
-				environmentId: req.environmentId ?? null,
-				providerConfigId: req.providerConfigId ?? null,
-				provider: req.provider,
-				model: req.model,
-				promptTokens: req.promptTokens,
-				completionTokens: req.completionTokens,
-				totalTokens: req.totalTokens,
-				cachedTokens: req.cachedTokens,
-				cacheCreationTokens: req.cacheCreationTokens,
-				cost: req.cost,
-				cacheSavings: req.cacheSavings,
-				inputCost: req.inputCost,
-				outputCost: req.outputCost,
-				endpoint: req.endpoint,
-				statusCode: req.statusCode,
-				latencyMs: req.latencyMs,
-				isStreaming: req.isStreaming,
-				userId: req.userId ?? null,
-				tags: JSON.stringify(req.tags),
-				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
-				traceId: req.traceId ?? null,
-				spanId: req.spanId ?? null,
-				parentSpanId: req.parentSpanId ?? null,
-				sessionId: req.sessionId ?? null,
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-		},
-		listRequests: async (params) => {
-			const result = await listRequestsSchema.safeParseAsync(params || {});
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { limit, offset, configId, variantId, environmentId, providerConfigId, provider, model, startDate, endDate, tags } = result.data;
-			let baseQuery = db.selectFrom("llm_requests");
-			if (configId) baseQuery = baseQuery.where("configId", "=", configId);
-			if (variantId) baseQuery = baseQuery.where("variantId", "=", variantId);
-			if (environmentId) baseQuery = baseQuery.where("environmentId", "=", environmentId);
-			if (providerConfigId) baseQuery = baseQuery.where("providerConfigId", "=", providerConfigId);
-			if (provider) baseQuery = baseQuery.where("provider", "=", provider);
-			if (model) baseQuery = baseQuery.where("model", "=", model);
-			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`);
-			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
-			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
-				if (values.length === 0) continue;
-				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
-				else {
-					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
-				}
-			}
-			const countResult = await baseQuery.select(kysely.sql`COUNT(*)`.as("total")).executeTakeFirst();
-			const total = Number(countResult?.total ?? 0);
-			return {
-				data: await baseQuery.selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute(),
-				total,
-				limit,
-				offset
-			};
-		},
-		getRequestByRequestId: async (requestId) => {
-			return db.selectFrom("llm_requests").selectAll().where("requestId", "=", requestId).executeTakeFirst();
-		},
-		getTotalCost: async (params) => {
-			const result = await dateRangeSchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
-			let query = db.selectFrom("llm_requests").select([
-				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("promptTokens")}), 0)`.as("totalPromptTokens"),
-				kysely.sql`COALESCE(SUM(${col$1("completionTokens")}), 0)`.as("totalCompletionTokens"),
-				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COALESCE(SUM(${col$1("cachedTokens")}), 0)`.as("totalCachedTokens"),
-				kysely.sql`COALESCE(SUM(${col$1("cacheSavings")}), 0)`.as("totalCacheSavings"),
-				kysely.sql`COUNT(*)`.as("requestCount")
-			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
-			if (configId) query = query.where("configId", "=", configId);
-			if (variantId) query = query.where("variantId", "=", variantId);
-			if (environmentId) query = query.where("environmentId", "=", environmentId);
-			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
-				if (values.length === 0) continue;
-				if (values.length === 1) query = query.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
-				else {
-					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					query = query.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
-				}
-			}
-			return await query.executeTakeFirst();
-		},
-		getCostByModel: async (params) => {
-			const result = await dateRangeSchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate } = result.data;
-			return db.selectFrom("llm_requests").select([
-				"provider",
-				"model",
-				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COUNT(*)`.as("requestCount"),
-				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs")
-			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
+		updatePlaygroundResult: async (params) => {
+			const value = await updatePlaygroundResult.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { resultId, outputContent, status, error, latencyMs, promptTokens, completionTokens, totalTokens, cost } = value.data;
+			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+			if (outputContent !== void 0) updateData.outputContent = outputContent;
+			if (status !== void 0) updateData.status = status;
+			if (error !== void 0) updateData.error = error;
+			if (latencyMs !== void 0) updateData.latencyMs = latencyMs;
+			if (promptTokens !== void 0) updateData.promptTokens = promptTokens;
+			if (completionTokens !== void 0) updateData.completionTokens = completionTokens;
+			if (totalTokens !== void 0) updateData.totalTokens = totalTokens;
+			if (cost !== void 0) updateData.cost = cost;
+			return db.updateTable("playground_results").set(updateData).where("id", "=", resultId).returningAll().executeTakeFirst();
 		},
-		getCostByProvider: async (params) => {
-			const result = await dateRangeSchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate } = result.data;
-			return db.selectFrom("llm_requests").select([
-				"provider",
-				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COUNT(*)`.as("requestCount"),
-				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs")
-			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy("provider").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
+		getPlaygroundResultById: async (params) => {
+			const value = await getPlaygroundResultById.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { resultId } = value.data;
+			return db.selectFrom("playground_results").selectAll().where("id", "=", resultId).executeTakeFirst();
 		},
-		getDailyCosts: async (params) => {
-			const result = await dateRangeSchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate } = result.data;
-			return db.selectFrom("llm_requests").select([
-				kysely.sql`DATE(${col$1("createdAt")})`.as("date"),
-				kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${col$1("inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COUNT(*)`.as("requestCount")
-			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`).groupBy(kysely.sql`DATE(${col$1("createdAt")})`).orderBy(kysely.sql`DATE(${col$1("createdAt")})`, "asc").execute();
+		listPlaygroundResults: async (params) => {
+			const value = await listPlaygroundResults.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId, columnId, limit = 500, offset = 0 } = value.data;
+			let query = db.selectFrom("playground_results").selectAll().where("runId", "=", runId);
+			if (columnId) query = query.where("columnId", "=", columnId);
+			return query.orderBy("createdAt", "asc").limit(limit).offset(offset).execute();
 		},
-		getCostSummary: async (params) => {
-			const result = await costSummarySchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate, groupBy, configId, variantId, environmentId, tags, tagKeys } = result.data;
-			let baseQuery = db.selectFrom("llm_requests").where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
-			if (configId) baseQuery = baseQuery.where("configId", "=", configId);
-			if (variantId) baseQuery = baseQuery.where("variantId", "=", variantId);
-			if (environmentId) baseQuery = baseQuery.where("environmentId", "=", environmentId);
-			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
-				if (values.length === 0) continue;
-				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
-				else {
-					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					baseQuery = baseQuery.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
-				}
-			}
-			switch (groupBy) {
-				case "day": return baseQuery.select([
-					kysely.sql`DATE(${col$1("createdAt")})`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount"),
-					kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens")
-				]).groupBy(kysely.sql`DATE(${col$1("createdAt")})`).orderBy(kysely.sql`DATE(${col$1("createdAt")})`, "asc").execute();
-				case "hour": return baseQuery.select([
-					kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount"),
-					kysely.sql`COALESCE(SUM(${col$1("totalTokens")}), 0)`.as("totalTokens")
-				]).groupBy(kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`).orderBy(kysely.sql`DATE_TRUNC('hour', ${col$1("createdAt")})`, "asc").execute();
-				case "model": return baseQuery.select([
-					kysely.sql`${col$1("provider")} || '/' || ${col$1("model")}`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
-				case "provider": return baseQuery.select([
-					kysely.sql`${col$1("provider")}`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy("provider").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
-				case "endpoint": return baseQuery.select([
-					kysely.sql`COALESCE(${col$1("endpoint")}, 'unknown')`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy("endpoint").orderBy(kysely.sql`SUM(${col$1("cost")})`, "desc").execute();
-				case "tags": {
-					const conditions = [kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`, kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`];
-					if (configId) conditions.push(kysely.sql`${col$1("configId")} = ${configId}`);
-					if (variantId) conditions.push(kysely.sql`${col$1("variantId")} = ${variantId}`);
-					if (environmentId) conditions.push(kysely.sql`${col$1("environmentId")} = ${environmentId}`);
-					if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
-						if (values.length === 0) continue;
-						if (values.length === 1) conditions.push(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
-						else {
-							const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-							conditions.push(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
-						}
-					}
-					if (tagKeys && tagKeys.length > 0) {
-						const tagKeyList = kysely.sql.join(tagKeys.map((k) => kysely.sql`${k}`), kysely.sql`, `);
-						conditions.push(kysely.sql`t.key IN (${tagKeyList})`);
-					}
-					const whereClause = kysely.sql.join(conditions, kysely.sql` AND `);
-					return (await kysely.sql`
-            SELECT t.key || ':' || t.value as "groupKey",
-                   COALESCE(SUM(${col$1("cost")}), 0) as "totalCost",
-                   COUNT(*) as "requestCount"
-            FROM "llm_requests", jsonb_each_text(${col$1("tags")}) t
-            WHERE ${whereClause}
-            GROUP BY t.key, t.value
-            ORDER BY SUM(${col$1("cost")}) DESC
-          `.execute(db)).rows;
-				}
-				default: return baseQuery.select([
-					kysely.sql`'total'`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount")
-				]).execute();
-			}
+		deletePlaygroundResultsByRunId: async (params) => {
+			const value = await deletePlaygroundResultsByRunId.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			const { runId } = value.data;
+			return db.deleteFrom("playground_results").where("runId", "=", runId).returningAll().execute();
 		},
-		getRequestStats: async (params) => {
-			const result = await dateRangeSchema.safeParseAsync(params);
-			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
-			let query = db.selectFrom("llm_requests").select([
-				kysely.sql`COUNT(*)`.as("totalRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col$1("statusCode")} >= 200 AND ${col$1("statusCode")} < 300 THEN 1 END)`.as("successfulRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col$1("statusCode")} >= 400 THEN 1 END)`.as("failedRequests"),
-				kysely.sql`COUNT(CASE WHEN ${col$1("isStreaming")} = true THEN 1 END)`.as("streamingRequests"),
-				kysely.sql`AVG(${col$1("latencyMs")})`.as("avgLatencyMs"),
-				kysely.sql`MAX(${col$1("latencyMs")})`.as("maxLatencyMs"),
-				kysely.sql`MIN(${col$1("latencyMs")})`.as("minLatencyMs")
-			]).where(kysely.sql`${col$1("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col$1("createdAt")} <= ${endDate.toISOString()}`);
-			if (configId) query = query.where("configId", "=", configId);
-			if (variantId) query = query.where("variantId", "=", variantId);
-			if (environmentId) query = query.where("environmentId", "=", environmentId);
-			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
-				if (values.length === 0) continue;
-				if (values.length === 1) query = query.where(kysely.sql`${col$1("tags")}->>${key} = ${values[0]}`);
-				else {
-					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
-					query = query.where(kysely.sql`${col$1("tags")}->>${key} IN (${valueList})`);
-				}
-			}
-			return await query.executeTakeFirst();
+		countPlaygroundResults: async (runId) => {
+			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).executeTakeFirst();
+			return Number(result?.count ?? 0);
 		},
-		getDistinctTags: async () => {
-			return (await kysely.sql`
-        SELECT DISTINCT key, value
-        FROM llm_requests, jsonb_each_text(tags) AS t(key, value)
-        WHERE tags != '{}'::jsonb
-        ORDER BY key, value
-      `.execute(db)).rows;
+		countCompletedPlaygroundResults: async (runId) => {
+			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).where("status", "=", "completed").executeTakeFirst();
+			return Number(result?.count ?? 0);
 		}
 	};
 };
 
 //#endregion
-//#region src/datalayer/playgrounds.ts
-const createNewPlayground = require_db.zod_default.object({
-	name: require_db.zod_default.string(),
+//#region src/datalayer/playgroundRuns.ts
+const createPlaygroundRun = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.string().uuid(),
 	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
-	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
+	datasetVersionId: require_db.zod_default.string().uuid().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed",
+		"cancelled"
+	]).default("pending"),
+	totalRecords: require_db.zod_default.number().int().default(0)
 });
-const updatePlayground = require_db.zod_default.object({
-	playgroundId: require_db.zod_default.uuidv4(),
-	name: require_db.zod_default.string().optional(),
-	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
-	columns: require_db.zod_default.array(require_db.playgroundColumnSchema).nullable().optional()
+const updatePlaygroundRun = require_db.zod_default.object({
+	runId: require_db.zod_default.string().uuid(),
+	status: require_db.zod_default.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed",
+		"cancelled"
+	]).optional(),
+	startedAt: require_db.zod_default.date().nullable().optional(),
+	completedAt: require_db.zod_default.date().nullable().optional(),
+	completedRecords: require_db.zod_default.number().int().optional()
 });
-const getPlaygroundById = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
-const deletePlayground = require_db.zod_default.object({ playgroundId: require_db.zod_default.uuidv4() });
-const listPlaygrounds = require_db.zod_default.object({
+const getPlaygroundRunById = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const listPlaygroundRuns = require_db.zod_default.object({
+	playgroundId: require_db.zod_default.string().uuid(),
 	limit: require_db.zod_default.number().int().positive().optional(),
 	offset: require_db.zod_default.number().int().nonnegative().optional()
 });
-const createPlaygroundDataLayer = (db) => {
+const deletePlaygroundRun = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
+const createPlaygroundRunsDataLayer = (db) => {
 	return {
-		createNewPlayground: async (params) => {
-			const value = await createNewPlayground.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { name, datasetId, columns } = value.data;
-			return db.insertInto("playgrounds").values({
-				id: (0, node_crypto.randomUUID)(),
-				name,
-				datasetId: datasetId ?? null,
-				columns: columns ? JSON.stringify(columns) : null,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updatePlayground: async (params) => {
-			const value = await updatePlayground.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { playgroundId, name, datasetId, columns } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (name !== void 0) updateData.name = name;
-			if (datasetId !== void 0) updateData.datasetId = datasetId;
-			if (columns !== void 0) updateData.columns = columns ? JSON.stringify(columns) : null;
-			return db.updateTable("playgrounds").set(updateData).where("id", "=", playgroundId).returningAll().executeTakeFirst();
-		},
-		getPlaygroundById: async (params) => {
-			const value = await getPlaygroundById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { playgroundId } = value.data;
-			return db.selectFrom("playgrounds").selectAll().where("id", "=", playgroundId).executeTakeFirst();
-		},
-		deletePlayground: async (params) => {
-			const value = await deletePlayground.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { playgroundId } = value.data;
-			return db.deleteFrom("playgrounds").where("id", "=", playgroundId).returningAll().executeTakeFirst();
-		},
-		listPlaygrounds: async (params) => {
-			const value = await listPlaygrounds.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("playgrounds").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		countPlaygrounds: async () => {
-			const result = await db.selectFrom("playgrounds").select(db.fn.countAll().as("count")).executeTakeFirst();
-			return Number(result?.count ?? 0);
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/playgroundResults.ts
-const createPlaygroundResult = require_db.zod_default.object({
-	runId: require_db.zod_default.string().uuid(),
-	columnId: require_db.zod_default.string().uuid(),
-	datasetRecordId: require_db.zod_default.string().uuid().nullable().optional(),
-	inputVariables: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({}),
-	status: require_db.zod_default.enum([
-		"pending",
-		"running",
-		"completed",
-		"failed"
-	]).default("pending")
-});
-const createPlaygroundResultsBatch = require_db.zod_default.object({ results: require_db.zod_default.array(createPlaygroundResult) });
-const updatePlaygroundResult = require_db.zod_default.object({
-	resultId: require_db.zod_default.string().uuid(),
-	outputContent: require_db.zod_default.string().nullable().optional(),
-	status: require_db.zod_default.enum([
-		"pending",
-		"running",
-		"completed",
-		"failed"
-	]).optional(),
-	error: require_db.zod_default.string().nullable().optional(),
-	latencyMs: require_db.zod_default.number().int().nullable().optional(),
-	promptTokens: require_db.zod_default.number().int().nullable().optional(),
-	completionTokens: require_db.zod_default.number().int().nullable().optional(),
-	totalTokens: require_db.zod_default.number().int().nullable().optional(),
-	cost: require_db.zod_default.number().int().nullable().optional()
-});
-const getPlaygroundResultById = require_db.zod_default.object({ resultId: require_db.zod_default.string().uuid() });
-const listPlaygroundResults = require_db.zod_default.object({
-	runId: require_db.zod_default.string().uuid(),
-	columnId: require_db.zod_default.string().uuid().optional(),
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const deletePlaygroundResultsByRunId = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
-const createPlaygroundResultsDataLayer = (db) => {
-	return {
-		createPlaygroundResult: async (params) => {
-			const value = await createPlaygroundResult.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { runId, columnId, datasetRecordId, inputVariables, status } = value.data;
-			return db.insertInto("playground_results").values({
-				id: (0, node_crypto.randomUUID)(),
-				runId,
-				columnId,
-				datasetRecordId: datasetRecordId ?? null,
-				inputVariables: JSON.stringify(inputVariables),
-				outputContent: null,
-				status,
-				error: null,
-				latencyMs: null,
-				promptTokens: null,
-				completionTokens: null,
-				totalTokens: null,
-				cost: null,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		createPlaygroundResultsBatch: async (params) => {
-			const value = await createPlaygroundResultsBatch.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { results } = value.data;
-			if (results.length === 0) return [];
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const values = results.map((result) => ({
-				id: (0, node_crypto.randomUUID)(),
-				runId: result.runId,
-				columnId: result.columnId,
-				datasetRecordId: result.datasetRecordId ?? null,
-				inputVariables: JSON.stringify(result.inputVariables),
-				outputContent: null,
-				status: result.status,
-				error: null,
-				latencyMs: null,
-				promptTokens: null,
-				completionTokens: null,
-				totalTokens: null,
-				cost: null,
-				createdAt: now,
-				updatedAt: now
-			}));
-			return db.insertInto("playground_results").values(values).returningAll().execute();
-		},
-		updatePlaygroundResult: async (params) => {
-			const value = await updatePlaygroundResult.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { resultId, outputContent, status, error, latencyMs, promptTokens, completionTokens, totalTokens, cost } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (outputContent !== void 0) updateData.outputContent = outputContent;
-			if (status !== void 0) updateData.status = status;
-			if (error !== void 0) updateData.error = error;
-			if (latencyMs !== void 0) updateData.latencyMs = latencyMs;
-			if (promptTokens !== void 0) updateData.promptTokens = promptTokens;
-			if (completionTokens !== void 0) updateData.completionTokens = completionTokens;
-			if (totalTokens !== void 0) updateData.totalTokens = totalTokens;
-			if (cost !== void 0) updateData.cost = cost;
-			return db.updateTable("playground_results").set(updateData).where("id", "=", resultId).returningAll().executeTakeFirst();
-		},
-		getPlaygroundResultById: async (params) => {
-			const value = await getPlaygroundResultById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { resultId } = value.data;
-			return db.selectFrom("playground_results").selectAll().where("id", "=", resultId).executeTakeFirst();
-		},
-		listPlaygroundResults: async (params) => {
-			const value = await listPlaygroundResults.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { runId, columnId, limit = 500, offset = 0 } = value.data;
-			let query = db.selectFrom("playground_results").selectAll().where("runId", "=", runId);
-			if (columnId) query = query.where("columnId", "=", columnId);
-			return query.orderBy("createdAt", "asc").limit(limit).offset(offset).execute();
-		},
-		deletePlaygroundResultsByRunId: async (params) => {
-			const value = await deletePlaygroundResultsByRunId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { runId } = value.data;
-			return db.deleteFrom("playground_results").where("runId", "=", runId).returningAll().execute();
-		},
-		countPlaygroundResults: async (runId) => {
-			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).executeTakeFirst();
-			return Number(result?.count ?? 0);
-		},
-		countCompletedPlaygroundResults: async (runId) => {
-			const result = await db.selectFrom("playground_results").select(db.fn.countAll().as("count")).where("runId", "=", runId).where("status", "=", "completed").executeTakeFirst();
-			return Number(result?.count ?? 0);
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/playgroundRuns.ts
-const createPlaygroundRun = require_db.zod_default.object({
-	playgroundId: require_db.zod_default.string().uuid(),
-	datasetId: require_db.zod_default.string().uuid().nullable().optional(),
-	datasetVersionId: require_db.zod_default.string().uuid().nullable().optional(),
-	status: require_db.zod_default.enum([
-		"pending",
-		"running",
-		"completed",
-		"failed",
-		"cancelled"
-	]).default("pending"),
-	totalRecords: require_db.zod_default.number().int().default(0)
-});
-const updatePlaygroundRun = require_db.zod_default.object({
-	runId: require_db.zod_default.string().uuid(),
-	status: require_db.zod_default.enum([
-		"pending",
-		"running",
-		"completed",
-		"failed",
-		"cancelled"
-	]).optional(),
-	startedAt: require_db.zod_default.date().nullable().optional(),
-	completedAt: require_db.zod_default.date().nullable().optional(),
-	completedRecords: require_db.zod_default.number().int().optional()
-});
-const getPlaygroundRunById = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
-const listPlaygroundRuns = require_db.zod_default.object({
-	playgroundId: require_db.zod_default.string().uuid(),
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const deletePlaygroundRun = require_db.zod_default.object({ runId: require_db.zod_default.string().uuid() });
-const createPlaygroundRunsDataLayer = (db) => {
-	return {
-		createPlaygroundRun: async (params) => {
-			const value = await createPlaygroundRun.safeParseAsync(params);
+		createPlaygroundRun: async (params) => {
+			const value = await createPlaygroundRun.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
 			const { playgroundId, datasetId, datasetVersionId, status, totalRecords } = value.data;
 			return db.insertInto("playground_runs").values({
@@ -2188,478 +1681,641 @@ const createPlaygroundRunsDataLayer = (db) => {
 };
 
 //#endregion
-//#region src/datalayer/providerConfigs.ts
-/**
-* Generate a unique slug for a provider config.
-* If the base slug already exists, appends -01, -02, etc.
-*/
-async function generateUniqueSlug(db, baseSlug) {
-	const existing = await db.selectFrom("provider_configs").select("slug").where("slug", "like", `${baseSlug}%`).execute();
-	if (existing.length === 0) return baseSlug;
-	const existingSlugs = new Set(existing.map((e) => e.slug));
-	if (!existingSlugs.has(baseSlug)) return baseSlug;
-	let counter = 1;
-	while (counter < 100) {
-		const candidateSlug = `${baseSlug}-${counter.toString().padStart(2, "0")}`;
-		if (!existingSlugs.has(candidateSlug)) return candidateSlug;
-		counter++;
-	}
-	return `${baseSlug}-${(0, node_crypto.randomUUID)().slice(0, 8)}`;
-}
-const createProviderConfig = require_db.zod_default.object({
-	providerId: require_db.zod_default.string().min(1),
-	slug: require_db.zod_default.string().nullable().optional(),
-	name: require_db.zod_default.string().nullable().optional(),
-	config: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()),
-	enabled: require_db.zod_default.boolean().optional().default(true)
-});
-const updateProviderConfig = require_db.zod_default.object({
-	id: require_db.zod_default.uuidv4(),
-	slug: require_db.zod_default.string().nullable().optional(),
+//#region src/datalayer/workspaceSettings.ts
+const updateWorkspaceSettings = require_db.zod_default.object({
 	name: require_db.zod_default.string().nullable().optional(),
-	config: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional(),
-	enabled: require_db.zod_default.boolean().optional()
-});
-const getProviderConfigById = require_db.zod_default.object({ id: require_db.zod_default.uuidv4() });
-const getProviderConfigByProviderId = require_db.zod_default.object({ providerId: require_db.zod_default.string().min(1) });
-const getProviderConfigBySlug = require_db.zod_default.object({ slug: require_db.zod_default.string().min(1) });
-const deleteProviderConfig = require_db.zod_default.object({ id: require_db.zod_default.uuidv4() });
-const listProviderConfigs = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
+	setupComplete: require_db.zod_default.boolean().optional(),
+	superAdminId: require_db.zod_default.string().nullable().optional()
 });
-const createProviderConfigsDataLayer = (db) => {
+const createWorkspaceSettingsDataLayer = (db) => {
 	return {
-		createProviderConfig: async (params) => {
-			const value = await createProviderConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerId, slug, name, config, enabled } = value.data;
-			const finalSlug = slug ?? await generateUniqueSlug(db, providerId);
-			return db.insertInto("provider_configs").values({
+		getWorkspaceSettings: async () => {
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (!settings) settings = await db.insertInto("workspace_settings").values({
 				id: (0, node_crypto.randomUUID)(),
-				providerId,
-				slug: finalSlug,
-				name: name ?? null,
-				config: JSON.stringify(config),
-				enabled,
+				name: null,
+				setupComplete: false,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 			}).returningAll().executeTakeFirst();
+			return settings;
 		},
-		updateProviderConfig: async (params) => {
-			const value = await updateProviderConfig.safeParseAsync(params);
+		updateWorkspaceSettings: async (params) => {
+			const value = await updateWorkspaceSettings.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, slug, name, config, enabled } = value.data;
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (!settings) return db.insertInto("workspace_settings").values({
+				id: (0, node_crypto.randomUUID)(),
+				name: value.data.name ?? null,
+				setupComplete: value.data.setupComplete ?? false,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
 			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (slug !== void 0) updateData.slug = slug;
-			if (name !== void 0) updateData.name = name;
-			if (config !== void 0) updateData.config = JSON.stringify(config);
-			if (enabled !== void 0) updateData.enabled = enabled;
-			return db.updateTable("provider_configs").set(updateData).where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		getProviderConfigById: async (params) => {
-			const value = await getProviderConfigById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("provider_configs").selectAll().where("id", "=", id).executeTakeFirst();
+			if (value.data.name !== void 0) updateData.name = value.data.name ?? null;
+			if (value.data.setupComplete !== void 0) updateData.setupComplete = value.data.setupComplete;
+			if (value.data.superAdminId !== void 0) updateData.superAdminId = value.data.superAdminId ?? null;
+			return db.updateTable("workspace_settings").set(updateData).where("id", "=", settings.id).returningAll().executeTakeFirst();
 		},
-		getProviderConfigByProviderId: async (params) => {
-			const value = await getProviderConfigByProviderId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerId } = value.data;
-			return db.selectFrom("provider_configs").selectAll().where("providerId", "=", providerId).executeTakeFirst();
-		},
-		getProviderConfigBySlug: async (params) => {
-			const value = await getProviderConfigBySlug.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { slug } = value.data;
-			return db.selectFrom("provider_configs").selectAll().where("slug", "=", slug).executeTakeFirst();
-		},
-		deleteProviderConfig: async (params) => {
-			const value = await deleteProviderConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("provider_configs").where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		listProviderConfigs: async (params) => {
-			const value = await listProviderConfigs.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("provider_configs").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		countProviderConfigs: async () => {
-			const result = await db.selectFrom("provider_configs").select(db.fn.countAll().as("count")).executeTakeFirst();
-			return Number(result?.count ?? 0);
+		getSuperAdminId: async () => {
+			return (await db.selectFrom("workspace_settings").select("superAdminId").executeTakeFirst())?.superAdminId ?? null;
 		},
-		upsertProviderConfig: async (params) => {
-			const value = await createProviderConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerId, slug, name, config, enabled } = value.data;
-			const existing = await db.selectFrom("provider_configs").selectAll().where("providerId", "=", providerId).executeTakeFirst();
-			if (existing) {
-				const finalSlug$1 = slug ?? existing.slug ?? await generateUniqueSlug(db, providerId);
-				return db.updateTable("provider_configs").set({
-					slug: finalSlug$1,
-					name: name ?? existing.name,
-					config: JSON.stringify(config),
-					enabled,
+		setSuperAdminId: async (userId) => {
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (settings?.superAdminId) return false;
+			if (!settings) {
+				await db.insertInto("workspace_settings").values({
+					id: (0, node_crypto.randomUUID)(),
+					name: null,
+					setupComplete: false,
+					superAdminId: userId,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				}).where("id", "=", existing.id).returningAll().executeTakeFirst();
+				}).execute();
+				return true;
 			}
-			const finalSlug = slug ?? await generateUniqueSlug(db, providerId);
-			return db.insertInto("provider_configs").values({
-				id: (0, node_crypto.randomUUID)(),
-				providerId,
-				slug: finalSlug,
-				name: name ?? null,
-				config: JSON.stringify(config),
-				enabled,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/providerGuardrailOverrides.ts
-const createProviderGuardrailOverride = require_db.zod_default.object({
-	providerConfigId: require_db.zod_default.string().uuid(),
-	guardrailConfigId: require_db.zod_default.string().uuid(),
-	enabled: require_db.zod_default.boolean().optional().default(true),
-	parameters: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional()
-});
-const updateProviderGuardrailOverride = require_db.zod_default.object({
-	id: require_db.zod_default.string().uuid(),
-	enabled: require_db.zod_default.boolean().optional(),
-	parameters: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional()
-});
-const getOverrideById = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const deleteOverride = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const getOverridesByProviderConfigId = require_db.zod_default.object({ providerConfigId: require_db.zod_default.string().uuid() });
-const getOverridesByGuardrailConfigId = require_db.zod_default.object({ guardrailConfigId: require_db.zod_default.string().uuid() });
-const getOverrideByProviderAndGuardrail = require_db.zod_default.object({
-	providerConfigId: require_db.zod_default.string().uuid(),
-	guardrailConfigId: require_db.zod_default.string().uuid()
-});
-const createProviderGuardrailOverridesDataLayer = (db) => {
-	return {
-		createProviderGuardrailOverride: async (params) => {
-			const value = await createProviderGuardrailOverride.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerConfigId, guardrailConfigId, enabled, parameters } = value.data;
-			return db.insertInto("provider_guardrail_overrides").values({
-				id: (0, node_crypto.randomUUID)(),
-				providerConfigId,
-				guardrailConfigId,
-				enabled,
-				parameters: parameters ? JSON.stringify(parameters) : null,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			await db.updateTable("workspace_settings").set({
+				superAdminId: userId,
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateProviderGuardrailOverride: async (params) => {
-			const value = await updateProviderGuardrailOverride.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, enabled, parameters } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (enabled !== void 0) updateData.enabled = enabled;
-			if (parameters !== void 0) updateData.parameters = parameters ? JSON.stringify(parameters) : null;
-			return db.updateTable("provider_guardrail_overrides").set(updateData).where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		getOverrideById: async (params) => {
-			const value = await getOverrideById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("provider_guardrail_overrides").selectAll().where("id", "=", id).executeTakeFirst();
-		},
-		deleteProviderGuardrailOverride: async (params) => {
-			const value = await deleteOverride.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("provider_guardrail_overrides").where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		getOverridesByProviderConfigId: async (params) => {
-			const value = await getOverridesByProviderConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerConfigId } = value.data;
-			return db.selectFrom("provider_guardrail_overrides").selectAll().where("providerConfigId", "=", providerConfigId).execute();
-		},
-		getOverridesByGuardrailConfigId: async (params) => {
-			const value = await getOverridesByGuardrailConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { guardrailConfigId } = value.data;
-			return db.selectFrom("provider_guardrail_overrides").selectAll().where("guardrailConfigId", "=", guardrailConfigId).execute();
+			}).where("id", "=", settings.id).execute();
+			return true;
 		},
-		getOverrideByProviderAndGuardrail: async (params) => {
-			const value = await getOverrideByProviderAndGuardrail.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerConfigId, guardrailConfigId } = value.data;
-			return db.selectFrom("provider_guardrail_overrides").selectAll().where("providerConfigId", "=", providerConfigId).where("guardrailConfigId", "=", guardrailConfigId).executeTakeFirst();
+		isSetupComplete: async () => {
+			try {
+				return (await db.selectFrom("workspace_settings").select("setupComplete").executeTakeFirst())?.setupComplete ?? false;
+			} catch {
+				return false;
+			}
 		},
-		upsertProviderGuardrailOverride: async (params) => {
-			const value = await createProviderGuardrailOverride.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerConfigId, guardrailConfigId, enabled, parameters } = value.data;
-			const existing = await db.selectFrom("provider_guardrail_overrides").selectAll().where("providerConfigId", "=", providerConfigId).where("guardrailConfigId", "=", guardrailConfigId).executeTakeFirst();
-			if (existing) return db.updateTable("provider_guardrail_overrides").set({
-				enabled,
-				parameters: parameters ? JSON.stringify(parameters) : null,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).where("id", "=", existing.id).returningAll().executeTakeFirst();
-			return db.insertInto("provider_guardrail_overrides").values({
+		markSetupComplete: async () => {
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (!settings) return db.insertInto("workspace_settings").values({
 				id: (0, node_crypto.randomUUID)(),
-				providerConfigId,
-				guardrailConfigId,
-				enabled,
-				parameters: parameters ? JSON.stringify(parameters) : null,
+				name: null,
+				setupComplete: true,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 			}).returningAll().executeTakeFirst();
-		},
-		deleteOverridesByGuardrailConfigId: async (params) => {
-			const value = await getOverridesByGuardrailConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { guardrailConfigId } = value.data;
-			return db.deleteFrom("provider_guardrail_overrides").where("guardrailConfigId", "=", guardrailConfigId).execute();
+			return db.updateTable("workspace_settings").set({
+				setupComplete: true,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).where("id", "=", settings.id).returningAll().executeTakeFirst();
 		}
 	};
 };
 
 //#endregion
-//#region src/datalayer/traces.ts
-const col = (name) => kysely.sql.ref(name);
+//#region src/datalayer/create.ts
 /**
-* Schema for upserting a trace
+* Create all datalayers from a Kysely database instance.
+* Returns a flat object with all datalayer methods spread together.
 */
-const upsertTraceSchema = require_db.zod_default.object({
-	traceId: require_db.zod_default.string(),
-	name: require_db.zod_default.string().nullable().optional(),
-	sessionId: require_db.zod_default.string().nullable().optional(),
-	userId: require_db.zod_default.string().nullable().optional(),
-	status: require_db.zod_default.enum([
-		"unset",
-		"ok",
-		"error"
-	]).default("unset"),
-	startTime: require_db.zod_default.date(),
-	endTime: require_db.zod_default.date().nullable().optional(),
-	durationMs: require_db.zod_default.number().int().nullable().optional(),
-	spanCount: require_db.zod_default.number().int().default(1),
-	totalInputTokens: require_db.zod_default.number().int().default(0),
-	totalOutputTokens: require_db.zod_default.number().int().default(0),
-	totalTokens: require_db.zod_default.number().int().default(0),
-	totalCost: require_db.zod_default.number().int().default(0),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
-	metadata: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
-});
+function createDataLayer(db) {
+	return {
+		...createDatasetsDataLayer(db),
+		...createPlaygroundDataLayer(db),
+		...createPlaygroundResultsDataLayer(db),
+		...createPlaygroundRunsDataLayer(db),
+		...createWorkspaceSettingsDataLayer(db)
+	};
+}
+
+//#endregion
+//#region src/pricing/calculator.ts
 /**
-* Schema for inserting spans
+* Calculate the cost of an LLM request in micro-dollars
+*
+* Micro-dollars are used to avoid floating-point precision issues:
+* - 1 dollar = 1,000,000 micro-dollars
+* - $0.001 = 1,000 micro-dollars
+* - $0.000001 = 1 micro-dollar
+*
+* @param usage - Token usage data from the LLM response
+* @param pricing - Model pricing information
+* @returns Cost breakdown in micro-dollars
+*
+* @example
+* ```typescript
+* const usage = { promptTokens: 1000, completionTokens: 500 };
+* const pricing = { inputCostPer1M: 2.5, outputCostPer1M: 10.0 };
+* const cost = calculateCost(usage, pricing);
+* // cost = { inputCost: 2500, outputCost: 5000, totalCost: 7500 }
+* // In dollars: $0.0025 input + $0.005 output = $0.0075 total
+* ```
 */
-const insertSpanSchema = require_db.zod_default.object({
-	traceId: require_db.zod_default.string(),
-	spanId: require_db.zod_default.string(),
-	parentSpanId: require_db.zod_default.string().nullable().optional(),
-	name: require_db.zod_default.string(),
-	kind: require_db.zod_default.number().int().default(1),
-	status: require_db.zod_default.number().int().default(0),
-	statusMessage: require_db.zod_default.string().nullable().optional(),
-	startTime: require_db.zod_default.date(),
-	endTime: require_db.zod_default.date().nullable().optional(),
-	durationMs: require_db.zod_default.number().int().nullable().optional(),
-	provider: require_db.zod_default.string().nullable().optional(),
-	model: require_db.zod_default.string().nullable().optional(),
-	promptTokens: require_db.zod_default.number().int().default(0),
-	completionTokens: require_db.zod_default.number().int().default(0),
-	totalTokens: require_db.zod_default.number().int().default(0),
-	cost: require_db.zod_default.number().int().default(0),
-	configId: require_db.zod_default.string().uuid().nullable().optional(),
-	variantId: require_db.zod_default.string().uuid().nullable().optional(),
-	environmentId: require_db.zod_default.string().uuid().nullable().optional(),
-	providerConfigId: require_db.zod_default.string().uuid().nullable().optional(),
-	requestId: require_db.zod_default.string().uuid().nullable().optional(),
-	source: require_db.zod_default.enum([
-		"gateway",
-		"otlp",
-		"langsmith"
-	]).default("gateway"),
-	input: require_db.zod_default.unknown().nullable().optional(),
-	output: require_db.zod_default.unknown().nullable().optional(),
-	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
-});
+function calculateCost(usage, pricing) {
+	const inputCost = Math.round(usage.promptTokens * pricing.inputCostPer1M);
+	const outputCost = Math.round(usage.completionTokens * pricing.outputCostPer1M);
+	return {
+		inputCost,
+		outputCost,
+		totalCost: inputCost + outputCost,
+		cacheSavings: 0
+	};
+}
 /**
-* Schema for inserting span events
+* Get default cache read rate as a fraction of input cost per provider.
+* Used when models.dev doesn't provide cache pricing.
 */
-const insertSpanEventSchema = require_db.zod_default.object({
-	traceId: require_db.zod_default.string(),
-	spanId: require_db.zod_default.string(),
-	name: require_db.zod_default.string(),
-	timestamp: require_db.zod_default.date(),
-	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
-});
+function getDefaultCacheReadRate(provider, inputCostPer1M) {
+	switch (provider?.toLowerCase()) {
+		case "anthropic": return inputCostPer1M * .1;
+		case "openai":
+		case "azure-openai": return inputCostPer1M * .5;
+		case "google":
+		case "gemini":
+		case "vertex_ai": return inputCostPer1M * .25;
+		default: return inputCostPer1M * .5;
+	}
+}
 /**
-* Schema for listing traces
+* Get default cache write/creation rate as a fraction of input cost per provider.
+* Used when models.dev doesn't provide cache pricing.
 */
-const listTracesSchema = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().max(1e3).default(50),
-	offset: require_db.zod_default.number().int().nonnegative().default(0),
-	sessionId: require_db.zod_default.string().optional(),
-	userId: require_db.zod_default.string().optional(),
-	status: require_db.zod_default.enum([
-		"unset",
-		"ok",
-		"error"
-	]).optional(),
-	name: require_db.zod_default.string().optional(),
-	startDate: require_db.zod_default.date().optional(),
-	endDate: require_db.zod_default.date().optional(),
-	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
-});
+function getDefaultCacheWriteRate(provider, inputCostPer1M) {
+	switch (provider?.toLowerCase()) {
+		case "anthropic": return inputCostPer1M * 1.25;
+		default: return inputCostPer1M;
+	}
+}
 /**
-* Schema for trace stats query
+* Calculate cache-aware cost of an LLM request in micro-dollars.
+*
+* Splits input tokens into uncached, cache-read, and cache-creation buckets,
+* each priced at different rates. Falls back to provider-specific multipliers
+* when models.dev doesn't provide cache pricing.
+*
+* @param usage - Token usage data (with cachedTokens and cacheCreationTokens)
+* @param pricing - Model pricing (may include cacheReadCostPer1M / cacheWriteCostPer1M)
+* @param provider - Provider name for fallback rate selection
+* @returns Cost breakdown in micro-dollars
 */
-const traceStatsSchema = require_db.zod_default.object({
-	startDate: require_db.zod_default.date(),
-	endDate: require_db.zod_default.date(),
-	sessionId: require_db.zod_default.string().optional(),
-	userId: require_db.zod_default.string().optional()
-});
-const createTracesDataLayer = (db) => {
+function calculateCacheAwareCost(usage, pricing, provider) {
+	const cachedTokens = usage.cachedTokens ?? 0;
+	const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
+	if (cachedTokens === 0 && cacheCreationTokens === 0) return calculateCost(usage, pricing);
+	const cacheReadRate = pricing.cacheReadCostPer1M ?? getDefaultCacheReadRate(provider, pricing.inputCostPer1M);
+	const cacheWriteRate = pricing.cacheWriteCostPer1M ?? getDefaultCacheWriteRate(provider, pricing.inputCostPer1M);
+	const uncachedInputTokens = Math.max(0, usage.promptTokens - cachedTokens - cacheCreationTokens);
+	const regularInputCost = Math.round(uncachedInputTokens * pricing.inputCostPer1M);
+	const cacheReadCost = Math.round(cachedTokens * cacheReadRate);
+	const cacheWriteCost = Math.round(cacheCreationTokens * cacheWriteRate);
+	const outputCost = Math.round(usage.completionTokens * pricing.outputCostPer1M);
+	const inputCost = regularInputCost + cacheReadCost + cacheWriteCost;
 	return {
-		upsertTrace: async (data) => {
-			const result = await upsertTraceSchema.safeParseAsync(data);
-			if (!result.success) throw new LLMOpsError(`Invalid trace data: ${result.error.message}`);
-			const trace = result.data;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			await kysely.sql`
-        INSERT INTO "traces" (
-          "id", "traceId", "name", "sessionId", "userId", "status",
-          "startTime", "endTime", "durationMs", "spanCount",
-          "totalInputTokens", "totalOutputTokens", "totalTokens", "totalCost",
-          "tags", "metadata", "createdAt", "updatedAt"
-        ) VALUES (
-          ${(0, node_crypto.randomUUID)()}, ${trace.traceId}, ${trace.name ?? null}, ${trace.sessionId ?? null},
-          ${trace.userId ?? null}, ${trace.status},
-          ${trace.startTime.toISOString()}, ${trace.endTime?.toISOString() ?? null},
-          ${trace.durationMs ?? null}, ${trace.spanCount},
-          ${trace.totalInputTokens}, ${trace.totalOutputTokens},
-          ${trace.totalTokens}, ${trace.totalCost},
-          ${JSON.stringify(trace.tags)}::jsonb, ${JSON.stringify(trace.metadata)}::jsonb,
-          ${now}, ${now}
-        )
-        ON CONFLICT ("traceId") DO UPDATE SET
-          "name" = COALESCE(EXCLUDED."name", "traces"."name"),
-          "sessionId" = COALESCE(EXCLUDED."sessionId", "traces"."sessionId"),
-          "userId" = COALESCE(EXCLUDED."userId", "traces"."userId"),
-          "status" = CASE
-            WHEN EXCLUDED."status" = 'error' THEN 'error'
-            WHEN EXCLUDED."status" = 'ok' AND "traces"."status" != 'error' THEN 'ok'
-            ELSE "traces"."status"
-          END,
-          "startTime" = LEAST("traces"."startTime", EXCLUDED."startTime"),
-          "endTime" = GREATEST(
-            COALESCE("traces"."endTime", EXCLUDED."endTime"),
-            COALESCE(EXCLUDED."endTime", "traces"."endTime")
-          ),
-          "durationMs" = EXTRACT(EPOCH FROM (
-            GREATEST(
-              COALESCE("traces"."endTime", EXCLUDED."endTime"),
-              COALESCE(EXCLUDED."endTime", "traces"."endTime")
-            ) -
-            LEAST("traces"."startTime", EXCLUDED."startTime")
-          ))::integer * 1000,
-          "spanCount" = "traces"."spanCount" + EXCLUDED."spanCount",
-          "totalInputTokens" = "traces"."totalInputTokens" + EXCLUDED."totalInputTokens",
-          "totalOutputTokens" = "traces"."totalOutputTokens" + EXCLUDED."totalOutputTokens",
-          "totalTokens" = "traces"."totalTokens" + EXCLUDED."totalTokens",
-          "totalCost" = "traces"."totalCost" + EXCLUDED."totalCost",
-          "tags" = "traces"."tags" || EXCLUDED."tags",
-          "metadata" = "traces"."metadata" || EXCLUDED."metadata",
-          "updatedAt" = ${now}
-      `.execute(db);
-		},
-		batchInsertSpans: async (spans) => {
-			if (spans.length === 0) return { count: 0 };
-			const validatedSpans = [];
-			for (const span of spans) {
-				const result = await insertSpanSchema.safeParseAsync(span);
-				if (!result.success) {
-					require_db.logger.warn(`[batchInsertSpans] Skipping invalid span ${span.spanId}: ${result.error.message}`);
-					continue;
-				}
-				validatedSpans.push(result.data);
+		inputCost,
+		outputCost,
+		totalCost: inputCost + outputCost,
+		cacheSavings: Math.round((cachedTokens + cacheCreationTokens) * pricing.inputCostPer1M) - cacheReadCost - cacheWriteCost
+	};
+}
+/**
+* Convert micro-dollars to dollars
+*
+* @param microDollars - Amount in micro-dollars
+* @returns Amount in dollars
+*
+* @example
+* ```typescript
+* microDollarsToDollars(7500); // 0.0075
+* microDollarsToDollars(1000000); // 1.0
+* ```
+*/
+function microDollarsToDollars(microDollars) {
+	return microDollars / 1e6;
+}
+/**
+* Convert dollars to micro-dollars
+*
+* @param dollars - Amount in dollars
+* @returns Amount in micro-dollars (rounded to nearest integer)
+*
+* @example
+* ```typescript
+* dollarsToMicroDollars(0.0075); // 7500
+* dollarsToMicroDollars(1.0); // 1000000
+* ```
+*/
+function dollarsToMicroDollars(dollars) {
+	return Math.round(dollars * 1e6);
+}
+/**
+* Format micro-dollars as a human-readable dollar string
+*
+* @param microDollars - Amount in micro-dollars
+* @param decimals - Number of decimal places (default: 6)
+* @returns Formatted dollar string
+*
+* @example
+* ```typescript
+* formatCost(7500); // "$0.007500"
+* formatCost(1234567, 2); // "$1.23"
+* ```
+*/
+function formatCost(microDollars, decimals = 6) {
+	return `$${microDollarsToDollars(microDollars).toFixed(decimals)}`;
+}
+
+//#endregion
+//#region src/pricing/provider.ts
+const LLMOPS_MODELS_API = "https://models.llmops.build";
+/**
+* Convert price from USD cents per token to dollars per 1M tokens.
+*
+* API returns cents/token. Our system uses dollars/1M tokens.
+* Formula: (centsPerToken / 100) * 1_000_000 = centsPerToken * 10_000
+*/
+function centsPerTokenToCostPer1M(centsPerToken) {
+	return centsPerToken * 1e4;
+}
+/**
+* Pricing provider that fetches per-model data from the LLMOps Models API.
+*
+* Features:
+* - Per-model in-memory cache with configurable TTL (default 5 minutes)
+* - Deduplicates concurrent fetches for the same model
+* - Caches null results (404s) to avoid repeated lookups
+* - Falls back to stale cache on fetch errors
+*/
+var LLMOpsPricingProvider = class {
+	cache = /* @__PURE__ */ new Map();
+	pendingFetches = /* @__PURE__ */ new Map();
+	cacheTTL;
+	baseUrl;
+	constructor(options) {
+		this.cacheTTL = options?.cacheTTL ?? 300 * 1e3;
+		this.baseUrl = options?.baseUrl ?? LLMOPS_MODELS_API;
+	}
+	getCacheKey(provider, model) {
+		return `${provider.toLowerCase()}:${model.toLowerCase()}`;
+	}
+	/**
+	* Fetch pricing for a single model from the API
+	*/
+	async fetchModelPricing(provider, model) {
+		const url = `${this.baseUrl}/model-configs/pricing/${encodeURIComponent(provider)}/${model}`;
+		try {
+			require_db.logger.debug(`[Pricing] GET ${url}`);
+			const startTime = Date.now();
+			const response = await fetch(url);
+			const elapsed = Date.now() - startTime;
+			require_db.logger.debug(`[Pricing] GET ${url} -> ${response.status} (${elapsed}ms)`);
+			if (response.status === 404) {
+				require_db.logger.debug(`[Pricing] No pricing found for ${provider}/${model}`);
+				return null;
 			}
-			if (validatedSpans.length === 0) return { count: 0 };
+			if (!response.ok) throw new Error(`API returned ${response.status}`);
+			const data = await response.json();
+			if (!data.pay_as_you_go) return null;
+			const payg = data.pay_as_you_go;
+			const pricing = {
+				inputCostPer1M: centsPerTokenToCostPer1M(payg.request_token?.price ?? 0),
+				outputCostPer1M: centsPerTokenToCostPer1M(payg.response_token?.price ?? 0),
+				cacheReadCostPer1M: payg.cache_read_input_token?.price != null ? centsPerTokenToCostPer1M(payg.cache_read_input_token.price) : void 0,
+				cacheWriteCostPer1M: payg.cache_write_input_token?.price != null ? centsPerTokenToCostPer1M(payg.cache_write_input_token.price) : void 0
+			};
+			require_db.logger.debug(`[Pricing] Cached pricing for ${provider}/${model}: input=$${pricing.inputCostPer1M}/1M, output=$${pricing.outputCostPer1M}/1M`);
+			return pricing;
+		} catch (error) {
+			require_db.logger.error(`[Pricing] Failed to fetch pricing for ${provider}/${model}: ${error instanceof Error ? error.message : String(error)}`);
+			const cacheKey = this.getCacheKey(provider, model);
+			const stale = this.cache.get(cacheKey);
+			if (stale) {
+				require_db.logger.debug(`[Pricing] Using stale cache for ${provider}/${model}`);
+				return stale.pricing;
+			}
+			return null;
+		}
+	}
+	/**
+	* Internal: fetch with cache and deduplication for a specific provider+model
+	*/
+	async getCachedPricing(provider, model) {
+		const cacheKey = this.getCacheKey(provider, model);
+		const cached = this.cache.get(cacheKey);
+		if (cached && Date.now() - cached.fetchedAt < this.cacheTTL) return cached.pricing;
+		let pending = this.pendingFetches.get(cacheKey);
+		if (!pending) {
+			pending = this.fetchModelPricing(provider, model).then((pricing) => {
+				this.cache.set(cacheKey, {
+					pricing,
+					fetchedAt: Date.now()
+				});
+				return pricing;
+			}).finally(() => {
+				this.pendingFetches.delete(cacheKey);
+			});
+			this.pendingFetches.set(cacheKey, pending);
+		}
+		return pending;
+	}
+	/**
+	* Get pricing for a specific model.
+	*
+	* When the model name contains a slash (e.g. "google/gemini-2.5-flash"),
+	* it's likely an OpenRouter model ID. If the initial provider lookup fails,
+	* we automatically retry with "openrouter" as the provider.
+	*/
+	async getModelPricing(provider, model) {
+		const pricing = await this.getCachedPricing(provider, model);
+		if (pricing) return pricing;
+		if (!pricing && model.includes("/") && provider.toLowerCase() !== "openrouter") {
+			require_db.logger.debug(`[Pricing] Retrying ${provider}/${model} as openrouter/${model}`);
+			return this.getCachedPricing("openrouter", model);
+		}
+		return pricing;
+	}
+	/**
+	* Force refresh the pricing cache (clears all cached entries)
+	*/
+	async refreshCache() {
+		this.cache.clear();
+	}
+	/**
+	* Always ready — no bulk pre-fetch needed
+	*/
+	isReady() {
+		return true;
+	}
+	/**
+	* Get the number of cached models (for debugging)
+	*/
+	getCacheSize() {
+		return this.cache.size;
+	}
+};
+let defaultProvider = null;
+/**
+* Get the default pricing provider instance
+*/
+function getDefaultPricingProvider() {
+	if (!defaultProvider) defaultProvider = new LLMOpsPricingProvider();
+	return defaultProvider;
+}
+
+//#endregion
+//#region src/telemetry/postgres.ts
+const guardrailResultSchema = require_db.zod_default.object({
+	checkId: require_db.zod_default.string(),
+	functionId: require_db.zod_default.string(),
+	hookType: require_db.zod_default.enum(["beforeRequestHook", "afterRequestHook"]),
+	verdict: require_db.zod_default.boolean(),
+	latencyMs: require_db.zod_default.number()
+});
+const guardrailResultsSchema = require_db.zod_default.object({
+	results: require_db.zod_default.array(guardrailResultSchema),
+	action: require_db.zod_default.enum([
+		"allowed",
+		"blocked",
+		"logged"
+	]),
+	totalLatencyMs: require_db.zod_default.number()
+});
+const insertLLMRequestSchema = require_db.zod_default.object({
+	requestId: require_db.zod_default.string().uuid(),
+	configId: require_db.zod_default.string().uuid().nullable().optional(),
+	variantId: require_db.zod_default.string().uuid().nullable().optional(),
+	environmentId: require_db.zod_default.string().uuid().nullable().optional(),
+	providerConfigId: require_db.zod_default.string().uuid().nullable().optional(),
+	provider: require_db.zod_default.string(),
+	model: require_db.zod_default.string(),
+	promptTokens: require_db.zod_default.number().int().default(0),
+	completionTokens: require_db.zod_default.number().int().default(0),
+	totalTokens: require_db.zod_default.number().int().default(0),
+	cachedTokens: require_db.zod_default.number().int().default(0),
+	cacheCreationTokens: require_db.zod_default.number().int().default(0),
+	cost: require_db.zod_default.number().int().default(0),
+	cacheSavings: require_db.zod_default.number().int().default(0),
+	inputCost: require_db.zod_default.number().int().default(0),
+	outputCost: require_db.zod_default.number().int().default(0),
+	endpoint: require_db.zod_default.string(),
+	statusCode: require_db.zod_default.number().int(),
+	latencyMs: require_db.zod_default.number().int().default(0),
+	isStreaming: require_db.zod_default.boolean().default(false),
+	userId: require_db.zod_default.string().nullable().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
+	guardrailResults: guardrailResultsSchema.nullable().optional(),
+	traceId: require_db.zod_default.string().nullable().optional(),
+	spanId: require_db.zod_default.string().nullable().optional(),
+	parentSpanId: require_db.zod_default.string().nullable().optional(),
+	sessionId: require_db.zod_default.string().nullable().optional()
+});
+const listRequestsSchema = require_db.zod_default.object({
+	limit: require_db.zod_default.number().int().positive().max(1e3).default(100),
+	offset: require_db.zod_default.number().int().nonnegative().default(0),
+	configId: require_db.zod_default.string().uuid().optional(),
+	variantId: require_db.zod_default.string().uuid().optional(),
+	environmentId: require_db.zod_default.string().uuid().optional(),
+	providerConfigId: require_db.zod_default.string().uuid().optional(),
+	provider: require_db.zod_default.string().optional(),
+	model: require_db.zod_default.string().optional(),
+	startDate: require_db.zod_default.date().optional(),
+	endDate: require_db.zod_default.date().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+});
+const dateRangeSchema = require_db.zod_default.object({
+	startDate: require_db.zod_default.date(),
+	endDate: require_db.zod_default.date(),
+	configId: require_db.zod_default.string().uuid().optional(),
+	variantId: require_db.zod_default.string().uuid().optional(),
+	environmentId: require_db.zod_default.string().uuid().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+});
+const COST_SUMMARY_GROUP_BY = [
+	"day",
+	"hour",
+	"model",
+	"provider",
+	"endpoint",
+	"tags"
+];
+const costSummarySchema = require_db.zod_default.object({
+	startDate: require_db.zod_default.date(),
+	endDate: require_db.zod_default.date(),
+	configId: require_db.zod_default.string().uuid().optional(),
+	variantId: require_db.zod_default.string().uuid().optional(),
+	environmentId: require_db.zod_default.string().uuid().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional(),
+	groupBy: require_db.zod_default.enum(COST_SUMMARY_GROUP_BY).optional(),
+	tagKeys: require_db.zod_default.array(require_db.zod_default.string()).optional()
+});
+const upsertTraceSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	name: require_db.zod_default.string().nullable().optional(),
+	sessionId: require_db.zod_default.string().nullable().optional(),
+	userId: require_db.zod_default.string().nullable().optional(),
+	status: require_db.zod_default.enum([
+		"unset",
+		"ok",
+		"error"
+	]).default("unset"),
+	startTime: require_db.zod_default.date(),
+	endTime: require_db.zod_default.date().nullable().optional(),
+	durationMs: require_db.zod_default.number().int().nullable().optional(),
+	spanCount: require_db.zod_default.number().int().default(1),
+	totalInputTokens: require_db.zod_default.number().int().default(0),
+	totalOutputTokens: require_db.zod_default.number().int().default(0),
+	totalTokens: require_db.zod_default.number().int().default(0),
+	totalCost: require_db.zod_default.number().int().default(0),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.string()).default({}),
+	metadata: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+const insertSpanSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	spanId: require_db.zod_default.string(),
+	parentSpanId: require_db.zod_default.string().nullable().optional(),
+	name: require_db.zod_default.string(),
+	kind: require_db.zod_default.number().int().default(1),
+	status: require_db.zod_default.number().int().default(0),
+	statusMessage: require_db.zod_default.string().nullable().optional(),
+	startTime: require_db.zod_default.date(),
+	endTime: require_db.zod_default.date().nullable().optional(),
+	durationMs: require_db.zod_default.number().int().nullable().optional(),
+	provider: require_db.zod_default.string().nullable().optional(),
+	model: require_db.zod_default.string().nullable().optional(),
+	promptTokens: require_db.zod_default.number().int().default(0),
+	completionTokens: require_db.zod_default.number().int().default(0),
+	totalTokens: require_db.zod_default.number().int().default(0),
+	cost: require_db.zod_default.number().int().default(0),
+	configId: require_db.zod_default.string().uuid().nullable().optional(),
+	variantId: require_db.zod_default.string().uuid().nullable().optional(),
+	environmentId: require_db.zod_default.string().uuid().nullable().optional(),
+	providerConfigId: require_db.zod_default.string().uuid().nullable().optional(),
+	requestId: require_db.zod_default.string().uuid().nullable().optional(),
+	source: require_db.zod_default.enum([
+		"gateway",
+		"otlp",
+		"langsmith"
+	]).default("gateway"),
+	input: require_db.zod_default.unknown().nullable().optional(),
+	output: require_db.zod_default.unknown().nullable().optional(),
+	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+const insertSpanEventSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
+	spanId: require_db.zod_default.string(),
+	name: require_db.zod_default.string(),
+	timestamp: require_db.zod_default.date(),
+	attributes: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).default({})
+});
+const listTracesSchema = require_db.zod_default.object({
+	limit: require_db.zod_default.number().int().positive().max(1e3).default(50),
+	offset: require_db.zod_default.number().int().nonnegative().default(0),
+	sessionId: require_db.zod_default.string().optional(),
+	userId: require_db.zod_default.string().optional(),
+	status: require_db.zod_default.enum([
+		"unset",
+		"ok",
+		"error"
+	]).optional(),
+	name: require_db.zod_default.string().optional(),
+	startDate: require_db.zod_default.date().optional(),
+	endDate: require_db.zod_default.date().optional(),
+	tags: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.array(require_db.zod_default.string())).optional()
+});
+const traceStatsSchema = require_db.zod_default.object({
+	startDate: require_db.zod_default.date(),
+	endDate: require_db.zod_default.date(),
+	sessionId: require_db.zod_default.string().optional(),
+	userId: require_db.zod_default.string().optional()
+});
+const col = (name) => kysely.sql.ref(name);
+function createLLMRequestsStore(db) {
+	return {
+		batchInsertRequests: async (requests) => {
+			if (requests.length === 0) return { count: 0 };
+			const validatedRequests = await Promise.all(requests.map(async (req) => {
+				const result = await insertLLMRequestSchema.safeParseAsync(req);
+				if (!result.success) throw new LLMOpsError(`Invalid request data: ${result.error.message}`);
+				return result.data;
+			}));
 			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const values = validatedSpans.map((span) => ({
+			const values = validatedRequests.map((req) => ({
 				id: (0, node_crypto.randomUUID)(),
-				traceId: span.traceId,
-				spanId: span.spanId,
-				parentSpanId: span.parentSpanId ?? null,
-				name: span.name,
-				kind: span.kind,
-				status: span.status,
-				statusMessage: span.statusMessage ?? null,
-				startTime: span.startTime.toISOString(),
-				endTime: span.endTime?.toISOString() ?? null,
-				durationMs: span.durationMs ?? null,
-				provider: span.provider ?? null,
-				model: span.model ?? null,
-				promptTokens: span.promptTokens,
-				completionTokens: span.completionTokens,
-				totalTokens: span.totalTokens,
-				cost: span.cost,
-				configId: span.configId ?? null,
-				variantId: span.variantId ?? null,
-				environmentId: span.environmentId ?? null,
-				providerConfigId: span.providerConfigId ?? null,
-				requestId: span.requestId ?? null,
-				source: span.source,
-				input: span.input != null ? JSON.stringify(span.input) : null,
-				output: span.output != null ? JSON.stringify(span.output) : null,
-				attributes: JSON.stringify(span.attributes),
+				requestId: req.requestId,
+				configId: req.configId ?? null,
+				variantId: req.variantId ?? null,
+				environmentId: req.environmentId ?? null,
+				providerConfigId: req.providerConfigId ?? null,
+				provider: req.provider,
+				model: req.model,
+				promptTokens: req.promptTokens,
+				completionTokens: req.completionTokens,
+				totalTokens: req.totalTokens,
+				cachedTokens: req.cachedTokens,
+				cacheCreationTokens: req.cacheCreationTokens,
+				cost: req.cost,
+				cacheSavings: req.cacheSavings,
+				inputCost: req.inputCost,
+				outputCost: req.outputCost,
+				endpoint: req.endpoint,
+				statusCode: req.statusCode,
+				latencyMs: req.latencyMs,
+				isStreaming: req.isStreaming,
+				userId: req.userId ?? null,
+				tags: JSON.stringify(req.tags),
+				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
+				traceId: req.traceId ?? null,
+				spanId: req.spanId ?? null,
+				parentSpanId: req.parentSpanId ?? null,
+				sessionId: req.sessionId ?? null,
 				createdAt: now,
 				updatedAt: now
 			}));
-			await db.insertInto("spans").values(values).onConflict((oc) => oc.column("spanId").doNothing()).execute();
-			return { count: values.length };
-		},
-		batchInsertSpanEvents: async (events) => {
-			if (events.length === 0) return { count: 0 };
-			const validatedEvents = [];
-			for (const event of events) {
-				const result = await insertSpanEventSchema.safeParseAsync(event);
-				if (!result.success) {
-					require_db.logger.warn(`[batchInsertSpanEvents] Skipping invalid event: ${result.error.message}`);
-					continue;
-				}
-				validatedEvents.push(result.data);
-			}
-			if (validatedEvents.length === 0) return { count: 0 };
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const values = validatedEvents.map((event) => ({
-				id: (0, node_crypto.randomUUID)(),
-				traceId: event.traceId,
-				spanId: event.spanId,
-				name: event.name,
-				timestamp: event.timestamp.toISOString(),
-				attributes: JSON.stringify(event.attributes),
-				createdAt: now
-			}));
-			await db.insertInto("span_events").values(values).execute();
+			await db.insertInto("llm_requests").values(values).execute();
 			return { count: values.length };
 		},
-		listTraces: async (params) => {
-			const result = await listTracesSchema.safeParseAsync(params || {});
+		insertRequest: async (request) => {
+			const result = await insertLLMRequestSchema.safeParseAsync(request);
+			if (!result.success) throw new LLMOpsError(`Invalid request data: ${result.error.message}`);
+			const req = result.data;
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			return db.insertInto("llm_requests").values({
+				id: (0, node_crypto.randomUUID)(),
+				requestId: req.requestId,
+				configId: req.configId ?? null,
+				variantId: req.variantId ?? null,
+				environmentId: req.environmentId ?? null,
+				providerConfigId: req.providerConfigId ?? null,
+				provider: req.provider,
+				model: req.model,
+				promptTokens: req.promptTokens,
+				completionTokens: req.completionTokens,
+				totalTokens: req.totalTokens,
+				cachedTokens: req.cachedTokens,
+				cacheCreationTokens: req.cacheCreationTokens,
+				cost: req.cost,
+				cacheSavings: req.cacheSavings,
+				inputCost: req.inputCost,
+				outputCost: req.outputCost,
+				endpoint: req.endpoint,
+				statusCode: req.statusCode,
+				latencyMs: req.latencyMs,
+				isStreaming: req.isStreaming,
+				userId: req.userId ?? null,
+				tags: JSON.stringify(req.tags),
+				guardrailResults: req.guardrailResults ? JSON.stringify(req.guardrailResults) : null,
+				traceId: req.traceId ?? null,
+				spanId: req.spanId ?? null,
+				parentSpanId: req.parentSpanId ?? null,
+				sessionId: req.sessionId ?? null,
+				createdAt: now,
+				updatedAt: now
+			}).returningAll().executeTakeFirst();
+		},
+		listRequests: async (params) => {
+			const result = await listRequestsSchema.safeParseAsync(params || {});
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { limit, offset, sessionId, userId, status, name, startDate, endDate, tags } = result.data;
-			let baseQuery = db.selectFrom("traces");
-			if (sessionId) baseQuery = baseQuery.where("sessionId", "=", sessionId);
-			if (userId) baseQuery = baseQuery.where("userId", "=", userId);
-			if (status) baseQuery = baseQuery.where("status", "=", status);
-			if (name) baseQuery = baseQuery.where(kysely.sql`${col("name")} ILIKE ${"%" + name + "%"}`);
-			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`);
-			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
+			const { limit, offset, configId, variantId, environmentId, providerConfigId, provider, model, startDate, endDate, tags } = result.data;
+			let baseQuery = db.selectFrom("llm_requests");
+			if (configId) baseQuery = baseQuery.where("configId", "=", configId);
+			if (variantId) baseQuery = baseQuery.where("variantId", "=", variantId);
+			if (environmentId) baseQuery = baseQuery.where("environmentId", "=", environmentId);
+			if (providerConfigId) baseQuery = baseQuery.where("providerConfigId", "=", providerConfigId);
+			if (provider) baseQuery = baseQuery.where("provider", "=", provider);
+			if (model) baseQuery = baseQuery.where("model", "=", model);
+			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`);
+			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
 			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
 				if (values.length === 0) continue;
 				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
@@ -2671,426 +2327,387 @@ const createTracesDataLayer = (db) => {
 			const countResult = await baseQuery.select(kysely.sql`COUNT(*)`.as("total")).executeTakeFirst();
 			const total = Number(countResult?.total ?? 0);
 			return {
-				data: await baseQuery.selectAll().orderBy("startTime", "desc").limit(limit).offset(offset).execute(),
+				data: await baseQuery.selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute(),
 				total,
 				limit,
 				offset
 			};
 		},
-		getTraceWithSpans: async (traceId) => {
-			const trace = await db.selectFrom("traces").selectAll().where("traceId", "=", traceId).executeTakeFirst();
-			if (!trace) return void 0;
-			return {
-				trace,
-				spans: await db.selectFrom("spans").selectAll().where("traceId", "=", traceId).orderBy("startTime", "asc").execute(),
-				events: await db.selectFrom("span_events").selectAll().where("traceId", "=", traceId).orderBy("timestamp", "asc").execute()
-			};
+		getRequestByRequestId: async (requestId) => {
+			return db.selectFrom("llm_requests").selectAll().where("requestId", "=", requestId).executeTakeFirst();
 		},
-		getTraceStats: async (params) => {
-			const result = await traceStatsSchema.safeParseAsync(params);
+		getTotalCost: async (params) => {
+			const result = await dateRangeSchema.safeParseAsync(params);
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
-			const { startDate, endDate, sessionId, userId } = result.data;
-			let query = db.selectFrom("traces").select([
-				kysely.sql`COUNT(*)`.as("totalTraces"),
-				kysely.sql`COALESCE(AVG(${col("durationMs")}), 0)`.as("avgDurationMs"),
-				kysely.sql`COUNT(CASE WHEN ${col("status")} = 'error' THEN 1 END)`.as("errorCount"),
-				kysely.sql`COALESCE(SUM(${col("totalCost")}), 0)`.as("totalCost"),
+			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
+			let query = db.selectFrom("llm_requests").select([
+				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col("promptTokens")}), 0)`.as("totalPromptTokens"),
+				kysely.sql`COALESCE(SUM(${col("completionTokens")}), 0)`.as("totalCompletionTokens"),
 				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COALESCE(SUM(${col("spanCount")}), 0)`.as("totalSpans")
-			]).where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
-			if (sessionId) query = query.where("sessionId", "=", sessionId);
-			if (userId) query = query.where("userId", "=", userId);
+				kysely.sql`COALESCE(SUM(${col("cachedTokens")}), 0)`.as("totalCachedTokens"),
+				kysely.sql`COALESCE(SUM(${col("cacheSavings")}), 0)`.as("totalCacheSavings"),
+				kysely.sql`COUNT(*)`.as("requestCount")
+			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			if (configId) query = query.where("configId", "=", configId);
+			if (variantId) query = query.where("variantId", "=", variantId);
+			if (environmentId) query = query.where("environmentId", "=", environmentId);
+			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+				if (values.length === 0) continue;
+				if (values.length === 1) query = query.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				else {
+					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+					query = query.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+				}
+			}
 			return query.executeTakeFirst();
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/workspaceSettings.ts
-const updateWorkspaceSettings = require_db.zod_default.object({
-	name: require_db.zod_default.string().nullable().optional(),
-	setupComplete: require_db.zod_default.boolean().optional(),
-	superAdminId: require_db.zod_default.string().nullable().optional()
-});
-const createWorkspaceSettingsDataLayer = (db) => {
-	return {
-		getWorkspaceSettings: async () => {
-			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
-			if (!settings) settings = await db.insertInto("workspace_settings").values({
-				id: (0, node_crypto.randomUUID)(),
-				name: null,
-				setupComplete: false,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-			return settings;
 		},
-		updateWorkspaceSettings: async (params) => {
-			const value = await updateWorkspaceSettings.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
-			if (!settings) return db.insertInto("workspace_settings").values({
-				id: (0, node_crypto.randomUUID)(),
-				name: value.data.name ?? null,
-				setupComplete: value.data.setupComplete ?? false,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (value.data.name !== void 0) updateData.name = value.data.name ?? null;
-			if (value.data.setupComplete !== void 0) updateData.setupComplete = value.data.setupComplete;
-			if (value.data.superAdminId !== void 0) updateData.superAdminId = value.data.superAdminId ?? null;
-			return db.updateTable("workspace_settings").set(updateData).where("id", "=", settings.id).returningAll().executeTakeFirst();
+		getCostByModel: async (params) => {
+			const result = await dateRangeSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate } = result.data;
+			return db.selectFrom("llm_requests").select([
+				"provider",
+				"model",
+				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COUNT(*)`.as("requestCount"),
+				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs")
+			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
 		},
-		getSuperAdminId: async () => {
-			return (await db.selectFrom("workspace_settings").select("superAdminId").executeTakeFirst())?.superAdminId ?? null;
+		getCostByProvider: async (params) => {
+			const result = await dateRangeSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate } = result.data;
+			return db.selectFrom("llm_requests").select([
+				"provider",
+				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COUNT(*)`.as("requestCount"),
+				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs")
+			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy("provider").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
 		},
-		setSuperAdminId: async (userId) => {
-			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
-			if (settings?.superAdminId) return false;
-			if (!settings) {
-				await db.insertInto("workspace_settings").values({
-					id: (0, node_crypto.randomUUID)(),
-					name: null,
-					setupComplete: false,
-					superAdminId: userId,
-					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				}).execute();
-				return true;
-			}
-			await db.updateTable("workspace_settings").set({
-				superAdminId: userId,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).where("id", "=", settings.id).execute();
-			return true;
+		getDailyCosts: async (params) => {
+			const result = await dateRangeSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate } = result.data;
+			return db.selectFrom("llm_requests").select([
+				kysely.sql`DATE(${col("createdAt")})`.as("date"),
+				kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("inputCost")}), 0)`.as("totalInputCost"),
+				kysely.sql`COALESCE(SUM(${col("outputCost")}), 0)`.as("totalOutputCost"),
+				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COUNT(*)`.as("requestCount")
+			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`).groupBy(kysely.sql`DATE(${col("createdAt")})`).orderBy(kysely.sql`DATE(${col("createdAt")})`, "asc").execute();
 		},
-		isSetupComplete: async () => {
-			try {
-				return (await db.selectFrom("workspace_settings").select("setupComplete").executeTakeFirst())?.setupComplete ?? false;
-			} catch {
-				return false;
+		getCostSummary: async (params) => {
+			const result = await costSummarySchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate, groupBy, configId, variantId, environmentId, tags, tagKeys } = result.data;
+			let baseQuery = db.selectFrom("llm_requests").where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			if (configId) baseQuery = baseQuery.where("configId", "=", configId);
+			if (variantId) baseQuery = baseQuery.where("variantId", "=", variantId);
+			if (environmentId) baseQuery = baseQuery.where("environmentId", "=", environmentId);
+			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+				if (values.length === 0) continue;
+				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				else {
+					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+					baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+				}
+			}
+			switch (groupBy) {
+				case "day": return baseQuery.select([
+					kysely.sql`DATE(${col("createdAt")})`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount"),
+					kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens")
+				]).groupBy(kysely.sql`DATE(${col("createdAt")})`).orderBy(kysely.sql`DATE(${col("createdAt")})`, "asc").execute();
+				case "hour": return baseQuery.select([
+					kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount"),
+					kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens")
+				]).groupBy(kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`).orderBy(kysely.sql`DATE_TRUNC('hour', ${col("createdAt")})`, "asc").execute();
+				case "model": return baseQuery.select([
+					kysely.sql`${col("provider")} || '/' || ${col("model")}`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount")
+				]).groupBy(["provider", "model"]).orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				case "provider": return baseQuery.select([
+					kysely.sql`${col("provider")}`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount")
+				]).groupBy("provider").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				case "endpoint": return baseQuery.select([
+					kysely.sql`COALESCE(${col("endpoint")}, 'unknown')`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount")
+				]).groupBy("endpoint").orderBy(kysely.sql`SUM(${col("cost")})`, "desc").execute();
+				case "tags": {
+					const conditions = [kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`, kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`];
+					if (configId) conditions.push(kysely.sql`${col("configId")} = ${configId}`);
+					if (variantId) conditions.push(kysely.sql`${col("variantId")} = ${variantId}`);
+					if (environmentId) conditions.push(kysely.sql`${col("environmentId")} = ${environmentId}`);
+					if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+						if (values.length === 0) continue;
+						if (values.length === 1) conditions.push(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+						else {
+							const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+							conditions.push(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+						}
+					}
+					if (tagKeys && tagKeys.length > 0) {
+						const tagKeyList = kysely.sql.join(tagKeys.map((k) => kysely.sql`${k}`), kysely.sql`, `);
+						conditions.push(kysely.sql`t.key IN (${tagKeyList})`);
+					}
+					const whereClause = kysely.sql.join(conditions, kysely.sql` AND `);
+					return (await kysely.sql`
+            SELECT t.key || ':' || t.value as "groupKey",
+                   COALESCE(SUM(${col("cost")}), 0) as "totalCost",
+                   COUNT(*) as "requestCount"
+            FROM "llm_requests", jsonb_each_text(${col("tags")}) t
+            WHERE ${whereClause}
+            GROUP BY t.key, t.value
+            ORDER BY SUM(${col("cost")}) DESC
+          `.execute(db)).rows;
+				}
+				default: return baseQuery.select([
+					kysely.sql`'total'`.as("groupKey"),
+					kysely.sql`COALESCE(SUM(${col("cost")}), 0)`.as("totalCost"),
+					kysely.sql`COUNT(*)`.as("requestCount")
+				]).execute();
 			}
 		},
-		markSetupComplete: async () => {
-			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
-			if (!settings) return db.insertInto("workspace_settings").values({
-				id: (0, node_crypto.randomUUID)(),
-				name: null,
-				setupComplete: true,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-			return db.updateTable("workspace_settings").set({
-				setupComplete: true,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).where("id", "=", settings.id).returningAll().executeTakeFirst();
+		getRequestStats: async (params) => {
+			const result = await dateRangeSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate, configId, variantId, environmentId, tags } = result.data;
+			let query = db.selectFrom("llm_requests").select([
+				kysely.sql`COUNT(*)`.as("totalRequests"),
+				kysely.sql`COUNT(CASE WHEN ${col("statusCode")} >= 200 AND ${col("statusCode")} < 300 THEN 1 END)`.as("successfulRequests"),
+				kysely.sql`COUNT(CASE WHEN ${col("statusCode")} >= 400 THEN 1 END)`.as("failedRequests"),
+				kysely.sql`COUNT(CASE WHEN ${col("isStreaming")} = true THEN 1 END)`.as("streamingRequests"),
+				kysely.sql`AVG(${col("latencyMs")})`.as("avgLatencyMs"),
+				kysely.sql`MAX(${col("latencyMs")})`.as("maxLatencyMs"),
+				kysely.sql`MIN(${col("latencyMs")})`.as("minLatencyMs")
+			]).where(kysely.sql`${col("createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("createdAt")} <= ${endDate.toISOString()}`);
+			if (configId) query = query.where("configId", "=", configId);
+			if (variantId) query = query.where("variantId", "=", variantId);
+			if (environmentId) query = query.where("environmentId", "=", environmentId);
+			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+				if (values.length === 0) continue;
+				if (values.length === 1) query = query.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				else {
+					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+					query = query.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+				}
+			}
+			return query.executeTakeFirst();
+		},
+		getDistinctTags: async () => {
+			return (await kysely.sql`
+        SELECT DISTINCT key, value
+        FROM llm_requests, jsonb_each_text(tags) AS t(key, value)
+        WHERE tags != '{}'::jsonb
+        ORDER BY key, value
+      `.execute(db)).rows;
 		}
 	};
-};
-
-//#endregion
-//#region src/datalayer/create.ts
-/**
-* Create all datalayers from a Kysely database instance.
-* Returns a flat object with all datalayer methods spread together.
-*/
-function createDataLayer(db) {
-	return {
-		...createDatasetsDataLayer(db),
-		...createGuardrailConfigsDataLayer(db),
-		...createLLMRequestsDataLayer(db),
-		...createPlaygroundDataLayer(db),
-		...createPlaygroundResultsDataLayer(db),
-		...createPlaygroundRunsDataLayer(db),
-		...createProviderConfigsDataLayer(db),
-		...createProviderGuardrailOverridesDataLayer(db),
-		...createTracesDataLayer(db),
-		...createWorkspaceSettingsDataLayer(db)
-	};
-}
-
-//#endregion
-//#region src/pricing/calculator.ts
-/**
-* Calculate the cost of an LLM request in micro-dollars
-*
-* Micro-dollars are used to avoid floating-point precision issues:
-* - 1 dollar = 1,000,000 micro-dollars
-* - $0.001 = 1,000 micro-dollars
-* - $0.000001 = 1 micro-dollar
-*
-* @param usage - Token usage data from the LLM response
-* @param pricing - Model pricing information
-* @returns Cost breakdown in micro-dollars
-*
-* @example
-* ```typescript
-* const usage = { promptTokens: 1000, completionTokens: 500 };
-* const pricing = { inputCostPer1M: 2.5, outputCostPer1M: 10.0 };
-* const cost = calculateCost(usage, pricing);
-* // cost = { inputCost: 2500, outputCost: 5000, totalCost: 7500 }
-* // In dollars: $0.0025 input + $0.005 output = $0.0075 total
-* ```
-*/
-function calculateCost(usage, pricing) {
-	const inputCost = Math.round(usage.promptTokens * pricing.inputCostPer1M);
-	const outputCost = Math.round(usage.completionTokens * pricing.outputCostPer1M);
-	return {
-		inputCost,
-		outputCost,
-		totalCost: inputCost + outputCost,
-		cacheSavings: 0
-	};
-}
-/**
-* Get default cache read rate as a fraction of input cost per provider.
-* Used when models.dev doesn't provide cache pricing.
-*/
-function getDefaultCacheReadRate(provider, inputCostPer1M) {
-	switch (provider?.toLowerCase()) {
-		case "anthropic": return inputCostPer1M * .1;
-		case "openai":
-		case "azure-openai": return inputCostPer1M * .5;
-		case "google":
-		case "gemini":
-		case "vertex_ai": return inputCostPer1M * .25;
-		default: return inputCostPer1M * .5;
-	}
-}
-/**
-* Get default cache write/creation rate as a fraction of input cost per provider.
-* Used when models.dev doesn't provide cache pricing.
-*/
-function getDefaultCacheWriteRate(provider, inputCostPer1M) {
-	switch (provider?.toLowerCase()) {
-		case "anthropic": return inputCostPer1M * 1.25;
-		default: return inputCostPer1M;
-	}
 }
-/**
-* Calculate cache-aware cost of an LLM request in micro-dollars.
-*
-* Splits input tokens into uncached, cache-read, and cache-creation buckets,
-* each priced at different rates. Falls back to provider-specific multipliers
-* when models.dev doesn't provide cache pricing.
-*
-* @param usage - Token usage data (with cachedTokens and cacheCreationTokens)
-* @param pricing - Model pricing (may include cacheReadCostPer1M / cacheWriteCostPer1M)
-* @param provider - Provider name for fallback rate selection
-* @returns Cost breakdown in micro-dollars
-*/
-function calculateCacheAwareCost(usage, pricing, provider) {
-	const cachedTokens = usage.cachedTokens ?? 0;
-	const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
-	if (cachedTokens === 0 && cacheCreationTokens === 0) return calculateCost(usage, pricing);
-	const cacheReadRate = pricing.cacheReadCostPer1M ?? getDefaultCacheReadRate(provider, pricing.inputCostPer1M);
-	const cacheWriteRate = pricing.cacheWriteCostPer1M ?? getDefaultCacheWriteRate(provider, pricing.inputCostPer1M);
-	const uncachedInputTokens = Math.max(0, usage.promptTokens - cachedTokens - cacheCreationTokens);
-	const regularInputCost = Math.round(uncachedInputTokens * pricing.inputCostPer1M);
-	const cacheReadCost = Math.round(cachedTokens * cacheReadRate);
-	const cacheWriteCost = Math.round(cacheCreationTokens * cacheWriteRate);
-	const outputCost = Math.round(usage.completionTokens * pricing.outputCostPer1M);
-	const inputCost = regularInputCost + cacheReadCost + cacheWriteCost;
+function createTracesStore(db) {
 	return {
-		inputCost,
-		outputCost,
-		totalCost: inputCost + outputCost,
-		cacheSavings: Math.round((cachedTokens + cacheCreationTokens) * pricing.inputCostPer1M) - cacheReadCost - cacheWriteCost
-	};
-}
-/**
-* Convert micro-dollars to dollars
-*
-* @param microDollars - Amount in micro-dollars
-* @returns Amount in dollars
-*
-* @example
-* ```typescript
-* microDollarsToDollars(7500); // 0.0075
-* microDollarsToDollars(1000000); // 1.0
-* ```
-*/
-function microDollarsToDollars(microDollars) {
-	return microDollars / 1e6;
-}
-/**
-* Convert dollars to micro-dollars
-*
-* @param dollars - Amount in dollars
-* @returns Amount in micro-dollars (rounded to nearest integer)
-*
-* @example
-* ```typescript
-* dollarsToMicroDollars(0.0075); // 7500
-* dollarsToMicroDollars(1.0); // 1000000
-* ```
-*/
-function dollarsToMicroDollars(dollars) {
-	return Math.round(dollars * 1e6);
-}
-/**
-* Format micro-dollars as a human-readable dollar string
-*
-* @param microDollars - Amount in micro-dollars
-* @param decimals - Number of decimal places (default: 6)
-* @returns Formatted dollar string
-*
-* @example
-* ```typescript
-* formatCost(7500); // "$0.007500"
-* formatCost(1234567, 2); // "$1.23"
-* ```
-*/
-function formatCost(microDollars, decimals = 6) {
-	return `$${microDollarsToDollars(microDollars).toFixed(decimals)}`;
-}
-
-//#endregion
-//#region src/pricing/provider.ts
-const LLMOPS_MODELS_API = "https://models.llmops.build";
-/**
-* Convert price from USD cents per token to dollars per 1M tokens.
-*
-* API returns cents/token. Our system uses dollars/1M tokens.
-* Formula: (centsPerToken / 100) * 1_000_000 = centsPerToken * 10_000
-*/
-function centsPerTokenToCostPer1M(centsPerToken) {
-	return centsPerToken * 1e4;
-}
-/**
-* Pricing provider that fetches per-model data from the LLMOps Models API.
-*
-* Features:
-* - Per-model in-memory cache with configurable TTL (default 5 minutes)
-* - Deduplicates concurrent fetches for the same model
-* - Caches null results (404s) to avoid repeated lookups
-* - Falls back to stale cache on fetch errors
-*/
-var LLMOpsPricingProvider = class {
-	cache = /* @__PURE__ */ new Map();
-	pendingFetches = /* @__PURE__ */ new Map();
-	cacheTTL;
-	baseUrl;
-	constructor(options) {
-		this.cacheTTL = options?.cacheTTL ?? 300 * 1e3;
-		this.baseUrl = options?.baseUrl ?? LLMOPS_MODELS_API;
-	}
-	getCacheKey(provider, model) {
-		return `${provider.toLowerCase()}:${model.toLowerCase()}`;
-	}
-	/**
-	* Fetch pricing for a single model from the API
-	*/
-	async fetchModelPricing(provider, model) {
-		const url = `${this.baseUrl}/model-configs/pricing/${encodeURIComponent(provider)}/${model}`;
-		try {
-			require_db.logger.debug(`[Pricing] GET ${url}`);
-			const startTime = Date.now();
-			const response = await fetch(url);
-			const elapsed = Date.now() - startTime;
-			require_db.logger.debug(`[Pricing] GET ${url} -> ${response.status} (${elapsed}ms)`);
-			if (response.status === 404) {
-				require_db.logger.debug(`[Pricing] No pricing found for ${provider}/${model}`);
-				return null;
+		upsertTrace: async (data) => {
+			const result = await upsertTraceSchema.safeParseAsync(data);
+			if (!result.success) throw new LLMOpsError(`Invalid trace data: ${result.error.message}`);
+			const trace = result.data;
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			await kysely.sql`
+        INSERT INTO "traces" (
+          "id", "traceId", "name", "sessionId", "userId", "status",
+          "startTime", "endTime", "durationMs", "spanCount",
+          "totalInputTokens", "totalOutputTokens", "totalTokens", "totalCost",
+          "tags", "metadata", "createdAt", "updatedAt"
+        ) VALUES (
+          ${(0, node_crypto.randomUUID)()}, ${trace.traceId}, ${trace.name ?? null}, ${trace.sessionId ?? null},
+          ${trace.userId ?? null}, ${trace.status},
+          ${trace.startTime.toISOString()}, ${trace.endTime?.toISOString() ?? null},
+          ${trace.durationMs ?? null}, ${trace.spanCount},
+          ${trace.totalInputTokens}, ${trace.totalOutputTokens},
+          ${trace.totalTokens}, ${trace.totalCost},
+          ${JSON.stringify(trace.tags)}::jsonb, ${JSON.stringify(trace.metadata)}::jsonb,
+          ${now}, ${now}
+        )
+        ON CONFLICT ("traceId") DO UPDATE SET
+          "name" = COALESCE(EXCLUDED."name", "traces"."name"),
+          "sessionId" = COALESCE(EXCLUDED."sessionId", "traces"."sessionId"),
+          "userId" = COALESCE(EXCLUDED."userId", "traces"."userId"),
+          "status" = CASE
+            WHEN EXCLUDED."status" = 'error' THEN 'error'
+            WHEN EXCLUDED."status" = 'ok' AND "traces"."status" != 'error' THEN 'ok'
+            ELSE "traces"."status"
+          END,
+          "startTime" = LEAST("traces"."startTime", EXCLUDED."startTime"),
+          "endTime" = GREATEST(
+            COALESCE("traces"."endTime", EXCLUDED."endTime"),
+            COALESCE(EXCLUDED."endTime", "traces"."endTime")
+          ),
+          "durationMs" = EXTRACT(EPOCH FROM (
+            GREATEST(
+              COALESCE("traces"."endTime", EXCLUDED."endTime"),
+              COALESCE(EXCLUDED."endTime", "traces"."endTime")
+            ) -
+            LEAST("traces"."startTime", EXCLUDED."startTime")
+          ))::integer * 1000,
+          "spanCount" = "traces"."spanCount" + EXCLUDED."spanCount",
+          "totalInputTokens" = "traces"."totalInputTokens" + EXCLUDED."totalInputTokens",
+          "totalOutputTokens" = "traces"."totalOutputTokens" + EXCLUDED."totalOutputTokens",
+          "totalTokens" = "traces"."totalTokens" + EXCLUDED."totalTokens",
+          "totalCost" = "traces"."totalCost" + EXCLUDED."totalCost",
+          "tags" = "traces"."tags" || EXCLUDED."tags",
+          "metadata" = "traces"."metadata" || EXCLUDED."metadata",
+          "updatedAt" = ${now}
+      `.execute(db);
+		},
+		batchInsertSpans: async (spans) => {
+			if (spans.length === 0) return { count: 0 };
+			const validatedSpans = [];
+			for (const span of spans) {
+				const result = await insertSpanSchema.safeParseAsync(span);
+				if (!result.success) {
+					require_db.logger.warn(`[batchInsertSpans] Skipping invalid span ${span.spanId}: ${result.error.message}`);
+					continue;
+				}
+				validatedSpans.push(result.data);
 			}
-			if (!response.ok) throw new Error(`API returned ${response.status}`);
-			const data = await response.json();
-			if (!data.pay_as_you_go) return null;
-			const payg = data.pay_as_you_go;
-			const pricing = {
-				inputCostPer1M: centsPerTokenToCostPer1M(payg.request_token?.price ?? 0),
-				outputCostPer1M: centsPerTokenToCostPer1M(payg.response_token?.price ?? 0),
-				cacheReadCostPer1M: payg.cache_read_input_token?.price != null ? centsPerTokenToCostPer1M(payg.cache_read_input_token.price) : void 0,
-				cacheWriteCostPer1M: payg.cache_write_input_token?.price != null ? centsPerTokenToCostPer1M(payg.cache_write_input_token.price) : void 0
-			};
-			require_db.logger.debug(`[Pricing] Cached pricing for ${provider}/${model}: input=$${pricing.inputCostPer1M}/1M, output=$${pricing.outputCostPer1M}/1M`);
-			return pricing;
-		} catch (error) {
-			require_db.logger.error(`[Pricing] Failed to fetch pricing for ${provider}/${model}: ${error instanceof Error ? error.message : String(error)}`);
-			const cacheKey = this.getCacheKey(provider, model);
-			const stale = this.cache.get(cacheKey);
-			if (stale) {
-				require_db.logger.debug(`[Pricing] Using stale cache for ${provider}/${model}`);
-				return stale.pricing;
+			if (validatedSpans.length === 0) return { count: 0 };
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const values = validatedSpans.map((span) => ({
+				id: (0, node_crypto.randomUUID)(),
+				traceId: span.traceId,
+				spanId: span.spanId,
+				parentSpanId: span.parentSpanId ?? null,
+				name: span.name,
+				kind: span.kind,
+				status: span.status,
+				statusMessage: span.statusMessage ?? null,
+				startTime: span.startTime.toISOString(),
+				endTime: span.endTime?.toISOString() ?? null,
+				durationMs: span.durationMs ?? null,
+				provider: span.provider ?? null,
+				model: span.model ?? null,
+				promptTokens: span.promptTokens,
+				completionTokens: span.completionTokens,
+				totalTokens: span.totalTokens,
+				cost: span.cost,
+				configId: span.configId ?? null,
+				variantId: span.variantId ?? null,
+				environmentId: span.environmentId ?? null,
+				providerConfigId: span.providerConfigId ?? null,
+				requestId: span.requestId ?? null,
+				source: span.source,
+				input: span.input != null ? JSON.stringify(span.input) : null,
+				output: span.output != null ? JSON.stringify(span.output) : null,
+				attributes: JSON.stringify(span.attributes),
+				createdAt: now,
+				updatedAt: now
+			}));
+			await db.insertInto("spans").values(values).onConflict((oc) => oc.column("spanId").doNothing()).execute();
+			return { count: values.length };
+		},
+		batchInsertSpanEvents: async (events) => {
+			if (events.length === 0) return { count: 0 };
+			const validatedEvents = [];
+			for (const event of events) {
+				const result = await insertSpanEventSchema.safeParseAsync(event);
+				if (!result.success) {
+					require_db.logger.warn(`[batchInsertSpanEvents] Skipping invalid event: ${result.error.message}`);
+					continue;
+				}
+				validatedEvents.push(result.data);
 			}
-			return null;
-		}
-	}
-	/**
-	* Internal: fetch with cache and deduplication for a specific provider+model
-	*/
-	async getCachedPricing(provider, model) {
-		const cacheKey = this.getCacheKey(provider, model);
-		const cached = this.cache.get(cacheKey);
-		if (cached && Date.now() - cached.fetchedAt < this.cacheTTL) return cached.pricing;
-		let pending = this.pendingFetches.get(cacheKey);
-		if (!pending) {
-			pending = this.fetchModelPricing(provider, model).then((pricing) => {
-				this.cache.set(cacheKey, {
-					pricing,
-					fetchedAt: Date.now()
-				});
-				return pricing;
-			}).finally(() => {
-				this.pendingFetches.delete(cacheKey);
-			});
-			this.pendingFetches.set(cacheKey, pending);
-		}
-		return pending;
-	}
-	/**
-	* Get pricing for a specific model.
-	*
-	* When the model name contains a slash (e.g. "google/gemini-2.5-flash"),
-	* it's likely an OpenRouter model ID. If the initial provider lookup fails,
-	* we automatically retry with "openrouter" as the provider.
-	*/
-	async getModelPricing(provider, model) {
-		const pricing = await this.getCachedPricing(provider, model);
-		if (pricing) return pricing;
-		if (!pricing && model.includes("/") && provider.toLowerCase() !== "openrouter") {
-			require_db.logger.debug(`[Pricing] Retrying ${provider}/${model} as openrouter/${model}`);
-			return this.getCachedPricing("openrouter", model);
+			if (validatedEvents.length === 0) return { count: 0 };
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const values = validatedEvents.map((event) => ({
+				id: (0, node_crypto.randomUUID)(),
+				traceId: event.traceId,
+				spanId: event.spanId,
+				name: event.name,
+				timestamp: event.timestamp.toISOString(),
+				attributes: JSON.stringify(event.attributes),
+				createdAt: now
+			}));
+			await db.insertInto("span_events").values(values).execute();
+			return { count: values.length };
+		},
+		listTraces: async (params) => {
+			const result = await listTracesSchema.safeParseAsync(params || {});
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { limit, offset, sessionId, userId, status, name, startDate, endDate, tags } = result.data;
+			let baseQuery = db.selectFrom("traces");
+			if (sessionId) baseQuery = baseQuery.where("sessionId", "=", sessionId);
+			if (userId) baseQuery = baseQuery.where("userId", "=", userId);
+			if (status) baseQuery = baseQuery.where("status", "=", status);
+			if (name) baseQuery = baseQuery.where(kysely.sql`${col("name")} ILIKE ${"%" + name + "%"}`);
+			if (startDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`);
+			if (endDate) baseQuery = baseQuery.where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
+			if (tags && Object.keys(tags).length > 0) for (const [key, values] of Object.entries(tags)) {
+				if (values.length === 0) continue;
+				if (values.length === 1) baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} = ${values[0]}`);
+				else {
+					const valueList = kysely.sql.join(values.map((v) => kysely.sql`${v}`));
+					baseQuery = baseQuery.where(kysely.sql`${col("tags")}->>${key} IN (${valueList})`);
+				}
+			}
+			const countResult = await baseQuery.select(kysely.sql`COUNT(*)`.as("total")).executeTakeFirst();
+			const total = Number(countResult?.total ?? 0);
+			return {
+				data: await baseQuery.selectAll().orderBy("startTime", "desc").limit(limit).offset(offset).execute(),
+				total,
+				limit,
+				offset
+			};
+		},
+		getTraceWithSpans: async (traceId) => {
+			const trace = await db.selectFrom("traces").selectAll().where("traceId", "=", traceId).executeTakeFirst();
+			if (!trace) return void 0;
+			return {
+				trace,
+				spans: await db.selectFrom("spans").selectAll().where("traceId", "=", traceId).orderBy("startTime", "asc").execute(),
+				events: await db.selectFrom("span_events").selectAll().where("traceId", "=", traceId).orderBy("timestamp", "asc").execute()
+			};
+		},
+		getTraceStats: async (params) => {
+			const result = await traceStatsSchema.safeParseAsync(params);
+			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
+			const { startDate, endDate, sessionId, userId } = result.data;
+			let query = db.selectFrom("traces").select([
+				kysely.sql`COUNT(*)`.as("totalTraces"),
+				kysely.sql`COALESCE(AVG(${col("durationMs")}), 0)`.as("avgDurationMs"),
+				kysely.sql`COUNT(CASE WHEN ${col("status")} = 'error' THEN 1 END)`.as("errorCount"),
+				kysely.sql`COALESCE(SUM(${col("totalCost")}), 0)`.as("totalCost"),
+				kysely.sql`COALESCE(SUM(${col("totalTokens")}), 0)`.as("totalTokens"),
+				kysely.sql`COALESCE(SUM(${col("spanCount")}), 0)`.as("totalSpans")
+			]).where(kysely.sql`${col("startTime")} >= ${startDate.toISOString()}`).where(kysely.sql`${col("startTime")} <= ${endDate.toISOString()}`);
+			if (sessionId) query = query.where("sessionId", "=", sessionId);
+			if (userId) query = query.where("userId", "=", userId);
+			return query.executeTakeFirst();
 		}
-		return pricing;
-	}
-	/**
-	* Force refresh the pricing cache (clears all cached entries)
-	*/
-	async refreshCache() {
-		this.cache.clear();
-	}
-	/**
-	* Always ready — no bulk pre-fetch needed
-	*/
-	isReady() {
-		return true;
-	}
-	/**
-	* Get the number of cached models (for debugging)
-	*/
-	getCacheSize() {
-		return this.cache.size;
-	}
-};
-let defaultProvider = null;
-/**
-* Get the default pricing provider instance
-*/
-function getDefaultPricingProvider() {
-	if (!defaultProvider) defaultProvider = new LLMOpsPricingProvider();
-	return defaultProvider;
+	};
 }
-
-//#endregion
-//#region src/telemetry/postgres.ts
 /**
 * Create a PostgreSQL-backed telemetry store.
 *
 * Usage:
 * ```ts
-* import { llmops, pgStore } from '@llmops/sdk'
+* import { llmops } from '@llmops/sdk'
+* import { pgStore } from '@llmops/sdk/store/pg'
 *
 * const ops = llmops({
 *   telemetry: pgStore(process.env.DATABASE_URL),
@@ -3111,140 +2728,14 @@ function createPgStore(connectionString, options) {
 			await connection.executeQuery(kysely.CompiledQuery.raw(`SET search_path TO "${schema}"`));
 		}
 	}) });
-	const llmRequests = createLLMRequestsDataLayer(db);
-	const traces = createTracesDataLayer(db);
 	require_db.logger.debug(`pgStore: initialized with schema "${schema}"`);
 	return {
-		...llmRequests,
-		...traces,
+		...createLLMRequestsStore(db),
+		...createTracesStore(db),
 		_db: db
 	};
 }
 
-//#endregion
-//#region src/manifest/builder.ts
-/**
-* Builds the gateway manifest from database
-*/
-var ManifestBuilder = class {
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Build the manifest from database
-	*/
-	async build() {
-		const [guardrailConfigs, providerGuardrailOverridesData] = await Promise.all([this.db.selectFrom("guardrail_configs").where("enabled", "=", true).selectAll().execute(), this.db.selectFrom("provider_guardrail_overrides").selectAll().execute()]);
-		const beforeRequestGuardrails = [];
-		const afterRequestGuardrails = [];
-		require_db.logger.info(`[ManifestBuilder] Found ${guardrailConfigs.length} enabled guardrail configs`);
-		for (const guardrail of guardrailConfigs) {
-			const parameters = typeof guardrail.parameters === "string" ? JSON.parse(guardrail.parameters) : guardrail.parameters;
-			const manifestGuardrail = {
-				id: guardrail.id,
-				name: guardrail.name,
-				pluginId: guardrail.pluginId,
-				functionId: guardrail.functionId,
-				hookType: guardrail.hookType,
-				parameters: parameters ?? {},
-				priority: guardrail.priority,
-				onFail: guardrail.onFail
-			};
-			if (guardrail.hookType === "beforeRequestHook") beforeRequestGuardrails.push(manifestGuardrail);
-			else afterRequestGuardrails.push(manifestGuardrail);
-		}
-		beforeRequestGuardrails.sort((a, b) => b.priority - a.priority);
-		afterRequestGuardrails.sort((a, b) => b.priority - a.priority);
-		const providerGuardrailOverrides = {};
-		for (const override of providerGuardrailOverridesData) {
-			const parameters = typeof override.parameters === "string" ? JSON.parse(override.parameters) : override.parameters;
-			const manifestOverride = {
-				id: override.id,
-				providerConfigId: override.providerConfigId,
-				guardrailConfigId: override.guardrailConfigId,
-				enabled: override.enabled,
-				parameters: parameters ?? null
-			};
-			if (!providerGuardrailOverrides[override.providerConfigId]) providerGuardrailOverrides[override.providerConfigId] = [];
-			providerGuardrailOverrides[override.providerConfigId].push(manifestOverride);
-		}
-		return {
-			version: Date.now(),
-			builtAt: (/* @__PURE__ */ new Date()).toISOString(),
-			guardrails: {
-				beforeRequestHook: beforeRequestGuardrails,
-				afterRequestHook: afterRequestGuardrails
-			},
-			providerGuardrailOverrides
-		};
-	}
-};
-
-//#endregion
-//#region src/manifest/service.ts
-const MANIFEST_CACHE_KEY = "manifest";
-const MANIFEST_NAMESPACE = "gateway";
-const DEFAULT_TTL_MS = 300 * 1e3;
-const log = require_db.logger.child({ module: "ManifestService" });
-var ManifestService = class {
-	builder;
-	constructor(cache, db, ttlMs = DEFAULT_TTL_MS) {
-		this.cache = cache;
-		this.ttlMs = ttlMs;
-		this.builder = new ManifestBuilder(db);
-		log.debug({ ttlMs }, "ManifestService initialized");
-	}
-	/**
-	* Get the current manifest, building if necessary
-	*/
-	async getManifest() {
-		log.debug("Getting manifest from cache or building");
-		const manifest = await this.cache.getOrSet(MANIFEST_CACHE_KEY, async () => {
-			log.info("Building new manifest");
-			const built = await this.builder.build();
-			log.info({ version: built.version }, "Manifest built successfully");
-			return built;
-		}, {
-			namespace: MANIFEST_NAMESPACE,
-			ttl: this.ttlMs
-		});
-		log.debug({ version: manifest.version }, "Manifest retrieved");
-		return manifest;
-	}
-	/**
-	* Force invalidate the manifest (called on mutations)
-	*/
-	async invalidate() {
-		log.info("Invalidating manifest cache");
-		await this.cache.delete(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE);
-	}
-	/**
-	* Invalidate and immediately rebuild (atomic refresh)
-	*/
-	async refresh() {
-		log.info("Refreshing manifest (invalidate + rebuild)");
-		await this.invalidate();
-		return this.getManifest();
-	}
-	/**
-	* Get manifest version without fetching full manifest
-	* Useful for checking if manifest is stale
-	*/
-	async getVersion() {
-		const version = (await this.cache.get(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE))?.version ?? null;
-		log.debug({ version }, "Got manifest version");
-		return version;
-	}
-	/**
-	* Check if manifest exists in cache
-	*/
-	async hasManifest() {
-		const exists = await this.cache.has(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE);
-		log.debug({ exists }, "Checked manifest existence");
-		return exists;
-	}
-};
-
 //#endregion
 exports.COST_SUMMARY_GROUP_BY = COST_SUMMARY_GROUP_BY;
 exports.CacheService = CacheService;
@@ -3260,8 +2751,6 @@ exports.LLMOPS_TRACE_NAME_HEADER = LLMOPS_TRACE_NAME_HEADER;
 exports.LLMOPS_USER_ID_HEADER = LLMOPS_USER_ID_HEADER;
 exports.LLMOpsPricingProvider = LLMOpsPricingProvider;
 exports.MS = MS;
-exports.ManifestBuilder = ManifestBuilder;
-exports.ManifestService = ManifestService;
 exports.MemoryCacheBackend = MemoryCacheBackend;
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.SupportedProviders = SupportedProviders;
@@ -3274,16 +2763,11 @@ exports.createDataLayer = createDataLayer;
 exports.createDatabase = require_db.createDatabase;
 exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
 exports.createDatasetsDataLayer = createDatasetsDataLayer;
-exports.createGuardrailConfigsDataLayer = createGuardrailConfigsDataLayer;
-exports.createLLMRequestsDataLayer = createLLMRequestsDataLayer;
 exports.createNeonDialect = require_neon_dialect.createNeonDialect;
 exports.createPgStore = createPgStore;
 exports.createPlaygroundDataLayer = createPlaygroundDataLayer;
 exports.createPlaygroundResultsDataLayer = createPlaygroundResultsDataLayer;
 exports.createPlaygroundRunsDataLayer = createPlaygroundRunsDataLayer;
-exports.createProviderConfigsDataLayer = createProviderConfigsDataLayer;
-exports.createProviderGuardrailOverridesDataLayer = createProviderGuardrailOverridesDataLayer;
-exports.createTracesDataLayer = createTracesDataLayer;
 exports.createWorkspaceSettingsDataLayer = createWorkspaceSettingsDataLayer;
 exports.datasetRecordsSchema = require_db.datasetRecordsSchema;
 exports.datasetVersionRecordsSchema = require_db.datasetVersionRecordsSchema;