@juspay/neurolink 7.29.3 → 7.30.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [7.30.0](https://github.com/juspay/neurolink/compare/v7.29.3...v7.30.0) (2025-08-29)
+
+### Features
+
+- **(SDK):** Integrate context summarization with conversation memory BZ-43344 ([a2316ff](https://github.com/juspay/neurolink/commit/a2316ff6df55107316892d33365455e6ebdcbbd9))
+
 ## [7.29.3](https://github.com/juspay/neurolink/compare/v7.29.2...v7.29.3) (2025-08-29)
 
 ### Bug Fixes

package/dist/config/conversationMemoryConfig.js

@@ -36,5 +36,10 @@ export function getConversationMemoryDefaults() {
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
         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/conversationMemoryManager.d.ts

@@ -2,10 +2,10 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
 export declare class ConversationMemoryManager {
     private sessions;
-    private config;
+    config: ConversationMemoryConfig;
     private isInitialized;
     constructor(config: ConversationMemoryConfig);
     /**
@@ -22,20 +22,14 @@ export declare class ConversationMemoryManager {
      * Returns pre-stored message array with zero conversion overhead
      */
     buildContextMessages(sessionId: string): ChatMessage[];
-    /**
-     * Get memory statistics (simplified for pure in-memory storage)
-     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
-     */
-    getStats(): Promise<ConversationMemoryStats>;
-    /**
-     * Clear all conversations for a specific session
-     */
-    clearSession(sessionId: string): Promise<boolean>;
-    /**
-     * Clear all conversations (reset memory)
-     */
-    clearAllSessions(): Promise<void>;
+    getSession(sessionId: string): SessionMemory | undefined;
+    createSummarySystemMessage(content: string): ChatMessage;
+    private _summarizeSession;
+    private _createSummarizationPrompt;
     private ensureInitialized;
     private createNewSession;
     private enforceSessionLimit;
+    getStats(): Promise<ConversationMemoryStats>;
+    clearSession(sessionId: string): Promise<boolean>;
+    clearAllSessions(): Promise<void>;
 }

package/dist/core/conversationMemoryManager.js

@@ -3,14 +3,14 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
+import { NeuroLink } from "../neurolink.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
     isInitialized = false;
     constructor(config) {
-        // Trust that config is already complete from applyConversationMemoryDefaults()
         this.config = config;
     }
     /**
@@ -48,21 +48,19 @@ export class ConversationMemoryManager {
             // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
-            // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
-                MESSAGES_PER_TURN;
-            if (session.messages.length > maxMessages) {
-                session.messages = session.messages.slice(-maxMessages);
+            if (this.config.enableSummarization) {
+                const currentTurnCount = session.messages.length / MESSAGES_PER_TURN;
+                if (currentTurnCount > (this.config.summarizationThresholdTurns || 20)) {
+                    await this._summarizeSession(session);
+                }
+            }
+            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);
+                }
             }
-            // Enforce global session limit
             this.enforceSessionLimit();
-            logger.debug("Conversation turn stored", {
-                sessionId,
-                messageCount: session.messages.length,
-                turnCount: session.messages.length / MESSAGES_PER_TURN, // Each turn = MESSAGES_PER_TURN messages
-                userMessageLength: userMessage.length,
-                aiResponseLength: aiResponse.length,
-            });
         }
         catch (error) {
             throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
@@ -77,48 +75,74 @@ export class ConversationMemoryManager {
      */
     buildContextMessages(sessionId) {
         const session = this.sessions.get(sessionId);
-        if (!session || session.messages.length === 0) {
-            return [];
-        }
-        // ULTRA-OPTIMIZED: Direct return - no processing needed!
-        return session.messages;
+        return session ? session.messages : [];
     }
-    /**
-     * Get memory statistics (simplified for pure in-memory storage)
-     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
-     */
-    async getStats() {
-        await this.ensureInitialized();
-        const sessions = Array.from(this.sessions.values());
-        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    createSummarySystemMessage(content) {
         return {
-            totalSessions: sessions.length,
-            totalTurns,
+            role: "system",
+            content: `Summary of previous conversation turns:\n\n${content}`,
         };
     }
-    /**
-     * Clear all conversations for a specific session
-     */
-    async clearSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return false;
+    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);
+        if (messagesToSummarize.length === 0) {
+            return;
+        }
+        const summarizationPrompt = this._createSummarizationPrompt(messagesToSummarize);
+        const summarizer = new NeuroLink({ conversationMemory: { enabled: false } });
+        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.`);
+            }
+        }
+        catch (error) {
+            logger.error(`[ConversationMemory] Error during summarization for session ${session.sessionId}`, { error });
         }
-        // Remove from memory
-        this.sessions.delete(sessionId);
-        logger.info("Session cleared", { sessionId });
-        return true;
     }
-    /**
-     * Clear all conversations (reset memory)
-     */
-    async clearAllSessions() {
-        const sessionIds = Array.from(this.sessions.keys());
-        // Clear memory
-        this.sessions.clear();
-        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
+    _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();
     }
-    // Private methods
     async ensureInitialized() {
         if (!this.isInitialized) {
             await this.initialize();
@@ -138,16 +162,33 @@ export class ConversationMemoryManager {
         if (this.sessions.size <= maxSessions) {
             return;
         }
-        // Sort sessions by last activity (oldest first)
         const sessions = Array.from(this.sessions.entries()).sort(([, a], [, b]) => a.lastActivity - b.lastActivity);
-        // Remove oldest sessions
-        const sessionsToRemove = sessions.slice(0, sessions.length - maxSessions);
+        const sessionsToRemove = sessions.slice(0, this.sessions.size - maxSessions);
         for (const [sessionId] of sessionsToRemove) {
             this.sessions.delete(sessionId);
         }
-        logger.debug("Session limit enforced", {
-            removedSessions: sessionsToRemove.length,
-            remainingSessions: this.sessions.size,
-        });
+    }
+    async getStats() {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+        return {
+            totalSessions: sessions.length,
+            totalTurns,
+        };
+    }
+    async clearSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        this.sessions.delete(sessionId);
+        logger.info("Session cleared", { sessionId });
+        return true;
+    }
+    async clearAllSessions() {
+        const sessionIds = Array.from(this.sessions.keys());
+        this.sessions.clear();
+        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
     }
 }

package/dist/core/types.d.ts

@@ -3,7 +3,7 @@ import type { ZodUnknownSchema, ValidationSchema } from "../types/typeAliases.js
 import type { GenerateResult } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue } from "../types/common.js";
-import type { ChatMessage } from "../types/conversationTypes.js";
+import type { ChatMessage, ConversationMemoryConfig } from "../types/conversationTypes.js";
 import type { TokenUsage, AnalyticsData } from "../types/providers.js";
 import type { EvaluationData } from "../index.js";
 export type { EvaluationData };
@@ -155,6 +155,8 @@ export interface TextGenerationOptions {
         content: string;
     }>;
     conversationMessages?: ChatMessage[];
+    conversationMemoryConfig?: Partial<ConversationMemoryConfig>;
+    originalPrompt?: string;
     expectedOutcome?: string;
     evaluationCriteria?: string[];
 }

package/dist/lib/config/conversationMemoryConfig.js

@@ -36,5 +36,10 @@ export function getConversationMemoryDefaults() {
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
         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/lib/core/conversationMemoryManager.d.ts

@@ -2,10 +2,10 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
 export declare class ConversationMemoryManager {
     private sessions;
-    private config;
+    config: ConversationMemoryConfig;
     private isInitialized;
     constructor(config: ConversationMemoryConfig);
     /**
@@ -22,20 +22,14 @@ export declare class ConversationMemoryManager {
      * Returns pre-stored message array with zero conversion overhead
      */
     buildContextMessages(sessionId: string): ChatMessage[];
-    /**
-     * Get memory statistics (simplified for pure in-memory storage)
-     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
-     */
-    getStats(): Promise<ConversationMemoryStats>;
-    /**
-     * Clear all conversations for a specific session
-     */
-    clearSession(sessionId: string): Promise<boolean>;
-    /**
-     * Clear all conversations (reset memory)
-     */
-    clearAllSessions(): Promise<void>;
+    getSession(sessionId: string): SessionMemory | undefined;
+    createSummarySystemMessage(content: string): ChatMessage;
+    private _summarizeSession;
+    private _createSummarizationPrompt;
     private ensureInitialized;
     private createNewSession;
     private enforceSessionLimit;
+    getStats(): Promise<ConversationMemoryStats>;
+    clearSession(sessionId: string): Promise<boolean>;
+    clearAllSessions(): Promise<void>;
 }

package/dist/lib/core/conversationMemoryManager.js

@@ -3,14 +3,14 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
+import { NeuroLink } from "../neurolink.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
     isInitialized = false;
     constructor(config) {
-        // Trust that config is already complete from applyConversationMemoryDefaults()
         this.config = config;
     }
     /**
@@ -48,21 +48,19 @@ export class ConversationMemoryManager {
             // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
-            // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
-                MESSAGES_PER_TURN;
-            if (session.messages.length > maxMessages) {
-                session.messages = session.messages.slice(-maxMessages);
+            if (this.config.enableSummarization) {
+                const currentTurnCount = session.messages.length / MESSAGES_PER_TURN;
+                if (currentTurnCount > (this.config.summarizationThresholdTurns || 20)) {
+                    await this._summarizeSession(session);
+                }
+            }
+            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);
+                }
             }
-            // Enforce global session limit
             this.enforceSessionLimit();
-            logger.debug("Conversation turn stored", {
-                sessionId,
-                messageCount: session.messages.length,
-                turnCount: session.messages.length / MESSAGES_PER_TURN, // Each turn = MESSAGES_PER_TURN messages
-                userMessageLength: userMessage.length,
-                aiResponseLength: aiResponse.length,
-            });
         }
         catch (error) {
             throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
@@ -77,48 +75,74 @@ export class ConversationMemoryManager {
      */
     buildContextMessages(sessionId) {
         const session = this.sessions.get(sessionId);
-        if (!session || session.messages.length === 0) {
-            return [];
-        }
-        // ULTRA-OPTIMIZED: Direct return - no processing needed!
-        return session.messages;
+        return session ? session.messages : [];
     }
-    /**
-     * Get memory statistics (simplified for pure in-memory storage)
-     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
-     */
-    async getStats() {
-        await this.ensureInitialized();
-        const sessions = Array.from(this.sessions.values());
-        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    createSummarySystemMessage(content) {
         return {
-            totalSessions: sessions.length,
-            totalTurns,
+            role: "system",
+            content: `Summary of previous conversation turns:\n\n${content}`,
         };
     }
-    /**
-     * Clear all conversations for a specific session
-     */
-    async clearSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return false;
+    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);
+        if (messagesToSummarize.length === 0) {
+            return;
+        }
+        const summarizationPrompt = this._createSummarizationPrompt(messagesToSummarize);
+        const summarizer = new NeuroLink({ conversationMemory: { enabled: false } });
+        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.`);
+            }
+        }
+        catch (error) {
+            logger.error(`[ConversationMemory] Error during summarization for session ${session.sessionId}`, { error });
         }
-        // Remove from memory
-        this.sessions.delete(sessionId);
-        logger.info("Session cleared", { sessionId });
-        return true;
     }
