@juspay/neurolink 9.5.2 → 9.6.0

package/dist/context/toolPairRepair.js

@@ -0,0 +1,66 @@
+/**
+ * Tool Use/Result Pair Repair
+ *
+ * After compaction, validates that every tool_use (tool_call) has a
+ * corresponding tool_result and vice versa. Inserts synthetic
+ * placeholders for orphaned entries.
+ */
+import { randomUUID } from "crypto";
+/**
+ * Repair orphaned tool_use/tool_result pairs in a message array.
+ *
+ * Ensures every tool_call has a following tool_result and vice versa.
+ */
+export function repairToolPairs(messages) {
+    const result = [];
+    let orphanedCallsFixed = 0;
+    let orphanedResultsFixed = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const nextMsg = i + 1 < messages.length ? messages[i + 1] : undefined;
+        if (msg.role === "tool_call") {
+            result.push(msg);
+            // Check if next message is the corresponding tool_result
+            if (!nextMsg || nextMsg.role !== "tool_result") {
+                // Insert synthetic tool_result
+                result.push({
+                    id: `repair-result-${randomUUID()}`,
+                    role: "tool_result",
+                    content: "[Tool result unavailable - conversation was compacted]",
+                    tool: msg.tool,
+                    timestamp: msg.timestamp,
+                    metadata: { truncated: true },
+                });
+                orphanedCallsFixed++;
+            }
+        }
+        else if (msg.role === "tool_result") {
+            // Check if previous message was the corresponding tool_call
+            const prevMsg = result.length > 0 ? result[result.length - 1] : undefined;
+            if (!prevMsg ||
+                (prevMsg.role !== "tool_call" && prevMsg.role !== "tool_result")) {
+                // Insert synthetic tool_call before this result
+                result.push({
+                    id: `repair-call-${randomUUID()}`,
+                    role: "tool_call",
+                    content: `[Tool call for ${msg.tool || "unknown"} - conversation was compacted]`,
+                    tool: msg.tool,
+                    timestamp: msg.timestamp,
+                    metadata: { truncated: true },
+                });
+                orphanedResultsFixed++;
+            }
+            result.push(msg);
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0;
+    return {
+        repaired,
+        messages: repaired ? result : messages,
+        orphanedCallsFixed,
+        orphanedResultsFixed,
+    };
+}

package/dist/core/conversationMemoryManager.d.ts

@@ -2,11 +2,13 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, StoreConversationTurnOptions } from "../types/conversation.js";
-export declare class ConversationMemoryManager {
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions } from "../types/conversation.js";
+import type { IConversationMemoryManager } from "../types/conversationMemoryInterface.js";
+export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
     private isInitialized;
+    private summarizationEngine;
     /**
      * Track sessions currently being summarized to prevent race conditions
      */
@@ -30,26 +32,14 @@ export declare class ConversationMemoryManager {
      * Check if summarization is needed based on token count
      */
     private checkAndSummarize;
-    /**
-     * Estimate total tokens for a list of messages
-     */
-    private estimateTokens;
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
      * Now consistently async to match Redis implementation
      */
     buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
-    getSession(sessionId: string): SessionMemory | undefined;
+    getSession(sessionId: string, _userId?: string): SessionMemory | undefined;
     createSummarySystemMessage(content: string, summarizesFrom?: string, summarizesTo?: string): ChatMessage;
-    /**
-     * Token-based summarization (pointer-based, non-destructive)
-     */
-    private summarizeSessionTokenBased;
-    /**
-     * Find split index to keep recent messages within target token count
-     */
-    private findSplitIndexByTokens;
     private ensureInitialized;
     private createNewSession;
     private enforceSessionLimit;

package/dist/core/conversationMemoryManager.js

@@ -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,7 +37,9 @@ 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),
+            });
         }
     }
     /**
@@ -61,6 +65,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 +149,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", {
@@ -166,14 +162,6 @@ export class ConversationMemoryManager {
             this.summarizationInProgress.delete(session.sessionId);
         }
     }
-    /**
-     * Estimate total tokens for a list of messages
-     */
-    estimateTokens(messages) {
-        return messages.reduce((total, msg) => {
-            return total + TokenUtils.estimateTokenCount(msg.content);
-        }, 0);
-    }
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
@@ -183,7 +171,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 +187,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/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/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/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/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/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/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,10 @@ export declare class RedisConversationMemoryManager {
      * Initialize the memory manager with Redis connection
      */
     initialize(): Promise<void>;
+    /**
+     * 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 +76,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/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, getSessionKey, getUserSessionsKey, 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;
     /**
@@ -76,7 +77,47 @@ 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),
+            });
+        }
+    }
+    /**
+     * 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 +341,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 +404,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 +425,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 +448,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 +615,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 {
@@ -903,8 +896,6 @@ User message: "${userMessage}`;
                             ? sessionError.message
                             : String(sessionError),
                     });
-                    // Continue with other sessions even if one fails
-                    continue;
                 }
             }
             return results;

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