@juspay/neurolink 9.5.3 → 9.7.0

package/dist/lib/core/conversationMemoryManager.js

@@ -2,16 +2,18 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import { ConversationMemoryError } from "../types/conversation.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 { randomUUID } from "crypto";
+import { DEFAULT_MAX_SESSIONS, MEMORY_THRESHOLD_PERCENTAGE, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
 import { TokenUtils } from "../constants/tokens.js";
-import { buildContextFromPointer, getEffectiveTokenThreshold, generateSummary, } from "../utils/conversationMemory.js";
+import { SummarizationEngine } from "../context/summarizationEngine.js";
+import { ConversationMemoryError } from "../types/conversation.js";
+import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
+import { logger } from "../utils/logger.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
     isInitialized = false;
+    summarizationEngine = new SummarizationEngine();
     /**
      * Track sessions currently being summarized to prevent race conditions
      */
@@ -35,9 +37,26 @@ export class ConversationMemoryManager {
             });
         }
         catch (error) {
-            throw new ConversationMemoryError("Failed to initialize conversation memory", "CONFIG_ERROR", { error: error instanceof Error ? error.message : String(error) });
+            throw new ConversationMemoryError("Failed to initialize conversation memory", "CONFIG_ERROR", {
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
     }
+    /** Whether this memory manager can persist data (always true for in-memory within process) */
+    get canPersist() {
+        return true;
+    }
+    /** Whether Redis client is configured (always false for in-memory) */
+    get isRedisConfigured() {
+        return false;
+    }
+    /** Get health status for monitoring */
+    getHealthStatus() {
+        return {
+            initialized: this.isInitialized,
+            connected: false,
+        };
+    }
     /**
      * Store a conversation turn for a session
      * TOKEN-BASED: Validates message size and triggers summarization based on tokens
@@ -61,6 +80,10 @@ export class ConversationMemoryManager {
             }
             session.messages.push(userMsg, assistantMsg);
             session.lastActivity = Date.now();
+            // Store API-reported token counts if available
+            if (options.tokenUsage) {
+                session.lastApiTokenCount = options.tokenUsage;
+            }
             const shouldSummarize = options.enableSummarization !== undefined
                 ? options.enableSummarization
                 : this.config.enableSummarization;
@@ -141,19 +164,7 @@ export class ConversationMemoryManager {
         }
         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);
-            }
+            await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[ConversationMemory]");
         }
         catch (error) {
             logger.error("Token counting or summarization failed", {
@@ -171,7 +182,12 @@ export class ConversationMemoryManager {
      */
     estimateTokens(messages) {
         return messages.reduce((total, msg) => {
-            return total + TokenUtils.estimateTokenCount(msg.content);
+            let msgTokens = TokenUtils.estimateTokenCount(msg.content);
+            if (msg.events && Array.isArray(msg.events) && msg.events.length > 0) {
+                const eventsJson = JSON.stringify(msg.events);
+                msgTokens += TokenUtils.estimateTokenCount(eventsJson);
+            }
+            return total + msgTokens;
         }, 0);
     }
     /**
@@ -183,7 +199,7 @@ export class ConversationMemoryManager {
         const session = this.sessions.get(sessionId);
         return session ? buildContextFromPointer(session) : [];
     }
-    getSession(sessionId) {
+    getSession(sessionId, _userId) {
         return this.sessions.get(sessionId);
     }
     createSummarySystemMessage(content, summarizesFrom, summarizesTo) {
@@ -199,54 +215,6 @@ export class ConversationMemoryManager {
             },
         };
     }
-    /**
-     * 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 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,
-        });
-    }
-    /**
-     * 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;
-        }
-        // To ensure at least one message is summarized
-        return Math.max(1, splitIndex);
-    }
     async ensureInitialized() {
         if (!this.isInitialized) {
             await this.initialize();

package/dist/lib/core/dynamicModels.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 /**
  * Model configuration schema for validation
@@ -122,7 +123,7 @@ export class DynamicModelProvider {
             }
             catch (error) {
                 clearTimeout(timeoutId);
-                if (error instanceof Error && error.name === "AbortError") {
+                if (isAbortError(error)) {
                     throw new Error(`Request timeout after ${timeoutMs}ms`);
                 }
                 throw error;
@@ -177,7 +178,7 @@ export class DynamicModelProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error(`Localhost health check timeout - server may not be running`);
             }
             // For connection refused, throw a more specific error

package/dist/lib/core/modules/GenerationHandler.js

@@ -53,6 +53,7 @@ export class GenerationHandler {
             ...(shouldUseTools && { toolChoice: "auto" }),
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            abortSignal: options.abortSignal,
             ...(useStructuredOutput &&
                 options.schema && {
                 experimental_output: Output.object({ schema: options.schema }),
@@ -272,6 +273,7 @@ export class GenerationHandler {
         return {
             content,
             usage,
+            finishReason: generateResult.finishReason,
             provider: this.providerName,
             model: this.modelName,
             toolCalls: generateResult.toolCalls

package/dist/lib/core/modules/MessageBuilder.d.ts

@@ -13,7 +13,7 @@
  * @module core/modules/MessageBuilder
  */
 import type { CoreMessage } from "ai";
-import type { TextGenerationOptions, AIProviderName } from "../../types/index.js";
+import type { AIProviderName, TextGenerationOptions } from "../../types/index.js";
 import type { StreamOptions } from "../../types/streamTypes.js";
 /**
  * MessageBuilder class - Handles message construction for AI providers

package/dist/lib/core/modules/MessageBuilder.js

@@ -65,6 +65,7 @@ export class MessageBuilder {
                 conversationHistory: options.conversationMessages,
                 schema: options.schema,
                 output: options.output,
+                fileRegistry: options.fileRegistry,
             };
             messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
         }
@@ -147,6 +148,7 @@ export class MessageBuilder {
                     .conversationMessages,
                 schema: options.schema,
                 output: options.output,
+                fileRegistry: options.fileRegistry,
             };
             messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
         }

package/dist/lib/core/modules/TelemetryHandler.d.ts

@@ -13,10 +13,9 @@
  *
  * @module core/modules/TelemetryHandler
  */
-import type { AIProviderName, EnhancedGenerateResult, TextGenerationOptions, AnalyticsData } from "../../types/index.js";
-import type { EvaluationData } from "../../types/index.js";
-import type { StreamOptions } from "../../types/streamTypes.js";
 import type { NeuroLink } from "../../neurolink.js";
+import type { AIProviderName, AnalyticsData, EnhancedGenerateResult, EvaluationData, TextGenerationOptions } from "../../types/index.js";
+import type { StreamOptions } from "../../types/streamTypes.js";
 /**
  * TelemetryHandler class - Handles analytics and telemetry for AI providers
  */

package/dist/lib/core/modules/TelemetryHandler.js

@@ -13,10 +13,10 @@
  *
  * @module core/modules/TelemetryHandler
  */
-import { logger } from "../../utils/logger.js";
 import { nanoid } from "nanoid";
+import { logger } from "../../utils/logger.js";
+import { getPerformanceOptimizedProvider, recordProviderPerformanceFromMetrics, } from "../evaluationProviders.js";
 import { modelConfig } from "../modelConfiguration.js";
-import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "../evaluationProviders.js";
 /**
  * TelemetryHandler class - Handles analytics and telemetry for AI providers
  */
@@ -147,7 +147,7 @@ export class TelemetryHandler {
             isEnabled: true,
             functionId,
             metadata,
-            recordInputs: true,
+            recordInputs: false,
             recordOutputs: true,
         };
     }

package/dist/lib/core/modules/ToolsManager.d.ts

@@ -21,12 +21,12 @@ import type { NeuroLink } from "../../neurolink.js";
 /**
  * Utility functions interface for ToolsManager
  */
-export interface ToolUtilities {
+export type ToolUtilities = {
     isZodSchema?: (schema: unknown) => boolean;
     convertToolResult?: (result: unknown) => Promise<unknown>;
     createPermissiveZodSchema?: () => z.ZodSchema;
     fixSchemaForOpenAIStrictMode?: (schema: Record<string, unknown>) => Record<string, unknown>;
-}
+};
 /**
  * ToolsManager class - Handles all tool management operations
  */

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

@@ -2,14 +2,16 @@
  * 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, StoreConversationTurnOptions } from "../types/conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionMemory, SessionMetadata, StoreConversationTurnOptions } from "../types/conversation.js";
+import type { IConversationMemoryManager } from "../types/conversationMemoryInterface.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
  */
-export declare class RedisConversationMemoryManager {
+export declare class RedisConversationMemoryManager implements IConversationMemoryManager {
     config: ConversationMemoryConfig;
     private isInitialized;
+    private summarizationEngine;
     private redisConfig;
     private redisClient;
     /**
@@ -32,6 +34,21 @@ export declare class RedisConversationMemoryManager {
      * Initialize the memory manager with Redis connection
      */
     initialize(): Promise<void>;
+    /** Whether this memory manager can persist data (Redis connected and initialized) */
+    get canPersist(): boolean;
+    /** Whether Redis client is configured and connected */
+    get isRedisConfigured(): boolean;
+    /** Get health status for monitoring */
+    getHealthStatus(): {
+        initialized: boolean;
+        connected: boolean;
+        host: string;
+        keyPrefix: string;
+    };
+    /**
+     * Get session by ID, reconstructing a SessionMemory from Redis storage.
+     */
+    getSession(sessionId: string, userId?: string): Promise<SessionMemory | undefined>;
     /**
      * Get all sessions for a specific user
      */
@@ -70,18 +87,6 @@ export declare class RedisConversationMemoryManager {
      * 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 (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)

package/dist/lib/core/redisConversationMemoryManager.js

@@ -3,13 +3,13 @@
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
 import { randomUUID } from "crypto";
+import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
+import { SummarizationEngine } from "../context/summarizationEngine.js";
+import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
-import { MESSAGES_PER_TURN, RECENT_MESSAGES_RATIO, } from "../config/conversationMemory.js";
+import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/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";
+import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -17,6 +17,7 @@ import { buildContextFromPointer, getEffectiveTokenThreshold, generateSummary, }
 export class RedisConversationMemoryManager {
     config;
     isInitialized = false;
+    summarizationEngine = new SummarizationEngine();
     redisConfig;
     redisClient = null;
     /**
@@ -53,7 +54,7 @@ export class RedisConversationMemoryManager {
                 keyPrefix: this.redisConfig.keyPrefix,
                 ttl: this.redisConfig.ttl,
             });
-            this.redisClient = await createRedisClient(this.redisConfig);
+            this.redisClient = await getPooledRedisClient(this.redisConfig);
             this.isInitialized = true;
             logger.info("RedisConversationMemoryManager initialized", {
                 storage: "redis",
@@ -76,7 +77,64 @@ export class RedisConversationMemoryManager {
                     port: this.redisConfig.port,
                 },
             });
-            throw new ConversationMemoryError("Failed to initialize Redis conversation memory", "CONFIG_ERROR", { error: error instanceof Error ? error.message : String(error) });
+            throw new ConversationMemoryError("Failed to initialize Redis conversation memory", "CONFIG_ERROR", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /** Whether this memory manager can persist data (Redis connected and initialized) */
+    get canPersist() {
+        return (this.isInitialized && this.redisClient !== null && this.redisClient.isOpen);
+    }
+    /** Whether Redis client is configured and connected */
+    get isRedisConfigured() {
+        return this.redisClient !== null && this.redisClient.isOpen;
+    }
+    /** Get health status for monitoring */
+    getHealthStatus() {
+        return {
+            initialized: this.isInitialized,
+            connected: this.redisClient?.isOpen ?? false,
+            host: this.redisConfig.host,
+            keyPrefix: this.redisConfig.keyPrefix,
+        };
+    }
+    /**
+     * Get session by ID, reconstructing a SessionMemory from Redis storage.
+     */
+    async getSession(sessionId, userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return undefined;
+        }
+        try {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            const conversation = deserializeConversation(conversationData || null);
+            if (!conversation) {
+                return undefined;
+            }
+            return {
+                sessionId: conversation.sessionId,
+                userId: conversation.userId,
+                messages: conversation.messages,
+                summarizedUpToMessageId: conversation.summarizedUpToMessageId,
+                summarizedMessage: conversation.summarizedMessage,
+                tokenThreshold: conversation.tokenThreshold,
+                lastTokenCount: conversation.lastTokenCount,
+                lastCountedAt: conversation.lastCountedAt,
+                lastApiTokenCount: conversation.lastApiTokenCount,
+                createdAt: new Date(conversation.createdAt).getTime(),
+                lastActivity: new Date(conversation.updatedAt).getTime(),
+            };
+        }
+        catch (error) {
+            logger.error("[RedisConversationMemoryManager] Failed to get session", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
         }
     }
     /**
@@ -300,6 +358,10 @@ export class RedisConversationMemoryManager {
                 events: options.events || undefined,
             };
             conversation.messages.push(assistantMsg);
+            // Store API-reported token counts if available
+            if (options.tokenUsage) {
+                conversation.lastApiTokenCount = options.tokenUsage;
+            }
             logger.info("[RedisConversationMemoryManager] Added new messages", {
                 sessionId: conversation.sessionId,
                 userId: conversation.userId,
@@ -359,7 +421,6 @@ export class RedisConversationMemoryManager {
     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,
@@ -381,12 +442,20 @@ export class RedisConversationMemoryManager {
                 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);
+            const summarized = await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[RedisConversationMemoryManager]");
+            conversation.lastTokenCount = session.lastTokenCount;
+            conversation.lastCountedAt = session.lastCountedAt;
+            if (summarized) {
+                conversation.summarizedUpToMessageId = session.summarizedUpToMessageId;
+                conversation.summarizedMessage = session.summarizedMessage;
+                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);
+                    }
+                }
             }
         }
         catch (error) {
@@ -396,71 +465,9 @@ export class RedisConversationMemoryManager {
             });
         }
         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);
-    }
-    /**
-     * Token-based summarization (pointer-based, non-destructive)
-     */
-    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)
@@ -625,7 +632,10 @@ export class RedisConversationMemoryManager {
         }
         await this.ensureInitialized();
         if (!this.redisClient) {
-            logger.warn("[RedisConversationMemoryManager] Redis client not available for getUserSessionObject", { userId, sessionId });
+            logger.warn("[RedisConversationMemoryManager] Redis client not available for getUserSessionObject", {
+                userId,
+                sessionId,
+            });
             return null;
         }
         try {
@@ -678,7 +688,7 @@ export class RedisConversationMemoryManager {
      * Uses AI to create a concise, descriptive title (5-8 words)
      */
     async generateConversationTitle(userMessage) {
-        logger.debug("[RedisConversationMemoryManager] Generating conversation title", {
+        logger.info("[RedisConversationMemoryManager] Generating conversation title", {
             userMessageLength: userMessage.length,
             userMessagePreview: userMessage.substring(0, 100),
         });
@@ -687,12 +697,12 @@ export class RedisConversationMemoryManager {
             const titleGenerator = new NeuroLink({
                 conversationMemory: { enabled: false },
             });
-            const titlePrompt = `Generate a clear, concise, and descriptive title (5–8 words maximum) for a conversation based on the following user message. 
-The title must meaningfully reflect the topic or intent of the message. 
-Do not output anything unrelated, vague, or generic. 
+            const titlePrompt = `Generate a clear, concise, and descriptive title (5–8 words maximum) for a conversation based on the following user message.
+The title must meaningfully reflect the topic or intent of the message.
+Do not output anything unrelated, vague, or generic.
 Do not say you cannot create a title. Always return a valid title.
 
-User message: "${userMessage}`;
+User message: "${userMessage}"`;
             const result = await titleGenerator.generate({
                 input: { text: titlePrompt },
                 provider: this.config.summarizationProvider || "vertex",
@@ -711,7 +721,7 @@ User message: "${userMessage}`;
             if (title.length < 3) {
                 title = "New Conversation";
             }
-            logger.debug("[RedisConversationMemoryManager] Generated conversation title", {
+            logger.info("[RedisConversationMemoryManager] Generated conversation title", {
                 originalLength: result.content?.length || 0,
                 cleanedTitle: title,
                 titleLength: title.length,
@@ -751,7 +761,7 @@ User message: "${userMessage}`;
      */
     async close() {
         if (this.redisClient) {
-            await this.redisClient.quit();
+            await releasePooledRedisClient(this.redisConfig);
             this.redisClient = null;
             this.isInitialized = false;
             logger.info("Redis connection closed");
@@ -903,8 +913,6 @@ User message: "${userMessage}`;
                             ? sessionError.message
                             : String(sessionError),
                     });
-                    // Continue with other sessions even if one fails
-                    continue;
                 }
             }
             return results;

package/dist/lib/factories/providerFactory.d.ts

@@ -10,11 +10,11 @@ type ProviderConstructor = {
 /**
  * Provider registration entry
  */
-interface ProviderRegistration {
+type ProviderRegistration = {
     constructor: ProviderConstructor;
     defaultModel?: string;
     aliases?: string[];
-}
+};
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements