@juspay/neurolink 3.0.1 → 4.1.0

package/dist/providers/openAI.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult, type LanguageModelV1 } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 export declare class OpenAI implements AIProvider {
     private modelName;
     private model;
@@ -11,4 +11,18 @@ export declare class OpenAI implements AIProvider {
     getModel(): LanguageModelV1;
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/providers/openAI.js

@@ -2,6 +2,9 @@ import { openai } from "@ai-sdk/openai";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, getDefaultTimeout, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
+import { createAnalytics } from "../core/analytics.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -60,7 +63,7 @@ export class OpenAI {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream text started`, {
@@ -152,12 +155,13 @@ export class OpenAI {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "OpenAI.generateText";
         const provider = "openai";
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -198,6 +202,15 @@ export class OpenAI {
                     responseLength: result.text?.length || 0,
                     timeout,
                 });
+                // Add analytics if enabled
+                if (options.enableAnalytics) {
+                    const { createAnalytics } = await import("./analytics-helper.js");
+                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
+                }
+                // Add evaluation if enabled
+                if (options.enableEvaluation) {
+                    result.evaluation = await evaluateResponse(prompt, result.text, options.context, options.evaluationDomain, options.toolUsageContext, options.conversationHistory);
+                }
                 return result;
             }
             finally {
@@ -226,4 +239,22 @@ export class OpenAI {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

package/dist/proxy/proxy-fetch.js

@@ -2,6 +2,7 @@
  * Proxy-aware fetch implementation for AI SDK providers
  * Implements the proven Vercel AI SDK proxy pattern using undici
  */
+import { logger } from "../utils/logger.js";
 /**
  * Create a proxy-aware fetch function
  * This implements the community-validated approach for Vercel AI SDK
@@ -11,12 +12,12 @@ export function createProxyFetch() {
     const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
     // If no proxy configured, return standard fetch
     if (!httpsProxy && !httpProxy) {
-        console.log("[Proxy Fetch] No proxy environment variables found - using standard fetch");
+        logger.debug("[Proxy Fetch] No proxy environment variables found - using standard fetch");
         return fetch;
     }
-    console.log(`[Proxy Fetch] Configuring proxy with undici ProxyAgent:`);
-    console.log(`[Proxy Fetch] HTTP_PROXY: ${httpProxy || "not set"}`);
-    console.log(`[Proxy Fetch] HTTPS_PROXY: ${httpsProxy || "not set"}`);
+    logger.debug(`[Proxy Fetch] Configuring proxy with undici ProxyAgent`);
+    logger.debug(`[Proxy Fetch] HTTP_PROXY: ${httpProxy || "not set"}`);
+    logger.debug(`[Proxy Fetch] HTTPS_PROXY: ${httpsProxy || "not set"}`);
     // Return proxy-aware fetch function
     return async (input, init) => {
         try {
@@ -30,7 +31,7 @@ export function createProxyFetch() {
                     : new URL(input.url);
             const proxyUrl = url.protocol === "https:" ? httpsProxy : httpProxy;
             if (proxyUrl) {
-                console.log(`[Proxy Fetch] Creating ProxyAgent for ${url.hostname} via ${proxyUrl}`);
+                logger.debug(`[Proxy Fetch] Creating ProxyAgent for ${url.hostname} via ${proxyUrl}`);
                 // Create ProxyAgent
                 const dispatcher = new ProxyAgent(proxyUrl);
                 // Use undici fetch with dispatcher
@@ -38,12 +39,12 @@ export function createProxyFetch() {
                     ...init,
                     dispatcher: dispatcher,
                 });
-                console.log(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
+                logger.debug(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
                 return response; // Type assertion to avoid complex type issues
             }
         }
         catch (error) {
-            console.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
+            logger.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
         }
         // Fallback to standard fetch
         return fetch(input, init);

package/dist/services/streaming/streaming-manager.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from "events";
+import type { StreamingSession, StreamingConfig, StreamingPoolConfig, StreamingMetrics, StreamingHealthStatus, BufferConfig } from "../types.js";
+export declare class StreamingManager extends EventEmitter {
+    private activeSessions;
+    private streamingPools;
+    private metrics;
+    private healthCheckInterval?;
+    private startTime;
+    constructor();
+    createStreamingSession(config: StreamingConfig): Promise<StreamingSession>;
+    terminateStreamingSession(sessionId: string): Promise<void>;
+    pauseStreamingSession(sessionId: string): Promise<void>;
+    resumeStreamingSession(sessionId: string): Promise<void>;
+    optimizeStreamingLatency(sessionId: string): Promise<void>;
+    enableStreamingCompression(sessionId: string): Promise<void>;
+    configureStreamingBuffering(sessionId: string, bufferConfig: BufferConfig): Promise<void>;
+    createStreamingPool(poolId: string, config: StreamingPoolConfig): Promise<void>;
+    balanceStreamingLoad(poolId: string): Promise<void>;
+    scaleStreamingCapacity(poolId: string, scale: number): Promise<void>;
+    getStreamingMetrics(sessionId?: string): StreamingMetrics;
+    getStreamingHealthStatus(): StreamingHealthStatus;
+    private updateGlobalMetrics;
+    private startHealthMonitoring;
+    private roundRobinBalance;
+    private leastConnectionsBalance;
+    private weightedBalance;
+    private adaptiveBalance;
+    destroy(): void;
+}

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