@llmops/core 0.2.13 → 0.3.0-beta.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as literal, C as variantsSchema, D as any, E as _enum, F as union, I as unknown, M as object, N as record, O as array, P as string, S as variantVersionsSchema, T as zod_default, _ as environmentsSchema, a as matchType, b as schemas, c as logger, d as validatePartialTableData, f as validateTableData, g as environmentSecretsSchema, h as configsSchema, i as getMigrations, j as number, k as boolean, l as parsePartialTableData, m as configVariantsSchema, n as createDatabaseFromConnection, o as runAutoMigrations, p as SCHEMA_METADATA, r as detectDatabaseType, s as getAuthClientOptions, t as createDatabase, u as parseTableData, v as llmRequestsSchema, w as workspaceSettingsSchema, x as targetingRulesSchema, y as providerConfigsSchema } from "./db-DohlAqJU.mjs";
+import { A as literal, C as variantsSchema, D as any, E as _enum, F as union, I as unknown, M as object, N as record, O as array, P as string, S as variantVersionsSchema, T as zod_default, _ as environmentsSchema, a as matchType, b as schemas, c as logger, d as validatePartialTableData, f as validateTableData, g as environmentSecretsSchema, h as configsSchema, i as getMigrations, j as number, k as boolean, l as parsePartialTableData, m as configVariantsSchema, n as createDatabaseFromConnection, o as runAutoMigrations, p as SCHEMA_METADATA, r as detectDatabaseType, s as getAuthClientOptions, t as createDatabase, u as parseTableData, v as llmRequestsSchema, w as workspaceSettingsSchema, x as targetingRulesSchema, y as providerConfigsSchema } from "./db-B-EsQtOz.mjs";
 import { n as executeWithSchema, t as createNeonDialect } from "./neon-dialect-DySGBYUi.mjs";
 import gateway from "@llmops/gateway";
 import { sql } from "kysely";
@@ -6,6 +6,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { createRandomStringGenerator } from "@better-auth/utils/random";
 import { randomBytes, randomUUID } from "node:crypto";
+import jsonLogic from "json-logic-js";
 
 //#region src/providers/supported-providers.ts
 /**
@@ -837,7 +838,10 @@ var CacheService = class {
 	}
 	createBackend(config) {
 		switch (config.backend) {
-			case "memory": return new MemoryCacheBackend(config.maxSize, config.cleanupInterval);
+			case "memory": return new MemoryCacheBackend({
+				maxSize: config.maxSize,
+				cleanupIntervalMs: config.cleanupInterval
+			});
 			case "file": return new FileCacheBackend(config.dataDir, config.fileName, config.saveInterval, config.cleanupInterval);
 			default: throw new Error(`Unsupported cache backend: ${config.backend}`);
 		}
@@ -1226,9 +1230,9 @@ const createConfigVariantDataLayer = (db) => {
 			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;
+			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.test(configIdOrSlug)) resolvedConfigId = configIdOrSlug;
+			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}`);
@@ -1264,7 +1268,7 @@ const createConfigVariantDataLayer = (db) => {
 			if (!versionData) throw new LLMOpsError(`No variant version found for variant ${configVariant.variantId}`);
 			let finalProvider = versionData.provider;
 			let providerConfigId = null;
-			if (UUID_REGEX.test(versionData.provider)) {
+			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;
@@ -1795,20 +1799,40 @@ const createLLMRequestsDataLayer = (db) => {
 
 //#endregion
 //#region src/datalayer/providerConfigs.ts
+/**
+* Generate a unique slug for a provider config.
+* If the base slug already exists, appends -01, -02, etc.
+*/
+async function generateUniqueSlug(db, baseSlug) {
+	const existing = await db.selectFrom("provider_configs").select("slug").where("slug", "like", `${baseSlug}%`).execute();
+	if (existing.length === 0) return baseSlug;
+	const existingSlugs = new Set(existing.map((e) => e.slug));
+	if (!existingSlugs.has(baseSlug)) return baseSlug;
+	let counter = 1;
+	while (counter < 100) {
+		const candidateSlug = `${baseSlug}-${counter.toString().padStart(2, "0")}`;
+		if (!existingSlugs.has(candidateSlug)) return candidateSlug;
+		counter++;
+	}
+	return `${baseSlug}-${randomUUID().slice(0, 8)}`;
+}
 const createProviderConfig = zod_default.object({
 	providerId: zod_default.string().min(1),
+	slug: zod_default.string().nullable().optional(),
 	name: zod_default.string().nullable().optional(),
 	config: zod_default.record(zod_default.string(), zod_default.unknown()),
 	enabled: zod_default.boolean().optional().default(true)
 });
 const updateProviderConfig = zod_default.object({
 	id: zod_default.uuidv4(),
+	slug: zod_default.string().nullable().optional(),
 	name: zod_default.string().nullable().optional(),
 	config: zod_default.record(zod_default.string(), zod_default.unknown()).optional(),
 	enabled: zod_default.boolean().optional()
 });
 const getProviderConfigById = zod_default.object({ id: zod_default.uuidv4() });
 const getProviderConfigByProviderId = zod_default.object({ providerId: zod_default.string().min(1) });
