@juspay/neurolink 3.0.0 → 4.0.0

package/dist/lib/chat/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Type definitions for chat infrastructure
+ */
+export interface ChatMessage {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: number;
+    metadata?: {
+        provider?: string;
+        model?: string;
+        tokens?: number;
+        duration?: number;
+    };
+}
+export interface ChatRequest {
+    sessionId: string;
+    message: string;
+    role?: "user";
+    options?: {
+        temperature?: number;
+        maxTokens?: number;
+        systemPrompt?: string;
+        streamResponse?: boolean;
+    };
+}
+export interface SSEOptions {
+    maxConnections?: number;
+    heartbeatInterval?: number;
+    connectionTimeout?: number;
+    enableCors?: boolean;
+    corsOrigins?: string[];
+}
+export interface SessionOptions {
+    maxHistory?: number;
+    persistenceAdapter?: "memory" | "redis" | "file";
+    contextWindowSize?: number;
+    autoSave?: boolean;
+    ttl?: number;
+}
+export interface SSEEvent {
+    type: "data" | "error" | "progress" | "complete" | "heartbeat";
+    data: any;
+    id?: string;
+    retry?: number;
+}
+export interface ChatSessionState {
+    id: string;
+    messages: ChatMessage[];
+    createdAt: number;
+    lastActivity: number;
+    metadata?: Record<string, any>;
+}
+export interface StreamingChatResponse {
+    sessionId: string;
+    messageId: string;
+    stream: ReadableStream;
+    response: Response;
+}
+export interface SessionStorage {
+    get(sessionId: string): Promise<ChatSessionState | null>;
+    set(sessionId: string, state: ChatSessionState): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    list(): Promise<string[]>;
+    cleanup(maxAge: number): Promise<number>;
+}
+export interface ContextManager {
+    addMessage(sessionId: string, message: ChatMessage): Promise<void>;
+    getHistory(sessionId: string, limit?: number): Promise<ChatMessage[]>;
+    trimContext(sessionId: string, maxTokens: number): Promise<number>;
+    estimateTokens(messages: ChatMessage[]): number;
+}

package/dist/lib/chat/types.js

@@ -0,0 +1,5 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Type definitions for chat infrastructure
+ */
+export {};

package/dist/lib/chat/websocket-chat-handler.d.ts

@@ -0,0 +1,36 @@
+import { SSEChatHandler } from "./sse-handler.js";
+import type { AIProvider } from "../core/types.js";
+import type { WebSocketOptions, ChatRequest, GroupChatRequest, StreamingChatRequest } from "../services/types.js";
+import type { SSEOptions } from "./types.js";
+export interface WebSocketChatOptions {
+    sseOptions?: any;
+    wsOptions?: WebSocketOptions;
+    enableTypingIndicators?: boolean;
+    enablePresenceTracking?: boolean;
+    enableMessageSync?: boolean;
+}
+export declare class WebSocketChatHandler extends SSEChatHandler {
+    private wsServer;
+    private streamingManager;
+    protected options: WebSocketChatOptions & Required<SSEOptions>;
+    private typingIndicators;
+    private presenceTracking;
+    constructor(provider: AIProvider, options?: WebSocketChatOptions);
+    private setupWebSocketHandlers;
+    handleWebSocketChatRequest(connectionId: string, request: ChatRequest): Promise<void>;
+    handleGroupChat(roomId: string, request: GroupChatRequest): Promise<void>;
+    handleStreamingChat(connectionId: string, request: StreamingChatRequest): Promise<void>;
+    enableTypingIndicators(roomId: string): Promise<void>;
+    enablePresenceTracking(roomId: string): Promise<void>;
+    enableMessageSynchronization(roomId: string): Promise<void>;
+    private sendToConnection;
+    private sendError;
+    private showTypingIndicator;
+    private clearTypingIndicator;
+    private updatePresence;
+    private handleWebSocketChatMessage;
+    getConnectionCount(): number;
+    getRoomCount(): number;
+    getStreamingMetrics(): import("../services/types.js").StreamingMetrics;
+    close(): void;
+}

package/dist/lib/chat/websocket-chat-handler.js

