recallrai/dist/models/session.js

Official Node.js SDK for RecallrAI - Revolutionary contextual memory system that enables AI assistants to form meaningful connections between conversations, just like human memory.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Context = exports.SessionList = exports.Session = exports.Message = exports.SessionStatus = exports.MessageRole = void 0;
const schemas_1 = require("./schemas");
/**
 * Message role in a conversation.
 */
var MessageRole;
(function (MessageRole) {
    MessageRole["USER"] = "user";
    MessageRole["ASSISTANT"] = "assistant";
})(MessageRole || (exports.MessageRole = MessageRole = {}));
/**
 * Status of a session.
 */
var SessionStatus;
(function (SessionStatus) {
    SessionStatus["PENDING"] = "pending";
    SessionStatus["PROCESSING"] = "processing";
    SessionStatus["PROCESSED"] = "processed";
})(SessionStatus || (exports.SessionStatus = SessionStatus = {}));
/**
 * Represents a message in a conversation session.
 */
class Message {
    /**
     * Creates a new Message instance
     *
     * @param data - Message data
     */
    constructor(data) {
        const parsedData = {
            ...data,
            // Convert string role to enum if needed
            role: typeof data.role === 'string' ?
                (data.role === 'user' ? MessageRole.USER : MessageRole.ASSISTANT) : data.role,
            timestamp: data.timestamp instanceof Date ?
                data.timestamp : new Date(data.timestamp)
        };
        const validated = schemas_1.messageSchema.parse(parsedData);
        this.role = validated.role;
        this.content = validated.content;
        this.timestamp = validated.timestamp;
    }
}
exports.Message = Message;
/**
 * Represents a conversation session.
 */
class Session {
    /**
     * Creates a new Session instance
     *
     * @param data - Session data
     */
    constructor(data) {
        const parsedData = {
            ...data,
            // Convert string status to enum if needed
            status: typeof data.status === 'string' ?
                this.mapStatusStringToEnum(data.status) : data.status,
            createdAt: data.createdAt instanceof Date ?
                data.createdAt : new Date(data.createdAt)
        };
        const validated = schemas_1.sessionSchema.parse(parsedData);
        this.sessionId = validated.sessionId;
        this.status = validated.status;
        this.createdAt = validated.createdAt;
    }
    mapStatusStringToEnum(status) {
        switch (status) {
            case 'pending': return SessionStatus.PENDING;
            case 'processing': return SessionStatus.PROCESSING;
            case 'processed': return SessionStatus.PROCESSED;
            default: return SessionStatus.PENDING;
        }
    }
    /**
     * Create a Session instance from an API response
     *
     * @param data - API response data
     * @returns A Session instance
     */
    static fromApiResponse(data) {
        return new Session({
            sessionId: data.session_id,
            status: data.status,
            createdAt: data.created_at,
        });
    }
}
exports.Session = Session;
/**
 * Represents a paginated list of sessions.
 */
class SessionList {
    /**
     * Creates a new SessionList instance
     *
     * @param data - Session list data
     */
    constructor(data) {
        // We'll validate separately to avoid type issues
        const { total, hasMore } = schemas_1.sessionListSchema.parse(data);
        this.sessions = data.sessions;
        this.total = total;
        this.hasMore = hasMore;
    }
    /**
     * Create a SessionList instance from an API response
     *
     * @param data - API response data
     * @returns A SessionList instance
     */
    static fromApiResponse(data) {
        return new SessionList({
            sessions: data.sessions.map((session) => Session.fromApiResponse(session)),
            total: data.total,
            hasMore: data.has_more,
        });
    }
}
exports.SessionList = SessionList;
/**
 * Represents the context for a session.
 */
class Context {
    /**
     * Creates a new Context instance
     *
     * @param data - Context data
     */
    constructor(data) {
        const validated = schemas_1.contextSchema.parse(data);
        this.memoryUsed = validated.memoryUsed;
        this.context = validated.context;
    }
    /**
     * Create a Context instance from an API response
     *
     * @param data - API response data
     * @returns A Context instance
     */
    static fromApiResponse(data) {
        return new Context({
            memoryUsed: data.memory_used,
            context: data.context,
        });
    }
}
exports.Context = Context;