devchain-cli 0.17.0 → 0.17.2

package/dist/server/modules/session-reader/services/session-cache.service.js

@@ -38,76 +38,228 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var SessionCacheService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionCacheService = void 0;
+exports.SessionCacheService = exports.TRANSCRIPT_CACHE_CONFIG = void 0;
+exports.getTranscriptCacheConfig = getTranscriptCacheConfig;
 const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs/promises"));
 const estimate_content_tokens_1 = require("../adapters/utils/estimate-content-tokens");
 const tool_result_fold_1 = require("../adapters/utils/tool-result-fold");
 const coalesce_turns_1 = require("../adapters/utils/coalesce-turns");
-const CACHE_TTL_MS = 10 * 60 * 1_000;
-const CACHE_MAX_ENTRIES = 20;
+const metrics_service_1 = require("../../metrics/services/metrics.service");
+const DEFAULT_CACHE_IDLE_TTL_MS = 10 * 60 * 1_000;
+const DEFAULT_CACHE_SWEEP_INTERVAL_MS = 60_000;
+const DEFAULT_CACHE_BUDGET_BYTES = 64 * 1024 * 1024;
+const SAFE_INTEGER_LOW_BITS = 0x20_0000;
+const FILE_HASH_CHUNK_BYTES = 64 * 1024;
+function fileSourceVersion(stat) {
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update(`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`)
+        .digest();
+    return digest.readUInt32BE(0) * SAFE_INTEGER_LOW_BITS + (digest.readUInt32BE(4) >>> 11);
+}
+exports.TRANSCRIPT_CACHE_CONFIG = Symbol('TRANSCRIPT_CACHE_CONFIG');
+function getTranscriptCacheConfig() {
+    return {
+        budgetBytes: positiveIntegerFromEnv(process.env.TRANSCRIPT_CACHE_MAX_BYTES, DEFAULT_CACHE_BUDGET_BYTES),
+        idleTtlMs: positiveIntegerFromEnv(process.env.TRANSCRIPT_CACHE_IDLE_TTL_MS, DEFAULT_CACHE_IDLE_TTL_MS),
+        sweepIntervalMs: positiveIntegerFromEnv(process.env.TRANSCRIPT_CACHE_SWEEP_INTERVAL_MS, DEFAULT_CACHE_SWEEP_INTERVAL_MS),
+    };
+}
 let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
