@juspay/neurolink 7.52.0 → 7.53.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.53.1](https://github.com/juspay/neurolink/compare/v7.53.0...v7.53.1) (2025-10-27)
+
+### Bug Fixes
+
+- **(redis):** Emit redis related info through events for logging ([3224075](https://github.com/juspay/neurolink/commit/3224075d86c97f4206855d485748a95d609256af))
+
+## [7.53.0](https://github.com/juspay/neurolink/compare/v7.52.0...v7.53.0) (2025-10-26)
+
+### Features
+
+- **(test):** vitest configuration setup for cli ([ffb7db3](https://github.com/juspay/neurolink/commit/ffb7db301e2e883af5427db6e6d00a8a7dd65023))
+
 ## [7.52.0](https://github.com/juspay/neurolink/compare/v7.51.3...v7.52.0) (2025-10-24)
 
 ### Features

package/dist/core/redisConversationMemoryManager.d.ts

@@ -148,13 +148,4 @@ export declare class RedisConversationMemoryManager {
      * Flush pending tool execution data for a session and merge into conversation
      */
     private flushPendingToolData;
-    /**
-     * Enforce session limit
-     *
-     * NOTE: This function is maintained only for backward compatibility with the
-     * in-memory implementation. In Redis, we do not actually delete sessions based on
-     * a global limit, as this could cause race conditions in a distributed environment.
-     * Each session is managed independently with its own TTL.
-     */
-    private enforceSessionLimit;
 }

package/dist/core/redisConversationMemoryManager.js

@@ -4,7 +4,7 @@
  */
 import { randomUUID } from "crypto";
 import { ConversationMemoryError } from "../types/conversation.js";
-import { DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
+import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLink } from "../neurolink.js";
 import { createRedisClient, getSessionKey, getUserSessionsKey, getNormalizedConfig, serializeConversation, deserializeConversation, scanKeys, } from "../utils/redis.js";
@@ -376,8 +376,6 @@ export class RedisConversationMemoryManager {
             if (userId) {
                 await this.addUserSession(userId, sessionId);
             }
-            // Enforce session limit
-            await this.enforceSessionLimit();
             logger.debug("[RedisConversationMemoryManager] Successfully stored conversation turn", {
                 sessionId,
                 totalMessages: conversation.messages.length,
@@ -799,10 +797,11 @@ User message: "${userMessage}`;
                         results.push(metadata);
                     }
                     else {
-                        logger.debug("[RedisConversationMemoryManager] Empty or missing session metadata", {
+                        logger.debug("[RedisConversationMemoryManager] Empty or missing session metadata - removing from user history", {
                             userId,
                             sessionId,
                         });
+                        await this.removeUserSession(userId, sessionId);
                     }
                 }
                 catch (sessionError) {
@@ -916,41 +915,4 @@ User message: "${userMessage}`;
             totalMessages: conversation.messages.length,
         });
     }
-    /**
-     * Enforce session limit
-     *
-     * NOTE: This function is maintained only for backward compatibility with the
-     * in-memory implementation. In Redis, we do not actually delete sessions based on
-     * a global limit, as this could cause race conditions in a distributed environment.
-     * Each session is managed independently with its own TTL.
-     */
-    async enforceSessionLimit() {
-        logger.debug("[RedisConversationMemoryManager] Enforcing session limit (compatibility function)");
-        if (!this.redisClient) {
-            logger.debug("[RedisConversationMemoryManager] No Redis client, skipping session limit check");
-            return;
-        }
-        const maxSessions = this.config.maxSessions || DEFAULT_MAX_SESSIONS;
-        const pattern = `${this.redisConfig.keyPrefix}*`;
-        logger.debug("[RedisConversationMemoryManager] Listing all session keys", {
-            pattern,
-            maxSessions,
-        });
-        // Use SCAN instead of KEYS to avoid blocking the server
-        const keys = await scanKeys(this.redisClient, pattern);
-        logger.debug("[RedisConversationMemoryManager] Found existing sessions using SCAN", {
-            sessionCount: keys.length,
-            maxSessions,
-            needsTrimming: keys.length > maxSessions,
-        });
-        // In the Redis implementation, we intentionally do not delete sessions based on a global limit.
-        // Each session is managed independently with its own TTL.
-        if (keys.length > maxSessions) {
-            logger.info("Redis session count exceeds limit, but not enforcing deletion", {
-                currentCount: keys.length,
-                maxSessions,
-                reason: "Redis sessions are managed independently with TTL",
-            });
-        }
-    }
 }

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -148,13 +148,4 @@ export declare class RedisConversationMemoryManager {
      * Flush pending tool execution data for a session and merge into conversation
      */
     private flushPendingToolData;
-    /**
-     * Enforce session limit
-     *
-     * NOTE: This function is maintained only for backward compatibility with the
-     * in-memory implementation. In Redis, we do not actually delete sessions based on
-     * a global limit, as this could cause race conditions in a distributed environment.
-     * Each session is managed independently with its own TTL.
-     */
-    private enforceSessionLimit;
 }

package/dist/lib/core/redisConversationMemoryManager.js

@@ -4,7 +4,7 @@
  */
 import { randomUUID } from "crypto";
 import { ConversationMemoryError } from "../types/conversation.js";
-import { DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
+import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLink } from "../neurolink.js";
 import { createRedisClient, getSessionKey, getUserSessionsKey, getNormalizedConfig, serializeConversation, deserializeConversation, scanKeys, } from "../utils/redis.js";
@@ -376,8 +376,6 @@ export class RedisConversationMemoryManager {
             if (userId) {
                 await this.addUserSession(userId, sessionId);
             }
-            // Enforce session limit
-            await this.enforceSessionLimit();
             logger.debug("[RedisConversationMemoryManager] Successfully stored conversation turn", {
                 sessionId,
                 totalMessages: conversation.messages.length,
@@ -799,10 +797,11 @@ User message: "${userMessage}`;
                         results.push(metadata);
                     }
                     else {
-                        logger.debug("[RedisConversationMemoryManager] Empty or missing session metadata", {
+                        logger.debug("[RedisConversationMemoryManager] Empty or missing session metadata - removing from user history", {
                             userId,
                             sessionId,
                         });
+                        await this.removeUserSession(userId, sessionId);
                     }
                 }
                 catch (sessionError) {
@@ -916,42 +915,5 @@ User message: "${userMessage}`;
             totalMessages: conversation.messages.length,
         });
     }
-    /**
-     * Enforce session limit
-     *
-     * NOTE: This function is maintained only for backward compatibility with the
-     * in-memory implementation. In Redis, we do not actually delete sessions based on
-     * a global limit, as this could cause race conditions in a distributed environment.
-     * Each session is managed independently with its own TTL.
-     */
-    async enforceSessionLimit() {
-        logger.debug("[RedisConversationMemoryManager] Enforcing session limit (compatibility function)");
-        if (!this.redisClient) {
-            logger.debug("[RedisConversationMemoryManager] No Redis client, skipping session limit check");
-            return;
-        }
-        const maxSessions = this.config.maxSessions || DEFAULT_MAX_SESSIONS;
-        const pattern = `${this.redisConfig.keyPrefix}*`;
-        logger.debug("[RedisConversationMemoryManager] Listing all session keys", {
-            pattern,
-            maxSessions,
-        });
-        // Use SCAN instead of KEYS to avoid blocking the server
-        const keys = await scanKeys(this.redisClient, pattern);
-        logger.debug("[RedisConversationMemoryManager] Found existing sessions using SCAN", {
-            sessionCount: keys.length,
-            maxSessions,
-            needsTrimming: keys.length > maxSessions,
-        });
-        // In the Redis implementation, we intentionally do not delete sessions based on a global limit.
-        // Each session is managed independently with its own TTL.
-        if (keys.length > maxSessions) {
-            logger.info("Redis session count exceeds limit, but not enforcing deletion", {
-                currentCount: keys.length,
-                maxSessions,
-                reason: "Redis sessions are managed independently with TTL",
-            });
-        }
-    }
 }
 //# sourceMappingURL=redisConversationMemoryManager.js.map

package/dist/lib/neurolink.js

@@ -1942,19 +1942,56 @@ export class NeuroLink {
                 }
                 finally {
                     // Store memory after stream consumption is complete
-                    if (self.conversationMemory) {
+                    if (self.conversationMemory && enhancedOptions.context?.sessionId) {
+                        const storageStartTime = Date.now();
+                        const sessionId = enhancedOptions.context?.sessionId;
+                        const userId = enhancedOptions.context
+                            ?.userId;
                         try {
-                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
-                                ?.sessionId, enhancedOptions.context
-                                ?.userId, originalPrompt ?? "", accumulatedContent, new Date(startTime));
+                            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: enhancedOptions.context
-                                    ?.sessionId,
+                                sessionId,
                                 userInputLength: originalPrompt?.length ?? 0,
                                 responseLength: accumulatedContent.length,
                             });
                         }
                         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),
                             });
@@ -2147,12 +2184,37 @@ export class NeuroLink {
             }
             finally {
                 // Store memory after fallback stream consumption is complete
-                if (self.conversationMemory) {
+                if (self.conversationMemory && enhancedOptions?.context?.sessionId) {
+                    const storageStartTime = Date.now();
+                    const sessionId = enhancedOptions?.context?.sessionId;
+                    const userId = enhancedOptions?.context
+                        ?.userId;
                     try {
-                        const sessionId = enhancedOptions?.context?.sessionId;
-                        const userId = enhancedOptions?.context
-                            ?.userId;
+                        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,
@@ -2160,6 +2222,18 @@ 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),
                         });

package/dist/neurolink.js

@@ -1942,19 +1942,56 @@ export class NeuroLink {
                 }
                 finally {
                     // Store memory after stream consumption is complete
-                    if (self.conversationMemory) {
+                    if (self.conversationMemory && enhancedOptions.context?.sessionId) {
+                        const storageStartTime = Date.now();
+                        const sessionId = enhancedOptions.context?.sessionId;
+                        const userId = enhancedOptions.context
+                            ?.userId;
                         try {
-                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
-                                ?.sessionId, enhancedOptions.context
-                                ?.userId, originalPrompt ?? "", accumulatedContent, new Date(startTime));
+                            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: enhancedOptions.context
-                                    ?.sessionId,
+                                sessionId,
                                 userInputLength: originalPrompt?.length ?? 0,
                                 responseLength: accumulatedContent.length,
                             });
                         }
                         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),
                             });
