@robota-sdk/sessions/dist/index.d.ts

Session and chat management for Robota SDK - multi-session support with independent workspaces

import { UniversalMessage, Context, Robota, ConversationHistory, UniversalMessageRole } from '@robota-sdk/core';
export * from '@robota-sdk/core';
export { AIProvider, Context, ModelResponse, StreamingResponseChunk } from '@robota-sdk/core';

declare enum SessionState$1 {
    ACTIVE = "active",
    PAUSED = "paused",
    TERMINATED = "terminated"
}
interface SessionConfig$1 {
    name?: string;
    maxChats?: number;
}
interface SessionInfo {
    id: string;
    userId: string;
    name: string;
    state: SessionState$1;
    chatCount: number;
    activeChatId?: string;
    createdAt: Date;
    lastUsedAt: Date;
}
interface ChatConfig$1 {
    name?: string;
    robotaConfig?: any;
}
interface ChatInfo {
    id: string;
    sessionId: string;
    name: string;
    isActive: boolean;
    messageCount: number;
    createdAt: Date;
    lastUsedAt: Date;
}
interface SessionManagerConfig$1 {
    maxSessions?: number;
    autoCleanupDays?: number;
}

interface ConversationHistoryInterface {
    addMessage(message: UniversalMessage): void;
    getMessages(): UniversalMessage[];
    getMessageCount(): number;
    clear(): void;
    getLastMessage(): UniversalMessage | null;
    getLastUserMessage(): UniversalMessage | null;
    getLastAssistantMessage(): UniversalMessage | null;
}
interface ConversationHistoryOptions {
    maxMessages?: number;
    enableMetadata?: boolean;
    enableTimestamps?: boolean;
}

interface ProviderConfig {
    name: string;
    apiKey?: string;
    baseUrl?: string;
    timeout?: number;
    retries?: number;
}
interface ProviderManager {
    addProvider(name: string, provider: any): void;
    getProvider(name: string): any | null;
    removeProvider(name: string): boolean;
    listProviders(): string[];
    setDefaultProvider(name: string): void;
    getDefaultProvider(): string | null;
}

interface ContextManager {
    getContext(): Context;
    updateContext(context: Partial<Context>): void;
    clearContext(): void;
    addSystemMessage(content: string): void;
    getSystemMessages(): any[];
}

declare class SimpleConversationHistory implements ConversationHistoryInterface {
    private messages;
    private maxMessages?;
    constructor(maxMessages?: number);
    addMessage(message: UniversalMessage): void;
    getMessages(): UniversalMessage[];
    getMessageCount(): number;
    clear(): void;
    getLastMessage(): UniversalMessage | null;
    getLastUserMessage(): UniversalMessage | null;
    getLastAssistantMessage(): UniversalMessage | null;
}

interface Logger {
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
}
declare class SimpleLoggerImpl implements Logger {
    private prefix;
    constructor(prefix?: string);
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
}

interface MetricsCollector {
    incrementCounter(name: string, value?: number): void;
    recordGauge(name: string, value: number): void;
    recordHistogram(name: string, value: number): void;
    getMetrics(): Record<string, any>;
    reset(): void;
}
declare class SimpleMetricsCollector implements MetricsCollector {
    private counters;
    private gauges;
    private histograms;
    incrementCounter(name: string, value?: number): void;
    recordGauge(name: string, value: number): void;
    recordHistogram(name: string, value: number): void;
    getMetrics(): Record<string, any>;
    reset(): void;
}

interface PromptTemplate {
    render(variables: Record<string, any>): string;
    getVariables(): string[];
}
declare class SimplePromptTemplate implements PromptTemplate {
    private template;
    private variables;
    constructor(template: string);
    render(variables: Record<string, any>): string;
    getVariables(): string[];
    private extractVariables;
    static create(template: string): SimplePromptTemplate;
}

