@ixo/matrix 1.1.0

package/dist/src/checkpointer/checkpointer.js

@@ -0,0 +1,669 @@
+import 'dotenv/config';
+import { BaseCheckpointSaver, TASKS, WRITES_IDX_MAP, copyCheckpoint, maxChannelVersion, } from '@langchain/langgraph-checkpoint';
+import { Logger } from '@ixo/logger';
+import { matrixStateManager } from '../matrix-state-manager/matrix-state-manager.js';
+class LRUCache {
+    cache = new Map();
+    max;
+    ttl;
+    constructor(max = 5000, ttl = 30000) {
+        this.max = max;
+        this.ttl = ttl;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.timestamp > this.ttl) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        this.cache.delete(key);
+        if (this.cache.size >= this.max) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(key, { value, timestamp: Date.now() });
+    }
+    delete(key) {
+        this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    deletePattern(pattern) {
+        const keysToDelete = [];
+        for (const key of this.cache.keys()) {
+            if (key.includes(pattern)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+        }
+    }
+}
+export class MatrixCheckpointSaver extends BaseCheckpointSaver {
+    stateManager = matrixStateManager;
+    checkpointCache;
+    writesCache;
+    latestCache;
+    indexCache;
+    metrics = {
+        hits: 0,
+        misses: 0,
+        indexRebuilds: 0,
+        filteredEvents: 0,
+        duplicateEvents: 0,
+    };
+    cacheTTL;
+    cacheMax;
+    maxCheckpointSizeBytes;
+    constructor(serde) {
+        super(serde);
+        this.cacheTTL = parseInt(process.env.MATRIX_CP_CACHE_TTL_MS || '300000', 10);
+        this.cacheMax = parseInt(process.env.MATRIX_CP_CACHE_MAX || '50000', 10);
+        this.maxCheckpointSizeBytes = parseInt(process.env.MATRIX_CP_MAX_SIZE_BYTES || '10485760', 10);
+        this.checkpointCache = new LRUCache(this.cacheMax, this.cacheTTL);
+        this.writesCache = new LRUCache(this.cacheMax, this.cacheTTL);
+        this.latestCache = new LRUCache(this.cacheMax, this.cacheTTL);
+        this.indexCache = new LRUCache(this.cacheMax, this.cacheTTL);
+    }
+    sanitizeOracleDid(oracleDid) {
+        return oracleDid.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+    getCheckpointKey(oracleDid, threadId, checkpointNs, checkpointId) {
+        const safe = this.sanitizeOracleDid(oracleDid);
+        return `${safe}_ckpt_${threadId}_${checkpointNs}_${checkpointId}`;
+    }
+    getWritesKey(oracleDid, threadId, checkpointNs, checkpointId) {
+        const safe = this.sanitizeOracleDid(oracleDid);
+        return `${safe}_writes_${threadId}_${checkpointNs}_${checkpointId}`;
+    }
+    getLatestCheckpointKey(oracleDid, threadId, checkpointNs) {
+        const safe = this.sanitizeOracleDid(oracleDid);
+        return `${safe}_latest_${threadId}_${checkpointNs}`;
+    }
+    getThreadMapKey(oracleDid) {
+        const safe = this.sanitizeOracleDid(oracleDid);
+        return `${safe}_thread_map`;
+    }
+    getCacheWritesKey(roomId, oracleDid, threadId, checkpointNs, checkpointId) {
+        return `${roomId}:${oracleDid}:${threadId}:${checkpointNs}:${checkpointId}:writes`;
+    }
+    getCacheLatestKey(roomId, oracleDid, threadId, checkpointNs) {
+        return `${roomId}:${oracleDid}:${threadId}:${checkpointNs}:latest`;
+    }
+    getCacheCheckpointKey(roomId, oracleDid, threadId, checkpointNs, checkpointId) {
+        return `${roomId}:${oracleDid}:${threadId}:${checkpointNs}:${checkpointId}:checkpoint`;
+    }
+    async getThreadMap(roomId, oracleDid) {
+        const cacheKey = `thread_map:${roomId}:${oracleDid}`;
+        const cached = this.indexCache.get(cacheKey);
+        if (cached) {
+            this.metrics.hits++;
+            return cached;
+        }
+        this.metrics.misses++;
+        try {
+            const threadMapKey = this.getThreadMapKey(oracleDid);
+            const threadMap = await this.stateManager.getState(roomId, threadMapKey);
+            if (threadMap && !threadMap.deleted) {
+                this.indexCache.set(cacheKey, threadMap);
+                return threadMap;
+            }
+        }
+        catch {
+        }
+        const emptyMap = {};
+        this.indexCache.set(cacheKey, emptyMap);
+        return emptyMap;
+    }
+    async updateThreadMap(roomId, oracleDid, threadId, checkpointId) {
+        const threadMap = await this.getThreadMap(roomId, oracleDid);
+        threadMap[threadId] = checkpointId;
+        const threadMapKey = this.getThreadMapKey(oracleDid);
+        await this.stateManager.setState({
+            roomId,
+            stateKey: threadMapKey,
+            data: threadMap,
+        });
+        const cacheKey = `thread_map:${roomId}:${oracleDid}`;
+        this.indexCache.set(cacheKey, threadMap);
+        Logger.debug(`Updated thread mapping: ${threadId} -> ${checkpointId}`);
+    }
+    async storeCheckpoint(roomId, oracleDid, storedCheckpoint) {
+        const key = this.getCheckpointKey(oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns, storedCheckpoint.checkpoint_id);
+        storedCheckpoint.lastUpdatedAt = Date.now();
+        const serialized = JSON.stringify(storedCheckpoint);
+        storedCheckpoint.sizeBytes = serialized.length;
+        if (serialized.length > this.maxCheckpointSizeBytes) {
+            Logger.warn(`Checkpoint ${storedCheckpoint.checkpoint_id} exceeds size limit: ${serialized.length} bytes`, {
+                threadId: storedCheckpoint.thread_id,
+                checkpointNs: storedCheckpoint.checkpoint_ns,
+                maxSize: this.maxCheckpointSizeBytes,
+            });
+        }
+        await this.stateManager.setState({
+            roomId,
+            stateKey: key,
+            data: storedCheckpoint,
+        });
+        await this.updateThreadMap(roomId, oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_id);
+        const latestKey = this.getLatestCheckpointKey(oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns);
+        await this.stateManager.setState({
+            roomId,
+            stateKey: latestKey,
+            data: storedCheckpoint,
+        });
+        const latestCacheKey = this.getCacheLatestKey(roomId, oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns);
+        this.latestCache.set(latestCacheKey, {
+            checkpointId: storedCheckpoint.checkpoint_id,
+            lastUpdatedAt: Date.now(),
+        });
+    }
+    async storeWrites(roomId, oracleDid, writes) {
+        if (!writes || writes.length === 0 || !writes[0])
+            return;
+        const key = this.getWritesKey(oracleDid, writes[0].thread_id, writes[0].checkpoint_ns, writes[0].checkpoint_id);
+        const existingWrites = await this.getStoredWrites(roomId, oracleDid, writes[0].thread_id, writes[0].checkpoint_ns, writes[0].checkpoint_id);
+        const writeMap = new Map();
+        for (const write of existingWrites) {
+            const compositeKey = `${write.task_id}:${write.idx}`;
+            writeMap.set(compositeKey, write);
+        }
+        let replacedCount = 0;
+        let appendedCount = 0;
+        for (const write of writes) {
+            const compositeKey = `${write.task_id}:${write.idx}`;
+            if (writeMap.has(compositeKey)) {
+                replacedCount++;
+            }
+            else {
+                appendedCount++;
+            }
+            writeMap.set(compositeKey, write);
+        }
+        const allWrites = Array.from(writeMap.values()).sort((a, b) => a.idx - b.idx);
+        await this.stateManager.setState({
+            roomId,
+            stateKey: key,
+            data: allWrites,
+        });
+        const cacheKey = this.getCacheWritesKey(roomId, oracleDid, writes[0].thread_id, writes[0].checkpoint_ns, writes[0].checkpoint_id);
+        this.writesCache.set(cacheKey, allWrites);
+        Logger.debug(`Stored writes for checkpoint ${writes[0].checkpoint_id}: ${replacedCount} replaced, ${appendedCount} appended`);
+    }
+    async getStoredCheckpoint(roomId, oracleDid, threadId, checkpointNs, checkpointId) {
+        try {
+            if (!checkpointId) {
+                const threadMap = await this.getThreadMap(roomId, oracleDid);
+                const latestCheckpointId = threadMap[threadId];
+                if (!latestCheckpointId) {
+                    Logger.debug(`No checkpoint found for thread ${threadId}`);
+                    return undefined;
+                }
+                checkpointId = latestCheckpointId;
+            }
+            const checkpointCacheKey = this.getCacheCheckpointKey(roomId, oracleDid, threadId, checkpointNs, checkpointId);
+            const cachedCheckpoint = this.checkpointCache.get(checkpointCacheKey);
+            if (cachedCheckpoint) {
+                this.metrics.hits++;
+                Logger.debug(`Checkpoint cache HIT for ${checkpointId}`, {
+                    threadId,
+                    checkpointNs,
+                    checkpointId,
+                });
+                return cachedCheckpoint;
+            }
+            this.metrics.misses++;
+            const key = this.getCheckpointKey(oracleDid, threadId, checkpointNs, checkpointId);
+            const stored = await this.stateManager.getState(roomId, key);
+            if (!stored ||
+                stored.deleted ||
+                !this.isValidCheckpoint(stored)) {
+                return undefined;
+            }
+            this.checkpointCache.set(checkpointCacheKey, stored);
+            return stored;
+        }
+        catch (error) {
+            Logger.debug(`Failed to get checkpoint: ${checkpointId || 'latest'}`, error);
+            return undefined;
+        }
+    }
+    isValidCheckpoint(checkpoint) {
+        return (checkpoint &&
+            typeof checkpoint === 'object' &&
+            typeof checkpoint.thread_id === 'string' &&
+            typeof checkpoint.checkpoint_id === 'string' &&
+            typeof checkpoint.checkpoint_ns === 'string' &&
+            typeof checkpoint.type === 'string' &&
+            typeof checkpoint.checkpoint === 'string' &&
+            typeof checkpoint.metadata === 'string');
+    }
+    async getStoredWrites(roomId, oracleDid, threadId, checkpointNs, checkpointId) {
+        const cacheKey = this.getCacheWritesKey(roomId, oracleDid, threadId, checkpointNs, checkpointId);
+        const cached = this.writesCache.get(cacheKey);
+        if (cached) {
+            this.metrics.hits++;
+            Logger.debug(`Writes cache HIT for checkpoint ${checkpointId}`, {
+                checkpointId,
+                cacheKey,
+            });
+            return cached;
+        }
+        this.metrics.misses++;
+        try {
+            const key = this.getWritesKey(oracleDid, threadId, checkpointNs, checkpointId);
+            const writes = await this.stateManager.getState(roomId, key);
+            if (!writes || writes.deleted) {
+                return [];
+            }
+            const sorted = (writes || []).sort((a, b) => a.idx - b.idx);
+            this.writesCache.set(cacheKey, sorted);
+            return sorted;
+        }
+        catch (error) {
+            if (error?.errcode === 'M_NOT_FOUND') {
+                Logger.debug(`No writes found for checkpoint ${checkpointId} (expected for checkpoints with writesCount=0)`);
+            }
+            else {
+                Logger.debug(`Failed to get writes for checkpoint ${checkpointId}`, error);
+            }
+            return [];
+        }
+    }
+    async migratePendingSends(mutableCheckpoint, roomId, oracleDid, threadId, checkpointNs, parentCheckpointId) {
+        const parentWrites = await this.getStoredWrites(roomId, oracleDid, threadId, checkpointNs, parentCheckpointId);
+        const taskWrites = parentWrites
+            .filter((write) => write.channel === TASKS)
+            .sort((a, b) => a.idx - b.idx);
+        const pendingSends = await Promise.all(taskWrites.map(async (write) => {
+            return await this.serde.loadsTyped(write.type, write.value);
+        }));
+        mutableCheckpoint.channel_values ??= {};
+        mutableCheckpoint.channel_values[TASKS] = pendingSends;
+        mutableCheckpoint.channel_versions ??= {};
+        mutableCheckpoint.channel_versions[TASKS] =
+            Object.keys(mutableCheckpoint.channel_versions).length > 0
+                ? maxChannelVersion(...Object.values(mutableCheckpoint.channel_versions))
+                : this.getNextVersion(undefined);
+    }
+    async getTuple(config) {
+        const startTime = Date.now();
+        const { thread_id: threadId, checkpoint_ns: checkpointNs = '', checkpoint_id: checkpointId, } = config.configurable ?? {};
+        if (!threadId) {
+            return undefined;
+        }
+        const configs = config.configurable?.configs;
+        if (!configs) {
+            Logger.error('Missing Matrix configs in configurable', {
+                threadId,
+                checkpointNs,
+                checkpointId,
+            });
+            return undefined;
+        }
+        const { matrix } = configs;
+        const storedCheckpoint = await this.getStoredCheckpoint(matrix.roomId, matrix.oracleDid, threadId, checkpointNs, checkpointId);
+        if (!storedCheckpoint) {
+            Logger.debug('Checkpoint not found', {
+                roomId: matrix.roomId,
+                threadId,
+                checkpointNs,
+                checkpointId: checkpointId || 'latest',
+            });
+            return undefined;
+        }
+        const checkpoint = (await this.serde.loadsTyped(storedCheckpoint.type, storedCheckpoint.checkpoint));
+        const metadata = (await this.serde.loadsTyped(storedCheckpoint.type, storedCheckpoint.metadata));
+        if (checkpoint.v < 4 && storedCheckpoint.parent_checkpoint_id != null) {
+            Logger.debug('Migrating v<4 checkpoint', {
+                threadId,
+                checkpointId: storedCheckpoint.checkpoint_id,
+                parentCheckpointId: storedCheckpoint.parent_checkpoint_id,
+            });
+            await this.migratePendingSends(checkpoint, matrix.roomId, matrix.oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns, storedCheckpoint.parent_checkpoint_id);
+        }
+        const storedWrites = await this.getStoredWrites(matrix.roomId, matrix.oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns, storedCheckpoint.checkpoint_id);
+        const pendingWrites = await Promise.all(storedWrites.map(async (write) => {
+            const value = await this.serde.loadsTyped(write.type, write.value);
+            return [write.task_id, write.channel, value];
+        }));
+        const finalConfig = {
+            configurable: {
+                thread_id: storedCheckpoint.thread_id,
+                checkpoint_ns: storedCheckpoint.checkpoint_ns,
+                checkpoint_id: storedCheckpoint.checkpoint_id,
+            },
+        };
+        const duration = Date.now() - startTime;
+        Logger.debug(`getTuple completed in ${duration}ms`, {
+            threadId,
+            checkpointId: storedCheckpoint.checkpoint_id,
+            writesCount: pendingWrites.length,
+        });
+        return {
+            config: finalConfig,
+            checkpoint,
+            metadata,
+            parentConfig: storedCheckpoint.parent_checkpoint_id
+                ? {
+                    configurable: {
+                        thread_id: storedCheckpoint.thread_id,
+                        checkpoint_ns: storedCheckpoint.checkpoint_ns,
+                        checkpoint_id: storedCheckpoint.parent_checkpoint_id,
+                    },
+                }
+                : undefined,
+            pendingWrites,
+        };
+    }
+    async *list(config, options) {
+        const startTime = Date.now();
+        const { thread_id: threadId, checkpoint_ns: checkpointNs = '' } = config.configurable ?? {};
+        if (!threadId) {
+            return;
+        }
+        const configs = config.configurable?.configs;
+        if (!configs) {
+            Logger.error('Missing Matrix configs in list', { threadId });
+            return;
+        }
+        const { matrix } = configs;
+        const { filter, before, limit } = options ?? {};
+        const threadMap = await this.getThreadMap(matrix.roomId, matrix.oracleDid);
+        const latestCheckpointId = threadMap[threadId];
+        if (!latestCheckpointId) {
+            Logger.debug('No checkpoints found for thread (empty thread map)', {
+                threadId,
+                checkpointNs,
+            });
+            return;
+        }
+        Logger.debug(`Listing checkpoints for thread ${threadId}`, {
+            threadId,
+            checkpointNs,
+            latestCheckpointId,
+        });
+        let currentId = latestCheckpointId;
+        let yieldedCount = 0;
+        while (currentId && (limit === undefined || yieldedCount < limit)) {
+            try {
+                if (before?.configurable?.checkpoint_id &&
+                    currentId >= before.configurable.checkpoint_id) {
+                    break;
+                }
+                const storedCheckpoint = await this.getStoredCheckpoint(matrix.roomId, matrix.oracleDid, threadId, checkpointNs, currentId);
+                if (!storedCheckpoint) {
+                    Logger.warn('Checkpoint in chain but not found in storage', {
+                        threadId,
+                        checkpointId: currentId,
+                    });
+                    break;
+                }
+                const checkpoint = (await this.serde.loadsTyped(storedCheckpoint.type, storedCheckpoint.checkpoint));
+                const metadata = (await this.serde.loadsTyped(storedCheckpoint.type, storedCheckpoint.metadata));
+                if (filter && Object.keys(filter).length > 0) {
+                    let matches = true;
+                    for (const [key, value] of Object.entries(filter)) {
+                        if (metadata[key] !== value) {
+                            matches = false;
+                            break;
+                        }
+                    }
+                    if (!matches) {
+                        currentId = storedCheckpoint.parent_checkpoint_id;
+                        continue;
+                    }
+                }
+                if (checkpoint.v < 4 && storedCheckpoint.parent_checkpoint_id != null) {
+                    await this.migratePendingSends(checkpoint, matrix.roomId, matrix.oracleDid, storedCheckpoint.thread_id, storedCheckpoint.checkpoint_ns, storedCheckpoint.parent_checkpoint_id);
+                }
+                yield {
+                    config: {
+                        configurable: {
+                            thread_id: storedCheckpoint.thread_id,
+                            checkpoint_ns: storedCheckpoint.checkpoint_ns,
+                            checkpoint_id: storedCheckpoint.checkpoint_id,
+                        },
+                    },
+                    checkpoint,
+                    metadata,
+                    parentConfig: storedCheckpoint.parent_checkpoint_id
+                        ? {
+                            configurable: {
+                                thread_id: storedCheckpoint.thread_id,
+                                checkpoint_ns: storedCheckpoint.checkpoint_ns,
+                                checkpoint_id: storedCheckpoint.parent_checkpoint_id,
+                            },
+                        }
+                        : undefined,
+                };
+                yieldedCount++;
+                currentId = storedCheckpoint.parent_checkpoint_id;
+            }
+            catch (error) {
+                Logger.warn('Skipping corrupted checkpoint in chain', {
+                    checkpointId: currentId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                break;
+            }
+        }
+        const duration = Date.now() - startTime;
+        Logger.debug(`list completed in ${duration}ms`, {
+            threadId,
+            yieldedCount,
+            cacheHits: this.metrics.hits,
+            cacheMisses: this.metrics.misses,
+        });
+    }
+    async put(config, checkpoint, metadata) {
+        const { thread_id: threadId, checkpoint_ns: checkpointNs = '', checkpoint_id: parentCheckpointId, } = config.configurable ?? {};
+        if (!threadId) {
+            throw new Error('Missing thread_id in config.configurable');
+        }
+        const configs = config.configurable?.configs;
+        if (!configs) {
+            throw new Error('Missing Matrix configs in configurable');
+        }
+        const { matrix } = configs;
+        const preparedCheckpoint = copyCheckpoint(checkpoint);
+        const [serializationType, serializedCheckpoint] = await this.serde.dumpsTyped(preparedCheckpoint);
+        const [, serializedMetadata] = await this.serde.dumpsTyped(metadata);
+        const storedCheckpoint = {
+            thread_id: threadId,
+            checkpoint_id: checkpoint.id,
+            checkpoint_ns: checkpointNs,
+            parent_checkpoint_id: parentCheckpointId,
+            type: serializationType,
+            checkpoint: new TextDecoder().decode(serializedCheckpoint),
+            metadata: new TextDecoder().decode(serializedMetadata),
+        };
+        await this.storeCheckpoint(matrix.roomId, matrix.oracleDid, storedCheckpoint);
+        return {
+            configurable: {
+                thread_id: threadId,
+                checkpoint_ns: checkpointNs,
+                checkpoint_id: checkpoint.id,
+            },
+        };
+    }
+    async putWrites(config, writes, taskId) {
+        const { thread_id: threadId, checkpoint_ns: checkpointNs = '', checkpoint_id: checkpointId, } = config.configurable ?? {};
+        if (!threadId || !checkpointId) {
+            Logger.error('Missing thread_id or checkpoint_id in putWrites', {
+                threadId,
+                checkpointId,
+            });
+            throw new Error('Missing thread_id or checkpoint_id in config.configurable');
+        }
+        const configs = config.configurable?.configs;
+        if (!configs) {
+            Logger.error('Missing Matrix configs in putWrites', {
+                threadId,
+                checkpointId,
+            });
+            throw new Error('Missing Matrix configs in configurable');
+        }
+        const { matrix } = configs;
+        const storedWrites = await Promise.all(writes.map(async ([channel, value], originalIdx) => {
+            const [type, serializedValue] = await this.serde.dumpsTyped(value);
+            const idx = WRITES_IDX_MAP[channel] ?? originalIdx;
+            return {
+                thread_id: threadId,
+                checkpoint_id: checkpointId,
+                checkpoint_ns: checkpointNs,
+                task_id: taskId,
+                idx,
+                channel,
+                type,
+                value: new TextDecoder().decode(serializedValue),
+            };
+        }));
+        await this.storeWrites(matrix.roomId, matrix.oracleDid, storedWrites);
+        Logger.debug(`putWrites completed`, {
+            threadId,
+            checkpointId,
+            taskId,
+            writesCount: storedWrites.length,
+        });
+    }
+    async deleteThread(threadId) {
+        Logger.info(`Deleting thread ${threadId}`);
+        const checkpointNs = '';
+        throw new Error(`deleteThread not fully implemented - requires roomId and oracleDid. ` +
+            `Thread ID: ${threadId}, namespace: ${checkpointNs}. ` +
+            `Consider implementing a version that accepts full config.`);
+    }
+    async deleteThreadWithContext(roomId, oracleDid, threadId, checkpointNs = '') {
+        Logger.info(`Deleting thread ${threadId} in room ${roomId}`, {
+            oracleDid,
+            checkpointNs,
+        });
+        try {
+            const threadMap = await this.getThreadMap(roomId, oracleDid);
+            const latestCheckpointId = threadMap[threadId];
+            if (!latestCheckpointId) {
+                Logger.debug(`Thread ${threadId} not found in thread map`);
+                return;
+            }
+            let currentId = latestCheckpointId;
+            let deletedCount = 0;
+            while (currentId) {
+                const checkpoint = await this.getStoredCheckpoint(roomId, oracleDid, threadId, checkpointNs, currentId);
+                if (!checkpoint)
+                    break;
+                const checkpointKey = this.getCheckpointKey(oracleDid, threadId, checkpointNs, currentId);
+                await this.stateManager.setState({
+                    roomId,
+                    stateKey: checkpointKey,
+                    data: null,
+                });
+                const writesKey = this.getWritesKey(oracleDid, threadId, checkpointNs, currentId);
+                await this.stateManager.setState({
+                    roomId,
+                    stateKey: writesKey,
+                    data: null,
+                });
+                deletedCount++;
+                currentId = checkpoint.parent_checkpoint_id;
+            }
+            delete threadMap[threadId];
+            const threadMapKey = this.getThreadMapKey(oracleDid);
+            await this.stateManager.setState({
+                roomId,
+                stateKey: threadMapKey,
+                data: threadMap,
+            });
+            const latestKey = this.getLatestCheckpointKey(oracleDid, threadId, checkpointNs);
+            await this.stateManager.setState({
+                roomId,
+                stateKey: latestKey,
+                data: null,
+            });
+            const threadPattern = `${roomId}:${oracleDid}:${threadId}:${checkpointNs}`;
+            this.checkpointCache.deletePattern(threadPattern);
+            this.writesCache.deletePattern(threadPattern);
+            this.latestCache.deletePattern(threadPattern);
+            const cacheKey = `thread_map:${roomId}:${oracleDid}`;
+            this.indexCache.delete(cacheKey);
+            Logger.info(`Deleted thread ${threadId}`, {
+                roomId,
+                deletedCheckpoints: deletedCount,
+            });
+        }
+        catch (error) {
+            Logger.error(`Failed to delete thread ${threadId}`, error);
+            throw error;
+        }
+    }
+    async rebuildThreadMap(roomId, oracleDid) {
+        Logger.warn(`Manual thread map rebuild requested for room ${roomId}`, {
+            oracleDid,
+        });
+        try {
+            const stateEvents = await this.stateManager.listStateEvents(roomId);
+            const threadMap = {};
+            let processedCount = 0;
+            for (const event of stateEvents) {
+                if (event &&
+                    'thread_id' in event &&
+                    'checkpoint_id' in event &&
+                    'checkpoint_ns' in event &&
+                    event.checkpoint_ns === '') {
+                    const threadId = event.thread_id;
+                    const checkpointId = event.checkpoint_id;
+                    if (!threadMap[threadId] || checkpointId > threadMap[threadId]) {
+                        threadMap[threadId] = checkpointId;
+                    }
+                    processedCount++;
+                }
+            }
+            const threadMapKey = this.getThreadMapKey(oracleDid);
+            await this.stateManager.setState({
+                roomId,
+                stateKey: threadMapKey,
+                data: threadMap,
+            });
+            const cacheKey = `thread_map:${roomId}:${oracleDid}`;
+            this.indexCache.set(cacheKey, threadMap);
+            Logger.info(`Successfully rebuilt thread map: ${Object.keys(threadMap).length} threads, ${processedCount} checkpoints processed`, {
+                roomId,
+                oracleDid,
+                threadCount: Object.keys(threadMap).length,
+                processedCheckpoints: processedCount,
+            });
+        }
+        catch (error) {
+            Logger.error(`Failed to rebuild thread map for room ${roomId}`, error);
+            throw error;
+        }
+    }
+    async end() {
+        Logger.debug('end() called (no-op)');
+    }
+    getCacheMetrics() {
+        return { ...this.metrics };
+    }
+    getFilteringMetrics() {
+        const avgEventsPerRebuild = this.metrics.indexRebuilds > 0
+            ? this.metrics.filteredEvents / this.metrics.indexRebuilds
+            : 0;
+        return {
+            filteredEvents: this.metrics.filteredEvents,
+            duplicateEvents: this.metrics.duplicateEvents,
+            indexRebuilds: this.metrics.indexRebuilds,
+            avgEventsPerRebuild: Math.round(avgEventsPerRebuild),
+        };
+    }
+}
+//# sourceMappingURL=checkpointer.js.map