@@ -2147,12 +2184,37 @@ export class NeuroLink {
             }
             finally {
                 // Store memory after fallback stream consumption is complete
-                if (self.conversationMemory) {
+                if (self.conversationMemory && enhancedOptions?.context?.sessionId) {
+                    const storageStartTime = Date.now();
+                    const sessionId = enhancedOptions?.context?.sessionId;
+                    const userId = enhancedOptions?.context
+                        ?.userId;
                     try {
-                        const sessionId = enhancedOptions?.context?.sessionId;
-                        const userId = enhancedOptions?.context
-                            ?.userId;
+                        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,
@@ -2160,6 +2222,18 @@ 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),
                         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.52.0",
+  "version": "7.53.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -56,11 +56,22 @@
     "// Shell Script Conversion": "",
     "convert:shell-scripts": "node tools/automation/shellConverter.js",
     "convert:specific": "node tools/automation/shellConverter.js --specific",
-    "// Testing (Single Continuous Test Suite)": "",
-    "test": "pnpm run test:providers",
-    "test:providers": "npx tsx test/continuous-test-suite.ts",
+    "// Testing (Enhanced Vitest Framework)": "",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "test:providers": "vitest run test/unit/providers",
+    "test:cli": "vitest run test/integration/cli",
+    "test:sdk": "vitest run test/unit/sdk",
+    "test:integration": "vitest run test/integration",
+    "test:e2e": "vitest run test/e2e",
+    "test:ci": "vitest run --coverage --reporter=junit --reporter=verbose",
+    "test:debug": "vitest --inspect-brk",
     "test:performance": "node tools/testing/performanceMonitor.js",
-    "test:ci": "pnpm run test:providers && pnpm run test:performance",
+    "// Legacy Testing Support (during transition)": "",
+    "test:legacy": "npx tsx test/continuous-test-suite.ts",
+    "test:comparison": "pnpm run test && pnpm run test:legacy",
     "// Content Generation (Cross-platform JS)": "",
     "content:videos": "node tools/converted-scripts/generateAllVideos.js",
     "content:cleanup": "node tools/converted-scripts/cleanupHashNamedVideos.js",