interface ConfigurationChange {
    id: string;
    timestamp: Date;
    type: 'provider' | 'model' | 'system' | 'function' | 'other';
    description: string;
    oldValue?: any;
    newValue: any;
    userId?: string;
}
type MessageContent = string | {
    text?: string;
    image?: string;
    file?: string;
    [key: string]: any;
};
interface ChatConfig {
    chatName?: string;
    description?: string;
    robotaConfig?: any;
    autoSave?: boolean;
    maxHistorySize?: number;
}
interface ChatMetadata {
    chatId: string;
    sessionId: string;
    chatName: string;
    description?: string;
    createdAt: Date;
    updatedAt: Date;
    lastAccessedAt: Date;
    messageCount: number;
    isActive: boolean;
}
interface EnhancedConversationHistory extends ConversationHistory {
    configurations: ConfigurationChange[];
    addConfigurationChange(change: ConfigurationChange): void;
    getConfigurationHistory(): ConfigurationChange[];
    clearConfigurationHistory(): void;
    updateMessage(index: number, content: string): boolean;
    removeMessage(index: number): boolean;
    getConfigurationChangeCount(): number;
    export(): string;
    import(data: string): void;
    getMemoryUsage(): number;
}
interface ChatInstance {
    readonly metadata: ChatMetadata;
    readonly config: ChatConfig;
    readonly robota: Robota;
    readonly history: EnhancedConversationHistory;
    sendMessage(content: MessageContent): Promise<string>;
    regenerateResponse(): Promise<string>;
    editMessage(messageId: string, newContent: MessageContent): Promise<void>;
    deleteMessage(messageId: string): Promise<void>;
    updateRobotaConfig(config: any): Promise<void>;
    getRobotaConfig(): any;
    activate(): void;
    deactivate(): void;
    clearHistory(): void;
    exportHistory(): Promise<string>;
    importHistory(data: string): Promise<void>;
    save(): Promise<void>;
    load(): Promise<void>;
    getStats(): ChatStats;
    updateConfig(config: Partial<ChatConfig>): void;
}
interface ChatStats {
    messageCount: number;
    configurationChanges: number;
    memoryUsage: number;
    createdAt: Date;
    lastActivity: Date;
    totalTokens?: number;
    averageResponseTime?: number;
}

declare enum SessionState {
    ACTIVE = "active",
    PAUSED = "paused",
    ARCHIVED = "archived",
    TERMINATED = "terminated"
}
interface SessionConfig {
    sessionName?: string;
    description?: string;
    autoSave?: boolean;
    saveInterval?: number;
    maxChats?: number;
    retentionPeriod?: number;
}
interface SessionMetadata {
    sessionId: string;
    userId: string;
    sessionName: string;
    description?: string;
    createdAt: Date;
    updatedAt: Date;
    lastAccessedAt: Date;
    state: SessionState;
    chatCount: number;
    activeChatId?: string;
}
interface Session {
    readonly metadata: SessionMetadata;
    readonly config: SessionConfig;
    createNewChat(config?: ChatConfig): Promise<ChatInstance>;
    getChat(chatId: string): ChatInstance | undefined;
    getAllChats(): ChatInstance[];
    switchToChat(chatId: string): Promise<void>;
    removeChat(chatId: string): Promise<void>;
    getActiveChat(): ChatInstance | undefined;
    pause(): Promise<void>;
    resume(): Promise<void>;
    archive(): Promise<void>;
    terminate(): Promise<void>;
    save(): Promise<void>;
    load(): Promise<void>;
    getState(): SessionState;
    updateConfig(config: Partial<SessionConfig>): void;
    getStats(): SessionStats;
}
interface SessionStats {
    chatCount: number;
    totalMessages: number;
    memoryUsage: number;
    diskUsage: number;
    createdAt: Date;
    lastActivity: Date;
    uptime: number;
}

interface SessionManagerConfig {
    maxActiveSessions?: number;
    autoCleanup?: boolean;
    cleanupInterval?: number;
    memoryThreshold?: number;
    storage?: any;
}
interface SessionManager {
    createSession(userId: string, config?: SessionConfig): Promise<Session>;
    getSession(sessionId: string): Session | undefined;
    getUserSessions(userId: string): Session[];
    removeSession(sessionId: string): Promise<void>;
    pauseSession(sessionId: string): Promise<void>;
    resumeSession(sessionId: string): Promise<void>;
    archiveSession(sessionId: string): Promise<void>;
    getActiveSessionCount(): number;
    cleanup(): Promise<void>;
    shutdown(): Promise<void>;
}
interface SessionManagerStats {
    totalSessions: number;
    activeSessions: number;
    pausedSessions: number;
    archivedSessions: number;
    memoryUsage: number;
}

