@llmops/core 0.1.4 → 0.1.5-beta.2

package/dist/index.d.mts

@@ -1,9 +1,9 @@
-import { A as TargetingRulesTable, B as environmentSecretsSchema, C as EnvironmentSecretsTable, D as Selectable, E as SCHEMA_METADATA, F as VariantsTable, G as variantsSchema, H as schemas, I as WorkspaceSettings, K as workspaceSettingsSchema, L as WorkspaceSettingsTable, M as Variant, N as VariantVersion, O as TableName, P as VariantVersionsTable, R as configVariantsSchema, S as EnvironmentSecret, T as Insertable, U as targetingRulesSchema, V as environmentsSchema, W as variantVersionsSchema, _ as ConfigVariant, a as createDatabaseFromConnection, b as Database, c as MigrationResult, d as runAutoMigrations, f as parsePartialTableData, g as Config, h as validateTableData, i as createDatabase, j as Updateable, k as TargetingRule, l as getMigrations, m as validatePartialTableData, n as DatabaseOptions, o as detectDatabaseType, p as parseTableData, r as DatabaseType, s as MigrationOptions, t as DatabaseConnection, u as matchType, v as ConfigVariantsTable, w as EnvironmentsTable, x as Environment, y as ConfigsTable, z as configsSchema } from "./index-D3ncxgf2.mjs";
+import { A as TableName, B as configVariantsSchema, C as EnvironmentSecretsTable, D as LLMRequestsTable, E as LLMRequest, F as VariantVersion, G as schemas, H as environmentSecretsSchema, I as VariantVersionsTable, J as variantsSchema, K as targetingRulesSchema, L as VariantsTable, M as TargetingRulesTable, N as Updateable, O as SCHEMA_METADATA, P as Variant, R as WorkspaceSettings, S as EnvironmentSecret, T as Insertable, U as environmentsSchema, V as configsSchema, W as llmRequestsSchema, Y as workspaceSettingsSchema, _ as ConfigVariant, a as createDatabaseFromConnection, b as Database, c as MigrationResult, d as runAutoMigrations, f as parsePartialTableData, g as Config, h as validateTableData, i as createDatabase, j as TargetingRule, k as Selectable, l as getMigrations, m as validatePartialTableData, n as DatabaseOptions, o as detectDatabaseType, p as parseTableData, q as variantVersionsSchema, r as DatabaseType, s as MigrationOptions, t as DatabaseConnection, u as matchType, v as ConfigVariantsTable, w as EnvironmentsTable, x as Environment, y as ConfigsTable, z as WorkspaceSettingsTable } from "./index-mUSLoeGU.mjs";
 import gateway from "@llmops/gateway";
 import { Kysely } from "kysely";
 import pino from "pino";
 import * as zod0 from "zod";
-import { z } from "zod";
+import z$1, { z } from "zod";
 import * as zod_v4_core0 from "zod/v4/core";
 
 //#region src/providers/supported-providers.d.ts
@@ -1323,12 +1323,427 @@ 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
 //#region src/utils/id.d.ts
 declare const generateId: (size?: number) => string;
 //#endregion
