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

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

import { AgentConfig, Robota, Message, AgentFactory, AgentTemplate } from '@robota-sdk/agents';
export { AgentConfig, AgentInterface, ConversationHistory, ConversationSession, Message, RunOptions } from '@robota-sdk/agents';

/**
 * Simple message content type
 */
type MessageContent = string;
/**
 * Chat configuration interface - simplified
 */
interface ChatConfig {
    chatName?: string;
    description?: string;
    robotaConfig: AgentConfig;
    agentTemplate?: string;
}
/**
 * Chat metadata interface - simplified
 */
interface ChatMetadata {
    chatId: string;
    sessionId: string;
    chatName: string;
    description?: string;
    createdAt: Date;
    updatedAt: Date;
    lastAccessedAt: Date;
    messageCount: number;
    isActive: boolean;
}
/**
 * Template manager interface for agent templates
 */
interface TemplateManager {
    getTemplate(name: string): AgentConfig | undefined;
    listTemplates(): string[];
    validateTemplate(config: AgentConfig): boolean;
}
/**
 * Simplified chat instance interface - just a wrapper around Robota
 */
interface ChatInstance$1 {
    readonly metadata: ChatMetadata;
    readonly config: ChatConfig;
    readonly robota: Robota;
    sendMessage(content: MessageContent): Promise<string>;
    regenerateResponse(): Promise<string>;
    updateRobotaConfig(config: AgentConfig): Promise<void>;
    getRobotaConfig(): AgentConfig;
    upgradeToTemplate?(templateName: string): Promise<void>;
    getTemplateManager?(): TemplateManager;
    activate(): void;
    deactivate(): void;
    getHistory(): Message[];
    clearHistory(): void;
    save(): Promise<void>;
    load(): Promise<void>;
    getStats(): ChatStats;
    updateConfig(config: Partial<ChatConfig>): void;
}
/**
 * Chat statistics interface - simplified
 */
interface ChatStats {
    messageCount: number;
    createdAt: Date;
    lastActivity: Date;
    totalTokens?: number;
    averageResponseTime?: number;
}

/**
 * Simple ChatInstance implementation - wrapper around Robota
 *
 * Focuses on the core purpose: managing a single AI agent instance
 * within a session context. Delegates conversation management to Robota.
 */
declare class ChatInstance implements ChatInstance$1 {
    readonly metadata: ChatMetadata;
    readonly config: ChatConfig;
    readonly robota: Robota;
    private templateManager;
    constructor(metadata: ChatMetadata, config: ChatConfig, robota: Robota);
    /**
     * Send a message and get AI response
     */
    sendMessage(content: MessageContent): Promise<string>;
    /**
     * Regenerate the last response
     */
    regenerateResponse(): Promise<string>;
    /**
     * Update robota configuration
     */
    updateRobotaConfig(config: AgentConfig): Promise<void>;
    /**
     * Get current robota configuration
     */
    getRobotaConfig(): AgentConfig;
    /**
     * Upgrade to use an agent template
     */
    upgradeToTemplate(templateName: string): Promise<void>;
    /**
     * Get template manager instance
     */
    getTemplateManager(): TemplateManager;
    /**
     * Activate this chat session
     */
    activate(): void;
    /**
     * Deactivate this chat session
     */
    deactivate(): void;
    /**
     * Get conversation history - delegate to Robota
     */
    getHistory(): Message[];
    /**
     * Clear conversation history - delegate to Robota
     */
    clearHistory(): void;
    /**
     * Save chat state
     */
    save(): Promise<void>;
    /**
     * Load chat state
     */
    load(): Promise<void>;
    /**
     * Get chat statistics
     */
    getStats(): ChatStats;
    /**
     * Update chat configuration
     */
    updateConfig(config: Partial<ChatConfig>): void;
}