@@ -0,0 +1,262 @@
+import { SSEChatHandler } from "./sse-handler.js";
+import { NeuroLinkWebSocketServer } from "../services/websocket/websocket-server.js";
+import { StreamingManager } from "../services/streaming/streaming-manager.js";
+import { randomUUID } from "crypto";
+export class WebSocketChatHandler extends SSEChatHandler {
+    wsServer;
+    streamingManager;
+    options;
+    typingIndicators = new Map();
+    presenceTracking = new Map();
+    constructor(provider, options = {}) {
+        super(provider, options.sseOptions);
+        this.options = {
+            enableTypingIndicators: true,
+            enablePresenceTracking: true,
+            enableMessageSync: true,
+            maxConnections: 100,
+            heartbeatInterval: 30000,
+            connectionTimeout: 300000,
+            enableCors: true,
+            corsOrigins: ["*"],
+            ...options,
+        };
+        this.wsServer = new NeuroLinkWebSocketServer(options.wsOptions);
+        this.streamingManager = new StreamingManager();
+        this.setupWebSocketHandlers();
+    }
+    setupWebSocketHandlers() {
+        this.wsServer.on("connection", ({ connectionId }) => {
+            console.log(`[WebSocket Chat] New connection: ${connectionId}`);
+            if (this.options.enablePresenceTracking) {
+                this.updatePresence(connectionId, "online");
+            }
+        });
+        this.wsServer.on("disconnection", ({ connectionId }) => {
+            console.log(`[WebSocket Chat] Disconnection: ${connectionId}`);
+            if (this.options.enablePresenceTracking) {
+                this.updatePresence(connectionId, "offline");
+            }
+            this.clearTypingIndicator(connectionId);
+        });
+        this.wsServer.on("chat-message", ({ connectionId, message }) => {
+            this.handleWebSocketChatMessage(connectionId, message);
+        });
+    }
+    // Enhanced Chat Capabilities
+    async handleWebSocketChatRequest(connectionId, request) {
+        try {
+            if (this.options.enableTypingIndicators) {
+                this.showTypingIndicator(connectionId, "assistant");
+            }
+            // Create streaming session for this chat
+            const streamingSession = await this.streamingManager.createStreamingSession({
+                provider: this.provider.constructor.name,
+                model: "default", // Should get from provider
+                streamingMode: "real-time",
+                compressionEnabled: true,
+                maxChunkSize: 1024,
+                bufferSize: 4096,
+                latencyTarget: 200,
+            });
+            // Generate AI response
+            const result = await this.provider.generateText({
+                prompt: request.prompt,
+                temperature: request.options?.temperature,
+                maxTokens: request.options?.maxTokens,
+            });
+            if (!result || !result.text) {
+                throw new Error("Invalid AI response");
+            }
+            // Send response via WebSocket
+            const responseMessage = {
+                id: randomUUID(),
+                type: "ai-response",
+                connectionId,
+                timestamp: Date.now(),
+                data: {
+                    text: result.text,
+                    sessionId: request.sessionId,
+                    metadata: {
+                        provider: this.provider.constructor.name,
+                        tokens: result.usage?.totalTokens,
+                        latency: Date.now() - Date.now(), // Should track actual timing
+                    },
+                },
+            };
+            this.sendToConnection(connectionId, responseMessage);
+            if (this.options.enableTypingIndicators) {
+                this.clearTypingIndicator(connectionId);
+            }
+            await this.streamingManager.terminateStreamingSession(streamingSession.id);
+        }
+        catch (error) {
+            console.error("[WebSocket Chat] Error handling chat request:", error);
+            this.sendError(connectionId, "Failed to process chat request");
+        }
+    }
+    async handleGroupChat(roomId, request) {
+        try {
+            // Process AI request
+            const result = await this.provider.generateText({
+                prompt: request.prompt,
+                temperature: request.options?.temperature,
+                maxTokens: request.options?.maxTokens,
+            });
+            if (!result || !result.text) {
+                throw new Error("Invalid AI response");
+            }
+            // Broadcast to room
+            const broadcastMessage = {
+                id: randomUUID(),
+                type: "ai-response",
+                connectionId: "system",
+                timestamp: Date.now(),
+                data: {
+                    text: result.text,
+                    sessionId: request.sessionId,
+                    userId: request.userId,
+                    isGroupMessage: true,
+                    metadata: {
+                        provider: this.provider.constructor.name,
+                        tokens: result.usage?.totalTokens,
+                    },
+                },
+            };
+            this.wsServer.broadcastToRoom(roomId, broadcastMessage);
+        }
+        catch (error) {
+            console.error("[WebSocket Chat] Error handling group chat:", error);
+        }
+    }
+    async handleStreamingChat(connectionId, request) {
+        try {
+            const streamingOptions = request.streamingOptions || {};
+            // Create streaming channel
+            const channelId = randomUUID();
+            const channel = this.wsServer.createStreamingChannel(connectionId, channelId);
+            // Generate response
+            const result = await this.provider.generateText({
+                prompt: request.prompt,
+                ...request.options,
+            });
+            if (!result || !result.text) {
+                throw new Error("Invalid AI response");
+            }
+            // Send complete response
+            const responseMessage = {
+                id: randomUUID(),
+                type: "ai-response",
+                connectionId,
+                timestamp: Date.now(),
+                data: {
+                    text: result.text,
+                    isStreamingComplete: true,
+                    channelId,
+                },
+            };
+            this.sendToConnection(connectionId, responseMessage);
+        }
+        catch (error) {
+            console.error("[WebSocket Chat] Error handling streaming chat:", error);
+            this.sendError(connectionId, "Failed to process streaming chat");
+        }
+    }
+    // Real-time Features
+    async enableTypingIndicators(roomId) {
+        this.options.enableTypingIndicators = true;
+        console.log(`[WebSocket Chat] Enabled typing indicators for room ${roomId}`);
+    }
+    async enablePresenceTracking(roomId) {
+        this.options.enablePresenceTracking = true;
+        console.log(`[WebSocket Chat] Enabled presence tracking for room ${roomId}`);
+    }
+    async enableMessageSynchronization(roomId) {
+        this.options.enableMessageSync = true;
+        console.log(`[WebSocket Chat] Enabled message sync for room ${roomId}`);
+    }
+    // Helper methods
+    sendToConnection(connectionId, message) {
+        // Use the WebSocket server's send method
+        const ws = this.wsServer.connections?.get(connectionId);
+        if (ws && ws.readyState === 1) {
+            // WebSocket.OPEN
+            ws.send(JSON.stringify(message));
+        }
+    }
+    sendError(connectionId, errorMessage) {
+        const errorMsg = {
+            id: randomUUID(),
+            type: "error",
+            connectionId,
+            timestamp: Date.now(),
+            data: { error: errorMessage },
+        };
+        this.sendToConnection(connectionId, errorMsg);
+    }
+    showTypingIndicator(connectionId, sender) {
+        if (!this.options.enableTypingIndicators) {
+            return;
+        }
+        const message = {
+            id: randomUUID(),
+            type: "system",
+            connectionId,
+            timestamp: Date.now(),
+            data: {
+                event: "typing_start",
+                sender,
+            },
+        };
+        this.sendToConnection(connectionId, message);
+    }
+    clearTypingIndicator(connectionId) {
+        const timeout = this.typingIndicators.get(connectionId);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.typingIndicators.delete(connectionId);
+        }
+    }
+    updatePresence(connectionId, status) {
+        if (!this.options.enablePresenceTracking) {
+            return;
+        }
+        this.presenceTracking.set(connectionId, {
+            lastSeen: Date.now(),
+            status,
+        });
+    }
+    handleWebSocketChatMessage(connectionId, message) {
+        switch (message.data?.event) {
+            case "chat_request":
+                this.handleWebSocketChatRequest(connectionId, message.data.request);
+                break;
+            case "join_room":
+                this.wsServer.joinRoom(connectionId, message.data.roomId);
+                break;
+            case "leave_room":
+                this.wsServer.leaveRoom(connectionId, message.data.roomId);
+                break;
+            case "typing_start":
+                this.showTypingIndicator(connectionId, message.data.sender || "user");
+                break;
+            case "typing_stop":
+                this.clearTypingIndicator(connectionId);
+                break;
+        }
+    }
+    // Public API
+    getConnectionCount() {
+        return this.wsServer.getConnectionCount();
+    }
+    getRoomCount() {
+        return this.wsServer.getRoomCount();
+    }
+    getStreamingMetrics() {
+        return this.streamingManager.getStreamingMetrics();
+    }
+    close() {
+        this.wsServer.close();
+        this.streamingManager.destroy();
+    }
+}

