@lov3kaizen/agentsea-cache 0.5.1

package/dist/index.js

@@ -0,0 +1,3301 @@
+import EventEmitter2, { EventEmitter } from 'eventemitter3';
+import { nanoid } from 'nanoid';
+import murmurhash from 'murmurhash';
+import { LRUCache } from 'lru-cache';
+
+// src/core/SemanticCache.ts
+function generateId(prefix) {
+  const id = nanoid(16);
+  return prefix ? `${prefix}_${id}` : id;
+}
+function now() {
+  return Date.now();
+}
+function isExpired(createdAt, ttlSeconds) {
+  if (ttlSeconds <= 0) return false;
+  return now() > createdAt + ttlSeconds * 1e3;
+}
+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;
+}
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+
+// src/analytics/CacheAnalytics.ts
+var DEFAULT_MODEL_PRICING = {
+  "gpt-4o": { inputPer1K: 25e-4, outputPer1K: 0.01 },
+  "gpt-4o-mini": { inputPer1K: 15e-5, outputPer1K: 6e-4 },
+  "gpt-4-turbo": { inputPer1K: 0.01, outputPer1K: 0.03 },
+  "gpt-4": { inputPer1K: 0.03, outputPer1K: 0.06 },
+  "gpt-3.5-turbo": { inputPer1K: 5e-4, outputPer1K: 15e-4 },
+  "claude-3-opus": { inputPer1K: 0.015, outputPer1K: 0.075 },
+  "claude-sonnet-4-20250514": { inputPer1K: 3e-3, outputPer1K: 0.015 },
+  "claude-3-5-sonnet": { inputPer1K: 3e-3, outputPer1K: 0.015 },
+  "claude-3-haiku": { inputPer1K: 25e-5, outputPer1K: 125e-5 },
+  default: { inputPer1K: 5e-3, outputPer1K: 0.015 }
+};
+var DEFAULT_CONFIG = {
+  enabled: true,
+  sampleRate: 1,
+  retentionSeconds: 86400 * 7,
+  // 7 days
+  flushIntervalMs: 6e4,
+  // 1 minute
+  modelPricing: DEFAULT_MODEL_PRICING
+};
+var CacheAnalytics = class {
+  config;
+  hits = 0;
+  misses = 0;
+  exactHits = 0;
+  semanticHits = 0;
+  tokensSaved = 0;
+  inputTokensSaved = 0;
+  outputTokensSaved = 0;
+  latencies = [];
+  modelHits = /* @__PURE__ */ new Map();
+  namespaceHits = /* @__PURE__ */ new Map();
+  hitEvents = [];
+  missEvents = [];
+  setCount = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Record a cache hit
+   */
+  recordHit(entry, type, latencyMs) {
+    if (!this.config.enabled) return;
+    if (Math.random() > this.config.sampleRate) return;
+    this.hits++;
+    if (type === "exact") {
+      this.exactHits++;
+    } else {
+      this.semanticHits++;
+    }
+    this.latencies.push(latencyMs);
+    const usage = entry.response.usage;
+    this.tokensSaved += usage.totalTokens;
+    this.inputTokensSaved += usage.promptTokens;
+    this.outputTokensSaved += usage.completionTokens;
+    const modelCount = this.modelHits.get(entry.request.model) ?? 0;
+    this.modelHits.set(entry.request.model, modelCount + 1);
+    if (entry.metadata.namespace) {
+      const nsCount = this.namespaceHits.get(entry.metadata.namespace) ?? 0;
+      this.namespaceHits.set(entry.metadata.namespace, nsCount + 1);
+    }
+    this.hitEvents.push({
+      timestamp: Date.now(),
+      type,
+      model: entry.request.model,
+      namespace: entry.metadata.namespace,
+      similarity: entry.metadata.similarity,
+      latencyMs,
+      tokensSaved: usage.totalTokens
+    });
+    this.trimEvents();
+  }
+  /**
+   * Record a cache miss
+   */
+  recordMiss(latencyMs, reason = "not_found") {
+    if (!this.config.enabled) return;
+    if (Math.random() > this.config.sampleRate) return;
+    this.misses++;
+    this.latencies.push(latencyMs);
+    this.missEvents.push({
+      timestamp: Date.now(),
+      model: "unknown",
+      latencyMs,
+      reason
+    });
+    this.trimEvents();
+  }
+  /**
+   * Record a cache set operation
+   */
+  recordSet(_entry) {
+    if (!this.config.enabled) return;
+    this.setCount++;
+  }
+  /**
+   * Get analytics summary
+   */
+  getSummary() {
+    const total = this.hits + this.misses;
+    return {
+      totalHits: this.hits,
+      totalMisses: this.misses,
+      exactHits: this.exactHits,
+      semanticHits: this.semanticHits,
+      hitRate: total > 0 ? this.hits / total : 0,
+      avgLatencyMs: mean(this.latencies),
+      p50LatencyMs: percentile(this.latencies, 50),
+      p95LatencyMs: percentile(this.latencies, 95),
+      p99LatencyMs: percentile(this.latencies, 99),
+      totalTokensSaved: this.tokensSaved,
+      estimatedCostSavingsUSD: this.calculateCostSavings(),
+      topModels: this.getTopModels(5),
+      topNamespaces: this.getTopNamespaces(5),
+      hourlyStats: this.getHourlyStats()
+    };
+  }
+  /**
+   * Get cost savings report
+   */
+  getCostSavingsReport(periodLabel = "all-time") {
+    const total = this.hits + this.misses;
+    const costSaved = this.calculateCostSavings();
+    const avgCostPerRequest = costSaved / (this.hits || 1);
+    const estimatedCostWithoutCache = avgCostPerRequest * total;
+    return {
+      period: periodLabel,
+      totalRequests: total,
+      cachedRequests: this.hits,
+      hitRate: total > 0 ? this.hits / total : 0,
+      inputTokensSaved: this.inputTokensSaved,
+      outputTokensSaved: this.outputTokensSaved,
+      totalTokensSaved: this.tokensSaved,
+      estimatedCostWithoutCache,
+      actualCostWithCache: estimatedCostWithoutCache - costSaved,
+      costSaved,
+      reductionPercent: estimatedCostWithoutCache > 0 ? costSaved / estimatedCostWithoutCache * 100 : 0
+    };
+  }
+  /**
+   * Get performance metrics
+   */
+  getPerformanceMetrics() {
+    const total = this.hits + this.misses;
+    return {
+      avgLookupMs: mean(this.latencies),
+      avgEmbeddingMs: 0,
+      // Would need to track separately
+      avgStoreReadMs: mean(this.latencies),
+      avgStoreWriteMs: 0,
+      // Would need to track separately
+      p50LatencyMs: percentile(this.latencies, 50),
+      p95LatencyMs: percentile(this.latencies, 95),
+      p99LatencyMs: percentile(this.latencies, 99),
+      totalOperations: total + this.setCount,
+      failedOperations: 0,
+      // Would need to track separately
+      errorRate: 0
+    };
+  }
+  /**
+   * Reset all analytics
+   */
+  reset() {
+    this.hits = 0;
+    this.misses = 0;
+    this.exactHits = 0;
+    this.semanticHits = 0;
+    this.tokensSaved = 0;
+    this.inputTokensSaved = 0;
+    this.outputTokensSaved = 0;
+    this.latencies = [];
+    this.modelHits.clear();
+    this.namespaceHits.clear();
+    this.hitEvents = [];
+    this.missEvents = [];
+    this.setCount = 0;
+  }
+  /**
+   * Export analytics data
+   */
+  export(format = "json") {
+    const data = this.getSummary();
+    if (format === "csv") {
+      const headers = Object.keys(data).filter(
+        (k) => typeof data[k] !== "object"
+      );
+      const values = headers.map((h) => data[h]);
+      return `${headers.join(",")}
+${values.join(",")}`;
+    }
+    return JSON.stringify(data, null, 2);
+  }
+  calculateCostSavings() {
+    let savings = 0;
+    for (const [model, hits] of this.modelHits) {
+      const pricing = this.config.modelPricing[model] ?? this.config.modelPricing["default"];
+      const avgInputTokens = this.inputTokensSaved / (this.hits || 1);
+      const avgOutputTokens = this.outputTokensSaved / (this.hits || 1);
+      const inputCost = avgInputTokens / 1e3 * pricing.inputPer1K * hits;
+      const outputCost = avgOutputTokens / 1e3 * pricing.outputPer1K * hits;
+      savings += inputCost + outputCost;
+    }
+    if (savings === 0 && this.tokensSaved > 0) {
+      const defaultPricing = this.config.modelPricing["default"];
+      savings = this.inputTokensSaved / 1e3 * defaultPricing.inputPer1K + this.outputTokensSaved / 1e3 * defaultPricing.outputPer1K;
+    }
+    return savings;
+  }
+  getTopModels(n) {
+    return Array.from(this.modelHits.entries()).map(([model, hits]) => ({ model, hits })).sort((a, b) => b.hits - a.hits).slice(0, n);
+  }
+  getTopNamespaces(n) {
+    return Array.from(this.namespaceHits.entries()).map(([namespace, hits]) => ({ namespace, hits })).sort((a, b) => b.hits - a.hits).slice(0, n);
+  }
+  getHourlyStats() {
+    const hourlyData = /* @__PURE__ */ new Map();
+    for (const event of this.hitEvents) {
+      const hour = new Date(event.timestamp).getHours();
+      const data = hourlyData.get(hour) ?? {
+        hits: 0,
+        misses: 0,
+        latencies: []
+      };
+      data.hits++;
+      data.latencies.push(event.latencyMs);
+      hourlyData.set(hour, data);
+    }
+    for (const event of this.missEvents) {
+      const hour = new Date(event.timestamp).getHours();
+      const data = hourlyData.get(hour) ?? {
+        hits: 0,
+        misses: 0,
+        latencies: []
+      };
+      data.misses++;
+      data.latencies.push(event.latencyMs);
+      hourlyData.set(hour, data);
+    }
+    return Array.from(hourlyData.entries()).map(([hour, data]) => ({
+      hour,
+      hits: data.hits,
+      misses: data.misses,
+      avgLatencyMs: mean(data.latencies)
+    })).sort((a, b) => a.hour - b.hour);
+  }
+  trimEvents() {
+    const cutoff = Date.now() - this.config.retentionSeconds * 1e3;
+    this.hitEvents = this.hitEvents.filter((e) => e.timestamp > cutoff);
+    this.missEvents = this.missEvents.filter((e) => e.timestamp > cutoff);
+  }
+};
+function createCacheAnalytics(config) {
+  return new CacheAnalytics(config);
+}
+var DEFAULT_KEY_OPTIONS = {
+  includeTemperature: false,
+  includeTools: false,
+  normalizeWhitespace: true,
+  extractUserMessage: false
+};
+function generateCacheKey(model, messages, options = {}) {
+  const opts = { ...DEFAULT_KEY_OPTIONS, ...options };
+  const normalized = normalizeRequest(model, messages, opts);
+  const hash = murmurhash.v3(JSON.stringify(normalized)).toString(16);
+  return `cache:${model}:${hash}`;
+}
+function normalizeRequest(model, messages, options = {}) {
+  const normalizedMessages = messages.map((m) => ({
+    role: m.role,
+    content: options.normalizeWhitespace ? normalizeWhitespace(m.content) : m.content
+  }));
+  return {
+    model,
+    messages: options.extractUserMessage ? extractUserMessage(normalizedMessages) : normalizedMessages
+  };
+}
+function normalizeWhitespace(text) {
+  return text.trim().replace(/\r\n/g, "\n").replace(/\s+/g, " ");
+}
+function extractUserMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      return messages[i].content;
+    }
+  }
+  return "";
+}
+function extractSystemPrompt(messages) {
+  const systemMessage = messages.find((m) => m.role === "system");
+  return systemMessage?.content;
+}
+function generateSemanticKey(model, messages) {
+  const userMessage = extractUserMessage(messages);
+  const normalized = normalizeWhitespace(userMessage);
+  return `${model}:${normalized}`;
+}
+function generateConversationFingerprint(messages) {
+  const pattern = messages.map((m) => `${m.role}:${m.content.length}`).join("|");
+  return murmurhash.v3(pattern).toString(16);
+}
+
+// src/core/SemanticCache.ts
+var DEFAULT_CONFIG2 = {
+  defaultTTL: 3600,
+  similarityThreshold: 0.92,
+  maxEntries: 1e4,
+  maxSizeBytes: 1024 * 1024 * 1024,
+  // 1GB
+  keyPrefix: "llm-cache",
+  matchStrategy: "hybrid",
+  analyticsEnabled: true,
+  namespace: "default",
+  cacheKeyFields: ["model", "messages"],
+  normalizeWhitespace: true
+};
+var SemanticCache = class extends EventEmitter {
+  config;
+  store;
+  strategy;
+  similarity;
+  analytics;
+  stats;
+  constructor(config, store, strategy, similarity) {
+    super();
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.store = store;
+    this.strategy = strategy;
+    this.similarity = similarity;
+    this.analytics = new CacheAnalytics({
+      enabled: this.config.analyticsEnabled
+    });
+    this.stats = this.createInitialStats();
+  }
+  createInitialStats() {
+    return {
+      entries: 0,
+      sizeBytes: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      exactHits: 0,
+      semanticHits: 0,
+      avgSimilarity: 0,
+      avgLatencyMs: 0,
+      costSavingsUSD: 0,
+      tokensSaved: 0
+    };
+  }
+  /**
+   * Wrap an LLM call with caching
+   *
+   * @param request - The LLM request
+   * @param fn - Function to call on cache miss
+   * @param options - Cache options
+   * @returns The response (cached or fresh)
+   */
+  async wrap(request, fn, options) {
+    const startTime = performance.now();
+    if (options?.skipCache) {
+      const response = await fn(request);
+      return { ...response, _cache: { hit: false } };
+    }
+    const lookupResult = await this.get(request, options);
+    if (lookupResult.hit && lookupResult.entry && !options?.forceRefresh) {
+      this.emit("hit", lookupResult.entry, lookupResult.similarity ?? 1);
+      this.stats.hits++;
+      this.updateStats("hit", lookupResult);
+      if (this.config.analyticsEnabled) {
+        this.analytics.recordHit(
+          lookupResult.entry,
+          lookupResult.source === "exact" ? "exact" : "semantic",
+          lookupResult.latencyMs
+        );
+      }
+      return {
+        ...lookupResult.entry.response,
+        _cache: {
+          hit: true,
+          similarity: lookupResult.similarity
+        }
+      };
+    }
+    const key = generateCacheKey(request.model, request.messages, {
+      normalizeWhitespace: this.config.normalizeWhitespace
+    });
+    this.emit("miss", key, lookupResult.source);
+    this.stats.misses++;
+    if (this.config.analyticsEnabled) {
+      this.analytics.recordMiss(performance.now() - startTime);
+    }
+    try {
+      const response = await fn(request);
+      await this.set(request, response, options);
+      return { ...response, _cache: { hit: false } };
+    } catch (error) {
+      this.emit("error", error, "wrap");
+      throw error;
+    }
+  }
+  /**
+   * Get an entry from cache
+   *
+   * @param request - The request to look up
+   * @param options - Lookup options
+   * @returns The lookup result
+   */
+  async get(request, options) {
+    const startTime = performance.now();
+    try {
+      const result = await this.strategy.match(
+        {
+          model: request.model,
+          messages: request.messages,
+          temperature: request.temperature
+        },
+        this.store,
+        this.similarity,
+        {
+          threshold: this.config.similarityThreshold,
+          namespace: options?.namespace ?? this.config.namespace
+        }
+      );
+      if (result.hit && result.entry) {
+        if (isExpired(result.entry.metadata.createdAt, result.entry.metadata.ttl)) {
+          await this.store.delete(result.entry.key);
+          return {
+            hit: false,
+            latencyMs: performance.now() - startTime,
+            source: "miss"
+          };
+        }
+      }
+      return {
+        ...result,
+        latencyMs: performance.now() - startTime
+      };
+    } catch (error) {
+      this.emit("error", error, "get");
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    }
+  }
+  /**
+   * Set an entry in cache
+   *
+   * @param request - The request
+   * @param response - The response to cache
+   * @param options - Cache options
+   */
+  async set(request, response, options) {
+    const namespace = options?.namespace ?? this.config.namespace;
+    const baseKey = generateCacheKey(request.model, request.messages, {
+      normalizeWhitespace: this.config.normalizeWhitespace
+    });
+    const tempSuffix = request.temperature !== void 0 ? `:t:${request.temperature}` : "";
+    const key = namespace && namespace !== "default" ? `${baseKey}${tempSuffix}:ns:${namespace}` : `${baseKey}${tempSuffix}`;
+    let embedding;
+    if (this.similarity && this.config.matchStrategy !== "exact") {
+      try {
+        const userMessage = extractUserMessage(request.messages);
+        if (userMessage) {
+          embedding = await this.similarity.embed(userMessage);
+        }
+      } catch (error) {
+        this.emit("error", error, "embedding");
+      }
+    }
+    const entry = {
+      id: generateId("entry"),
+      key,
+      embedding,
+      request: {
+        model: request.model,
+        messages: request.messages,
+        temperature: request.temperature,
+        maxTokens: request.maxTokens,
+        tools: request.tools
+      },
+      response: {
+        content: response.content,
+        model: response.model ?? request.model,
+        usage: response.usage ?? {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0
+        },
+        finishReason: response.finishReason ?? "stop",
+        toolCalls: response.toolCalls
+      },
+      metadata: {
+        createdAt: now(),
+        accessedAt: now(),
+        accessCount: 0,
+        ttl: options?.ttl ?? this.config.defaultTTL,
+        hitCount: 0,
+        tags: options?.tags,
+        namespace,
+        userId: options?.userId,
+        agentId: options?.agentId
+      }
+    };
+    try {
+      await this.store.set(key, entry);
+      this.emit("set", entry);
+      this.stats.entries++;
+      if (this.config.analyticsEnabled) {
+        this.analytics.recordSet(entry);
+      }
+    } catch (error) {
+      this.emit("error", error, "set");
+      throw error;
+    }
+  }
+  /**
+   * Delete an entry from cache
+   *
+   * @param key - The cache key to delete
+   * @returns Whether the entry was deleted
+   */
+  async delete(key) {
+    const deleted = await this.store.delete(key);
+    if (deleted) {
+      this.emit("delete", key);
+      this.stats.entries = Math.max(0, this.stats.entries - 1);
+    }
+    return deleted;
+  }
+  /**
+   * Clear all entries from cache
+   */
+  async clear() {
+    await this.store.clear();
+    this.stats = this.createInitialStats();
+    this.analytics.reset();
+  }
+  /**
+   * Invalidate entries by pattern
+   *
+   * @param pattern - Regex pattern to match keys
+   * @returns Number of entries invalidated
+   */
+  async invalidateByPattern(pattern) {
+    const keys = await this.store.keys();
+    let count = 0;
+    for (const key of keys) {
+      if (pattern.test(key)) {
+        await this.store.delete(key);
+        count++;
+      }
+    }
+    this.stats.entries = Math.max(0, this.stats.entries - count);
+    return count;
+  }
+  /**
+   * Invalidate entries by tags
+   *
+   * @param tags - Tags to match
+   * @returns Number of entries invalidated
+   */
+  async invalidateByTags(tags) {
+    const keys = await this.store.keys();
+    let count = 0;
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (entry?.metadata.tags?.some((t) => tags.includes(t))) {
+        await this.store.delete(key);
+        count++;
+      }
+    }
+    this.stats.entries = Math.max(0, this.stats.entries - count);
+    return count;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    this.updateHitRate();
+    return { ...this.stats };
+  }
+  /**
+   * Get analytics instance
+   */
+  getAnalytics() {
+    return this.analytics;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check store health
+   */
+  async checkHealth() {
+    return this.store.checkHealth();
+  }
+  /**
+   * Close the cache and release resources
+   */
+  async close() {
+    await this.store.close();
+    this.removeAllListeners();
+  }
+  updateStats(type, result) {
+    if (type === "hit" && result) {
+      if (result.source === "exact") {
+        this.stats.exactHits++;
+      } else if (result.source === "semantic") {
+        this.stats.semanticHits++;
+        if (result.similarity) {
+          const total = this.stats.exactHits + this.stats.semanticHits;
+          this.stats.avgSimilarity = (this.stats.avgSimilarity * (total - 1) + result.similarity) / total;
+        }
+      }
+      if (result.entry?.response.usage) {
+        this.stats.tokensSaved += result.entry.response.usage.totalTokens;
+        this.stats.costSavingsUSD += result.entry.response.usage.totalTokens / 1e3 * 0.01;
+      }
+    }
+    this.updateHitRate();
+  }
+  updateHitRate() {
+    const total = this.stats.hits + this.stats.misses;
+    this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+  }
+};
+function createSemanticCache(config, store, strategy, similarity) {
+  return new SemanticCache(config, store, strategy, similarity);
+}
+
+// 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;
+    }
+  }
+};
+var DEFAULT_CONFIG3 = {
+  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_CONFIG3, ...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 dotProduct2 = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct2 += 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 dotProduct2 / 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 dotProduct2 = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct2 += 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 dotProduct2 / denominator;
+}
+function euclideanDistance(a, b) {
+  if (a.length !== b.length) return Infinity;
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+function dotProduct(a, b) {
+  if (a.length !== b.length) return 0;
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function manhattanDistance(a, b) {
+  if (a.length !== b.length) return Infinity;
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += Math.abs(a[i] - b[i]);
+  }
+  return sum;
+}
+function distanceToSimilarity(distance) {
+  return 1 / (1 + distance);
+}
+function normalize(vector) {
+  const magnitude2 = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+  if (magnitude2 === 0) return vector;
+  return vector.map((v) => v / magnitude2);
+}
+function magnitude(vector) {
+  return Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+}
+
+// src/stores/RedisCacheStore.ts
+var DEFAULT_CONFIG4 = {
+  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_CONFIG4, ...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_CONFIG5 = {
+  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_CONFIG5, ...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);
+}
+
+// src/strategies/BaseMatchStrategy.ts
+var BaseMatchStrategy = class {
+};
+
+// src/strategies/ExactMatchStrategy.ts
+var DEFAULT_CONFIG6 = {
+  normalizeWhitespace: true,
+  hashFields: ["model", "messages"]
+};
+var ExactMatchStrategy = class extends BaseMatchStrategy {
+  name = "exact";
+  config;
+  constructor(config) {
+    super();
+    this.config = { ...DEFAULT_CONFIG6, ...config };
+  }
+  async match(request, store, _similarity, options) {
+    const startTime = performance.now();
+    const namespace = options?.namespace;
+    const baseKey = generateCacheKey(request.model, request.messages, {
+      normalizeWhitespace: this.config.normalizeWhitespace,
+      includeTemperature: this.config.hashFields?.includes("temperature")
+    });
+    const tempSuffix = request.temperature !== void 0 ? `:t:${request.temperature}` : "";
+    const key = namespace && namespace !== "default" ? `${baseKey}${tempSuffix}:ns:${namespace}` : `${baseKey}${tempSuffix}`;
+    const entry = await store.get(key);
+    if (entry) {
+      if (namespace && entry.metadata.namespace && entry.metadata.namespace !== namespace) {
+        return {
+          hit: false,
+          latencyMs: performance.now() - startTime,
+          source: "miss"
+        };
+      }
+      return {
+        hit: true,
+        entry,
+        similarity: 1,
+        // Exact match = 100% similarity
+        latencyMs: performance.now() - startTime,
+        source: "exact"
+      };
+    }
+    return {
+      hit: false,
+      latencyMs: performance.now() - startTime,
+      source: "miss"
+    };
+  }
+};
+function createExactMatchStrategy(config) {
+  return new ExactMatchStrategy(config);
+}
+
+// src/strategies/SemanticMatchStrategy.ts
+var DEFAULT_CONFIG7 = {
+  threshold: 0.92,
+  matchModel: true,
+  topK: 5
+};
+var SemanticMatchStrategy = class extends BaseMatchStrategy {
+  name = "semantic";
+  config;
+  constructor(config) {
+    super();
+    this.config = { ...DEFAULT_CONFIG7, ...config };
+  }
+  async match(request, store, similarity, options) {
+    const startTime = performance.now();
+    if (!similarity) {
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    }
+    const userMessage = extractUserMessage(request.messages);
+    if (!userMessage) {
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    }
+    try {
+      const queryEmbedding = await similarity.embed(userMessage);
+      const threshold = options?.threshold ?? this.config.threshold ?? 0.92;
+      const topK = options?.topK ?? this.config.topK ?? 5;
+      const results = await store.query(queryEmbedding, {
+        topK,
+        minSimilarity: threshold,
+        namespace: options?.namespace
+      });
+      if (results.entries.length > 0) {
+        let bestMatch = results.entries[0];
+        if (this.config.matchModel) {
+          const modelMatch = results.entries.find(
+            (e) => e.request.model === request.model
+          );
+          if (modelMatch) {
+            bestMatch = modelMatch;
+          }
+        }
+        if (bestMatch && bestMatch.score >= threshold) {
+          return {
+            hit: true,
+            entry: bestMatch,
+            similarity: bestMatch.score,
+            latencyMs: performance.now() - startTime,
+            source: "semantic"
+          };
+        }
+      }
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    } catch (error) {
+      console.error("Semantic match error:", error);
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    }
+  }
+};
+function createSemanticMatchStrategy(config) {
+  return new SemanticMatchStrategy(config);
+}
+
+// src/strategies/HybridMatchStrategy.ts
+var DEFAULT_CONFIG8 = {
+  exact: {
+    normalizeWhitespace: true,
+    hashFields: ["model", "messages"]
+  },
+  semantic: {
+    threshold: 0.92,
+    matchModel: true,
+    topK: 5
+  }
+};
+var HybridMatchStrategy = class extends BaseMatchStrategy {
+  name = "hybrid";
+  exact;
+  semantic;
+  config;
+  constructor(config) {
+    super();
+    this.config = { ...DEFAULT_CONFIG8, ...config };
+    this.exact = new ExactMatchStrategy(this.config.exact);
+    this.semantic = new SemanticMatchStrategy(this.config.semantic);
+  }
+  async match(request, store, similarity, options) {
+    const startTime = performance.now();
+    if (this.shouldUseExactOnly(request)) {
+      const result = await this.exact.match(
+        request,
+        store,
+        similarity,
+        options
+      );
+      return {
+        ...result,
+        latencyMs: performance.now() - startTime
+      };
+    }
+    const exactResult = await this.exact.match(
+      request,
+      store,
+      similarity,
+      options
+    );
+    if (exactResult.hit) {
+      return {
+        ...exactResult,
+        latencyMs: performance.now() - startTime
+      };
+    }
+    if (!this.shouldUseSemantic(request)) {
+      return {
+        hit: false,
+        latencyMs: performance.now() - startTime,
+        source: "miss"
+      };
+    }
+    if (similarity) {
+      const semanticResult = await this.semantic.match(
+        request,
+        store,
+        similarity,
+        options
+      );
+      return {
+        ...semanticResult,
+        latencyMs: performance.now() - startTime
+      };
+    }
+    return {
+      hit: false,
+      latencyMs: performance.now() - startTime,
+      source: "miss"
+    };
+  }
+  /**
+   * Check if request should use exact-only matching
+   */
+  shouldUseExactOnly(request) {
+    if (!this.config.exactOnlyPatterns) return false;
+    const userMessage = this.extractUserMessage(request);
+    return this.config.exactOnlyPatterns.some(
+      (pattern) => pattern.test(userMessage)
+    );
+  }
+  /**
+   * Check if semantic matching should be used
+   */
+  shouldUseSemantic(request) {
+    if (!this.config.semanticPatterns) return true;
+    const userMessage = this.extractUserMessage(request);
+    return this.config.semanticPatterns.some(
+      (pattern) => pattern.test(userMessage)
+    );
+  }
+  /**
+   * Extract user message from request
+   */
+  extractUserMessage(request) {
+    for (let i = request.messages.length - 1; i >= 0; i--) {
+      if (request.messages[i].role === "user") {
+        return request.messages[i].content;
+      }
+    }
+    return "";
+  }
+};
+function createHybridMatchStrategy(config) {
+  return new HybridMatchStrategy(config);
+}
+
+// src/similarity/SimilarityEngine.ts
+var SimilarityEngine = class {
+  provider;
+  metric;
+  embeddingCache;
+  maxCacheSize;
+  constructor(config) {
+    this.provider = config.provider;
+    this.metric = config.metric ?? "cosine";
+    this.maxCacheSize = config.maxCacheSize ?? 1e4;
+    if (config.cacheEmbeddings) {
+      this.embeddingCache = /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Generate embedding for text
+   */
+  async embed(text) {
+    if (this.embeddingCache?.has(text)) {
+      return this.embeddingCache.get(text);
+    }
+    const embedding = await this.provider.embed(text);
+    if (this.embeddingCache) {
+      if (this.embeddingCache.size >= this.maxCacheSize) {
+        const firstKey = this.embeddingCache.keys().next().value;
+        if (firstKey) {
+          this.embeddingCache.delete(firstKey);
+        }
+      }
+      this.embeddingCache.set(text, embedding);
+    }
+    return embedding;
+  }
+  /**
+   * Generate embeddings for multiple texts
+   */
+  async embedBatch(texts) {
+    if (this.provider.embedBatch) {
+      return this.provider.embedBatch(texts);
+    }
+    return Promise.all(texts.map((text) => this.embed(text)));
+  }
+  /**
+   * Compute similarity between two vectors
+   */
+  computeSimilarity(a, b) {
+    switch (this.metric) {
+      case "cosine":
+        return this.cosineSimilarity(a, b);
+      case "euclidean": {
+        const dist = this.euclideanDistance(a, b);
+        return 1 / (1 + dist);
+      }
+      case "dot_product":
+        return this.dotProduct(a, b);
+      default:
+        return this.cosineSimilarity(a, b);
+    }
+  }
+  /**
+   * Find most similar vectors from candidates
+   */
+  findMostSimilar(query, candidates, minSimilarity = 0) {
+    const results = candidates.map((c) => ({
+      id: c.id,
+      similarity: this.computeSimilarity(query, c.vector)
+    })).filter((r) => r.similarity >= minSimilarity).sort((a, b) => b.similarity - a.similarity);
+    return results;
+  }
+  /**
+   * Get embedding dimensions
+   */
+  get dimensions() {
+    return this.provider.dimensions ?? 0;
+  }
+  /**
+   * Clear embedding cache
+   */
+  clearCache() {
+    this.embeddingCache?.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    if (!this.embeddingCache) return null;
+    return {
+      size: this.embeddingCache.size,
+      maxSize: this.maxCacheSize
+    };
+  }
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct2 = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct2 += 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 dotProduct2 / denominator;
+  }
+  euclideanDistance(a, b) {
+    if (a.length !== b.length) return Infinity;
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+  }
+  dotProduct(a, b) {
+    if (a.length !== b.length) return 0;
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      sum += a[i] * b[i];
+    }
+    return sum;
+  }
+};
+function createSimilarityEngine(config) {
+  return new SimilarityEngine(config);
+}
+
+// src/streaming/ChunkBuffer.ts
+var DEFAULT_CONFIG9 = {
+  maxChunks: 100,
+  maxBytes: 64 * 1024,
+  // 64KB
+  flushIntervalMs: 1e3,
+  preserveOrder: true
+};
+var ChunkBuffer = class {
+  chunks = [];
+  currentBytes = 0;
+  config;
+  flushTimer = null;
+  onFlush;
+  constructor(config, onFlush) {
+    this.config = { ...DEFAULT_CONFIG9, ...config };
+    this.onFlush = onFlush;
+    if (this.config.flushIntervalMs > 0) {
+      this.startFlushTimer();
+    }
+  }
+  /**
+   * Add a chunk to the buffer
+   */
+  add(chunk) {
+    if (this.config.preserveOrder) {
+      if (chunk.index === void 0) {
+        chunk.index = this.chunks.length;
+      }
+    }
+    this.chunks.push(chunk);
+    this.currentBytes += this.estimateChunkSize(chunk);
+    if (this.shouldFlush()) {
+      this.flush();
+    }
+  }
+  /**
+   * Add multiple chunks
+   */
+  addAll(chunks) {
+    for (const chunk of chunks) {
+      this.add(chunk);
+    }
+  }
+  /**
+   * Flush all buffered chunks
+   */
+  flush() {
+    const flushed = this.chunks;
+    if (this.config.preserveOrder) {
+      flushed.sort((a, b) => a.index - b.index);
+    }
+    this.chunks = [];
+    this.currentBytes = 0;
+    if (this.onFlush && flushed.length > 0) {
+      this.onFlush(flushed);
+    }
+    return flushed;
+  }
+  /**
+   * Get current buffer size
+   */
+  size() {
+    return this.chunks.length;
+  }
+  /**
+   * Get current buffer bytes
+   */
+  bytes() {
+    return this.currentBytes;
+  }
+  /**
+   * Check if buffer is empty
+   */
+  isEmpty() {
+    return this.chunks.length === 0;
+  }
+  /**
+   * Peek at buffered chunks without flushing
+   */
+  peek() {
+    return this.chunks;
+  }
+  /**
+   * Clear the buffer without flushing
+   */
+  clear() {
+    this.chunks = [];
+    this.currentBytes = 0;
+  }
+  /**
+   * Stop the flush timer
+   */
+  stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  /**
+   * Destroy the buffer
+   */
+  destroy() {
+    this.stop();
+    this.clear();
+  }
+  shouldFlush() {
+    return this.chunks.length >= this.config.maxChunks || this.currentBytes >= this.config.maxBytes;
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      if (!this.isEmpty()) {
+        this.flush();
+      }
+    }, this.config.flushIntervalMs);
+  }
+  estimateChunkSize(chunk) {
+    let size = 0;
+    if (chunk.content) {
+      size += chunk.content.length * 2;
+    }
+    if (chunk.toolCall) {
+      size += JSON.stringify(chunk.toolCall).length;
+    }
+    if (chunk.toolResult) {
+      size += JSON.stringify(chunk.toolResult).length;
+    }
+    if (chunk.metadata) {
+      size += JSON.stringify(chunk.metadata).length;
+    }
+    return size + 50;
+  }
+};
+function createChunkBuffer(config, onFlush) {
+  return new ChunkBuffer(config, onFlush);
+}
+
+// src/streaming/StreamRecorder.ts
+var DEFAULT_CONFIG10 = {
+  buffer: {
+    maxChunks: 100,
+    maxBytes: 64 * 1024,
+    flushIntervalMs: 0,
+    // No auto-flush during recording
+    preserveOrder: true
+  },
+  captureToolCalls: true,
+  captureMetadata: true,
+  maxDurationMs: 3e5,
+  // 5 minutes
+  maxChunks: 1e4
+};
+var StreamRecorder = class {
+  config;
+  buffer;
+  recording = false;
+  startTime = 0;
+  model = "";
+  messages = [];
+  key = "";
+  totalChars = 0;
+  chunkIndex = 0;
+  timeoutId = null;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_CONFIG10,
+      ...config,
+      buffer: { ...DEFAULT_CONFIG10.buffer, ...config?.buffer }
+    };
+    this.buffer = new ChunkBuffer(this.config.buffer);
+  }
+  /**
+   * Start recording a new stream
+   */
+  start(model, messages, key) {
+    if (this.recording) {
+      throw new Error("Recording already in progress");
+    }
+    this.recording = true;
+    this.startTime = now();
+    this.model = model;
+    this.messages = messages;
+    this.key = key ?? generateId();
+    this.totalChars = 0;
+    this.chunkIndex = 0;
+    this.buffer.clear();
+    if (this.config.maxDurationMs > 0) {
+      this.timeoutId = setTimeout(() => {
+        if (this.recording) {
+          this.abort("Recording exceeded maximum duration");
+        }
+      }, this.config.maxDurationMs);
+    }
+  }
+  /**
+   * Record a text chunk
+   */
+  recordText(content, metadata) {
+    this.recordChunk({
+      type: "text",
+      content,
+      metadata: this.config.captureMetadata ? metadata : void 0,
+      timestamp: now(),
+      index: this.chunkIndex++
+    });
+    this.totalChars += content.length;
+  }
+  /**
+   * Record a tool call chunk
+   */
+  recordToolCall(id, name, args, metadata) {
+    if (!this.config.captureToolCalls) return;
+    this.recordChunk({
+      type: "tool_call",
+      toolCall: { id, name, arguments: args },
+      metadata: this.config.captureMetadata ? metadata : void 0,
+      timestamp: now(),
+      index: this.chunkIndex++
+    });
+  }
+  /**
+   * Record a tool result chunk
+   */
+  recordToolResult(callId, content, metadata) {
+    if (!this.config.captureToolCalls) return;
+    this.recordChunk({
+      type: "tool_result",
+      toolResult: { callId, content },
+      metadata: this.config.captureMetadata ? metadata : void 0,
+      timestamp: now(),
+      index: this.chunkIndex++
+    });
+  }
+  /**
+   * Record metadata
+   */
+  recordMetadata(metadata) {
+    if (!this.config.captureMetadata) return;
+    this.recordChunk({
+      type: "metadata",
+      metadata,
+      timestamp: now(),
+      index: this.chunkIndex++
+    });
+  }
+  /**
+   * Record a generic chunk
+   */
+  recordChunk(chunk) {
+    if (!this.recording) {
+      throw new Error("Not currently recording");
+    }
+    if (chunk.index >= this.config.maxChunks) {
+      throw new Error("Maximum chunks exceeded");
+    }
+    this.buffer.add(chunk);
+  }
+  /**
+   * Complete the recording and return the recorded stream
+   */
+  complete(tokenUsage) {
+    if (!this.recording) {
+      throw new Error("Not currently recording");
+    }
+    this.clearTimeout();
+    const endTime = now();
+    const chunks = this.buffer.flush();
+    const stream = {
+      id: generateId(),
+      key: this.key,
+      chunks,
+      model: this.model,
+      messages: this.messages,
+      startTime: this.startTime,
+      endTime,
+      durationMs: endTime - this.startTime,
+      totalChars: this.totalChars,
+      tokenUsage,
+      complete: true
+    };
+    this.reset();
+    return stream;
+  }
+  /**
+   * Abort the recording
+   */
+  abort(reason) {
+    if (!this.recording) {
+      throw new Error("Not currently recording");
+    }
+    this.clearTimeout();
+    const endTime = now();
+    const chunks = this.buffer.flush();
+    const stream = {
+      id: generateId(),
+      key: this.key,
+      chunks,
+      model: this.model,
+      messages: this.messages,
+      startTime: this.startTime,
+      endTime,
+      durationMs: endTime - this.startTime,
+      totalChars: this.totalChars,
+      complete: false,
+      error: reason ?? "Recording aborted"
+    };
+    this.reset();
+    return stream;
+  }
+  /**
+   * Check if currently recording
+   */
+  isRecording() {
+    return this.recording;
+  }
+  /**
+   * Get current chunk count
+   */
+  getChunkCount() {
+    return this.chunkIndex;
+  }
+  /**
+   * Get current recording duration in ms
+   */
+  getDuration() {
+    if (!this.recording) return 0;
+    return now() - this.startTime;
+  }
+  /**
+   * Destroy the recorder
+   */
+  destroy() {
+    this.clearTimeout();
+    this.buffer.destroy();
+    this.reset();
+  }
+  reset() {
+    this.recording = false;
+    this.startTime = 0;
+    this.model = "";
+    this.messages = [];
+    this.key = "";
+    this.totalChars = 0;
+    this.chunkIndex = 0;
+  }
+  clearTimeout() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
+function createStreamRecorder(config) {
+  return new StreamRecorder(config);
+}
+
+// src/streaming/StreamReplayer.ts
+var DEFAULT_CONFIG11 = {
+  speedMultiplier: 1,
+  minDelayMs: 0,
+  maxDelayMs: 100,
+  simulateTiming: false,
+  onChunk: () => {
+  },
+  onComplete: () => {
+  },
+  onError: () => {
+  }
+};
+var StreamReplayer = class {
+  config;
+  abortController = null;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG11, ...config };
+  }
+  /**
+   * Replay a recorded stream as an async iterable
+   */
+  async *replay(stream) {
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    try {
+      const chunks = [...stream.chunks].sort((a, b) => a.index - b.index);
+      let lastTimestamp = chunks[0]?.timestamp ?? 0;
+      for (let i = 0; i < chunks.length; i++) {
+        if (signal.aborted) {
+          break;
+        }
+        const chunk = chunks[i];
+        if (this.config.simulateTiming && i > 0) {
+          const timeDiff = chunk.timestamp - lastTimestamp;
+          const delay = Math.min(
+            Math.max(
+              timeDiff / this.config.speedMultiplier,
+              this.config.minDelayMs
+            ),
+            this.config.maxDelayMs
+          );
+          if (delay > 0) {
+            await this.delay(delay, signal);
+          }
+        }
+        lastTimestamp = chunk.timestamp;
+        this.config.onChunk(chunk);
+        yield chunk;
+      }
+      this.config.onComplete(stream);
+    } catch (error) {
+      if (error.name !== "AbortError") {
+        this.config.onError(error);
+        throw error;
+      }
+    } finally {
+      this.abortController = null;
+    }
+  }
+  /**
+   * Replay as a full async iterable of text content only
+   */
+  async *replayText(stream) {
+    for await (const chunk of this.replay(stream)) {
+      if (chunk.type === "text" && chunk.content) {
+        yield chunk.content;
+      }
+    }
+  }
+  /**
+   * Replay synchronously (no timing simulation)
+   */
+  *replaySync(stream) {
+    const chunks = [...stream.chunks].sort((a, b) => a.index - b.index);
+    for (const chunk of chunks) {
+      this.config.onChunk(chunk);
+      yield chunk;
+    }
+    this.config.onComplete(stream);
+  }
+  /**
+   * Get all chunks at once
+   */
+  getAllChunks(stream) {
+    return [...stream.chunks].sort((a, b) => a.index - b.index);
+  }
+  /**
+   * Get full text content from stream
+   */
+  getFullText(stream) {
+    return stream.chunks.filter((c) => c.type === "text" && c.content).sort((a, b) => a.index - b.index).map((c) => c.content).join("");
+  }
+  /**
+   * Get tool calls from stream
+   */
+  getToolCalls(stream) {
+    return stream.chunks.filter((c) => c.type === "tool_call" && c.toolCall).sort((a, b) => a.index - b.index).map((c) => c.toolCall);
+  }
+  /**
+   * Stop current replay
+   */
+  stop() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  /**
+   * Update configuration
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, ms);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new DOMException("Aborted", "AbortError"));
+      });
+    });
+  }
+};
+function createStreamReplayer(config) {
+  return new StreamReplayer(config);
+}
+var DEFAULT_CONFIG12 = {
+  recorder: {},
+  replayer: {},
+  cacheIncomplete: false,
+  minLengthToCache: 10,
+  streamTtl: 3600
+  // 1 hour
+};
+var StreamCache = class extends EventEmitter2 {
+  store;
+  similarity;
+  config;
+  recorder;
+  replayer;
+  stats = {
+    totalLookups: 0,
+    totalHits: 0,
+    totalMisses: 0,
+    hitRate: 0,
+    avgReplayLatencyMs: 0,
+    totalStreamsCached: 0,
+    totalBytesCached: 0,
+    avgStreamDurationMs: 0
+  };
+  replayLatencies = [];
+  streamDurations = [];
+  constructor(store, config, similarity) {
+    super();
+    this.store = store;
+    this.similarity = similarity;
+    this.config = { ...DEFAULT_CONFIG12, ...config };
+    this.recorder = new StreamRecorder(this.config.recorder);
+    this.replayer = new StreamReplayer(this.config.replayer);
+  }
+  /**
+   * Look up a cached stream
+   */
+  async lookup(model, messages) {
+    const startTime = performance.now();
+    this.stats.totalLookups++;
+    const key = this.generateStreamKey(model, messages);
+    try {
+      const entry = await this.store.get(key);
+      if (entry) {
+        const stream = this.deserializeStream(entry.response.content);
+        if (stream) {
+          this.stats.totalHits++;
+          this.updateHitRate();
+          const latencyMs2 = performance.now() - startTime;
+          this.replayLatencies.push(latencyMs2);
+          const result = {
+            hit: true,
+            stream,
+            similarity: 1,
+            source: "exact",
+            latencyMs: latencyMs2
+          };
+          this.emit("hit", result);
+          return result;
+        }
+      }
+      if (this.similarity) {
+        const userMessage = messages.find((m) => m.role === "user")?.content;
+        if (userMessage) {
+          const embedding = await this.similarity.embed(userMessage);
+          const results = await this.store.query(embedding, {
+            topK: 1,
+            minSimilarity: 0.92
+          });
+          if (results.entries.length > 0) {
+            const entry2 = results.entries[0];
+            const stream = this.deserializeStream(entry2.response.content);
+            if (stream && entry2.score >= 0.92) {
+              this.stats.totalHits++;
+              this.updateHitRate();
+              const latencyMs2 = performance.now() - startTime;
+              this.replayLatencies.push(latencyMs2);
+              const result = {
+                hit: true,
+                stream,
+                similarity: entry2.score,
+                source: "semantic",
+                latencyMs: latencyMs2
+              };
+              this.emit("hit", result);
+              return result;
+            }
+          }
+        }
+      }
+      this.stats.totalMisses++;
+      this.updateHitRate();
+      const latencyMs = performance.now() - startTime;
+      this.emit("miss", key);
+      return {
+        hit: false,
+        source: "miss",
+        latencyMs
+      };
+    } catch (error) {
+      this.emit("error", error);
+      return {
+        hit: false,
+        source: "miss",
+        latencyMs: performance.now() - startTime
+      };
+    }
+  }
+  /**
+   * Cache a recorded stream
+   */
+  async cache(stream, embedding) {
+    if (!stream.complete && !this.config.cacheIncomplete) {
+      return;
+    }
+    if (stream.totalChars < this.config.minLengthToCache) {
+      return;
+    }
+    const key = this.generateStreamKey(stream.model, stream.messages);
+    try {
+      const cacheMessages = stream.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      await this.store.set(key, {
+        id: generateId(),
+        key,
+        request: {
+          messages: cacheMessages,
+          model: stream.model
+        },
+        response: {
+          content: this.serializeStream(stream),
+          model: stream.model,
+          finishReason: stream.complete ? "stop" : "error",
+          usage: {
+            promptTokens: stream.tokenUsage?.prompt ?? 0,
+            completionTokens: stream.tokenUsage?.completion ?? 0,
+            totalTokens: stream.tokenUsage?.total ?? 0
+          }
+        },
+        embedding,
+        metadata: {
+          createdAt: now(),
+          accessedAt: now(),
+          accessCount: 1,
+          hitCount: 0,
+          ttl: this.config.streamTtl
+        }
+      });
+      this.stats.totalStreamsCached++;
+      this.stats.totalBytesCached += this.estimateStreamSize(stream);
+      this.streamDurations.push(stream.durationMs);
+      this.updateAvgStreamDuration();
+      this.emit("record", stream);
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Wrap a streaming function with caching
+   */
+  async *wrapStream(model, messages, streamFn, options) {
+    const lookupResult = await this.lookup(model, messages);
+    if (lookupResult.hit && lookupResult.stream) {
+      for await (const chunk of this.replayer.replay(lookupResult.stream)) {
+        yield { content: chunk.content };
+      }
+      return;
+    }
+    const key = this.generateStreamKey(model, messages);
+    this.recorder.start(model, messages, key);
+    try {
+      for await (const chunk of streamFn()) {
+        if (chunk.content) {
+          this.recorder.recordText(chunk.content);
+        }
+        yield chunk;
+      }
+      const stream = this.recorder.complete();
+      await this.cache(stream, options?.embedding);
+    } catch (error) {
+      if (this.recorder.isRecording()) {
+        this.recorder.abort(error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Replay a cached stream
+   */
+  async *replay(stream) {
+    for await (const chunk of this.replayer.replay(stream)) {
+      yield chunk;
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Clear the stream cache
+   */
+  async clear() {
+    await this.store.clear();
+    this.stats = {
+      totalLookups: 0,
+      totalHits: 0,
+      totalMisses: 0,
+      hitRate: 0,
+      avgReplayLatencyMs: 0,
+      totalStreamsCached: 0,
+      totalBytesCached: 0,
+      avgStreamDurationMs: 0
+    };
+    this.replayLatencies = [];
+    this.streamDurations = [];
+  }
+  /**
+   * Destroy the stream cache
+   */
+  destroy() {
+    this.recorder.destroy();
+    this.replayer.stop();
+    this.removeAllListeners();
+  }
+  generateStreamKey(model, messages) {
+    const cacheMessages = messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    return generateCacheKey(model, cacheMessages);
+  }
+  serializeStream(stream) {
+    return JSON.stringify(stream);
+  }
+  deserializeStream(content) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  estimateStreamSize(stream) {
+    return JSON.stringify(stream).length;
+  }
+  updateHitRate() {
+    if (this.stats.totalLookups > 0) {
+      this.stats.hitRate = this.stats.totalHits / this.stats.totalLookups * 100;
+    }
+  }
+  updateAvgStreamDuration() {
+    if (this.streamDurations.length > 0) {
+      this.stats.avgStreamDurationMs = this.streamDurations.reduce((a, b) => a + b, 0) / this.streamDurations.length;
+    }
+  }
+};
+function createStreamCache(store, config, similarity) {
+  return new StreamCache(store, config, similarity);
+}
+var DEFAULT_CONFIG13 = {
+  strategy: "ttl",
+  ttl: {
+    defaultTtl: 3600,
+    softTtl: false
+  },
+  emitEvents: true
+};
+var InvalidationManager = class extends EventEmitter2 {
+  store;
+  config;
+  autoInterval = null;
+  stats = {
+    totalInvalidations: 0,
+    ttlRemovals: 0,
+    lruRemovals: 0,
+    eventRemovals: 0,
+    smartRemovals: 0,
+    manualRemovals: 0,
+    totalBytesFreed: 0
+  };
+  accessTimes = /* @__PURE__ */ new Map();
+  constructor(store, config) {
+    super();
+    this.store = store;
+    this.config = { ...DEFAULT_CONFIG13, ...config };
+  }
+  /**
+   * Run invalidation based on configured strategy
+   */
+  async run() {
+    switch (this.config.strategy) {
+      case "ttl":
+        return this.runTTLInvalidation();
+      case "lru":
+        return this.runLRUInvalidation();
+      case "smart":
+        return this.runSmartInvalidation();
+      default:
+        return this.runTTLInvalidation();
+    }
+  }
+  /**
+   * Run TTL-based invalidation
+   */
+  async runTTLInvalidation() {
+    const startTime = performance.now();
+    const invalidatedKeys = [];
+    let bytesFreed = 0;
+    const currentTime = now();
+    const keys = await this.store.keys();
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (!entry) continue;
+      const ttl = entry.metadata.ttl ?? this.getTTL(entry.request.model, entry.metadata.namespace);
+      const age = (currentTime - entry.metadata.createdAt) / 1e3;
+      if (age >= ttl) {
+        if (this.config.ttl?.softTtl && this.config.ttl?.gracePeriod) {
+          if (age < ttl + this.config.ttl.gracePeriod) {
+            continue;
+          }
+        }
+        const deleted = await this.store.delete(key);
+        if (deleted) {
+          invalidatedKeys.push(key);
+          bytesFreed += this.estimateEntrySize(entry);
+        }
+      }
+    }
+    this.stats.totalInvalidations++;
+    this.stats.ttlRemovals += invalidatedKeys.length;
+    this.stats.totalBytesFreed += bytesFreed;
+    this.stats.lastInvalidationAt = now();
+    const result = {
+      invalidatedKeys,
+      entriesRemoved: invalidatedKeys.length,
+      bytesFreed,
+      durationMs: performance.now() - startTime
+    };
+    this.emitEvent("ttl", invalidatedKeys, bytesFreed);
+    return result;
+  }
+  /**
+   * Run LRU-based invalidation
+   */
+  async runLRUInvalidation() {
+    const startTime = performance.now();
+    const invalidatedKeys = [];
+    let bytesFreed = 0;
+    const maxEntries = this.config.lru?.maxEntries ?? 1e3;
+    this.config.lru?.maxSizeBytes ?? Infinity;
+    const batchSize = this.config.lru?.evictionBatchSize ?? 10;
+    const minAge = this.config.lru?.minAge ?? 0;
+    const currentSize = await this.store.size();
+    if (currentSize <= maxEntries) {
+      return {
+        invalidatedKeys: [],
+        entriesRemoved: 0,
+        bytesFreed: 0,
+        durationMs: performance.now() - startTime
+      };
+    }
+    const keys = await this.store.keys();
+    const entriesWithAccess = [];
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (entry) {
+        entriesWithAccess.push({
+          key,
+          accessedAt: entry.metadata.accessedAt,
+          size: this.estimateEntrySize(entry)
+        });
+      }
+    }
+    entriesWithAccess.sort((a, b) => a.accessedAt - b.accessedAt);
+    const toRemove = Math.min(currentSize - maxEntries, batchSize);
+    const currentTime = now();
+    for (let i = 0; i < toRemove && i < entriesWithAccess.length; i++) {
+      const { key, accessedAt, size } = entriesWithAccess[i];
+      const age = (currentTime - accessedAt) / 1e3;
+      if (age < minAge) continue;
+      const deleted = await this.store.delete(key);
+      if (deleted) {
+        invalidatedKeys.push(key);
+        bytesFreed += size;
+      }
+    }
+    this.stats.totalInvalidations++;
+    this.stats.lruRemovals += invalidatedKeys.length;
+    this.stats.totalBytesFreed += bytesFreed;
+    this.stats.lastInvalidationAt = now();
+    const result = {
+      invalidatedKeys,
+      entriesRemoved: invalidatedKeys.length,
+      bytesFreed,
+      durationMs: performance.now() - startTime
+    };
+    this.emitEvent("lru", invalidatedKeys, bytesFreed);
+    return result;
+  }
+  /**
+   * Run smart invalidation (combines TTL + LRU + hit rate analysis)
+   */
+  async runSmartInvalidation() {
+    const startTime = performance.now();
+    const invalidatedKeys = [];
+    let bytesFreed = 0;
+    const minHitRate = this.config.smart?.minHitRate ?? 0.1;
+    const currentTime = now();
+    const keys = await this.store.keys();
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (!entry) continue;
+      let shouldInvalidate = false;
+      const ttl = entry.metadata.ttl ?? this.getTTL(entry.request.model, entry.metadata.namespace);
+      const age = (currentTime - entry.metadata.createdAt) / 1e3;
+      if (age >= ttl) {
+        shouldInvalidate = true;
+      }
+      if (this.config.smart?.analyzeHitRate && entry.metadata.accessCount > 0) {
+        const accessRate = entry.metadata.accessCount / Math.max(age / 3600, 1);
+        if (accessRate < minHitRate) {
+          shouldInvalidate = true;
+        }
+      }
+      if (shouldInvalidate) {
+        const deleted = await this.store.delete(key);
+        if (deleted) {
+          invalidatedKeys.push(key);
+          bytesFreed += this.estimateEntrySize(entry);
+        }
+      }
+    }
+    this.stats.totalInvalidations++;
+    this.stats.smartRemovals += invalidatedKeys.length;
+    this.stats.totalBytesFreed += bytesFreed;
+    this.stats.lastInvalidationAt = now();
+    const result = {
+      invalidatedKeys,
+      entriesRemoved: invalidatedKeys.length,
+      bytesFreed,
+      durationMs: performance.now() - startTime
+    };
+    this.emitEvent("smart", invalidatedKeys, bytesFreed);
+    return result;
+  }
+  /**
+   * Manually invalidate specific keys
+   */
+  async invalidateKeys(keys) {
+    const startTime = performance.now();
+    const invalidatedKeys = [];
+    let bytesFreed = 0;
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (entry) {
+        const size = this.estimateEntrySize(entry);
+        const deleted = await this.store.delete(key);
+        if (deleted) {
+          invalidatedKeys.push(key);
+          bytesFreed += size;
+        }
+      }
+    }
+    this.stats.totalInvalidations++;
+    this.stats.manualRemovals += invalidatedKeys.length;
+    this.stats.totalBytesFreed += bytesFreed;
+    this.stats.lastInvalidationAt = now();
+    const result = {
+      invalidatedKeys,
+      entriesRemoved: invalidatedKeys.length,
+      bytesFreed,
+      durationMs: performance.now() - startTime
+    };
+    this.emitEvent("manual", invalidatedKeys, bytesFreed);
+    return result;
+  }
+  /**
+   * Invalidate by pattern (e.g., namespace or model)
+   */
+  async invalidateByPattern(options) {
+    const startTime = performance.now();
+    const invalidatedKeys = [];
+    let bytesFreed = 0;
+    const currentTime = now();
+    const keys = await this.store.keys();
+    for (const key of keys) {
+      const entry = await this.store.get(key);
+      if (!entry) continue;
+      let matches = true;
+      if (options.namespace && entry.metadata.namespace !== options.namespace) {
+        matches = false;
+      }
+      if (options.model && entry.request.model !== options.model) {
+        matches = false;
+      }
+      if (options.olderThan) {
+        const age = (currentTime - entry.metadata.createdAt) / 1e3;
+        if (age < options.olderThan) {
+          matches = false;
+        }
+      }
+      if (matches) {
+        const size = this.estimateEntrySize(entry);
+        const deleted = await this.store.delete(key);
+        if (deleted) {
+          invalidatedKeys.push(key);
+          bytesFreed += size;
+        }
+      }
+    }
+    this.stats.totalInvalidations++;
+    this.stats.manualRemovals += invalidatedKeys.length;
+    this.stats.totalBytesFreed += bytesFreed;
+    this.stats.lastInvalidationAt = now();
+    const result = {
+      invalidatedKeys,
+      entriesRemoved: invalidatedKeys.length,
+      bytesFreed,
+      durationMs: performance.now() - startTime
+    };
+    this.emitEvent("manual", invalidatedKeys, bytesFreed);
+    return result;
+  }
+  /**
+   * Start automatic invalidation
+   */
+  startAuto(intervalMs = 6e4) {
+    if (this.autoInterval) {
+      this.stopAuto();
+    }
+    this.autoInterval = setInterval(() => {
+      void (async () => {
+        try {
+          await this.run();
+        } catch (error) {
+          this.emit("error", error);
+        }
+      })();
+    }, intervalMs);
+  }
+  /**
+   * Stop automatic invalidation
+   */
+  stopAuto() {
+    if (this.autoInterval) {
+      clearInterval(this.autoInterval);
+      this.autoInterval = null;
+    }
+  }
+  /**
+   * Get invalidation statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalInvalidations: 0,
+      ttlRemovals: 0,
+      lruRemovals: 0,
+      eventRemovals: 0,
+      smartRemovals: 0,
+      manualRemovals: 0,
+      totalBytesFreed: 0
+    };
+  }
+  /**
+   * Destroy the manager
+   */
+  destroy() {
+    this.stopAuto();
+    this.removeAllListeners();
+    this.accessTimes.clear();
+  }
+  getTTL(model, namespace) {
+    if (this.config.ttl?.modelTtls?.[model]) {
+      return this.config.ttl.modelTtls[model];
+    }
+    if (namespace && this.config.ttl?.namespaceTtls?.[namespace]) {
+      return this.config.ttl.namespaceTtls[namespace];
+    }
+    return this.config.ttl?.defaultTtl ?? 3600;
+  }
+  estimateEntrySize(entry) {
+    return entry.response.content.length * 2 + 200;
+  }
+  emitEvent(reason, keys, bytesFreed) {
+    if (this.config.emitEvents && keys.length > 0) {
+      const event = {
+        timestamp: now(),
+        keys,
+        reason,
+        entriesRemoved: keys.length,
+        bytesFreed
+      };
+      this.emit("invalidate", event);
+      this.config.onInvalidate?.(event);
+    }
+  }
+};
+function createInvalidationManager(store, config) {
+  return new InvalidationManager(store, config);
+}
+
+export { BaseCacheStore, BaseMatchStrategy, CacheAnalytics, ChunkBuffer, ExactMatchStrategy, HybridMatchStrategy, InvalidationManager, MemoryCacheStore, PineconeCacheStore, RedisCacheStore, SQLiteCacheStore, SemanticCache, SemanticMatchStrategy, SimilarityEngine, StreamCache, StreamRecorder, StreamReplayer, TieredCacheStore, cosineSimilarity, createCacheAnalytics, createChunkBuffer, createExactMatchStrategy, createHybridMatchStrategy, createInvalidationManager, createMemoryCacheStore, createPineconeCacheStore, createRedisCacheStore, createSQLiteCacheStore, createSemanticCache, createSemanticMatchStrategy, createSimilarityEngine, createStreamCache, createStreamRecorder, createStreamReplayer, createTieredCacheStore, distanceToSimilarity, dotProduct, estimateEntrySize, euclideanDistance, extractSystemPrompt, extractUserMessage, generateCacheKey, generateConversationFingerprint, generateId, generateSemanticKey, isExpired, magnitude, manhattanDistance, normalize, normalizeWhitespace, now };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map