@llmops/core 0.2.13 → 0.3.0-beta.1

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('./db-BOe6mM51.cjs');
-const require_neon_dialect = require('./neon-dialect-BQey5lUw.cjs');
+const require_db = require('./db-Du2xmkGS.cjs');
+const require_neon_dialect = require('./neon-dialect-BR1nZmKX.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
 let kysely = require("kysely");
@@ -9,6 +9,8 @@ let node_path = require("node:path");
 node_path = require_db.__toESM(node_path);
 let __better_auth_utils_random = require("@better-auth/utils/random");
 let node_crypto = require("node:crypto");
+let json_logic_js = require("json-logic-js");
+json_logic_js = require_db.__toESM(json_logic_js);
 
 //#region src/providers/supported-providers.ts
 /**
@@ -840,7 +842,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}`);
 		}
@@ -1229,9 +1234,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}`);
@@ -1267,7 +1272,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;
@@ -1798,20 +1803,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}-${(0, node_crypto.randomUUID)().slice(0, 8)}`;
+}
 const createProviderConfig = require_db.zod_default.object({
 	providerId: require_db.zod_default.string().min(1),
+	slug: require_db.zod_default.string().nullable().optional(),
 	name: require_db.zod_default.string().nullable().optional(),
 	config: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()),
 	enabled: require_db.zod_default.boolean().optional().default(true)
 });
 const updateProviderConfig = require_db.zod_default.object({
 	id: require_db.zod_default.uuidv4(),
+	slug: require_db.zod_default.string().nullable().optional(),
 	name: require_db.zod_default.string().nullable().optional(),
 	config: require_db.zod_default.record(require_db.zod_default.string(), require_db.zod_default.unknown()).optional(),
 	enabled: require_db.zod_default.boolean().optional()
 });
 const getProviderConfigById = require_db.zod_default.object({ id: require_db.zod_default.uuidv4() });
 const getProviderConfigByProviderId = require_db.zod_default.object({ providerId: require_db.zod_default.string().min(1) });
+const getProviderConfigBySlug = require_db.zod_default.object({ slug: require_db.zod_default.string().min(1) });
 const deleteProviderConfig = require_db.zod_default.object({ id: require_db.zod_default.uuidv4() });
 const listProviderConfigs = require_db.zod_default.object({
 	limit: require_db.zod_default.number().int().positive().optional(),
@@ -1822,10 +1847,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: (0, node_crypto.randomUUID)(),
 				providerId,
+				slug: finalSlug,
 				name: name ?? null,
 				config: JSON.stringify(config),
 				enabled,
@@ -1836,8 +1863,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;
@@ -1855,6 +1883,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}`);
@@ -1874,17 +1908,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: (0, node_crypto.randomUUID)(),
 				providerId,
+				slug: finalSlug,
 				name: name ?? null,
 				config: JSON.stringify(config),
 				enabled,
@@ -2580,10 +2620,341 @@ function getDefaultPricingProvider() {
 	return defaultProvider;
 }
 
+//#endregion
+//#region src/manifest/builder.ts
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Builds the gateway routing manifest from database
+*/
+var ManifestBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Build the complete routing manifest from database
+	*/
+	async build() {
+		const [configs, environments, environmentSecrets, targetingRules, configVariants, variantVersions, providerConfigs] = 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 = require_db.logger.child({ module: "ManifestService" });
+var ManifestService = class {
+	builder;
+	constructor(cache, db, ttlMs = DEFAULT_TTL_MS) {
+		this.cache = cache;
+		this.ttlMs = ttlMs;
+		this.builder = new ManifestBuilder(db);
+		log.debug({ ttlMs }, "ManifestService initialized");
+	}
+	/**
+	* Get the current manifest, building if necessary
+	*/
+	async getManifest() {
+		log.debug("Getting manifest from cache or building");
+		const manifest = await this.cache.getOrSet(MANIFEST_CACHE_KEY, async () => {
+			log.info("Building new manifest");
+			const built = await this.builder.build();
+			log.info({
+				version: built.version,
+				configCount: Object.keys(built.configs).length,
+				environmentCount: Object.keys(built.environments).length
+			}, "Manifest built successfully");
+			return built;
+		}, {
+			namespace: MANIFEST_NAMESPACE,
+			ttl: this.ttlMs
+		});
+		log.debug({ version: manifest.version }, "Manifest retrieved");
+		return manifest;
+	}
+	/**
+	* Force invalidate the manifest (called on mutations)
+	*/
+	async invalidate() {
+		log.info("Invalidating manifest cache");
+		await this.cache.delete(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE);
+	}
+	/**
+	* Invalidate and immediately rebuild (atomic refresh)
+	*/
+	async refresh() {
+		log.info("Refreshing manifest (invalidate + rebuild)");
+		await this.invalidate();
+		return this.getManifest();
+	}
+	/**
+	* Get manifest version without fetching full manifest
+	* Useful for checking if manifest is stale
+	*/
+	async getVersion() {
+		const version = (await this.cache.get(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE))?.version ?? null;
+		log.debug({ version }, "Got manifest version");
+		return version;
+	}
+	/**
+	* Check if manifest exists in cache
+	*/
+	async hasManifest() {
+		const exists = await this.cache.has(MANIFEST_CACHE_KEY, MANIFEST_NAMESPACE);
+		log.debug({ exists }, "Checked manifest existence");
+		return exists;
+	}
+};
+
+//#endregion
+//#region src/manifest/router.ts
+/**
+* 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 (!json_logic_js.default.apply(rule.conditions, evalContext)) continue;
+			} catch (error) {
+				console.warn(`JSONLogic evaluation error for rule ${rule.id}:`, error);
+				continue;
+			}
+			return {
+				configId,
+				environmentId,
+				variantId: rule.resolvedVersion.variantId,
+				version: rule.resolvedVersion,
+				rule
+			};
+		}
+		return null;
+	}
+	/**
+	* Route with weighted random selection among matching rules of same priority
+	*/
+	routeWithWeights(configIdOrSlug, environmentId, context = {}) {
+		const configId = this.resolveConfigId(configIdOrSlug);
+		if (!configId) return null;
+		const rules = this.manifest.routingTable[configId]?.[environmentId];
+		if (!rules || rules.length === 0) return null;
+		const evalContext = {
+			...context,
+			timestamp: context.timestamp ?? Date.now()
+		};
+		const rulesByPriority = /* @__PURE__ */ new Map();
+		for (const rule$1 of rules) {
+			if (!rule$1.enabled) continue;
+			if (rule$1.conditions) try {
+				if (!json_logic_js.default.apply(rule$1.conditions, evalContext)) continue;
+			} catch {
+				continue;
+			}
+			const list = rulesByPriority.get(rule$1.priority) || [];
+			list.push(rule$1);
+			rulesByPriority.set(rule$1.priority, list);
+		}
+		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
 exports.CacheService = CacheService;
 exports.FileCacheBackend = FileCacheBackend;
 exports.MS = MS;
+exports.ManifestBuilder = ManifestBuilder;
+exports.ManifestRouter = ManifestRouter;
+exports.ManifestService = ManifestService;
 exports.MemoryCacheBackend = MemoryCacheBackend;
 exports.ModelsDevPricingProvider = ModelsDevPricingProvider;
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;