declare enum SessionState {
    ACTIVE = "active",
    PAUSED = "paused",
    TERMINATED = "terminated"
}
interface SessionConfig {
    name?: string;
    maxChats?: number;
    userId?: string;
    workspaceId?: string;
}
interface SessionInfo {
    id: string;
    userId: string;
    name: string;
    state: SessionState;
    chatCount: number;
    activeChatId?: string;
    createdAt: Date;
    lastUsedAt: Date;
    workspaceId?: string;
}
interface ChatInfo {
    id: string;
    sessionId: string;
    name: string;
    isActive: boolean;
    messageCount: number;
    createdAt: Date;
    lastUsedAt: Date;
    agentTemplate?: string;
}
interface SessionManagerConfig {
    maxSessions?: number;
    maxChatsPerSession?: number;
}
interface CreateSessionOptions {
    name?: string;
    userId?: string;
    workspaceId?: string;
    maxChats?: number;
}
interface CreateChatOptions {
    name?: string;
    agentConfig: AgentConfig;
    agentTemplate?: string;
    description?: string;
}

/**
 * SessionManager - manages multiple independent AI agents in isolated workspaces
 *
 * Core responsibilities:
 * - Create and manage multiple sessions (workspaces)
 * - Create and manage multiple chat instances (AI agents) per session
 * - Provide workspace isolation between sessions
 * - Handle basic session lifecycle and limits
 */
declare class SessionManager {
    private sessions;
    private chats;
    private sessionChats;
    private agentFactory;
    private config;
    constructor(config?: SessionManagerConfig);
    /**
     * Create a new session (workspace)
     */
    createSession(options?: CreateSessionOptions): string;
    /**
     * Create a new chat (AI agent) within a session
     */
    createChat(sessionId: string, options: CreateChatOptions): Promise<string>;
    /**
     * Get a chat instance
     */
    getChat(chatId: string): ChatInstance | undefined;
    /**
     * Get session information
     */
    getSession(sessionId: string): SessionInfo | undefined;
    /**
     * List all chats in a session
     */
    getSessionChats(sessionId: string): ChatInfo[];
    /**
     * Switch active chat in session
     */
    switchChat(sessionId: string, chatId: string): boolean;
    /**
     * Delete a chat
     */
    deleteChat(chatId: string): boolean;
    /**
     * Delete a session and all its chats
     */
    deleteSession(sessionId: string): boolean;
    /**
     * List all sessions
     */
    listSessions(): SessionInfo[];
    /**
     * Generate unique session ID
     */
    private generateSessionId;
    /**
     * Generate unique chat ID
     */
    private generateChatId;
}

/**
 * TemplateManagerAdapter - adapts agents package AgentFactory/AgentTemplates to TemplateManager interface
 *
 * This adapter allows the sessions package to use the template functionality from
 * the agents package without duplicating implementation.
 */
declare class TemplateManagerAdapter implements TemplateManager {
    private agentFactory;
    private agentTemplates;
    constructor(agentFactory?: AgentFactory);
    /**
     * Get template configuration by name
     */
    getTemplate(name: string): AgentConfig | undefined;
    /**
     * List all available template names
     */
    listTemplates(): string[];
    /**
     * Validate template configuration
     */
    validateTemplate(config: AgentConfig): boolean;
    /**
     * Register a new template
     */
    registerTemplate(template: AgentTemplate): void;
    /**
     * Unregister a template
     */
    unregisterTemplate(templateId: string): boolean;
    /**
     * Get template details (full template object)
     */
    getTemplateDetails(name: string): AgentTemplate | undefined;
    /**
     * Apply template to create agent config with overrides
     */
    applyTemplate(templateId: string, overrides?: Partial<AgentConfig>): AgentConfig | undefined;
}

export { type ChatConfig, type ChatInfo, ChatInstance, type ChatMetadata, type ChatStats, type CreateChatOptions, type CreateSessionOptions, type MessageContent, type SessionConfig, type SessionInfo, SessionManager, type SessionManagerConfig, SessionState, type TemplateManager, TemplateManagerAdapter };