+const getProviderConfigBySlug = zod_default.object({ slug: zod_default.string().min(1) });
 const deleteProviderConfig = zod_default.object({ id: zod_default.uuidv4() });
 const listProviderConfigs = zod_default.object({
 	limit: zod_default.number().int().positive().optional(),
@@ -1819,10 +1843,12 @@ const createProviderConfigsDataLayer = (db) => {
 		createProviderConfig: async (params) => {
 			const value = await createProviderConfig.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerId, name, config, enabled } = value.data;
+			const { providerId, slug, name, config, enabled } = value.data;
+			const finalSlug = slug ?? await generateUniqueSlug(db, providerId);
 			return db.insertInto("provider_configs").values({
 				id: randomUUID(),
 				providerId,
+				slug: finalSlug,
 				name: name ?? null,
 				config: JSON.stringify(config),
 				enabled,
@@ -1833,8 +1859,9 @@ const createProviderConfigsDataLayer = (db) => {
 		updateProviderConfig: async (params) => {
 			const value = await updateProviderConfig.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { id, name, config, enabled } = value.data;
+			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;
@@ -1852,6 +1879,12 @@ const createProviderConfigsDataLayer = (db) => {
 			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}`);
@@ -1871,17 +1904,23 @@ const createProviderConfigsDataLayer = (db) => {
 		upsertProviderConfig: async (params) => {
 			const value = await createProviderConfig.safeParseAsync(params);
 			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
-			const { providerId, name, config, enabled } = value.data;
+			const { providerId, slug, name, config, enabled } = value.data;
 			const existing = await db.selectFrom("provider_configs").selectAll().where("providerId", "=", providerId).executeTakeFirst();
-			if (existing) return db.updateTable("provider_configs").set({
-				name: name ?? existing.name,
-				config: JSON.stringify(config),
-				enabled,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}).where("id", "=", existing.id).returningAll().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: randomUUID(),
 				providerId,
+				slug: finalSlug,
 				name: name ?? null,
 				config: JSON.stringify(config),
 				enabled,
@@ -2578,4 +2617,332 @@ function getDefaultPricingProvider() {
 }
 
 //#endregion
-export { CacheService, FileCacheBackend, MS, MemoryCacheBackend, ModelsDevPricingProvider, SCHEMA_METADATA, SupportedProviders, calculateCost, chatCompletionCreateParamsBaseSchema, configVariantsSchema, configsSchema, createDataLayer, createDatabase, createDatabaseFromConnection, createLLMRequestsDataLayer, createNeonDialect, createProviderConfigsDataLayer, createWorkspaceSettingsDataLayer, detectDatabaseType, dollarsToMicroDollars, environmentSecretsSchema, environmentsSchema, executeWithSchema, formatCost, gateway, generateId, getAuthClientOptions, getDefaultPricingProvider, getMigrations, llmRequestsSchema, llmopsConfigSchema, logger, matchType, microDollarsToDollars, parsePartialTableData, parseTableData, providerConfigsSchema, runAutoMigrations, schemas, targetingRulesSchema, validateLLMOpsConfig, validatePartialTableData, validateTableData, variantJsonDataSchema, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };
+//#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] = 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()
+		]);
+		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;
+		});
+		return {
+			version: Date.now(),
+			builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+			configs: manifestConfigs,
+			configsBySlug,
+			environments: manifestEnvironments,
+			environmentsBySlug,
+			routingTable,
+			secretToEnvironment
+		};
+	}
+};
+
+//#endregion
+//#region src/manifest/service.ts
+const MANIFEST_CACHE_KEY = "manifest";
+const MANIFEST_NAMESPACE = "gateway";
+const DEFAULT_TTL_MS = 300 * 1e3;
+const log = 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
+/**
+* Router for evaluating the gateway manifest and selecting variants
+*/
+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 (!jsonLogic.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 (!jsonLogic.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);
+		}
+		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
+		};
+	}
+};
+
+//#endregion
+export { CacheService, FileCacheBackend, MS, ManifestBuilder, ManifestRouter, ManifestService, MemoryCacheBackend, ModelsDevPricingProvider, SCHEMA_METADATA, SupportedProviders, calculateCost, chatCompletionCreateParamsBaseSchema, configVariantsSchema, configsSchema, createDataLayer, createDatabase, createDatabaseFromConnection, createLLMRequestsDataLayer, createNeonDialect, createProviderConfigsDataLayer, createWorkspaceSettingsDataLayer, detectDatabaseType, dollarsToMicroDollars, environmentSecretsSchema, environmentsSchema, executeWithSchema, formatCost, gateway, generateId, getAuthClientOptions, getDefaultPricingProvider, getMigrations, llmRequestsSchema, llmopsConfigSchema, logger, matchType, microDollarsToDollars, parsePartialTableData, parseTableData, providerConfigsSchema, runAutoMigrations, schemas, targetingRulesSchema, validateLLMOpsConfig, validatePartialTableData, validateTableData, variantJsonDataSchema, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };

package/dist/{neon-dialect-C0GZuGot.cjs → neon-dialect-B-Q6mmbI.cjs}

@@ -1,3 +1,3 @@
-const require_neon_dialect = require('./neon-dialect-BQey5lUw.cjs');
+const require_neon_dialect = require('./neon-dialect-BR1nZmKX.cjs');
 
 exports.createNeonDialect = require_neon_dialect.createNeonDialect;

package/dist/{neon-dialect-BQey5lUw.cjs → neon-dialect-BR1nZmKX.cjs}

@@ -1,4 +1,4 @@
-const require_db = require('./db-BOe6mM51.cjs');
+const require_db = require('./db-Du2xmkGS.cjs');
 let kysely_neon = require("kysely-neon");
 require("@neondatabase/serverless");
 

package/dist/{node-sqlite-dialect-N8j5UsT-.cjs → node-sqlite-dialect-DpdAEbyp.cjs}

@@ -1,4 +1,4 @@
-const require_db = require('./db-BOe6mM51.cjs');
+const require_db = require('./db-Du2xmkGS.cjs');
 let kysely = require("kysely");
 
 //#region src/db/node-sqlite-dialect.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmops/core",
-  "version": "0.2.13",
+  "version": "0.3.0-beta.1",
   "description": "Core LLMOps functionality and utilities",
   "type": "module",
   "license": "Apache-2.0",
@@ -51,12 +51,14 @@
     "@neondatabase/serverless": "^1.0.2",
     "better-auth": "^1.4.10",
     "hono": "^4.10.7",
+    "json-logic-js": "^2.0.5",
     "kysely": "^0.28.8",
     "kysely-neon": "^2.0.2",
     "pino": "^10.1.0",
-    "@llmops/gateway": "^0.2.13"
+    "@llmops/gateway": "^0.3.0-beta.1"
   },
   "devDependencies": {
+    "@types/json-logic-js": "^2.0.8",
     "@types/ws": "^8.18.1"
   },
   "scripts": {