-    /**
-     * Clear all conversations (reset memory)
-     */
-    async clearAllSessions() {
-        const sessionIds = Array.from(this.sessions.keys());
-        // Clear memory
-        this.sessions.clear();
-        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
+    _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();
     }
-    // Private methods
     async ensureInitialized() {
         if (!this.isInitialized) {
             await this.initialize();
@@ -138,16 +162,33 @@ export class ConversationMemoryManager {
         if (this.sessions.size <= maxSessions) {
             return;
         }
-        // Sort sessions by last activity (oldest first)
         const sessions = Array.from(this.sessions.entries()).sort(([, a], [, b]) => a.lastActivity - b.lastActivity);
-        // Remove oldest sessions
-        const sessionsToRemove = sessions.slice(0, sessions.length - maxSessions);
+        const sessionsToRemove = sessions.slice(0, this.sessions.size - maxSessions);
         for (const [sessionId] of sessionsToRemove) {
             this.sessions.delete(sessionId);
         }
-        logger.debug("Session limit enforced", {
-            removedSessions: sessionsToRemove.length,
-            remainingSessions: this.sessions.size,
-        });
+    }
+    async getStats() {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+        return {
+            totalSessions: sessions.length,
+            totalTurns,
+        };
+    }
+    async clearSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        this.sessions.delete(sessionId);
+        logger.info("Session cleared", { sessionId });
+        return true;
+    }
+    async clearAllSessions() {
+        const sessionIds = Array.from(this.sessions.keys());
+        this.sessions.clear();
+        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
     }
 }

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