declare class SessionManagerImpl implements SessionManager {
    private sessions;
    private userSessions;
    private config;
    constructor(config?: SessionManagerConfig);
    createSession(userId: string, config?: SessionConfig): Promise<Session>;
    getSession(sessionId: string): Session | undefined;
    getUserSessions(userId: string): Session[];
    removeSession(sessionId: string): Promise<void>;
    pauseSession(sessionId: string): Promise<void>;
    resumeSession(sessionId: string): Promise<void>;
    archiveSession(sessionId: string): Promise<void>;
    getActiveSessionCount(): number;
    cleanup(): Promise<void>;
    shutdown(): Promise<void>;
    getStats(): SessionManagerStats;
}

interface SessionStore {
    save(session: SessionInfo): Promise<void>;
    load(sessionId: string): Promise<SessionInfo | null>;
    delete(sessionId: string): Promise<boolean>;
    list(userId?: string): Promise<SessionInfo[]>;
    exists(sessionId: string): Promise<boolean>;
    clear(): Promise<void>;
}
declare class BasicSessionStore implements SessionStore {
    private sessions;
    save(session: SessionInfo): Promise<void>;
    load(sessionId: string): Promise<SessionInfo | null>;
    delete(sessionId: string): Promise<boolean>;
    list(userId?: string): Promise<SessionInfo[]>;
    exists(sessionId: string): Promise<boolean>;
    clear(): Promise<void>;
    size(): number;
    getAllSessions(): SessionInfo[];
}

interface SystemMessageManager {
    setSystemPrompt(prompt: string): void;
    addSystemMessage(content: string): void;
    getSystemMessages(): UniversalMessage[];
    clearSystemMessages(): void;
    hasSystemMessages(): boolean;
}
declare class SystemMessageManagerImpl implements SystemMessageManager {
    private systemMessages;
    setSystemPrompt(prompt: string): void;
    addSystemMessage(content: string): void;
    getSystemMessages(): UniversalMessage[];
    clearSystemMessages(): void;
    hasSystemMessages(): boolean;
}

interface IMultiProviderAdapterManager {
    addProvider(name: string, provider: any): void;
    getProvider(name: string): any | null;
    setDefaultProvider(name: string): void;
    getDefaultProvider(): string | null;
}
declare class MultiProviderAdapterManager implements IMultiProviderAdapterManager {
    private providers;
    private defaultProvider;
    addProvider(name: string, provider: any): void;
    getProvider(name: string): any | null;
    setDefaultProvider(name: string): void;
    getDefaultProvider(): string | null;
}

interface ConversationService {
    addMessage(message: UniversalMessage): void;
    getMessages(): UniversalMessage[];
    getConversationSummary(): string;
    clearConversation(): void;
}
declare class ConversationServiceImpl implements ConversationService {
    private conversationHistory;
    constructor(maxMessages?: number);
    addMessage(message: UniversalMessage): void;
    getMessages(): UniversalMessage[];
    getConversationSummary(): string;
    clearConversation(): void;
}

declare class LoggerFactory {
    private static instances;
    static getLogger(name: string): Logger;
    static createLogger(name: string): Logger;
    static clearCache(): void;
}

declare class MetricsCollectorFactory {
    private static instances;
    static getCollector(name: string): MetricsCollector;
    static createCollector(): MetricsCollector;
    static clearCache(): void;
    static getAllMetrics(): Record<string, any>;
}

