@juspay/neurolink 3.0.1 → 4.0.0

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

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

package/dist/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;
+}

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

@@ -0,0 +1,304 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+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) => {
+            console.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) => {
+            console.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"],
+                },
+            },
+        });
+        console.log(`[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) {
+            console.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);
+        console.log(`[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,
+            },
+        });
+        console.log(`[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,
+            },
+        });
+        console.log(`[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) {
+            console.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) {
+                        console.log(`[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) {
+        console.error(`[Streaming Channel] ${channelId} error:`, error);
+    }
+    handleChannelClose(channelId) {
+        console.log(`[Streaming Channel] ${channelId} closed`);
+    }
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,15 @@
+export { TelemetryService, type HealthMetrics } from "./telemetry-service.js";
+/**
+ * Initialize telemetry for NeuroLink
+ * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ */
+export declare function initializeTelemetry(): Promise<import("./telemetry-service.js").TelemetryService>;
+/**
+ * Get telemetry status
+ */
+export declare function getTelemetryStatus(): Promise<{
+    enabled: boolean;
+    endpoint?: string;
+    service?: string;
+    version?: string;
+}>;

package/dist/telemetry/index.js

@@ -0,0 +1,22 @@
+// Optional Telemetry Infrastructure (Phase 2)
+export { TelemetryService } from "./telemetry-service.js";
+/**
+ * Initialize telemetry for NeuroLink
+ * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ */
+export async function initializeTelemetry() {
+    const { TelemetryService } = await import("./telemetry-service.js");
+    const telemetry = TelemetryService.getInstance();
+    if (telemetry.isEnabled()) {
+        await telemetry.initialize();
+        console.log("[NeuroLink] Telemetry initialized");
+    }
+    return telemetry;
+}
+/**
+ * Get telemetry status
+ */
+export async function getTelemetryStatus() {
+    const { TelemetryService } = await import("./telemetry-service.js");
+    return TelemetryService.getInstance().getStatus();
+}

package/dist/telemetry/telemetry-service.d.ts

@@ -0,0 +1,47 @@
+export interface HealthMetrics {
+    timestamp: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    uptime: number;
+    activeConnections: number;
+    errorRate: number;
+    averageResponseTime: number;
+}
+export declare class TelemetryService {
+    private static instance;
+    private sdk?;
+    private enabled;
+    private meter?;
+    private tracer?;
+    private aiRequestCounter?;
+    private aiRequestDuration?;
+    private aiTokensUsed?;
+    private aiProviderErrors?;
+    private mcpToolCalls?;
+    private connectionCounter?;
+    private responseTimeHistogram?;
+    private constructor();
+    static getInstance(): TelemetryService;
+    private isTelemetryEnabled;
+    private initializeTelemetry;
+    private initializeMetrics;
+    initialize(): Promise<void>;
+    traceAIRequest<T>(provider: string, operation: () => Promise<T>): Promise<T>;
+    recordAIRequest(provider: string, model: string, tokens: number, duration: number): void;
+    recordAIError(provider: string, error: Error): void;
+    recordMCPToolCall(toolName: string, duration: number, success: boolean): void;
+    recordConnection(type: "websocket" | "sse" | "http"): void;
+    recordResponseTime(endpoint: string, method: string, duration: number): void;
+    recordCustomMetric(name: string, value: number, labels?: Record<string, string>): void;
+    recordCustomHistogram(name: string, value: number, labels?: Record<string, string>): void;
+    getHealthMetrics(): Promise<HealthMetrics>;
+    isEnabled(): boolean;
+    getStatus(): {
+        enabled: boolean;
+        endpoint?: string;
+        service?: string;
+        version?: string;
+    };
+    private getDurationBucket;
+    private getStatusBucket;
+    shutdown(): Promise<void>;
+}