@juspay/neurolink 3.0.1 → 4.1.0

package/dist/chat/client-utils.js

@@ -0,0 +1,298 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Client-side utilities for SSE chat integration
+ */
+/**
+ * Client for SSE chat communication
+ */
+export class ChatClient {
+    eventSource;
+    options;
+    messages = [];
+    reconnectCount = 0;
+    isConnected = false;
+    isReconnecting = false;
+    reconnectTimeout;
+    constructor(options) {
+        this.options = {
+            ...options,
+            onMessage: options.onMessage || (() => { }),
+            onError: options.onError || (() => { }),
+            onConnect: options.onConnect || (() => { }),
+            onDisconnect: options.onDisconnect || (() => { }),
+            reconnectAttempts: options.reconnectAttempts ?? 5,
+            reconnectDelay: options.reconnectDelay ?? 1000,
+        };
+    }
+    /**
+     * Connect to SSE endpoint
+     */
+    connect() {
+        if (this.eventSource) {
+            this.disconnect();
+        }
+        const url = new URL("/chat/stream", this.options.endpoint);
+        url.searchParams.set("sessionId", this.options.sessionId);
+        this.eventSource = new EventSource(url.toString());
+        this.eventSource.onopen = () => {
+            this.isConnected = true;
+            this.isReconnecting = false;
+            this.reconnectCount = 0;
+            this.options.onConnect();
+        };
+        this.eventSource.onmessage = (event) => {
+            try {
+                const sseEvent = JSON.parse(event.data);
+                this.handleSSEEvent(sseEvent);
+            }
+            catch (error) {
+                console.error("Failed to parse SSE event:", error);
+            }
+        };
+        this.eventSource.onerror = (error) => {
+            this.isConnected = false;
+            this.options.onDisconnect();
+            if (this.reconnectCount < this.options.reconnectAttempts) {
+                this.isReconnecting = true;
+                this.scheduleReconnect();
+            }
+            else {
+                this.isReconnecting = false;
+                this.options.onError(new Error("Max reconnection attempts reached"));
+            }
+        };
+        // Handle specific event types
+        this.eventSource.addEventListener("data", (event) => {
+            this.handleDataEvent(JSON.parse(event.data));
+        });
+        this.eventSource.addEventListener("errMsg", (event) => {
+            this.handleErrorEvent(JSON.parse(event.data));
+        });
+        this.eventSource.addEventListener("complete", (event) => {
+            this.handleCompleteEvent(JSON.parse(event.data));
+        });
+    }
+    /**
+     * Send message to chat
+     */
+    async sendMessage(content) {
+        if (!this.isConnected) {
+            throw new Error("Not connected to chat server");
+        }
+        try {
+            const response = await fetch(`${this.options.endpoint}/chat/send`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    sessionId: this.options.sessionId,
+                    message: content,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            this.options.onError(error);
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from SSE endpoint
+     */
+    disconnect() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = undefined;
+        }
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
+        this.isConnected = false;
+        this.isReconnecting = false;
+        this.options.onDisconnect();
+    }
+    /**
+     * Get message history
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+    /**
+     * Clear message history
+     */
+    clearMessages() {
+        this.messages = [];
+    }
+    /**
+     * Check connection status
+     */
+    getConnectionStatus() {
+        return {
+            connected: this.isConnected,
+            reconnecting: this.isReconnecting,
+            reconnectCount: this.reconnectCount,
+        };
+    }
+    handleSSEEvent(event) {
+        switch (event.type) {
+            case "data":
+                this.handleDataEvent(event.data);
+                break;
+            case "error":
+                this.handleErrorEvent(event.data);
+                break;
+            case "complete":
+                this.handleCompleteEvent(event.data);
+                break;
+            case "heartbeat":
+                // Heartbeat received, connection is alive
+                break;
+        }
+    }
+    handleDataEvent(data) {
+        if (data.type === "chunk") {
+            // Handle streaming response chunk
+            const lastMessage = this.messages[this.messages.length - 1];
+            if (lastMessage && lastMessage.role === "assistant") {
+                // Append to existing assistant message
+                lastMessage.content += data.content;
+                this.options.onMessage(lastMessage);
+            }
+            else {
+                // Create new assistant message
+                const message = {
+                    id: `msg_${Date.now()}_assistant`,
+                    role: "assistant",
+                    content: data.content,
+                    timestamp: Date.now(),
+                };
+                this.messages.push(message);
+                this.options.onMessage(message);
+            }
+        }
+        else if (data.type === "start") {
+            // New conversation started
+            const userMessage = {
+                id: data.messageId,
+                role: "user",
+                content: data.content || "", // Use data content if available
+                timestamp: Date.now(),
+            };
+            this.messages.push(userMessage);
+        }
+    }
+    handleErrorEvent(data) {
+        this.options.onError(new Error(data.message || "Chat error"));
+    }
+    handleCompleteEvent(data) {
+        // Message completion - final processing
+        if (data.totalTokens) {
+            const lastMessage = this.messages[this.messages.length - 1];
+            if (lastMessage) {
+                // Initialize metadata if it doesn't exist
+                if (!lastMessage.metadata) {
+                    lastMessage.metadata = {};
+                }
+                lastMessage.metadata.tokens = data.totalTokens;
+            }
+        }
+    }
+    scheduleReconnect() {
+        const delay = this.options.reconnectDelay * Math.pow(2, this.reconnectCount);
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectCount++;
+            this.reconnectTimeout = undefined;
+            this.connect();
+        }, delay);
+    }
+}
+/**
+ * Create chat client instance
+ */
+export function createChatClient(options) {
+    return new ChatClient(options);
+}
+/**
+ * React-style hook for chat streaming (can be adapted for other frameworks)
+ */
+export function useChatStream(options) {
+    // This would typically use React hooks or similar framework state management
+    // For now, providing a basic implementation that can be extended
+    const client = new ChatClient(options);
+    // Connect on creation
+    client.connect();
+    return {
+        get messages() {
+            return client.getMessages();
+        },
+        get isConnected() {
+            return client.getConnectionStatus().connected;
+        },
+        get isReconnecting() {
+            return client.getConnectionStatus().reconnecting;
+        },
+        sendMessage: async (content) => {
+            await client.sendMessage(content);
+        },
+        disconnect: () => {
+            client.disconnect();
+        },
+        reconnect: () => {
+            client.connect();
+        },
+        clearHistory: () => {
+            client.clearMessages();
+        },
+    };
+}
+/**
+ * Utility for creating SSE EventSource with automatic reconnection
+ */
+export function createSSEConnection(url, options = {}) {
+    let eventSource = null;
+    let reconnectCount = 0;
+    let isConnected = false;
+    const maxAttempts = options.maxReconnectAttempts ?? 5;
+    const connect = () => {
+        if (eventSource) {
+            eventSource.close();
+        }
+        eventSource = new EventSource(url);
+        eventSource.onopen = () => {
+            isConnected = true;
+            reconnectCount = 0;
+            options.onOpen?.();
+        };
+        eventSource.onmessage = (event) => {
+            options.onMessage?.(event);
+        };
+        eventSource.onerror = () => {
+            isConnected = false;
+            if (options.reconnect && reconnectCount < maxAttempts) {
+                setTimeout(() => {
+                    reconnectCount++;
+                    connect();
+                }, 1000 * Math.pow(2, reconnectCount));
+            }
+            else {
+                options.onError?.(new Error("SSE connection failed"));
+            }
+        };
+    };
+    const disconnect = () => {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        isConnected = false;
+    };
+    return {
+        connect,
+        disconnect,
+        isConnected: () => isConnected,
+    };
+}

