@juspay/neurolink 6.0.0 → 6.2.0

package/dist/lib/services/types.d.ts

@@ -1,156 +0,0 @@
-import type { UnknownRecord, Unknown } from "../types/common.js";
-export interface StreamingSession {
-    id: string;
-    connectionId: string;
-    provider: string;
-    status: "active" | "paused" | "terminated";
-    startTime: number;
-    lastActivity: number;
-    config: StreamingConfig;
-    metrics: {
-        bytesTransferred: number;
-        messagesCount: number;
-        averageLatency: number;
-        errorCount: number;
-    };
-}
-export interface WebSocketOptions {
-    port?: number;
-    maxConnections?: number;
-    heartbeatInterval?: number;
-    enableCompression?: boolean;
-    enableBackpressure?: boolean;
-    bufferSize?: number;
-    timeoutMs?: number;
-}
-export interface StreamingConfig {
-    provider: string;
-    model: string;
-    streamingMode: "real-time" | "buffered" | "adaptive";
-    compressionEnabled: boolean;
-    maxChunkSize: number;
-    bufferSize: number;
-    latencyTarget: number;
-}
-export interface StreamingPool {
-    id: string;
-    maxSessions: number;
-    activeSessions: Set<string>;
-    config: StreamingPoolConfig;
-    loadBalancer: LoadBalancingStrategy;
-}
-export interface StreamingPoolConfig {
-    maxConcurrentSessions: number;
-    sessionTimeout: number;
-    loadBalancing: LoadBalancingStrategy;
-    autoScaling: {
-        enabled: boolean;
-        minSessions: number;
-        maxSessions: number;
-        scaleUpThreshold: number;
-        scaleDownThreshold: number;
-    };
-}
-export type LoadBalancingStrategy = "round-robin" | "least-connections" | "weighted" | "adaptive";
-export interface StreamingChannel {
-    id: string;
-    connectionId: string;
-    type: "ai-response" | "mcp-tool" | "chat" | "notification";
-    status: "open" | "closed" | "error";
-    buffer: StreamingBuffer;
-    onData: (data: Unknown) => void;
-    onError: (error: Error) => void;
-    onClose: () => void;
-}
-export interface StreamingBuffer {
-    data: Unknown[];
-    maxSize: number;
-    currentSize: number;
-    flushThreshold: number;
-    lastFlush: number;
-}
-export interface StreamingMetrics {
-    sessionId?: string;
-    activeSessions: number;
-    totalBytesTransferred: number;
-    averageLatency: number;
-    throughputBps: number;
-    errorRate: number;
-    connectionCount: number;
-    uptime: number;
-}
-export interface StreamingHealthStatus {
-    status: "healthy" | "degraded" | "unhealthy";
-    activeSessions: number;
-    errorRate: number;
-    averageLatency: number;
-    lastHealthCheck: number;
-    issues: string[];
-}
-export interface WebSocketMessage {
-    id: string;
-    type: "chat" | "ai-response" | "tool-result" | "system" | "heartbeat" | "error";
-    connectionId: string;
-    roomId?: string;
-    timestamp: number;
-    data: Unknown;
-    metadata?: {
-        provider?: string;
-        model?: string;
-        tokens?: number;
-        latency?: number;
-    };
-}
-export interface ChatRequest {
-    prompt: string;
-    sessionId?: string;
-    options?: {
-        temperature?: number;
-        maxTokens?: number;
-        streaming?: boolean;
-        enableTools?: boolean;
-    };
-}
-export interface GroupChatRequest extends ChatRequest {
-    roomId: string;
-    userId?: string;
-    broadcastToRoom?: boolean;
-}
-export interface StreamingChatRequest extends ChatRequest {
-    streamingOptions?: {
-        chunkSize?: number;
-        flushInterval?: number;
-        enableCompression?: boolean;
-    };
-}
-export interface MultiModalContent {
-    type: "text" | "image" | "audio" | "video" | "file";
-    content: string | Buffer;
-    metadata?: {
-        mimeType?: string;
-        size?: number;
-        duration?: number;
-        dimensions?: {
-            width: number;
-            height: number;
-        };
-    };
-}
-export interface BufferConfig {
-    maxSize: number;
-    flushThreshold: number;
-    flushInterval: number;
-    compressionEnabled: boolean;
-    persistToDisk: boolean;
-}
-export interface ConnectionInfo {
-    id: string;
-    userId?: string;
-    userAgent?: string;
-    ipAddress?: string;
-    connectedAt: number;
-    lastActivity: number;
-    rooms: Set<string>;
-    subscriptions: Set<string>;
-    metadata: UnknownRecord;
-}