declare class EnhancedConversationHistoryImpl implements EnhancedConversationHistory {
    private messages;
    configurations: ConfigurationChange[];
    private maxHistorySize;
    constructor(maxHistorySize?: number);
    addMessage(message: UniversalMessage): void;
    addUserMessage(content: string, metadata?: Record<string, any>): void;
    addAssistantMessage(content: string, toolCalls?: {
        id: string;
        type: "function";
        function: {
            name: string;
            arguments: string;
        };
    }[], metadata?: Record<string, any>): void;
    addSystemMessage(content: string, metadata?: Record<string, any>): void;
    addToolMessage(toolCallId: string, content: string, toolName: string, metadata?: Record<string, any>): void;
    addToolMessageWithId(content: string, toolCallId: string, toolName: string, metadata?: Record<string, any>): void;
    getMessages(): UniversalMessage[];
    getMessagesByRole(role: UniversalMessageRole): UniversalMessage[];
    getRecentMessages(count: number): UniversalMessage[];
    clear(): void;
    getMessageCount(): number;
    addConfigurationChange(change: ConfigurationChange): void;
    getConfigurationHistory(): ConfigurationChange[];
    clearConfigurationHistory(): void;
    updateMessage(index: number, content: string): boolean;
    removeMessage(index: number): boolean;
    getConfigurationChangeCount(): number;
    export(): string;
    import(data: string): void;
    getMemoryUsage(): number;
    private _enforceMaxSize;
}

/**
 * Improved Session Implementation
 *
 * Uses state machine pattern and pure functions for better maintainability
 */
declare class SessionImpl implements Session {
    readonly metadata: SessionMetadata;
    readonly config: SessionConfig;
    private readonly _chats;
    private _activeChatId?;
    private readonly _startTime;
    constructor(userId: string, config?: SessionConfig);
    createNewChat(config?: ChatConfig): Promise<ChatInstance>;
    getChat(chatId: string): ChatInstance | undefined;
    getAllChats(): ChatInstance[];
    switchToChat(chatId: string): Promise<void>;
    removeChat(chatId: string): Promise<void>;
    getActiveChat(): ChatInstance | undefined;
    pause(): Promise<void>;
    resume(): Promise<void>;
    archive(): Promise<void>;
    terminate(): Promise<void>;
    save(): Promise<void>;
    load(): Promise<void>;
    getState(): SessionState;
    updateConfig(config: Partial<SessionConfig>): void;
    getStats(): SessionStats;
    private _updateLastAccessed;
    private _transitionState;
    private _setActiveChat;
    private _deactivateAllChats;
    private _ensureOperationAllowed;
}

declare class ChatInstanceImpl implements ChatInstance {
    readonly metadata: ChatMetadata;
    readonly config: ChatConfig;
    readonly robota: Robota;
    private _isActive;
    private _startTime;
    constructor(sessionId: string, config?: ChatConfig, robotaConfig?: any);
    sendMessage(content: MessageContent): Promise<string>;
    activate(): void;
    deactivate(): void;
    clearHistory(): void;
    updateRobotaConfig(config: any): Promise<void>;
    getRobotaConfig(): any;
    regenerateResponse(): Promise<string>;
    editMessage(messageId: string, newContent: MessageContent): Promise<void>;
    deleteMessage(messageId: string): Promise<void>;
    exportHistory(): Promise<string>;
    importHistory(data: string): Promise<void>;
    save(): Promise<void>;
    load(): Promise<void>;
    getStats(): ChatStats;
    updateConfig(config: Partial<ChatConfig>): void;
    private _updateLastAccessed;
    get history(): any;
}

/**
 * Session State Machine
 *
 * @module SessionStateMachine
 * @description
 * Pure functions for managing session state transitions.
 * Uses state machine pattern to ensure valid state transitions.
 */

/**
 * State transition definition
 */
interface StateTransition {
    from: SessionState;
    to: SessionState;
    action: string;
    condition?: (context: any) => boolean;
}
/**
 * State transition result
 */
interface TransitionResult {
    success: boolean;
    newState?: SessionState;
    error?: string;
}
/**
 * Check if a state transition is valid
 *
 * @param currentState - Current session state
 * @param targetState - Target session state
 * @param action - Action being performed
 * @param context - Optional context for condition checking
 * @returns True if transition is valid
 */
declare function isValidTransition(currentState: SessionState, targetState: SessionState, action: string, context?: any): boolean;
/**
 * Attempt to transition to a new state
 *
 * @param currentState - Current session state
 * @param targetState - Target session state
 * @param action - Action being performed
 * @param context - Optional context for condition checking
 * @returns Transition result
 */
declare function attemptTransition(currentState: SessionState, targetState: SessionState, action: string, context?: any): TransitionResult;
/**
 * Get all possible next states from current state
 *
 * @param currentState - Current session state
 * @returns Array of possible next states with their actions
 */
