@juspay/neurolink 8.19.1 → 8.20.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [8.20.0](https://github.com/juspay/neurolink/compare/v8.19.1...v8.20.0) (2025-12-22)
+
+### Features
+
+- **(memory):** Implement token based summarization ([ffdc902](https://github.com/juspay/neurolink/commit/ffdc902f534c97a5aff38d7de419021fcabcd791))
+
 ## [8.19.1](https://github.com/juspay/neurolink/compare/v8.19.0...v8.19.1) (2025-12-20)
 
 ### Bug Fixes

package/dist/cli/loop/optionsSchema.js

@@ -61,5 +61,9 @@ export const textGenerationOptionsSchema = {
         type: "string",
         description: "Context about tools/MCPs used in the interaction.",
     },
+    enableSummarization: {
+        type: "boolean",
+        description: "Enable or disable automatic conversation summarization for this request.",
+    },
 };
 //# sourceMappingURL=optionsSchema.js.map

package/dist/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/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,12 +71,16 @@ 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",
     };
 }

package/dist/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/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/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;

package/dist/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/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
      */