@@ -3,7 +3,7 @@ import type { ZodUnknownSchema, ValidationSchema } from "../types/typeAliases.js
 import type { GenerateResult } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue } from "../types/common.js";
-import type { ChatMessage } from "../types/conversationTypes.js";
+import type { ChatMessage, ConversationMemoryConfig } from "../types/conversationTypes.js";
 import type { TokenUsage, AnalyticsData } from "../types/providers.js";
 import type { EvaluationData } from "../index.js";
 export type { EvaluationData };
@@ -155,6 +155,8 @@ export interface TextGenerationOptions {
         content: string;
     }>;
     conversationMessages?: ChatMessage[];
+    conversationMemoryConfig?: Partial<ConversationMemoryConfig>;
+    originalPrompt?: string;
     expectedOutcome?: string;
     evaluationCriteria?: string[];
 }

package/dist/lib/neurolink.d.ts

@@ -39,11 +39,9 @@ export interface MCPStatus {
     error?: string;
     [key: string]: unknown;
 }
-import type { ContextManagerConfig } from "./context/types.js";
 export declare class NeuroLink {
     private mcpInitialized;
     private emitter;
-    private contextManager;
     private autoDiscoveredServerInfos;
     private externalServerManager;
     private toolCircuitBreakers;
@@ -167,13 +165,6 @@ export declare class NeuroLink {
      * @returns The original prompt text as a string.
      */
     private _extractOriginalPrompt;
-    /**
-     * Enables automatic context summarization for the NeuroLink instance.
-     * Once enabled, the instance will maintain conversation history and
-     * automatically summarize it when it exceeds token limits.
-     * @param config Optional configuration to override default summarization settings.
-     */
-    enableContextSummarization(config?: Partial<ContextManagerConfig>): void;
     /**
      * Generate AI content using the best available provider with MCP tool integration.
      * This is the primary method for text generation with full feature support.