declare function getPossibleTransitions(currentState: SessionState): Array<{
    state: SessionState;
    action: string;
}>;
/**
 * Check if a state is a final state (no transitions possible)
 *
 * @param state - State to check
 * @returns True if state is final
 */
declare function isFinalState(state: SessionState): boolean;
/**
 * Check if a state allows active operations
 *
 * @param state - State to check
 * @returns True if state allows active operations
 */
declare function isActiveState(state: SessionState): boolean;
/**
 * Check if a state allows modifications
 *
 * @param state - State to check
 * @returns True if state allows modifications
 */
declare function allowsModifications(state: SessionState): boolean;
/**
 * Get human-readable state description
 *
 * @param state - Session state
 * @returns Human-readable description
 */
declare function getStateDescription(state: SessionState): string;
/**
 * Validate state transition chain
 *
 * @param transitions - Array of state transitions to validate
 * @returns Validation result with any errors
 */
declare function validateTransitionChain(transitions: Array<{
    from: SessionState;
    to: SessionState;
    action: string;
}>): {
    valid: boolean;
    errors: string[];
};

/**
 * Error Messages Constants
 *
 * @module ErrorMessages
 * @description
 * Centralized error messages for consistent error handling.
 * Supports internationalization and message formatting.
 */

/**
 * Session error message keys
 */
declare enum SessionErrorKey {
    MAX_CHATS_REACHED = "MAX_CHATS_REACHED",
    CHAT_NOT_FOUND = "CHAT_NOT_FOUND",
    INVALID_STATE_TRANSITION = "INVALID_STATE_TRANSITION",
    OPERATION_NOT_ALLOWED = "OPERATION_NOT_ALLOWED",
    SESSION_TERMINATED = "SESSION_TERMINATED",
    INVALID_CONFIG = "INVALID_CONFIG",
    SAVE_FAILED = "SAVE_FAILED",
    LOAD_FAILED = "LOAD_FAILED"
}
/**
 * Get formatted error message
 *
 * @param key - Error message key
 * @param params - Message parameters for substitution
 * @returns Formatted error message
 */
declare function getErrorMessage(key: SessionErrorKey, params?: Record<string, any>): string;
/**
 * Create session error with formatted message
 *
 * @param key - Error message key
 * @param params - Message parameters
 * @returns Error instance
 */
declare function createSessionError(key: SessionErrorKey, params?: Record<string, any>): Error;
/**
 * Session operation error class
 */
declare class SessionOperationError extends Error {
    readonly code: SessionErrorKey;
    readonly context: Record<string, any>;
    constructor(code: SessionErrorKey, context?: Record<string, any>);
}
/**
 * State transition error class
 */
declare class StateTransitionError extends SessionOperationError {
    readonly currentState: SessionState;
    readonly targetState: SessionState;
    readonly action: string;
    constructor(currentState: SessionState, targetState: SessionState, action: string);
}
/**
 * Validation error utilities
 */
declare class ValidationError extends Error {
    readonly field: string;
    readonly value: any;
    readonly constraint: string;
    constructor(field: string, value: any, constraint: string);
}
/**
 * Common validation constraints
 */
declare const ValidationConstraints: {
    readonly required: (field: string) => string;
    readonly minLength: (field: string, min: number) => string;
    readonly maxLength: (field: string, max: number) => string;
    readonly positive: (field: string) => string;
    readonly range: (field: string, min: number, max: number) => string;
};

declare function generateId(): string;

/**
 * Session Utilities
 *
 * @module SessionUtils
 * @description
 * Pure utility functions for session operations.
 * These functions are stateless and reusable.
 */

/**
 * Internal default configuration type with all required fields
 */
interface DefaultSessionConfig {
    sessionName: string;
    description?: string;
    autoSave: boolean;
    saveInterval: number;
    maxChats: number;
    retentionPeriod: number;
}
/**
 * Default session configuration
 */
declare const DEFAULT_SESSION_CONFIG: DefaultSessionConfig;
/**
 * Generate default session name based on timestamp
 *
 * @param timestamp - Optional timestamp (defaults to current time)
 * @returns Generated session name
 */
