@juspay/neurolink 6.0.0 → 6.2.0

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

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

package/dist/lib/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/lib/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/lib/core/defaults.d.ts

@@ -1,19 +0,0 @@
-/**
- * Default value helper functions for NeuroLink
- * Centralized logic for applying defaults across the system
- */
-import type { UnknownRecord } from "../types/common.js";
-/**
- * Apply default values to options object
- * User-provided values take precedence over defaults
- */
-export declare function applyDefaults(options: UnknownRecord): UnknownRecord;
-/**
- * Get default max tokens for a specific provider
- * Can be extended for provider-specific overrides in the future
- */
-export declare function getDefaultMaxTokens(provider?: string): number;
-/**
- * Get default temperature for a specific use case
- */
-export declare function getDefaultTemperature(useCase?: string): number;

package/dist/lib/core/defaults.js

@@ -1,29 +0,0 @@
-/**
- * Default value helper functions for NeuroLink
- * Centralized logic for applying defaults across the system
- */
-import { ENV_DEFAULTS, } from "./constants.js";
-/**
- * Apply default values to options object
- * User-provided values take precedence over defaults
- */
-export function applyDefaults(options) {
-    return {
-        maxTokens: ENV_DEFAULTS.maxTokens,
-        temperature: ENV_DEFAULTS.temperature,
-        ...options, // User overrides take precedence
-    };
-}
-/**
- * Get default max tokens for a specific provider
- * Can be extended for provider-specific overrides in the future
- */
-export function getDefaultMaxTokens(provider) {
-    return ENV_DEFAULTS.maxTokens;
-}
-/**
- * Get default temperature for a specific use case
- */
-export function getDefaultTemperature(useCase) {
-    return ENV_DEFAULTS.temperature;
-}

package/dist/lib/core/evaluation-config.d.ts

@@ -1,29 +0,0 @@
-import type { EvaluationConfig } from "./types.js";
-/**
- * Parse evaluation configuration from environment variables
- */
-export declare function parseEvaluationConfig(): EvaluationConfig;
-/**
- * Get intelligent provider fallback order
- */
-export declare function getProviderFallbackOrder(config: EvaluationConfig): string[];
-/**
- * Estimate evaluation cost
- */
-export declare function estimateEvaluationCost(providerName: string, mode: string, promptLength: number, expectedResponseLength?: number): number;
-/**
- * Validate evaluation configuration
- */
-export declare function validateEvaluationConfig(config: EvaluationConfig): string[];
-/**
- * Get configuration with validation and defaults
- */
-export declare function getValidatedEvaluationConfig(): EvaluationConfig;
-/**
- * Check if evaluation is enabled for the current configuration
- */
-export declare function isEvaluationEnabled(): boolean;
-/**
- * Get cost-optimized provider based on configuration
- */
-export declare function getCostOptimizedProvider(config: EvaluationConfig): string | null;

package/dist/lib/core/evaluation-config.js

