@juspay/neurolink 6.1.0 → 6.2.1

package/dist/chat/types.d.ts

@@ -1,74 +0,0 @@
-/**
- * Phase 3: SSE Chat Utilities
- * Type definitions for chat infrastructure
- */
-import type { JsonValue } from "../types/common.js";
-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: JsonValue;
-    id?: string;
-    retry?: number;
-}
-export interface ChatSessionState {
-    id: string;
-    messages: ChatMessage[];
-    createdAt: number;
-    lastActivity: number;
-    metadata?: Record<string, JsonValue>;
-}
-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

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

package/dist/chat/websocket-chat-handler.d.ts

@@ -1,37 +0,0 @@
-import { SSEChatHandler } from "./sse-handler.js";
-import type { AIProvider } from "../core/types.js";
-import type { WebSocketOptions, GroupChatRequest, StreamingChatRequest } from "../services/types.js";
-import type { SSEOptions, ChatRequest } from "./types.js";
-import type { UnknownRecord } from "../types/common.js";
-export interface WebSocketChatOptions {
-    sseOptions?: UnknownRecord;
-    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

@@ -1,262 +0,0 @@
-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.generate({
-                prompt: request.message,
-                temperature: request.options?.temperature,
-                maxTokens: request.options?.maxTokens,
-            });
-            if (!result || !result.content) {
-                throw new Error("Invalid AI response");
-            }
-            // Send response via WebSocket
-            const responseMessage = {
-                id: randomUUID(),
-                type: "ai-response",
-                connectionId,
-                timestamp: Date.now(),
-                data: {
-                    text: result.content,
-                    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.generate({
-                prompt: request.prompt,
-                temperature: request.options?.temperature,
-                maxTokens: request.options?.maxTokens,
-            });
-            if (!result || !result.content) {
-                throw new Error("Invalid AI response");
-            }
-            // Broadcast to room
-            const broadcastMessage = {
-                id: randomUUID(),
-                type: "ai-response",
-                connectionId: "system",
-                timestamp: Date.now(),
-                data: {
-                    text: result.content,
-                    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.generate({
-                prompt: request.prompt,
-                ...request.options,
-            });
-            if (!result || !result.content) {
-                throw new Error("Invalid AI response");
-            }
-            // Send complete response
-            const responseMessage = {
-                id: randomUUID(),
-                type: "ai-response",
-                connectionId,
-                timestamp: Date.now(),
-                data: {
-                    text: result.content,
-                    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 public send method
-        this.wsServer.sendMessage(connectionId, 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) {
-        const data = message.data;
-        if (!data || typeof data !== "object") {
-            return;
-        }
-        switch (data.event) {
-            case "chat_request":
-                this.handleWebSocketChatRequest(connectionId, data.request);
-                break;
-            case "join_room":
-                this.wsServer.joinRoom(connectionId, data.roomId);
-                break;
-            case "leave_room":
-                this.wsServer.leaveRoom(connectionId, data.roomId);
-                break;
-            case "typing_start":
-                this.showTypingIndicator(connectionId, 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/mcp.d.ts

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP Server Management Commands
- * Real MCP server connectivity and management
- */
-import type { Argv } from "yargs";
-import type { JsonValue } from "../../lib/types/common.js";
-interface MCPServerConfig {
-    name: string;
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    transport: "stdio" | "sse";
-    url?: string;
-}
-export declare function executeMCPTool(serverConfig: MCPServerConfig, toolName: string, toolParams: JsonValue): Promise<JsonValue>;
-export declare function mcpExecuteTool(serverName: string, toolName: string, toolParams: JsonValue): Promise<JsonValue>;
-export declare function addMCPCommands(yargs: Argv): Argv;
-export {};