contextual-agent-sdk/dist/storage/MemoryStorageProvider.js

SDK for building AI agents with seamless voice-text context switching

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MemoryStorageProvider = void 0;
class MemoryStorageProvider {
    sessions = new Map();
    eventHandlers = new Set();
    cleanupTimer;
    constructor(config) {
        if (config?.cleanupInterval && config?.maxAge) {
            this.cleanupTimer = setInterval(() => {
                this.cleanup(config.maxAge).catch(error => {
                    this.emitEvent({ type: 'error', error });
                });
            }, config.cleanupInterval);
        }
    }
    async createSession(sessionId, session) {
        this.sessions.set(sessionId, {
            ...session,
            startTime: new Date(session.startTime),
            lastActivity: new Date(session.lastActivity)
        });
        this.emitEvent({ type: 'session_created', sessionId });
    }
    async getSession(sessionId) {
        const session = this.sessions.get(sessionId);
        if (!session)
            return null;
        return this.cloneSession(session);
    }
    async updateSession(sessionId, session) {
        this.sessions.set(sessionId, {
            ...session,
            startTime: new Date(session.startTime),
            lastActivity: new Date(session.lastActivity)
        });
        this.emitEvent({ type: 'session_updated', sessionId });
    }
    async deleteSession(sessionId) {
        const deleted = this.sessions.delete(sessionId);
        if (deleted) {
            this.emitEvent({ type: 'session_deleted', sessionId });
        }
        return deleted;
    }
    async getSessions(filter) {
        let sessions = Array.from(this.sessions.values())
            .map(session => this.cloneSession(session));
        if (filter) {
            sessions = sessions.filter(session => {
                if (filter.userId && session.userId !== filter.userId)
                    return false;
                if (filter.modality && session.currentModality !== filter.modality)
                    return false;
                const startTime = session.startTime.getTime();
                if (filter.startTime?.from && startTime < filter.startTime.from.getTime())
                    return false;
                if (filter.startTime?.to && startTime > filter.startTime.to.getTime())
                    return false;
                const lastActivity = session.lastActivity.getTime();
                if (filter.lastActivity?.from && lastActivity < filter.lastActivity.from.getTime())
                    return false;
                if (filter.lastActivity?.to && lastActivity > filter.lastActivity.to.getTime())
                    return false;
                return true;
            });
        }
        return sessions;
    }
    async deleteSessions(filter) {
        const sessionsToDelete = await this.getSessions(filter);
        let deleted = 0;
        for (const session of sessionsToDelete) {
            const success = await this.deleteSession(session.sessionId);
            if (success)
                deleted++;
        }
        return deleted;
    }
    async cleanup(maxAge) {
        this.emitEvent({ type: 'cleanup_started' });
        const now = Date.now();
        let deleted = 0;
        for (const [sessionId, session] of this.sessions.entries()) {
            const age = now - session.lastActivity.getTime();
            if (age > maxAge) {
                const success = await this.deleteSession(sessionId);
                if (success)
                    deleted++;
            }
        }
        this.emitEvent({ type: 'cleanup_completed', deletedCount: deleted });
    }
    async healthCheck() {
        return true;
    }
    async getStats() {
        const now = Date.now();
        const oneDayAgo = now - 24 * 60 * 60 * 1000;
        const sessions = Array.from(this.sessions.values());
        const activeSessions = sessions.filter(s => s.lastActivity.getTime() > oneDayAgo);
        const durations = sessions.map(s => s.lastActivity.getTime() - s.startTime.getTime());
        const avgDuration = durations.length > 0
            ? durations.reduce((a, b) => a + b, 0) / durations.length
            : 0;
        const modalityCount = sessions.reduce((acc, s) => {
            acc[s.currentModality]++;
            return acc;
        }, { text: 0, voice: 0 });
        const storageSize = sessions.reduce((size, session) => {
            return size + JSON.stringify(session).length;
        }, 0);
        return {
            totalSessions: sessions.length,
            activeSessionsLast24h: activeSessions.length,
            averageSessionDuration: avgDuration,
            modalityDistribution: modalityCount,
            storageSize
        };
    }
    on(handler) {
        this.eventHandlers.add(handler);
    }
    off(handler) {
        this.eventHandlers.delete(handler);
    }
    emitEvent(event) {
        this.eventHandlers.forEach(handler => handler(event));
    }
    cloneSession(session) {
        return {
            ...session,
            startTime: new Date(session.startTime),
            lastActivity: new Date(session.lastActivity),
            context: {
                ...session.context,
                memoryBank: session.context.memoryBank.map(memory => ({
                    ...memory,
                    timestamp: new Date(memory.timestamp)
                }))
            }
        };
    }
    async shutdown() {
        if (this.cleanupTimer) {
            clearInterval(this.cleanupTimer);
        }
        this.sessions.clear();
    }
}
exports.MemoryStorageProvider = MemoryStorageProvider;
//# sourceMappingURL=MemoryStorageProvider.js.map