package/dist/lib/services/types.js

@@ -1,2 +0,0 @@
-// Real-time Services Types
-export {};

package/dist/lib/services/websocket/websocket-server.d.ts

@@ -1,34 +0,0 @@
-import { EventEmitter } from "events";
-import type { WebSocketOptions, WebSocketMessage, StreamingChannel } from "../types.js";
-export declare class NeuroLinkWebSocketServer extends EventEmitter {
-    private wss;
-    private connections;
-    private connectionInfo;
-    private rooms;
-    private streamingChannels;
-    private heartbeatInterval?;
-    private options;
-    constructor(options?: WebSocketOptions);
-    private setupEventHandlers;
-    private handleConnection;
-    private handleMessage;
-    private handleDisconnection;
-    joinRoom(connectionId: string, roomId: string): boolean;
-    leaveRoom(connectionId: string, roomId: string): boolean;
-    broadcastToRoom(roomId: string, message: WebSocketMessage): void;
-    createStreamingChannel(connectionId: string, channelId: string): StreamingChannel;
-    destroyStreamingChannel(channelId: string): void;
-    sendMessage(connectionId: string, message: WebSocketMessage): boolean;
-    private sendError;
-    private updateLastActivity;
-    private handleHeartbeat;
-    private handleChatMessage;
-    private startHeartbeat;
-    getConnectionCount(): number;
-    getRoomCount(): number;
-    getActiveChannels(): number;
-    close(): void;
-    private handleChannelData;
-    private handleChannelError;
-    private handleChannelClose;
-}

package/dist/lib/services/websocket/websocket-server.js

