@juspay/neurolink 3.0.0 → 4.0.0

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

@@ -0,0 +1,95 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Chat session management with persistence
+ */
+import type { ChatMessage, SessionOptions, ChatSessionState } from "./types.js";
+export declare class ChatSession {
+    private sessionId;
+    private messages;
+    private options;
+    private storage;
+    private createdAt;
+    private lastActivity;
+    private metadata;
+    constructor(sessionId: string, options?: SessionOptions);
+    /**
+     * Add message to session
+     */
+    addMessage(role: "user" | "assistant" | "system", content: string, metadata?: any): ChatMessage;
+    /**
+     * Get conversation history
+     */
+    getHistory(limit?: number): ChatMessage[];
+    /**
+     * Get messages for a specific role
+     */
+    getMessagesByRole(role: "user" | "assistant" | "system"): ChatMessage[];
+    /**
+     * Get session metadata
+     */
+    getMetadata(): Record<string, any>;
+    /**
+     * Set session metadata
+     */
+    setMetadata(key: string, value: any): void;
+    /**
+     * Clear session history
+     */
+    clearHistory(): void;
+    /**
+     * Get session statistics
+     */
+    getStats(): {
+        messageCount: number;
+        userMessages: number;
+        assistantMessages: number;
+        systemMessages: number;
+        totalTokens: number;
+        sessionAge: number;
+        lastActivity: number;
+    };
+    /**
+     * Trim context to fit within token limits
+     */
+    trimContext(maxTokens: number): number;
+    /**
+     * Estimate total tokens in session
+     */
+    estimateTokens(): number;
+    /**
+     * Get session context for AI prompts
+     */
+    getContextForPrompt(includeSystem?: boolean): string;
+    /**
+     * Persist session to storage
+     */
+    persist(): Promise<void>;
+    /**
+     * Load session from storage
+     */
+    private loadSession;
+    /**
+     * Delete session from storage
+     */
+    delete(): Promise<void>;
+    /**
+     * Create storage adapter based on options
+     */
+    private createStorageAdapter;
+    /**
+     * Export session data
+     */
+    export(): ChatSessionState;
+    /**
+     * Import session data
+     */
+    import(state: ChatSessionState): void;
+    /**
+     * Get session ID
+     */
+    getId(): string;
+    /**
+     * Check if session is active (not expired)
+     */
+    isActive(): boolean;
+}

package/dist/lib/chat/session.js

