@juspay/neurolink 8.19.1 → 8.20.0

package/dist/lib/core/redisConversationMemoryManager.js

@@ -4,10 +4,12 @@
  */
 import { randomUUID } from "crypto";
 import { ConversationMemoryError } from "../types/conversation.js";
-import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
+import { MESSAGES_PER_TURN, RECENT_MESSAGES_RATIO, } 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";
+import { TokenUtils } from "../constants/tokens.js";
+import { buildContextFromPointer, getEffectiveTokenThreshold, generateSummary, } from "../utils/conversationMemory.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -27,6 +29,11 @@ export class RedisConversationMemoryManager {
      * Key format: "${sessionId}:${userId}"
      */
     titleGenerationInProgress = new Set();
+    /**
+     * Track sessions currently being summarized to prevent race conditions
+     * Key format: "${sessionId}:${userId}"
+     */
+    summarizationInProgress = new Set();
     constructor(config, redisConfig = {}) {
         this.config = config;
         this.redisConfig = getNormalizedConfig(redisConfig);
@@ -138,25 +145,12 @@ export class RedisConversationMemoryManager {
             return false;
         }
     }
-    /**
-     * Generate next message ID for a conversation
-     */
-    generateMessageId(conversation) {
-        const currentCount = conversation?.messages?.length || 0;
-        return `msg_${currentCount + 1}`;
-    }
     /**
      * Generate current timestamp in ISO format
      */
     generateTimestamp() {
         return new Date().toISOString();
     }
-    /**
-     * Generate a unique conversation ID using UUID v4
-     */
-    generateUniqueId() {
-        return randomUUID();
-    }
     /**
      * Store tool execution data for a session (temporarily to avoid race conditions)
      */
