@juspay/neurolink 5.2.0 → 6.0.0

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

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { logger } from "../../utils/logger.js";
 export class StreamingManager extends EventEmitter {
     activeSessions = new Map();
     streamingPools = new Map();
@@ -40,7 +41,7 @@ export class StreamingManager extends EventEmitter {
         };
         this.activeSessions.set(sessionId, session);
         this.updateGlobalMetrics();
-        console.log(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
+        logger.debug(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
         this.emit("session-created", session);
         return session;
     }
@@ -52,7 +53,7 @@ export class StreamingManager extends EventEmitter {
         session.status = "terminated";
         this.activeSessions.delete(sessionId);
         this.updateGlobalMetrics();
-        console.log(`[Streaming Manager] Terminated session ${sessionId}`);
+        logger.debug(`[Streaming Manager] Terminated session ${sessionId}`);
         this.emit("session-terminated", session);
     }
     async pauseStreamingSession(sessionId) {
@@ -62,7 +63,7 @@ export class StreamingManager extends EventEmitter {
         }
         if (session.status === "active") {
             session.status = "paused";
-            console.log(`[Streaming Manager] Paused session ${sessionId}`);
+            logger.debug(`[Streaming Manager] Paused session ${sessionId}`);
             this.emit("session-paused", session);
         }
     }
@@ -74,7 +75,7 @@ export class StreamingManager extends EventEmitter {
         if (session.status === "paused") {
             session.status = "active";
             session.lastActivity = Date.now();
-            console.log(`[Streaming Manager] Resumed session ${sessionId}`);
+            logger.debug(`[Streaming Manager] Resumed session ${sessionId}`);
             this.emit("session-resumed", session);
         }
     }
@@ -97,7 +98,7 @@ export class StreamingManager extends EventEmitter {
             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}`);
+        logger.debug(`[Streaming Manager] Optimized session ${sessionId}: latency=${currentLatency}ms, mode=${session.config.streamingMode}`);
     }
     async enableStreamingCompression(sessionId) {
         const session = this.activeSessions.get(sessionId);
@@ -105,7 +106,7 @@ export class StreamingManager extends EventEmitter {
             return;
         }
         session.config.compressionEnabled = true;
-        console.log(`[Streaming Manager] Enabled compression for session ${sessionId}`);
+        logger.debug(`[Streaming Manager] Enabled compression for session ${sessionId}`);
     }
     async configureStreamingBuffering(sessionId, bufferConfig) {
         const session = this.activeSessions.get(sessionId);
@@ -114,7 +115,7 @@ export class StreamingManager extends EventEmitter {
         }
         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);
+        logger.debug(`[Streaming Manager] Updated buffer config for session ${sessionId}:`, bufferConfig);
     }
     // Multi-Stream Coordination
     async createStreamingPool(poolId, config) {
@@ -126,7 +127,7 @@ export class StreamingManager extends EventEmitter {
             loadBalancer: config.loadBalancing,
         };
         this.streamingPools.set(poolId, pool);
-        console.log(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
+        logger.debug(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
     }
     async balanceStreamingLoad(poolId) {
         const pool = this.streamingPools.get(poolId);
@@ -160,7 +161,7 @@ export class StreamingManager extends EventEmitter {
         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)`);
+        logger.debug(`[Streaming Manager] Scaled pool ${poolId} to ${newMaxSessions} max sessions (${scale}x)`);
     }
     // Performance Monitoring
     getStreamingMetrics(sessionId) {
@@ -217,7 +218,7 @@ export class StreamingManager extends EventEmitter {
         this.healthCheckInterval = setInterval(() => {
             const health = this.getStreamingHealthStatus();
             if (health.status !== "healthy") {
-                console.warn("[Streaming Manager] Health check:", health);
+                logger.debug("[Streaming Manager] Health check:", health);
                 this.emit("health-warning", health);
             }
         }, 30000); // Check every 30 seconds

package/dist/services/types.d.ts

@@ -1,3 +1,4 @@
+import type { UnknownRecord, Unknown } from "../types/common.js";
 export interface StreamingSession {
     id: string;
     connectionId: string;
@@ -57,12 +58,12 @@ export interface StreamingChannel {
     type: "ai-response" | "mcp-tool" | "chat" | "notification";
     status: "open" | "closed" | "error";
     buffer: StreamingBuffer;
-    onData: (data: any) => void;
+    onData: (data: Unknown) => void;
     onError: (error: Error) => void;
     onClose: () => void;
 }
 export interface StreamingBuffer {
-    data: any[];
+    data: Unknown[];
     maxSize: number;
     currentSize: number;
     flushThreshold: number;
@@ -92,7 +93,7 @@ export interface WebSocketMessage {
     connectionId: string;
     roomId?: string;
     timestamp: number;
-    data: any;
+    data: Unknown;
     metadata?: {
         provider?: string;
         model?: string;
@@ -151,5 +152,5 @@ export interface ConnectionInfo {
     lastActivity: number;
     rooms: Set<string>;
     subscriptions: Set<string>;
-    metadata: Record<string, any>;
+    metadata: UnknownRecord;
 }

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

@@ -18,7 +18,7 @@ export declare class NeuroLinkWebSocketServer extends EventEmitter {
     broadcastToRoom(roomId: string, message: WebSocketMessage): void;
     createStreamingChannel(connectionId: string, channelId: string): StreamingChannel;
     destroyStreamingChannel(channelId: string): void;
-    private sendMessage;
+    sendMessage(connectionId: string, message: WebSocketMessage): boolean;
     private sendError;
     private updateLastActivity;
     private handleHeartbeat;

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

@@ -1,6 +1,8 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { IncomingMessage } from "http";
+import { logger } from "../../utils/logger.js";
 export class NeuroLinkWebSocketServer extends EventEmitter {
     wss;
     connections = new Map();
@@ -32,7 +34,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleConnection(ws, request);
         });
         this.wss.on("error", (error) => {
-            console.error("[WebSocket Server] Error:", error);
+            logger.error("[WebSocket Server] Error:", error);
             this.emit("error", error);
         });
     }
@@ -43,7 +45,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         }
         const connectionId = randomUUID();
         const userAgent = request.headers["user-agent"];
-        const ipAddress = request.socket.remoteAddress;
+        const ipAddress = request.socket?.remoteAddress;
         // Store connection
         this.connections.set(connectionId, ws);
         this.connectionInfo.set(connectionId, {
@@ -64,7 +66,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleDisconnection(connectionId);
         });
         ws.on("error", (error) => {
-            console.error(`[WebSocket] Connection ${connectionId} error:`, error);
+            logger.error(`[WebSocket] Connection ${connectionId} error:`, error);
             this.handleDisconnection(connectionId);
         });
         // Send connection confirmation
@@ -82,7 +84,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 },
             },
         });
