@relayplane/proxy 1.5.46 → 1.7.1

package/dist/response-cache.d.ts

@@ -0,0 +1,139 @@
+/**
+ * RelayPlane Response Cache — Phase 1: Exact Match
+ *
+ * Caches LLM API responses locally to avoid duplicate API calls.
+ * SHA-256 hash of canonical request → cached response.
+ *
+ * Features:
+ * - In-memory LRU + disk persistence (~/.relayplane/cache/)
+ * - SQLite index for metadata (hit counts, cost tracking, TTL)
+ * - Gzipped response bodies on disk
+ * - Configurable TTL with task-type overrides
+ * - Only caches deterministic requests (temperature=0)
+ * - Skips responses containing tool calls
+ *
+ * @packageDocumentation
+ */
+export interface CacheConfig {
+    enabled?: boolean;
+    /** Max in-memory cache size in MB (default: 100) */
+    maxSizeMb?: number;
+    /** Default TTL in seconds (default: 3600 = 1 hour) */
+    defaultTtlSeconds?: number;
+    /** Per-task-type TTL overrides in seconds */
+    ttlByTaskType?: Record<string, number>;
+    /** Only cache when temperature=0 or unset (default: true) */
+    onlyWhenDeterministic?: boolean;
+    /** Cache directory (default: ~/.relayplane/cache) */
+    cacheDir?: string;
+    /** Cache mode: "exact" (default) or "aggressive" */
+    mode?: 'exact' | 'aggressive';
+    /** TTL for aggressive mode in seconds (default: 1800 = 30 min) */
+    aggressiveMaxAge?: number;
+}
+export interface CacheSetOptions {
+    model: string;
+    tokensIn: number;
+    tokensOut: number;
+    costUsd: number;
+    taskType?: string;
+}
+export interface CacheStats {
+    totalEntries: number;
+    totalSizeBytes: number;
+    hits: number;
+    misses: number;
+    bypasses: number;
+    hitRate: number;
+    savedCostUsd: number;
+    savedRequests: number;
+    byModel: Record<string, {
+        hits: number;
+        entries: number;
+        savedCostUsd: number;
+    }>;
+    byTaskType: Record<string, {
+        hits: number;
+        entries: number;
+        savedCostUsd: number;
+    }>;
+}
+/**
+ * Generate a SHA-256 cache key from a request body.
+ * Only includes fields that affect the response content.
+ * Excluded: stream, provider headers, API keys.
+ */
+export declare function computeCacheKey(requestBody: Record<string, unknown>): string;
+/**
+ * Generate an aggressive cache key from a request body.
+ * Uses: system prompt + last user message + model + tools.
+ * Ignores: full conversation history, temperature, max_tokens, etc.
+ */
+export declare function computeAggressiveCacheKey(requestBody: Record<string, unknown>): string;
+/**
+ * Check if a request is deterministic (temperature=0 or unset).
+ */
+export declare function isDeterministic(requestBody: Record<string, unknown>): boolean;
+/**
+ * Check if a response contains tool calls.
+ * Note: We still cache tool call responses — agent workloads are almost
+ * entirely tool calls, and identical requests should return cached results.
+ * The caller decides whether to use this check.
+ */
+export declare function responseHasToolCalls(responseBody: Record<string, unknown>): boolean;
+export declare class ResponseCache {
+    private config;
+    private memory;
+    private db;
+    private responsesDir;
+    private _initialized;
+    private _hits;
+    private _misses;
+    private _bypasses;
+    private _savedCostUsd;
+    constructor(config?: Partial<CacheConfig>);
+    /** Initialize disk storage + SQLite. Safe to call multiple times. */
+    init(): void;
+    /** Returns true if the request should bypass the cache. */
+    shouldBypass(requestBody: Record<string, unknown>): boolean;
+    /** Get the cache mode */
+    get mode(): 'exact' | 'aggressive';
+    /** Compute cache key based on current mode */
+    computeKey(requestBody: Record<string, unknown>): string;
+    /** Get aggressive mode max age in seconds */
+    get aggressiveMaxAge(): number;
+    /** Look up a cached response. Returns the response string or null. */
+    get(hash: string): string | null;
+    /** Store a response in cache. */
+    set(hash: string, responseJson: string, opts: CacheSetOptions): void;
+    /** Record a cache hit (for stats). */
+    recordHit(savedCostUsd: number, _savedLatencyMs: number): void;
+    /** Record a cache miss (for stats). */
+    recordMiss(): void;
+    /** Record a cache bypass (for stats). */
+    recordBypass(): void;
+    /** Remove a single entry. */
+    evict(hash: string): void;
+    /** Clear all cached entries. */
+    clear(): void;
+    /** Clean expired entries. Returns count removed. */
+    cleanup(): number;
+    /** Get detailed stats. */
+    getStats(): CacheStats;
+    /** Simple status for CLI. */
+    getStatus(): {
+        enabled: boolean;
+        entries: number;
+        sizeMb: number;
+        hitRate: string;
+        savedCostUsd: number;
+    };
+    setEnabled(enabled: boolean): void;
+    get enabled(): boolean;
+    close(): void;
+    private loadFromDisk;
+    private saveToDisk;
+}
+export declare function getResponseCache(config?: Partial<CacheConfig>): ResponseCache;
+export declare function resetResponseCache(): void;
+//# sourceMappingURL=response-cache.d.ts.map