@@ -1,305 +0,0 @@
-import { WebSocketServer, WebSocket } from "ws";
-import { EventEmitter } from "events";
-import { randomUUID } from "crypto";
-import { logger } from "../../utils/logger.js";
-export class NeuroLinkWebSocketServer extends EventEmitter {
-    wss;
-    connections = new Map();
-    connectionInfo = new Map();
-    rooms = new Map();
-    streamingChannels = new Map();
-    heartbeatInterval;
-    options;
-    constructor(options = {}) {
-        super();
-        this.options = {
-            port: options.port || 8080,
-            maxConnections: options.maxConnections || 1000,
-            heartbeatInterval: options.heartbeatInterval || 30000,
-            enableCompression: options.enableCompression ?? true,
-            enableBackpressure: options.enableBackpressure ?? true,
-            bufferSize: options.bufferSize || 8192,
-            timeoutMs: options.timeoutMs || 30000,
-        };
-        this.wss = new WebSocketServer({
-            port: this.options.port,
-            perMessageDeflate: this.options.enableCompression,
-        });
-        this.setupEventHandlers();
-        this.startHeartbeat();
-    }
-    setupEventHandlers() {
-        this.wss.on("connection", (ws, request) => {
-            this.handleConnection(ws, request);
-        });
-        this.wss.on("error", (error) => {
-            logger.error("[WebSocket Server] Error:", error);
-            this.emit("error", error);
-        });
-    }
-    handleConnection(ws, request) {
-        if (this.connections.size >= this.options.maxConnections) {
-            ws.close(1013, "Server at capacity");
-            return;
-        }
-        const connectionId = randomUUID();
-        const userAgent = request.headers["user-agent"];
-        const ipAddress = request.socket?.remoteAddress;
-        // Store connection
-        this.connections.set(connectionId, ws);
-        this.connectionInfo.set(connectionId, {
-            id: connectionId,
-            userAgent,
-            ipAddress,
-            connectedAt: Date.now(),
-            lastActivity: Date.now(),
-            rooms: new Set(),
-            subscriptions: new Set(),
-            metadata: {},
-        });
-        // Setup WebSocket event handlers
-        ws.on("message", (data) => {
-            this.handleMessage(connectionId, data);
-        });
-        ws.on("close", () => {
-            this.handleDisconnection(connectionId);
-        });
-        ws.on("error", (error) => {
-            logger.error(`[WebSocket] Connection ${connectionId} error:`, error);
-            this.handleDisconnection(connectionId);
-        });
-        // Send connection confirmation
-        this.sendMessage(connectionId, {
-            id: randomUUID(),
-            type: "system",
-            connectionId,
-            timestamp: Date.now(),
-            data: {
-                event: "connected",
-                connectionId,
-                serverInfo: {
-                    version: "3.0.1",
-                    features: ["streaming", "rooms", "tools"],
-                },
-            },
-        });
-        logger.debug(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
-        this.emit("connection", { connectionId, userAgent, ipAddress });
-    }
-    handleMessage(connectionId, data) {
-        try {
-            const message = JSON.parse(data.toString());
-            this.updateLastActivity(connectionId);
-            switch (message.type) {
-                case "heartbeat":
-                    this.handleHeartbeat(connectionId);
-                    break;
-                case "chat":
-                    this.handleChatMessage(connectionId, message);
-                    break;
-                default:
-                    this.emit("message", { connectionId, message });
-            }
-        }
-        catch (error) {
-            logger.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
-            this.sendError(connectionId, "Invalid message format");
-        }
-    }
-    handleDisconnection(connectionId) {
-        const connection = this.connectionInfo.get(connectionId);
-        if (!connection) {
-            return;
-        }
-        // Leave all rooms
-        connection.rooms.forEach((roomId) => {
-            this.leaveRoom(connectionId, roomId);
-        });
-        // Close streaming channels
-        this.streamingChannels.forEach((channel, channelId) => {
-            if (channel.connectionId === connectionId) {
-                channel.onClose();
-                this.streamingChannels.delete(channelId);
-            }
-        });
-        // Clean up
-        this.connections.delete(connectionId);
-        this.connectionInfo.delete(connectionId);
-        logger.debug(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
-        this.emit("disconnection", { connectionId });
-    }
-    // Room Management
-    joinRoom(connectionId, roomId) {
-        const connection = this.connectionInfo.get(connectionId);
-        if (!connection) {
-            return false;
-        }
-        if (!this.rooms.has(roomId)) {
-            this.rooms.set(roomId, new Set());
-        }
-        this.rooms.get(roomId).add(connectionId);
-        connection.rooms.add(roomId);
-        this.sendMessage(connectionId, {
-            id: randomUUID(),
-            type: "system",
-            connectionId,
-            roomId,
-            timestamp: Date.now(),
-            data: {
-                event: "room_joined",
-                roomId,
-                memberCount: this.rooms.get(roomId).size,
-            },
-        });
-        logger.debug(`[WebSocket] ${connectionId} joined room ${roomId}`);
-        return true;
-    }
-    leaveRoom(connectionId, roomId) {
-        const connection = this.connectionInfo.get(connectionId);
-        if (!connection) {
-            return false;
-        }
-        const room = this.rooms.get(roomId);
-        if (!room) {
-            return false;
-        }
-        room.delete(connectionId);
-        connection.rooms.delete(roomId);
-        if (room.size === 0) {
-            this.rooms.delete(roomId);
-        }
-        this.sendMessage(connectionId, {
-            id: randomUUID(),
-            type: "system",
-            connectionId,
-            roomId,
-            timestamp: Date.now(),
-            data: {
-                event: "room_left",
-                roomId,
-                memberCount: room.size,
-            },
-        });
-        logger.debug(`[WebSocket] ${connectionId} left room ${roomId}`);
-        return true;
-    }
-    broadcastToRoom(roomId, message) {
-        const room = this.rooms.get(roomId);
-        if (!room) {
-            return;
-        }
-        room.forEach((connectionId) => {
-            this.sendMessage(connectionId, { ...message, roomId });
-        });
-    }
-    // Streaming Support
-    createStreamingChannel(connectionId, channelId) {
-        const channel = {
-            id: channelId,
-            connectionId,
-            type: "ai-response",
-            status: "open",
-            buffer: {
-                data: [],
-                maxSize: this.options.bufferSize,
-                currentSize: 0,
-                flushThreshold: Math.floor(this.options.bufferSize * 0.8),
-                lastFlush: Date.now(),
-            },
-            onData: (data) => this.handleChannelData(channelId, data),
-            onError: (error) => this.handleChannelError(channelId, error),
-            onClose: () => this.handleChannelClose(channelId),
-        };
-        this.streamingChannels.set(channelId, channel);
-        return channel;
-    }
-    destroyStreamingChannel(channelId) {
-        const channel = this.streamingChannels.get(channelId);
-        if (channel) {
-            channel.status = "closed";
-            channel.onClose();
-            this.streamingChannels.delete(channelId);
-        }
-    }
-    // Helper methods
-    sendMessage(connectionId, message) {
-        const ws = this.connections.get(connectionId);
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            return false;
-        }
-        try {
-            ws.send(JSON.stringify(message));
-            return true;
-        }
-        catch (error) {
-            logger.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
-            return false;
-        }
-    }
-    sendError(connectionId, errorMessage) {
-        this.sendMessage(connectionId, {
-            id: randomUUID(),
-            type: "error",
-            connectionId,
-            timestamp: Date.now(),
-            data: { error: errorMessage },
-        });
-    }
-    updateLastActivity(connectionId) {
-        const connection = this.connectionInfo.get(connectionId);
-        if (connection) {
-            connection.lastActivity = Date.now();
-        }
-    }
-    handleHeartbeat(connectionId) {
-        this.sendMessage(connectionId, {
-            id: randomUUID(),
-            type: "heartbeat",
-            connectionId,
-            timestamp: Date.now(),
-            data: { pong: true },
-        });
-    }
-    handleChatMessage(connectionId, message) {
-        this.emit("chat-message", { connectionId, message });
-    }
-    startHeartbeat() {
-        this.heartbeatInterval = setInterval(() => {
-            this.connections.forEach((ws, connectionId) => {
-                if (ws.readyState === WebSocket.OPEN) {
-                    const connection = this.connectionInfo.get(connectionId);
-                    if (connection &&
-                        Date.now() - connection.lastActivity > this.options.timeoutMs) {
-                        logger.debug(`[WebSocket] Timeout for connection ${connectionId}`);
-                        ws.terminate();
-                    }
-                }
-            });
-        }, this.options.heartbeatInterval);
-    }
-    // Public getters
-    getConnectionCount() {
-        return this.connections.size;
-    }
-    getRoomCount() {
-        return this.rooms.size;
-    }
-    getActiveChannels() {
-        return this.streamingChannels.size;
-    }
-    close() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-        }
-        this.wss.close();
-    }
-    handleChannelData(channelId, data) {
-        // Implementation for channel data handling
-    }
-    handleChannelError(channelId, error) {
-        logger.error(`[Streaming Channel] ${channelId} error:`, error);
-    }
-    handleChannelClose(channelId) {
-        logger.debug(`[Streaming Channel] ${channelId} closed`);
-    }
-}