package/dist/chat/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Main chat module exports
+ */
+import { SSEChatHandler } from "./sse-handler.js";
+export { SSEChatHandler } from "./sse-handler.js";
+export { ChatSession } from "./session.js";
+export { MemorySessionStorage, FileSessionStorage, RedisSessionStorage, SessionStorageFactory, } from "./session-storage.js";
+export { createChatClient, useChatStream } from "./client-utils.js";
+export type { ChatMessage, ChatRequest, SSEOptions, SessionOptions, SSEEvent, ChatSessionState, StreamingChatResponse, SessionStorage, ContextManager, } from "./types.js";
+/**
+ * Quick setup helper for SSE chat
+ */
+export declare function createSSEChat(provider: any, options?: any): Promise<SSEChatHandler>;
+/**
+ * Quick setup helper for chat session
+ */
+export declare function createChatSession(sessionId: string, options?: any): Promise<import("./session.js").ChatSession>;
+/**
+ * Enhanced factory function for real-time chat
+ */
+export declare function createEnhancedChatService(options: {
+    provider: any;
+    enableSSE?: boolean;
+    enableWebSocket?: boolean;
+    streamingConfig?: any;
+}): Promise<SSEChatHandler>;

package/dist/chat/index.js

@@ -0,0 +1,41 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Main chat module exports
+ */
+import { SSEChatHandler } from "./sse-handler.js";
+export { SSEChatHandler } from "./sse-handler.js";
+export { ChatSession } from "./session.js";
+export { MemorySessionStorage, FileSessionStorage, RedisSessionStorage, SessionStorageFactory, } from "./session-storage.js";
+export { createChatClient, useChatStream } from "./client-utils.js";
+/**
+ * Quick setup helper for SSE chat
+ */
+export async function createSSEChat(provider, options) {
+    const { SSEChatHandler } = await import("./sse-handler.js");
+    return new SSEChatHandler(provider, options);
+}
+/**
+ * Quick setup helper for chat session
+ */
+export async function createChatSession(sessionId, options) {
+    const { ChatSession } = await import("./session.js");
+    return new ChatSession(sessionId, options);
+}
+// Real-time Services (Phase 4) - Temporarily disabled for testing
+// export { WebSocketChatHandler } from './websocket-chat-handler.js';
+// export { NeuroLinkWebSocketServer } from '../services/websocket/websocket-server.js';
+// export { StreamingManager } from '../services/streaming/streaming-manager.js';
+// export * from '../services/types.js';
+/**
+ * Enhanced factory function for real-time chat
+ */
+export async function createEnhancedChatService(options) {
+    if (options.enableWebSocket) {
+        const { WebSocketChatHandler } = await import("./websocket-chat-handler.js");
+        return new WebSocketChatHandler(options.provider, {
+            sseOptions: options.enableSSE ? {} : undefined,
+            wsOptions: options.streamingConfig,
+        });
+    }
+    return new SSEChatHandler(options.provider);
+}

