@juspay/neurolink 8.19.1 → 8.20.0

package/dist/types/generateTypes.d.ts

@@ -350,6 +350,7 @@ export type TextGenerationOptions = {
         formatStyle?: "raw" | "markdown" | "json";
         includeHeaders?: boolean;
     };
+    enableSummarization?: boolean;
 };
 /**
  * Text generation result (consolidated from core types)

package/dist/types/sdkTypes.d.ts

@@ -22,4 +22,4 @@ export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonA
 export type { EvaluationData, EvaluationContext, EnhancedEvaluationResult, EvaluationRequest, EvaluationCriteria, } from "./evaluation.js";
 export type { TaskType, TaskClassification, ClassificationScores, ClassificationStats, ClassificationValidation, } from "./taskClassificationTypes.js";
 export type { DomainType, DomainConfig, DomainTemplate, DomainConfigOptions, DomainEvaluationCriteria, DomainValidationRule, } from "./domainTypes.js";
-export type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, MessageContent, MultimodalChatMessage, ConversationMemoryEvents, ConversationMemoryError, SessionIdentifier, SessionMetadata, RedisConversationObject, RedisStorageConfig, } from "./conversation.js";
+export type { ConversationMemoryConfig, SessionMemory, ChatMessage, MessageContent, MultimodalChatMessage, ConversationMemoryEvents, ConversationMemoryError, SessionIdentifier, SessionMetadata, RedisConversationObject, RedisStorageConfig, } from "./conversation.js";

package/dist/types/streamTypes.d.ts

@@ -299,6 +299,7 @@ export type StreamOptions = {
     };
     conversationMessages?: ChatMessage[];
     middleware?: MiddlewareFactoryOptions;
+    enableSummarization?: boolean;
 };
 /**
  * Stream function result type - Primary output format for streaming

package/dist/utils/conversationMemory.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import type { ConversationMemoryConfig, ChatMessage } from "../types/conversation.js";
+import type { ConversationMemoryConfig, ChatMessage, SessionMemory } from "../types/conversation.js";
 import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
 import type { TextGenerationOptions, TextGenerationResult } from "../types/generateTypes.js";
@@ -20,3 +20,45 @@ export declare function getConversationMessages(conversationMemory: Conversation
  * Saves user messages and AI responses for conversation memory
  */
 export declare function storeConversationTurn(conversationMemory: ConversationMemoryManager | RedisConversationMemoryManager | null | undefined, originalOptions: TextGenerationOptions, result: TextGenerationResult, startTimeStamp?: Date | undefined): Promise<void>;
+/**
+ * Build context messages from pointer onwards (token-based memory)
+ * Returns summary message (if exists) + all messages after the summarized pointer
+ * @param session - Session memory with pointer
+ * @returns Context messages to send to LLM
+ */
+export declare function buildContextFromPointer(session: SessionMemory): ChatMessage[];
+/**
+ * Create summarization prompt from message history
+ * Used by both in-memory and Redis conversation managers
+ * @param history - Messages to summarize
+ * @param previousSummary - Optional previous summary to build upon
+ */
+export declare function createSummarizationPrompt(history: ChatMessage[], previousSummary?: string): string;
+/**
+ * Calculate token threshold based on model's output token limit
+ * Uses existing provider token limits as proxy for context window
+ * @param provider - AI provider name
+ * @param model - Model name
+ * @returns Token threshold (80% of model's token limit)
+ */
+export declare function calculateTokenThreshold(provider: string, model: string): number;
+/**
+ * Get effective token threshold for a session
+ * Priority: session override > env var > model-based (80%) > fallback
+ * @param provider - AI provider name
+ * @param model - Model name
+ * @param envOverride - Environment variable override
+ * @param sessionOverride - Per-session token threshold override
+ * @returns Effective token threshold
+ */
+export declare function getEffectiveTokenThreshold(provider: string, model: string, envOverride?: number, sessionOverride?: number): number;
+/**
+ * Generate summary using configured provider and model
+ * Centralized summarization logic used by both ConversationMemoryManager and RedisConversationMemoryManager
+ * @param messages - Messages to summarize
+ * @param config - Conversation memory configuration containing provider/model settings
+ * @param previousSummary - Optional previous summary to build upon
+ * @param logPrefix - Prefix for log messages (e.g., "[ConversationMemory]" or "[RedisConversationMemoryManager]")
+ * @returns Summary text or null if generation fails
+ */
+export declare function generateSummary(messages: ChatMessage[], config: ConversationMemoryConfig, logPrefix?: string, previousSummary?: string): Promise<string | null>;