@@ -224,49 +218,31 @@ export class RedisConversationMemoryManager {
     /**
      * Store a conversation turn for a session
      */
-    async storeConversationTurn(sessionId, userId, userMessage, aiResponse, startTimeStamp) {
+    async storeConversationTurn(options) {
         logger.debug("[RedisConversationMemoryManager] Storing conversation turn", {
-            sessionId,
-            userId,
-            userMessageLength: userMessage.length,
-            aiResponseLength: aiResponse.length,
+            sessionId: options.sessionId,
+            userId: options.userId,
         });
         await this.ensureInitialized();
         try {
             if (!this.redisClient) {
                 throw new Error("Redis client not initialized");
             }
-            // Generate Redis key
-            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-            // Get existing conversation object
+            const redisKey = getSessionKey(this.redisConfig, options.sessionId, options.userId);
             const conversationData = await this.redisClient.get(redisKey);
             let conversation = deserializeConversation(conversationData);
             const currentTime = new Date().toISOString();
-            const normalizedUserId = userId || "randomUser";
-            // If no existing conversation, create a new one
+            const normalizedUserId = options.userId || "randomUser";
             if (!conversation) {
-                // Generate title asynchronously in the background (non-blocking)
-                const titleGenerationKey = `${sessionId}:${normalizedUserId}`;
+                const titleGenerationKey = `${options.sessionId}:${normalizedUserId}`;
                 setImmediate(async () => {
-                    // Check if title generation is already in progress for this session
                     if (this.titleGenerationInProgress.has(titleGenerationKey)) {
-                        logger.debug("[RedisConversationMemoryManager] Title generation already in progress, skipping", {
-                            sessionId,
-                            userId: normalizedUserId,
-                            titleGenerationKey,
-                        });
                         return;
                     }
-                    // Mark title generation as in progress
                     this.titleGenerationInProgress.add(titleGenerationKey);
                     try {
-                        const title = await this.generateConversationTitle(userMessage);
-                        logger.info("[RedisConversationMemoryManager] Successfully generated conversation title", {
-                            sessionId,
-                            userId: normalizedUserId,
-                            title,
-                        });
-                        const updatedRedisKey = getSessionKey(this.redisConfig, sessionId, userId || undefined);
+                        const title = await this.generateConversationTitle(options.userMessage);
+                        const updatedRedisKey = getSessionKey(this.redisConfig, options.sessionId, options.userId || undefined);
                         const updatedConversationData = await this.redisClient?.get(updatedRedisKey);
                         const updatedConversation = deserializeConversation(updatedConversationData || null);
                         if (updatedConversation) {
@@ -281,7 +257,7 @@ export class RedisConversationMemoryManager {
                     }
                     catch (titleError) {
                         logger.warn("[RedisConversationMemoryManager] Failed to generate conversation title in background", {
-                            sessionId,
+                            sessionId: options.sessionId,
                             userId: normalizedUserId,
                             error: titleError instanceof Error
                                 ? titleError.message
@@ -289,136 +265,243 @@ export class RedisConversationMemoryManager {
                         });
                     }
                     finally {
-                        // Always remove from tracking set when done (success or failure)
                         this.titleGenerationInProgress.delete(titleGenerationKey);
-                        logger.debug("[RedisConversationMemoryManager] Title generation completed, removed from tracking", {
-                            sessionId,
-                            userId: normalizedUserId,
-                            titleGenerationKey,
-                            remainingInProgress: this.titleGenerationInProgress.size,
-                        });
                     }
                 });
                 conversation = {
-                    id: this.generateUniqueId(), // Generate unique UUID v4 for conversation
+                    id: randomUUID(),
                     title: "New Conversation", // Temporary title until generated
-                    sessionId,
+                    sessionId: options.sessionId,
                     userId: normalizedUserId,
-                    createdAt: startTimeStamp?.toISOString() || currentTime,
-                    updatedAt: startTimeStamp?.toISOString() || currentTime,
+                    createdAt: options.startTimeStamp?.toISOString() || currentTime,
+                    updatedAt: options.startTimeStamp?.toISOString() || currentTime,
                     messages: [],
                 };
             }
             else {
-                // Update existing conversation timestamp
                 conversation.updatedAt = currentTime;
             }
-            logger.info("[RedisConversationMemoryManager] Processing conversation", {
-                isNewConversation: !conversationData,
-                messageCount: conversation.messages.length,
-                sessionId: conversation.sessionId,
-                userId: conversation.userId,
-            });
-            // Add new messages to conversation history with new format
+            const tokenThreshold = options.providerDetails
+                ? getEffectiveTokenThreshold(options.providerDetails.provider, options.providerDetails.model, this.config.tokenThreshold, conversation.tokenThreshold)
+                : this.config.tokenThreshold || 50000;
             const userMsg = {
-                id: this.generateMessageId(conversation),
-                timestamp: startTimeStamp?.toISOString() || this.generateTimestamp(),
+                id: randomUUID(),
+                timestamp: options.startTimeStamp?.toISOString() || this.generateTimestamp(),
                 role: "user",
-                content: userMessage,
+                content: options.userMessage,
             };
             conversation.messages.push(userMsg);
-            await this.flushPendingToolData(conversation, sessionId, normalizedUserId);
+            await this.flushPendingToolData(conversation, options.sessionId, normalizedUserId);
             const assistantMsg = {
-                id: this.generateMessageId(conversation),
+                id: randomUUID(),
                 timestamp: this.generateTimestamp(),
                 role: "assistant",
-                content: aiResponse,
+                content: options.aiResponse,
             };
             conversation.messages.push(assistantMsg);
             logger.info("[RedisConversationMemoryManager] Added new messages", {
-                newMessageCount: conversation.messages.length,
-                latestMessages: [
-                    {
-                        role: conversation.messages[conversation.messages.length - 2]?.role,
-                        contentLength: conversation.messages[conversation.messages.length - 2]?.content
-                            .length,
-                    },
-                    {
-                        role: conversation.messages[conversation.messages.length - 1]?.role,
-                        contentLength: conversation.messages[conversation.messages.length - 1]?.content
-                            .length,
-                    },
-                ],
+                sessionId: conversation.sessionId,
+                userId: conversation.userId,
             });
-            // Save updated conversation object
+            // Use per-request enableSummarization with higher priority than instance config
+            const shouldSummarize = options.enableSummarization !== undefined
+                ? options.enableSummarization
+                : this.config.enableSummarization;
+            if (shouldSummarize) {
+                const normalizedUserId = options.userId || "randomUser";
+                const summarizationKey = `${options.sessionId}:${normalizedUserId}`;
+                // Only trigger summarization if not already in progress for this session
+                if (!this.summarizationInProgress.has(summarizationKey)) {
+                    setImmediate(async () => {
+                        try {
+                            await this.checkAndSummarize(conversation, tokenThreshold, options.sessionId, options.userId);
+                        }
+                        catch (error) {
+                            logger.error("Background summarization failed", {
+                                sessionId: conversation.sessionId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    });
+                }
+                else {
+                    logger.debug("[RedisConversationMemoryManager] Summarization already in progress, skipping", {
+                        sessionId: options.sessionId,
+                        userId: normalizedUserId,
+                    });
+                }
+            }
             const serializedData = serializeConversation(conversation);
-            logger.debug("[RedisConversationMemoryManager] Saving conversation to Redis", {
-                redisKey,
-                messageCount: conversation.messages.length,
-                serializedDataLength: serializedData.length,
-                title: conversation.title,
-            });
-            logger.info("Storing conversation data to Redis", {
-                sessionId,
-                dataLength: serializedData.length,
-                messageCount: conversation.messages.length,
-            });
             await this.redisClient.set(redisKey, serializedData);
-            // Set TTL if configured
             if (this.redisConfig.ttl > 0) {
-                logger.debug("[RedisConversationMemoryManager] Setting Redis TTL", {
-                    redisKey,
-                    ttl: this.redisConfig.ttl,
-                });
                 await this.redisClient.expire(redisKey, this.redisConfig.ttl);
             }
-            // Add session to user's session set
-            if (userId) {
-                await this.addUserSession(userId, sessionId);
+            if (options.userId) {
+                await this.addUserSession(options.userId, options.sessionId);
             }
             logger.debug("[RedisConversationMemoryManager] Successfully stored conversation turn", {
-                sessionId,
+                sessionId: options.sessionId,
                 totalMessages: conversation.messages.length,
                 title: conversation.title,
             });
         }
         catch (error) {
-            throw new ConversationMemoryError(`Failed to store conversation turn in Redis for session ${sessionId}`, "STORAGE_ERROR", {
+            throw new ConversationMemoryError(`Failed to store conversation turn in Redis for session ${options.sessionId}`, "STORAGE_ERROR", {
+                sessionId: options.sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Check if summarization is needed based on token count
+     */
+    async checkAndSummarize(conversation, threshold, sessionId, userId) {
+        const normalizedUserId = userId || "randomUser";
+        const summarizationKey = `${sessionId}:${normalizedUserId}`;
+        // Acquire lock - if already in progress, skip
+        if (this.summarizationInProgress.has(summarizationKey)) {
+            logger.debug("[RedisConversationMemoryManager] Summarization already in progress, skipping", {
                 sessionId,
+                userId: normalizedUserId,
+            });
+            return;
+        }
+        this.summarizationInProgress.add(summarizationKey);
+        try {
+            const session = {
+                sessionId: conversation.sessionId,
+                userId: conversation.userId,
+                messages: conversation.messages,
+                summarizedUpToMessageId: conversation.summarizedUpToMessageId,
+                summarizedMessage: conversation.summarizedMessage,
+                tokenThreshold: conversation.tokenThreshold,
+                lastTokenCount: conversation.lastTokenCount,
+                lastCountedAt: conversation.lastCountedAt,
+                createdAt: new Date(conversation.createdAt).getTime(),
+                lastActivity: new Date(conversation.updatedAt).getTime(),
+            };
+            const contextMessages = buildContextFromPointer(session);
+            const tokenCount = this.estimateTokens(contextMessages);
+            conversation.lastTokenCount = tokenCount;
+            conversation.lastCountedAt = Date.now();
+            if (tokenCount >= threshold) {
+                await this.summarizeSessionTokenBased(conversation, threshold, sessionId, userId);
+            }
+        }
+        catch (error) {
+            logger.error("Token counting or summarization failed", {
+                sessionId: conversation.sessionId,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
+        finally {
+            // Release lock when done
+            this.summarizationInProgress.delete(summarizationKey);
+        }
+    }
+    /**
+     * Estimate total tokens for a list of messages
+     */
+    estimateTokens(messages) {
+        return messages.reduce((total, msg) => {
+            return total + TokenUtils.estimateTokenCount(msg.content);
+        }, 0);
     }
     /**
-     * Build context messages for AI prompt injection
+     * Token-based summarization (pointer-based, non-destructive)
      */
-    async buildContextMessages(sessionId, userId) {
+    async summarizeSessionTokenBased(conversation, threshold, sessionId, userId) {
+        const startIndex = conversation.summarizedUpToMessageId
+            ? conversation.messages.findIndex((m) => m.id === conversation.summarizedUpToMessageId) + 1
+            : 0;
+        const recentMessages = conversation.messages.slice(startIndex);
+        if (recentMessages.length === 0) {
+            return;
+        }
+        // We only want to include user, assistant, and system messages in summarization
+        const filteredRecentMessages = recentMessages.filter((msg) => msg.role !== "tool_call" && msg.role !== "tool_result");
+        const targetRecentTokens = threshold * RECENT_MESSAGES_RATIO;
+        const splitIndex = await this.findSplitIndexByTokens(filteredRecentMessages, targetRecentTokens);
+        const messagesToSummarize = filteredRecentMessages.slice(0, splitIndex);
+        if (messagesToSummarize.length === 0) {
+            return;
+        }
+        const summary = await generateSummary(messagesToSummarize, this.config, "[RedisConversationMemoryManager]", conversation.summarizedMessage);
+        if (!summary) {
+            logger.warn(`[RedisConversationMemoryManager] Summary generation failed for session ${conversation.sessionId}`);
+            return;
+        }
+        const lastSummarized = messagesToSummarize[messagesToSummarize.length - 1];
+        conversation.summarizedUpToMessageId = lastSummarized.id;
+        conversation.summarizedMessage = summary;
+        if (this.redisClient) {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const serializedData = serializeConversation(conversation);
+            await this.redisClient.set(redisKey, serializedData);
+            if (this.redisConfig.ttl > 0) {
+                await this.redisClient.expire(redisKey, this.redisConfig.ttl);
+            }
+        }
+    }
+    /**
+     * Find split index to keep recent messages within target token count
+     */
+    async findSplitIndexByTokens(messages, targetRecentTokens) {
+        let recentTokens = 0;
+        let splitIndex = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msgTokens = TokenUtils.estimateTokenCount(messages[i].content);
+            if (recentTokens + msgTokens > targetRecentTokens) {
+                splitIndex = i + 1;
+                break;
+            }
+            recentTokens += msgTokens;
+        }
+        // Ensure we're summarizing at least something
+        return Math.max(1, splitIndex);
+    }
+    /**
+     * Build context messages for AI prompt injection (TOKEN-BASED)
+     * Returns messages from pointer onwards (or all if no pointer)
+     * Filters out tool_call and tool_result messages when summarization is enabled
+     */
+    async buildContextMessages(sessionId, userId, enableSummarization) {
         logger.info("[RedisConversationMemoryManager] Building context messages", {
             sessionId,
             userId,
             method: "buildContextMessages",
         });
-        const messages = await this.getUserSessionHistory(userId || "randomUser", sessionId);
-        if (!messages) {
-            logger.info("[RedisConversationMemoryManager] No context messages found", {
-                sessionId,
-                userId,
-            });
+        const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+        const conversationData = await this.redisClient?.get(redisKey);
+        const conversation = deserializeConversation(conversationData || null);
+        if (!conversation) {
             return [];
         }
-        logger.info("[RedisConversationMemoryManager] Retrieved messages", {
-            messageCount: messages.length,
-            hasMessages: messages.length > 0,
-        });
+        const session = {
+            sessionId: conversation.sessionId,
+            userId: conversation.userId,
+            messages: conversation.messages,
+            summarizedUpToMessageId: conversation.summarizedUpToMessageId,
+            summarizedMessage: conversation.summarizedMessage,
+            tokenThreshold: conversation.tokenThreshold,
+            lastTokenCount: conversation.lastTokenCount,
+            lastCountedAt: conversation.lastCountedAt,
+            createdAt: new Date(conversation.createdAt).getTime(),
+            lastActivity: new Date(conversation.updatedAt).getTime(),
+        };
+        const contextMessages = buildContextFromPointer(session);
+        const isSummarizationEnabled = enableSummarization !== undefined
+            ? enableSummarization
+            : this.config.enableSummarization === true;
+        let finalMessages = contextMessages;
+        if (isSummarizationEnabled) {
+            finalMessages = contextMessages.filter((msg) => msg.role !== "tool_call" && msg.role !== "tool_result");
+        }
         logger.info("[RedisConversationMemoryManager] Retrieved context messages", {
             sessionId,
             userId,
-            messageCount: messages.length,
-            messageRoles: messages.map((m) => m.role),
-            firstMessagePreview: messages[0]?.content?.substring(0, 50),
-            lastMessagePreview: messages[messages.length - 1]?.content?.substring(0, 50),
         });
-        return messages;
+        return finalMessages;
     }
     /**
      * Get session metadata for a specific user session (optimized for listing)
@@ -649,10 +732,17 @@ User message: "${userMessage}`;
     /**
      * Create summary system message
      */
-    createSummarySystemMessage(content) {
+    createSummarySystemMessage(content, summarizesFrom, summarizesTo) {
         return {
+            id: `summary-${randomUUID()}`,
             role: "system",
             content: `Summary of previous conversation turns:\n\n${content}`,
+            timestamp: new Date().toISOString(),
+            metadata: {
+                isSummary: true,
+                summarizesFrom,
+                summarizesTo,
+            },
         };
     }
     /**
@@ -876,7 +966,7 @@ User message: "${userMessage}`;
             // Store in mapping for tool results
             toolCallMap.set(toolCallId, toolName);
             const toolCallMessage = {
-                id: this.generateMessageId(conversation),
+                id: randomUUID(),
                 timestamp: toolCall.timestamp?.toISOString() || this.generateTimestamp(),
                 role: "tool_call",
                 content: "", // Can be empty for tool calls
@@ -893,7 +983,7 @@ User message: "${userMessage}`;
             const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
             const toolName = toolCallMap.get(toolCallId) || "unknown";
             const toolResultMessage = {
-                id: this.generateMessageId(conversation),
+                id: randomUUID(),
                 timestamp: toolResult.timestamp?.toISOString() || this.generateTimestamp(),
                 role: "tool_result",
                 content: "", // Can be empty for tool results

package/dist/lib/neurolink.js

@@ -2089,12 +2089,22 @@ Current user's request: ${currentInput}`;
                         if (self.conversationMemory && enhancedOptions.context?.sessionId) {
                             const sessionId = enhancedOptions.context?.sessionId;
                             const userId = enhancedOptions.context?.userId;
+                            let providerDetails = undefined;
+                            if (enhancedOptions.model) {
+                                providerDetails = {
+                                    provider: providerName,
+                                    model: enhancedOptions.model,
+                                };
+                            }
                             try {
-                                await self.conversationMemory.storeConversationTurn(sessionId, userId, originalPrompt ?? "", accumulatedContent, new Date(startTime));
-                                logger.debug("Stream conversation turn stored", {
+                                await self.conversationMemory.storeConversationTurn({
                                     sessionId,
-                                    userInputLength: originalPrompt?.length ?? 0,
-                                    responseLength: accumulatedContent.length,
+                                    userId,
+                                    userMessage: originalPrompt ?? "",
+                                    aiResponse: accumulatedContent,
+                                    startTimeStamp: new Date(startTime),
+                                    providerDetails,
+                                    enableSummarization: enhancedOptions.enableSummarization,
                                 });
                             }
                             catch (error) {
@@ -2194,6 +2204,7 @@ Current user's request: ${currentInput}`;
         const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
         // Get conversation messages for context
         const conversationMessages = await getConversationMessages(this.conversationMemory, {
+            ...options,
             prompt: options.input.text,
             context: options.context,
         });
@@ -2297,12 +2308,22 @@ Current user's request: ${currentInput}`;
                     const sessionId = enhancedOptions?.context?.sessionId;
                     const userId = enhancedOptions?.context
                         ?.userId;
+                    let providerDetails = undefined;
+                    if (options.model) {
+                        providerDetails = {
+                            provider: providerName,
+                            model: options.model,
+                        };
+                    }
                     try {
-                        await self.conversationMemory.storeConversationTurn(sessionId || options.context?.sessionId, userId || options.context?.userId, originalPrompt ?? "", fallbackAccumulatedContent, new Date(startTime));
-                        logger.debug("Fallback stream conversation turn stored", {
+                        await self.conversationMemory.storeConversationTurn({
                             sessionId: sessionId || options.context?.sessionId,
-                            userInputLength: originalPrompt?.length ?? 0,
-                            responseLength: fallbackAccumulatedContent.length,
+                            userId: userId || options.context?.userId,
+                            userMessage: originalPrompt ?? "",
+                            aiResponse: fallbackAccumulatedContent,
+                            startTimeStamp: new Date(startTime),
+                            providerDetails,
+                            enableSummarization: enhancedOptions?.enableSummarization,
                         });
                     }
                     catch (error) {
@@ -4231,23 +4252,9 @@ Current user's request: ${currentInput}`;
             // Import the integration module
             const { initializeConversationMemory } = await import("./core/conversationMemoryInitializer.js");
             // Use the integration module to create the appropriate memory manager
-            const memoryManagerCreateStartTime = process.hrtime.bigint();
             const memoryManager = await initializeConversationMemory(this.conversationMemoryConfig);
             // Assign to conversationMemory with proper type to handle both memory manager types
             this.conversationMemory = memoryManager;
-            const memoryManagerCreateEndTime = process.hrtime.bigint();
-            const memoryManagerCreateDurationNs = memoryManagerCreateEndTime - memoryManagerCreateStartTime;
-            logger.info(`[NeuroLink] ✅ LOG_POINT_G004_MEMORY_LAZY_INIT_SUCCESS`, {
-                logPoint: "G004_MEMORY_LAZY_INIT_SUCCESS",
-                generateInternalId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - generateInternalStartTime,
-                elapsedNs: (process.hrtime.bigint() - generateInternalHrTimeStart).toString(),
-                memoryManagerCreateDurationNs: memoryManagerCreateDurationNs.toString(),
-                memoryManagerCreateDurationMs: Number(memoryManagerCreateDurationNs) / 1000000,
-                storageType: process.env.STORAGE_TYPE || "memory",
-                message: "Lazy conversation memory initialization completed successfully",
-            });
             // Reset the lazy init flag since we've now initialized
             this.conversationMemoryNeedsInit = false;
         }