package/dist/chat/session-storage.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Session storage adapters for persistence
+ */
+import type { SessionStorage, ChatSessionState } from "./types.js";
+/**
+ * In-memory session storage (default)
+ */
+export declare class MemorySessionStorage implements SessionStorage {
+    private sessions;
+    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>;
+    /**
+     * Get storage statistics
+     */
+    getStats(): {
+        totalSessions: number;
+        memoryUsageBytes: number;
+        oldestSession?: number;
+        newestSession?: number;
+    };
+    /**
+     * Clear all sessions
+     */
+    clear(): Promise<void>;
+}
+/**
+ * File-based session storage
+ */
+export declare class FileSessionStorage implements SessionStorage {
+    private basePath;
+    private constructor();
+    static create(basePath?: string): Promise<FileSessionStorage>;
+    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>;
+    private getFilePath;
+    private ensureDirectory;
+}
+/**
+ * Redis session storage (for production scaling)
+ */
+interface RedisClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: any): Promise<any>;
+    del(key: string): Promise<number>;
+    exists(key: string): Promise<number>;
+    expire?(key: string, ttl: number): Promise<any>;
+    keys?(pattern: string): Promise<string[]>;
+}
+export declare class RedisSessionStorage implements SessionStorage {
+    private client;
+    private keyPrefix;
+    constructor(redisClient: RedisClient, keyPrefix?: string);
+    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>;
+    private getKey;
+}
+/**
+ * Session storage factory
+ */
+export declare class SessionStorageFactory {
+    static create(type: "memory" | "file" | "redis", options?: {
+        basePath?: string;
+        redisClient?: RedisClient;
+        keyPrefix?: string;
+    }): Promise<SessionStorage>;
+}
+export {};

package/dist/chat/session-storage.js