package/dist/utils/conversationMemory.js

@@ -2,8 +2,10 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import { getConversationMemoryDefaults } from "../config/conversationMemory.js";
+import { getConversationMemoryDefaults, MEMORY_THRESHOLD_PERCENTAGE, DEFAULT_FALLBACK_THRESHOLD, } from "../config/conversationMemory.js";
+import { TokenUtils } from "../constants/tokens.js";
 import { logger } from "./logger.js";
+import { NeuroLink } from "../neurolink.js";
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values
@@ -34,8 +36,8 @@ export async function getConversationMessages(conversationMemory, options) {
     try {
         // Extract userId from context
         const userId = options.context?.userId;
-        // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = await conversationMemory.buildContextMessages(sessionId, userId);
+        const enableSummarization = options.enableSummarization ?? undefined;
+        const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
         logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
             sessionId,
             messageCount: messages.length,
@@ -100,9 +102,24 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
         return;
     }
     const userMessage = originalOptions.originalPrompt || originalOptions.prompt || "";
-    const aiResponse = result.content;
+    const aiResponse = result.content ?? "";
+    let providerDetails = undefined;
+    if (result.provider && result.model) {
+        providerDetails = {
+            provider: result.provider,
+            model: result.model,
+        };
+    }
     try {
-        await conversationMemory.storeConversationTurn(sessionId, userId, userMessage, aiResponse, startTimeStamp);
+        await conversationMemory.storeConversationTurn({
+            sessionId,
+            userId,
+            userMessage,
+            aiResponse,
+            startTimeStamp,
+            providerDetails,
+            enableSummarization: originalOptions.enableSummarization,
+        });
         logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
             sessionId,
             userId,
@@ -121,3 +138,162 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
         });
     }
 }
+/**
+ * Build context messages from pointer onwards (token-based memory)
+ * Returns summary message (if exists) + all messages after the summarized pointer
+ * @param session - Session memory with pointer
+ * @returns Context messages to send to LLM
+ */
+export function buildContextFromPointer(session) {
+    if (!session.summarizedUpToMessageId || !session.summarizedMessage) {
+        return session.messages;
+    }
+    // find a better way to wirte this
+    const pointerIndex = session.messages.findIndex((msg) => msg.id === session.summarizedUpToMessageId);
+    if (pointerIndex === -1) {
+        logger.warn("Pointer message not found, returning all messages", {
+            sessionId: session.sessionId,
+            pointer: session.summarizedUpToMessageId,
+            totalMessages: session.messages.length,
+        });
+        return session.messages;
+    }
+    const messagesAfterPointer = session.messages.slice(pointerIndex + 1);
+    // Construct context: summary message + recent messages
+    const summaryMessage = {
+        id: `summary-${session.summarizedUpToMessageId}`,
+        role: "system",
+        content: `Previous conversation summary: ${session.summarizedMessage}`,
+        timestamp: new Date().toISOString(),
+        metadata: {
+            isSummary: true,
+            summarizesTo: session.summarizedUpToMessageId,
+        },
+    };
+    logger.debug("Building context with summary", {
+        sessionId: session.sessionId,
+        pointerIndex,
+        messagesAfterPointer: messagesAfterPointer.length,
+        totalMessages: session.messages.length,
+        summaryLength: session.summarizedMessage.length,
+    });
+    return [summaryMessage, ...messagesAfterPointer];
+}
+/**
+ * Create summarization prompt from message history
+ * Used by both in-memory and Redis conversation managers
+ * @param history - Messages to summarize
+ * @param previousSummary - Optional previous summary to build upon
+ */
+export function createSummarizationPrompt(history, previousSummary) {
+    const formattedHistory = history
+        .map((msg) => `${msg.role}: ${msg.content}`)
+        .join("\n\n");
+    const previousSummarySection = previousSummary
+        ? `Previous Summary:
+---
+${previousSummary}
+---
+
+`
+        : "";
+    return `
+You are a context summarization AI. Your task is to condense the following conversation history for another AI assistant.
+${previousSummary ? "Build upon the previous summary and incorporate the new conversation turns below." : ""}
+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.
+
+${previousSummarySection}Conversation History to Summarize:
+---
+${formattedHistory}
+---
+`.trim();
+}
+/**
+ * Calculate token threshold based on model's output token limit
+ * Uses existing provider token limits as proxy for context window
+ * @param provider - AI provider name
+ * @param model - Model name
+ * @returns Token threshold (80% of model's token limit)
+ */
+export function calculateTokenThreshold(provider, model) {
+    try {
+        // Get model's token limit from existing TokenUtils
+        const modelTokenLimit = TokenUtils.getProviderTokenLimit(provider, model);
+        // Return 80% of token limit for conversation memory
+        // This is conservative since output limits are typically smaller than input limits
+        return Math.floor(modelTokenLimit * MEMORY_THRESHOLD_PERCENTAGE);
+    }
+    catch (error) {
+        logger.warn("Failed to calculate model threshold, using fallback", {
+            provider,
+            model,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return DEFAULT_FALLBACK_THRESHOLD;
+    }
+}
+/**
+ * Get effective token threshold for a session
+ * Priority: session override > env var > model-based (80%) > fallback
+ * @param provider - AI provider name
+ * @param model - Model name
+ * @param envOverride - Environment variable override
+ * @param sessionOverride - Per-session token threshold override
+ * @returns Effective token threshold
+ */
+export function getEffectiveTokenThreshold(provider, model, envOverride, sessionOverride) {
+    // Priority 1: Session-level override
+    if (sessionOverride && sessionOverride > 0) {
+        return sessionOverride;
+    }
+    // Priority 2: Environment variable override
+    if (envOverride && envOverride > 0) {
+        return envOverride;
+    }
+    // Priority 3: Model-based calculation (80% of context window)
+    try {
+        return calculateTokenThreshold(provider, model);
+    }
+    catch (error) {
+        logger.warn("Failed to calculate effective threshold, using fallback", {
+            provider,
+            model,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Priority 4: Fallback for unknown models
+        return DEFAULT_FALLBACK_THRESHOLD;
+    }
+}
+/**
+ * Generate summary using configured provider and model
+ * Centralized summarization logic used by both ConversationMemoryManager and RedisConversationMemoryManager
+ * @param messages - Messages to summarize
+ * @param config - Conversation memory configuration containing provider/model settings
+ * @param previousSummary - Optional previous summary to build upon
+ * @param logPrefix - Prefix for log messages (e.g., "[ConversationMemory]" or "[RedisConversationMemoryManager]")
+ * @returns Summary text or null if generation fails
+ */
+export async function generateSummary(messages, config, logPrefix = "[ConversationMemory]", previousSummary) {
+    const summarizationPrompt = createSummarizationPrompt(messages, previousSummary);
+    const summarizer = new NeuroLink({
+        conversationMemory: { enabled: false },
+    });
+    try {
+        if (!config.summarizationProvider || !config.summarizationModel) {
+            logger.error(`${logPrefix} Missing summarization provider`);
+            return null;
+        }
+        const summaryResult = await summarizer.generate({
+            input: { text: summarizationPrompt },
+            provider: config.summarizationProvider,
+            model: config.summarizationModel,
+            disableTools: true,
+        });
+        return summaryResult.content || null;
+    }
+    catch (error) {
+        logger.error(`${logPrefix} Error generating summary`, { error });
+        return null;
+    }
+}

package/dist/utils/conversationMemoryUtils.js

@@ -58,8 +58,23 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
     if (typeof sessionId !== "string" || !sessionId) {
         return;
     }
+    let providerDetails = undefined;
+    if (result.provider && result.model) {
+        providerDetails = {
+            provider: result.provider,
+            model: result.model,
+        };
+    }
     try {
-        await conversationMemory.storeConversationTurn(sessionId, userId, originalOptions.originalPrompt || originalOptions.prompt || "", result.content, startTimeStamp);
+        await conversationMemory.storeConversationTurn({
+            sessionId,
+            userId,
+            userMessage: originalOptions.originalPrompt || originalOptions.prompt || "",
+            aiResponse: result.content,
+            startTimeStamp,
+            providerDetails,
+            enableSummarization: originalOptions.enableSummarization,
+        });
         logger.debug("Conversation turn stored", {
             sessionId,
             userId,

package/dist/utils/redis.js

@@ -91,14 +91,9 @@ export function serializeConversation(conversation) {
  */
 export function deserializeConversation(data) {
     if (!data) {
-        logger.debug("[redisUtils] No conversation data to deserialize, returning null");
         return null;
     }
     try {
-        logger.debug("[redisUtils] Deserializing conversation", {
-            dataLength: data.length,
-            dataPreview: data.substring(0, 100) + (data.length > 100 ? "..." : ""),
-        });
         // Parse as unknown first, then validate before casting
         const parsedData = JSON.parse(data);
         // Check if the parsed data is an object with required properties

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "8.19.1",
+  "version": "8.20.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",