package/dist/lib/config/configManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * NeuroLink Config Manager with Backup/Restore System
+ * Industry standard configuration management with safety mechanisms
+ */
+import type { NeuroLinkConfig, ProviderConfig, BackupInfo, ConfigValidationResult, ConfigUpdateOptions } from "./types.js";
+/**
+ * Enhanced Config Manager with automatic backup/restore capabilities
+ */
+export declare class NeuroLinkConfigManager {
+    private configPath;
+    private backupDir;
+    private config;
+    private configCache;
+    /**
+     * Load configuration with caching
+     */
+    loadConfig(): Promise<NeuroLinkConfig>;
+    /**
+     * Update configuration with automatic backup
+     */
+    updateConfig(updates: Partial<NeuroLinkConfig>, options?: ConfigUpdateOptions): Promise<void>;
+    /**
+     * Create a backup with metadata
+     */
+    createBackup(reason?: string): Promise<string>;
+    /**
+     * List all available backups
+     */
+    listBackups(): Promise<BackupInfo[]>;
+    /**
+     * Restore from specific backup
+     */
+    restoreFromBackup(backupFilename: string): Promise<void>;
+    /**
+     * Restore from latest backup
+     */
+    restoreLatestBackup(): Promise<void>;
+    /**
+     * Clean up old backups
+     */
+    cleanupOldBackups(keepCount?: number): Promise<void>;
+    /**
+     * Update provider status
+     */
+    updateProviderStatus(providerId: string, status: Partial<ProviderConfig>): Promise<void>;
+    /**
+     * Validate configuration
+     */
+    validateConfig(config: NeuroLinkConfig): Promise<ConfigValidationResult>;
+    /**
+     * Generate default configuration
+     */
+    generateDefaultConfig(): Promise<NeuroLinkConfig>;
+    private ensureBackupDirectory;
+    private readConfigFile;
+    private persistConfig;
+    private generateConfigHash;
+    private extractMetadataFromBackup;
+    private extractConfigFromBackup;
+}