-        console.log(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("connection", { connectionId, userAgent, ipAddress });
     }
     handleMessage(connectionId, data) {
@@ -101,7 +103,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
+            logger.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
             this.sendError(connectionId, "Invalid message format");
         }
     }
@@ -124,7 +126,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Clean up
         this.connections.delete(connectionId);
         this.connectionInfo.delete(connectionId);
-        console.log(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("disconnection", { connectionId });
     }
     // Room Management
@@ -150,7 +152,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: this.rooms.get(roomId).size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} joined room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} joined room ${roomId}`);
         return true;
     }
     leaveRoom(connectionId, roomId) {
@@ -179,7 +181,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: room.size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} left room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} left room ${roomId}`);
         return true;
     }
     broadcastToRoom(roomId, message) {
@@ -231,7 +233,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             return true;
         }
         catch (error) {
-            console.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
+            logger.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
             return false;
         }
     }
@@ -269,7 +271,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                     const connection = this.connectionInfo.get(connectionId);
                     if (connection &&
                         Date.now() - connection.lastActivity > this.options.timeoutMs) {
-                        console.log(`[WebSocket] Timeout for connection ${connectionId}`);
+                        logger.debug(`[WebSocket] Timeout for connection ${connectionId}`);
                         ws.terminate();
                     }
                 }
@@ -296,9 +298,9 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Implementation for channel data handling
     }
     handleChannelError(channelId, error) {
-        console.error(`[Streaming Channel] ${channelId} error:`, error);
+        logger.error(`[Streaming Channel] ${channelId} error:`, error);
     }
     handleChannelClose(channelId) {
-        console.log(`[Streaming Channel] ${channelId} closed`);
+        logger.debug(`[Streaming Channel] ${channelId} closed`);
     }
 }

package/dist/telemetry/telemetry-service.js

@@ -1,11 +1,12 @@
 import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace } from "@opentelemetry/api";
+import { metrics, trace, } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
     sdk;
@@ -27,7 +28,7 @@ export class TelemetryService {
             this.initializeTelemetry();
         }
         else {
-            console.log("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
+            logger.debug("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
         }
     }
     static getInstance() {
@@ -58,10 +59,10 @@ export class TelemetryService {
             this.meter = metrics.getMeter("neurolink-ai");
             this.tracer = trace.getTracer("neurolink-ai");
             this.initializeMetrics();
-            console.log("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
         }
         catch (error) {
-            console.error("[Telemetry] Failed to initialize:", error);
+            logger.error("[Telemetry] Failed to initialize:", error);
             this.enabled = false;
         }
     }
@@ -97,10 +98,10 @@ export class TelemetryService {
         }
         try {
             await this.sdk?.start();
-            console.log("[Telemetry] SDK started successfully");
+            logger.debug("[Telemetry] SDK started successfully");
         }
         catch (error) {
-            console.error("[Telemetry] Failed to start SDK:", error);
+            logger.error("[Telemetry] Failed to start SDK:", error);
             this.enabled = false;
         }
     }
@@ -251,10 +252,10 @@ export class TelemetryService {
         if (this.enabled && this.sdk) {
             try {
                 await this.sdk.shutdown();
-                console.log("[Telemetry] SDK shutdown completed");
+                logger.debug("[Telemetry] SDK shutdown completed");
             }
             catch (error) {
-                console.error("[Telemetry] Error during shutdown:", error);
+                logger.error("[Telemetry] Error during shutdown:", error);
             }
         }
     }

package/dist/types/cli.d.ts

@@ -0,0 +1,247 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+import type { UnknownRecord, JsonValue } from "./common.js";
+import type { AnalyticsData, EvaluationData, TokenUsage } from "./providers.js";
+import type { ToolCall, ToolResult } from "./tools.js";
+/**
+ * Base command arguments interface
+ */
+export interface BaseCommandArgs {
+    /** Enable debug output */
+    debug?: boolean;
+    /** Output format */
+    format?: "text" | "json" | "table";
+    /** Verbose output */
+    verbose?: boolean;
+    /** Quiet mode */
+    quiet?: boolean;
+}
+/**
+ * Generate command arguments
+ */
+export interface GenerateCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Enable analytics */
+    analytics?: boolean;
+    /** Enable evaluation */
+    evaluation?: boolean;
+    /** Context data */
+    context?: string;
+    /** Disable tools */
+    disableTools?: boolean;
+    /** Maximum steps for multi-turn */
+    maxSteps?: number;
+    /** Output file */
+    output?: string;
+}
+/**
+ * Stream command arguments
+ */
+export interface StreamCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Disable tools */
+    disableTools?: boolean;
+}
+/**
+ * MCP command arguments
+ */
+export interface MCPCommandArgs extends BaseCommandArgs {
+    /** MCP server name */
+    server?: string;
+    /** Tool name to execute */
+    tool?: string;
+    /** Tool parameters as JSON string */
+    params?: string;
+    /** List available tools */
+    list?: boolean;
+    /** Discover MCP servers */
+    discover?: boolean;
+    /** Show server information */
+    info?: boolean;
+}
+/**
+ * Ollama command arguments
+ */
+export interface OllamaCommandArgs extends BaseCommandArgs {
+    /** Ollama model name */
+    model?: string;
+    /** List available models */
+    list?: boolean;
+    /** Pull a model */
+    pull?: boolean;
+    /** Remove a model */
+    remove?: boolean;
+    /** Show model information */
+    show?: boolean;
+}
+/**
+ * Provider status command arguments
+ */
+export interface ProviderStatusArgs extends BaseCommandArgs {
+    /** Specific provider to check */
+    provider?: string;
+    /** Check all providers */
+    all?: boolean;
+}
+/**
+ * CLI command result
+ */
+export interface CommandResult {
+    /** Command success status */
+    success: boolean;
+    /** Result data */
+    data?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Output content */
+    content?: string;
+    /** Execution metadata */
+    metadata?: {
+        executionTime?: number;
+        timestamp?: number;
+        command?: string;
+    };
+}
+/**
+ * Generate command result
+ */
+export interface GenerateResult extends CommandResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    responseTime?: number;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        args: UnknownRecord;
+        result: unknown;
+        executionTime: number;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+/**
+ * Stream result chunk
+ */
+export interface StreamChunk {
+    content?: string;
+    delta?: string;
+    done?: boolean;
+    metadata?: UnknownRecord;
+}
+/**
+ * CLI output formatting options
+ */
+export interface OutputOptions {
+    format: "text" | "json" | "table";
+    pretty?: boolean;
+    color?: boolean;
+    compact?: boolean;
+}
+/**
+ * Command handler function type
+ */
+export type CommandHandler<TArgs = BaseCommandArgs, TResult = CommandResult> = (args: TArgs) => Promise<TResult>;
+/**
+ * Command definition
+ */
+export interface CommandDefinition<TArgs = BaseCommandArgs> {
+    name: string;
+    description: string;
+    aliases?: string[];
+    args?: {
+        [K in keyof TArgs]: {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean;
+            default?: TArgs[K];
+        };
+    };
+    handler: CommandHandler<TArgs>;
+}
+/**
+ * CLI context
+ */
+export interface CLIContext {
+    cwd: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    exitCode?: number;
+}
+/**
+ * Color mapping for CLI output
+ */
+export interface ColorMap {
+    [severity: string]: {
+        color: string;
+        symbol?: string;
+    };
+}
+/**
+ * Display severity colors (for evaluation display)
+ */
+export interface SeverityColors {
+    [key: string]: {
+        color: string;
+        symbol: string;
+    };
+}
+/**
+ * JSON output structure
+ */
+export interface JSONOutput {
+    success: boolean;
+    data?: JsonValue;
+    error?: string;
+    metadata?: {
+        timestamp: number;
+        command: string;
+        version?: string;
+    };
+}
+/**
+ * Console override for quiet mode
+ */
+export interface ConsoleOverride {
+    [method: string]: (() => void) | undefined;
+}
+/**
+ * Type guard for generate result
+ */
+export declare function isGenerateResult(value: unknown): value is GenerateResult;
+/**
+ * Type guard for command result
+ */
+export declare function isCommandResult(value: unknown): value is CommandResult;

