@llmops/core 0.2.14 → 0.3.0-beta.1

package/dist/index.d.mts

@@ -2,6 +2,7 @@ import { $ as variantsSchema, A as ProviderConfig, B as VariantVersionsTable, C
 import gateway from "@llmops/gateway";
 import { Kysely } from "kysely";
 import pino from "pino";
+import { RulesLogic } from "json-logic-js";
 import * as zod33 from "zod";
 import z$1, { z } from "zod";
 import * as better_auth0 from "better-auth";
@@ -1392,6 +1393,9 @@ declare const getProviderConfigById: z$1.ZodObject<{
 declare const getProviderConfigByProviderId: z$1.ZodObject<{
   providerId: z$1.ZodString;
 }, z$1.core.$strip>;
+declare const getProviderConfigBySlug: z$1.ZodObject<{
+  slug: z$1.ZodString;
+}, z$1.core.$strip>;
 declare const deleteProviderConfig: z$1.ZodObject<{
   id: z$1.ZodUUID;
 }, z$1.core.$strip>;
@@ -1440,6 +1444,16 @@ declare const createProviderConfigsDataLayer: (db: Kysely<Database>) => {
     providerId: string;
     config: Record<string, unknown>;
   } | undefined>;
+  getProviderConfigBySlug: (params: z$1.infer<typeof getProviderConfigBySlug>) => Promise<{
+    slug: string | null;
+    name: string | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    enabled: boolean;
+    providerId: string;
+    config: Record<string, unknown>;
+  } | undefined>;
   deleteProviderConfig: (params: z$1.infer<typeof deleteProviderConfig>) => Promise<{
     slug: string | null;
     name: string | null;
@@ -1974,6 +1988,18 @@ declare const createDataLayer: (db: Kysely<Database>) => Promise<{
     providerId: string;
     config: Record<string, unknown>;
   } | undefined>;
+  getProviderConfigBySlug: (params: zod33.infer<zod33.ZodObject<{
+    slug: zod33.ZodString;
+  }, better_auth0.$strip>>) => Promise<{
+    slug: string | null;
+    name: string | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    enabled: boolean;
+    providerId: string;
+    config: Record<string, unknown>;
+  } | undefined>;
   deleteProviderConfig: (params: zod33.infer<zod33.ZodObject<{
     id: zod33.ZodUUID;
   }, better_auth0.$strip>>) => Promise<{
@@ -2817,4 +2843,171 @@ interface AuthClientOptions {
  */
 declare const getAuthClientOptions: (options: AuthClientOptions) => BetterAuthOptions;
 //#endregion
-export { type AnthropicProviderConfig, type AnyProviderConfig, AuthClientDatabaseConfig, AuthClientOptions, type AzureAIProviderConfig, type AzureOpenAIProviderConfig, BaseCacheConfig, type BaseProviderConfig, type BedrockProviderConfig, CacheBackend, CacheBackendType, CacheConfig, CacheEntry, CacheOptions, CacheService, CacheStats, ChatCompletionCreateParamsBase, Config, ConfigVariant, type ConfigVariantsTable, type ConfigsTable, type CortexProviderConfig, CostResult, type Database, DatabaseConnection, DatabaseOptions, DatabaseType, Environment, EnvironmentSecret, type EnvironmentSecretsTable, type EnvironmentsTable, FileCacheBackend, FileCacheConfig, type FireworksAIProviderConfig, type GoogleProviderConfig, type HuggingFaceProviderConfig, Insertable, LLMOpsClient, LLMOpsConfig, type LLMOpsConfigInput, LLMRequest, type LLMRequestInsert, LLMRequestsTable, MS, MemoryCacheBackend, MemoryCacheConfig, MigrationOptions, MigrationResult, type MistralAIProviderConfig, ModelPricing, ModelsDevPricingProvider, type OpenAIProviderConfig, type OracleProviderConfig, Prettify, PricingProvider, ProviderConfig, type ProviderConfigMap, ProviderConfigsTable, type ProvidersConfig, SCHEMA_METADATA, type SagemakerProviderConfig, Selectable, type StabilityAIProviderConfig, SupportedProviders, type TableName, TargetingRule, type TargetingRulesTable, Updateable, UsageData, type ValidatedLLMOpsConfig, Variant, VariantJsonData, VariantVersion, VariantVersionsTable, type VariantsTable, type VertexAIProviderConfig, type WorkersAIProviderConfig, WorkspaceSettings, WorkspaceSettingsTable, 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/types.d.ts
+/**
+ * Pre-computed variant version data needed for routing
+ */
+interface ManifestVariantVersion {
+  id: string;
+  variantId: string;
+  version: number;
+  provider: string;
+  providerConfigId: string | null;
+  modelName: string;
+  jsonData: Record<string, unknown>;
+}
+/**
+ * A targeting rule entry in the manifest
+ * Pre-resolved with all necessary data for routing
+ */
+interface ManifestTargetingRule {
+  id: string;
+  configVariantId: string;
+  variantVersionId: string | null;
+  weight: number;
+  priority: number;
+  enabled: boolean;
+  conditions: RulesLogic | null;
+  resolvedVersion: ManifestVariantVersion;
+}
+/**
+ * Config entry in the manifest
+ */
+interface ManifestConfig {
+  id: string;
+  slug: string;
+  name: string | null;
+}
+/**
+ * Environment entry in the manifest
+ */
+interface ManifestEnvironment {
+  id: string;
+  slug: string;
+  name: string;
+  isProd: boolean;
+}
+/**
+ * The complete routing manifest
+ * Stored in cache under key: "gateway:manifest"
+ */
+interface GatewayManifest {
+  version: number;
+  builtAt: string;
+  configs: Record<string, ManifestConfig>;
+  configsBySlug: Record<string, string>;
+  environments: Record<string, ManifestEnvironment>;
+  environmentsBySlug: Record<string, string>;
+  routingTable: Record<string, Record<string, ManifestTargetingRule[]>>;
+  secretToEnvironment: Record<string, string>;
+}
+/**
+ * Context passed to JSONLogic for condition evaluation
+ */
+interface RoutingContext {
+  headers?: Record<string, string>;
+  user?: {
+    id?: string;
+    email?: string;
+    groups?: string[];
+    [key: string]: unknown;
+  };
+  request?: {
+    path?: string;
+    method?: string;
+    ip?: string;
+  };
+  custom?: Record<string, unknown>;
+  timestamp?: number;
+}
+/**
+ * Result of routing a request
+ */
+interface RoutingResult {
+  configId: string;
+  environmentId: string;
+  variantId: string;
+  version: ManifestVariantVersion;
+  rule: ManifestTargetingRule;
+}
+//#endregion
+//#region src/manifest/builder.d.ts
+/**
+ * Builds the gateway routing manifest from database
+ */
+declare class ManifestBuilder {
+  private db;
+  constructor(db: Kysely<Database>);
+  /**
+   * Build the complete routing manifest from database
+   */
+  build(): Promise<GatewayManifest>;
+}
+//#endregion
+//#region src/manifest/service.d.ts
+declare class ManifestService {
+  private cache;
+  private ttlMs;
+  private builder;
+  constructor(cache: CacheService, db: Kysely<Database>, ttlMs?: number);
+  /**
+   * Get the current manifest, building if necessary
+   */
+  getManifest(): Promise<GatewayManifest>;
+  /**
+   * Force invalidate the manifest (called on mutations)
+   */
+  invalidate(): Promise<void>;
+  /**
+   * Invalidate and immediately rebuild (atomic refresh)
+   */
+  refresh(): Promise<GatewayManifest>;
+  /**
+   * Get manifest version without fetching full manifest
+   * Useful for checking if manifest is stale
+   */
+  getVersion(): Promise<number | null>;
+  /**
+   * Check if manifest exists in cache
+   */
+  hasManifest(): Promise<boolean>;
+}
+//#endregion
+//#region src/manifest/router.d.ts
+/**
+ * Router for evaluating the gateway manifest and selecting variants
+ */
+declare class ManifestRouter {
+  private manifest;
+  constructor(manifest: GatewayManifest);
+  /**
+   * Resolve a config identifier (UUID or slug) to config ID
+   */
+  resolveConfigId(configIdOrSlug: string): string | null;
+  /**
+   * Resolve environment from secret value
+   */
+  resolveEnvironmentFromSecret(secretValue: string): string | null;
+  /**
+   * Get production environment ID
+   */
+  getProductionEnvironmentId(): string | null;
+  /**
+   * Get environment by ID
+   */
+  getEnvironment(environmentId: string): ManifestEnvironment;
+  /**
+   * Get config by ID
+   */
+  getConfig(configId: string): ManifestConfig;
+  /**
+   * Route a request to the appropriate variant version (first match wins)
+   */
+  route(configIdOrSlug: string, environmentId: string, context?: RoutingContext): RoutingResult | null;
+  /**
+   * Route with weighted random selection among matching rules of same priority
+   */
+  routeWithWeights(configIdOrSlug: string, environmentId: string, context?: RoutingContext): RoutingResult | null;
+}
+//#endregion
+export { type AnthropicProviderConfig, type AnyProviderConfig, AuthClientDatabaseConfig, AuthClientOptions, type AzureAIProviderConfig, type AzureOpenAIProviderConfig, BaseCacheConfig, type BaseProviderConfig, type BedrockProviderConfig, CacheBackend, CacheBackendType, CacheConfig, CacheEntry, CacheOptions, CacheService, CacheStats, ChatCompletionCreateParamsBase, Config, ConfigVariant, type ConfigVariantsTable, type ConfigsTable, type CortexProviderConfig, CostResult, type Database, DatabaseConnection, DatabaseOptions, DatabaseType, Environment, EnvironmentSecret, type EnvironmentSecretsTable, type EnvironmentsTable, FileCacheBackend, FileCacheConfig, type FireworksAIProviderConfig, type GatewayManifest, type GoogleProviderConfig, type HuggingFaceProviderConfig, Insertable, LLMOpsClient, LLMOpsConfig, type LLMOpsConfigInput, LLMRequest, type LLMRequestInsert, LLMRequestsTable, MS, ManifestBuilder, type ManifestConfig, type ManifestEnvironment, ManifestRouter, ManifestService, type ManifestTargetingRule, type ManifestVariantVersion, MemoryCacheBackend, MemoryCacheConfig, MigrationOptions, MigrationResult, type MistralAIProviderConfig, ModelPricing, ModelsDevPricingProvider, type OpenAIProviderConfig, type OracleProviderConfig, Prettify, PricingProvider, ProviderConfig, type ProviderConfigMap, ProviderConfigsTable, type ProvidersConfig, type RoutingContext, type RoutingResult, SCHEMA_METADATA, type SagemakerProviderConfig, Selectable, type StabilityAIProviderConfig, SupportedProviders, type TableName, TargetingRule, type TargetingRulesTable, Updateable, UsageData, type ValidatedLLMOpsConfig, Variant, VariantJsonData, VariantVersion, VariantVersionsTable, type VariantsTable, type VertexAIProviderConfig, type WorkersAIProviderConfig, WorkspaceSettings, WorkspaceSettingsTable, 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/index.mjs

@@ -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;
@@ -1828,6 +1832,7 @@ const updateProviderConfig = zod_default.object({
 });
 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(),
@@ -1874,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}`);
@@ -2606,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmops/core",
-  "version": "0.2.14",
+  "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.14"
+    "@llmops/gateway": "^0.3.0-beta.1"
   },
   "devDependencies": {
+    "@types/json-logic-js": "^2.0.8",
     "@types/ws": "^8.18.1"
   },
   "scripts": {