@@ -0,0 +1,233 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Session storage adapters for persistence
+ */
+import { promises as fs } from "fs";
+/**
+ * In-memory session storage (default)
+ */
+export class MemorySessionStorage {
+    sessions = new Map();
+    async get(sessionId) {
+        return this.sessions.get(sessionId) || null;
+    }
+    async set(sessionId, state) {
+        this.sessions.set(sessionId, state);
+    }
+    async delete(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    async list() {
+        return Array.from(this.sessions.keys());
+    }
+    async cleanup(maxAge) {
+        const now = Date.now();
+        let removed = 0;
+        for (const [sessionId, state] of this.sessions.entries()) {
+            if (now - state.lastActivity > maxAge) {
+                this.sessions.delete(sessionId);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Get storage statistics
+     */
+    getStats() {
+        const sessions = Array.from(this.sessions.values());
+        const memoryUsageBytes = Buffer.byteLength(JSON.stringify(sessions), "utf8");
+        const timestamps = sessions.map((s) => s.lastActivity);
+        return {
+            totalSessions: this.sessions.size,
+            memoryUsageBytes,
+            oldestSession: timestamps.length > 0 ? Math.min(...timestamps) : undefined,
+            newestSession: timestamps.length > 0 ? Math.max(...timestamps) : undefined,
+        };
+    }
+    /**
+     * Clear all sessions
+     */
+    async clear() {
+        this.sessions.clear();
+    }
+}
+/**
+ * File-based session storage
+ */
+export class FileSessionStorage {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    static async create(basePath = "./sessions") {
+        const instance = new FileSessionStorage(basePath);
+        await instance.ensureDirectory();
+        return instance;
+    }
+    async get(sessionId) {
+        try {
+            const filePath = this.getFilePath(sessionId);
+            const data = await fs.readFile(filePath, "utf-8");
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                return null; // File doesn't exist
+            }
+            throw error;
+        }
+    }
+    async set(sessionId, state) {
+        const filePath = this.getFilePath(sessionId);
+        const data = JSON.stringify({
+            ...state,
+            lastActivity: state.lastActivity ?? Date.now(),
+        }, null, 2);
+        await fs.writeFile(filePath, data, "utf-8");
+    }
+    async delete(sessionId) {
+        try {
+            const filePath = this.getFilePath(sessionId);
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    async list() {
+        try {
+            const files = await fs.readdir(this.basePath);
+            return files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => file.replace(".json", ""));
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    async cleanup(maxAge) {
+        const sessionIds = await this.list();
+        const now = Date.now();
+        let removed = 0;
+        for (const sessionId of sessionIds) {
+            const state = await this.get(sessionId);
+            if (state && now - state.lastActivity > maxAge) {
+                await this.delete(sessionId);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    getFilePath(sessionId) {
+        return `${this.basePath}/${sessionId}.json`;
+    }
+    async ensureDirectory() {
+        try {
+            await fs.mkdir(this.basePath, { recursive: true });
+        }
+        catch (error) {
+            if (error?.code !== "EEXIST") {
+                throw error; // Rethrow unexpected errors
+            }
+            // Directory already exists, which is fine
+        }
+    }
+}
+export class RedisSessionStorage {
+    client;
+    keyPrefix;
+    constructor(redisClient, keyPrefix = "neurolink:session:") {
+        this.client = redisClient;
+        this.keyPrefix = keyPrefix;
+    }
+    async get(sessionId) {
+        try {
+            const data = await this.client.get(this.getKey(sessionId));
+            return data ? JSON.parse(data) : null;
+        }
+        catch (error) {
+            console.error("Redis get error:", error);
+            return null;
+        }
+    }
+    async set(sessionId, state) {
+        try {
+            const key = this.getKey(sessionId);
+            const data = JSON.stringify({
+                ...state,
+                lastActivity: Date.now(),
+            });
+            await this.client.set(key, data);
+            // Set TTL if supported
+            if (this.client.expire) {
+                await this.client.expire(key, 3600); // 1 hour default
+            }
+        }
+        catch (error) {
+            console.error("Redis set error:", error);
+            throw error;
+        }
+    }
+    async delete(sessionId) {
+        try {
+            await this.client.del(this.getKey(sessionId));
+        }
+        catch (error) {
+            console.error("Redis delete error:", error);
+            throw error;
+        }
+    }
+    async list() {
+        try {
+            if (!this.client.keys) {
+                console.warn("Redis client does not support keys operation");
+                return [];
+            }
+            const keys = await this.client.keys(`${this.keyPrefix}*`);
+            return keys.map((key) => key.replace(this.keyPrefix, ""));
+        }
+        catch (error) {
+            console.error("Redis list error:", error);
+            return [];
+        }
+    }
+    async cleanup(maxAge) {
+        const sessionIds = await this.list();
+        const now = Date.now();
+        let removed = 0;
+        for (const sessionId of sessionIds) {
+            const state = await this.get(sessionId);
+            if (state && now - state.lastActivity > maxAge) {
+                await this.delete(sessionId);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    getKey(sessionId) {
+        return `${this.keyPrefix}${sessionId}`;
+    }
+}
+/**
+ * Session storage factory
+ */
+export class SessionStorageFactory {
+    static async create(type, options) {
+        switch (type) {
+            case "memory":
+                return new MemorySessionStorage();
+            case "file":
+                return await FileSessionStorage.create(options?.basePath);
+            case "redis":
+                if (!options?.redisClient) {
+                    throw new Error("Redis client required for Redis storage");
+                }
+                return new RedisSessionStorage(options.redisClient, options.keyPrefix);
+            default:
+                throw new Error(`Unknown storage type: ${type}`);
+        }
+    }
+}