@llmops/core 0.1.4 → 0.1.5-beta.1

package/dist/index.cjs

@@ -1,6 +1,10 @@
 const require_db = require('./db-C9-M-kdS.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_db.__toESM(node_fs_promises);
+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");
 
@@ -465,6 +469,491 @@ function validateLLMOpsConfig(config) {
 	return result.data;
 }
 
+//#endregion
+//#region src/cache/types.ts
+/** Time constants in milliseconds for convenience */
+const MS = {
+	"1_MINUTE": 60 * 1e3,
+	"5_MINUTES": 300 * 1e3,
+	"10_MINUTES": 600 * 1e3,
+	"30_MINUTES": 1800 * 1e3,
+	"1_HOUR": 3600 * 1e3,
+	"6_HOURS": 360 * 60 * 1e3,
+	"12_HOURS": 720 * 60 * 1e3,
+	"1_DAY": 1440 * 60 * 1e3,
+	"7_DAYS": 10080 * 60 * 1e3,
+	"30_DAYS": 720 * 60 * 60 * 1e3
+};
+
+//#endregion
+//#region src/cache/backends/memory.ts
+var MemoryCacheBackend = class {
+	cache = /* @__PURE__ */ new Map();
+	stats = {
+		hits: 0,
+		misses: 0,
+		sets: 0,
+		deletes: 0,
+		size: 0,
+		expired: 0
+	};
+	cleanupInterval;
+	maxSize;
+	constructor(maxSize = 1e4, cleanupIntervalMs = 6e4) {
+		this.maxSize = maxSize;
+		this.startCleanup(cleanupIntervalMs);
+	}
+	startCleanup(intervalMs) {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, intervalMs);
+	}
+	getFullKey(key, namespace) {
+		return namespace ? `${namespace}:${key}` : key;
+	}
+	isExpired(entry) {
+		return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+	}
+	evictIfNeeded() {
+		if (this.cache.size >= this.maxSize) {
+			const entries = Array.from(this.cache.entries());
+			entries.sort((a, b) => a[1].createdAt - b[1].createdAt);
+			const toRemove = Math.floor(this.maxSize * .1);
+			for (let i = 0; i < toRemove && i < entries.length; i++) this.cache.delete(entries[i][0]);
+		}
+	}
+	async get(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const entry = this.cache.get(fullKey);
+		if (!entry) {
+			this.stats.misses++;
+			return null;
+		}
+		if (this.isExpired(entry)) {
+			this.cache.delete(fullKey);
+			this.stats.expired++;
+			this.stats.misses++;
+			return null;
+		}
+		this.stats.hits++;
+		return entry;
+	}
+	async set(key, value, options = {}) {
+		const fullKey = this.getFullKey(key, options.namespace);
+		const now = Date.now();
+		const entry = {
+			value,
+			createdAt: now,
+			expiresAt: options.ttl ? now + options.ttl : void 0,
+			metadata: options.metadata
+		};
+		this.evictIfNeeded();
+		this.cache.set(fullKey, entry);
+		this.stats.sets++;
+		this.stats.size = this.cache.size;
+	}
+	async delete(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const deleted = this.cache.delete(fullKey);
+		if (deleted) {
+			this.stats.deletes++;
+			this.stats.size = this.cache.size;
+		}
+		return deleted;
+	}
+	async clear(namespace) {
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			const keysToDelete = Array.from(this.cache.keys()).filter((key) => key.startsWith(prefix));
+			for (const key of keysToDelete) this.cache.delete(key);
+			this.stats.deletes += keysToDelete.length;
+		} else {
+			this.stats.deletes += this.cache.size;
+			this.cache.clear();
+		}
+		this.stats.size = this.cache.size;
+	}
+	async has(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const entry = this.cache.get(fullKey);
+		if (!entry) return false;
+		if (this.isExpired(entry)) {
+			this.cache.delete(fullKey);
+			this.stats.expired++;
+			return false;
+		}
+		return true;
+	}
+	async keys(namespace) {
+		const allKeys = Array.from(this.cache.keys());
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			return allKeys.filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+		}
+		return allKeys;
+	}
+	async getStats(namespace) {
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			const namespaceKeys = Array.from(this.cache.keys()).filter((key) => key.startsWith(prefix));
+			let expired = 0;
+			for (const key of namespaceKeys) {
+				const entry = this.cache.get(key);
+				if (entry && this.isExpired(entry)) expired++;
+			}
+			return {
+				...this.stats,
+				size: namespaceKeys.length,
+				expired
+			};
+		}
+		return { ...this.stats };
+	}
+	async cleanup() {
+		let expiredCount = 0;
+		for (const [key, entry] of this.cache.entries()) if (this.isExpired(entry)) {
+			this.cache.delete(key);
+			expiredCount++;
+		}
+		if (expiredCount > 0) {
+			this.stats.expired += expiredCount;
+			this.stats.size = this.cache.size;
+		}
+	}
+	async close() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+		this.cache.clear();
+	}
+};
+
+//#endregion
+//#region src/cache/backends/file.ts
+/**
+* @file src/cache/backends/file.ts
+* File-based cache backend implementation
+*/
+var FileCacheBackend = class {
+	cacheFile;
+	data = {};
+	saveTimer;
+	cleanupInterval;
+	loaded = false;
+	loadPromise;
+	stats = {
+		hits: 0,
+		misses: 0,
+		sets: 0,
+		deletes: 0,
+		size: 0,
+		expired: 0
+	};
+	saveInterval;
+	constructor(dataDir = "data", fileName = "cache.json", saveIntervalMs = 1e3, cleanupIntervalMs = 6e4) {
+		this.cacheFile = node_path.join(process.cwd(), dataDir, fileName);
+		this.saveInterval = saveIntervalMs;
+		this.loadPromise = this.loadCache();
+		this.loadPromise.then(() => {
+			this.startCleanup(cleanupIntervalMs);
+		});
+	}
+	/** Ensure cache is loaded before any operation */
+	async ensureLoaded() {
+		if (!this.loaded) await this.loadPromise;
+	}
+	async ensureDataDir() {
+		const dir = node_path.dirname(this.cacheFile);
+		try {
+			await node_fs_promises.mkdir(dir, { recursive: true });
+		} catch {}
+	}
+	async loadCache() {
+		try {
+			const content = await node_fs_promises.readFile(this.cacheFile, "utf-8");
+			this.data = JSON.parse(content);
+			this.updateStats();
+			this.loaded = true;
+		} catch {
+			this.data = {};
+			this.loaded = true;
+		}
+	}
+	async saveCache() {
+		try {
+			await this.ensureDataDir();
+			await node_fs_promises.writeFile(this.cacheFile, JSON.stringify(this.data, null, 2));
+		} catch {}
+	}
+	scheduleSave() {
+		if (this.saveTimer) clearTimeout(this.saveTimer);
+		this.saveTimer = setTimeout(() => {
+			this.saveCache();
+			this.saveTimer = void 0;
+		}, this.saveInterval);
+	}
+	startCleanup(intervalMs) {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, intervalMs);
+	}
+	isExpired(entry) {
+		return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+	}
+	updateStats() {
+		let totalSize = 0;
+		let totalExpired = 0;
+		for (const namespace of Object.values(this.data)) for (const entry of Object.values(namespace)) {
+			totalSize++;
+			if (this.isExpired(entry)) totalExpired++;
+		}
+		this.stats.size = totalSize;
+		this.stats.expired = totalExpired;
+	}
+	getNamespaceData(namespace = "default") {
+		if (!this.data[namespace]) this.data[namespace] = {};
+		return this.data[namespace];
+	}
+	async get(key, namespace) {
+		await this.ensureLoaded();
+		const namespaceData = this.getNamespaceData(namespace);
+		const entry = namespaceData[key];
+		if (!entry) {
+			this.stats.misses++;
+			return null;
+		}
+		if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			this.stats.expired++;
+			this.stats.misses++;
+			this.scheduleSave();
+			return null;
+		}
+		this.stats.hits++;
+		return entry;
+	}
+	async set(key, value, options = {}) {
+		await this.ensureLoaded();
+		const namespace = options.namespace || "default";
+		const namespaceData = this.getNamespaceData(namespace);
+		const now = Date.now();
+		namespaceData[key] = {
+			value,
+			createdAt: now,
+			expiresAt: options.ttl ? now + options.ttl : void 0,
+			metadata: options.metadata
+		};
+		this.stats.sets++;
+		this.updateStats();
+		this.scheduleSave();
+	}
+	async delete(key, namespace) {
+		const namespaceData = this.getNamespaceData(namespace);
+		const existed = key in namespaceData;
+		if (existed) {
+			delete namespaceData[key];
+			this.stats.deletes++;
+			this.updateStats();
+			this.scheduleSave();
+		}
+		return existed;
+	}
+	async clear(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			const count = Object.keys(namespaceData).length;
+			this.data[namespace] = {};
+			this.stats.deletes += count;
+		} else {
+			const totalCount = Object.values(this.data).reduce((sum, ns) => sum + Object.keys(ns).length, 0);
+			this.data = {};
+			this.stats.deletes += totalCount;
+		}
+		this.updateStats();
+		this.scheduleSave();
+	}
+	async has(key, namespace) {
+		const namespaceData = this.getNamespaceData(namespace);
+		const entry = namespaceData[key];
+		if (!entry) return false;
+		if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			this.stats.expired++;
+			this.scheduleSave();
+			return false;
+		}
+		return true;
+	}
+	async keys(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			return Object.keys(namespaceData);
+		}
+		const allKeys = [];
+		for (const namespaceData of Object.values(this.data)) allKeys.push(...Object.keys(namespaceData));
+		return allKeys;
+	}
+	async getStats(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			const keys = Object.keys(namespaceData);
+			let expired = 0;
+			for (const key of keys) {
+				const entry = namespaceData[key];
+				if (this.isExpired(entry)) expired++;
+			}
+			return {
+				...this.stats,
+				size: keys.length,
+				expired
+			};
+		}
+		this.updateStats();
+		return { ...this.stats };
+	}
+	async cleanup() {
+		let expiredCount = 0;
+		let hasChanges = false;
+		for (const [, namespaceData] of Object.entries(this.data)) for (const [key, entry] of Object.entries(namespaceData)) if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			expiredCount++;
+			hasChanges = true;
+		}
+		if (hasChanges) {
+			this.stats.expired += expiredCount;
+			this.updateStats();
+			this.scheduleSave();
+		}
+	}
+	/** Wait for the cache to be ready (file loaded) */
+	async waitForReady() {
+		await this.loadPromise;
+	}
+	async close() {
+		if (this.saveTimer) {
+			clearTimeout(this.saveTimer);
+			await this.saveCache();
+		}
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/cache/service.ts
+/**
+* @file src/cache/service.ts
+* Unified cache service with pluggable backends
+*/
+var CacheService = class {
+	backend;
+	defaultTtl;
+	constructor(config) {
+		this.defaultTtl = config.defaultTtl;
+		this.backend = this.createBackend(config);
+	}
+	createBackend(config) {
+		switch (config.backend) {
+			case "memory": return new MemoryCacheBackend(config.maxSize, config.cleanupInterval);
+			case "file": return new FileCacheBackend(config.dataDir, config.fileName, config.saveInterval, config.cleanupInterval);
+			default: throw new Error(`Unsupported cache backend: ${config.backend}`);
+		}
+	}
+	/** Get a value from the cache */
+	async get(key, namespace) {
+		const entry = await this.backend.get(key, namespace);
+		return entry ? entry.value : null;
+	}
+	/** Get the full cache entry (with metadata) */
+	async getEntry(key, namespace) {
+		return this.backend.get(key, namespace);
+	}
+	/** Set a value in the cache */
+	async set(key, value, options = {}) {
+		const finalOptions = {
+			...options,
+			ttl: options.ttl ?? this.defaultTtl
+		};
+		await this.backend.set(key, value, finalOptions);
+	}
+	/** Set a value with TTL in seconds (convenience method) */
+	async setWithTtl(key, value, ttlSeconds, namespace) {
+		await this.set(key, value, {
+			ttl: ttlSeconds * 1e3,
+			namespace
+		});
+	}
+	/** Delete a value from the cache */
+	async delete(key, namespace) {
+		return this.backend.delete(key, namespace);
+	}
+	/** Check if a key exists in the cache */
+	async has(key, namespace) {
+		return this.backend.has(key, namespace);
+	}
+	/** Get all keys in a namespace */
+	async keys(namespace) {
+		return this.backend.keys(namespace);
+	}
+	/** Clear all entries in a namespace (or all entries if no namespace) */
+	async clear(namespace) {
+		await this.backend.clear(namespace);
+	}
+	/** Get cache statistics */
+	async getStats(namespace) {
+		return this.backend.getStats(namespace);
+	}
+	/** Manually trigger cleanup of expired entries */
+	async cleanup() {
+		await this.backend.cleanup();
+	}
+	/** Wait for the backend to be ready */
+	async waitForReady() {
+		if ("waitForReady" in this.backend) await this.backend.waitForReady();
+	}
+	/** Close the cache and cleanup resources */
+	async close() {
+		await this.backend.close();
+	}
+	/** Get or set pattern - get value, or compute and cache it if not found */
+	async getOrSet(key, factory, options = {}) {
+		const existing = await this.get(key, options.namespace);
+		if (existing !== null) return existing;
+		const value = await factory();
+		await this.set(key, value, options);
+		return value;
+	}
+	/** Increment a numeric value (simulated atomic operation) */
+	async increment(key, delta = 1, options = {}) {
+		const newValue = (await this.get(key, options.namespace) || 0) + delta;
+		await this.set(key, newValue, options);
+		return newValue;
+	}
+	/** Set multiple values at once */
+	async setMany(entries, defaultOptions = {}) {
+		const promises = entries.map(({ key, value, options }) => this.set(key, value, {
+			...defaultOptions,
+			...options
+		}));
+		await Promise.all(promises);
+	}
+	/** Get multiple values at once */
+	async getMany(keys, namespace) {
+		const promises = keys.map(async (key) => ({
+			key,
+			value: await this.get(key, namespace)
+		}));
+		return Promise.all(promises);
+	}
+	/** Get the underlying backend (for advanced use cases) */
+	getBackend() {
+		return this.backend;
+	}
+};
+
 //#endregion
 //#region src/utils/id.ts
 const generateId = (size) => {
@@ -1387,6 +1876,10 @@ const createDataLayer = async (db) => {
 };
 
 //#endregion
+exports.CacheService = CacheService;
+exports.FileCacheBackend = FileCacheBackend;
+exports.MS = MS;
+exports.MemoryCacheBackend = MemoryCacheBackend;
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.SupportedProviders = SupportedProviders;
 exports.chatCompletionCreateParamsBaseSchema = chatCompletionCreateParamsBaseSchema;

package/dist/index.d.cts

@@ -1323,6 +1323,188 @@ declare const variantJsonDataSchema: z.ZodObject<{
 }, z.core.$strip>;
 type VariantJsonData = z.infer<typeof variantJsonDataSchema>;
 //#endregion
+//#region src/cache/types.d.ts
+/**
+ * @file src/cache/types.ts
+ * Type definitions for the unified cache system
+ */
+interface CacheEntry<T = unknown> {
+  value: T;
+  expiresAt?: number;
+  createdAt: number;
+  metadata?: Record<string, unknown>;
+}
+interface CacheOptions {
+  /** Time to live in milliseconds */
+  ttl?: number;
+  /** Cache namespace for organization */
+  namespace?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+}
+interface CacheStats {
+  hits: number;
+  misses: number;
+  sets: number;
+  deletes: number;
+  size: number;
+  expired: number;
+}
+interface CacheBackend {
+  get<T = unknown>(key: string, namespace?: string): Promise<CacheEntry<T> | null>;
+  set<T = unknown>(key: string, value: T, options?: CacheOptions): Promise<void>;
+  delete(key: string, namespace?: string): Promise<boolean>;
+  clear(namespace?: string): Promise<void>;
+  has(key: string, namespace?: string): Promise<boolean>;
+  keys(namespace?: string): Promise<string[]>;
+  getStats(namespace?: string): Promise<CacheStats>;
+  /** Remove expired entries */
+  cleanup(): Promise<void>;
+  /** Cleanup resources */
+  close(): Promise<void>;
+}
+type CacheBackendType = 'memory' | 'file';
+interface BaseCacheConfig {
+  backend: CacheBackendType;
+  /** Default TTL in milliseconds */
+  defaultTtl?: number;
+  /** Cleanup interval in milliseconds */
+  cleanupInterval?: number;
+}
+interface MemoryCacheConfig extends BaseCacheConfig {
+  backend: 'memory';
+  /** Maximum number of entries */
+  maxSize?: number;
+}
+interface FileCacheConfig extends BaseCacheConfig {
+  backend: 'file';
+  /** Data directory path */
+  dataDir?: string;
+  /** Cache file name */
+  fileName?: string;
+  /** Debounce save interval in milliseconds */
+  saveInterval?: number;
+}
+type CacheConfig = MemoryCacheConfig | FileCacheConfig;
+/** Time constants in milliseconds for convenience */
+declare const MS: {
+  readonly '1_MINUTE': number;
+  readonly '5_MINUTES': number;
+  readonly '10_MINUTES': number;
+  readonly '30_MINUTES': number;
+  readonly '1_HOUR': number;
+  readonly '6_HOURS': number;
+  readonly '12_HOURS': number;
+  readonly '1_DAY': number;
+  readonly '7_DAYS': number;
+  readonly '30_DAYS': number;
+};
+//#endregion
+//#region src/cache/backends/memory.d.ts
+declare class MemoryCacheBackend implements CacheBackend {
+  private cache;
+  private stats;
+  private cleanupInterval?;
+  private maxSize;
+  constructor(maxSize?: number, cleanupIntervalMs?: number);
+  private startCleanup;
+  private getFullKey;
+  private isExpired;
+  private evictIfNeeded;
+  get<T = unknown>(key: string, namespace?: string): Promise<CacheEntry<T> | null>;
+  set<T = unknown>(key: string, value: T, options?: CacheOptions): Promise<void>;
+  delete(key: string, namespace?: string): Promise<boolean>;
+  clear(namespace?: string): Promise<void>;
+  has(key: string, namespace?: string): Promise<boolean>;
+  keys(namespace?: string): Promise<string[]>;
+  getStats(namespace?: string): Promise<CacheStats>;
+  cleanup(): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/cache/backends/file.d.ts
+declare class FileCacheBackend implements CacheBackend {
+  private cacheFile;
+  private data;
+  private saveTimer?;
+  private cleanupInterval?;
+  private loaded;
+  private loadPromise;
+  private stats;
+  private saveInterval;
+  constructor(dataDir?: string, fileName?: string, saveIntervalMs?: number, cleanupIntervalMs?: number);
+  /** Ensure cache is loaded before any operation */
+  private ensureLoaded;
+  private ensureDataDir;
+  private loadCache;
+  private saveCache;
+  private scheduleSave;
+  private startCleanup;
+  private isExpired;
+  private updateStats;
+  private getNamespaceData;
+  get<T = unknown>(key: string, namespace?: string): Promise<CacheEntry<T> | null>;
+  set<T = unknown>(key: string, value: T, options?: CacheOptions): Promise<void>;
+  delete(key: string, namespace?: string): Promise<boolean>;
+  clear(namespace?: string): Promise<void>;
+  has(key: string, namespace?: string): Promise<boolean>;
+  keys(namespace?: string): Promise<string[]>;
+  getStats(namespace?: string): Promise<CacheStats>;
+  cleanup(): Promise<void>;
+  /** Wait for the cache to be ready (file loaded) */
+  waitForReady(): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/cache/service.d.ts
+declare class CacheService {
+  private backend;
+  private defaultTtl?;
+  constructor(config: CacheConfig);
+  private createBackend;
+  /** Get a value from the cache */
+  get<T = unknown>(key: string, namespace?: string): Promise<T | null>;
+  /** Get the full cache entry (with metadata) */
+  getEntry<T = unknown>(key: string, namespace?: string): Promise<CacheEntry<T> | null>;
+  /** Set a value in the cache */
+  set<T = unknown>(key: string, value: T, options?: CacheOptions): Promise<void>;
+  /** Set a value with TTL in seconds (convenience method) */
+  setWithTtl<T = unknown>(key: string, value: T, ttlSeconds: number, namespace?: string): Promise<void>;
+  /** Delete a value from the cache */
+  delete(key: string, namespace?: string): Promise<boolean>;
+  /** Check if a key exists in the cache */
+  has(key: string, namespace?: string): Promise<boolean>;
+  /** Get all keys in a namespace */
+  keys(namespace?: string): Promise<string[]>;
+  /** Clear all entries in a namespace (or all entries if no namespace) */
+  clear(namespace?: string): Promise<void>;
+  /** Get cache statistics */
+  getStats(namespace?: string): Promise<CacheStats>;
+  /** Manually trigger cleanup of expired entries */
+  cleanup(): Promise<void>;
+  /** Wait for the backend to be ready */
+  waitForReady(): Promise<void>;
+  /** Close the cache and cleanup resources */
+  close(): Promise<void>;
+  /** Get or set pattern - get value, or compute and cache it if not found */
+  getOrSet<T = unknown>(key: string, factory: () => Promise<T> | T, options?: CacheOptions): Promise<T>;
+  /** Increment a numeric value (simulated atomic operation) */
+  increment(key: string, delta?: number, options?: CacheOptions): Promise<number>;
+  /** Set multiple values at once */
+  setMany<T = unknown>(entries: Array<{
+    key: string;
+    value: T;
+    options?: CacheOptions;
+  }>, defaultOptions?: CacheOptions): Promise<void>;
+  /** Get multiple values at once */
+  getMany<T = unknown>(keys: string[], namespace?: string): Promise<Array<{
+    key: string;
+    value: T | null;
+  }>>;
+  /** Get the underlying backend (for advanced use cases) */
+  getBackend(): CacheBackend;
+}
+//#endregion
 //#region src/utils/logger.d.ts
 declare const logger: pino.Logger<never, boolean>;
 //#endregion
@@ -2114,4 +2296,4 @@ declare const createDataLayer: (db: Kysely<Database>) => Promise<{
   }[]>;
 }>;
 //#endregion
-export { type AnthropicProviderConfig, type AnyProviderConfig, type AuthConfig, AutoMigrateConfig, type AzureAIProviderConfig, type AzureOpenAIProviderConfig, type BaseProviderConfig, type BasicAuthConfig, type BedrockProviderConfig, ChatCompletionCreateParamsBase, Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, type CortexProviderConfig, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, type FireworksAIProviderConfig, type GoogleProviderConfig, type HuggingFaceProviderConfig, Insertable, LLMOpsClient, LLMOpsConfig, type LLMOpsConfigInput, MigrationOptions, MigrationResult, type MistralAIProviderConfig, type OpenAIProviderConfig, type OracleProviderConfig, Prettify, type ProviderConfigMap, type ProvidersConfig, SCHEMA_METADATA, type SagemakerProviderConfig, Selectable, type StabilityAIProviderConfig, SupportedProviders, TableName, TargetingRule, TargetingRulesTable, Updateable, type ValidatedLLMOpsConfig, Variant, VariantJsonData, VariantVersion, VariantVersionsTable, VariantsTable, type VertexAIProviderConfig, type WorkersAIProviderConfig, WorkspaceSettings, WorkspaceSettingsTable, chatCompletionCreateParamsBaseSchema, configVariantsSchema, configsSchema, createDataLayer, createDatabase, createDatabaseFromConnection, detectDatabaseType, environmentSecretsSchema, environmentsSchema, gateway, generateId, getMigrations, llmopsConfigSchema, logger, matchType, parsePartialTableData, parseTableData, runAutoMigrations, schemas, targetingRulesSchema, validateLLMOpsConfig, validatePartialTableData, validateTableData, variantJsonDataSchema, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };
+export { type AnthropicProviderConfig, type AnyProviderConfig, type AuthConfig, AutoMigrateConfig, type AzureAIProviderConfig, type AzureOpenAIProviderConfig, BaseCacheConfig, type BaseProviderConfig, type BasicAuthConfig, type BedrockProviderConfig, CacheBackend, CacheBackendType, CacheConfig, CacheEntry, CacheOptions, CacheService, CacheStats, ChatCompletionCreateParamsBase, Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, type CortexProviderConfig, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, FileCacheBackend, FileCacheConfig, type FireworksAIProviderConfig, type GoogleProviderConfig, type HuggingFaceProviderConfig, Insertable, LLMOpsClient, LLMOpsConfig, type LLMOpsConfigInput, MS, MemoryCacheBackend, MemoryCacheConfig, MigrationOptions, MigrationResult, type MistralAIProviderConfig, type OpenAIProviderConfig, type OracleProviderConfig, Prettify, type ProviderConfigMap, type ProvidersConfig, SCHEMA_METADATA, type SagemakerProviderConfig, Selectable, type StabilityAIProviderConfig, SupportedProviders, TableName, TargetingRule, TargetingRulesTable, Updateable, type ValidatedLLMOpsConfig, Variant, VariantJsonData, VariantVersion, VariantVersionsTable, VariantsTable, type VertexAIProviderConfig, type WorkersAIProviderConfig, WorkspaceSettings, WorkspaceSettingsTable, chatCompletionCreateParamsBaseSchema, configVariantsSchema, configsSchema, createDataLayer, createDatabase, createDatabaseFromConnection, detectDatabaseType, environmentSecretsSchema, environmentsSchema, gateway, generateId, getMigrations, llmopsConfigSchema, logger, matchType, parsePartialTableData, parseTableData, runAutoMigrations, schemas, targetingRulesSchema, validateLLMOpsConfig, validatePartialTableData, validateTableData, variantJsonDataSchema, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };