@llmops/core 0.1.0-beta.11 → 0.1.0-beta.13

package/dist/index.cjs

@@ -0,0 +1,1385 @@
+const require_db = require('./db-CUPUfhtT.cjs');
+let __llmops_gateway = require("@llmops/gateway");
+__llmops_gateway = require_db.__toESM(__llmops_gateway);
+let pino = require("pino");
+pino = require_db.__toESM(pino);
+let __better_auth_utils_random = require("@better-auth/utils/random");
+let node_crypto = require("node:crypto");
+
+//#region src/providers/supported-providers.ts
+/**
+* Supported providers - derived from @llmops/gateway providers
+* @see packages/gateway/src/providers/index.ts
+*/
+let SupportedProviders = /* @__PURE__ */ function(SupportedProviders$1) {
+	SupportedProviders$1["OPENAI"] = "openai";
+	SupportedProviders$1["COHERE"] = "cohere";
+	SupportedProviders$1["ANTHROPIC"] = "anthropic";
+	SupportedProviders$1["AZURE_OPENAI"] = "azure-openai";
+	SupportedProviders$1["HUGGINGFACE"] = "huggingface";
+	SupportedProviders$1["ANYSCALE"] = "anyscale";
+	SupportedProviders$1["PALM"] = "palm";
+	SupportedProviders$1["TOGETHER_AI"] = "together-ai";
+	SupportedProviders$1["GOOGLE"] = "google";
+	SupportedProviders$1["VERTEX_AI"] = "vertex-ai";
+	SupportedProviders$1["PERPLEXITY_AI"] = "perplexity-ai";
+	SupportedProviders$1["MISTRAL_AI"] = "mistral-ai";
+	SupportedProviders$1["DEEPINFRA"] = "deepinfra";
+	SupportedProviders$1["NCOMPASS"] = "ncompass";
+	SupportedProviders$1["STABILITY_AI"] = "stability-ai";
+	SupportedProviders$1["NOMIC"] = "nomic";
+	SupportedProviders$1["OLLAMA"] = "ollama";
+	SupportedProviders$1["AI21"] = "ai21";
+	SupportedProviders$1["BEDROCK"] = "bedrock";
+	SupportedProviders$1["GROQ"] = "groq";
+	SupportedProviders$1["SEGMIND"] = "segmind";
+	SupportedProviders$1["JINA"] = "jina";
+	SupportedProviders$1["FIREWORKS_AI"] = "fireworks-ai";
+	SupportedProviders$1["WORKERS_AI"] = "workers-ai";
+	SupportedProviders$1["REKA_AI"] = "reka-ai";
+	SupportedProviders$1["MOONSHOT"] = "moonshot";
+	SupportedProviders$1["OPENROUTER"] = "openrouter";
+	SupportedProviders$1["LINGYI"] = "lingyi";
+	SupportedProviders$1["ZHIPU"] = "zhipu";
+	SupportedProviders$1["NOVITA_AI"] = "novita-ai";
+	SupportedProviders$1["MONSTERAPI"] = "monsterapi";
+	SupportedProviders$1["DEEPSEEK"] = "deepseek";
+	SupportedProviders$1["PREDIBASE"] = "predibase";
+	SupportedProviders$1["TRITON"] = "triton";
+	SupportedProviders$1["VOYAGE"] = "voyage";
+	SupportedProviders$1["AZURE_AI"] = "azure-ai";
+	SupportedProviders$1["GITHUB"] = "github";
+	SupportedProviders$1["DEEPBRICKS"] = "deepbricks";
+	SupportedProviders$1["SILICONFLOW"] = "siliconflow";
+	SupportedProviders$1["CEREBRAS"] = "cerebras";
+	SupportedProviders$1["INFERENCE_NET"] = "inference-net";
+	SupportedProviders$1["SAMBANOVA"] = "sambanova";
+	SupportedProviders$1["LEMONFOX_AI"] = "lemonfox-ai";
+	SupportedProviders$1["UPSTAGE"] = "upstage";
+	SupportedProviders$1["LAMBDA"] = "lambda";
+	SupportedProviders$1["DASHSCOPE"] = "dashscope";
+	SupportedProviders$1["X_AI"] = "x-ai";
+	SupportedProviders$1["QDRANT"] = "qdrant";
+	SupportedProviders$1["SAGEMAKER"] = "sagemaker";
+	SupportedProviders$1["NEBIUS"] = "nebius";
+	SupportedProviders$1["RECRAFT_AI"] = "recraft-ai";
+	SupportedProviders$1["MILVUS"] = "milvus";
+	SupportedProviders$1["REPLICATE"] = "replicate";
+	SupportedProviders$1["LEPTON"] = "lepton";
+	SupportedProviders$1["KLUSTER_AI"] = "kluster-ai";
+	SupportedProviders$1["NSCALE"] = "nscale";
+	SupportedProviders$1["HYPERBOLIC"] = "hyperbolic";
+	SupportedProviders$1["BYTEZ"] = "bytez";
+	SupportedProviders$1["FEATHERLESS_AI"] = "featherless-ai";
+	SupportedProviders$1["KRUTRIM"] = "krutrim";
+	SupportedProviders$1["AI302"] = "302ai";
+	SupportedProviders$1["COMETAPI"] = "cometapi";
+	SupportedProviders$1["MATTERAI"] = "matterai";
+	SupportedProviders$1["MESHY"] = "meshy";
+	SupportedProviders$1["NEXTBIT"] = "nextbit";
+	SupportedProviders$1["TRIPO3D"] = "tripo3d";
+	SupportedProviders$1["MODAL"] = "modal";
+	SupportedProviders$1["Z_AI"] = "z-ai";
+	SupportedProviders$1["ORACLE"] = "oracle";
+	SupportedProviders$1["IOINTELLIGENCE"] = "iointelligence";
+	SupportedProviders$1["AIBADGR"] = "aibadgr";
+	return SupportedProviders$1;
+}({});
+
+//#endregion
+//#region src/schemas/openai.ts
+const chatCompletionContentPartTextSchema = require_db.object({
+	text: require_db.string(),
+	type: require_db.literal("text")
+});
+const chatCompletionContentPartImageSchema = require_db.object({
+	image_url: require_db.object({
+		url: require_db.string(),
+		detail: require_db._enum([
+			"auto",
+			"low",
+			"high"
+		]).optional()
+	}),
+	type: require_db.literal("image_url")
+});
+const chatCompletionContentPartInputAudioSchema = require_db.object({
+	input_audio: require_db.object({
+		data: require_db.string(),
+		format: require_db._enum(["wav", "mp3"])
+	}),
+	type: require_db.literal("input_audio")
+});
+const chatCompletionContentPartFileSchema = require_db.object({
+	file: require_db.object({
+		file_data: require_db.string().optional(),
+		file_id: require_db.string().optional(),
+		filename: require_db.string().optional()
+	}),
+	type: require_db.literal("file")
+});
+const chatCompletionContentPartRefusalSchema = require_db.object({
+	refusal: require_db.string(),
+	type: require_db.literal("refusal")
+});
+const chatCompletionContentPartSchema = require_db.union([
+	chatCompletionContentPartTextSchema,
+	chatCompletionContentPartImageSchema,
+	chatCompletionContentPartInputAudioSchema,
+	chatCompletionContentPartFileSchema
+]);
+const chatCompletionDeveloperMessageParamSchema = require_db.object({
+	content: require_db.union([require_db.string(), require_db.array(chatCompletionContentPartTextSchema)]),
+	role: require_db.literal("developer"),
+	name: require_db.string().optional()
+});
+const chatCompletionSystemMessageParamSchema = require_db.object({
+	content: require_db.union([require_db.string(), require_db.array(chatCompletionContentPartTextSchema)]),
+	role: require_db.literal("system"),
+	name: require_db.string().optional()
+});
+const chatCompletionUserMessageParamSchema = require_db.object({
+	content: require_db.union([require_db.string(), require_db.array(chatCompletionContentPartSchema)]),
+	role: require_db.literal("user"),
+	name: require_db.string().optional()
+});
+const chatCompletionMessageToolCallSchema = require_db.object({
+	id: require_db.string(),
+	function: require_db.object({
+		arguments: require_db.string(),
+		name: require_db.string()
+	}),
+	type: require_db.literal("function")
+});
+const chatCompletionAssistantMessageParamSchema = require_db.object({
+	role: require_db.literal("assistant"),
+	audio: require_db.object({ id: require_db.string() }).optional().nullable(),
+	content: require_db.union([require_db.string(), require_db.array(require_db.union([chatCompletionContentPartTextSchema, chatCompletionContentPartRefusalSchema]))]).optional().nullable(),
+	function_call: require_db.object({
+		arguments: require_db.string(),
+		name: require_db.string()
+	}).optional().nullable(),
+	name: require_db.string().optional(),
+	refusal: require_db.string().optional().nullable(),
+	tool_calls: require_db.array(chatCompletionMessageToolCallSchema).optional()
+});
+const chatCompletionToolMessageParamSchema = require_db.object({
+	content: require_db.union([require_db.string(), require_db.array(chatCompletionContentPartTextSchema)]),
+	role: require_db.literal("tool"),
+	tool_call_id: require_db.string()
+});
+const chatCompletionFunctionMessageParamSchema = require_db.object({
+	content: require_db.string().nullable(),
+	name: require_db.string(),
+	role: require_db.literal("function")
+});
+const chatCompletionMessageParamSchema = require_db.union([
+	chatCompletionDeveloperMessageParamSchema,
+	chatCompletionSystemMessageParamSchema,
+	chatCompletionUserMessageParamSchema,
+	chatCompletionAssistantMessageParamSchema,
+	chatCompletionToolMessageParamSchema,
+	chatCompletionFunctionMessageParamSchema
+]);
+const functionDefinitionSchema = require_db.object({
+	name: require_db.string(),
+	description: require_db.string().optional(),
+	parameters: require_db.record(require_db.string(), require_db.any()).optional()
+});
+const chatCompletionFunctionToolSchema = require_db.object({
+	function: functionDefinitionSchema,
+	type: require_db.literal("function")
+});
+const chatCompletionCustomToolSchema = require_db.object({
+	custom: require_db.object({
+		name: require_db.string(),
+		description: require_db.string().optional(),
+		format: require_db.union([require_db.object({ type: require_db.literal("text") }), require_db.object({
+			grammar: require_db.object({
+				definition: require_db.string(),
+				syntax: require_db._enum(["lark", "regex"])
+			}),
+			type: require_db.literal("grammar")
+		})]).optional()
+	}),
+	type: require_db.literal("custom")
+});
+const chatCompletionToolSchema = require_db.union([chatCompletionFunctionToolSchema, chatCompletionCustomToolSchema]);
+const chatCompletionNamedToolChoiceSchema = require_db.object({
+	function: require_db.object({ name: require_db.string() }),
+	type: require_db.literal("function")
+});
+const chatCompletionNamedToolChoiceCustomSchema = require_db.object({
+	custom: require_db.object({ name: require_db.string() }),
+	type: require_db.literal("custom")
+});
+const chatCompletionAllowedToolChoiceSchema = require_db.object({
+	allowed_tools: require_db.object({
+		mode: require_db._enum(["auto", "required"]),
+		tools: require_db.array(require_db.record(require_db.string(), require_db.unknown()))
+	}),
+	type: require_db.literal("allowed_tools")
+});
+const chatCompletionToolChoiceOptionSchema = require_db.union([
+	require_db._enum([
+		"none",
+		"auto",
+		"required"
+	]),
+	chatCompletionAllowedToolChoiceSchema,
+	chatCompletionNamedToolChoiceSchema,
+	chatCompletionNamedToolChoiceCustomSchema
+]);
+const chatCompletionAudioParamSchema = require_db.object({
+	format: require_db._enum([
+		"wav",
+		"aac",
+		"mp3",
+		"flac",
+		"opus",
+		"pcm16"
+	]),
+	voice: require_db.union([require_db.string(), require_db._enum([
+		"alloy",
+		"ash",
+		"ballad",
+		"coral",
+		"echo",
+		"sage",
+		"shimmer",
+		"verse",
+		"marin",
+		"cedar"
+	])])
+});
+const chatCompletionStreamOptionsSchema = require_db.object({
+	include_obfuscation: require_db.boolean().optional(),
+	include_usage: require_db.boolean().optional()
+});
+const chatCompletionPredictionContentSchema = require_db.object({
+	content: require_db.union([require_db.string(), require_db.array(chatCompletionContentPartTextSchema)]),
+	type: require_db.literal("content")
+});
+const responseFormatTextSchema = require_db.object({ type: require_db.literal("text") });
+const responseFormatJSONObjectSchema = require_db.object({ type: require_db.literal("json_object") });
+const responseFormatJSONSchemaSchema = require_db.object({
+	type: require_db.literal("json_schema"),
+	json_schema: require_db.object({
+		name: require_db.string(),
+		description: require_db.string().optional(),
+		schema: require_db.record(require_db.string(), require_db.any()).optional(),
+		strict: require_db.boolean().optional()
+	})
+});
+const responseFormatSchema = require_db.union([
+	responseFormatTextSchema,
+	responseFormatJSONObjectSchema,
+	responseFormatJSONSchemaSchema
+]);
+const webSearchUserLocationSchema = require_db.object({
+	approximate: require_db.object({
+		city: require_db.string().optional(),
+		country: require_db.string().optional(),
+		region: require_db.string().optional(),
+		timezone: require_db.string().optional()
+	}),
+	type: require_db.literal("approximate")
+});
+const webSearchOptionsSchema = require_db.object({
+	search_context_size: require_db._enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	user_location: webSearchUserLocationSchema.optional().nullable()
+});
+const chatCompletionCreateParamsBaseSchema = require_db.object({
+	messages: require_db.array(chatCompletionMessageParamSchema),
+	model: require_db.string(),
+	audio: chatCompletionAudioParamSchema.optional().nullable(),
+	frequency_penalty: require_db.number().min(-2).max(2).optional().nullable(),
+	function_call: require_db.union([require_db._enum(["none", "auto"]), require_db.object({ name: require_db.string() })]).optional(),
+	functions: require_db.array(require_db.object({
+		name: require_db.string(),
+		description: require_db.string().optional(),
+		parameters: require_db.record(require_db.string(), require_db.any()).optional()
+	})).optional(),
+	logit_bias: require_db.record(require_db.string(), require_db.number().min(-100).max(100)).optional().nullable(),
+	logprobs: require_db.boolean().optional().nullable(),
+	max_completion_tokens: require_db.number().positive().optional().nullable(),
+	max_tokens: require_db.number().positive().optional().nullable(),
+	metadata: require_db.record(require_db.string(), require_db.string()).optional().nullable(),
+	modalities: require_db.array(require_db._enum(["text", "audio"])).optional().nullable(),
+	n: require_db.number().positive().optional().nullable(),
+	parallel_tool_calls: require_db.boolean().optional(),
+	prediction: chatCompletionPredictionContentSchema.optional().nullable(),
+	presence_penalty: require_db.number().min(-2).max(2).optional().nullable(),
+	prompt_cache_key: require_db.string().optional(),
+	prompt_cache_retention: require_db._enum(["in-memory", "24h"]).optional().nullable(),
+	reasoning_effort: require_db._enum([
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]).optional().nullable(),
+	response_format: responseFormatSchema.optional(),
+	safety_identifier: require_db.string().optional(),
+	seed: require_db.number().optional().nullable(),
+	service_tier: require_db._enum([
+		"auto",
+		"default",
+		"flex",
+		"scale",
+		"priority"
+	]).optional().nullable(),
+	stop: require_db.union([require_db.string(), require_db.array(require_db.string())]).optional().nullable(),
+	store: require_db.boolean().optional().nullable(),
+	stream: require_db.boolean().optional().nullable(),
+	stream_options: chatCompletionStreamOptionsSchema.optional().nullable(),
+	temperature: require_db.number().min(0).max(2).optional().nullable(),
+	tool_choice: chatCompletionToolChoiceOptionSchema.optional(),
+	tools: require_db.array(chatCompletionToolSchema).optional(),
+	top_logprobs: require_db.number().min(0).max(20).optional().nullable(),
+	top_p: require_db.number().min(0).max(1).optional().nullable(),
+	user: require_db.string().optional(),
+	verbosity: require_db._enum([
+		"low",
+		"medium",
+		"high"
+	]).optional().nullable(),
+	web_search_options: webSearchOptionsSchema.optional()
+});
+/**
+* Schema for variant jsonData - these are the parameters that can be
+* configured per variant to override the default chat completion settings.
+* This is a subset of ChatCompletionCreateParamsBase that makes sense to
+* configure at the variant level (excludes messages which come from the request).
+*/
+const variantJsonDataSchema = require_db.object({
+	system_prompt: require_db.string().optional(),
+	model: require_db.string().optional(),
+	audio: chatCompletionAudioParamSchema.optional().nullable(),
+	frequency_penalty: require_db.number().min(-2).max(2).optional().nullable(),
+	function_call: require_db.union([require_db._enum(["none", "auto"]), require_db.object({ name: require_db.string() })]).optional(),
+	functions: require_db.array(require_db.object({
+		name: require_db.string(),
+		description: require_db.string().optional(),
+		parameters: require_db.record(require_db.string(), require_db.any()).optional()
+	})).optional(),
+	logit_bias: require_db.record(require_db.string(), require_db.number().min(-100).max(100)).optional().nullable(),
+	logprobs: require_db.boolean().optional().nullable(),
+	max_completion_tokens: require_db.number().positive().optional().nullable(),
+	max_tokens: require_db.number().positive().optional().nullable(),
+	metadata: require_db.record(require_db.string(), require_db.string()).optional().nullable(),
+	modalities: require_db.array(require_db._enum(["text", "audio"])).optional().nullable(),
+	n: require_db.number().positive().optional().nullable(),
+	parallel_tool_calls: require_db.boolean().optional(),
+	prediction: chatCompletionPredictionContentSchema.optional().nullable(),
+	presence_penalty: require_db.number().min(-2).max(2).optional().nullable(),
+	prompt_cache_key: require_db.string().optional(),
+	prompt_cache_retention: require_db._enum(["in-memory", "24h"]).optional().nullable(),
+	reasoning_effort: require_db._enum([
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]).optional().nullable(),
+	response_format: responseFormatSchema.optional(),
+	safety_identifier: require_db.string().optional(),
+	seed: require_db.number().optional().nullable(),
+	service_tier: require_db._enum([
+		"auto",
+		"default",
+		"flex",
+		"scale",
+		"priority"
+	]).optional().nullable(),
+	stop: require_db.union([require_db.string(), require_db.array(require_db.string())]).optional().nullable(),
+	store: require_db.boolean().optional().nullable(),
+	stream: require_db.boolean().optional().nullable(),
+	stream_options: chatCompletionStreamOptionsSchema.optional().nullable(),
+	temperature: require_db.number().min(0).max(2).optional().nullable(),
+	tool_choice: chatCompletionToolChoiceOptionSchema.optional(),
+	tools: require_db.array(chatCompletionToolSchema).optional(),
+	top_logprobs: require_db.number().min(0).max(20).optional().nullable(),
+	top_p: require_db.number().min(0).max(1).optional().nullable(),
+	user: require_db.string().optional(),
+	verbosity: require_db._enum([
+		"low",
+		"medium",
+		"high"
+	]).optional().nullable(),
+	web_search_options: webSearchOptionsSchema.optional()
+});
+
+//#endregion
+//#region src/schemas/config.ts
+/**
+* Provider configuration schema
+*
+* This is a flexible schema that allows any provider configuration.
+* The actual provider validation happens at the gateway level.
+* Uses passthrough() to allow provider-specific options.
+*/
+const providerConfigSchema = require_db.object({
+	apiKey: require_db.string().min(1, "API key is required"),
+	customHost: require_db.string().optional(),
+	requestTimeout: require_db.number().optional(),
+	forwardHeaders: require_db.array(require_db.string()).optional()
+}).passthrough();
+/**
+* Build a partial object schema from SupportedProviders enum
+* Each provider key is optional, allowing users to configure only the providers they need
+*/
+const providerEntries = Object.values(SupportedProviders).map((provider) => [provider, providerConfigSchema.optional()]);
+/**
+* Providers configuration - maps supported provider names to their configs
+* All providers are optional, but at least one must be configured
+*/
+const providersSchema = require_db.object(Object.fromEntries(providerEntries)).refine((providers) => Object.values(providers).some((v) => v !== void 0 && v !== null), "At least one provider must be configured");
+const authSchema = require_db.object({
+	type: require_db.literal("basic"),
+	defaultUser: require_db.string(),
+	defaultPassword: require_db.string()
+});
+const llmopsConfigSchema = require_db.object({
+	database: require_db.any(),
+	auth: authSchema,
+	basePath: require_db.string().min(1, "Base path is required and cannot be empty").refine((path) => path.startsWith("/"), "Base path must start with a forward slash"),
+	providers: providersSchema
+});
+function validateLLMOpsConfig(config) {
+	const result = llmopsConfigSchema.safeParse(config);
+	if (!result.success) {
+		const errorMessages = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
+		throw new Error(`LLMOps configuration validation failed:\n${errorMessages}`);
+	}
+	return result.data;
+}
+
+//#endregion
+//#region src/utils/logger.ts
+const logger = (0, pino.default)();
+
+//#endregion
+//#region src/utils/id.ts
+const generateId = (size) => {
+	return (0, __better_auth_utils_random.createRandomStringGenerator)("a-z", "A-Z", "0-9")(size || 32);
+};
+
+//#endregion
+//#region src/error/index.ts
+var LLMOpsError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = "LLMOpsError";
+		this.message = message;
+		this.cause = cause;
+		this.stack = "";
+	}
+};
+
+//#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
+			}));
+			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
+				};
+			});
+		}
+	};
+};
+
+//#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 = /^[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.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}`);
+			return versionData;
+		}
+	};
+};
+
+//#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/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/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/index.ts
+const createDataLayer = async (db) => {
+	return {
+		...createConfigDataLayer(db),
+		...createConfigVariantDataLayer(db),
+		...createEnvironmentDataLayer(db),
+		...createEnvironmentSecretDataLayer(db),
+		...createTargetingRulesDataLayer(db),
+		...createVariantDataLayer(db),
+		...createVariantVersionsDataLayer(db)
+	};
+};
+
+//#endregion
+exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
+exports.SupportedProviders = SupportedProviders;
+exports.chatCompletionCreateParamsBaseSchema = chatCompletionCreateParamsBaseSchema;
+exports.configVariantsSchema = require_db.configVariantsSchema;
+exports.configsSchema = require_db.configsSchema;
+exports.createDataLayer = createDataLayer;
+exports.createDatabase = require_db.createDatabase;
+exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
+exports.detectDatabaseType = require_db.detectDatabaseType;
+exports.environmentSecretsSchema = require_db.environmentSecretsSchema;
+exports.environmentsSchema = require_db.environmentsSchema;
+Object.defineProperty(exports, 'gateway', {
+  enumerable: true,
+  get: function () {
+    return __llmops_gateway.default;
+  }
+});
+exports.generateId = generateId;
+exports.llmopsConfigSchema = llmopsConfigSchema;
+exports.logger = logger;
+exports.parsePartialTableData = require_db.parsePartialTableData;
+exports.parseTableData = require_db.parseTableData;
+exports.schemas = require_db.schemas;
+exports.targetingRulesSchema = require_db.targetingRulesSchema;
+exports.validateLLMOpsConfig = validateLLMOpsConfig;
+exports.validatePartialTableData = require_db.validatePartialTableData;
+exports.validateTableData = require_db.validateTableData;
+exports.variantJsonDataSchema = variantJsonDataSchema;
+exports.variantVersionsSchema = require_db.variantVersionsSchema;
+exports.variantsSchema = require_db.variantsSchema;