@juspay/neurolink 3.0.0 → 4.0.0

package/dist/lib/services/streaming/streaming-manager.js

@@ -0,0 +1,244 @@
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+export class StreamingManager extends EventEmitter {
+    activeSessions = new Map();
+    streamingPools = new Map();
+    metrics;
+    healthCheckInterval;
+    startTime;
+    constructor() {
+        super();
+        this.startTime = Date.now();
+        this.metrics = {
+            activeSessions: 0,
+            totalBytesTransferred: 0,
+            averageLatency: 0,
+            throughputBps: 0,
+            errorRate: 0,
+            connectionCount: 0,
+            uptime: 0,
+        };
+        this.startHealthMonitoring();
+    }
+    // Stream Lifecycle Management
+    async createStreamingSession(config) {
+        const sessionId = randomUUID();
+        const session = {
+            id: sessionId,
+            connectionId: config.provider, // Temporary, should be actual connection ID
+            provider: config.provider,
+            status: "active",
+            startTime: Date.now(),
+            lastActivity: Date.now(),
+            config,
+            metrics: {
+                bytesTransferred: 0,
+                messagesCount: 0,
+                averageLatency: 0,
+                errorCount: 0,
+            },
+        };
+        this.activeSessions.set(sessionId, session);
+        this.updateGlobalMetrics();
+        console.log(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
+        this.emit("session-created", session);
+        return session;
+    }
+    async terminateStreamingSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        session.status = "terminated";
+        this.activeSessions.delete(sessionId);
+        this.updateGlobalMetrics();
+        console.log(`[Streaming Manager] Terminated session ${sessionId}`);
+        this.emit("session-terminated", session);
+    }
+    async pauseStreamingSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        if (session.status === "active") {
+            session.status = "paused";
+            console.log(`[Streaming Manager] Paused session ${sessionId}`);
+            this.emit("session-paused", session);
+        }
+    }
+    async resumeStreamingSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        if (session.status === "paused") {
+            session.status = "active";
+            session.lastActivity = Date.now();
+            console.log(`[Streaming Manager] Resumed session ${sessionId}`);
+            this.emit("session-resumed", session);
+        }
+    }
+    // Stream Optimization
+    async optimizeStreamingLatency(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        // Adaptive optimization based on current metrics
+        const currentLatency = session.metrics.averageLatency;
+        const targetLatency = session.config.latencyTarget;
+        if (currentLatency > targetLatency * 1.2) {
+            // Increase buffer size for better throughput
+            session.config.bufferSize = Math.min(session.config.bufferSize * 1.5, 16384);
+            session.config.streamingMode = "buffered";
+        }
+        else if (currentLatency < targetLatency * 0.8) {
+            // Decrease buffer size for better latency
+            session.config.bufferSize = Math.max(session.config.bufferSize * 0.8, 1024);
+            session.config.streamingMode = "real-time";
+        }
+        console.log(`[Streaming Manager] Optimized session ${sessionId}: latency=${currentLatency}ms, mode=${session.config.streamingMode}`);
+    }
+    async enableStreamingCompression(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.config.compressionEnabled = true;
+        console.log(`[Streaming Manager] Enabled compression for session ${sessionId}`);
+    }
+    async configureStreamingBuffering(sessionId, bufferConfig) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.config.bufferSize = bufferConfig.maxSize;
+        session.config.maxChunkSize = Math.min(session.config.maxChunkSize, bufferConfig.flushThreshold);
+        console.log(`[Streaming Manager] Updated buffer config for session ${sessionId}:`, bufferConfig);
+    }
+    // Multi-Stream Coordination
+    async createStreamingPool(poolId, config) {
+        const pool = {
+            id: poolId,
+            maxSessions: config.maxConcurrentSessions,
+            activeSessions: new Set(),
+            config,
+            loadBalancer: config.loadBalancing,
+        };
+        this.streamingPools.set(poolId, pool);
+        console.log(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
+    }
+    async balanceStreamingLoad(poolId) {
+        const pool = this.streamingPools.get(poolId);
+        if (!pool) {
+            return;
+        }
+        const activeSessions = Array.from(pool.activeSessions)
+            .map((sessionId) => this.activeSessions.get(sessionId))
+            .filter((session) => session && session.status === "active");
+        // Implement load balancing strategies
+        switch (pool.loadBalancer) {
+            case "round-robin":
+                this.roundRobinBalance(activeSessions);
+                break;
+            case "least-connections":
+                this.leastConnectionsBalance(activeSessions);
+                break;
+            case "weighted":
+                this.weightedBalance(activeSessions);
+                break;
+            case "adaptive":
+                this.adaptiveBalance(activeSessions);
+                break;
+        }
+    }
+    async scaleStreamingCapacity(poolId, scale) {
+        const pool = this.streamingPools.get(poolId);
+        if (!pool) {
+            return;
+        }
+        const newMaxSessions = Math.max(1, Math.floor(pool.maxSessions * scale));
+        pool.maxSessions = newMaxSessions;
+        pool.config.maxConcurrentSessions = newMaxSessions;
+        console.log(`[Streaming Manager] Scaled pool ${poolId} to ${newMaxSessions} max sessions (${scale}x)`);
+    }
+    // Performance Monitoring
+    getStreamingMetrics(sessionId) {
+        if (sessionId) {
+            const session = this.activeSessions.get(sessionId);
+            if (session) {
+                return {
+                    sessionId,
+                    activeSessions: 1,
+                    totalBytesTransferred: session.metrics.bytesTransferred,
+                    averageLatency: session.metrics.averageLatency,
+                    throughputBps: session.metrics.bytesTransferred /
+                        ((Date.now() - session.startTime) / 1000),
+                    errorRate: session.metrics.errorCount /
+                        Math.max(session.metrics.messagesCount, 1),
+                    connectionCount: 1,
+                    uptime: Date.now() - session.startTime,
+                };
+            }
+        }
+        return { ...this.metrics, uptime: Date.now() - this.startTime };
+    }
+    getStreamingHealthStatus() {
+        const metrics = this.getStreamingMetrics();
+        const issues = [];
+        let status = "healthy";
+        if (metrics.errorRate > 0.1) {
+            issues.push(`High error rate: ${(metrics.errorRate * 100).toFixed(1)}%`);
+            status = "degraded";
+        }
+        if (metrics.averageLatency > 1000) {
+            issues.push(`High latency: ${metrics.averageLatency}ms`);
+            status = status === "healthy" ? "degraded" : "unhealthy";
+        }
+        if (metrics.activeSessions === 0 && this.activeSessions.size > 0) {
+            issues.push("Session count mismatch");
+            status = "unhealthy";
+        }
+        return {
+            status,
+            activeSessions: metrics.activeSessions,
+            errorRate: metrics.errorRate,
+            averageLatency: metrics.averageLatency,
+            lastHealthCheck: Date.now(),
+            issues,
+        };
+    }
+    // Private helper methods
+    updateGlobalMetrics() {
+        this.metrics.activeSessions = this.activeSessions.size;
+        this.metrics.connectionCount = this.activeSessions.size;
+    }
+    startHealthMonitoring() {
+        this.healthCheckInterval = setInterval(() => {
+            const health = this.getStreamingHealthStatus();
+            if (health.status !== "healthy") {
+                console.warn("[Streaming Manager] Health check:", health);
+                this.emit("health-warning", health);
+            }
+        }, 30000); // Check every 30 seconds
+    }
+    roundRobinBalance(sessions) {
+        // Round-robin implementation
+    }
+    leastConnectionsBalance(sessions) {
+        // Least connections implementation
+    }
+    weightedBalance(sessions) {
+        // Weighted load balancing implementation
+    }
+    adaptiveBalance(sessions) {
+        // Adaptive load balancing implementation
+    }
+    destroy() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+        }
+        this.activeSessions.clear();
+        this.streamingPools.clear();
+    }
+}

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

@@ -0,0 +1,155 @@
+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: any) => void;
+    onError: (error: Error) => void;
+    onClose: () => void;
+}
+export interface StreamingBuffer {
+    data: any[];
+    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: any;
+    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: Record<string, any>;
+}

package/dist/lib/services/types.js

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

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

@@ -0,0 +1,34 @@
+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;
+    private sendMessage;
+    private sendError;
+    private updateLastActivity;
+    private handleHeartbeat;
+    private handleChatMessage;
+    private startHeartbeat;
+    getConnectionCount(): number;
+    getRoomCount(): number;
+    getActiveChannels(): number;
+    close(): void;
+    private handleChannelData;
+    private handleChannelError;
+    private handleChannelClose;
+}