-    constructor() {
+    constructor(metricsService, config) {
+        this.metricsService = metricsService;
         this.logger = new common_1.Logger(SessionCacheService_1.name);
         this.cache = new Map();
+        this.hits = 0;
+        this.misses = 0;
+        this.chunksHits = 0;
+        this.chunksMisses = 0;
+        this.dtoHits = 0;
+        this.dtoMisses = 0;
+        this.budgetUsedBytes = 0;
+        this.evictions = 0;
+        this.config = config ?? getTranscriptCacheConfig();
+    }
+    onModuleInit() {
+        this.metricsService.registerCacheStatsProvider('parsed', () => this.getCacheStats(), () => Array.from(this.cache.values(), (entry) => entry.session));
+        this.metricsService.registerCacheStatsProvider('chunks', () => this.getChunksCacheStats(), () => this.getChunksRetainedRoots());
+        this.idleSweepTimer = setInterval(() => this.sweepIdleEntries(), this.config.sweepIntervalMs);
+        this.idleSweepTimer.unref();
     }
     onModuleDestroy() {
-        this.cache.clear();
+        if (this.idleSweepTimer) {
+            clearInterval(this.idleSweepTimer);
+            this.idleSweepTimer = undefined;
+        }
+        this.clear();
+    }
+    getCacheStats() {
+        const total = this.hits + this.misses;
+        return {
+            entries: this.cache.size,
+            bytesEstimated: 0,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+            bytesMethod: 'deferred-to-aggregate',
+            budgetUsedBytes: this.budgetUsedBytes,
+            budgetBytes: this.config.budgetBytes,
+            evictions: this.evictions,
+        };
+    }
+    getChunksCacheStats() {
+        const total = this.chunksHits + this.chunksMisses;
+        let entries = 0;
+        for (const entry of this.cache.values()) {
+            if (entry.chunks)
+                entries += 1;
+        }
+        return {
+            entries,
+            bytesEstimated: 0,
+            hits: this.chunksHits,
+            misses: this.chunksMisses,
+            hitRate: total > 0 ? this.chunksHits / total : 0,
+            bytesMethod: 'deferred-to-aggregate',
+        };
+    }
+    getDtoCacheStats() {
+        let entries = 0;
+        let bytesEstimated = 0;
+        for (const entry of this.cache.values()) {
+            if (!entry.dto)
+                continue;
+            entries += 1;
+            bytesEstimated += entry.dto.responseBytes;
+        }
+        const total = this.dtoHits + this.dtoMisses;
+        return {
+            entries,
+            bytesEstimated,
+            hits: this.dtoHits,
+            misses: this.dtoMisses,
+            hitRate: total > 0 ? this.dtoHits / total : 0,
+            bytesMethod: 'json-stringify-length',
+        };
+    }
+    async getFreshSession(sessionId, source, adapter) {
+        const cached = this.cache.get(sessionId);
+        if (!cached)
+            return undefined;
+        const ref = this.toSourceRef(source, adapter);
+        const freshness = await this.computeFreshness(ref, adapter);
+        return this.takeFreshCachedSession(sessionId, cached, freshness.token, Date.now());
     }
     async getOrParse(sessionId, source, adapter) {
+        return (await this.getOrParseResult(sessionId, source, adapter)).session;
+    }
+    async getOrParseWithMeta(sessionId, source, adapter) {
+        return this.getOrParseResult(sessionId, source, adapter);
+    }
+    async getOrParseResult(sessionId, source, adapter) {
         const now = Date.now();
         const ref = this.toSourceRef(source, adapter);
         const threadRef = typeof source !== 'string' ? ref : undefined;
-        const freshness = await this.computeFreshness(ref, adapter);
+        let freshness = await this.computeFreshness(ref, adapter);
         const cached = this.cache.get(sessionId);
-        if (cached &&
-            now - cached.cachedAt < CACHE_TTL_MS &&
-            JSON.stringify(cached.freshnessToken) === JSON.stringify(freshness.token)) {
-            this.logger.debug({ sessionId }, 'Session cache hit');
-            this.touchLru(sessionId, cached);
-            return cached.session;
+        const freshSession = this.takeFreshCachedSession(sessionId, cached, freshness.token, now);
+        if (freshSession && cached) {
+            return this.toGetOrParseResult(freshSession, cached, true, 'cache-hit');
         }
+        this.misses += 1;
         let session;
         let lastOffset;
         let boundaryFold = false;
-        if (cached && freshness.size > cached.lastSize) {
+        let acceptedFileDigests;
+        const sameFileIdentity = ref.kind !== 'file' ||
+            (cached?.fileIdentity !== undefined && cached.fileIdentity === freshness.fileIdentity);
+        const fileReplaced = cached !== undefined && ref.kind === 'file' && !sameFileIdentity;
+        const sameIdentityGrowth = cached !== undefined &&
+            ref.kind === 'file' &&
+            sameFileIdentity &&
+            freshness.size > cached.lastSize;
+        const growthDigests = sameIdentityGrowth && cached.fileContentDigest !== undefined
+            ? await this.tryHashFileContent(ref.filePath, freshness, cached.lastOffset)
+            : undefined;
+        const provenSameFileAppend = sameIdentityGrowth &&
+            cached.fileContentDigest !== undefined &&
+            growthDigests?.prefixDigest === cached.fileContentDigest;
+        let sourceChangeKind = !cached
+            ? 'unknown-full-parse'
+            : ref.kind === 'db'
+                ? 'db-update'
+                : fileReplaced
+                    ? 'file-replacement'
+                    : freshness.size > cached.lastSize
+                        ? provenSameFileAppend
+                            ? 'same-file-append'
+                            : 'same-file-rewrite'
+                        : freshness.size < cached.lastSize
+                            ? 'file-truncation'
+                            : 'same-file-rewrite';
+        if (cached && provenSameFileAppend && growthDigests) {
             this.logger.debug({ sessionId, lastOffset: cached.lastOffset, currentSize: freshness.size }, 'Incremental parse (source grew)');
             const incOptions = { byteOffset: cached.lastOffset, includeToolCalls: true };
-            const result = threadRef
+            let tentativeResult = threadRef
                 ? await adapter.parseIncremental(ref.filePath, incOptions, threadRef)
                 : await adapter.parseIncremental(ref.filePath, incOptions);
-            const newMessages = result.entries;
-            if (adapter.incrementalMode === 'snapshot') {
-                const snapshotMetrics = result.metrics ?? cached.session.metrics;
-                session = {
-                    ...cached.session,
-                    messages: newMessages,
-                    metrics: snapshotMetrics,
-                    isOngoing: snapshotMetrics.isOngoing,
-                    warnings: this.mergeWarnings(cached.session.warnings, result.warnings),
-                };
+            const postParseDigests = await this.tryHashFileContent(ref.filePath, freshness, freshness.size);
+            if (postParseDigests?.fullDigest !== growthDigests.fullDigest) {
+                this.logger.debug({ sessionId }, 'Discarding incremental parse because its proven file revision drifted');
+                tentativeResult = undefined;
+                freshness = await this.computeFreshness(ref, adapter);
+                sourceChangeKind = this.classifyUnsafeFileChange(cached, freshness);
+                session = threadRef
+                    ? await adapter.parseFullSession(ref.filePath, threadRef)
+                    : await adapter.parseFullSession(ref.filePath);
+                lastOffset = freshness.size;
             }
             else {
-                const folded = this.foldLeadingContinuationIntoCachedTail(cached.session.messages, newMessages);
-                boundaryFold = folded.tailMutatedWithoutNewMessage;
-                const mergedMessages = folded.merged;
-                const mergedMetrics = result.metrics
-                    ? this.mergeMetrics(cached.session.metrics, result.metrics, mergedMessages)
-                    : cached.session.metrics;
-                session = {
-                    ...cached.session,
-                    messages: mergedMessages,
-                    metrics: mergedMetrics,
-                    isOngoing: mergedMetrics.isOngoing,
-                    warnings: this.mergeWarnings(cached.session.warnings, result.warnings),
-                };
+                const acceptedResult = tentativeResult;
+                acceptedFileDigests = postParseDigests;
+                const newMessages = acceptedResult.entries;
+                if (adapter.incrementalMode === 'snapshot') {
+                    const snapshotMetrics = acceptedResult.metrics ?? cached.session.metrics;
+                    session = {
+                        ...cached.session,
+                        messages: newMessages,
+                        metrics: snapshotMetrics,
+                        isOngoing: snapshotMetrics.isOngoing,
+                        warnings: this.mergeWarnings(cached.session.warnings, acceptedResult.warnings),
+                    };
+                }
+                else {
+                    const folded = this.foldLeadingContinuationIntoCachedTail(cached.session.messages, newMessages);
+                    boundaryFold = folded.tailMutatedWithoutNewMessage;
+                    const mergedMessages = folded.merged;
+                    const mergedMetrics = acceptedResult.metrics
+                        ? this.mergeMetrics(cached.session.metrics, acceptedResult.metrics, mergedMessages)
+                        : cached.session.metrics;
+                    session = {
+                        ...cached.session,
+                        messages: mergedMessages,
+                        metrics: mergedMetrics,
+                        isOngoing: mergedMetrics.isOngoing,
+                        warnings: this.mergeWarnings(cached.session.warnings, acceptedResult.warnings),
+                    };
+                }
+                lastOffset = acceptedResult.nextByteOffset;
             }
-            lastOffset = result.nextByteOffset;
         }
         else {
-            if (cached && freshness.size < cached.lastSize) {
+            if (fileReplaced) {
+                this.logger.debug({ sessionId }, 'Full reparse (source replaced)');
+            }
+            else if (cached && freshness.size < cached.lastSize) {
                 this.logger.debug({ sessionId }, 'Full reparse (source truncated)');
             }
             session = threadRef
@@ -119,58 +271,175 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         if (coalesced.messages !== session.messages) {
             session = { ...session, messages: coalesced.messages, metrics: coalesced.metrics };
         }
-        this.evictIfNeeded(sessionId);
-        this.cache.delete(sessionId);
-        this.cache.set(sessionId, {
+        session = this.withoutDerivedChunks(session);
+        const fileContentDigest = ref.kind === 'file'
+            ? lastOffset === freshness.size && acceptedFileDigests !== undefined
+                ? acceptedFileDigests.fullDigest
+                : (await this.tryHashFileContent(ref.filePath, freshness, lastOffset))?.prefixDigest
+            : undefined;
+        this.deleteEntry(sessionId);
+        const sourceWeightBytes = this.estimateSourceWeight(ref, session, freshness.size);
+        const entry = {
             session,
             lastOffset,
             lastSize: freshness.size,
             lastMtime: freshness.mtimeMs,
+            fileIdentity: freshness.fileIdentity,
+            fileContentDigest,
             sourceVersion: freshness.sourceVersion,
             freshnessToken: freshness.token,
-            cachedAt: now,
+            lastAccessedAt: now,
+            sourceWeightBytes,
+            weights: { parsed: sourceWeightBytes * 2, chunks: 0, dto: 0 },
             boundaryFold,
-        });
-        return session;
-    }
-    async getOrParseWithMeta(sessionId, source, adapter) {
-        const prevSession = this.cache.get(sessionId)?.session;
-        const session = await this.getOrParse(sessionId, source, adapter);
-        const entry = this.cache.get(sessionId);
+        };
+        this.cache.set(sessionId, entry);
+        this.budgetUsedBytes += entry.weights.parsed;
+        this.enforceBudget();
         return {
             session,
-            cacheHit: session === prevSession,
-            lastOffset: entry.lastOffset,
-            lastSize: entry.lastSize,
-            lastMtime: entry.lastMtime,
-            sourceVersion: entry.sourceVersion,
-            boundaryFold: entry.boundaryFold,
+            cacheHit: false,
+            sourceChangeKind,
+            lastOffset,
+            lastSize: freshness.size,
+            lastMtime: freshness.mtimeMs,
+            sourceVersion: freshness.sourceVersion,
+            boundaryFold,
         };
     }
     getEntry(sessionId) {
         return this.cache.get(sessionId);
     }
+    getChunks(sessionId, sourceVersion) {
+        const entry = this.cache.get(sessionId);
+        if (!entry?.chunks || entry.chunks.sourceVersion !== sourceVersion) {
+            this.chunksMisses += 1;
+            return undefined;
+        }
+        this.chunksHits += 1;
+        this.touchLru(sessionId, entry, Date.now());
+        return entry.chunks.chunks;
+    }
+    setChunks(sessionId, sourceVersion, chunks) {
+        const entry = this.cache.get(sessionId);
+        if (!entry || entry.sourceVersion !== sourceVersion)
+            return;
+        this.budgetUsedBytes -= entry.weights.chunks;
+        entry.chunks = { chunks, sourceVersion };
+        entry.weights.chunks = entry.sourceWeightBytes;
+        this.budgetUsedBytes += entry.weights.chunks;
+        this.touchLru(sessionId, entry, Date.now());
+        this.enforceBudget();
+    }
+    getDto(sessionId, maxToolResultLength, enrichmentFingerprint) {
+        const entry = this.cache.get(sessionId);
+        const dto = entry?.dto;
+        if (!entry ||
+            !dto ||
+            dto.maxToolResultLength !== maxToolResultLength ||
+            dto.enrichmentFingerprint !== enrichmentFingerprint) {
+            this.dtoMisses += 1;
+            return undefined;
+        }
+        this.dtoHits += 1;
+        this.touchLru(sessionId, entry, Date.now());
+        return dto;
+    }
+    setDto(sessionId, dto) {
+        const entry = this.cache.get(sessionId);
+        if (!entry)
+            return;
+        this.budgetUsedBytes -= entry.weights.dto;
+        entry.dto = dto;
+        entry.weights.dto = dto.responseBytes;
+        this.budgetUsedBytes += entry.weights.dto;
+        this.touchLru(sessionId, entry, Date.now());
+        this.enforceBudget();
+    }
+    getDtoRetainedRoots() {
+        return Array.from(this.cache.values(), (entry) => entry.dto?.result);
+    }
+    getChunksRetainedRoots() {
+        return Array.from(this.cache.values(), (entry) => entry.chunks?.chunks);
+    }
+    sweepIdleEntries(now = Date.now()) {
+        let swept = 0;
+        for (const [sessionId, entry] of this.cache) {
+            if (now - entry.lastAccessedAt < this.config.idleTtlMs)
+                continue;
+            this.deleteEntry(sessionId);
+            swept += 1;
+        }
+        return swept;
+    }
     invalidate(sessionId) {
-        this.cache.delete(sessionId);
+        this.deleteEntry(sessionId);
     }
     clear() {
         this.cache.clear();
+        this.budgetUsedBytes = 0;
     }
     get size() {
         return this.cache.size;
     }
-    touchLru(sessionId, entry) {
+    takeFreshCachedSession(sessionId, cached, freshnessToken, now) {
+        if (!cached || JSON.stringify(cached.freshnessToken) !== JSON.stringify(freshnessToken)) {
+            return undefined;
+        }
+        this.logger.debug({ sessionId }, 'Session cache hit');
+        this.touchLru(sessionId, cached, now);
+        this.hits += 1;
+        return cached.session;
+    }
+    toGetOrParseResult(session, entry, cacheHit, sourceChangeKind) {
+        return {
+            session,
+            cacheHit,
+            sourceChangeKind,
+            lastOffset: entry.lastOffset,
+            lastSize: entry.lastSize,
+            lastMtime: entry.lastMtime,
+            sourceVersion: entry.sourceVersion,
+            boundaryFold: entry.boundaryFold,
+        };
+    }
+    touchLru(sessionId, entry, now) {
+        entry.lastAccessedAt = now;
         this.cache.delete(sessionId);
         this.cache.set(sessionId, entry);
     }
-    evictIfNeeded(sessionId) {
-        if (this.cache.size >= CACHE_MAX_ENTRIES && !this.cache.has(sessionId)) {
+    enforceBudget() {
+        while (this.budgetUsedBytes > this.config.budgetBytes && this.cache.size > 0) {
             const oldestKey = this.cache.keys().next().value;
             if (oldestKey !== undefined) {
-                this.cache.delete(oldestKey);
+                this.deleteEntry(oldestKey);
+                this.evictions += 1;
             }
         }
     }
+    deleteEntry(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (!entry)
+            return;
+        this.budgetUsedBytes -= this.entryWeight(entry);
+        this.cache.delete(sessionId);
+    }
+    entryWeight(entry) {
+        return entry.weights.parsed + entry.weights.chunks + entry.weights.dto;
+    }
+    estimateSourceWeight(ref, session, sourceSize) {
+        if (ref.kind === 'file')
+            return Math.max(1, sourceSize);
+        const tokenProxy = Math.max(session.metrics.totalContextConsumption, session.metrics.totalTokens, session.metrics.visibleContextTokens) * 4;
+        return Math.max(1_024, tokenProxy, session.messages.length * 256);
+    }
+    withoutDerivedChunks(session) {
+        if (session.chunks === undefined)
+            return session;
+        const parsedSession = { ...session };
+        delete parsedSession.chunks;
+        return parsedSession;
+    }
     foldLeadingContinuationIntoCachedTail(cachedMessages, newMessages) {
         const tail = cachedMessages[cachedMessages.length - 1];
         if (!tail || tail.role !== 'assistant' || newMessages.length === 0) {
@@ -266,7 +535,79 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
     }
     async statFile(filePath) {
         const stat = await fs.stat(filePath);
-        return { size: stat.size, mtimeMs: stat.mtime.getTime() };
+        return {
+            size: stat.size,
+            mtimeMs: stat.mtime.getTime(),
+            dev: stat.dev,
+            ino: stat.ino,
+            fileIdentity: `${stat.dev}:${stat.ino}`,
+        };
+    }
+    classifyUnsafeFileChange(cached, current) {
+        if (cached.fileIdentity === undefined ||
+            current.fileIdentity === undefined ||
+            cached.fileIdentity !== current.fileIdentity) {
+            return 'file-replacement';
+        }
+        if (current.size < cached.lastSize) {
+            return 'file-truncation';
+        }
+        return 'same-file-rewrite';
+    }
+    async tryHashFileContent(filePath, expected, prefixLength) {
+        try {
+            return await this.hashFileContent(filePath, expected, prefixLength);
+        }
+        catch (error) {
+            this.logger.debug({ error, filePath }, 'File prefix proof unavailable — append is unsafe');
+            return undefined;
+        }
+    }
+    async hashFileContent(filePath, expected, prefixLength) {
+        if (!Number.isSafeInteger(prefixLength) ||
+            prefixLength < 0 ||
+            prefixLength > expected.size ||
+            expected.fileIdentity === undefined) {
+            throw new Error('Invalid file prefix proof bounds');
+        }
+        const handle = await fs.open(filePath, 'r');
+        const assertStableSnapshot = async () => {
+            const current = await handle.stat();
+            if (current.size !== expected.size ||
+                current.mtime.getTime() !== expected.mtimeMs ||
+                `${current.dev}:${current.ino}` !== expected.fileIdentity) {
+                throw new Error('File changed while computing append proof');
+            }
+        };
+        try {
+            await assertStableSnapshot();
+            const prefixHash = (0, node_crypto_1.createHash)('sha256');
+            const fullHash = (0, node_crypto_1.createHash)('sha256');
+            const buffer = Buffer.allocUnsafe(Math.min(FILE_HASH_CHUNK_BYTES, Math.max(1, expected.size)));
+            let position = 0;
+            while (position < expected.size) {
+                const requested = Math.min(buffer.byteLength, expected.size - position);
+                const { bytesRead } = await handle.read(buffer, 0, requested, position);
+                if (bytesRead === 0) {
+                    throw new Error('File ended while computing append proof');
+                }
+                const chunk = buffer.subarray(0, bytesRead);
+                fullHash.update(chunk);
+                const prefixBytes = Math.min(bytesRead, Math.max(0, prefixLength - position));
+                if (prefixBytes > 0) {
+                    prefixHash.update(chunk.subarray(0, prefixBytes));
+                }
+                position += bytesRead;
+            }
+            await assertStableSnapshot();
+            return {
+                prefixDigest: prefixHash.digest('hex'),
+                fullDigest: fullHash.digest('hex'),
+            };
+        }
+        finally {
+            await handle.close();
+        }
     }
     toSourceRef(source, adapter) {
         if (typeof source === 'string') {
@@ -279,12 +620,21 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
         return source;
     }
     async computeFreshness(ref, adapter) {
-        const { size, mtimeMs } = await this.statFile(ref.filePath);
-        const token = adapter.getFreshnessToken
+        const { size, mtimeMs, dev, ino, fileIdentity } = await this.statFile(ref.filePath);
+        const adapterToken = adapter.getFreshnessToken
             ? await adapter.getFreshnessToken(ref)
-            : { mtimeMs, size };
-        const sourceVersion = ref.kind === 'db' ? this.dbSourceVersion(token, size) : size;
-        return { token, sourceVersion, size, mtimeMs };
+            : { mtimeMs, size, dev, ino };
+        const token = ref.kind === 'file' && adapter.getFreshnessToken ? { adapterToken, dev, ino } : adapterToken;
+        const sourceVersion = ref.kind === 'db'
+            ? this.dbSourceVersion(token, size)
+            : fileSourceVersion({ size, mtimeMs, dev, ino });
+        return {
+            token,
+            sourceVersion,
+            size,
+            mtimeMs,
+            fileIdentity: ref.kind === 'file' ? fileIdentity : undefined,
+        };
     }
     dbSourceVersion(token, fallbackSize) {
         if (token && typeof token === 'object') {
@@ -298,6 +648,15 @@ let SessionCacheService = SessionCacheService_1 = class SessionCacheService {
 };
 exports.SessionCacheService = SessionCacheService;
 exports.SessionCacheService = SessionCacheService = SessionCacheService_1 = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(exports.TRANSCRIPT_CACHE_CONFIG)),
+    __metadata("design:paramtypes", [metrics_service_1.MetricsService, Object])
 ], SessionCacheService);
+function positiveIntegerFromEnv(raw, fallback) {
+    if (raw === undefined)
+        return fallback;
+    const parsed = Number(raw);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
 //# sourceMappingURL=session-cache.service.js.map