package/dist/lib/utils/provider-validation.d.ts

@@ -1,36 +0,0 @@
-/**
- * Enhanced Provider Validation Utilities
- *
- * Fixes false positives in provider status checking by implementing:
- * - API key format validation
- * - Lightweight authentication checks
- * - Proper error classification
- * - Rate-limit friendly validation
- */
-import type { UnknownRecord } from "../types/common.js";
-export interface ProviderValidationResult {
-    configured: boolean;
-    formatValid: boolean;
-    authenticated: boolean;
-    available: boolean;
-    error?: string;
-    errorType?: "config" | "format" | "auth" | "network" | "quota" | "unknown";
-    responseTime?: number;
-    details?: UnknownRecord;
-}
-/**
- * Validate API key format for a specific provider
- */
-export declare function validateApiKeyFormat(provider: string, apiKey: string): boolean;
-/**
- * Comprehensive provider validation that prevents false positives
- */
-export declare function validateProvider(provider: string): Promise<ProviderValidationResult>;
-/**
- * Batch validate multiple providers efficiently
- */
-export declare function validateProviders(providers: string[]): Promise<Record<string, ProviderValidationResult>>;
-/**
- * Check if provider validation should be cached (to avoid rate limits)
- */
-export declare function shouldCacheValidation(result: ProviderValidationResult): boolean;