@juspay/neurolink 6.1.0 → 6.2.1

package/dist/chat/client-utils.js

@@ -1,315 +0,0 @@
-/**
- * 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":
-                if (this.isDataEventData(event.data)) {
-                    this.handleDataEvent(event.data);
-                }
-                break;
-            case "error":
-                if (this.isErrorEventData(event.data)) {
-                    this.handleErrorEvent(event.data);
-                }
-                break;
-            case "complete":
-                if (this.isCompleteEventData(event.data)) {
-                    this.handleCompleteEvent(event.data);
-                }
-                break;
-            case "heartbeat":
-                // Heartbeat received, connection is alive
-                break;
-        }
-    }
-    isDataEventData(data) {
-        return (typeof data === "object" &&
-            data !== null &&
-            typeof data.type === "string");
-    }
-    isErrorEventData(data) {
-        return typeof data === "object" && data !== null;
-    }
-    isCompleteEventData(data) {
-        return typeof data === "object" && data !== null;
-    }
-    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: String(data.messageId || `msg_${Date.now()}_user`),
-                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

@@ -1,24 +0,0 @@
-/**
- * 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: unknown, options?: unknown): Promise<SSEChatHandler>;
-/**
- * Quick setup helper for chat session
- */
-export declare function createChatSession(sessionId: string, options?: unknown): Promise<import("./session.js").ChatSession>;
-export declare function createEnhancedChatService(options: {
-    provider: unknown;
-    enableSSE?: boolean;
-    enableWebSocket?: boolean;
-    streamingConfig?: unknown;
-}): Promise<SSEChatHandler>;

package/dist/chat/index.js

@@ -1,33 +0,0 @@
-/**
- * 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);
-}
-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

@@ -1,77 +0,0 @@
-/**
- * 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?: unknown): Promise<unknown>;
-    del(key: string): Promise<number>;
-    exists(key: string): Promise<number>;
-    expire?(key: string, ttl: number): Promise<unknown>;
-    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

@@ -1,233 +0,0 @@
-/**
- * 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}`);
-        }
-    }
-}