@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/index.mjs

@@ -0,0 +1,1028 @@
+import {
+  BaseCache,
+  MemoryCache,
+  RedisCache,
+  SQLiteCache,
+  TieredCache,
+  createCache,
+  createMemoryCache,
+  createRedisCache,
+  createSQLiteCache,
+  createStandardTieredCache,
+  createTieredCache
+} from "./chunk-VPSMDBHH.mjs";
+import {
+  BaseChunker,
+  CodeChunker,
+  FixedChunker,
+  MarkdownChunker,
+  RecursiveChunker,
+  SemanticChunker,
+  chunk,
+  createChunker,
+  createCodeChunker,
+  createFixedChunker,
+  createMarkdownChunker,
+  createRecursiveChunker,
+  createSemanticChunker,
+  defaultTokenCounter,
+  mergeSmallChunks,
+  splitLargeChunks
+} from "./chunk-DJAURHAS.mjs";
+import {
+  BaseProvider,
+  CohereProvider,
+  HuggingFaceProvider,
+  LocalProvider,
+  OpenAIProvider,
+  VoyageProvider,
+  createCohereProvider,
+  createHuggingFaceProvider,
+  createLocalProvider,
+  createMockProvider,
+  createOpenAIProvider,
+  createRandomProvider,
+  createVoyageProvider
+} from "./chunk-NBHIRTJT.mjs";
+import {
+  BaseStore,
+  ChromaStore,
+  MemoryStore,
+  PineconeStore,
+  QdrantStore,
+  createChromaStore,
+  createMemoryStore,
+  createPineconeStore,
+  createQdrantStore,
+  createStore
+} from "./chunk-TER262ST.mjs";
+import {
+  batch,
+  cacheKey,
+  clamp,
+  contentHash,
+  createEventEmitter,
+  deepClone,
+  deferred,
+  estimateTokens,
+  formatBytes,
+  formatDuration,
+  generateId,
+  mean,
+  measureTime,
+  normalize,
+  percentile,
+  retry,
+  sleep,
+  splitByChars,
+  splitBySeparator,
+  stdDev,
+  variance,
+  withConcurrency
+} from "./chunk-3KM32UQK.mjs";
+import {
+  EmbeddingModel,
+  ModelRegistry,
+  modelRegistry
+} from "./chunk-QAITLJ2E.mjs";
+
+// src/core/EmbeddingManager.ts
+import EventEmitter from "eventemitter3";
+var EmbeddingManager = class extends EventEmitter {
+  config;
+  modelRegistry;
+  cache = null;
+  chunker = null;
+  store = null;
+  stats;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      defaultModel: config.defaultModel ?? "text-embedding-3-small",
+      defaultProvider: config.defaultProvider ?? "openai",
+      caching: config.caching ?? true,
+      batchSize: config.batchSize ?? 100,
+      concurrency: config.concurrency ?? 5,
+      retry: {
+        maxRetries: config.retry?.maxRetries ?? 3,
+        initialDelay: config.retry?.initialDelay ?? 1e3,
+        maxDelay: config.retry?.maxDelay ?? 3e4
+      }
+    };
+    this.modelRegistry = new ModelRegistry();
+    this.stats = this.createInitialStats();
+  }
+  createInitialStats() {
+    return {
+      totalEmbeddings: 0,
+      totalTokens: 0,
+      avgLatencyMs: 0,
+      cacheHitRate: 0,
+      apiCalls: 0,
+      errors: 0,
+      estimatedCostUSD: 0
+    };
+  }
+  /**
+   * Register an embedding model
+   */
+  registerModel(model, isDefault = false) {
+    this.modelRegistry.register(model, isDefault);
+    if (isDefault) {
+      this.config.defaultModel = model.name;
+      this.config.defaultProvider = model.provider;
+    }
+    return this;
+  }
+  /**
+   * Set the cache implementation
+   */
+  setCache(cache) {
+    this.cache = cache;
+    return this;
+  }
+  /**
+   * Set the chunker implementation
+   */
+  setChunker(chunker) {
+    this.chunker = chunker;
+    return this;
+  }
+  /**
+   * Set the store implementation
+   */
+  setStore(store) {
+    this.store = store;
+    return this;
+  }
+  /**
+   * Get the model to use for embedding
+   */
+  getModel(options) {
+    const modelName = options?.model ?? this.config.defaultModel;
+    const model = this.modelRegistry.getByKey(
+      `${this.config.defaultProvider}:${modelName}`
+    ) ?? this.modelRegistry.getDefault();
+    if (!model) {
+      throw new Error(`No embedding model found. Register a model first.`);
+    }
+    return model;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async embed(text, options) {
+    this.emit("embed:start", text, options);
+    const model = this.getModel(options);
+    if (this.config.caching && this.cache && !options?.skipCache) {
+      const key = cacheKey(text, model.name);
+      const cached = await this.cache.get(key);
+      if (cached) {
+        this.emit("cache:hit", key);
+        this.updateStats({ cacheHits: 1 });
+        this.emit("embed:complete", { ...cached, cached: true });
+        return { ...cached, cached: true };
+      }
+      this.emit("cache:miss", key);
+    }
+    try {
+      const { result, durationMs } = await measureTime(
+        () => model.embed(text, options)
+      );
+      const finalResult = {
+        ...result,
+        latencyMs: durationMs,
+        cached: false
+      };
+      if (this.config.caching && this.cache && !options?.skipCache) {
+        const key = cacheKey(text, model.name);
+        await this.cache.set(key, finalResult);
+      }
+      this.updateStats({
+        embeddings: 1,
+        tokens: finalResult.tokenCount,
+        latency: durationMs,
+        apiCalls: 1,
+        cost: this.estimateCost(model, finalResult.tokenCount)
+      });
+      this.emit("embed:complete", finalResult);
+      return finalResult;
+    } catch (error) {
+      this.stats.errors++;
+      this.emit("embed:error", error, text);
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts
+   */
+  async embedBatch(texts, options) {
+    this.emit("batch:start", texts, options);
+    const model = this.getModel(options);
+    const batchSize = options?.concurrency ?? this.config.batchSize;
+    const results = [];
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    let failures = 0;
+    let totalTokens = 0;
+    const startTime = performance.now();
+    const cacheResults = /* @__PURE__ */ new Map();
+    const textsToEmbed = [];
+    if (this.config.caching && this.cache && !options?.skipCache) {
+      for (let i = 0; i < texts.length; i++) {
+        const key = cacheKey(texts[i], model.name);
+        const cached = await this.cache.get(key);
+        if (cached) {
+          cacheResults.set(i, { ...cached, cached: true });
+          cacheHits++;
+        } else {
+          textsToEmbed.push({ index: i, text: texts[i] });
+          cacheMisses++;
+        }
+      }
+    } else {
+      textsToEmbed.push(...texts.map((text, index) => ({ index, text })));
+      cacheMisses = texts.length;
+    }
+    const batches = batch(textsToEmbed, batchSize);
+    let processedCount = cacheResults.size;
+    for (const batchItems of batches) {
+      const batchTexts = batchItems.map((item) => item.text);
+      try {
+        const { result: batchResult2 } = await measureTime(
+          () => model.embedBatch(batchTexts, options)
+        );
+        for (let i = 0; i < batchResult2.results.length; i++) {
+          const item = batchItems[i];
+          const embeddingResult = batchResult2.results[i];
+          cacheResults.set(item.index, embeddingResult);
+          if (this.config.caching && this.cache && !options?.skipCache) {
+            const key = cacheKey(item.text, model.name);
+            await this.cache.set(key, embeddingResult);
+          }
+        }
+        totalTokens += batchResult2.totalTokens;
+        processedCount += batchItems.length;
+      } catch (error) {
+        if (options?.continueOnError) {
+          failures += batchItems.length;
+          processedCount += batchItems.length;
+        } else {
+          throw error;
+        }
+      }
+      this.emit("batch:progress", {
+        completed: processedCount,
+        total: texts.length
+      });
+      options?.onProgress?.({
+        percent: processedCount / texts.length * 100,
+        processed: processedCount,
+        total: texts.length,
+        elapsedMs: performance.now() - startTime
+      });
+    }
+    for (let i = 0; i < texts.length; i++) {
+      const result = cacheResults.get(i);
+      if (result) {
+        results.push(result);
+      }
+    }
+    const totalLatencyMs = performance.now() - startTime;
+    const batchResult = {
+      results,
+      totalTokens,
+      totalLatencyMs,
+      cacheHits,
+      cacheMisses,
+      failures
+    };
+    this.updateStats({
+      embeddings: results.length,
+      tokens: totalTokens,
+      latency: totalLatencyMs / results.length,
+      apiCalls: batches.length,
+      cacheHits,
+      cost: this.estimateCost(model, totalTokens)
+    });
+    this.emit("batch:complete", batchResult);
+    return batchResult;
+  }
+  /**
+   * Embed a document with chunking
+   */
+  async embedDocument(text, options) {
+    if (!this.chunker) {
+      throw new Error("No chunker configured. Use setChunker() first.");
+    }
+    const chunks = await this.chunker.chunk(
+      text,
+      options
+    );
+    const chunkTexts = chunks.map((c) => c.text);
+    const embedResult = await this.embedBatch(chunkTexts, options);
+    const embeddedChunks = [];
+    let position = 0;
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk2 = chunks[i];
+      const result = embedResult.results[i];
+      if (result) {
+        embeddedChunks.push({
+          id: generateId("chunk"),
+          text: chunk2.text,
+          vector: result.vector,
+          index: i,
+          startPosition: position,
+          endPosition: position + chunk2.text.length,
+          tokenCount: result.tokenCount,
+          metadata: {
+            documentId: options?.documentId,
+            source: options?.source,
+            type: options?.type,
+            ...chunk2.metadata,
+            ...options?.chunkMetadata
+          }
+        });
+      }
+      position += chunk2.text.length;
+    }
+    if (this.store) {
+      await this.store.upsert(embeddedChunks, options?.documentId);
+    }
+    return embeddedChunks;
+  }
+  /**
+   * Search for similar content
+   */
+  async search(query, options) {
+    if (!this.store) {
+      throw new Error("No store configured. Use setStore() first.");
+    }
+    const queryResult = await this.embed(query);
+    return this.store.query(queryResult.vector, options);
+  }
+  /**
+   * Calculate similarity between two texts
+   */
+  async similarity(text1, text2) {
+    const [result1, result2] = await Promise.all([
+      this.embed(text1),
+      this.embed(text2)
+    ]);
+    return EmbeddingModel.cosineSimilarity(result1.vector, result2.vector);
+  }
+  /**
+   * Get embedding statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = this.createInitialStats();
+  }
+  /**
+   * Get registered models
+   */
+  getModels() {
+    return this.modelRegistry.list().map((m) => ({
+      provider: m.provider,
+      name: m.name,
+      dimensions: m.dimensions
+    }));
+  }
+  /**
+   * Update statistics
+   */
+  updateStats(update) {
+    if (update.embeddings) {
+      this.stats.totalEmbeddings += update.embeddings;
+    }
+    if (update.tokens) {
+      this.stats.totalTokens += update.tokens;
+    }
+    if (update.latency) {
+      const n = this.stats.totalEmbeddings;
+      this.stats.avgLatencyMs = (this.stats.avgLatencyMs * (n - 1) + update.latency) / n;
+    }
+    if (update.apiCalls) {
+      this.stats.apiCalls += update.apiCalls;
+    }
+    if (update.cacheHits !== void 0) {
+      const totalLookups = this.stats.totalEmbeddings;
+      const currentHits = this.stats.cacheHitRate * (totalLookups - 1);
+      this.stats.cacheHitRate = (currentHits + update.cacheHits) / totalLookups;
+    }
+    if (update.cost) {
+      this.stats.estimatedCostUSD += update.cost;
+    }
+  }
+  /**
+   * Estimate cost for embedding tokens
+   */
+  estimateCost(model, tokens) {
+    const costPer1K = model.info.costPer1K ?? 0;
+    return tokens / 1e3 * costPer1K;
+  }
+};
+function createEmbeddingManager(config) {
+  return new EmbeddingManager(config);
+}
+
+// src/versioning/VersionRegistry.ts
+import { nanoid } from "nanoid";
+import EventEmitter2 from "eventemitter3";
+var VersionRegistry = class extends EventEmitter2 {
+  versions = /* @__PURE__ */ new Map();
+  activeVersion = null;
+  options;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      autoRegister: options.autoRegister ?? true,
+      trackUsage: options.trackUsage ?? true,
+      maxVersions: options.maxVersions ?? 100,
+      ...options
+    };
+  }
+  /**
+   * Register a new version
+   */
+  register(version) {
+    const newVersion = {
+      ...version,
+      id: nanoid(),
+      createdAt: Date.now(),
+      active: false,
+      deprecated: false
+    };
+    const entry = {
+      version: newVersion,
+      documentCount: 0,
+      chunkCount: 0,
+      firstUsed: 0,
+      lastUsed: 0
+    };
+    this.versions.set(newVersion.id, entry);
+    if (this.versions.size === 1) {
+      this.activate(newVersion.id);
+    }
+    if (this.versions.size > (this.options.maxVersions ?? 100)) {
+      this.pruneOldVersions();
+    }
+    this.emit("version:created", newVersion);
+    this.emitChange("created", newVersion.id);
+    return newVersion;
+  }
+  /**
+   * Get a version by ID
+   */
+  get(id) {
+    return this.versions.get(id)?.version;
+  }
+  /**
+   * Get the active version
+   */
+  getActive() {
+    if (!this.activeVersion) return void 0;
+    return this.versions.get(this.activeVersion)?.version;
+  }
+  /**
+   * Activate a version
+   */
+  activate(id) {
+    const entry = this.versions.get(id);
+    if (!entry) {
+      throw new Error(`Version ${id} not found`);
+    }
+    const previousVersion = this.activeVersion ? this.versions.get(this.activeVersion)?.version : void 0;
+    if (this.activeVersion && this.activeVersion !== id) {
+      const prev = this.versions.get(this.activeVersion);
+      if (prev) {
+        prev.version.active = false;
+      }
+    }
+    entry.version.active = true;
+    this.activeVersion = id;
+    this.emit("version:activated", entry.version, previousVersion);
+    this.emitChange("activated", id, previousVersion?.id);
+  }
+  /**
+   * Deprecate a version
+   */
+  deprecate(id, reason, replacement) {
+    const entry = this.versions.get(id);
+    if (!entry) {
+      throw new Error(`Version ${id} not found`);
+    }
+    entry.version.deprecated = true;
+    entry.version.deprecationReason = reason;
+    entry.version.replacement = replacement;
+    this.emit("version:deprecated", entry.version, reason);
+    this.emitChange("deprecated", id);
+  }
+  /**
+   * Delete a version
+   */
+  delete(id) {
+    if (this.activeVersion === id) {
+      throw new Error("Cannot delete active version");
+    }
+    const deleted = this.versions.delete(id);
+    if (deleted) {
+      this.emit("version:deleted", id);
+      this.emitChange("deleted", id);
+    }
+    return deleted;
+  }
+  /**
+   * List all versions
+   */
+  list() {
+    return Array.from(this.versions.values()).map((e) => e.version);
+  }
+  /**
+   * Find versions by provider
+   */
+  findByProvider(provider) {
+    return this.list().filter((v) => v.provider === provider);
+  }
+  /**
+   * Find versions by model
+   */
+  findByModel(model) {
+    return this.list().filter((v) => v.model === model);
+  }
+  /**
+   * Compare two versions
+   */
+  compare(sourceId, targetId) {
+    const source = this.get(sourceId);
+    const target = this.get(targetId);
+    if (!source || !target) {
+      throw new Error("One or both versions not found");
+    }
+    const dimensionChange = target.dimensions - source.dimensions;
+    const providerChanged = source.provider !== target.provider;
+    const migrationRequired = dimensionChange !== 0 || providerChanged || source.model !== target.model;
+    let migrationComplexity = "low";
+    if (dimensionChange !== 0) {
+      migrationComplexity = "high";
+    } else if (providerChanged) {
+      migrationComplexity = "medium";
+    }
+    const notes = [];
+    if (dimensionChange > 0) {
+      notes.push(`Dimensions increase by ${dimensionChange}`);
+    } else if (dimensionChange < 0) {
+      notes.push(`Dimensions decrease by ${Math.abs(dimensionChange)}`);
+    }
+    if (providerChanged) {
+      notes.push(
+        `Provider changes from ${source.provider} to ${target.provider}`
+      );
+    }
+    if (source.model !== target.model) {
+      notes.push(`Model changes from ${source.model} to ${target.model}`);
+    }
+    return {
+      source,
+      target,
+      compatible: dimensionChange === 0,
+      dimensionChange,
+      providerChanged,
+      migrationRequired,
+      migrationComplexity,
+      notes
+    };
+  }
+  /**
+   * Get upgrade path between versions
+   */
+  getUpgradePath(fromId, toId) {
+    const comparison = this.compare(fromId, toId);
+    return {
+      from: fromId,
+      to: toId,
+      steps: comparison.migrationRequired ? ["backup", "re-embed", "verify", "switch"] : ["switch"],
+      direct: !comparison.migrationRequired,
+      complexity: comparison.migrationComplexity,
+      breakingChanges: comparison.dimensionChange !== 0 ? [`Dimension change: ${comparison.dimensionChange}`] : []
+    };
+  }
+  /**
+   * Track usage of a version
+   */
+  trackUsage(id, documents = 0, chunks = 0) {
+    if (!this.options.trackUsage) return;
+    const entry = this.versions.get(id);
+    if (!entry) return;
+    const now = Date.now();
+    if (entry.firstUsed === 0) {
+      entry.firstUsed = now;
+    }
+    entry.lastUsed = now;
+    entry.documentCount += documents;
+    entry.chunkCount += chunks;
+  }
+  /**
+   * Get usage stats for a version
+   */
+  getUsageStats(id) {
+    return this.versions.get(id);
+  }
+  /**
+   * Prune old inactive versions
+   */
+  pruneOldVersions() {
+    const entries = Array.from(this.versions.entries()).filter(([id]) => id !== this.activeVersion).sort((a, b) => a[1].lastUsed - b[1].lastUsed);
+    const toRemove = entries.slice(
+      0,
+      entries.length - (this.options.maxVersions ?? 100) + 1
+    );
+    for (const [id] of toRemove) {
+      this.versions.delete(id);
+      this.emitChange("deleted", id);
+    }
+  }
+  /**
+   * Emit change event
+   */
+  emitChange(type, versionId, previousVersion) {
+    this.emit("change", {
+      type,
+      versionId,
+      previousVersion,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Export registry state
+   */
+  export() {
+    return {
+      versions: Array.from(this.versions.values()),
+      activeVersion: this.activeVersion
+    };
+  }
+  /**
+   * Import registry state
+   */
+  import(data) {
+    this.versions.clear();
+    for (const entry of data.versions) {
+      this.versions.set(entry.version.id, entry);
+    }
+    this.activeVersion = data.activeVersion;
+  }
+};
+function createVersionRegistry(options) {
+  return new VersionRegistry(options);
+}
+
+// src/quality/DriftDetector.ts
+import EventEmitter3 from "eventemitter3";
+import { nanoid as nanoid2 } from "nanoid";
+var DriftDetector = class extends EventEmitter3 {
+  reference = null;
+  config;
+  monitorInterval;
+  sampleBuffer = [];
+  constructor(config = {}) {
+    super();
+    this.config = {
+      checkInterval: config.checkInterval ?? 36e5,
+      // 1 hour
+      sampleSize: config.sampleSize ?? 1e3,
+      driftThreshold: config.driftThreshold ?? 0.1,
+      alertSeverity: config.alertSeverity ?? "medium",
+      autoUpdateBaseline: config.autoUpdateBaseline ?? false,
+      baselineUpdateInterval: config.baselineUpdateInterval ?? 864e5,
+      // 24 hours
+      ...config
+    };
+  }
+  /**
+   * Set reference distribution from embeddings
+   */
+  setReference(embeddings, model, version) {
+    if (embeddings.length === 0) {
+      throw new Error("Cannot create reference from empty embeddings");
+    }
+    const dimensions = embeddings[0].length;
+    const meanVector = EmbeddingModel.average(embeddings);
+    const varianceVector = [];
+    for (let d = 0; d < dimensions; d++) {
+      const values = embeddings.map((e) => e[d]);
+      varianceVector.push(variance(values));
+    }
+    this.reference = {
+      id: nanoid2(),
+      model,
+      version,
+      sampleCount: embeddings.length,
+      mean: meanVector,
+      variance: varianceVector,
+      createdAt: Date.now()
+    };
+    this.emit("baseline:updated", this.reference);
+    return this.reference;
+  }
+  /**
+   * Get current reference distribution
+   */
+  getReference() {
+    return this.reference;
+  }
+  /**
+   * Detect drift from reference distribution
+   */
+  detect(currentEmbeddings) {
+    if (!this.reference) {
+      throw new Error("No reference distribution set");
+    }
+    if (currentEmbeddings.length === 0) {
+      throw new Error("Cannot detect drift from empty embeddings");
+    }
+    const dimensions = this.reference.mean.length;
+    const currentMean = EmbeddingModel.average(currentEmbeddings);
+    const currentVariance = [];
+    for (let d = 0; d < dimensions; d++) {
+      const values = currentEmbeddings.map((e) => e[d]);
+      currentVariance.push(variance(values));
+    }
+    const comparison = this.compareDistributions(
+      this.reference.mean,
+      this.reference.variance,
+      currentMean,
+      currentVariance
+    );
+    const driftScore = this.calculateDriftScore(comparison);
+    const severity = this.determineSeverity(driftScore);
+    const affectedDimensions = comparison.dimensionStats?.filter((s) => s.significantChange).length ?? 0;
+    const result = {
+      driftDetected: driftScore >= (this.config.driftThreshold ?? 0.1),
+      severity,
+      driftScore,
+      affectedDimensionsPercent: affectedDimensions / dimensions * 100,
+      meanShift: comparison.meanCosineSimilarity,
+      varianceChange: mean(
+        currentVariance.map(
+          (v, i) => Math.abs(v - this.reference.variance[i]) / (this.reference.variance[i] || 1)
+        )
+      ),
+      distributionComparison: comparison,
+      detectedAt: Date.now(),
+      referenceTimestamp: this.reference.createdAt,
+      currentTimestamp: Date.now(),
+      recommendations: this.generateRecommendations(driftScore, severity)
+    };
+    if (result.driftDetected) {
+      this.emit("drift:detected", result);
+      if (this.shouldAlert(severity)) {
+        this.emitAlert(result);
+      }
+    }
+    return result;
+  }
+  /**
+   * Compare two distributions
+   */
+  compareDistributions(refMean, refVariance, curMean, curVariance) {
+    const dimensions = refMean.length;
+    const meanCosineSimilarity = EmbeddingModel.cosineSimilarity(
+      refMean,
+      curMean
+    );
+    let klDivergence = 0;
+    for (let d = 0; d < dimensions; d++) {
+      const refVar = refVariance[d] || 1e-4;
+      const curVar = curVariance[d] || 1e-4;
+      const meanDiff = curMean[d] - refMean[d];
+      klDivergence += Math.log(Math.sqrt(curVar / refVar)) + (refVar + meanDiff * meanDiff) / (2 * curVar) - 0.5;
+    }
+    klDivergence = Math.max(0, klDivergence / dimensions);
+    const jsDivergence = klDivergence / 2;
+    let wassersteinDistance = 0;
+    for (let d = 0; d < dimensions; d++) {
+      const meanDiff = Math.abs(curMean[d] - refMean[d]);
+      const stdDiff = Math.abs(
+        Math.sqrt(curVariance[d]) - Math.sqrt(refVariance[d])
+      );
+      wassersteinDistance += meanDiff + stdDiff;
+    }
+    wassersteinDistance /= dimensions;
+    const dimensionStats = [];
+    for (let d = 0; d < dimensions; d++) {
+      const meanChange = curMean[d] - refMean[d];
+      const varChange = curVariance[d] - refVariance[d];
+      const refStd = Math.sqrt(refVariance[d] || 1e-4);
+      dimensionStats.push({
+        dimension: d,
+        referenceMean: refMean[d],
+        currentMean: curMean[d],
+        meanChange,
+        referenceVariance: refVariance[d],
+        currentVariance: curVariance[d],
+        varianceChange: varChange,
+        significantChange: Math.abs(meanChange) > 2 * refStd
+      });
+    }
+    return {
+      klDivergence,
+      jsDivergence,
+      wassersteinDistance,
+      meanCosineSimilarity,
+      dimensionStats
+    };
+  }
+  /**
+   * Calculate overall drift score
+   */
+  calculateDriftScore(comparison) {
+    const cosineDistance = 1 - comparison.meanCosineSimilarity;
+    const klScore = Math.min(1, comparison.klDivergence / 10);
+    const wasserstein = Math.min(1, comparison.wassersteinDistance);
+    return cosineDistance * 0.4 + klScore * 0.3 + wasserstein * 0.3;
+  }
+  /**
+   * Determine severity based on drift score
+   */
+  determineSeverity(driftScore) {
+    if (driftScore < 0.05) return "none";
+    if (driftScore < 0.1) return "low";
+    if (driftScore < 0.2) return "medium";
+    if (driftScore < 0.4) return "high";
+    return "critical";
+  }
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(driftScore, severity) {
+    const recommendations = [];
+    if (severity === "none" || severity === "low") {
+      recommendations.push("Continue monitoring");
+    }
+    if (severity === "medium") {
+      recommendations.push("Consider updating the baseline distribution");
+      recommendations.push("Review recent changes to input data");
+    }
+    if (severity === "high") {
+      recommendations.push("Re-embed affected documents");
+      recommendations.push("Update baseline distribution immediately");
+      recommendations.push("Investigate root cause of drift");
+    }
+    if (severity === "critical") {
+      recommendations.push("URGENT: Stop accepting new embeddings");
+      recommendations.push("Full re-embedding required");
+      recommendations.push("Review embedding model for issues");
+    }
+    return recommendations;
+  }
+  /**
+   * Check if should alert
+   */
+  shouldAlert(severity) {
+    const severityOrder = ["none", "low", "medium", "high", "critical"];
+    const alertLevel = this.config.alertSeverity ?? "medium";
+    return severityOrder.indexOf(severity) >= severityOrder.indexOf(alertLevel);
+  }
+  /**
+   * Emit quality alert
+   */
+  emitAlert(result) {
+    const alert = {
+      id: nanoid2(),
+      type: "drift_detected",
+      severity: result.severity,
+      message: `Embedding drift detected with score ${result.driftScore.toFixed(3)}`,
+      currentValue: result.driftScore,
+      thresholdValue: this.config.driftThreshold,
+      createdAt: Date.now(),
+      acknowledged: false
+    };
+    this.emit("drift:alert", alert);
+    this.config.onAlert?.(result);
+  }
+  /**
+   * Add sample to buffer for monitoring
+   */
+  addSample(embedding) {
+    this.sampleBuffer.push(embedding);
+    if (this.sampleBuffer.length >= (this.config.sampleSize ?? 1e3)) {
+      if (this.reference) {
+        this.detect(this.sampleBuffer);
+      }
+      this.sampleBuffer = [];
+    }
+  }
+  /**
+   * Start continuous monitoring
+   */
+  startMonitoring() {
+    if (this.monitorInterval) return;
+    this.monitorInterval = setInterval(() => {
+      if (this.reference && this.sampleBuffer.length >= 100) {
+        this.detect(this.sampleBuffer);
+        this.sampleBuffer = [];
+      }
+    }, this.config.checkInterval);
+  }
+  /**
+   * Stop monitoring
+   */
+  stopMonitoring() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+      this.monitorInterval = void 0;
+    }
+  }
+};
+function createDriftDetector(config) {
+  return new DriftDetector(config);
+}
+export {
+  BaseCache,
+  BaseChunker,
+  BaseProvider,
+  BaseStore,
+  ChromaStore,
+  CodeChunker,
+  CohereProvider,
+  DriftDetector,
+  EmbeddingManager,
+  EmbeddingModel,
+  FixedChunker,
+  HuggingFaceProvider,
+  LocalProvider,
+  MarkdownChunker,
+  MemoryCache,
+  MemoryStore,
+  ModelRegistry,
+  OpenAIProvider,
+  PineconeStore,
+  QdrantStore,
+  RecursiveChunker,
+  RedisCache,
+  SQLiteCache,
+  SemanticChunker,
+  TieredCache,
+  VersionRegistry,
+  VoyageProvider,
+  batch,
+  cacheKey,
+  chunk,
+  clamp,
+  contentHash,
+  createCache,
+  createChromaStore,
+  createChunker,
+  createCodeChunker,
+  createCohereProvider,
+  createDriftDetector,
+  createEmbeddingManager,
+  createEventEmitter,
+  createFixedChunker,
+  createHuggingFaceProvider,
+  createLocalProvider,
+  createMarkdownChunker,
+  createMemoryCache,
+  createMemoryStore,
+  createMockProvider,
+  createOpenAIProvider,
+  createPineconeStore,
+  createQdrantStore,
+  createRandomProvider,
+  createRecursiveChunker,
+  createRedisCache,
+  createSQLiteCache,
+  createSemanticChunker,
+  createStandardTieredCache,
+  createStore,
+  createTieredCache,
+  createVersionRegistry,
+  createVoyageProvider,
+  deepClone,
+  defaultTokenCounter,
+  deferred,
+  estimateTokens,
+  formatBytes,
+  formatDuration,
+  generateId,
+  mean,
+  measureTime,
+  mergeSmallChunks,
+  modelRegistry,
+  normalize,
+  percentile,
+  retry,
+  sleep,
+  splitByChars,
+  splitBySeparator,
+  splitLargeChunks,
+  stdDev,
+  variance,
+  withConcurrency
+};