@juspay/neurolink 8.19.1 → 8.20.0

package/dist/lib/core/conversationMemoryManager.js

@@ -3,13 +3,19 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversation.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
+import { DEFAULT_MAX_SESSIONS, MEMORY_THRESHOLD_PERCENTAGE, RECENT_MESSAGES_RATIO, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
 import { logger } from "../utils/logger.js";
-import { NeuroLink } from "../neurolink.js";
+import { randomUUID } from "crypto";
+import { TokenUtils } from "../constants/tokens.js";
+import { buildContextFromPointer, getEffectiveTokenThreshold, generateSummary, } from "../utils/conversationMemory.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
     isInitialized = false;
+    /**
+     * Track sessions currently being summarized to prevent race conditions
+     */
+    summarizationInProgress = new Set();
     constructor(config) {
         this.config = config;
     }
@@ -34,121 +40,209 @@ export class ConversationMemoryManager {
     }
     /**
      * Store a conversation turn for a session
-     * ULTRA-OPTIMIZED: Direct ChatMessage[] storage with zero conversion overhead
+     * TOKEN-BASED: Validates message size and triggers summarization based on tokens
      */
-    async storeConversationTurn(sessionId, userId, userMessage, aiResponse, _startTimeStamp) {
+    async storeConversationTurn(options) {
         await this.ensureInitialized();
         try {
             // Get or create session
-            let session = this.sessions.get(sessionId);
+            let session = this.sessions.get(options.sessionId);
             if (!session) {
-                session = this.createNewSession(sessionId, userId);
-                this.sessions.set(sessionId, session);
+                session = this.createNewSession(options.sessionId, options.userId);
+                this.sessions.set(options.sessionId, session);
             }
-            // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
-            session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
+            const tokenThreshold = options.providerDetails
+                ? getEffectiveTokenThreshold(options.providerDetails.provider, options.providerDetails.model, this.config.tokenThreshold, session.tokenThreshold)
+                : this.config.tokenThreshold || 50000;
+            const userMsg = await this.validateAndPrepareMessage(options.userMessage, "user", tokenThreshold);
+            const assistantMsg = await this.validateAndPrepareMessage(options.aiResponse, "assistant", tokenThreshold);
+            session.messages.push(userMsg, assistantMsg);
             session.lastActivity = Date.now();
-            if (this.config.enableSummarization) {
-                const userAssistantCount = session.messages.filter((msg) => msg.role === "user" || msg.role === "assistant").length;
-                const currentTurnCount = Math.floor(userAssistantCount / MESSAGES_PER_TURN);
-                if (currentTurnCount >= (this.config.summarizationThresholdTurns || 20)) {
-                    await this._summarizeSession(session);
+            const shouldSummarize = options.enableSummarization !== undefined
+                ? options.enableSummarization
+                : this.config.enableSummarization;
+            if (shouldSummarize) {
+                // Only trigger summarization if not already in progress for this session
+                if (!this.summarizationInProgress.has(options.sessionId)) {
+                    setImmediate(async () => {
+                        try {
+                            await this.checkAndSummarize(session, tokenThreshold);
+                        }
+                        catch (error) {
+                            logger.error("Background summarization failed", {
+                                sessionId: session.sessionId,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    });
                 }
-            }
-            else {
-                const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
-                    MESSAGES_PER_TURN;
-                if (session.messages.length > maxMessages) {
-                    session.messages = session.messages.slice(-maxMessages);
+                else {
+                    logger.debug("[ConversationMemoryManager] Summarization already in progress, skipping", {
+                        sessionId: options.sessionId,
+                    });
                 }
             }
             this.enforceSessionLimit();
         }
         catch (error) {
-            throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
-                sessionId,
+            throw new ConversationMemoryError(`Failed to store conversation turn for session ${options.sessionId}`, "STORAGE_ERROR", {
+                sessionId: options.sessionId,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
     }
     /**
-     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
-     * Returns pre-stored message array with zero conversion overhead
+     * Validate and prepare a message before adding to session
+     * Truncates if message exceeds token limit
+     */
+    async validateAndPrepareMessage(content, role, threshold) {
+        const id = randomUUID();
+        const tokenCount = TokenUtils.estimateTokenCount(content);
+        const maxMessageSize = Math.floor(threshold * MEMORY_THRESHOLD_PERCENTAGE);
+        if (tokenCount > maxMessageSize) {
+            const truncated = TokenUtils.truncateToTokenLimit(content, maxMessageSize);
+            logger.warn("Message truncated due to token limit", {
+                id,
+                role,
+                originalTokens: tokenCount,
+                threshold,
+                truncatedTo: maxMessageSize,
+            });
+            return {
+                id,
+                role,
+                content: truncated,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    truncated: true,
+                },
+            };
+        }
+        return {
+            id,
+            role,
+            content,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Check if summarization is needed based on token count
+     */
+    async checkAndSummarize(session, threshold) {
+        // Acquire lock - if already in progress, skip
+        if (this.summarizationInProgress.has(session.sessionId)) {
+            logger.debug("[ConversationMemoryManager] Summarization already in progress, skipping", {
+                sessionId: session.sessionId,
+            });
+            return;
+        }
+        this.summarizationInProgress.add(session.sessionId);
+        try {
+            const contextMessages = buildContextFromPointer(session);
+            const tokenCount = this.estimateTokens(contextMessages);
+            session.lastTokenCount = tokenCount;
+            session.lastCountedAt = Date.now();
+            logger.debug("Token count check", {
+                sessionId: session.sessionId,
+                tokenCount,
+                threshold,
+                needsSummarization: tokenCount >= threshold,
+            });
+            if (tokenCount >= threshold) {
+                await this.summarizeSessionTokenBased(session, threshold);
+            }
+        }
+        catch (error) {
+            logger.error("Token counting or summarization failed", {
+                sessionId: session.sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            // Release lock when done
+            this.summarizationInProgress.delete(session.sessionId);
+        }
+    }
+    /**
+     * 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)
+     * Returns messages from pointer onwards (or all if no pointer)
      * Now consistently async to match Redis implementation
      */
     async buildContextMessages(sessionId) {
         const session = this.sessions.get(sessionId);
-        return session ? session.messages : [];
+        return session ? buildContextFromPointer(session) : [];
     }
     getSession(sessionId) {
         return this.sessions.get(sessionId);
     }
-    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,
+            },
         };
     }
-    async _summarizeSession(session) {
-        logger.info(`[ConversationMemory] Summarizing session ${session.sessionId}...`);
-        const targetTurns = this.config.summarizationTargetTurns || 10;
-        const splitIndex = Math.max(0, session.messages.length - targetTurns * MESSAGES_PER_TURN);
-        const messagesToSummarize = session.messages.slice(0, splitIndex);
-        const recentMessages = session.messages.slice(splitIndex);
+    /**
+     * Token-based summarization (pointer-based, non-destructive)
+     */
+    async summarizeSessionTokenBased(session, threshold) {
+        const startIndex = session.summarizedUpToMessageId
+            ? session.messages.findIndex((m) => m.id === session.summarizedUpToMessageId) + 1
+            : 0;
+        const recentMessages = session.messages.slice(startIndex);
+        if (recentMessages.length === 0) {
+            return;
+        }
+        const targetRecentTokens = threshold * RECENT_MESSAGES_RATIO;
+        const splitIndex = await this.findSplitIndexByTokens(recentMessages, targetRecentTokens);
+        const messagesToSummarize = recentMessages.slice(0, splitIndex);
         if (messagesToSummarize.length === 0) {
             return;
         }
-        const summarizationPrompt = this._createSummarizationPrompt(messagesToSummarize);
-        const summarizer = new NeuroLink({
-            conversationMemory: { enabled: false },
+        const summary = await generateSummary(messagesToSummarize, this.config, "[ConversationMemory]", session.summarizedMessage);
+        if (!summary) {
+            logger.warn(`[ConversationMemory] Summary generation failed for session ${session.sessionId}`);
+            return;
+        }
+        const lastSummarized = messagesToSummarize[messagesToSummarize.length - 1];
+        session.summarizedUpToMessageId = lastSummarized.id;
+        session.summarizedMessage = summary; // Store summary separately
+        logger.info(`[ConversationMemory] Summarization complete for session ${session.sessionId}`, {
+            summarizedCount: messagesToSummarize.length,
+            totalMessages: session.messages.length,
+            pointer: session.summarizedUpToMessageId,
         });
-        try {
-            const providerName = this.config.summarizationProvider;
-            // Map provider names to correct format
-            let mappedProvider = providerName;
-            if (providerName === "vertex") {
-                mappedProvider = "googlevertex";
-            }
-            if (!mappedProvider) {
-                logger.error(`[ConversationMemory] Missing summarization provider`);
-                return;
-            }
-            logger.debug(`[ConversationMemory] Using provider: ${mappedProvider} for summarization`);
-            const summaryResult = await summarizer.generate({
-                input: { text: summarizationPrompt },
-                provider: mappedProvider,
-                model: this.config.summarizationModel,
-                disableTools: true,
-            });
-            if (summaryResult.content) {
-                session.messages = [
-                    this.createSummarySystemMessage(summaryResult.content),
-                    ...recentMessages,
-                ];
-                logger.info(`[ConversationMemory] Summarization complete for session ${session.sessionId}.`);
-            }
-            else {
-                logger.warn(`[ConversationMemory] Summarization failed for session ${session.sessionId}. History not modified.`);
+    }
+    /**
+     * 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;
         }
-        catch (error) {
-            logger.error(`[ConversationMemory] Error during summarization for session ${session.sessionId}`, { error });
-        }
-    }
-    _createSummarizationPrompt(history) {
-        const formattedHistory = history
-            .map((msg) => `${msg.role}: ${msg.content}`)
-            .join("\n\n");
-        return `
-You are a context summarization AI. Your task is to condense the following conversation history for another AI assistant.
-The summary must be a concise, third-person narrative that retains all critical information, including key entities, technical details, decisions made, and any specific dates or times mentioned.
-Ensure the summary flows logically and is ready to be used as context for the next turn in the conversation.
-
-Conversation History to Summarize:
----
-${formattedHistory}
----
-`.trim();
+        // To ensure at least one message is summarized
+        return Math.max(1, splitIndex);
     }
     async ensureInitialized() {
         if (!this.isInitialized) {

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

@@ -2,7 +2,7 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage, RedisStorageConfig, SessionMetadata, RedisConversationObject } from "../types/conversation.js";
+import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage, RedisStorageConfig, SessionMetadata, RedisConversationObject, StoreConversationTurnOptions } from "../types/conversation.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -22,6 +22,11 @@ export declare class RedisConversationMemoryManager {
      * Key format: "${sessionId}:${userId}"
      */
     private titleGenerationInProgress;
+    /**
+     * Track sessions currently being summarized to prevent race conditions
+     * Key format: "${sessionId}:${userId}"
+     */
+    private summarizationInProgress;
     constructor(config: ConversationMemoryConfig, redisConfig?: RedisStorageConfig);
     /**
      * Initialize the memory manager with Redis connection
@@ -39,18 +44,10 @@ export declare class RedisConversationMemoryManager {
      * Remove a session from user's session set (private method)
      */
     private removeUserSession;
-    /**
-     * Generate next message ID for a conversation
-     */
-    private generateMessageId;
     /**
      * Generate current timestamp in ISO format
      */
     private generateTimestamp;
-    /**
-     * Generate a unique conversation ID using UUID v4
-     */
-    private generateUniqueId;
     /**
      * Store tool execution data for a session (temporarily to avoid race conditions)
      */
@@ -68,11 +65,29 @@ export declare class RedisConversationMemoryManager {
     /**
      * Store a conversation turn for a session
      */
-    storeConversationTurn(sessionId: string, userId: string | undefined, userMessage: string, aiResponse: string, startTimeStamp: Date | undefined): Promise<void>;
+    storeConversationTurn(options: StoreConversationTurnOptions): Promise<void>;
+    /**
+     * Check if summarization is needed based on token count
+     */
+    private checkAndSummarize;
+    /**
+     * Estimate total tokens for a list of messages
+     */
+    private estimateTokens;
+    /**
+     * Token-based summarization (pointer-based, non-destructive)
+     */
+    private summarizeSessionTokenBased;
+    /**
+     * Find split index to keep recent messages within target token count
+     */
+    private findSplitIndexByTokens;
     /**
-     * Build context messages for AI prompt injection
+     * 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
      */
-    buildContextMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
+    buildContextMessages(sessionId: string, userId?: string, enableSummarization?: boolean): Promise<ChatMessage[]>;
     /**
      * Get session metadata for a specific user session (optimized for listing)
      * Fetches only essential metadata without heavy message arrays
@@ -110,7 +125,7 @@ export declare class RedisConversationMemoryManager {
     /**
      * Create summary system message
      */
-    createSummarySystemMessage(content: string): ChatMessage;
+    createSummarySystemMessage(content: string, summarizesFrom?: string, summarizesTo?: string): ChatMessage;
     /**
      * Close Redis connection
      */