@juspay/neurolink 6.1.0 → 6.2.1

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

@@ -1,96 +0,0 @@
-/**
- * Phase 3: SSE Chat Utilities
- * Chat session management with persistence
- */
-import type { ChatMessage, SessionOptions, ChatSessionState } from "./types.js";
-import type { JsonValue } from "../types/common.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?: unknown): 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, JsonValue>;
-    /**
-     * Set session metadata
-     */
-    setMetadata(key: string, value: JsonValue): 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

@@ -1,257 +0,0 @@
-/**
- * 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: 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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,259 +0,0 @@
-/**
- * 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.stream({
-                    input: { text: message },
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt,
-                });
-                if (aiResponse?.stream) {
-                    // Iterate over the async iterable stream
-                    const reader = aiResponse.stream;
-                    let fullResponse = "";
-                    for await (const chunk of reader) {
-                        const content = chunk.content;
-                        fullResponse += content;
-                        // Send chunk to client
-                        await this.sendEvent(writer, {
-                            type: "data",
-                            data: {
-                                type: "chunk",
-                                content: content,
-                                sessionId,
-                            },
-                        });
-                    }
-                    // 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,
-        };
-    }
-}