package/dist/response-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-cache.d.ts","sourceRoot":"","sources":["../src/response-cache.ts"],"names":[],"mappings":"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"}

package/dist/response-cache.js

@@ -0,0 +1,515 @@
+"use strict";
+/**
+ * RelayPlane Response Cache — Phase 1: Exact Match
+ *
+ * Caches LLM API responses locally to avoid duplicate API calls.
+ * SHA-256 hash of canonical request → cached response.
+ *
+ * Features:
+ * - In-memory LRU + disk persistence (~/.relayplane/cache/)
+ * - SQLite index for metadata (hit counts, cost tracking, TTL)
+ * - Gzipped response bodies on disk
+ * - Configurable TTL with task-type overrides
+ * - Only caches deterministic requests (temperature=0)
+ * - Skips responses containing tool calls
+ *
+ * @packageDocumentation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseCache = void 0;
+exports.computeCacheKey = computeCacheKey;
+exports.computeAggressiveCacheKey = computeAggressiveCacheKey;
+exports.isDeterministic = isDeterministic;
+exports.responseHasToolCalls = responseHasToolCalls;
+exports.getResponseCache = getResponseCache;
+exports.resetResponseCache = resetResponseCache;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const zlib = __importStar(require("node:zlib"));
+const DEFAULTS = {
+    enabled: true,
+    maxSizeMb: 100,
+    defaultTtlSeconds: 3600,
+    ttlByTaskType: {},
+    onlyWhenDeterministic: true,
+    cacheDir: path.join(os.homedir(), '.relayplane', 'cache'),
+    mode: 'exact',
+    aggressiveMaxAge: 1800,
+};
+function resolveCache(cfg) {
+    return {
+        enabled: cfg?.enabled ?? DEFAULTS.enabled,
+        maxSizeMb: cfg?.maxSizeMb ?? DEFAULTS.maxSizeMb,
+        defaultTtlSeconds: cfg?.defaultTtlSeconds ?? DEFAULTS.defaultTtlSeconds,
+        ttlByTaskType: cfg?.ttlByTaskType ?? DEFAULTS.ttlByTaskType,
+        onlyWhenDeterministic: cfg?.onlyWhenDeterministic ?? DEFAULTS.onlyWhenDeterministic,
+        cacheDir: cfg?.cacheDir ?? DEFAULTS.cacheDir,
+        mode: cfg?.mode ?? DEFAULTS.mode,
+        aggressiveMaxAge: cfg?.aggressiveMaxAge ?? DEFAULTS.aggressiveMaxAge,
+    };
+}
+// ─── Cache Key Generation ────────────────────────────────────────────
+/**
+ * Fields included in the cache key (sorted alphabetically for determinism).
+ */
+const CACHE_KEY_FIELDS = [
+    'max_tokens',
+    'messages',
+    'model',
+    'stop_sequences',
+    'system',
+    'temperature',
+    'tool_choice',
+    'tools',
+    'top_k',
+    'top_p',
+];
+/**
+ * Generate a SHA-256 cache key from a request body.
+ * Only includes fields that affect the response content.
+ * Excluded: stream, provider headers, API keys.
+ */
+function computeCacheKey(requestBody) {
+    const canonical = {};
+    for (const field of CACHE_KEY_FIELDS) {
+        if (requestBody[field] !== undefined) {
+            canonical[field] = requestBody[field];
+        }
+    }
+    // Use stable JSON serialization (sorted top-level keys, full depth)
+    const sortedKeys = Object.keys(canonical).sort();
+    const ordered = {};
+    for (const k of sortedKeys)
+        ordered[k] = canonical[k];
+    const json = JSON.stringify(ordered);
+    return crypto.createHash('sha256').update(json).digest('hex');
+}
+/**
+ * Fields included in the aggressive cache key.
+ * Ignores conversation history — only uses system prompt + last user message + model + tools.
+ */
+const AGGRESSIVE_KEY_FIELDS = ['model', 'system', 'tools'];
+/**
+ * Generate an aggressive cache key from a request body.
+ * Uses: system prompt + last user message + model + tools.
+ * Ignores: full conversation history, temperature, max_tokens, etc.
+ */
+function computeAggressiveCacheKey(requestBody) {
+    const canonical = {};
+    for (const field of AGGRESSIVE_KEY_FIELDS) {
+        if (requestBody[field] !== undefined) {
+            canonical[field] = requestBody[field];
+        }
+    }
+    // Extract last user message only
+    const messages = requestBody['messages'];
+    if (messages && messages.length > 0) {
+        // Find last user message
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i]['role'] === 'user') {
+                canonical['last_user_message'] = messages[i]['content'];
+                break;
+            }
+        }
+    }
+    const sortedKeys = Object.keys(canonical).sort();
+    const ordered = {};
+    for (const k of sortedKeys)
+        ordered[k] = canonical[k];
+    const json = JSON.stringify(ordered);
+    return crypto.createHash('sha256').update(json).digest('hex');
+}
+/**
+ * Check if a request is deterministic (temperature=0 or unset).
+ */
+function isDeterministic(requestBody) {
+    const temp = requestBody['temperature'];
+    return temp === undefined || temp === null || temp === 0;
+}
+/**
+ * Check if a response contains tool calls.
+ * Note: We still cache tool call responses — agent workloads are almost
+ * entirely tool calls, and identical requests should return cached results.
+ * The caller decides whether to use this check.
+ */
+function responseHasToolCalls(responseBody) {
+    // OpenAI format: choices[].message.tool_calls
+    const choices = responseBody['choices'];
+    if (choices) {
+        for (const choice of choices) {
+            const message = choice['message'];
+            if (message?.['tool_calls'] && Array.isArray(message['tool_calls']) && message['tool_calls'].length > 0) {
+                return true;
+            }
+        }
+    }
+    // Anthropic format: content[].type === 'tool_use'
+    const content = responseBody['content'];
+    if (content) {
+        for (const block of content) {
+            if (block['type'] === 'tool_use')
+                return true;
+        }
+    }
+    // Anthropic stop_reason
+    if (responseBody['stop_reason'] === 'tool_use')
+        return true;
+    return false;
+}
+class MemoryLRU {
+    entries = new Map();
+    currentSizeBytes = 0;
+    maxSizeBytes;
+    constructor(maxSizeMb) {
+        this.maxSizeBytes = maxSizeMb * 1024 * 1024;
+    }
+    get(hash) {
+        const entry = this.entries.get(hash);
+        if (!entry)
+            return null;
+        // Move to end (most recently used)
+        this.entries.delete(hash);
+        this.entries.set(hash, entry);
+        return entry.response;
+    }
+    set(hash, response) {
+        const sizeBytes = Buffer.byteLength(response, 'utf-8');
+        const existing = this.entries.get(hash);
+        if (existing) {
+            this.currentSizeBytes -= existing.sizeBytes;
+            this.entries.delete(hash);
+        }
+        // Evict LRU until we have space
+        while (this.currentSizeBytes + sizeBytes > this.maxSizeBytes && this.entries.size > 0) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            const entry = this.entries.get(oldest);
+            if (entry) {
+                this.currentSizeBytes -= entry.sizeBytes;
+                this.entries.delete(oldest);
+            }
+        }
+        if (sizeBytes > this.maxSizeBytes)
+            return; // too big
+        this.entries.set(hash, { response, sizeBytes });
+        this.currentSizeBytes += sizeBytes;
+    }
+    delete(hash) {
+        const entry = this.entries.get(hash);
+        if (entry) {
+            this.currentSizeBytes -= entry.sizeBytes;
+            this.entries.delete(hash);
+        }
+    }
+    clear() {
+        this.entries.clear();
+        this.currentSizeBytes = 0;
+    }
+    get size() { return this.entries.size; }
+    get sizeBytes() { return this.currentSizeBytes; }
+}
+function openDatabase(dbPath) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    return db;
+}
+// ─── ResponseCache ──────────────────────────────────────────────────
+class ResponseCache {
+    config;
+    memory;
+    db = null;
+    responsesDir;
+    _initialized = false;
+    // Runtime counters
+    _hits = 0;
+    _misses = 0;
+    _bypasses = 0;
+    _savedCostUsd = 0;
+    constructor(config) {
+        this.config = resolveCache(config);
+        this.memory = new MemoryLRU(this.config.maxSizeMb);
+        this.responsesDir = path.join(this.config.cacheDir, 'responses');
+    }
+    /** Initialize disk storage + SQLite. Safe to call multiple times. */
+    init() {
+        if (this._initialized)
+            return;
+        if (!this.config.enabled)
+            return;
+        this._initialized = true;
+        fs.mkdirSync(this.config.cacheDir, { recursive: true });
+        fs.mkdirSync(this.responsesDir, { recursive: true });
+        try {
+            const dbPath = path.join(this.config.cacheDir, 'index.db');
+            this.db = openDatabase(dbPath);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS cache_entries (
+          hash TEXT PRIMARY KEY,
+          model TEXT NOT NULL,
+          task_type TEXT NOT NULL DEFAULT 'general',
+          tokens_in INTEGER NOT NULL DEFAULT 0,
+          tokens_out INTEGER NOT NULL DEFAULT 0,
+          cost_usd REAL NOT NULL DEFAULT 0,
+          created_at INTEGER NOT NULL,
+          expires_at INTEGER NOT NULL,
+          hit_count INTEGER NOT NULL DEFAULT 0,
+          response_size_bytes INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_expires_at ON cache_entries(expires_at);
+        CREATE INDEX IF NOT EXISTS idx_model ON cache_entries(model);
+      `);
+            // Clean expired on startup
+            this.db.prepare('DELETE FROM cache_entries WHERE expires_at <= ?').run(Date.now());
+        }
+        catch (err) {
+            console.warn('[RelayPlane Cache] SQLite unavailable, memory-only mode:', err.message);
+            this.db = null;
+        }
+    }
+    /** Returns true if the request should bypass the cache. */
+    shouldBypass(requestBody) {
+        if (!this.config.enabled)
+            return true;
+        // In aggressive mode, bypass only if disabled
+        if (this.config.mode === 'aggressive')
+            return false;
+        if (this.config.onlyWhenDeterministic && !isDeterministic(requestBody))
+            return true;
+        return false;
+    }
+    /** Get the cache mode */
+    get mode() { return this.config.mode; }
+    /** Compute cache key based on current mode */
+    computeKey(requestBody) {
+        if (this.config.mode === 'aggressive') {
+            return computeAggressiveCacheKey(requestBody);
+        }
+        return computeCacheKey(requestBody);
+    }
+    /** Get aggressive mode max age in seconds */
+    get aggressiveMaxAge() { return this.config.aggressiveMaxAge; }
+    /** Look up a cached response. Returns the response string or null. */
+    get(hash) {
+        // Memory first
+        const memHit = this.memory.get(hash);
+        if (memHit !== null) {
+            // Check expiry via DB if available
+            if (this.db) {
+                const row = this.db.prepare('SELECT expires_at FROM cache_entries WHERE hash = ?').get(hash);
+                if (!row || row.expires_at <= Date.now()) {
+                    this.evict(hash);
+                    return null;
+                }
+                this.db.prepare('UPDATE cache_entries SET hit_count = hit_count + 1 WHERE hash = ?').run(hash);
+            }
+            return memHit;
+        }
+        // Disk fallback
+        if (this.db) {
+            const row = this.db.prepare('SELECT hash FROM cache_entries WHERE hash = ? AND expires_at > ?').get(hash, Date.now());
+            if (row) {
+                const diskResponse = this.loadFromDisk(hash);
+                if (diskResponse) {
+                    this.memory.set(hash, diskResponse);
+                    this.db.prepare('UPDATE cache_entries SET hit_count = hit_count + 1 WHERE hash = ?').run(hash);
+                    return diskResponse;
+                }
+                // Broken disk entry
+                this.db.prepare('DELETE FROM cache_entries WHERE hash = ?').run(hash);
+            }
+        }
+        return null;
+    }
+    /** Store a response in cache. */
+    set(hash, responseJson, opts) {
+        if (!this.config.enabled)
+            return;
+        const taskType = opts.taskType || 'general';
+        const ttlSec = this.config.ttlByTaskType[taskType] ?? this.config.defaultTtlSeconds;
+        const now = Date.now();
+        const sizeBytes = Buffer.byteLength(responseJson, 'utf-8');
+        // Memory
+        this.memory.set(hash, responseJson);
+        // Disk
+        this.saveToDisk(hash, responseJson);
+        // SQLite
+        if (this.db) {
+            this.db.prepare(`
+        INSERT OR REPLACE INTO cache_entries 
+        (hash, model, task_type, tokens_in, tokens_out, cost_usd, created_at, expires_at, hit_count, response_size_bytes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+      `).run(hash, opts.model, taskType, opts.tokensIn, opts.tokensOut, opts.costUsd, now, now + ttlSec * 1000, sizeBytes);
+        }
+    }
+    /** Record a cache hit (for stats). */
+    recordHit(savedCostUsd, _savedLatencyMs) {
+        this._hits++;
+        this._savedCostUsd += savedCostUsd;
+    }
+    /** Record a cache miss (for stats). */
+    recordMiss() {
+        this._misses++;
+    }
+    /** Record a cache bypass (for stats). */
+    recordBypass() {
+        this._bypasses++;
+    }
+    /** Remove a single entry. */
+    evict(hash) {
+        this.memory.delete(hash);
+        if (this.db)
+            this.db.prepare('DELETE FROM cache_entries WHERE hash = ?').run(hash);
+        try {
+            fs.unlinkSync(path.join(this.responsesDir, `${hash}.gz`));
+        }
+        catch { /* ok */ }
+    }
+    /** Clear all cached entries. */
+    clear() {
+        this.memory.clear();
+        if (this.db)
+            this.db.exec('DELETE FROM cache_entries');
+        try {
+            for (const f of fs.readdirSync(this.responsesDir)) {
+                try {
+                    fs.unlinkSync(path.join(this.responsesDir, f));
+                }
+                catch { /* ok */ }
+            }
+        }
+        catch { /* ok */ }
+        this._hits = 0;
+        this._misses = 0;
+        this._bypasses = 0;
+        this._savedCostUsd = 0;
+    }
+    /** Clean expired entries. Returns count removed. */
+    cleanup() {
+        if (!this.db)
+            return 0;
+        const now = Date.now();
+        const expired = this.db.prepare('SELECT hash FROM cache_entries WHERE expires_at <= ?').all(now);
+        for (const { hash } of expired)
+            this.evict(hash);
+        return expired.length;
+    }
+    /** Get detailed stats. */
+    getStats() {
+        const total = this._hits + this._misses;
+        const result = {
+            totalEntries: this.memory.size,
+            totalSizeBytes: this.memory.sizeBytes,
+            hits: this._hits,
+            misses: this._misses,
+            bypasses: this._bypasses,
+            hitRate: total > 0 ? this._hits / total : 0,
+            savedCostUsd: this._savedCostUsd,
+            savedRequests: this._hits,
+            byModel: {},
+            byTaskType: {},
+        };
+        if (this.db) {
+            const countRow = this.db.prepare('SELECT COUNT(*) as c, COALESCE(SUM(response_size_bytes),0) as s FROM cache_entries').get();
+            result.totalEntries = countRow.c;
+            result.totalSizeBytes = countRow.s;
+            const modelRows = this.db.prepare('SELECT model, SUM(hit_count) as h, COUNT(*) as e, SUM(cost_usd * hit_count) as sv FROM cache_entries GROUP BY model').all();
+            for (const r of modelRows)
+                result.byModel[r.model] = { hits: r.h, entries: r.e, savedCostUsd: r.sv };
+            const taskRows = this.db.prepare('SELECT task_type, SUM(hit_count) as h, COUNT(*) as e, SUM(cost_usd * hit_count) as sv FROM cache_entries GROUP BY task_type').all();
+            for (const r of taskRows)
+                result.byTaskType[r.task_type] = { hits: r.h, entries: r.e, savedCostUsd: r.sv };
+        }
+        return result;
+    }
+    /** Simple status for CLI. */
+    getStatus() {
+        const s = this.getStats();
+        return {
+            enabled: this.config.enabled,
+            entries: s.totalEntries,
+            sizeMb: parseFloat((s.totalSizeBytes / (1024 * 1024)).toFixed(2)),
+            hitRate: `${(s.hitRate * 100).toFixed(1)}%`,
+            savedCostUsd: parseFloat(s.savedCostUsd.toFixed(4)),
+        };
+    }
+    setEnabled(enabled) { this.config.enabled = enabled; }
+    get enabled() { return this.config.enabled; }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    // ─── Private ──────────────────────────────────────────────────────
+    loadFromDisk(hash) {
+        try {
+            const compressed = fs.readFileSync(path.join(this.responsesDir, `${hash}.gz`));
+            return zlib.gunzipSync(compressed).toString('utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    saveToDisk(hash, response) {
+        try {
+            const compressed = zlib.gzipSync(Buffer.from(response, 'utf-8'));
+            fs.writeFileSync(path.join(this.responsesDir, `${hash}.gz`), compressed);
+        }
+        catch { /* non-fatal */ }
+    }
+}
+exports.ResponseCache = ResponseCache;
+// ─── Singleton ──────────────────────────────────────────────────────
+let _instance = null;
+function getResponseCache(config) {
+    if (!_instance) {
+        _instance = new ResponseCache(config);
+    }
+    return _instance;
+}
+function resetResponseCache() {
+    if (_instance) {
+        _instance.close();
+        _instance = null;
+    }
+}
+//# sourceMappingURL=response-cache.js.map