@@ -1,144 +0,0 @@
-import { getAvailableProviders, sortProvidersByPreference, getProviderConfig, } from "./evaluation-providers.js";
-import { logger } from "../utils/logger.js";
-/**
- * Parse evaluation configuration from environment variables
- */
-export function parseEvaluationConfig() {
-    return {
-        provider: process.env.NEUROLINK_EVALUATION_PROVIDER || "google-ai",
-        model: process.env.NEUROLINK_EVALUATION_MODEL || "gemini-2.5-flash",
-        mode: process.env.NEUROLINK_EVALUATION_MODE || "fast",
-        fallbackEnabled: process.env.NEUROLINK_EVALUATION_FALLBACK_ENABLED !== "false",
-        fallbackProviders: (process.env.NEUROLINK_EVALUATION_FALLBACK_PROVIDERS ||
-            "openai,anthropic,vertex,bedrock").split(","),
-        timeout: parseInt(process.env.NEUROLINK_EVALUATION_TIMEOUT || "10000"),
-        maxTokens: parseInt(process.env.NEUROLINK_EVALUATION_MAX_TOKENS || "500"),
-        temperature: parseFloat(process.env.NEUROLINK_EVALUATION_TEMPERATURE || "0.1"),
-        preferCheap: process.env.NEUROLINK_EVALUATION_PREFER_CHEAP !== "false",
-        maxCostPerEval: parseFloat(process.env.NEUROLINK_EVALUATION_MAX_COST_PER_EVAL || "0.01"),
-        retryAttempts: parseInt(process.env.NEUROLINK_EVALUATION_RETRY_ATTEMPTS || "2"),
-    };
-}
-/**
- * Get intelligent provider fallback order
- */
-export function getProviderFallbackOrder(config) {
-    const available = getAvailableProviders();
-    const sorted = sortProvidersByPreference(available, config.preferCheap);
-    // Start with user's preferred provider
-    const fallbackOrder = [config.provider];
-    // Add configured fallbacks
-    config.fallbackProviders.forEach((provider) => {
-        if (!fallbackOrder.includes(provider)) {
-            fallbackOrder.push(provider);
-        }
-    });
-    // Add remaining available providers
-    sorted.forEach((providerConfig) => {
-        if (!fallbackOrder.includes(providerConfig.provider)) {
-            fallbackOrder.push(providerConfig.provider);
-        }
-    });
-    logger.debug("[EvaluationConfig] Provider fallback order:", fallbackOrder);
-    return fallbackOrder;
-}
-/**
- * Estimate evaluation cost
- */
-export function estimateEvaluationCost(providerName, mode, promptLength, expectedResponseLength = 200) {
-    const config = getProviderConfig(providerName);
-    if (!config || !config.costPerToken) {
-        return 0;
-    }
-    const inputTokens = Math.ceil(promptLength / 4); // Rough token estimation
-    const outputTokens = expectedResponseLength / 4;
-    return (inputTokens * config.costPerToken.input +
-        outputTokens * config.costPerToken.output);
-}
-/**
- * Validate evaluation configuration
- */
-export function validateEvaluationConfig(config) {
-    const errors = [];
-    // Validate provider
-    if (!getProviderConfig(config.provider)) {
-        errors.push(`Invalid provider: ${config.provider}`);
-    }
-    // Validate mode
-    if (!["fast", "balanced", "quality"].includes(config.mode)) {
-        errors.push(`Invalid mode: ${config.mode}. Must be 'fast', 'balanced', or 'quality'`);
-    }
-    // Validate timeout
-    if (config.timeout <= 0 || config.timeout > 60000) {
-        errors.push(`Invalid timeout: ${config.timeout}. Must be between 1 and 60000ms`);
-    }
-    // Validate max tokens
-    if (config.maxTokens <= 0 || config.maxTokens > 4000) {
-        errors.push(`Invalid maxTokens: ${config.maxTokens}. Must be between 1 and 4000`);
-    }
-    // Validate temperature
-    if (config.temperature < 0 || config.temperature > 2) {
-        errors.push(`Invalid temperature: ${config.temperature}. Must be between 0 and 2`);
-    }
-    // Validate max cost
-    if (config.maxCostPerEval <= 0) {
-        errors.push(`Invalid maxCostPerEval: ${config.maxCostPerEval}. Must be greater than 0`);
-    }
-    // Validate retry attempts
-    if (config.retryAttempts < 0 || config.retryAttempts > 5) {
-        errors.push(`Invalid retryAttempts: ${config.retryAttempts}. Must be between 0 and 5`);
-    }
-    return errors;
-}
-/**
- * Get configuration with validation and defaults
- */
-export function getValidatedEvaluationConfig() {
-    const config = parseEvaluationConfig();
-    const errors = validateEvaluationConfig(config);
-    if (errors.length > 0) {
-        logger.warn("[EvaluationConfig] Configuration validation errors:", errors);
-        // Return default configuration if validation fails
-        return {
-            provider: "google-ai",
-            model: "gemini-2.5-flash",
-            mode: "fast",
-            fallbackEnabled: true,
-            fallbackProviders: ["openai", "anthropic"],
-            timeout: 10000,
-            maxTokens: 500,
-            temperature: 0.1,
-            preferCheap: true,
-            maxCostPerEval: 0.01,
-            retryAttempts: 2,
-        };
-    }
-    return config;
-}
-/**
- * Check if evaluation is enabled for the current configuration
- */
-export function isEvaluationEnabled() {
-    // Check if at least one provider is available
-    const available = getAvailableProviders();
-    return available.length > 0;
-}
-/**
- * Get cost-optimized provider based on configuration
- */
-export function getCostOptimizedProvider(config) {
-    const available = getAvailableProviders();
-    if (available.length === 0) {
-        return null;
-    }
-    const sorted = sortProvidersByPreference(available, true); // Always prefer cheap for cost optimization
-    // Find the cheapest provider that meets cost requirements
-    for (const providerConfig of sorted) {
-        const estimatedCost = estimateEvaluationCost(providerConfig.provider, config.mode, 1000);
-        if (estimatedCost <= config.maxCostPerEval) {
-            return providerConfig.provider;
-        }
-    }
-    // If no provider meets cost requirements, return the cheapest one
-    return sorted[0].provider;
-}

package/dist/lib/factories/compatibility-factory.d.ts

@@ -1,35 +0,0 @@
-import type { GenerateOptions, GenerateResult } from "../types/generate-types.js";
-import type { TextGenerationOptions } from "../core/types.js";
-/**
- * Compatibility conversion factory for seamless migration
- * between generateText and generate functions
- */
-export declare class CompatibilityConversionFactory {
-    /**
-     * Convert TextGenerationOptions to GenerateOptions
-     */
-    static convertTextToGenerate(options: TextGenerationOptions): GenerateOptions;
-    /**
-     * Convert GenerateResult to legacy TextGenerationResult format
-     */
-    static convertGenerateToText(result: GenerateResult): {
-        content: string;
-        provider?: string;
-        model?: string;
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-        };
-        responseTime?: number;
-        toolsUsed?: number;
-        toolExecutions?: unknown[];
-        analytics?: unknown;
-        evaluation?: unknown;
-        [key: string]: unknown;
-    };
-    /**
-     * Convert GenerateOptions to TextGenerationOptions
-     */
-    static convertGenerateToText_Options(options: GenerateOptions): TextGenerationOptions;
-}