@lov3kaizen/agentsea-cache 0.5.1

package/dist/stores/index.js

@@ -0,0 +1,1147 @@
+import { LRUCache } from 'lru-cache';
+import 'nanoid';
+
+// src/stores/BaseCacheStore.ts
+var BaseCacheStore = class {
+  /** Store configuration */
+  config;
+  /** Store metrics */
+  metrics = {
+    gets: 0,
+    sets: 0,
+    deletes: 0,
+    hits: 0,
+    misses: 0
+  };
+  constructor(config) {
+    this.config = {
+      namespace: config.namespace ?? "default",
+      ...config
+    };
+  }
+  /**
+   * Get the store namespace
+   */
+  get namespace() {
+    return this.config.namespace ?? "default";
+  }
+  /**
+   * Get store metrics
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Reset store metrics
+   */
+  resetMetrics() {
+    this.metrics = {
+      gets: 0,
+      sets: 0,
+      deletes: 0,
+      hits: 0,
+      misses: 0
+    };
+  }
+  /**
+   * Increment a metric counter
+   */
+  incrementMetric(metric, amount = 1) {
+    if (typeof this.metrics[metric] === "number") {
+      this.metrics[metric] += amount;
+    }
+  }
+};
+function now() {
+  return Date.now();
+}
+function estimateEntrySize(entry) {
+  const vectorSize = (entry.embedding?.length ?? 0) * 4;
+  const messageSize = entry.request.messages.reduce(
+    (acc, m) => acc + (m.content?.length ?? 0) * 2,
+    0
+  );
+  const responseSize = (entry.response.content?.length ?? 0) * 2;
+  const overheadSize = 500;
+  return vectorSize + messageSize + responseSize + overheadSize;
+}
+
+// src/stores/MemoryCacheStore.ts
+var DEFAULT_CONFIG = {
+  maxEntries: 1e4,
+  maxSizeBytes: 1024 * 1024 * 1024,
+  // 1GB
+  evictionPolicy: "lru"
+};
+var MemoryCacheStore = class extends BaseCacheStore {
+  storeType = "memory";
+  cache;
+  vectors = /* @__PURE__ */ new Map();
+  memoryConfig;
+  closed = false;
+  constructor(config = { type: "memory" }) {
+    super(config);
+    this.memoryConfig = { ...DEFAULT_CONFIG, ...config };
+    this.cache = new LRUCache({
+      max: this.memoryConfig.maxEntries ?? 1e4,
+      maxSize: this.memoryConfig.maxSizeBytes ?? 1024 * 1024 * 1024,
+      sizeCalculation: (entry) => estimateEntrySize(entry),
+      ttl: 0,
+      // TTL handled per-entry
+      updateAgeOnGet: true,
+      allowStale: false
+    });
+  }
+  get(key) {
+    this.incrementMetric("gets");
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.incrementMetric("hits");
+      entry.metadata.accessedAt = now();
+      entry.metadata.accessCount++;
+      return Promise.resolve(entry);
+    }
+    this.incrementMetric("misses");
+    return Promise.resolve(void 0);
+  }
+  set(key, entry) {
+    const startTime = performance.now();
+    this.incrementMetric("sets");
+    const ttlMs = entry.metadata.ttl > 0 ? entry.metadata.ttl * 1e3 : void 0;
+    this.cache.set(key, entry, { ttl: ttlMs });
+    if (entry.embedding && entry.embedding.length > 0) {
+      this.vectors.set(key, {
+        id: entry.id,
+        vector: entry.embedding
+      });
+    }
+    return Promise.resolve({
+      success: true,
+      id: entry.id,
+      durationMs: performance.now() - startTime
+    });
+  }
+  has(key) {
+    return Promise.resolve(this.cache.has(key));
+  }
+  delete(key) {
+    this.incrementMetric("deletes");
+    const existed = this.cache.has(key);
+    this.cache.delete(key);
+    this.vectors.delete(key);
+    return Promise.resolve(existed);
+  }
+  clear() {
+    this.cache.clear();
+    this.vectors.clear();
+    return Promise.resolve();
+  }
+  size() {
+    return Promise.resolve(this.cache.size);
+  }
+  keys() {
+    return Promise.resolve(Array.from(this.cache.keys()));
+  }
+  query(vector, options) {
+    const startTime = performance.now();
+    const topK = options?.topK ?? 10;
+    const minSimilarity = options?.minSimilarity ?? 0;
+    const results = [];
+    for (const [key, stored] of this.vectors) {
+      const entry = this.cache.get(key);
+      if (!entry) continue;
+      if (options?.namespace && entry.metadata.namespace !== options.namespace) {
+        continue;
+      }
+      const similarity = this.cosineSimilarity(vector, stored.vector);
+      if (similarity >= minSimilarity) {
+        results.push({ ...entry, score: similarity });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return Promise.resolve({
+      entries: results.slice(0, topK),
+      durationMs: performance.now() - startTime
+    });
+  }
+  checkHealth() {
+    return Promise.resolve({
+      healthy: !this.closed,
+      latencyMs: 0,
+      lastCheck: now(),
+      error: this.closed ? "Store is closed" : void 0
+    });
+  }
+  close() {
+    this.closed = true;
+    this.cache.clear();
+    this.vectors.clear();
+    return Promise.resolve();
+  }
+  /**
+   * Compute cosine similarity between two vectors
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0) return 0;
+    return dotProduct / denominator;
+  }
+  /**
+   * Get memory usage information
+   */
+  getMemoryInfo() {
+    return {
+      entries: this.cache.size,
+      calculatedSize: this.cache.calculatedSize ?? 0,
+      maxSize: this.memoryConfig.maxSizeBytes ?? 0,
+      vectorCount: this.vectors.size
+    };
+  }
+  /**
+   * Prune expired entries
+   */
+  prune() {
+    this.cache.purgeStale();
+    let pruned = 0;
+    for (const key of this.vectors.keys()) {
+      if (!this.cache.has(key)) {
+        this.vectors.delete(key);
+        pruned++;
+      }
+    }
+    return Promise.resolve(pruned);
+  }
+};
+function createMemoryCacheStore(config) {
+  return new MemoryCacheStore({ type: "memory", ...config });
+}
+
+// src/similarity/metrics/SimilarityMetrics.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) return 0;
+  return dotProduct / denominator;
+}
+
+// src/stores/RedisCacheStore.ts
+var DEFAULT_CONFIG2 = {
+  host: "localhost",
+  port: 6379,
+  db: 0,
+  keyPrefix: "llm-cache",
+  connectTimeout: 1e4
+};
+var RedisCacheStore = class extends BaseCacheStore {
+  storeType = "redis";
+  client = null;
+  redisConfig;
+  connected = false;
+  constructor(config) {
+    super(config);
+    this.redisConfig = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /**
+   * Connect to Redis
+   */
+  async connect() {
+    if (this.connected) return;
+    try {
+      const { Redis } = await import('ioredis');
+      if (this.redisConfig.url) {
+        this.client = new Redis(this.redisConfig.url, {
+          connectTimeout: this.redisConfig.connectTimeout ?? 1e4,
+          lazyConnect: false,
+          tls: this.redisConfig.tls ? {} : void 0
+        });
+      } else {
+        this.client = new Redis({
+          host: this.redisConfig.host ?? "localhost",
+          port: this.redisConfig.port ?? 6379,
+          password: this.redisConfig.password,
+          db: this.redisConfig.db ?? 0,
+          connectTimeout: this.redisConfig.connectTimeout ?? 1e4,
+          tls: this.redisConfig.tls ? {} : void 0
+        });
+      }
+      await this.client.ping();
+      this.connected = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to connect to Redis: ${error.message}`
+      );
+    }
+  }
+  async ensureConnected() {
+    if (!this.connected || !this.client) {
+      await this.connect();
+    }
+    if (!this.client) {
+      throw new Error("Redis client not initialized");
+    }
+    return this.client;
+  }
+  prefixKey(key) {
+    const prefix = this.redisConfig.keyPrefix ?? "llm-cache";
+    return `${prefix}:${this.namespace}:${key}`;
+  }
+  async get(key) {
+    this.incrementMetric("gets");
+    const client = await this.ensureConnected();
+    const data = await client.get(this.prefixKey(key));
+    if (!data) {
+      this.incrementMetric("misses");
+      return void 0;
+    }
+    this.incrementMetric("hits");
+    try {
+      const entry = JSON.parse(data);
+      entry.metadata.accessedAt = now();
+      entry.metadata.accessCount++;
+      client.set(this.prefixKey(key), JSON.stringify(entry)).catch(() => {
+      });
+      return entry;
+    } catch {
+      return void 0;
+    }
+  }
+  async set(key, entry) {
+    const startTime = performance.now();
+    this.incrementMetric("sets");
+    const client = await this.ensureConnected();
+    await client.set(this.prefixKey(key), JSON.stringify(entry));
+    if (entry.metadata.ttl > 0) {
+      await client.expire(this.prefixKey(key), entry.metadata.ttl);
+    }
+    return {
+      success: true,
+      id: entry.id,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async has(key) {
+    const client = await this.ensureConnected();
+    return await client.exists(this.prefixKey(key)) > 0;
+  }
+  async delete(key) {
+    this.incrementMetric("deletes");
+    const client = await this.ensureConnected();
+    return await client.del(this.prefixKey(key)) > 0;
+  }
+  async clear() {
+    const client = await this.ensureConnected();
+    const pattern = this.prefixKey("*");
+    const keys = await client.keys(pattern);
+    if (keys.length > 0) {
+      await client.del(...keys);
+    }
+  }
+  async size() {
+    const client = await this.ensureConnected();
+    const keys = await client.keys(this.prefixKey("*"));
+    return keys.length;
+  }
+  async keys() {
+    const client = await this.ensureConnected();
+    const keys = await client.keys(this.prefixKey("*"));
+    const prefix = this.prefixKey("");
+    return keys.map((k) => k.slice(prefix.length));
+  }
+  async query(vector, options) {
+    const startTime = performance.now();
+    const allKeys = await this.keys();
+    const entries = [];
+    const keysToProcess = allKeys.slice(0, 1e3);
+    for (const key of keysToProcess) {
+      const entry = await this.get(key);
+      if (entry?.embedding) {
+        const score = cosineSimilarity(vector, entry.embedding);
+        if (score >= (options?.minSimilarity ?? 0)) {
+          if (options?.namespace && entry.metadata.namespace !== options.namespace) {
+            continue;
+          }
+          entries.push({ ...entry, score });
+        }
+      }
+    }
+    entries.sort((a, b) => b.score - a.score);
+    return {
+      entries: entries.slice(0, options?.topK ?? 10),
+      durationMs: performance.now() - startTime
+    };
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    try {
+      const client = await this.ensureConnected();
+      await client.ping();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now()
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now(),
+        error: error.message
+      };
+    }
+  }
+  async close() {
+    if (this.client) {
+      await this.client.quit();
+      this.client = null;
+      this.connected = false;
+    }
+  }
+  /**
+   * Check if connected to Redis
+   */
+  isConnected() {
+    return this.connected;
+  }
+};
+function createRedisCacheStore(config) {
+  return new RedisCacheStore(config);
+}
+
+// src/stores/SQLiteCacheStore.ts
+var DEFAULT_CONFIG3 = {
+  dbPath: "cache.db",
+  inMemory: false,
+  enableVector: false
+};
+var SQLiteCacheStore = class extends BaseCacheStore {
+  storeType = "sqlite";
+  db = null;
+  sqliteConfig;
+  initialized = false;
+  constructor(config) {
+    super(config);
+    this.sqliteConfig = { ...DEFAULT_CONFIG3, ...config };
+  }
+  /**
+   * Initialize the database
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      const BetterSqlite3 = (await import('better-sqlite3')).default;
+      const db = new BetterSqlite3(
+        this.sqliteConfig.inMemory ? ":memory:" : this.sqliteConfig.dbPath ?? "cache.db"
+      );
+      this.db = db;
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS cache_entries (
+          key TEXT PRIMARY KEY,
+          id TEXT NOT NULL,
+          data TEXT NOT NULL,
+          embedding BLOB,
+          model TEXT NOT NULL,
+          namespace TEXT,
+          created_at INTEGER NOT NULL,
+          accessed_at INTEGER NOT NULL,
+          ttl INTEGER DEFAULT 0
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_namespace ON cache_entries(namespace);
+        CREATE INDEX IF NOT EXISTS idx_model ON cache_entries(model);
+        CREATE INDEX IF NOT EXISTS idx_created_at ON cache_entries(created_at);
+        CREATE INDEX IF NOT EXISTS idx_accessed_at ON cache_entries(accessed_at);
+      `);
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize SQLite database: ${error.message}`
+      );
+    }
+  }
+  ensureInitialized() {
+    if (!this.initialized || !this.db) {
+      throw new Error("SQLite store not initialized. Call init() first.");
+    }
+    return this.db;
+  }
+  get(key) {
+    this.incrementMetric("gets");
+    const db = this.ensureInitialized();
+    const row = db.prepare("SELECT data FROM cache_entries WHERE key = ?").get(key);
+    if (!row) {
+      this.incrementMetric("misses");
+      return Promise.resolve(void 0);
+    }
+    this.incrementMetric("hits");
+    try {
+      const entry = JSON.parse(row.data);
+      entry.metadata.accessedAt = now();
+      entry.metadata.accessCount++;
+      db.prepare(
+        "UPDATE cache_entries SET accessed_at = ?, data = ? WHERE key = ?"
+      ).run(now(), JSON.stringify(entry), key);
+      return Promise.resolve(entry);
+    } catch {
+      return Promise.resolve(void 0);
+    }
+  }
+  set(key, entry) {
+    const startTime = performance.now();
+    this.incrementMetric("sets");
+    const db = this.ensureInitialized();
+    const embedding = entry.embedding ? Buffer.from(new Float32Array(entry.embedding).buffer) : null;
+    db.prepare(
+      `
+      INSERT OR REPLACE INTO cache_entries
+      (key, id, data, embedding, model, namespace, created_at, accessed_at, ttl)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      key,
+      entry.id,
+      JSON.stringify(entry),
+      embedding,
+      entry.request.model,
+      entry.metadata.namespace ?? null,
+      entry.metadata.createdAt,
+      entry.metadata.accessedAt,
+      entry.metadata.ttl
+    );
+    return Promise.resolve({
+      success: true,
+      id: entry.id,
+      durationMs: performance.now() - startTime
+    });
+  }
+  has(key) {
+    const db = this.ensureInitialized();
+    const row = db.prepare("SELECT 1 FROM cache_entries WHERE key = ?").get(key);
+    return Promise.resolve(!!row);
+  }
+  delete(key) {
+    this.incrementMetric("deletes");
+    const db = this.ensureInitialized();
+    const result = db.prepare("DELETE FROM cache_entries WHERE key = ?").run(key);
+    return Promise.resolve(result.changes > 0);
+  }
+  clear() {
+    const db = this.ensureInitialized();
+    if (this.namespace === "default") {
+      db.prepare("DELETE FROM cache_entries").run();
+    } else {
+      db.prepare("DELETE FROM cache_entries WHERE namespace = ?").run(
+        this.namespace
+      );
+    }
+    return Promise.resolve();
+  }
+  size() {
+    const db = this.ensureInitialized();
+    const row = db.prepare("SELECT COUNT(*) as count FROM cache_entries").get();
+    return Promise.resolve(row.count);
+  }
+  keys() {
+    const db = this.ensureInitialized();
+    const rows = db.prepare("SELECT key FROM cache_entries").all();
+    return Promise.resolve(rows.map((r) => r.key));
+  }
+  query(vector, options) {
+    const startTime = performance.now();
+    const db = this.ensureInitialized();
+    let sql = `
+      SELECT key, data, embedding FROM cache_entries
+      WHERE embedding IS NOT NULL
+    `;
+    const params = [];
+    if (options?.namespace) {
+      sql += " AND namespace = ?";
+      params.push(options.namespace);
+    }
+    const rows = db.prepare(sql).all(...params);
+    const results = [];
+    for (const row of rows) {
+      const stored = new Float32Array(
+        row.embedding.buffer,
+        row.embedding.byteOffset,
+        row.embedding.length / 4
+      );
+      const similarity = cosineSimilarity(vector, Array.from(stored));
+      if (similarity >= (options?.minSimilarity ?? 0)) {
+        try {
+          const entry = JSON.parse(row.data);
+          results.push({ ...entry, score: similarity });
+        } catch {
+        }
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return Promise.resolve({
+      entries: results.slice(0, options?.topK ?? 10),
+      durationMs: performance.now() - startTime
+    });
+  }
+  checkHealth() {
+    const startTime = performance.now();
+    try {
+      this.ensureInitialized();
+      return Promise.resolve({
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now()
+      });
+    } catch (error) {
+      return Promise.resolve({
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now(),
+        error: error.message
+      });
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.initialized = false;
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Prune expired entries
+   */
+  pruneExpired() {
+    const db = this.ensureInitialized();
+    const currentTime = now();
+    const result = db.prepare(
+      `
+      DELETE FROM cache_entries
+      WHERE ttl > 0 AND (created_at + (ttl * 1000)) < ?
+    `
+    ).run(currentTime);
+    return Promise.resolve(result.changes);
+  }
+  /**
+   * Get database file size (for non-memory databases)
+   */
+  async getDbSize() {
+    if (this.sqliteConfig.inMemory) return null;
+    try {
+      const { statSync } = await import('fs');
+      const stats = statSync(this.sqliteConfig.dbPath ?? "cache.db");
+      return stats.size;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if database is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+function createSQLiteCacheStore(config) {
+  return new SQLiteCacheStore(config);
+}
+
+// src/stores/TieredCacheStore.ts
+var TieredCacheStore = class extends BaseCacheStore {
+  storeType = "tiered";
+  tiers;
+  accessCounts = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    const validTiers = config.tiers.filter(
+      (t) => t.store !== void 0
+    );
+    if (validTiers.length === 0) {
+      throw new Error(
+        "TieredCacheStore requires at least one tier with a store"
+      );
+    }
+    this.tiers = validTiers.sort((a, b) => a.priority - b.priority);
+  }
+  async get(key) {
+    this.incrementMetric("gets");
+    for (let i = 0; i < this.tiers.length; i++) {
+      const tier = this.tiers[i];
+      const entry = await tier.store.get(key);
+      if (entry) {
+        this.incrementMetric("hits");
+        const accessCount = (this.accessCounts.get(key) ?? 0) + 1;
+        this.accessCounts.set(key, accessCount);
+        if (i > 0) {
+          await this.checkPromotion(key, entry, i, accessCount);
+        }
+        return entry;
+      }
+    }
+    this.incrementMetric("misses");
+    return void 0;
+  }
+  async set(key, entry) {
+    const startTime = performance.now();
+    this.incrementMetric("sets");
+    const result = await this.tiers[0].store.set(key, entry);
+    this.accessCounts.set(key, 0);
+    await this.checkDemotion(0);
+    return {
+      ...result,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async has(key) {
+    for (const tier of this.tiers) {
+      if (await tier.store.has(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async delete(key) {
+    this.incrementMetric("deletes");
+    let deleted = false;
+    for (const tier of this.tiers) {
+      if (await tier.store.delete(key)) {
+        deleted = true;
+      }
+    }
+    this.accessCounts.delete(key);
+    return deleted;
+  }
+  async clear() {
+    for (const tier of this.tiers) {
+      await tier.store.clear();
+    }
+    this.accessCounts.clear();
+  }
+  async size() {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const tier of this.tiers) {
+      const keys = await tier.store.keys();
+      keys.forEach((k) => allKeys.add(k));
+    }
+    return allKeys.size;
+  }
+  async keys() {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const tier of this.tiers) {
+      const keys = await tier.store.keys();
+      keys.forEach((k) => allKeys.add(k));
+    }
+    return Array.from(allKeys);
+  }
+  async query(vector, options) {
+    const startTime = performance.now();
+    const entriesMap = /* @__PURE__ */ new Map();
+    for (const tier of this.tiers) {
+      const result = await tier.store.query(vector, options);
+      for (const entry of result.entries) {
+        const existing = entriesMap.get(entry.key);
+        if (!existing || entry.score > existing.score) {
+          entriesMap.set(entry.key, entry);
+        }
+      }
+    }
+    const entries = Array.from(entriesMap.values()).sort((a, b) => b.score - a.score).slice(0, options?.topK ?? 10);
+    return {
+      entries,
+      durationMs: performance.now() - startTime
+    };
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    const tierHealths = [];
+    for (const tier of this.tiers) {
+      const health = await tier.store.checkHealth();
+      tierHealths.push({ name: tier.name, healthy: health.healthy });
+    }
+    const allHealthy = tierHealths.every((t) => t.healthy);
+    return {
+      healthy: allHealthy,
+      latencyMs: performance.now() - startTime,
+      lastCheck: now(),
+      error: allHealthy ? void 0 : `Unhealthy tiers: ${tierHealths.filter((t) => !t.healthy).map((t) => t.name).join(", ")}`
+    };
+  }
+  async close() {
+    for (const tier of this.tiers) {
+      await tier.store.close();
+    }
+  }
+  /**
+   * Get tier statistics
+   */
+  async getTierStats() {
+    const stats = [];
+    for (const tier of this.tiers) {
+      stats.push({
+        name: tier.name,
+        priority: tier.priority,
+        size: await tier.store.size(),
+        maxSize: tier.maxSize
+      });
+    }
+    return stats;
+  }
+  /**
+   * Manually promote an entry to a higher tier
+   */
+  async promote(key, targetTierIndex = 0) {
+    for (let i = targetTierIndex + 1; i < this.tiers.length; i++) {
+      const entry = await this.tiers[i].store.get(key);
+      if (entry) {
+        await this.tiers[targetTierIndex].store.set(key, entry);
+        await this.tiers[i].store.delete(key);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Manually demote an entry to a lower tier
+   */
+  async demote(key, targetTierIndex) {
+    for (let i = 0; i < this.tiers.length - 1; i++) {
+      const entry = await this.tiers[i].store.get(key);
+      if (entry) {
+        const target = targetTierIndex ?? i + 1;
+        if (target >= this.tiers.length) return false;
+        await this.tiers[target].store.set(key, entry);
+        await this.tiers[i].store.delete(key);
+        return true;
+      }
+    }
+    return false;
+  }
+  async checkPromotion(key, entry, currentTierIndex, accessCount) {
+    for (let i = currentTierIndex - 1; i >= 0; i--) {
+      const tier = this.tiers[i];
+      const threshold = tier.promotionThreshold ?? 3;
+      if (accessCount >= threshold) {
+        await tier.store.set(key, entry);
+        await this.tiers[currentTierIndex].store.delete(key);
+        break;
+      }
+    }
+  }
+  async checkDemotion(tierIndex) {
+    const tier = this.tiers[tierIndex];
+    if (!tier.maxSize) return;
+    const size = await tier.store.size();
+    if (size <= tier.maxSize) return;
+    const demotionTarget = tier.demotionTarget ?? 0.9;
+    const targetSize = Math.floor(tier.maxSize * demotionTarget);
+    const toRemove = size - targetSize;
+    if (toRemove <= 0) return;
+    const keys = await tier.store.keys();
+    const keysByAccess = keys.map((k) => ({ key: k, count: this.accessCounts.get(k) ?? 0 })).sort((a, b) => a.count - b.count);
+    const nextTierIndex = tierIndex + 1;
+    if (nextTierIndex >= this.tiers.length) {
+      for (let i = 0; i < toRemove && i < keysByAccess.length; i++) {
+        await tier.store.delete(keysByAccess[i].key);
+        this.accessCounts.delete(keysByAccess[i].key);
+      }
+    } else {
+      for (let i = 0; i < toRemove && i < keysByAccess.length; i++) {
+        const key = keysByAccess[i].key;
+        const entry = await tier.store.get(key);
+        if (entry) {
+          await this.tiers[nextTierIndex].store.set(key, entry);
+          await tier.store.delete(key);
+        }
+      }
+    }
+  }
+};
+function createTieredCacheStore(config) {
+  return new TieredCacheStore(config);
+}
+
+// src/stores/PineconeCacheStore.ts
+var PineconeCacheStore = class extends BaseCacheStore {
+  storeType = "pinecone";
+  client = null;
+  index = null;
+  ns = null;
+  pineconeConfig;
+  connected = false;
+  constructor(config) {
+    super(config);
+    this.pineconeConfig = config;
+  }
+  /**
+   * Connect to Pinecone
+   */
+  async connect() {
+    if (this.connected) return;
+    try {
+      const { Pinecone } = await import('@pinecone-database/pinecone');
+      this.client = new Pinecone({
+        apiKey: this.pineconeConfig.apiKey
+      });
+      this.index = this.client.Index(this.pineconeConfig.index);
+      this.ns = this.index.namespace(this.namespace);
+      this.connected = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to connect to Pinecone: ${error.message}`
+      );
+    }
+  }
+  async ensureConnected() {
+    if (!this.connected || !this.ns) {
+      await this.connect();
+    }
+    if (!this.ns) {
+      throw new Error("Pinecone namespace not initialized");
+    }
+    return this.ns;
+  }
+  async get(key) {
+    this.incrementMetric("gets");
+    const ns = await this.ensureConnected();
+    try {
+      const result = await ns.fetch([key]);
+      if (!result.records[key]) {
+        this.incrementMetric("misses");
+        return void 0;
+      }
+      this.incrementMetric("hits");
+      const record = result.records[key];
+      const metadata = record.metadata;
+      const entry = JSON.parse(metadata.entryData);
+      entry.metadata.accessedAt = now();
+      entry.metadata.accessCount++;
+      this.updateAccessMetadata(key, record.values, metadata).catch(() => {
+      });
+      return entry;
+    } catch {
+      this.incrementMetric("misses");
+      return void 0;
+    }
+  }
+  async updateAccessMetadata(key, values, metadata) {
+    const ns = await this.ensureConnected();
+    const updatedEntry = JSON.parse(metadata.entryData);
+    updatedEntry.metadata.accessedAt = now();
+    updatedEntry.metadata.accessCount++;
+    await ns.upsert([
+      {
+        id: key,
+        values,
+        metadata: {
+          ...metadata,
+          accessedAt: now(),
+          accessCount: metadata.accessCount + 1,
+          entryData: JSON.stringify(updatedEntry)
+        }
+      }
+    ]);
+  }
+  async set(key, entry) {
+    const startTime = performance.now();
+    this.incrementMetric("sets");
+    const ns = await this.ensureConnected();
+    if (!entry.embedding || entry.embedding.length === 0) {
+      return {
+        success: false,
+        id: entry.id,
+        durationMs: performance.now() - startTime
+      };
+    }
+    const metadata = {
+      key,
+      model: entry.request.model,
+      content: entry.response.content.substring(0, 3e4),
+      // Pinecone metadata limit
+      createdAt: entry.metadata.createdAt,
+      accessedAt: entry.metadata.accessedAt,
+      accessCount: entry.metadata.accessCount,
+      hitCount: entry.metadata.hitCount,
+      ttl: entry.metadata.ttl,
+      namespace: entry.metadata.namespace ?? this.namespace,
+      tags: entry.metadata.tags ?? [],
+      entryData: JSON.stringify(entry)
+    };
+    try {
+      await ns.upsert([
+        {
+          id: key,
+          values: entry.embedding,
+          metadata
+        }
+      ]);
+      return {
+        success: true,
+        id: entry.id,
+        durationMs: performance.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        id: entry.id,
+        durationMs: performance.now() - startTime
+      };
+    }
+  }
+  async has(key) {
+    const ns = await this.ensureConnected();
+    try {
+      const result = await ns.fetch([key]);
+      return !!result.records[key];
+    } catch {
+      return false;
+    }
+  }
+  async delete(key) {
+    this.incrementMetric("deletes");
+    const ns = await this.ensureConnected();
+    try {
+      await ns.deleteOne(key);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    const ns = await this.ensureConnected();
+    await ns.deleteAll();
+  }
+  async size() {
+    if (!this.index) {
+      await this.connect();
+    }
+    try {
+      const stats = await this.index.describeIndexStats();
+      return stats.namespaces[this.namespace]?.recordCount ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  async keys() {
+    const ns = await this.ensureConnected();
+    try {
+      const result = await ns.listPaginated({ limit: 1e4 });
+      return result.vectors.map((v) => v.id);
+    } catch {
+      return [];
+    }
+  }
+  async query(vector, options) {
+    const startTime = performance.now();
+    const ns = await this.ensureConnected();
+    const queryOptions = {
+      vector,
+      topK: options?.topK ?? 10,
+      includeMetadata: true,
+      includeValues: options?.includeEmbedding ?? false
+    };
+    if (options?.filter) {
+      queryOptions.filter = options.filter;
+    }
+    try {
+      const result = await ns.query(queryOptions);
+      const entries = [];
+      for (const match of result.matches) {
+        if (options?.minSimilarity && match.score < options.minSimilarity) {
+          continue;
+        }
+        const metadata = match.metadata;
+        if (metadata?.entryData) {
+          try {
+            const entry = JSON.parse(metadata.entryData);
+            if (options?.includeEmbedding && match.values) {
+              entry.embedding = match.values;
+            }
+            entries.push({
+              ...entry,
+              score: match.score
+            });
+          } catch {
+          }
+        }
+      }
+      return {
+        entries,
+        durationMs: performance.now() - startTime
+      };
+    } catch (error) {
+      return {
+        entries: [],
+        durationMs: performance.now() - startTime
+      };
+    }
+  }
+  async checkHealth() {
+    const startTime = performance.now();
+    try {
+      if (!this.index) {
+        await this.connect();
+      }
+      await this.index.describeIndexStats();
+      return {
+        healthy: true,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now()
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: performance.now() - startTime,
+        lastCheck: now(),
+        error: error.message
+      };
+    }
+  }
+  close() {
+    this.client = null;
+    this.index = null;
+    this.ns = null;
+    this.connected = false;
+    return Promise.resolve();
+  }
+  /**
+   * Check if connected to Pinecone
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get index stats
+   */
+  async getIndexStats() {
+    if (!this.index) {
+      await this.connect();
+    }
+    try {
+      return await this.index.describeIndexStats();
+    } catch {
+      return null;
+    }
+  }
+};
+function createPineconeCacheStore(config) {
+  return new PineconeCacheStore(config);
+}
+
+export { BaseCacheStore, MemoryCacheStore, PineconeCacheStore, RedisCacheStore, SQLiteCacheStore, TieredCacheStore, createMemoryCacheStore, createPineconeCacheStore, createRedisCacheStore, createSQLiteCacheStore, createTieredCacheStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map