@llmops/core 0.6.10 → 1.0.0-beta.2

package/dist/index.cjs

@@ -1,14 +1,11 @@
-const require_db = require('./db-D8otWwZL.cjs');
-const require_neon_dialect = require('./neon-dialect-ccr-mLKR.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");
 let node_path = require("node:path");
 node_path = require_db.__toESM(node_path);
-let __better_auth_utils_random = require("@better-auth/utils/random");
 let node_crypto = require("node:crypto");
-let json_logic_js = require("json-logic-js");
-json_logic_js = require_db.__toESM(json_logic_js);
 
 //#region src/constants/headers.ts
 /**
@@ -633,9 +630,8 @@ const providersConfigSchema = require_db.array(inlineProviderConfigSchema).optio
 * Base schema without refinements (used for transform)
 */
 const llmopsConfigBaseSchema = require_db.object({
-	database: require_db.any().optional(),
+	telemetry: require_db.any().optional(),
 	basePath: require_db.string().min(1, "Base path cannot be empty").refine((path) => path.startsWith("/"), "Base path must start with a forward slash").default("/llmops"),
-	schema: require_db.string().optional().default("llmops"),
 	providers: providersConfigSchema
 });
 const llmopsConfigSchema = llmopsConfigBaseSchema.transform((config) => ({
@@ -1160,8 +1156,13 @@ var CacheService = class {
 
 //#endregion
 //#region src/utils/id.ts
+const CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 const generateId = (size) => {
-	return (0, __better_auth_utils_random.createRandomStringGenerator)("a-z", "A-Z", "0-9")(size || 32);
+	const length = size || 32;
+	const bytes = (0, node_crypto.randomBytes)(length);
+	let result = "";
+	for (let i = 0; i < length; i++) result += CHARS[bytes[i] % 62];
+	return result;
 };
 
 //#endregion
@@ -1176,339 +1177,6 @@ var LLMOpsError = class extends Error {
 	}
 };
 
-//#endregion
-//#region src/datalayer/configs.ts
-/**
-* Generate a short unique ID for configs (8 characters, URL-safe)
-* Uses base62 encoding (a-z, A-Z, 0-9) for shorter, readable IDs
-*/
-function generateShortId(length = 8) {
-	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-	const bytes = (0, node_crypto.randomBytes)(length);
-	let result = "";
-	for (let i = 0; i < length; i++) result += chars[bytes[i] % 62];
-	return result;
-}
-const createNewConfig = require_db.zod_default.object({ name: require_db.zod_default.string() });
-const updateConfigName = require_db.zod_default.object({
-	configId: require_db.zod_default.uuidv4(),
-	newName: require_db.zod_default.string()
-});
-const getConfigById = require_db.zod_default.object({ configId: require_db.zod_default.uuidv4() });
-const deleteConfig = require_db.zod_default.object({ configId: require_db.zod_default.uuidv4() });
-const listConfigs = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const createConfigDataLayer = (db) => {
-	return {
-		createNewConfig: async (params) => {
-			const value = await createNewConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { name } = value.data;
-			return db.insertInto("configs").values({
-				id: (0, node_crypto.randomUUID)(),
-				slug: generateShortId(),
-				name,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateConfigName: async (params) => {
-			const value = await updateConfigName.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { newName, configId } = value.data;
-			return db.updateTable("configs").set({
-				name: newName,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).where("id", "=", configId).returningAll().executeTakeFirst();
-		},
-		getConfigById: async (params) => {
-			const value = await getConfigById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId } = value.data;
-			return db.selectFrom("configs").selectAll().where("id", "=", configId).executeTakeFirst();
-		},
-		deleteConfig: async (params) => {
-			const value = await deleteConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId } = value.data;
-			return db.deleteFrom("configs").where("id", "=", configId).returningAll().executeTakeFirst();
-		},
-		listConfigs: async (params) => {
-			const value = await listConfigs.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("configs").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getConfigWithVariants: async (params) => {
-			const value = await getConfigById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId } = value.data;
-			const configData = await db.selectFrom("configs").leftJoin("config_variants", "configs.id", "config_variants.configId").leftJoin("variants", "config_variants.variantId", "variants.id").select([
-				"configs.id",
-				"configs.slug",
-				"configs.name",
-				"configs.createdAt",
-				"configs.updatedAt",
-				"variants.id as variantId",
-				"variants.name as variantName"
-			]).where("configs.id", "=", configId).execute();
-			const variantIds = configData.map((row) => row.variantId).filter((id) => id !== null);
-			if (variantIds.length === 0) return configData.map((row) => ({
-				...row,
-				provider: null,
-				modelName: null,
-				jsonData: null,
-				variantVersionId: null
-			}));
-			const latestVersions = await Promise.all(variantIds.map((variantId) => db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).orderBy("version", "desc").limit(1).executeTakeFirst()));
-			const versionMap = new Map(latestVersions.filter((v) => v !== void 0).map((v) => [v.variantId, v]));
-			return configData.map((row) => {
-				const version = row.variantId ? versionMap.get(row.variantId) : null;
-				return {
-					...row,
-					provider: version?.provider ?? null,
-					modelName: version?.modelName ?? null,
-					jsonData: version?.jsonData ?? null,
-					variantVersionId: version?.id ?? null
-				};
-			});
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/configVariants.ts
-const createConfigVariant = require_db.zod_default.object({
-	configId: require_db.zod_default.string().uuid(),
-	variantId: require_db.zod_default.string().uuid()
-});
-const getConfigVariantById = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const getConfigVariantsByConfigId = require_db.zod_default.object({
-	configId: 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 getConfigVariantsByVariantId = require_db.zod_default.object({
-	variantId: 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 deleteConfigVariant = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const deleteConfigVariantByIds = require_db.zod_default.object({
-	configId: require_db.zod_default.string().uuid(),
-	variantId: require_db.zod_default.string().uuid()
-});
-const listConfigVariants = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const createVariantAndLinkToConfig = require_db.zod_default.object({
-	configId: require_db.zod_default.string().uuid(),
-	name: require_db.zod_default.string(),
-	provider: require_db.zod_default.string(),
-	modelName: require_db.zod_default.string(),
-	jsonData: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional().default({})
-});
-const getVariantJsonDataForConfig = require_db.zod_default.object({
-	configId: require_db.zod_default.string(),
-	envSecret: require_db.zod_default.string().optional()
-});
-const createConfigVariantDataLayer = (db) => {
-	return {
-		createConfigVariant: async (params) => {
-			const value = await createConfigVariant.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, variantId } = value.data;
-			return db.insertInto("config_variants").values({
-				id: (0, node_crypto.randomUUID)(),
-				configId,
-				variantId,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		getConfigVariantById: async (params) => {
-			const value = await getConfigVariantById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("config_variants").selectAll().where("id", "=", id).executeTakeFirst();
-		},
-		getConfigVariantsByConfigId: async (params) => {
-			const value = await getConfigVariantsByConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("config_variants").selectAll().where("configId", "=", configId).orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getConfigVariantsByVariantId: async (params) => {
-			const value = await getConfigVariantsByVariantId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("config_variants").selectAll().where("variantId", "=", variantId).orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		deleteConfigVariant: async (params) => {
-			const value = await deleteConfigVariant.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("config_variants").where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		deleteConfigVariantByIds: async (params) => {
-			const value = await deleteConfigVariantByIds.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, variantId } = value.data;
-			return db.deleteFrom("config_variants").where("configId", "=", configId).where("variantId", "=", variantId).returningAll().executeTakeFirst();
-		},
-		listConfigVariants: async (params) => {
-			const value = await listConfigVariants.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("config_variants").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getConfigVariantWithDetails: async (params) => {
-			const value = await getConfigVariantById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			const configVariant = await db.selectFrom("config_variants").leftJoin("configs", "config_variants.configId", "configs.id").leftJoin("variants", "config_variants.variantId", "variants.id").select([
-				"config_variants.id",
-				"config_variants.configId",
-				"config_variants.variantId",
-				"config_variants.createdAt",
-				"config_variants.updatedAt",
-				"configs.name as configName",
-				"variants.name as variantName"
-			]).where("config_variants.id", "=", id).executeTakeFirst();
-			if (!configVariant) return;
-			const latestVersion = await db.selectFrom("variant_versions").selectAll().where("variantId", "=", configVariant.variantId).orderBy("version", "desc").limit(1).executeTakeFirst();
-			return {
-				...configVariant,
-				latestVersion: latestVersion ?? null
-			};
-		},
-		getConfigVariantsWithDetailsByConfigId: async (params) => {
-			const value = await getConfigVariantsByConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, limit = 100, offset = 0 } = value.data;
-			const configVariants = await db.selectFrom("config_variants").leftJoin("variants", "config_variants.variantId", "variants.id").select([
-				"config_variants.id",
-				"config_variants.configId",
-				"config_variants.variantId",
-				"config_variants.createdAt",
-				"config_variants.updatedAt",
-				"variants.name"
-			]).where("config_variants.configId", "=", configId).orderBy("config_variants.createdAt", "desc").limit(limit).offset(offset).execute();
-			if (configVariants.length === 0) return [];
-			return await Promise.all(configVariants.map(async (cv) => {
-				const latestVersion = cv.variantId ? await db.selectFrom("variant_versions").selectAll().where("variantId", "=", cv.variantId).orderBy("version", "desc").limit(1).executeTakeFirst() : null;
-				return {
-					...cv,
-					provider: latestVersion?.provider ?? null,
-					modelName: latestVersion?.modelName ?? null,
-					jsonData: latestVersion?.jsonData ?? null,
-					latestVersion: latestVersion ?? null
-				};
-			}));
-		},
-		createVariantAndLinkToConfig: async (params) => {
-			const value = await createVariantAndLinkToConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, name, provider, modelName, jsonData } = value.data;
-			const variantId = (0, node_crypto.randomUUID)();
-			const versionId = (0, node_crypto.randomUUID)();
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const variant = await db.insertInto("variants").values({
-				id: variantId,
-				name,
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-			if (!variant) throw new LLMOpsError("Failed to create variant");
-			const version = await db.insertInto("variant_versions").values({
-				id: versionId,
-				variantId,
-				version: 1,
-				provider,
-				modelName,
-				jsonData: JSON.stringify(jsonData),
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-			if (!version) throw new LLMOpsError("Failed to create variant version");
-			const configVariant = await db.insertInto("config_variants").values({
-				id: (0, node_crypto.randomUUID)(),
-				configId,
-				variantId,
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-			if (!configVariant) throw new LLMOpsError("Failed to link variant to config");
-			return {
-				variant,
-				version,
-				configVariant
-			};
-		},
-		getVariantJsonDataForConfig: async (params) => {
-			const value = await getVariantJsonDataForConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId: configIdOrSlug, envSecret } = value.data;
-			const UUID_REGEX$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-			let resolvedConfigId;
-			if (UUID_REGEX$1.test(configIdOrSlug)) resolvedConfigId = configIdOrSlug;
-			else {
-				const config = await db.selectFrom("configs").select("id").where("slug", "=", configIdOrSlug).executeTakeFirst();
-				if (!config) throw new LLMOpsError(`Config not found: ${configIdOrSlug}`);
-				resolvedConfigId = config.id;
-			}
-			let environmentId;
-			if (envSecret) {
-				const secret = await db.selectFrom("environment_secrets").select("environmentId").where("keyValue", "=", envSecret).executeTakeFirst();
-				if (!secret) throw new LLMOpsError("Invalid environment secret");
-				environmentId = secret.environmentId;
-			} else {
-				const prodEnv = await db.selectFrom("environments").select("id").where("isProd", "=", true).executeTakeFirst();
-				if (!prodEnv) throw new LLMOpsError("No production environment found");
-				environmentId = prodEnv.id;
-			}
-			const targetingRule = await db.selectFrom("targeting_rules").select(["configVariantId", "variantVersionId"]).where("configId", "=", resolvedConfigId).where("environmentId", "=", environmentId).where("enabled", "=", true).orderBy("priority", "desc").orderBy("weight", "desc").executeTakeFirst();
-			if (!targetingRule) throw new LLMOpsError(`No targeting rule found for config ${resolvedConfigId} in environment ${environmentId}`);
-			const configVariant = await db.selectFrom("config_variants").select("variantId").where("id", "=", targetingRule.configVariantId).executeTakeFirst();
-			if (!configVariant) throw new LLMOpsError(`No config variant found for ${targetingRule.configVariantId}`);
-			let versionData;
-			if (targetingRule.variantVersionId) versionData = await db.selectFrom("variant_versions").select([
-				"jsonData",
-				"provider",
-				"modelName",
-				"version"
-			]).where("id", "=", targetingRule.variantVersionId).executeTakeFirst();
-			else versionData = await db.selectFrom("variant_versions").select([
-				"jsonData",
-				"provider",
-				"modelName",
-				"version"
-			]).where("variantId", "=", configVariant.variantId).orderBy("version", "desc").limit(1).executeTakeFirst();
-			if (!versionData) throw new LLMOpsError(`No variant version found for variant ${configVariant.variantId}`);
-			let finalProvider = versionData.provider;
-			let providerConfigId = null;
-			if (UUID_REGEX$1.test(versionData.provider)) {
-				const providerConfig = await db.selectFrom("provider_configs").select(["id", "providerId"]).where("id", "=", versionData.provider).executeTakeFirst();
-				if (providerConfig) {
-					finalProvider = providerConfig.providerId;
-					providerConfigId = providerConfig.id;
-				}
-			}
-			return {
-				...versionData,
-				provider: finalProvider,
-				providerConfigId,
-				configId: resolvedConfigId,
-				variantId: configVariant.variantId,
-				environmentId
-			};
-		}
-	};
-};
-
 //#endregion
 //#region src/datalayer/datasets.ts
 const createDataset = require_db.zod_default.object({
@@ -1718,254 +1386,6 @@ const createDatasetsDataLayer = (db) => {
 	};
 };
 
-//#endregion
-//#region src/datalayer/environments.ts
-const createNewEnvironment = require_db.zod_default.object({
-	name: require_db.zod_default.string(),
-	slug: require_db.zod_default.string(),
-	isProd: require_db.zod_default.boolean().optional().default(false)
-});
-const updateEnvironment = require_db.zod_default.object({
-	environmentId: require_db.zod_default.uuidv4(),
-	name: require_db.zod_default.string().optional(),
-	slug: require_db.zod_default.string().optional()
-});
-const getEnvironmentById = require_db.zod_default.object({ environmentId: require_db.zod_default.uuidv4() });
-const getEnvironmentBySlug = require_db.zod_default.object({ slug: require_db.zod_default.string() });
-const deleteEnvironment = require_db.zod_default.object({ environmentId: require_db.zod_default.uuidv4() });
-const listEnvironments = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const createEnvironmentDataLayer = (db) => {
-	return {
-		createNewEnvironment: async (params) => {
-			const value = await createNewEnvironment.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { name, slug, isProd } = value.data;
-			return db.insertInto("environments").values({
-				id: (0, node_crypto.randomUUID)(),
-				name,
-				slug,
-				isProd,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateEnvironment: async (params) => {
-			const value = await updateEnvironment.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId, name, slug } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (name !== void 0) updateData.name = name;
-			if (slug !== void 0) updateData.slug = slug;
-			return db.updateTable("environments").set(updateData).where("id", "=", environmentId).returningAll().executeTakeFirst();
-		},
-		getEnvironmentById: async (params) => {
-			const value = await getEnvironmentById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId } = value.data;
-			return db.selectFrom("environments").selectAll().where("id", "=", environmentId).executeTakeFirst();
-		},
-		getEnvironmentBySlug: async (params) => {
-			const value = await getEnvironmentBySlug.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { slug } = value.data;
-			return db.selectFrom("environments").selectAll().where("slug", "=", slug).executeTakeFirst();
-		},
-		deleteEnvironment: async (params) => {
-			const value = await deleteEnvironment.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId } = value.data;
-			return db.deleteFrom("environments").where("id", "=", environmentId).returningAll().executeTakeFirst();
-		},
-		listEnvironments: async (params) => {
-			const value = await listEnvironments.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("environments").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		countEnvironments: async () => {
-			const result = await db.selectFrom("environments").select(db.fn.countAll().as("count")).executeTakeFirst();
-			return Number(result?.count ?? 0);
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/environmentSecrets.ts
-const createEnvironmentSecret = require_db.zod_default.object({
-	environmentId: require_db.zod_default.uuidv4(),
-	keyName: require_db.zod_default.string(),
-	keyValue: require_db.zod_default.string()
-});
-const updateEnvironmentSecret = require_db.zod_default.object({
-	secretId: require_db.zod_default.uuidv4(),
-	keyName: require_db.zod_default.string().optional(),
-	keyValue: require_db.zod_default.string().optional()
-});
-const getEnvironmentSecretById = require_db.zod_default.object({ secretId: require_db.zod_default.uuidv4() });
-const getSecretsByEnvironmentId = require_db.zod_default.object({ environmentId: require_db.zod_default.uuidv4() });
-const deleteEnvironmentSecret = require_db.zod_default.object({ secretId: require_db.zod_default.uuidv4() });
-const deleteSecretsByEnvironmentId = require_db.zod_default.object({ environmentId: require_db.zod_default.uuidv4() });
-const listEnvironmentSecrets = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const createEnvironmentSecretDataLayer = (db) => {
-	return {
-		createEnvironmentSecret: async (params) => {
-			const value = await createEnvironmentSecret.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId, keyName, keyValue } = value.data;
-			return db.insertInto("environment_secrets").values({
-				id: (0, node_crypto.randomUUID)(),
-				environmentId,
-				keyName,
-				keyValue,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateEnvironmentSecret: async (params) => {
-			const value = await updateEnvironmentSecret.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { secretId, keyName, keyValue } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (keyName !== void 0) updateData.keyName = keyName;
-			if (keyValue !== void 0) updateData.keyValue = keyValue;
-			return db.updateTable("environment_secrets").set(updateData).where("id", "=", secretId).returningAll().executeTakeFirst();
-		},
-		getEnvironmentSecretById: async (params) => {
-			const value = await getEnvironmentSecretById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { secretId } = value.data;
-			return db.selectFrom("environment_secrets").selectAll().where("id", "=", secretId).executeTakeFirst();
-		},
-		getSecretsByEnvironmentId: async (params) => {
-			const value = await getSecretsByEnvironmentId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId } = value.data;
-			return db.selectFrom("environment_secrets").selectAll().where("environmentId", "=", environmentId).orderBy("createdAt", "desc").execute();
-		},
-		deleteEnvironmentSecret: async (params) => {
-			const value = await deleteEnvironmentSecret.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { secretId } = value.data;
-			return db.deleteFrom("environment_secrets").where("id", "=", secretId).returningAll().executeTakeFirst();
-		},
-		deleteSecretsByEnvironmentId: async (params) => {
-			const value = await deleteSecretsByEnvironmentId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId } = value.data;
-			return db.deleteFrom("environment_secrets").where("environmentId", "=", environmentId).returningAll().execute();
-		},
-		listEnvironmentSecrets: async (params) => {
-			const value = await listEnvironmentSecrets.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("environment_secrets").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		countEnvironmentSecrets: async () => {
-			const result = await db.selectFrom("environment_secrets").select(db.fn.countAll().as("count")).executeTakeFirst();
-			return Number(result?.count ?? 0);
-		}
-	};
-};
-
-//#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")
-});
-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 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({
-	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()
-});
-const createGuardrailConfigsDataLayer = (db) => {
-	return {
-		createGuardrailConfig: async (params) => {
-			const value = await createGuardrailConfig.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({
-				id: (0, node_crypto.randomUUID)(),
-				name,
-				pluginId,
-				functionId,
-				hookType,
-				parameters: JSON.stringify(parameters),
-				enabled,
-				priority,
-				onFail,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateGuardrailConfig: async (params) => {
-			const value = await updateGuardrailConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, name, hookType, parameters, enabled, priority, onFail } = 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();
-		},
-		getGuardrailConfigById: async (params) => {
-			const value = await getGuardrailConfigById.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();
-		},
-		deleteGuardrailConfig: async (params) => {
-			const value = await deleteGuardrailConfig.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();
-		},
-		listGuardrailConfigs: async (params) => {
-			const value = await listGuardrailConfigs.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();
-		},
-		countGuardrailConfigs: async () => {
-			const result = await db.selectFrom("guardrail_configs").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
 /**
@@ -2057,7 +1477,6 @@ const COST_SUMMARY_GROUP_BY = [
 	"hour",
 	"model",
 	"provider",
-	"config",
 	"endpoint",
 	"tags"
 ];
@@ -2079,7 +1498,6 @@ const costSummarySchema = require_db.zod_default.object({
 * Uses sql.ref() to properly quote column names for the database
 */
 const col$1 = (name) => kysely.sql.ref(name);
-const tableCol = (table, name) => kysely.sql.ref(`${table}.${name}`);
 const createLLMRequestsDataLayer = (db) => {
 	return {
 		batchInsertRequests: async (requests) => {
@@ -2253,25 +1671,6 @@ const createLLMRequestsDataLayer = (db) => {
 				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();
 		},
-		getCostByConfig: 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").leftJoin("configs", "llm_requests.configId", "configs.id").select([
-				"llm_requests.configId",
-				"configs.name as configName",
-				"configs.slug as configSlug",
-				kysely.sql`COALESCE(SUM(${tableCol("llm_requests", "cost")}), 0)`.as("totalCost"),
-				kysely.sql`COALESCE(SUM(${tableCol("llm_requests", "inputCost")}), 0)`.as("totalInputCost"),
-				kysely.sql`COALESCE(SUM(${tableCol("llm_requests", "outputCost")}), 0)`.as("totalOutputCost"),
-				kysely.sql`COALESCE(SUM(${tableCol("llm_requests", "totalTokens")}), 0)`.as("totalTokens"),
-				kysely.sql`COUNT(*)`.as("requestCount")
-			]).where(kysely.sql`${tableCol("llm_requests", "createdAt")} >= ${startDate.toISOString()}`).where(kysely.sql`${tableCol("llm_requests", "createdAt")} <= ${endDate.toISOString()}`).groupBy([
-				"llm_requests.configId",
-				"configs.name",
-				"configs.slug"
-			]).orderBy(kysely.sql`SUM(${tableCol("llm_requests", "cost")})`, "desc").execute();
-		},
 		getDailyCosts: async (params) => {
 			const result = await dateRangeSchema.safeParseAsync(params);
 			if (!result.success) throw new LLMOpsError(`Invalid parameters: ${result.error.message}`);
@@ -2324,11 +1723,6 @@ const createLLMRequestsDataLayer = (db) => {
 					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 "config": return baseQuery.select([
-					kysely.sql`COALESCE(${col$1("configId")}::text, 'no-config')`.as("groupKey"),
-					kysely.sql`COALESCE(SUM(${col$1("cost")}), 0)`.as("totalCost"),
-					kysely.sql`COUNT(*)`.as("requestCount")
-				]).groupBy("configId").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"),
@@ -2701,463 +2095,31 @@ const createPlaygroundRunsDataLayer = (db) => {
 };
 
 //#endregion
-//#region src/datalayer/providerConfigs.ts
+//#region src/datalayer/traces.ts
+const col = (name) => kysely.sql.ref(name);
 /**
-* Generate a unique slug for a provider config.
-* If the base slug already exists, appends -01, -02, etc.
+* Schema for upserting a trace
 */
-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(),
+const upsertTraceSchema = require_db.zod_default.object({
+	traceId: require_db.zod_default.string(),
 	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()
-});
-const createProviderConfigsDataLayer = (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({
-				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();
-		},
-		updateProviderConfig: async (params) => {
-			const value = await updateProviderConfig.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, slug, name, config, enabled } = value.data;
-			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();
-		},
-		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);
-		},
-		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,
-					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				}).where("id", "=", existing.id).returningAll().executeTakeFirst();
-			}
-			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(),
-				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();
-		},
-		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();
-		},
-		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({
-				id: (0, node_crypto.randomUUID)(),
-				providerConfigId,
-				guardrailConfigId,
-				enabled,
-				parameters: parameters ? JSON.stringify(parameters) : null,
-				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();
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/targetingRules.ts
-const createTargetingRule = require_db.zod_default.object({
-	environmentId: require_db.zod_default.string().uuid(),
-	configId: require_db.zod_default.string().uuid(),
-	configVariantId: require_db.zod_default.string().uuid(),
-	variantVersionId: require_db.zod_default.string().uuid().nullable().optional(),
-	weight: require_db.zod_default.number().int().min(0).max(1e4).optional().default(1e4),
-	priority: require_db.zod_default.number().int().optional().default(0),
-	enabled: require_db.zod_default.boolean().optional().default(true),
-	conditions: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional()
-});
-const updateTargetingRule = require_db.zod_default.object({
-	id: require_db.zod_default.string().uuid(),
-	variantVersionId: require_db.zod_default.string().uuid().nullable().optional(),
-	weight: require_db.zod_default.number().int().min(0).max(1e4).optional(),
-	priority: require_db.zod_default.number().int().optional(),
-	enabled: require_db.zod_default.boolean().optional(),
-	conditions: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).nullable().optional()
-});
-const getTargetingRuleById = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const getTargetingRulesByConfigId = require_db.zod_default.object({
-	configId: 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 getTargetingRulesByEnvironmentId = require_db.zod_default.object({
-	environmentId: 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 getTargetingRulesByConfigAndEnvironment = require_db.zod_default.object({
-	configId: require_db.zod_default.string().uuid(),
-	environmentId: require_db.zod_default.string().uuid()
-});
-const deleteTargetingRule = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const deleteTargetingRulesByConfigId = require_db.zod_default.object({ configId: require_db.zod_default.string().uuid() });
-const deleteTargetingRulesByEnvironmentId = require_db.zod_default.object({ environmentId: require_db.zod_default.string().uuid() });
-const listTargetingRules = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const setTargetingForEnvironment = require_db.zod_default.object({
-	environmentId: require_db.zod_default.string().uuid(),
-	configId: require_db.zod_default.string().uuid(),
-	configVariantId: require_db.zod_default.string().uuid(),
-	variantVersionId: require_db.zod_default.string().uuid().nullable().optional()
-});
-const createTargetingRulesDataLayer = (db) => {
-	return {
-		createTargetingRule: async (params) => {
-			const value = await createTargetingRule.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId, configId, configVariantId, variantVersionId, weight, priority, enabled, conditions } = value.data;
-			return db.insertInto("targeting_rules").values({
-				id: (0, node_crypto.randomUUID)(),
-				environmentId,
-				configId,
-				configVariantId,
-				variantVersionId: variantVersionId ?? null,
-				weight,
-				priority,
-				enabled,
-				conditions: JSON.stringify(conditions ?? {}),
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateTargetingRule: async (params) => {
-			const value = await updateTargetingRule.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, variantVersionId, weight, priority, enabled, conditions } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (variantVersionId !== void 0) updateData.variantVersionId = variantVersionId;
-			if (weight !== void 0) updateData.weight = weight;
-			if (priority !== void 0) updateData.priority = priority;
-			if (enabled !== void 0) updateData.enabled = enabled;
-			if (conditions !== void 0) updateData.conditions = conditions ? JSON.stringify(conditions) : null;
-			return db.updateTable("targeting_rules").set(updateData).where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		getTargetingRuleById: async (params) => {
-			const value = await getTargetingRuleById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("targeting_rules").selectAll().where("id", "=", id).executeTakeFirst();
-		},
-		getTargetingRulesByConfigId: async (params) => {
-			const value = await getTargetingRulesByConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("targeting_rules").selectAll().where("configId", "=", configId).where("enabled", "=", true).orderBy("priority", "desc").orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getTargetingRulesByEnvironmentId: async (params) => {
-			const value = await getTargetingRulesByEnvironmentId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("targeting_rules").selectAll().where("environmentId", "=", environmentId).where("enabled", "=", true).orderBy("priority", "desc").orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getTargetingRulesByConfigAndEnvironment: async (params) => {
-			const value = await getTargetingRulesByConfigAndEnvironment.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, environmentId } = value.data;
-			return db.selectFrom("targeting_rules").selectAll().where("configId", "=", configId).where("environmentId", "=", environmentId).where("enabled", "=", true).orderBy("priority", "desc").orderBy("weight", "desc").execute();
-		},
-		deleteTargetingRule: async (params) => {
-			const value = await deleteTargetingRule.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("targeting_rules").where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		deleteTargetingRulesByConfigId: async (params) => {
-			const value = await deleteTargetingRulesByConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId } = value.data;
-			return db.deleteFrom("targeting_rules").where("configId", "=", configId).returningAll().execute();
-		},
-		deleteTargetingRulesByEnvironmentId: async (params) => {
-			const value = await deleteTargetingRulesByEnvironmentId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId } = value.data;
-			return db.deleteFrom("targeting_rules").where("environmentId", "=", environmentId).returningAll().execute();
-		},
-		listTargetingRules: async (params) => {
-			const value = await listTargetingRules.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("targeting_rules").selectAll().orderBy("priority", "desc").orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		getTargetingRulesWithDetailsByConfigId: async (params) => {
-			const value = await getTargetingRulesByConfigId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { configId, limit = 100, offset = 0 } = value.data;
-			const rules = await db.selectFrom("targeting_rules").leftJoin("environments", "targeting_rules.environmentId", "environments.id").leftJoin("config_variants", "targeting_rules.configVariantId", "config_variants.id").leftJoin("variants", "config_variants.variantId", "variants.id").select([
-				"targeting_rules.id",
-				"targeting_rules.environmentId",
-				"targeting_rules.configId",
-				"targeting_rules.configVariantId",
-				"targeting_rules.variantVersionId",
-				"targeting_rules.weight",
-				"targeting_rules.priority",
-				"targeting_rules.enabled",
-				"targeting_rules.conditions",
-				"targeting_rules.createdAt",
-				"targeting_rules.updatedAt",
-				"environments.name as environmentName",
-				"environments.slug as environmentSlug",
-				"variants.name as variantName",
-				"config_variants.variantId"
-			]).where("targeting_rules.configId", "=", configId).orderBy("targeting_rules.priority", "desc").orderBy("targeting_rules.createdAt", "desc").limit(limit).offset(offset).execute();
-			return await Promise.all(rules.map(async (rule) => {
-				let versionInfo = null;
-				if (rule.variantVersionId) versionInfo = await db.selectFrom("variant_versions").select([
-					"provider",
-					"modelName",
-					"version"
-				]).where("id", "=", rule.variantVersionId).executeTakeFirst();
-				else if (rule.variantId) versionInfo = await db.selectFrom("variant_versions").select([
-					"provider",
-					"modelName",
-					"version"
-				]).where("variantId", "=", rule.variantId).orderBy("version", "desc").limit(1).executeTakeFirst();
-				return {
-					...rule,
-					variantProvider: versionInfo?.provider ?? null,
-					variantModelName: versionInfo?.modelName ?? null,
-					pinnedVersion: rule.variantVersionId ? versionInfo?.version : null,
-					latestVersion: !rule.variantVersionId ? versionInfo?.version : null
-				};
-			}));
-		},
-		setTargetingForEnvironment: async (params) => {
-			const value = await setTargetingForEnvironment.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { environmentId, configId, configVariantId, variantVersionId } = value.data;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			await db.deleteFrom("targeting_rules").where("configId", "=", configId).where("environmentId", "=", environmentId).execute();
-			return db.insertInto("targeting_rules").values({
-				id: (0, node_crypto.randomUUID)(),
-				environmentId,
-				configId,
-				configVariantId,
-				variantVersionId: variantVersionId ?? null,
-				weight: 1e4,
-				priority: 0,
-				enabled: true,
-				conditions: JSON.stringify({}),
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/traces.ts
-const col = (name) => kysely.sql.ref(name);
-/**
-* Schema for upserting a trace
-*/
-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({})
+	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({})
 });
 /**
 * Schema for inserting spans
@@ -3411,198 +2373,6 @@ const createTracesDataLayer = (db) => {
 	};
 };
 
-//#endregion
-//#region src/datalayer/variants.ts
-const createVariant = require_db.zod_default.object({ name: require_db.zod_default.string() });
-const updateVariant = require_db.zod_default.object({
-	variantId: require_db.zod_default.string().uuid(),
-	name: require_db.zod_default.string().optional()
-});
-const getVariantById = require_db.zod_default.object({ variantId: require_db.zod_default.string().uuid() });
-const deleteVariant = require_db.zod_default.object({ variantId: require_db.zod_default.string().uuid() });
-const listVariants = require_db.zod_default.object({
-	limit: require_db.zod_default.number().int().positive().optional(),
-	offset: require_db.zod_default.number().int().nonnegative().optional()
-});
-const createVariantDataLayer = (db) => {
-	return {
-		createVariant: async (params) => {
-			const value = await createVariant.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { name } = value.data;
-			return db.insertInto("variants").values({
-				id: (0, node_crypto.randomUUID)(),
-				name,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).returningAll().executeTakeFirst();
-		},
-		updateVariant: async (params) => {
-			const value = await updateVariant.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, ...updates } = value.data;
-			const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-			if (updates.name) updateData.name = updates.name;
-			return db.updateTable("variants").set(updateData).where("id", "=", variantId).returningAll().executeTakeFirst();
-		},
-		getVariantById: async (params) => {
-			const value = await getVariantById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId } = value.data;
-			return db.selectFrom("variants").selectAll().where("id", "=", variantId).executeTakeFirst();
-		},
-		getVariantWithLatestVersion: async (params) => {
-			const value = await getVariantById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId } = value.data;
-			const variant = await db.selectFrom("variants").selectAll().where("id", "=", variantId).executeTakeFirst();
-			if (!variant) return;
-			const latestVersion = await db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).orderBy("version", "desc").limit(1).executeTakeFirst();
-			return {
-				...variant,
-				latestVersion: latestVersion ?? null
-			};
-		},
-		deleteVariant: async (params) => {
-			const value = await deleteVariant.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId } = value.data;
-			await db.deleteFrom("variant_versions").where("variantId", "=", variantId).execute();
-			return db.deleteFrom("variants").where("id", "=", variantId).returningAll().executeTakeFirst();
-		},
-		listVariants: async (params) => {
-			const value = await listVariants.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("variants").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-		},
-		listVariantsWithLatestVersion: async (params) => {
-			const value = await listVariants.safeParseAsync(params || {});
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { limit = 100, offset = 0 } = value.data;
-			const variants = await db.selectFrom("variants").selectAll().orderBy("createdAt", "desc").limit(limit).offset(offset).execute();
-			if (variants.length === 0) return [];
-			return await Promise.all(variants.map(async (variant) => {
-				const latestVersion = await db.selectFrom("variant_versions").selectAll().where("variantId", "=", variant.id).orderBy("version", "desc").limit(1).executeTakeFirst();
-				return {
-					...variant,
-					latestVersion: latestVersion ?? null
-				};
-			}));
-		}
-	};
-};
-
-//#endregion
-//#region src/datalayer/variantVersions.ts
-const createVariantVersion = require_db.zod_default.object({
-	variantId: require_db.zod_default.string().uuid(),
-	provider: require_db.zod_default.string(),
-	modelName: require_db.zod_default.string(),
-	jsonData: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional().default({})
-});
-const getVariantVersionById = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const getVariantVersionsByVariantId = require_db.zod_default.object({
-	variantId: 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 getLatestVariantVersion = require_db.zod_default.object({ variantId: require_db.zod_default.string().uuid() });
-const getVariantVersionByNumber = require_db.zod_default.object({
-	variantId: require_db.zod_default.string().uuid(),
-	version: require_db.zod_default.number().int().positive()
-});
-const deleteVariantVersion = require_db.zod_default.object({ id: require_db.zod_default.string().uuid() });
-const createVariantVersionsDataLayer = (db) => {
-	return {
-		createVariantVersion: async (params) => {
-			const value = await createVariantVersion.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, provider, modelName, jsonData } = value.data;
-			const newVersionNumber = ((await db.selectFrom("variant_versions").select("version").where("variantId", "=", variantId).orderBy("version", "desc").limit(1).executeTakeFirst())?.version ?? 0) + 1;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			return db.insertInto("variant_versions").values({
-				id: (0, node_crypto.randomUUID)(),
-				variantId,
-				version: newVersionNumber,
-				provider,
-				modelName,
-				jsonData: JSON.stringify(jsonData),
-				createdAt: now,
-				updatedAt: now
-			}).returningAll().executeTakeFirst();
-		},
-		getVariantVersionById: async (params) => {
-			const value = await getVariantVersionById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("variant_versions").selectAll().where("id", "=", id).executeTakeFirst();
-		},
-		getVariantVersionsByVariantId: async (params) => {
-			const value = await getVariantVersionsByVariantId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).orderBy("version", "desc").limit(limit).offset(offset).execute();
-		},
-		getLatestVariantVersion: async (params) => {
-			const value = await getLatestVariantVersion.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId } = value.data;
-			return db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).orderBy("version", "desc").limit(1).executeTakeFirst();
-		},
-		getVariantVersionByNumber: async (params) => {
-			const value = await getVariantVersionByNumber.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, version } = value.data;
-			return db.selectFrom("variant_versions").selectAll().where("variantId", "=", variantId).where("version", "=", version).executeTakeFirst();
-		},
-		deleteVariantVersion: async (params) => {
-			const value = await deleteVariantVersion.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.deleteFrom("variant_versions").where("id", "=", id).returningAll().executeTakeFirst();
-		},
-		deleteVariantVersionsByVariantId: async (params) => {
-			const value = await getLatestVariantVersion.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId } = value.data;
-			return db.deleteFrom("variant_versions").where("variantId", "=", variantId).returningAll().execute();
-		},
-		getVariantVersionWithVariant: async (params) => {
-			const value = await getVariantVersionById.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id } = value.data;
-			return db.selectFrom("variant_versions").innerJoin("variants", "variant_versions.variantId", "variants.id").select([
-				"variant_versions.id",
-				"variant_versions.variantId",
-				"variant_versions.version",
-				"variant_versions.provider",
-				"variant_versions.modelName",
-				"variant_versions.jsonData",
-				"variant_versions.createdAt",
-				"variant_versions.updatedAt",
-				"variants.name as variantName"
-			]).where("variant_versions.id", "=", id).executeTakeFirst();
-		},
-		getVariantVersionsWithVariantByVariantId: async (params) => {
-			const value = await getVariantVersionsByVariantId.safeParseAsync(params);
-			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { variantId, limit = 100, offset = 0 } = value.data;
-			return db.selectFrom("variant_versions").innerJoin("variants", "variant_versions.variantId", "variants.id").select([
-				"variant_versions.id",
-				"variant_versions.variantId",
-				"variant_versions.version",
-				"variant_versions.provider",
-				"variant_versions.modelName",
-				"variant_versions.jsonData",
-				"variant_versions.createdAt",
-				"variant_versions.updatedAt",
-				"variants.name as variantName"
-			]).where("variant_versions.variantId", "=", variantId).orderBy("variant_versions.version", "desc").limit(limit).offset(offset).execute();
-		}
-	};
-};
-
 //#endregion
 //#region src/datalayer/workspaceSettings.ts
 const updateWorkspaceSettings = require_db.zod_default.object({
@@ -3695,22 +2465,12 @@ const createWorkspaceSettingsDataLayer = (db) => {
 */
 function createDataLayer(db) {
 	return {
-		...createConfigDataLayer(db),
-		...createConfigVariantDataLayer(db),
 		...createDatasetsDataLayer(db),
-		...createEnvironmentDataLayer(db),
-		...createEnvironmentSecretDataLayer(db),
-		...createGuardrailConfigsDataLayer(db),
 		...createLLMRequestsDataLayer(db),
 		...createPlaygroundDataLayer(db),
 		...createPlaygroundResultsDataLayer(db),
 		...createPlaygroundRunsDataLayer(db),
-		...createProviderConfigsDataLayer(db),
-		...createProviderGuardrailOverridesDataLayer(db),
-		...createTargetingRulesDataLayer(db),
 		...createTracesDataLayer(db),
-		...createVariantDataLayer(db),
-		...createVariantVersionsDataLayer(db),
 		...createWorkspaceSettingsDataLayer(db)
 	};
 }
@@ -3989,372 +2749,42 @@ function getDefaultPricingProvider() {
 }
 
 //#endregion
-//#region src/manifest/builder.ts
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
-* Builds the gateway routing manifest from database
-*/
-var ManifestBuilder = class {
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Build the complete routing manifest from database
-	*/
-	async build() {
-		const [configs, environments, environmentSecrets, targetingRules, configVariants, variantVersions, providerConfigs, guardrailConfigs, providerGuardrailOverridesData] = await Promise.all([
-			this.db.selectFrom("configs").selectAll().execute(),
-			this.db.selectFrom("environments").selectAll().execute(),
-			this.db.selectFrom("environment_secrets").selectAll().execute(),
-			this.db.selectFrom("targeting_rules").where("enabled", "=", true).selectAll().execute(),
-			this.db.selectFrom("config_variants").selectAll().execute(),
-			this.db.selectFrom("variant_versions").selectAll().execute(),
-			this.db.selectFrom("provider_configs").selectAll().execute(),
-			this.db.selectFrom("guardrail_configs").where("enabled", "=", true).selectAll().execute(),
-			this.db.selectFrom("provider_guardrail_overrides").selectAll().execute()
-		]);
-		const manifestConfigs = {};
-		const configsBySlug = {};
-		for (const config of configs) {
-			manifestConfigs[config.id] = {
-				id: config.id,
-				slug: config.slug,
-				name: config.name ?? null
-			};
-			configsBySlug[config.slug] = config.id;
-		}
-		const manifestEnvironments = {};
-		const environmentsBySlug = {};
-		for (const env of environments) {
-			manifestEnvironments[env.id] = {
-				id: env.id,
-				slug: env.slug,
-				name: env.name,
-				isProd: env.isProd
-			};
-			environmentsBySlug[env.slug] = env.id;
-		}
-		const secretToEnvironment = {};
-		for (const secret of environmentSecrets) secretToEnvironment[secret.keyValue] = secret.environmentId;
-		const configVariantMap = new Map(configVariants.map((cv) => [cv.id, cv]));
-		const providerConfigMap = new Map(providerConfigs.map((pc) => [pc.id, pc]));
-		const versionsByVariant = /* @__PURE__ */ new Map();
-		for (const vv of variantVersions) {
-			const list = versionsByVariant.get(vv.variantId) || [];
-			list.push(vv);
-			versionsByVariant.set(vv.variantId, list);
-		}
-		for (const list of versionsByVariant.values()) list.sort((a, b) => b.version - a.version);
-		const versionById = new Map(variantVersions.map((vv) => [vv.id, vv]));
-		const resolveProvider = (provider) => {
-			if (UUID_REGEX.test(provider)) {
-				const pc = providerConfigMap.get(provider);
-				if (pc) return {
-					providerId: pc.providerId,
-					providerConfigId: pc.id
-				};
-			}
-			return {
-				providerId: provider,
-				providerConfigId: null
-			};
-		};
-		const buildVersion = (vv) => {
-			const { providerId, providerConfigId } = resolveProvider(vv.provider);
-			const jsonData = typeof vv.jsonData === "string" ? JSON.parse(vv.jsonData) : vv.jsonData;
-			return {
-				id: vv.id,
-				variantId: vv.variantId,
-				version: vv.version,
-				provider: providerId,
-				providerConfigId,
-				modelName: vv.modelName,
-				jsonData
-			};
-		};
-		const routingTable = {};
-		for (const rule of targetingRules) {
-			const configVariant = configVariantMap.get(rule.configVariantId);
-			if (!configVariant) continue;
-			const variantId = configVariant.variantId;
-			let resolvedVersionData;
-			if (rule.variantVersionId) resolvedVersionData = versionById.get(rule.variantVersionId);
-			else resolvedVersionData = versionsByVariant.get(variantId)?.[0];
-			if (!resolvedVersionData) continue;
-			let conditions = null;
-			if (rule.conditions) {
-				const conditionsObj = typeof rule.conditions === "string" ? JSON.parse(rule.conditions) : rule.conditions;
-				if (conditionsObj && Object.keys(conditionsObj).length > 0) conditions = conditionsObj;
-			}
-			const manifestRule = {
-				id: rule.id,
-				configVariantId: rule.configVariantId,
-				variantVersionId: rule.variantVersionId,
-				weight: rule.weight,
-				priority: rule.priority,
-				enabled: rule.enabled,
-				conditions,
-				resolvedVersion: buildVersion(resolvedVersionData)
-			};
-			if (!routingTable[rule.configId]) routingTable[rule.configId] = {};
-			if (!routingTable[rule.configId][rule.environmentId]) routingTable[rule.configId][rule.environmentId] = [];
-			routingTable[rule.configId][rule.environmentId].push(manifestRule);
-		}
-		for (const configRules of Object.values(routingTable)) for (const envRules of Object.values(configRules)) envRules.sort((a, b) => {
-			if (b.priority !== a.priority) return b.priority - a.priority;
-			return b.weight - a.weight;
-		});
-		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(),
-			configs: manifestConfigs,
-			configsBySlug,
-			environments: manifestEnvironments,
-			environmentsBySlug,
-			routingTable,
-			secretToEnvironment,
-			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,
-				configCount: Object.keys(built.configs).length,
-				environmentCount: Object.keys(built.environments).length
-			}, "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
-//#region src/manifest/router.ts
+//#region src/telemetry/postgres.ts
 /**
-* Router for evaluating the gateway manifest and selecting variants
+* Create a PostgreSQL-backed telemetry store.
+*
+* Usage:
+* ```ts
+* import { llmops, pgStore } from '@llmops/sdk'
+*
+* const ops = llmops({
+*   telemetry: pgStore(process.env.DATABASE_URL),
+* })
+* ```
 */
-var ManifestRouter = class {
-	constructor(manifest) {
-		this.manifest = manifest;
-	}
-	/**
-	* Resolve a config identifier (UUID or slug) to config ID
-	*/
-	resolveConfigId(configIdOrSlug) {
-		if (this.manifest.configs[configIdOrSlug]) return configIdOrSlug;
-		return this.manifest.configsBySlug[configIdOrSlug] ?? null;
-	}
-	/**
-	* Resolve environment from secret value
-	*/
-	resolveEnvironmentFromSecret(secretValue) {
-		return this.manifest.secretToEnvironment[secretValue] ?? null;
-	}
-	/**
-	* Get production environment ID
-	*/
-	getProductionEnvironmentId() {
-		for (const env of Object.values(this.manifest.environments)) if (env.isProd) return env.id;
-		return null;
-	}
-	/**
-	* Get environment by ID
-	*/
-	getEnvironment(environmentId) {
-		return this.manifest.environments[environmentId] ?? null;
-	}
-	/**
-	* Get config by ID
-	*/
-	getConfig(configId) {
-		return this.manifest.configs[configId] ?? null;
-	}
-	/**
-	* Route a request to the appropriate variant version (first match wins)
-	*/
-	route(configIdOrSlug, environmentId, context = {}) {
-		const configId = this.resolveConfigId(configIdOrSlug);
-		if (!configId) return null;
-		const rules = this.manifest.routingTable[configId]?.[environmentId];
-		if (!rules || rules.length === 0) return null;
-		const evalContext = {
-			...context,
-			timestamp: context.timestamp ?? Date.now()
-		};
-		for (const rule of rules) {
-			if (!rule.enabled) continue;
-			if (rule.conditions) try {
-				if (!json_logic_js.default.apply(rule.conditions, evalContext)) continue;
-			} catch (error) {
-				console.warn(`JSONLogic evaluation error for rule ${rule.id}:`, error);
-				continue;
-			}
-			return {
-				configId,
-				environmentId,
-				variantId: rule.resolvedVersion.variantId,
-				version: rule.resolvedVersion,
-				rule
-			};
-		}
-		return null;
-	}
-	/**
-	* Route with weighted random selection among matching rules of same priority
-	*/
-	routeWithWeights(configIdOrSlug, environmentId, context = {}) {
-		const configId = this.resolveConfigId(configIdOrSlug);
-		if (!configId) return null;
-		const rules = this.manifest.routingTable[configId]?.[environmentId];
-		if (!rules || rules.length === 0) return null;
-		const evalContext = {
-			...context,
-			timestamp: context.timestamp ?? Date.now()
-		};
-		const rulesByPriority = /* @__PURE__ */ new Map();
-		for (const rule$1 of rules) {
-			if (!rule$1.enabled) continue;
-			if (rule$1.conditions) try {
-				if (!json_logic_js.default.apply(rule$1.conditions, evalContext)) continue;
-			} catch {
-				continue;
-			}
-			const list = rulesByPriority.get(rule$1.priority) || [];
-			list.push(rule$1);
-			rulesByPriority.set(rule$1.priority, list);
+function createPgStore(connectionString, options) {
+	const schema = options?.schema ?? "llmops";
+	let pool;
+	try {
+		pool = new (require("pg")).Pool({ connectionString });
+	} catch {
+		throw new Error("pgStore requires the \"pg\" package. Install it with: pnpm add pg");
+	}
+	const db = new kysely.Kysely({ dialect: new kysely.PostgresDialect({
+		pool,
+		onCreateConnection: async (connection) => {
+			await connection.executeQuery(kysely.CompiledQuery.raw(`SET search_path TO "${schema}"`));
 		}
-		const priorities = Array.from(rulesByPriority.keys()).sort((a, b) => b - a);
-		if (priorities.length === 0) return null;
-		const topPriorityRules = rulesByPriority.get(priorities[0]);
-		if (topPriorityRules.length === 1) {
-			const rule$1 = topPriorityRules[0];
-			return {
-				configId,
-				environmentId,
-				variantId: rule$1.resolvedVersion.variantId,
-				version: rule$1.resolvedVersion,
-				rule: rule$1
-			};
-		}
-		const totalWeight = topPriorityRules.reduce((sum, r) => sum + r.weight, 0);
-		if (totalWeight === 0) return null;
-		let random = Math.random() * totalWeight;
-		for (const rule$1 of topPriorityRules) {
-			random -= rule$1.weight;
-			if (random <= 0) return {
-				configId,
-				environmentId,
-				variantId: rule$1.resolvedVersion.variantId,
-				version: rule$1.resolvedVersion,
-				rule: rule$1
-			};
-		}
-		const rule = topPriorityRules[0];
-		return {
-			configId,
-			environmentId,
-			variantId: rule.resolvedVersion.variantId,
-			version: rule.resolvedVersion,
-			rule
-		};
-	}
-};
+	}) });
+	const llmRequests = createLLMRequestsDataLayer(db);
+	const traces = createTracesDataLayer(db);
+	require_db.logger.debug(`pgStore: initialized with schema "${schema}"`);
+	return {
+		...llmRequests,
+		...traces,
+		_db: db
+	};
+}
 
 //#endregion
 exports.COST_SUMMARY_GROUP_BY = COST_SUMMARY_GROUP_BY;
@@ -4371,9 +2801,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.ManifestRouter = ManifestRouter;
-exports.ManifestService = ManifestService;
 exports.MemoryCacheBackend = MemoryCacheBackend;
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.SupportedProviders = SupportedProviders;
@@ -4382,26 +2809,17 @@ exports.calculateCost = calculateCost;
 exports.chatCompletionCreateParamsBaseSchema = chatCompletionCreateParamsBaseSchema;
 exports.configVariantsSchema = require_db.configVariantsSchema;
 exports.configsSchema = require_db.configsSchema;
-exports.createConfigDataLayer = createConfigDataLayer;
-exports.createConfigVariantDataLayer = createConfigVariantDataLayer;
 exports.createDataLayer = createDataLayer;
 exports.createDatabase = require_db.createDatabase;
 exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
 exports.createDatasetsDataLayer = createDatasetsDataLayer;
-exports.createEnvironmentDataLayer = createEnvironmentDataLayer;
-exports.createEnvironmentSecretDataLayer = createEnvironmentSecretDataLayer;
-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.createTargetingRulesDataLayer = createTargetingRulesDataLayer;
 exports.createTracesDataLayer = createTracesDataLayer;
-exports.createVariantDataLayer = createVariantDataLayer;
-exports.createVariantVersionsDataLayer = createVariantVersionsDataLayer;
 exports.createWorkspaceSettingsDataLayer = createWorkspaceSettingsDataLayer;
 exports.datasetRecordsSchema = require_db.datasetRecordsSchema;
 exports.datasetVersionRecordsSchema = require_db.datasetVersionRecordsSchema;
@@ -4420,7 +2838,6 @@ Object.defineProperty(exports, 'gateway', {
   }
 });
 exports.generateId = generateId;
-exports.getAuthClientOptions = require_db.getAuthClientOptions;
 exports.getDefaultPricingProvider = getDefaultPricingProvider;
 exports.getDefaultProviders = getDefaultProviders;
 exports.getMigrations = require_db.getMigrations;