@@ -0,0 +1,257 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Chat session management with persistence
+ */
+import { MemorySessionStorage } from "./session-storage.js";
+export class ChatSession {
+    sessionId;
+    messages = [];
+    options;
+    storage;
+    createdAt;
+    lastActivity;
+    metadata = {};
+    constructor(sessionId, options = {}) {
+        this.sessionId = sessionId;
+        this.createdAt = Date.now();
+        this.lastActivity = Date.now();
+        this.options = {
+            maxHistory: options.maxHistory ?? 100,
+            persistenceAdapter: options.persistenceAdapter ?? "memory",
+            contextWindowSize: options.contextWindowSize ?? 4000,
+            autoSave: options.autoSave ?? true,
+            ttl: options.ttl ?? 3600, // 1 hour default
+        };
+        // Initialize storage adapter
+        this.storage = this.createStorageAdapter();
+        // Load existing session if available
+        this.loadSession().catch(() => { });
+    }
+    /**
+     * Add message to session
+     */
+    addMessage(role, content, metadata) {
+        const message = {
+            id: `${this.sessionId}_${Date.now()}_${role}`,
+            role,
+            content,
+            timestamp: Date.now(),
+            metadata,
+        };
+        this.messages.push(message);
+        this.lastActivity = Date.now();
+        // Trim history if needed
+        if (this.messages.length > this.options.maxHistory) {
+            this.messages = this.messages.slice(-this.options.maxHistory);
+        }
+        // Auto-save if enabled
+        if (this.options.autoSave) {
+            this.persist().catch((error) => {
+                console.error("Auto-save failed:", error);
+            });
+        }
+        return message;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory(limit) {
+        const messages = limit ? this.messages.slice(-limit) : this.messages;
+        return [...messages]; // Return copy to prevent mutations
+    }
+    /**
+     * Get messages for a specific role
+     */
+    getMessagesByRole(role) {
+        return this.messages.filter((msg) => msg.role === role);
+    }
+    /**
+     * Get session metadata
+     */
+    getMetadata() {
+        return { ...this.metadata };
+    }
+    /**
+     * Set session metadata
+     */
+    setMetadata(key, value) {
+        this.metadata[key] = value;
+        this.lastActivity = Date.now();
+    }
+    /**
+     * Clear session history
+     */
+    clearHistory() {
+        this.messages = [];
+        this.lastActivity = Date.now();
+        if (this.options.autoSave) {
+            this.persist().catch((error) => {
+                console.error("Auto-save after clear failed:", error);
+            });
+        }
+    }
+    /**
+     * Get session statistics
+     */
+    getStats() {
+        const userMessages = this.getMessagesByRole("user").length;
+        const assistantMessages = this.getMessagesByRole("assistant").length;
+        const systemMessages = this.getMessagesByRole("system").length;
+        // Rough token estimation (characters / 4)
+        const totalTokens = this.messages.reduce((sum, msg) => {
+            return sum + Math.ceil(msg.content.length / 4);
+        }, 0);
+        return {
+            messageCount: this.messages.length,
+            userMessages,
+            assistantMessages,
+            systemMessages,
+            totalTokens,
+            sessionAge: Date.now() - this.createdAt,
+            lastActivity: this.lastActivity,
+        };
+    }
+    /**
+     * Trim context to fit within token limits
+     */
+    trimContext(maxTokens) {
+        let currentTokens = this.estimateTokens();
+        let removedMessages = 0;
+        // Keep the most recent messages within token limit
+        while (currentTokens > maxTokens && this.messages.length > 1) {
+            // Remove oldest message (but keep system messages if possible)
+            const oldestNonSystem = this.messages.findIndex((msg) => msg.role !== "system");
+            const indexToRemove = oldestNonSystem >= 0 ? oldestNonSystem : 0;
+            const removedMessage = this.messages.splice(indexToRemove, 1)[0];
+            currentTokens -= Math.ceil(removedMessage.content.length / 4);
+            removedMessages++;
+        }
+        this.lastActivity = Date.now();
+        if (this.options.autoSave && removedMessages > 0) {
+            this.persist().catch((error) => {
+                console.error("Auto-save after trim failed:", error);
+            });
+        }
+        return removedMessages;
+    }
+    /**
+     * Estimate total tokens in session
+     */
+    estimateTokens() {
+        return this.messages.reduce((sum, msg) => {
+            return sum + Math.ceil(msg.content.length / 4);
+        }, 0);
+    }
+    /**
+     * Get session context for AI prompts
+     */
+    getContextForPrompt(includeSystem = true) {
+        const relevantMessages = includeSystem
+            ? this.messages
+            : this.messages.filter((msg) => msg.role !== "system");
+        return relevantMessages
+            .map((msg) => `${msg.role}: ${msg.content}`)
+            .join("\n\n");
+    }
+    /**
+     * Persist session to storage
+     */
+    async persist() {
+        const state = {
+            id: this.sessionId,
+            messages: this.messages,
+            createdAt: this.createdAt,
+            lastActivity: this.lastActivity,
+            metadata: this.metadata,
+        };
+        await this.storage.set(this.sessionId, state);
+    }
+    /**
+     * Load session from storage
+     */
+    async loadSession() {
+        try {
+            const state = await this.storage.get(this.sessionId);
+            if (state) {
+                this.messages = state.messages || [];
+                this.createdAt = state.createdAt || Date.now();
+                this.lastActivity = state.lastActivity || Date.now();
+                this.metadata = state.metadata || {};
+                // Check if session has expired
+                const age = Date.now() - this.lastActivity;
+                if (age > this.options.ttl * 1000) {
+                    // Session expired, start fresh
+                    this.messages = [];
+                    this.metadata = {};
+                    this.createdAt = Date.now();
+                    this.lastActivity = Date.now();
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to load session:", error);
+            // Continue with fresh session
+        }
+    }
+    /**
+     * Delete session from storage
+     */
+    async delete() {
+        await this.storage.delete(this.sessionId);
+        this.messages = [];
+        this.metadata = {};
+    }
+    /**
+     * Create storage adapter based on options
+     */
+    createStorageAdapter() {
+        switch (this.options.persistenceAdapter) {
+            case "memory":
+                return new MemorySessionStorage();
+            case "redis":
+                // TODO: Implement Redis adapter
+                console.warn("Redis adapter not yet implemented, falling back to memory");
+                return new MemorySessionStorage();
+            case "file":
+                // TODO: Implement File adapter
+                console.warn("File adapter not yet implemented, falling back to memory");
+                return new MemorySessionStorage();
+            default:
+                return new MemorySessionStorage();
+        }
+    }
+    /**
+     * Export session data
+     */
+    export() {
+        return {
+            id: this.sessionId,
+            messages: [...this.messages],
+            createdAt: this.createdAt,
+            lastActivity: this.lastActivity,
+            metadata: { ...this.metadata },
+        };
+    }
+    /**
+     * Import session data
+     */
+    import(state) {
+        this.messages = state.messages || [];
+        this.createdAt = state.createdAt || Date.now();
+        this.lastActivity = state.lastActivity || Date.now();
+        this.metadata = state.metadata || {};
+    }
+    /**
+     * Get session ID
+     */
+    getId() {
+        return this.sessionId;
+    }
+    /**
+     * Check if session is active (not expired)
+     */
+    isActive() {
+        const age = Date.now() - this.lastActivity;
+        return age <= this.options.ttl * 1000;
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Server-Sent Events handler for real-time chat
+ */
+import type { AIProvider } from "../core/types.js";
+import type { ChatRequest, SSEOptions } from "./types.js";
+export declare class SSEChatHandler {
+    private connections;
+    protected provider: AIProvider;
+    protected options: Required<SSEOptions>;
+    private heartbeatInterval?;
+    constructor(provider: AIProvider, options?: SSEOptions);
+    /**
+     * Handle incoming chat request and return SSE response
+     */
+    handleChatRequest(request: ChatRequest): Promise<Response>;
+    /**
+     * Create event stream for a session
+     */
+    createEventStream(sessionId: string, handler?: (writer: WritableStreamDefaultWriter) => Promise<void>): ReadableStream;
+    /**
+     * Send SSE event to client
+     */
+    private sendEvent;
+    /**
+     * Get SSE response headers
+     */
+    private getSSEHeaders;
+    /**
+     * Close connection and cleanup
+     */
+    private closeConnection;
+    /**
+     * Start heartbeat to keep connections alive
+     */
+    private startHeartbeat;
+    /**
+     * Cleanup and stop handler
+     */
+    destroy(): void;
+    /**
+     * Get handler statistics
+     */
+    getStats(): {
+        activeConnections: number;
+        maxConnections: number;
+        uptime: number;
+    };
+}

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

@@ -0,0 +1,266 @@
+/**
+ * Phase 3: SSE Chat Utilities
+ * Server-Sent Events handler for real-time chat
+ */
+import { ChatSession } from "./session.js";
+export class SSEChatHandler {
+    connections = new Map();
+    provider;
+    options;
+    heartbeatInterval;
+    constructor(provider, options = {}) {
+        this.provider = provider;
+        this.options = {
+            maxConnections: options.maxConnections ?? 100,
+            heartbeatInterval: options.heartbeatInterval ?? 30000,
+            connectionTimeout: options.connectionTimeout ?? 300000,
+            enableCors: options.enableCors ?? true,
+            corsOrigins: options.corsOrigins ?? ["*"],
+        };
+        this.startHeartbeat();
+    }
+    /**
+     * Handle incoming chat request and return SSE response
+     */
+    async handleChatRequest(request) {
+        const { sessionId, message, options = {} } = request;
+        const session = new ChatSession(sessionId);
+        // Add user message to session
+        const userMessage = {
+            id: `msg_${Date.now()}_user`,
+            role: "user",
+            content: message,
+            timestamp: Date.now(),
+        };
+        session.addMessage(userMessage.role, userMessage.content);
+        // Create SSE stream
+        const stream = this.createEventStream(sessionId, async (writer) => {
+            try {
+                // Send initial event
+                await this.sendEvent(writer, {
+                    type: "data",
+                    data: { type: "start", sessionId, messageId: userMessage.id },
+                });
+                // Generate AI response with streaming
+                const aiResponse = await this.provider.streamText({
+                    prompt: message,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    systemPrompt: options.systemPrompt,
+                });
+                if (aiResponse?.textStream) {
+                    const reader = aiResponse.textStream.getReader();
+                    let fullResponse = "";
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            fullResponse += value;
+                            // Send chunk to client
+                            await this.sendEvent(writer, {
+                                type: "data",
+                                data: {
+                                    type: "chunk",
+                                    content: value,
+                                    sessionId,
+                                },
+                            });
+                        }
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                    // Add AI response to session
+                    const assistantMessage = {
+                        id: `msg_${Date.now()}_assistant`,
+                        role: "assistant",
+                        content: fullResponse,
+                        timestamp: Date.now(),
+                        metadata: {
+                            provider: this.provider.constructor.name || "unknown",
+                            model: "default",
+                        },
+                    };
+                    session.addMessage(assistantMessage.role, assistantMessage.content);
+                    // Send completion event
+                    await this.sendEvent(writer, {
+                        type: "complete",
+                        data: {
+                            type: "complete",
+                            sessionId,
+                            messageId: assistantMessage.id,
+                            totalTokens: fullResponse.length, // Rough estimate
+                        },
+                    });
+                }
+                // Persist session
+                await session.persist();
+            }
+            catch (error) {
+                await this.sendEvent(writer, {
+                    type: "error",
+                    data: {
+                        type: "error",
+                        message: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                    },
+                });
+            }
+        });
+        return new Response(stream, {
+            headers: this.getSSEHeaders(),
+        });
+    }
+    /**
+     * Create event stream for a session
+     */
+    createEventStream(sessionId, handler) {
+        const encoder = new TextEncoder();
+        return new ReadableStream({
+            start: async (controller) => {
+                // Check connection limits
+                if (this.connections.size >= this.options.maxConnections) {
+                    controller.error(new Error("Maximum connections exceeded"));
+                    return;
+                }
+                const { writable, readable } = new TransformStream();
+                const writer = writable.getWriter();
+                // Store connection
+                this.connections.set(sessionId, writer);
+                // Setup connection timeout
+                const timeout = setTimeout(() => {
+                    this.closeConnection(sessionId);
+                }, this.options.connectionTimeout);
+                try {
+                    if (handler) {
+                        await handler(writer);
+                    }
+                }
+                catch (error) {
+                    console.error("SSE Handler error:", error);
+                }
+                finally {
+                    clearTimeout(timeout);
+                    this.closeConnection(sessionId);
+                }
+                // Pipe the readable side to controller
+                const reader = readable.getReader();
+                const pump = async () => {
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                controller.close();
+                                break;
+                            }
+                            controller.enqueue(value);
+                        }
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                };
+                pump();
+            },
+            cancel: () => {
+                this.closeConnection(sessionId);
+            },
+        });
+    }
+    /**
+     * Send SSE event to client
+     */
+    async sendEvent(writer, event) {
+        const encoder = new TextEncoder();
+        let eventText = "";
+        if (event.id) {
+            eventText += `id: ${event.id}\n`;
+        }
+        if (event.retry) {
+            eventText += `retry: ${event.retry}\n`;
+        }
+        eventText += `event: ${event.type}\n`;
+        eventText += `data: ${JSON.stringify(event.data)}\n\n`;
+        await writer.write(encoder.encode(eventText));
+    }
+    /**
+     * Get SSE response headers
+     */
+    getSSEHeaders() {
+        const headers = {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        };
+        if (this.options.enableCors) {
+            headers["Access-Control-Allow-Origin"] =
+                this.options.corsOrigins.join(", ");
+            headers["Access-Control-Allow-Headers"] = "Cache-Control";
+        }
+        return headers;
+    }
+    /**
+     * Close connection and cleanup
+     */
+    async closeConnection(sessionId) {
+        const writer = this.connections.get(sessionId);
+        if (writer) {
+            try {
+                await writer.close();
+            }
+            catch (error) {
+                // Ignore close errors
+            }
+            this.connections.delete(sessionId);
+        }
+    }
+    /**
+     * Start heartbeat to keep connections alive
+     */
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(async () => {
+            const heartbeatEvent = {
+                type: "heartbeat",
+                data: { timestamp: Date.now() },
+            };
+            // Send heartbeat to all connections
+            for (const [sessionId, writer] of this.connections) {
+                try {
+                    await this.sendEvent(writer, heartbeatEvent);
+                }
+                catch (error) {
+                    // Remove failed connections
+                    this.closeConnection(sessionId);
+                }
+            }
+        }, this.options.heartbeatInterval);
+    }
+    /**
+     * Cleanup and stop handler
+     */
+    destroy() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        // Close all connections
+        for (const sessionId of this.connections.keys()) {
+            this.closeConnection(sessionId);
+        }
+        this.connections.clear();
+    }
+    /**
+     * Get handler statistics
+     */
+    getStats() {
+        return {
+            activeConnections: this.connections.size,
+            maxConnections: this.options.maxConnections,
+            uptime: process.uptime() * 1000,
+        };
+    }
+}