@juspay/neurolink 7.53.4 → 7.54.0

package/dist/lib/types/utilities.js

@@ -1,5 +1,5 @@
 /**
  * Utility module types - extracted from utils module files
  */
-export {};
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 //# sourceMappingURL=utilities.js.map

package/dist/lib/utils/errorHandling.d.ts

@@ -2,34 +2,8 @@
  * Robust Error Handling Utilities for NeuroLink
  * Provides structured error management for tool execution and system operations
  */
-export declare enum ErrorCategory {
-    VALIDATION = "validation",
-    TIMEOUT = "timeout",
-    NETWORK = "network",
-    RESOURCE = "resource",
-    PERMISSION = "permission",
-    CONFIGURATION = "configuration",
-    EXECUTION = "execution",
-    SYSTEM = "system"
-}
-export declare enum ErrorSeverity {
-    LOW = "low",
-    MEDIUM = "medium",
-    HIGH = "high",
-    CRITICAL = "critical"
-}
-export type StructuredError = {
-    code: string;
-    message: string;
-    category: ErrorCategory;
-    severity: ErrorSeverity;
-    retriable: boolean;
-    context?: Record<string, unknown>;
-    originalError?: Error;
-    timestamp: Date;
-    toolName?: string;
-    serverId?: string;
-};
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
+import type { StructuredError } from "../types/utilities.js";
 export declare const ERROR_CODES: {
     readonly TOOL_NOT_FOUND: "TOOL_NOT_FOUND";
     readonly TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED";

package/dist/lib/utils/errorHandling.js

@@ -2,27 +2,8 @@
  * Robust Error Handling Utilities for NeuroLink
  * Provides structured error management for tool execution and system operations
  */
+import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { logger } from "./logger.js";
-// Error categories for proper handling
-export var ErrorCategory;
-(function (ErrorCategory) {
-    ErrorCategory["VALIDATION"] = "validation";
-    ErrorCategory["TIMEOUT"] = "timeout";
-    ErrorCategory["NETWORK"] = "network";
-    ErrorCategory["RESOURCE"] = "resource";
-    ErrorCategory["PERMISSION"] = "permission";
-    ErrorCategory["CONFIGURATION"] = "configuration";
-    ErrorCategory["EXECUTION"] = "execution";
-    ErrorCategory["SYSTEM"] = "system";
-})(ErrorCategory || (ErrorCategory = {}));
-// Error severity levels
-export var ErrorSeverity;
-(function (ErrorSeverity) {
-    ErrorSeverity["LOW"] = "low";
-    ErrorSeverity["MEDIUM"] = "medium";
-    ErrorSeverity["HIGH"] = "high";
-    ErrorSeverity["CRITICAL"] = "critical";
-})(ErrorSeverity || (ErrorSeverity = {}));
 // Error codes for different scenarios
 export const ERROR_CODES = {
     // Tool errors

package/dist/lib/utils/logger.d.ts

@@ -13,34 +13,28 @@
  * - Structured data support for complex objects
  * - Tabular data display
  */
-/**
- * Represents the available logging severity levels.
- * - debug: Detailed information for debugging purposes
- * - info: General information about system operation
- * - warn: Potential issues that don't prevent operation
- * - error: Critical issues that may cause failures
- */
-export type LogLevel = "debug" | "info" | "warn" | "error";
-/**
- * Represents a single log entry in the logging system.
- * Each entry contains metadata about the log event along with the actual message.
- */
-interface LogEntry {
-    /** The severity level of the log entry */
-    level: LogLevel;
-    /** The text message to be logged */
-    message: string;
-    /** When the log entry was created */
-    timestamp: Date;
-    /** Optional additional data associated with the log entry (objects, arrays, etc.) */
-    data?: unknown;
-}
+import type { LogEntry, LogLevel } from "../types/utilities.js";
 declare class NeuroLinkLogger {
     private logLevel;
     private logs;
     private maxLogs;
     private isDebugMode;
+    private eventEmitter?;
     constructor();
+    /**
+     * Sets the event emitter that will receive log events.
+     * When set, all log operations will emit a "log-event" event.
+     *
+     * @param emitter - The event emitter instance
+     */
+    setEventEmitter(emitter: {
+        emit: (event: string, ...args: unknown[]) => boolean;
+    }): void;
+    /**
+     * Clears the event emitter reference.
+     * Should be called when a NeuroLink instance is disposed to prevent memory leaks.
+     */
+    clearEventEmitter(): void;
     /**
      * Sets the minimum log level that will be processed and output.
      * Log messages with a level lower than this will be ignored.
@@ -84,6 +78,7 @@ declare class NeuroLinkLogger {
      * 2. Storing entries in the log history
      * 3. Managing log rotation to prevent memory issues
      * 4. Outputting formatted logs to the console
+     * 5. Emitting log events if an event emitter is configured
      *
      * This is the central method called by all specific logging methods (debug, info, etc.)
      *
@@ -185,6 +180,7 @@ declare class NeuroLinkLogger {
  * - Unconditional logging (always, table)
  * - Log level control and configuration
  * - Log history management
+ * - Event emission for all log operations (when emitter is configured)
  */
 export declare const logger: {
     debug: (...args: unknown[]) => void;
@@ -196,6 +192,10 @@ export declare const logger: {
     setLogLevel: (level: LogLevel) => void;
     getLogs: (level?: LogLevel) => LogEntry[];
     clearLogs: () => void;
+    setEventEmitter: (emitter: {
+        emit: (event: string, ...args: unknown[]) => boolean;
+    }) => void;
+    clearEventEmitter: () => void;
 };
 /**
  * MCP compatibility exports - all use the same unified logger instance.
@@ -236,4 +236,4 @@ export declare const LogLevels: {
     readonly warn: "warn";
     readonly error: "error";
 };
-export type { LogEntry };
+export {};

package/dist/lib/utils/logger.js

@@ -25,6 +25,7 @@ class NeuroLinkLogger {
     logs = [];
     maxLogs = 1000;
     isDebugMode;
+    eventEmitter;
     constructor() {
         // Cache debug mode check to avoid repeated array searches
         this.isDebugMode =
@@ -36,6 +37,22 @@ class NeuroLinkLogger {
             this.logLevel = envLevel;
         }
     }
+    /**
+     * Sets the event emitter that will receive log events.
+     * When set, all log operations will emit a "log-event" event.
+     *
+     * @param emitter - The event emitter instance
+     */
+    setEventEmitter(emitter) {
+        this.eventEmitter = emitter;
+    }
+    /**
+     * Clears the event emitter reference.
+     * Should be called when a NeuroLink instance is disposed to prevent memory leaks.
+     */
+    clearEventEmitter() {
+        this.eventEmitter = undefined;
+    }
     /**
      * Sets the minimum log level that will be processed and output.
      * Log messages with a level lower than this will be ignored.
@@ -106,6 +123,7 @@ class NeuroLinkLogger {
      * 2. Storing entries in the log history
      * 3. Managing log rotation to prevent memory issues
      * 4. Outputting formatted logs to the console
+     * 5. Emitting log events if an event emitter is configured
      *
      * This is the central method called by all specific logging methods (debug, info, etc.)
      *
@@ -123,6 +141,20 @@ class NeuroLinkLogger {
             timestamp: new Date(),
             data,
         };
+        // Emit log event if emitter is configured
+        if (this.eventEmitter) {
+            try {
+                this.eventEmitter.emit("log-event", {
+                    level,
+                    message,
+                    timestamp: new Date().getTime(),
+                    data,
+                });
+            }
+            catch {
+                // Silently ignore emitter errors to avoid disrupting logging
+            }
+        }
         // Store log entry
         this.logs.push(entry);
         // Trim old logs
@@ -277,6 +309,7 @@ function processLoggerArgs(args, logMethod) {
  * - Unconditional logging (always, table)
  * - Log level control and configuration
  * - Log history management
+ * - Event emission for all log operations (when emitter is configured)
  */
 export const logger = {
     debug: (...args) => {
@@ -309,6 +342,8 @@ export const logger = {
     setLogLevel: (level) => neuroLinkLogger.setLogLevel(level),
     getLogs: (level) => neuroLinkLogger.getLogs(level),
     clearLogs: () => neuroLinkLogger.clearLogs(),
+    setEventEmitter: (emitter) => neuroLinkLogger.setEventEmitter(emitter),
+    clearEventEmitter: () => neuroLinkLogger.clearEventEmitter(),
 };
 /**
  * MCP compatibility exports - all use the same unified logger instance.

package/dist/lib/utils/modelRouter.d.ts

@@ -2,23 +2,7 @@
  * Model Router for NeuroLink Orchestration
  * Routes tasks to optimal models based on classification and requirements
  */
-import type { TaskType } from "../types/taskClassificationTypes.js";
-export type ModelRoute = {
-    provider: string;
-    model: string;
-    reasoning: string;
-    confidence: number;
-};
-export type ModelRoutingOptions = {
-    /** Override the task classification */
-    forceTaskType?: TaskType;
-    /** Require specific performance characteristics */
-    requireFast?: boolean;
-    /** Require specific capability (reasoning, creativity, etc.) */
-    requireCapability?: string;
-    /** Fallback strategy if primary choice fails */
-    fallbackStrategy?: "fast" | "reasoning" | "auto";
-};
+import type { ModelRoute, ModelRoutingOptions } from "../types/modelTypes.js";
 /**
  * Model configurations for different task types and providers
  */

package/dist/lib/utils/optionsConversion.d.ts

@@ -17,11 +17,6 @@ export declare function convertGenerateToStreamOptions(generateOptions: Generate
  * Useful for fallback scenarios and unified processing
  */
 export declare function convertStreamToGenerateOptions(streamOptions: StreamOptions): GenerateOptions;
-/**
- * Create a unified options interface that works with both methods
- * Useful for factory utilities that need to work with either type
- */
-export type UnifiedOptions = GenerateOptions & StreamOptions;
 /**
  * Check if options object has factory configuration
  * Useful for determining if enhanced processing is needed

package/dist/lib/utils/optionsUtils.d.ts

@@ -5,60 +5,7 @@
  */
 import type { GenerateOptions, UnifiedGenerationOptions } from "../types/generateTypes.js";
 import type { StreamOptions } from "../types/streamTypes.js";
-import type { ExecutionContext } from "../types/tools.js";
-/**
- * Enhancement types for different optimization strategies
- */
-export type EnhancementType = "streaming-optimization" | "mcp-integration" | "legacy-migration" | "context-conversion" | "domain-configuration" | "batch-parallel-enhancement" | "batch-hybrid-enhancement" | "batch-dependency-enhancement";
-/**
- * Enhancement options for modifying GenerateOptions
- */
-export interface EnhancementOptions {
-    enhancementType: EnhancementType;
-    streamingOptions?: {
-        enabled?: boolean;
-        chunkSize?: number;
-        bufferSize?: number;
-        enableProgress?: boolean;
-        preferStreaming?: boolean;
-    };
-    mcpOptions?: {
-        enableToolRegistry?: boolean;
-        contextAware?: boolean;
-        executionContext?: ExecutionContext;
-    };
-    legacyMigration?: {
-        legacyContext?: Record<string, unknown>;
-        domainType?: string;
-        preserveFields?: boolean;
-    };
-    domainConfiguration?: {
-        domainType: string;
-        keyTerms?: string[];
-        failurePatterns?: string[];
-        successPatterns?: string[];
-        evaluationCriteria?: Record<string, unknown>;
-    };
-    performance?: {
-        enableAnalytics?: boolean;
-        enableEvaluation?: boolean;
-        timeout?: number;
-    };
-}
-/**
- * Enhancement result with metadata
- */
-export interface EnhancementResult {
-    options: UnifiedGenerationOptions;
-    metadata: {
-        enhancementApplied: boolean;
-        enhancementType: EnhancementType;
-        processingTime: number;
-        configurationUsed: Record<string, unknown>;
-        warnings: string[];
-        recommendations: string[];
-    };
-}
+import type { ConflictDetectionPlugin, EnhancementOptions, EnhancementResult, EnhancementType } from "../types/utilities.js";
 /**
  * Options Enhancement Utility Class
  * Main utility for enhancing GenerateOptions with factory patterns
@@ -176,22 +123,6 @@ export declare function migrateLegacyContext(options: GenerateOptions, legacyCon
  * Automatically detects independent enhancements for parallel processing
  */
 export declare function batchEnhance(options: GenerateOptions, enhancements: EnhancementOptions[]): EnhancementResult;
-/**
- * Plugin-based conflict detection system
- * Extensible and configurable enhancement conflict resolution
- */
-export interface ConflictDetectionPlugin {
-    /** Plugin name for identification */
-    name: string;
-    /** Plugin version for compatibility checks */
-    version: string;
-    /** Check if two enhancement types conflict */
-    detectConflict(enhancementA: EnhancementType, enhancementB: EnhancementType, optionsA?: EnhancementOptions, optionsB?: EnhancementOptions): boolean;
-    /** Get conflict severity (low, medium, high) */
-    getConflictSeverity?(enhancementA: EnhancementType, enhancementB: EnhancementType): "low" | "medium" | "high";
-    /** Suggest resolution strategies */
-    suggestResolution?(enhancementA: EnhancementType, enhancementB: EnhancementType): string[];
-}
 /**
  * Plugin registry for managing conflict detection plugins
  */

package/dist/lib/utils/parameterValidation.d.ts

@@ -3,6 +3,7 @@
  * Provides consistent parameter validation across all tool interfaces
  */
 import type { ValidationSchema, StringArray } from "../types/typeAliases.js";
+import type { EnhancedValidationResult } from "../types/tools.js";
 /**
  * Custom error class for parameter validation failures
  * Provides detailed information about validation errors including field context and suggestions
@@ -20,20 +21,6 @@ export declare class ValidationError extends Error {
      */
     constructor(message: string, field?: string | undefined, code?: string | undefined, suggestions?: StringArray | undefined);
 }
-/**
- * Result of a validation operation
- * Contains validation status, errors, warnings, and suggestions for improvement
- */
-export interface ValidationResult {
-    /** Whether the validation passed without errors */
-    isValid: boolean;
-    /** Array of validation errors that must be fixed */
-    errors: ValidationError[];
-    /** Array of warning messages that should be addressed */
-    warnings: string[];
-    /** Array of suggestions to improve the validated object */
-    suggestions: StringArray;
-}
 /**
  * Validate that a string parameter is present and non-empty
  */
@@ -61,23 +48,23 @@ export declare function validateToolDescription(description: unknown): Validatio
 /**
  * Validate MCP tool structure comprehensively
  */
-export declare function validateMCPTool(tool: unknown): ValidationResult;
+export declare function validateMCPTool(tool: unknown): EnhancedValidationResult;
 /**
  * Validate text generation options
  */
-export declare function validateTextGenerationOptions(options: unknown): ValidationResult;
+export declare function validateTextGenerationOptions(options: unknown): EnhancedValidationResult;
 /**
  * Validate stream options
  */
-export declare function validateStreamOptions(options: unknown): ValidationResult;
+export declare function validateStreamOptions(options: unknown): EnhancedValidationResult;
 /**
  * Validate generate options (unified interface)
  */
-export declare function validateGenerateOptions(options: unknown): ValidationResult;
+export declare function validateGenerateOptions(options: unknown): EnhancedValidationResult;
 /**
  * Validate tool execution parameters
  */
-export declare function validateToolExecutionParams(toolName: string, params: unknown, expectedSchema?: ValidationSchema): ValidationResult;
+export declare function validateToolExecutionParams(toolName: string, params: unknown, expectedSchema?: ValidationSchema): EnhancedValidationResult;
 /**
  * Validate multiple tools at once
  */
@@ -85,13 +72,13 @@ export declare function validateToolBatch(tools: Record<string, unknown>): {
     isValid: boolean;
     validTools: string[];
     invalidTools: string[];
-    results: Record<string, ValidationResult>;
+    results: Record<string, EnhancedValidationResult>;
 };
 /**
  * Create a validation error summary for logging
  */
-export declare function createValidationSummary(result: ValidationResult): string;
+export declare function createValidationSummary(result: EnhancedValidationResult): string;
 /**
  * Check if validation result has only warnings (no errors)
  */
-export declare function hasOnlyWarnings(result: ValidationResult): boolean;
+export declare function hasOnlyWarnings(result: EnhancedValidationResult): boolean;

package/dist/lib/utils/performance.d.ts

@@ -2,19 +2,7 @@
  * Performance measurement and memory management utilities
  * Part of Sub-phase 3.3.1-3.3.2 optimization efforts
  */
-export interface PerformanceMetrics {
-    startTime: number;
-    endTime?: number;
-    duration?: number;
-    memoryStart: NodeJS.MemoryUsage;
-    memoryEnd?: NodeJS.MemoryUsage;
-    memoryDelta?: {
-        rss: number;
-        heapTotal: number;
-        heapUsed: number;
-        external: number;
-    };
-}
+import type { PerformanceMetrics } from "../types/analytics.js";
 /**
  * Performance measurement utility for tracking operations
  */

package/dist/lib/utils/promptRedaction.d.ts

@@ -2,14 +2,7 @@
  * Prompt redaction utilities for safe logging
  * Provides consistent prompt masking across NeuroLink components
  */
-export interface PromptRedactionOptions {
-    /** Maximum length of redacted prompt */
-    maxLength?: number;
-    /** Whether to show word count */
-    showWordCount?: boolean;
-    /** Mask character to use for redaction */
-    maskChar?: string;
-}
+import type { PromptRedactionOptions } from "../types/utilities.js";
 /**
  * Redact a prompt for safe logging
  * Truncates to maxLength and optionally shows word count

package/dist/lib/utils/providerUtils.d.ts

@@ -1,4 +1,5 @@
-import type { ProviderError } from "../types/index.js";
+import type { ProviderError } from "../types/providers.js";
+import type { EnvVarValidationResult } from "../types/utilities.js";
 /**
  * Get the best available provider based on real-time availability checks
  * Enhanced version consolidated from providerUtils-fixed.ts
@@ -6,15 +7,6 @@ import type { ProviderError } from "../types/index.js";
  * @returns The best provider name to use
  */
 export declare function getBestProvider(requestedProvider?: string): Promise<string>;
-/**
- * Validation results for environment variables
- */
-export interface EnvVarValidationResult {
-    isValid: boolean;
-    missingVars: string[];
-    invalidVars: string[];
-    warnings: string[];
-}
 /**
  * Validate environment variable values for a provider
  * Addresses GitHub Copilot comment about adding environment variable validation

package/dist/lib/utils/redis.d.ts

@@ -3,8 +3,8 @@
  * Helper functions for Redis storage operations
  */
 import { createClient } from "redis";
-type RedisClient = ReturnType<typeof createClient>;
 import type { RedisStorageConfig, RedisConversationObject } from "../types/conversation.js";
+type RedisClient = ReturnType<typeof createClient>;
 /**
  * Creates a Redis client with the provided configuration
  */

package/dist/lib/utils/redis.js

@@ -4,7 +4,6 @@
  */
 import { createClient } from "redis";
 import { logger } from "./logger.js";
-// Redis client type
 /**
  * Creates a Redis client with the provided configuration
  */

package/dist/lib/utils/retryHandler.d.ts

@@ -2,6 +2,7 @@
  * Retry and resilience utilities for NeuroLink
  * Part of Sub-phase 3.3.3 - Edge Case Handling
  */
+import type { RetryOptions } from "../types/utilities.js";
 /**
  * Calculate exponential backoff delay with jitter
  * @param attempt - Current attempt number (1-based)
@@ -12,14 +13,6 @@
  * @returns Calculated delay in milliseconds
  */
 export declare function calculateBackoffDelay(attempt: number, initialDelay?: number, multiplier?: number, maxDelay?: number, addJitter?: boolean): number;
-export interface RetryOptions {
-    maxAttempts?: number;
-    initialDelay?: number;
-    maxDelay?: number;
-    backoffMultiplier?: number;
-    retryCondition?: (error: unknown) => boolean;
-    onRetry?: (attempt: number, error: unknown) => void;
-}
 /**
  * Error types that are typically retryable
  */

package/dist/neurolink.js

@@ -187,6 +187,7 @@ export class NeuroLink {
         this.observabilityConfig = config?.observability;
         // Initialize orchestration setting
         this.enableOrchestration = config?.enableOrchestration ?? false;
+        logger.setEventEmitter(this.emitter);
         // Read tool cache duration from environment variables, with a default
         const cacheDurationEnv = process.env.NEUROLINK_TOOL_CACHE_DURATION;
         this.toolCacheDuration = cacheDurationEnv
@@ -1945,36 +1946,11 @@ export class NeuroLink {
                 finally {
                     // Store memory after stream consumption is complete
                     if (self.conversationMemory && enhancedOptions.context?.sessionId) {
-                        const storageStartTime = Date.now();
                         const sessionId = enhancedOptions.context?.sessionId;
                         const userId = enhancedOptions.context
                             ?.userId;
                         try {
-                            self.emitter.emit("log-event", {
-                                type: "log-event:storage:start",
-                                data: {
-                                    operation: "storeConversationTurn",
-                                    sessionId,
-                                    userId,
-                                    timestamp: storageStartTime,
-                                    source: "stream-finally-block",
-                                    userInputLength: originalPrompt?.length ?? 0,
-                                    responseLength: accumulatedContent.length,
-                                },
-                            });
                             await self.conversationMemory.storeConversationTurn(sessionId, userId, originalPrompt ?? "", accumulatedContent, new Date(startTime));
-                            self.emitter.emit("log-event", {
-                                type: "log-event:storage:end",
-                                data: {
-                                    operation: "storeConversationTurn",
-                                    sessionId,
-                                    userId,
-                                    timestamp: Date.now(),
-                                    duration: Date.now() - storageStartTime,
-                                    source: "stream-finally-block",
-                                    success: true,
-                                },
-                            });
                             logger.debug("Stream conversation turn stored", {
                                 sessionId,
                                 userInputLength: originalPrompt?.length ?? 0,
@@ -1982,18 +1958,6 @@ export class NeuroLink {
                             });
                         }
                         catch (error) {
-                            self.emitter.emit("log-event", {
-                                type: "log-event:storage:error",
-                                data: {
-                                    operation: "storeConversationTurn",
-                                    sessionId,
-                                    userId,
-                                    timestamp: Date.now(),
-                                    duration: Date.now() - storageStartTime,
-                                    source: "stream-finally-block",
-                                    error: error instanceof Error ? error.message : String(error),
-                                },
-                            });
                             logger.warn("Failed to store stream conversation turn", {
                                 error: error instanceof Error ? error.message : String(error),
                             });
@@ -2187,36 +2151,11 @@ export class NeuroLink {
             finally {
                 // Store memory after fallback stream consumption is complete
                 if (self.conversationMemory && enhancedOptions?.context?.sessionId) {
-                    const storageStartTime = Date.now();
                     const sessionId = enhancedOptions?.context?.sessionId;
                     const userId = enhancedOptions?.context
                         ?.userId;
                     try {
-                        self.emitter.emit("log", {
-                            type: "log-event:storage:start",
-                            data: {
-                                operation: "storeConversationTurn",
-                                sessionId,
-                                userId,
-                                timestamp: storageStartTime,
-                                source: "fallback-stream-finally-block",
-                                userInputLength: originalPrompt?.length ?? 0,
-                                responseLength: fallbackAccumulatedContent.length,
-                            },
-                        });
                         await self.conversationMemory.storeConversationTurn(sessionId || options.context?.sessionId, userId || options.context?.userId, originalPrompt ?? "", fallbackAccumulatedContent, new Date(startTime));
-                        self.emitter.emit("log", {
-                            type: "log-event:storage:end",
-                            data: {
-                                operation: "storeConversationTurn",
-                                sessionId,
-                                userId,
-                                timestamp: Date.now(),
-                                duration: Date.now() - storageStartTime,
-                                source: "fallback-stream-finally-block",
-                                success: true,
-                            },
-                        });
                         logger.debug("Fallback stream conversation turn stored", {
                             sessionId: sessionId || options.context?.sessionId,
                             userInputLength: originalPrompt?.length ?? 0,
@@ -2224,18 +2163,6 @@ export class NeuroLink {
                         });
                     }
                     catch (error) {
-                        self.emitter.emit("log-event", {
-                            type: "log-event:storage:error",
-                            data: {
-                                operation: "storeConversationTurn",
-                                sessionId,
-                                userId,
-                                timestamp: Date.now(),
-                                duration: Date.now() - storageStartTime,
-                                source: "fallback-stream-finally-block",
-                                error: error instanceof Error ? error.message : String(error),
-                            },
-                        });
                         logger.warn("Failed to store fallback stream conversation turn", {
                             error: error instanceof Error ? error.message : String(error),
                         });
@@ -4254,6 +4181,7 @@ export class NeuroLink {
                 try {
                     logger.debug("[NeuroLink] Removing all event listeners...");
                     this.emitter.removeAllListeners();
+                    logger.clearEventEmitter();
                     logger.debug("[NeuroLink] Event listeners removed successfully");
                 }
                 catch (error) {