@juspay/neurolink 8.19.1 → 8.20.0

package/dist/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/config/conversationMemory.d.ts

@@ -20,6 +20,21 @@ export declare const MESSAGES_PER_TURN = 2;
  * Used to enhance system prompts when conversation history exists
  */
 export declare const CONVERSATION_INSTRUCTIONS = "\n\nIMPORTANT: You are continuing an ongoing conversation. The previous messages in this conversation contain important context including:\n- Names, personal information, and preferences shared by the user\n- Projects, tasks, and topics discussed previously  \n- Any decisions, agreements, or conclusions reached\n\nAlways reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.";
+/**
+ * Percentage of model context window to use for conversation memory threshold
+ * Default: 80% of model's context window
+ */
+export declare const MEMORY_THRESHOLD_PERCENTAGE = 0.8;
+/**
+ * Fallback token threshold if model context unknown
+ */
+export declare const DEFAULT_FALLBACK_THRESHOLD = 50000;
+/**
+ * Ratio of threshold to keep as recent unsummarized messages
+ * When summarization triggers, this percentage of tokens from the end
+ * are preserved as detailed messages, while older content gets summarized.
+ */
+export declare const RECENT_MESSAGES_RATIO = 0.3;
 /**
  * Structured output instructions for JSON/structured output mode
  * Used to ensure AI providers output only valid JSON without conversational filler

package/dist/lib/config/conversationMemory.js

@@ -26,6 +26,21 @@ IMPORTANT: You are continuing an ongoing conversation. The previous messages in
 - Any decisions, agreements, or conclusions reached
 
 Always reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.`;
+/**
+ * Percentage of model context window to use for conversation memory threshold
+ * Default: 80% of model's context window
+ */
+export const MEMORY_THRESHOLD_PERCENTAGE = 0.8;
+/**
+ * Fallback token threshold if model context unknown
+ */
+export const DEFAULT_FALLBACK_THRESHOLD = 50000;
+/**
+ * Ratio of threshold to keep as recent unsummarized messages
+ * When summarization triggers, this percentage of tokens from the end
+ * are preserved as detailed messages, while older content gets summarized.
+ */
+export const RECENT_MESSAGES_RATIO = 0.3;
 /**
  * Structured output instructions for JSON/structured output mode
  * Used to ensure AI providers output only valid JSON without conversational filler
@@ -56,13 +71,17 @@ export function getConversationMemoryDefaults() {
     return {
         enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
+        enableSummarization: process.env.NEUROLINK_SUMMARIZATION_ENABLED !== "false",
+        tokenThreshold: process.env.NEUROLINK_TOKEN_THRESHOLD
+            ? Number(process.env.NEUROLINK_TOKEN_THRESHOLD)
+            : undefined,
+        summarizationProvider: process.env.NEUROLINK_SUMMARIZATION_PROVIDER || "vertex",
+        summarizationModel: process.env.NEUROLINK_SUMMARIZATION_MODEL || "gemini-2.5-flash",
+        // Deprecated (for backward compatibility)
         maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) ||
             DEFAULT_MAX_TURNS_PER_SESSION,
-        enableSummarization: process.env.NEUROLINK_SUMMARIZATION_ENABLED === "true",
         summarizationThresholdTurns: Number(process.env.NEUROLINK_SUMMARIZATION_THRESHOLD_TURNS) || 20,
         summarizationTargetTurns: Number(process.env.NEUROLINK_SUMMARIZATION_TARGET_TURNS) || 10,
-        summarizationProvider: process.env.NEUROLINK_SUMMARIZATION_PROVIDER || "vertex",
-        summarizationModel: process.env.NEUROLINK_SUMMARIZATION_MODEL || "gemini-2.5-flash",
     };
 }
 //# sourceMappingURL=conversationMemory.js.map

package/dist/lib/core/conversationMemoryFactory.js

@@ -14,10 +14,7 @@ export function createConversationMemoryManager(config, storageType = "memory",
         config: {
             enabled: config.enabled,
             maxSessions: config.maxSessions,
-            maxTurnsPerSession: config.maxTurnsPerSession,
             enableSummarization: config.enableSummarization,
-            summarizationThresholdTurns: config.summarizationThresholdTurns,
-            summarizationTargetTurns: config.summarizationTargetTurns,
             summarizationProvider: config.summarizationProvider,
             summarizationModel: config.summarizationModel,
         },

package/dist/lib/core/conversationMemoryInitializer.js

@@ -62,15 +62,7 @@ export async function initializeConversationMemory(config) {
                     "RedisConversationMemoryManager",
                 hasConfig: !!redisMemoryManager?.config,
             });
-            logger.info("[conversationMemoryInitializer] Redis conversation memory manager created successfully", {
-                configSource,
-                host: redisConfig.host || "localhost",
-                port: redisConfig.port || 6379,
-                keyPrefix: redisConfig.keyPrefix || "neurolink:conversation:",
-                maxSessions: memoryConfig.maxSessions,
-                maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
-                managerType: redisMemoryManager?.constructor?.name,
-            });
+            logger.info("[conversationMemoryInitializer] Redis conversation memory manager created successfully");
             // Perform basic validation
             if (redisMemoryManager?.constructor?.name !==
                 "RedisConversationMemoryManager") {

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

@@ -2,11 +2,15 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage } from "../types/conversation.js";
+import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, StoreConversationTurnOptions } from "../types/conversation.js";
 export declare class ConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
     private isInitialized;
+    /**
+     * Track sessions currently being summarized to prevent race conditions
+     */
+    private summarizationInProgress;
     constructor(config: ConversationMemoryConfig);
     /**
      * Initialize the memory manager
@@ -14,19 +18,38 @@ export declare class ConversationMemoryManager {
     initialize(): Promise<void>;
     /**
      * 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
+     */
+    storeConversationTurn(options: StoreConversationTurnOptions): Promise<void>;
+    /**
+     * Validate and prepare a message before adding to session
+     * Truncates if message exceeds token limit
+     */
+    private validateAndPrepareMessage;
+    /**
+     * Check if summarization is needed based on token count
      */
-    storeConversationTurn(sessionId: string, userId: string | undefined, userMessage: string, aiResponse: string, _startTimeStamp: Date | undefined): Promise<void>;
+    private checkAndSummarize;
     /**
-     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
-     * Returns pre-stored message array with zero conversion overhead
+     * Estimate total tokens for a list of messages
+     */
+    private estimateTokens;
+    /**
+     * 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
      */
     buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
     getSession(sessionId: string): SessionMemory | undefined;
-    createSummarySystemMessage(content: string): ChatMessage;
-    private _summarizeSession;
-    private _createSummarizationPrompt;
+    createSummarySystemMessage(content: string, summarizesFrom?: string, summarizesTo?: string): ChatMessage;
+    /**
+     * Token-based summarization (pointer-based, non-destructive)
+     */
+    private summarizeSessionTokenBased;
+    /**
+     * Find split index to keep recent messages within target token count
+     */
+    private findSplitIndexByTokens;
     private ensureInitialized;
     private createNewSession;
     private enforceSessionLimit;