@juspay/neurolink 3.0.1 → 4.0.0

package/dist/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/chat/types.js

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

package/dist/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/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/cli/commands/config.js

@@ -11,6 +11,7 @@ import path from "path";
 import os from "os";
 import chalk from "chalk";
 import { z } from "zod";
+import { CLI_LIMITS } from "../../lib/core/constants.js";
 // Configuration schema for validation
 const ConfigSchema = z.object({
     defaultProvider: z
@@ -55,7 +56,7 @@ const ConfigSchema = z.object({
             serviceAccountKey: z.string().optional(),
             clientEmail: z.string().optional(),
             privateKey: z.string().optional(),
-            model: z.string().default("gemini-1.5-pro"),
+            model: z.string().default("gemini-2.5-pro"),
         })
             .optional(),
         anthropic: z
@@ -75,7 +76,7 @@ const ConfigSchema = z.object({
         "google-ai": z
             .object({
             apiKey: z.string().optional(),
-            model: z.string().default("gemini-1.5-pro-latest"),
+            model: z.string().default("gemini-2.5-pro"),
         })
             .optional(),
         huggingface: z
@@ -104,7 +105,11 @@ const ConfigSchema = z.object({
         .object({
         outputFormat: z.enum(["text", "json", "yaml"]).default("text"),
         temperature: z.number().min(0).max(2).default(0.7),
-        maxTokens: z.number().min(1).max(4000).default(1000),
+        maxTokens: z
+            .number()
+            .min(CLI_LIMITS.maxTokens.min)
+            .max(CLI_LIMITS.maxTokens.max)
+            .default(CLI_LIMITS.maxTokens.default),
         enableLogging: z.boolean().default(false),
         enableCaching: z.boolean().default(true),
         cacheStrategy: z.enum(["memory", "file", "redis"]).default("memory"),
@@ -399,8 +404,8 @@ export class ConfigManager {
                 type: "list",
                 name: "model",
                 message: "Default model:",
-                choices: ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"],
-                default: "gemini-1.5-pro",
+                choices: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-pro"],
+                default: "gemini-2.5-pro",
             },
         ]);
         let authConfig = {};
@@ -536,13 +541,8 @@ export class ConfigManager {
                 type: "list",
                 name: "model",
                 message: "Default model:",
-                choices: [
-                    "gemini-1.5-pro-latest",
-                    "gemini-2.0-flash-exp",
-                    "gemini-1.5-flash-latest",
-                    "gemini-1.0-pro",
-                ],
-                default: "gemini-1.5-pro-latest",
+                choices: ["gemini-2.5-pro", "gemini-2.5-flash"],
+                default: "gemini-2.5-pro",
             },
         ]);
         this.config.providers["google-ai"] = answers;

package/dist/cli/commands/mcp.js

@@ -828,10 +828,9 @@ export function addMCPCommands(yargs) {
                 console.log(chalk.green(`\n📋 Found ${filteredServers.length} servers:`));
                 console.log(chalk.gray("─".repeat(80)));
                 filteredServers.forEach((server, index) => {
-                    const sourceIcon = getSourceTypeIcon(server.source);
-                    const priorityColor = chalk.gray; // Default color
+                    const sourceIcon = getSourceTypeIcon(String(server.source || "unknown"));
                     console.log(`${chalk.white(`${index + 1}.`)} ${sourceIcon} ${chalk.cyan(server.metadata.name)}`);
-                    console.log(`   ${chalk.gray("Version:")} ${server.metadata.version}`);
+                    console.log(`   ${chalk.gray("Version:")} ${String(server.metadata.version || "unknown")}`);
                     console.log(`   ${chalk.gray("Source:")} ${server.source}`);
                     console.log(`   ${chalk.gray("Entry:")} ${server.entryPath}`);
                     if (server.metadata.description) {
@@ -843,7 +842,7 @@ export function addMCPCommands(yargs) {
                     }
                 });
                 // Display statistics
-                const stats = await unifiedRegistry.getStats();
+                const stats = await unifiedRegistry.getDetailedStats();
                 console.log(chalk.blue("📊 Registry Statistics:"));
                 console.log(`   ${chalk.gray("Total plugins:")} ${stats.total}`);
                 console.log(`   ${chalk.gray("Manual servers:")} ${stats.manual?.servers || 0}`);

package/dist/cli/index.d.ts

@@ -1,9 +1,2 @@
 #!/usr/bin/env node
-/**
- * NeuroLink CLI - Enhanced Simplified Approach
- *
- * Professional CLI experience with minimal maintenance overhead.
- * Features: Spinners, colors, batch processing, provider testing, rich help
- * Implementation: ~300 lines using simple JS utility functions
- */
 export {};