+//#region src/datalayer/llmRequests.d.ts
+/**
+ * Schema for inserting a new LLM request log
+ */
+declare const insertLLMRequestSchema: z$1.ZodObject<{
+  requestId: z$1.ZodString;
+  configId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  variantId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  provider: z$1.ZodString;
+  model: z$1.ZodString;
+  promptTokens: z$1.ZodDefault<z$1.ZodNumber>;
+  completionTokens: z$1.ZodDefault<z$1.ZodNumber>;
+  totalTokens: z$1.ZodDefault<z$1.ZodNumber>;
+  cachedTokens: z$1.ZodDefault<z$1.ZodNumber>;
+  cost: z$1.ZodDefault<z$1.ZodNumber>;
+  inputCost: z$1.ZodDefault<z$1.ZodNumber>;
+  outputCost: z$1.ZodDefault<z$1.ZodNumber>;
+  endpoint: z$1.ZodString;
+  statusCode: z$1.ZodNumber;
+  latencyMs: z$1.ZodDefault<z$1.ZodNumber>;
+  isStreaming: z$1.ZodDefault<z$1.ZodBoolean>;
+  userId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  tags: z$1.ZodDefault<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type LLMRequestInsert = z$1.infer<typeof insertLLMRequestSchema>;
+/**
+ * Schema for listing LLM requests
+ */
+declare const listRequestsSchema: z$1.ZodObject<{
+  limit: z$1.ZodDefault<z$1.ZodNumber>;
+  offset: z$1.ZodDefault<z$1.ZodNumber>;
+  configId: z$1.ZodOptional<z$1.ZodString>;
+  provider: z$1.ZodOptional<z$1.ZodString>;
+  model: z$1.ZodOptional<z$1.ZodString>;
+  startDate: z$1.ZodOptional<z$1.ZodDate>;
+  endDate: z$1.ZodOptional<z$1.ZodDate>;
+}, z$1.core.$strip>;
+/**
+ * Schema for date range queries
+ */
+declare const dateRangeSchema: z$1.ZodObject<{
+  startDate: z$1.ZodDate;
+  endDate: z$1.ZodDate;
+}, z$1.core.$strip>;
+/**
+ * Schema for cost summary with grouping
+ */
+declare const costSummarySchema: z$1.ZodObject<{
+  startDate: z$1.ZodDate;
+  endDate: z$1.ZodDate;
+  groupBy: z$1.ZodOptional<z$1.ZodEnum<{
+    provider: "provider";
+    model: "model";
+    day: "day";
+    hour: "hour";
+    config: "config";
+  }>>;
+}, z$1.core.$strip>;
+declare const createLLMRequestsDataLayer: (db: Kysely<Database>) => {
+  /**
+   * Batch insert LLM request logs
+   * Used by the BatchWriter service for efficient writes
+   */
+  batchInsertRequests: (requests: LLMRequestInsert[]) => Promise<{
+    count: number;
+  }>;
+  /**
+   * Insert a single LLM request log
+   */
+  insertRequest: (request: LLMRequestInsert) => Promise<{
+    configId: string | null;
+    variantId: string | null;
+    id: string;
+    provider: string;
+    requestId: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+    inputCost: number;
+    outputCost: number;
+    endpoint: string;
+    statusCode: number;
+    latencyMs: number;
+    isStreaming: boolean;
+    userId: string | null;
+    tags: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+  } | undefined>;
+  /**
+   * List LLM requests with filtering and pagination
+   * Returns data and total count for pagination
+   */
+  listRequests: (params?: z$1.infer<typeof listRequestsSchema>) => Promise<{
+    data: {
+      configId: string | null;
+      variantId: string | null;
+      id: string;
+      provider: string;
+      requestId: string;
+      model: string;
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+      cachedTokens: number;
+      cost: number;
+      inputCost: number;
+      outputCost: number;
+      endpoint: string;
+      statusCode: number;
+      latencyMs: number;
+      isStreaming: boolean;
+      userId: string | null;
+      tags: Record<string, string>;
+      createdAt: Date;
+      updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+  }>;
+  /**
+   * Get a single request by requestId
+   */
+  getRequestByRequestId: (requestId: string) => Promise<{
+    configId: string | null;
+    variantId: string | null;
+    id: string;
+    provider: string;
+    requestId: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+    inputCost: number;
+    outputCost: number;
+    endpoint: string;
+    statusCode: number;
+    latencyMs: number;
+    isStreaming: boolean;
+    userId: string | null;
+    tags: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+  } | undefined>;
+  /**
+   * Get total cost for a date range
+   */
+  getTotalCost: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+    requestCount: number;
+  } | undefined>;
+  /**
+   * Get cost breakdown by model
+   */
+  getCostByModel: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    provider: string;
+    model: string;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    avgLatencyMs: number;
+  }[]>;
+  /**
+   * Get cost breakdown by provider
+   */
+  getCostByProvider: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    provider: string;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    avgLatencyMs: number;
+  }[]>;
+  /**
+   * Get cost breakdown by config
+   */
+  getCostByConfig: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    configId: string | null;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    configName: string | null | undefined;
+    configSlug: string | null;
+  }[]>;
+  /**
+   * Get daily cost summary
+   */
+  getDailyCosts: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    date: string;
+  }[]>;
+  /**
+   * Get cost summary with flexible grouping
+   */
+  getCostSummary: (params: z$1.infer<typeof costSummarySchema>) => Promise<{
+    totalCost: number;
+    requestCount: number;
+    groupKey: string;
+  }[]>;
+  /**
+   * Get request count and stats for a time range
+   */
+  getRequestStats: (params: z$1.infer<typeof dateRangeSchema>) => Promise<{
+    avgLatencyMs: number;
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    streamingRequests: number;
+    maxLatencyMs: number;
+    minLatencyMs: number;
+  } | undefined>;
+};
+//#endregion
 //#region src/datalayer/index.d.ts
 declare const createDataLayer: (db: Kysely<Database>) => Promise<{
   getWorkspaceSettings: () => Promise<{
@@ -1753,6 +2168,179 @@ declare const createDataLayer: (db: Kysely<Database>) => Promise<{
     createdAt: Date;
     updatedAt: Date;
   } | undefined>;
+  batchInsertRequests: (requests: LLMRequestInsert[]) => Promise<{
+    count: number;
+  }>;
+  insertRequest: (request: LLMRequestInsert) => Promise<{
+    configId: string | null;
+    variantId: string | null;
+    id: string;
+    provider: string;
+    requestId: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+    inputCost: number;
+    outputCost: number;
+    endpoint: string;
+    statusCode: number;
+    latencyMs: number;
+    isStreaming: boolean;
+    userId: string | null;
+    tags: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+  } | undefined>;
+  listRequests: (params?: zod0.infer<zod0.ZodObject<{
+    limit: zod0.ZodDefault<zod0.ZodNumber>;
+    offset: zod0.ZodDefault<zod0.ZodNumber>;
+    configId: zod0.ZodOptional<zod0.ZodString>;
+    provider: zod0.ZodOptional<zod0.ZodString>;
+    model: zod0.ZodOptional<zod0.ZodString>;
+    startDate: zod0.ZodOptional<zod0.ZodDate>;
+    endDate: zod0.ZodOptional<zod0.ZodDate>;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    data: {
+      configId: string | null;
+      variantId: string | null;
+      id: string;
+      provider: string;
+      requestId: string;
+      model: string;
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+      cachedTokens: number;
+      cost: number;
+      inputCost: number;
+      outputCost: number;
+      endpoint: string;
+      statusCode: number;
+      latencyMs: number;
+      isStreaming: boolean;
+      userId: string | null;
+      tags: Record<string, string>;
+      createdAt: Date;
+      updatedAt: Date;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+  }>;
+  getRequestByRequestId: (requestId: string) => Promise<{
+    configId: string | null;
+    variantId: string | null;
+    id: string;
+    provider: string;
+    requestId: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+    inputCost: number;
+    outputCost: number;
+    endpoint: string;
+    statusCode: number;
+    latencyMs: number;
+    isStreaming: boolean;
+    userId: string | null;
+    tags: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+  } | undefined>;
+  getTotalCost: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+    requestCount: number;
+  } | undefined>;
+  getCostByModel: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    provider: string;
+    model: string;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    avgLatencyMs: number;
+  }[]>;
+  getCostByProvider: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    provider: string;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    avgLatencyMs: number;
+  }[]>;
+  getCostByConfig: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    configId: string | null;
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    configName: string | null | undefined;
+    configSlug: string | null;
+  }[]>;
+  getDailyCosts: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    totalCost: number;
+    totalInputCost: number;
+    totalOutputCost: number;
+    totalTokens: number;
+    requestCount: number;
+    date: string;
+  }[]>;
+  getCostSummary: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+    groupBy: zod0.ZodOptional<zod0.ZodEnum<{
+      provider: "provider";
+      model: "model";
+      day: "day";
+      hour: "hour";
+      config: "config";
+    }>>;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    totalCost: number;
+    requestCount: number;
+    groupKey: string;
+  }[]>;
+  getRequestStats: (params: zod0.infer<zod0.ZodObject<{
+    startDate: zod0.ZodDate;
+    endDate: zod0.ZodDate;
+  }, zod_v4_core0.$strip>>) => Promise<{
+    avgLatencyMs: number;
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    streamingRequests: number;
+    maxLatencyMs: number;
+    minLatencyMs: number;
+  } | undefined>;
   createEnvironmentSecret: (params: zod0.infer<zod0.ZodObject<{
     environmentId: zod0.ZodUUID;
     keyName: zod0.ZodString;
@@ -2046,6 +2634,8 @@ declare const createDataLayer: (db: Kysely<Database>) => Promise<{
     configId: zod0.ZodString;
     envSecret: zod0.ZodOptional<zod0.ZodString>;
   }, zod_v4_core0.$strip>>) => Promise<{
+    configId: string;
+    variantId: string;
     version: number;
     provider: string;
     modelName: string;
@@ -2114,4 +2704,193 @@ 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, type ConfigVariantsTable, type ConfigsTable, type CortexProviderConfig, type Database, DatabaseConnection, DatabaseOptions, DatabaseType, Environment, EnvironmentSecret, type EnvironmentSecretsTable, type 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, type TableName, TargetingRule, type TargetingRulesTable, Updateable, type ValidatedLLMOpsConfig, Variant, VariantJsonData, VariantVersion, VariantVersionsTable, type 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 };
+//#region src/pricing/types.d.ts
+/**
+ * Pricing types for cost tracking
+ */
+/**
+ * Model pricing information
+ * All costs are in dollars per 1 million tokens
+ */
+interface ModelPricing {
+  /** Cost per 1M input/prompt tokens in dollars */
+  inputCostPer1M: number;
+  /** Cost per 1M output/completion tokens in dollars */
+  outputCostPer1M: number;
+  /** Cost per 1M cached read tokens in dollars (optional) */
+  cacheReadCostPer1M?: number;
+  /** Cost per 1M cached write tokens in dollars (optional) */
+  cacheWriteCostPer1M?: number;
+  /** Cost per 1M reasoning tokens in dollars (optional, for models like o1) */
+  reasoningCostPer1M?: number;
+}
+/**
+ * Token usage data from LLM response
+ */
+interface UsageData {
+  /** Number of tokens in the prompt/input */
+  promptTokens: number;
+  /** Number of tokens in the completion/output */
+  completionTokens: number;
+  /** Total tokens (prompt + completion) */
+  totalTokens?: number;
+  /** Number of cached tokens (optional) */
+  cachedTokens?: number;
+  /** Number of reasoning tokens (optional, for models like o1) */
+  reasoningTokens?: number;
+}
+/**
+ * Cost calculation result
+ * All costs are in micro-dollars (1 dollar = 1,000,000 micro-dollars)
+ * This avoids floating-point precision issues
+ */
+interface CostResult {
+  /** Total cost in micro-dollars */
+  totalCost: number;
+  /** Input/prompt cost in micro-dollars */
+  inputCost: number;
+  /** Output/completion cost in micro-dollars */
+  outputCost: number;
+}
+/**
+ * Provider for fetching model pricing data
+ * Abstracted to allow swapping data sources (models.dev, local JSON, etc.)
+ */
+interface PricingProvider {
+  /**
+   * Get pricing for a specific model
+   * @param provider - Provider name (e.g., "openai", "anthropic")
+   * @param model - Model identifier (e.g., "gpt-4o", "claude-3-sonnet")
+   * @returns Model pricing or null if not found
+   */
+  getModelPricing(provider: string, model: string): Promise<ModelPricing | null>;
+  /**
+   * Force refresh the pricing cache
+   */
+  refreshCache(): Promise<void>;
+  /**
+   * Check if the provider is ready (cache is populated)
+   */
+  isReady(): boolean;
+}
+//#endregion
+//#region src/pricing/calculator.d.ts
+/**
+ * Calculate the cost of an LLM request in micro-dollars
+ *
+ * Micro-dollars are used to avoid floating-point precision issues:
+ * - 1 dollar = 1,000,000 micro-dollars
+ * - $0.001 = 1,000 micro-dollars
+ * - $0.000001 = 1 micro-dollar
+ *
+ * @param usage - Token usage data from the LLM response
+ * @param pricing - Model pricing information
+ * @returns Cost breakdown in micro-dollars
+ *
+ * @example
+ * ```typescript
+ * const usage = { promptTokens: 1000, completionTokens: 500 };
+ * const pricing = { inputCostPer1M: 2.5, outputCostPer1M: 10.0 };
+ * const cost = calculateCost(usage, pricing);
+ * // cost = { inputCost: 2500, outputCost: 5000, totalCost: 7500 }
+ * // In dollars: $0.0025 input + $0.005 output = $0.0075 total
+ * ```
+ */
+declare function calculateCost(usage: UsageData, pricing: ModelPricing): CostResult;
+/**
+ * Convert micro-dollars to dollars
+ *
+ * @param microDollars - Amount in micro-dollars
+ * @returns Amount in dollars
+ *
+ * @example
+ * ```typescript
+ * microDollarsToDollars(7500); // 0.0075
+ * microDollarsToDollars(1000000); // 1.0
+ * ```
+ */
+declare function microDollarsToDollars(microDollars: number): number;
+/**
+ * Convert dollars to micro-dollars
+ *
+ * @param dollars - Amount in dollars
+ * @returns Amount in micro-dollars (rounded to nearest integer)
+ *
+ * @example
+ * ```typescript
+ * dollarsToMicroDollars(0.0075); // 7500
+ * dollarsToMicroDollars(1.0); // 1000000
+ * ```
+ */
+declare function dollarsToMicroDollars(dollars: number): number;
+/**
+ * Format micro-dollars as a human-readable dollar string
+ *
+ * @param microDollars - Amount in micro-dollars
+ * @param decimals - Number of decimal places (default: 6)
+ * @returns Formatted dollar string
+ *
+ * @example
+ * ```typescript
+ * formatCost(7500); // "$0.007500"
+ * formatCost(1234567, 2); // "$1.23"
+ * ```
+ */
+declare function formatCost(microDollars: number, decimals?: number): string;
+//#endregion
+//#region src/pricing/provider.d.ts
+/**
+ * Pricing provider that fetches data from models.dev API
+ *
+ * Features:
+ * - Caches pricing data with configurable TTL (default 5 minutes)
+ * - Supports fallback to local cache on fetch failure
+ * - Thread-safe cache refresh
+ */
+declare class ModelsDevPricingProvider implements PricingProvider {
+  private cache;
+  private lastFetch;
+  private cacheTTL;
+  private fetchPromise;
+  private ready;
+  /**
+   * Create a new ModelsDevPricingProvider
+   *
+   * @param cacheTTL - Cache TTL in milliseconds (default: 5 minutes)
+   */
+  constructor(cacheTTL?: number);
+  /**
+   * Generate a cache key for a provider/model combination
+   */
+  private getCacheKey;
+  /**
+   * Fetch pricing data from models.dev API
+   */
+  private fetchPricingData;
+  /**
+   * Ensure cache is fresh, fetching if necessary
+   */
+  private ensureFreshCache;
+  /**
+   * Get pricing for a specific model
+   */
+  getModelPricing(provider: string, model: string): Promise<ModelPricing | null>;
+  /**
+   * Force refresh the pricing cache
+   */
+  refreshCache(): Promise<void>;
+  /**
+   * Check if the provider is ready
+   */
+  isReady(): boolean;
+  /**
+   * Get the number of cached models (for debugging)
+   */
+  getCacheSize(): number;
+}
+/**
+ * Get the default pricing provider instance
+ */
+declare function getDefaultPricingProvider(): ModelsDevPricingProvider;
+//#endregion
+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, 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, type ProviderConfigMap, 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, detectDatabaseType, dollarsToMicroDollars, environmentSecretsSchema, environmentsSchema, formatCost, gateway, generateId, getDefaultPricingProvider, getMigrations, llmRequestsSchema, llmopsConfigSchema, logger, matchType, microDollarsToDollars, parsePartialTableData, parseTableData, runAutoMigrations, schemas, targetingRulesSchema, validateLLMOpsConfig, validatePartialTableData, validateTableData, variantJsonDataSchema, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };