@juspay/neurolink 8.19.0 → 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/adapters/providerImageAdapter.d.ts

@@ -60,4 +60,16 @@ export declare class ProviderImageAdapter {
      * Get all vision-capable providers
      */
     static getVisionProviders(): string[];
+    /**
+     * Count total "images" in a message (actual images + PDF pages)
+     * PDF pages count toward image limits for providers
+     */
+    static countImagesInMessage(images: Array<Buffer | string>, pdfPages?: number | null): number;
+    /**
+     * Extract page count from PDF metadata array
+     * Returns total pages across all PDFs
+     */
+    static countImagesInPages(pdfMetadataArray: Array<{
+        pageCount?: number | null;
+    }> | undefined): number;
 }

package/dist/lib/adapters/providerImageAdapter.js

@@ -416,13 +416,19 @@ export class ProviderImageAdapter {
                     adaptedPayload = this.formatForOpenAI(text, images);
                     break;
                 case "litellm":
-                    adaptedPayload = this.formatForOpenAI(text, images);
+                    // LiteLLM uses same format as OpenAI but validate with litellm provider name
+                    this.validateImageCount(images.length, "litellm");
+                    adaptedPayload = this.formatForOpenAI(text, images, true);
                     break;
                 case "mistral":
-                    adaptedPayload = this.formatForOpenAI(text, images);
+                    // Mistral uses same format as OpenAI but validate with mistral provider name
+                    this.validateImageCount(images.length, "mistral");
+                    adaptedPayload = this.formatForOpenAI(text, images, true);
                     break;
                 case "bedrock":
-                    adaptedPayload = this.formatForAnthropic(text, images);
+                    // Bedrock uses same format as Anthropic but validate with bedrock provider name
+                    this.validateImageCount(images.length, "bedrock");
+                    adaptedPayload = this.formatForAnthropic(text, images, true);
                     break;
                 default:
                     throw new Error(`Vision not supported for provider: ${provider}`);
@@ -666,5 +672,26 @@ export class ProviderImageAdapter {
     static getVisionProviders() {
         return Object.keys(VISION_CAPABILITIES);
     }
+    /**
+     * Count total "images" in a message (actual images + PDF pages)
+     * PDF pages count toward image limits for providers
+     */
+    static countImagesInMessage(images, pdfPages) {
+        const imageCount = images?.length || 0;
+        const pageCount = pdfPages ?? 0;
+        return imageCount + pageCount;
+    }
+    /**
+     * Extract page count from PDF metadata array
+     * Returns total pages across all PDFs
+     */
+    static countImagesInPages(pdfMetadataArray) {
+        if (!pdfMetadataArray || pdfMetadataArray.length === 0) {
+            return 0;
+        }
+        return pdfMetadataArray.reduce((total, pdf) => {
+            return total + (pdf.pageCount ?? 0);
+        }, 0);
+    }
 }
 //# sourceMappingURL=providerImageAdapter.js.map

package/dist/lib/config/conversationMemory.d.ts

@@ -20,12 +20,28 @@ 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
  * This addresses the issue where models add text like "Excellent!" before JSON output
+ * and the case where tools are used but final output must still be pure JSON
  */
-export declare const STRUCTURED_OUTPUT_INSTRUCTIONS = "\n\nSTRUCTURED OUTPUT REQUIREMENT:\nYou MUST respond with ONLY a valid JSON object that matches the provided schema.\n- Do NOT include any text before the JSON (no greetings, acknowledgments, or preamble like \"Excellent!\", \"Sure!\", \"Here is the result:\", etc.)\n- Do NOT include any text after the JSON (no explanations, summaries, or follow-up comments)\n- Do NOT wrap the JSON in markdown code blocks\n- Output ONLY the raw JSON object, starting with { and ending with }\n- Ensure the JSON is valid and parseable";
+export declare const STRUCTURED_OUTPUT_INSTRUCTIONS = "\nOutput ONLY valid JSON. No markdown, text, or decorations\u2014ever.\n\nFORBIDDEN: markdown code blocks, text before/after JSON, explanations, preambles, summaries, conversational text about tools.\n\nREQUIRED: response starts with { and ends with }, valid JSON only, no additional characters.\n\nIF YOU CALLED TOOLS: Incorporate data directly into the JSON structure. Do NOT explain what you did.\n\nWRONG: ```json\n{\"field\": \"value\"}\n```\nWRONG: Based on the data, here's the result: {\"field\": \"value\"}\nCORRECT: {\"field\": \"value\"}\n\nYour entire response = raw JSON object. Nothing else.";
 /**
  * Get default configuration values for conversation memory
  * Reads environment variables when called (not at module load time)

package/dist/lib/config/conversationMemory.js

@@ -26,20 +26,43 @@ 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
  * This addresses the issue where models add text like "Excellent!" before JSON output
+ * and the case where tools are used but final output must still be pure JSON
  */
 export const STRUCTURED_OUTPUT_INSTRUCTIONS = `
+Output ONLY valid JSON. No markdown, text, or decorations—ever.
+
+FORBIDDEN: markdown code blocks, text before/after JSON, explanations, preambles, summaries, conversational text about tools.
 
-STRUCTURED OUTPUT REQUIREMENT:
-You MUST respond with ONLY a valid JSON object that matches the provided schema.
-- Do NOT include any text before the JSON (no greetings, acknowledgments, or preamble like "Excellent!", "Sure!", "Here is the result:", etc.)
-- Do NOT include any text after the JSON (no explanations, summaries, or follow-up comments)
-- Do NOT wrap the JSON in markdown code blocks
-- Output ONLY the raw JSON object, starting with { and ending with }
-- Ensure the JSON is valid and parseable`;
+REQUIRED: response starts with { and ends with }, valid JSON only, no additional characters.
+
+IF YOU CALLED TOOLS: Incorporate data directly into the JSON structure. Do NOT explain what you did.
+
+WRONG: \`\`\`json
+{"field": "value"}
+\`\`\`
+WRONG: Based on the data, here's the result: {"field": "value"}
+CORRECT: {"field": "value"}
+
+Your entire response = raw JSON object. Nothing else.`;
 /**
  * Get default configuration values for conversation memory
  * Reads environment variables when called (not at module load time)
@@ -48,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