declare function generateDefaultSessionName(timestamp?: Date): string;
/**
 * Validate session configuration
 *
 * @param config - Configuration to validate
 * @returns Validation result
 */
declare function validateSessionConfig(config: SessionConfig): {
    valid: boolean;
    errors: ValidationError[];
};
/**
 * Merge session configuration with defaults
 *
 * @param config - User provided configuration
 * @returns Merged configuration with all required fields
 */
declare function mergeWithDefaults(config: SessionConfig): DefaultSessionConfig;
/**
 * Create initial session metadata
 *
 * @param sessionId - Unique session ID
 * @param userId - User ID
 * @param config - Session configuration
 * @returns Initial metadata
 */
declare function createInitialMetadata(sessionId: string, userId: string, config: DefaultSessionConfig): SessionMetadata;
/**
 * Update metadata timestamps
 *
 * @param metadata - Current metadata
 * @returns Updated metadata with new timestamps
 */
declare function updateTimestamps(metadata: SessionMetadata): SessionMetadata;
/**
 * Calculate session statistics
 *
 * @param metadata - Session metadata
 * @param chats - All chat instances
 * @param startTime - Session start time
 * @returns Calculated statistics
 */
declare function calculateSessionStats(metadata: SessionMetadata, chats: ChatInstance[], startTime: Date): SessionStats;
/**
 * Find next active chat when current one is removed
 *
 * @param chats - Map of chat instances
 * @param removedChatId - ID of chat being removed
 * @param currentActiveChatId - Current active chat ID
 * @returns ID of next chat to activate, or undefined if none
 */
declare function findNextActiveChat(chats: Map<string, ChatInstance>, removedChatId: string, currentActiveChatId?: string): string | undefined;
/**
 * Check if chat limit would be exceeded
 *
 * @param currentCount - Current number of chats
 * @param maxChats - Maximum allowed chats
 * @returns True if limit would be exceeded
 */
declare function wouldExceedChatLimit(currentCount: number, maxChats: number): boolean;
/**
 * Format uptime duration in human-readable format
 *
 * @param uptimeMs - Uptime in milliseconds
 * @returns Formatted duration string
 */
declare function formatUptime(uptimeMs: number): string;
/**
 * Check if session is in a modifiable state
 *
 * @param state - Current session state
 * @returns True if session allows modifications
 */
declare function isSessionModifiable(state: SessionState): boolean;
/**
 * Check if session is active and ready for operations
 *
 * @param state - Current session state
 * @returns True if session is active
 */
declare function isSessionActive(state: SessionState): boolean;

export { BasicSessionStore, type ChatConfig$1 as ChatConfig, type ChatInfo, type ChatInstance, ChatInstanceImpl, type ChatMetadata, type ChatStats, type ContextManager, SimpleConversationHistory as ConversationHistory, type ConversationHistoryInterface, type ConversationHistoryOptions, ConversationServiceImpl, DEFAULT_SESSION_CONFIG, EnhancedConversationHistoryImpl, LoggerFactory, type MessageContent, MetricsCollectorFactory, MultiProviderAdapterManager, type ProviderConfig, type ProviderManager, type Session, type SessionConfig$1 as SessionConfig, SessionErrorKey, SessionImpl, type SessionInfo, type SessionManager, type SessionManagerConfig$1 as SessionManagerConfig, SessionManagerImpl, type SessionManagerStats, type SessionMetadata, SessionOperationError, SessionState$1 as SessionState, type SessionStats, SimpleConversationHistory, SimpleLoggerImpl, SimpleMetricsCollector, SimplePromptTemplate, type StateTransition, StateTransitionError, SystemMessageManagerImpl, type TransitionResult, ValidationConstraints, ValidationError, allowsModifications, attemptTransition, calculateSessionStats, createInitialMetadata, createSessionError, findNextActiveChat, formatUptime, generateDefaultSessionName, generateId, getErrorMessage, getPossibleTransitions, getStateDescription, isActiveState, isFinalState, isSessionActive, isSessionModifiable, isValidTransition, mergeWithDefaults, updateTimestamps, validateSessionConfig, validateTransitionChain, wouldExceedChatLimit };