package/dist/types/cli.js

@@ -0,0 +1,22 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+/**
+ * Type guard for generate result
+ */
+export function isGenerateResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "content" in value &&
+        typeof value.content === "string");
+}
+/**
+ * Type guard for command result
+ */
+export function isCommandResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "success" in value &&
+        typeof value.success === "boolean");
+}

package/dist/types/common.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Common utility types for NeuroLink
+ * These types provide type-safe alternatives to 'any' usage
+ */
+/**
+ * Type-safe unknown value - use instead of 'any' when type is truly unknown
+ */
+export type Unknown = unknown;
+/**
+ * Type-safe record for metadata and configuration objects
+ */
+export type UnknownRecord = Record<string, unknown>;
+/**
+ * Type-safe array of unknown items
+ */
+export type UnknownArray = unknown[];
+/**
+ * JSON-serializable value type
+ */
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ * Type-safe error handling
+ */
+export interface ErrorInfo {
+    message: string;
+    code?: string | number;
+    stack?: string;
+    cause?: unknown;
+}
+/**
+ * Generic success/error result type
+ */
+export interface Result<T = unknown, E = ErrorInfo> {
+    success: boolean;
+    data?: T;
+    error?: E;
+}
+/**
+ * Function parameter type for dynamic functions
+ */
+export interface FunctionParameters {
+    [key: string]: unknown;
+}
+/**
+ * Generic async function type
+ */
+export type AsyncFunction<TParams = FunctionParameters, TResult = unknown> = (params: TParams) => Promise<TResult>;
+/**
+ * Sync function type
+ */
+export type SyncFunction<TParams = FunctionParameters, TResult = unknown> = (params: TParams) => TResult;
+/**
+ * Union of async and sync functions
+ */
+export type AnyFunction<TParams = FunctionParameters, TResult = unknown> = AsyncFunction<TParams, TResult> | SyncFunction<TParams, TResult>;
+/**
+ * Type guard to check if value is Error
+ */
+export declare function isError(value: unknown): value is Error;
+/**
+ * Type guard to check if value is ErrorInfo
+ */
+export declare function isErrorInfo(value: unknown): value is ErrorInfo;
+/**
+ * Safe error message extraction
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Safe error conversion
+ */
+export declare function toErrorInfo(error: unknown): ErrorInfo;