@juspay/neurolink 7.37.1 → 7.38.1

package/dist/lib/neurolink.d.ts

@@ -14,6 +14,8 @@ import type { NeuroLinkEvents, TypedEventEmitter, ToolExecutionContext, ToolExec
 import type { JsonObject } from "./types/common.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
 import type { ConversationMemoryConfig, ChatMessage } from "./types/conversation.js";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
     provider: string;
@@ -62,7 +64,7 @@ export declare class NeuroLink {
      * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
-    private conversationMemory?;
+    conversationMemory?: ConversationMemoryManager | RedisConversationMemoryManager | null;
     private conversationMemoryNeedsInit;
     private conversationMemoryConfig?;
     private enableOrchestration;
@@ -848,6 +850,12 @@ export declare class NeuroLink {
             recommendations: string[];
         }>;
     }>;
+    /**
+     * Initialize conversation memory if enabled (public method for explicit initialization)
+     * This is useful for testing or when you want to ensure conversation memory is ready
+     * @returns Promise resolving to true if initialization was successful, false otherwise
+     */
+    ensureConversationMemoryInitialized(): Promise<boolean>;
     /**
      * Get conversation memory statistics (public API)
      */
@@ -866,6 +874,30 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * Store tool executions in conversation memory if enabled and Redis is configured
+     * @param sessionId - Session identifier
+     * @param userId - User identifier (optional)
+     * @param toolCalls - Array of tool calls
+     * @param toolResults - Array of tool results
+     * @returns Promise resolving when storage is complete
+     */
+    storeToolExecutions(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>): Promise<void>;
+    /**
+     * Check if tool execution storage is available
+     * @returns boolean indicating if Redis storage is configured and available
+     */
+    isToolExecutionStorageAvailable(): boolean;
     /**
      * Add an external MCP server
      * Automatically discovers and registers tools from the server

package/dist/lib/neurolink.js

@@ -3232,6 +3232,24 @@ export class NeuroLink {
     // ============================================================================
     // CONVERSATION MEMORY PUBLIC API
     // ============================================================================
+    /**
+     * Initialize conversation memory if enabled (public method for explicit initialization)
+     * This is useful for testing or when you want to ensure conversation memory is ready
+     * @returns Promise resolving to true if initialization was successful, false otherwise
+     */
+    async ensureConversationMemoryInitialized() {
+        try {
+            const initId = `manual-init-${Date.now()}`;
+            await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+            return !!this.conversationMemory;
+        }
+        catch (error) {
+            logger.error("Failed to initialize conversation memory", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
     /**
      * Get conversation memory statistics (public API)
      */
@@ -3302,6 +3320,52 @@ export class NeuroLink {
         }
         await this.conversationMemory.clearAllSessions();
     }
+    /**
+     * Store tool executions in conversation memory if enabled and Redis is configured
+     * @param sessionId - Session identifier
+     * @param userId - User identifier (optional)
+     * @param toolCalls - Array of tool calls
+     * @param toolResults - Array of tool results
+     * @returns Promise resolving when storage is complete
+     */
+    async storeToolExecutions(sessionId, userId, toolCalls, toolResults) {
+        // Check if tools are not empty
+        const hasToolData = (toolCalls && toolCalls.length > 0) ||
+            (toolResults && toolResults.length > 0);
+        if (!hasToolData) {
+            logger.debug("Tool execution storage skipped", {
+                hasToolData,
+                toolCallsCount: toolCalls?.length || 0,
+                toolResultsCount: toolResults?.length || 0,
+            });
+            return;
+        }
+        // Type guard to ensure it's Redis conversation memory manager
+        const redisMemory = this
+            .conversationMemory;
+        try {
+            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults);
+        }
+        catch (error) {
+            logger.warn("Failed to store tool executions", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't throw - tool storage failures shouldn't break generation
+        }
+    }
+    /**
+     * Check if tool execution storage is available
+     * @returns boolean indicating if Redis storage is configured and available
+     */
+    isToolExecutionStorageAvailable() {
+        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
+        const hasRedisConversationMemory = this.conversationMemory &&
+            this.conversationMemory.constructor.name ===
+                "RedisConversationMemoryManager";
+        return !!(isRedisStorage && hasRedisConversationMemory);
+    }
     // ===== EXTERNAL MCP SERVER METHODS =====
     /**
      * Add an external MCP server

package/dist/lib/providers/anthropic.js

@@ -103,6 +103,14 @@ export class AnthropicProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             const transformedStream = this.createTextStream(result);

package/dist/lib/providers/anthropicBaseProvider.js

@@ -73,6 +73,14 @@ export class AnthropicProviderV2 extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream (match Google AI pattern)

package/dist/lib/providers/azureOpenai.js

@@ -122,6 +122,14 @@ export class AzureOpenAIProvider extends BaseProvider {
                     : {}),
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             });
             // Transform string stream to content object stream using BaseProvider method

package/dist/lib/providers/googleAiStudio.js

@@ -101,6 +101,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/lib/providers/googleVertex.js

@@ -646,6 +646,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 onChunk: () => {
                     chunkCount++;
                 },
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
+                    // Handle tool execution storage
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             };
             if (analysisSchema) {
                 try {

package/dist/lib/providers/huggingFace.js

@@ -123,6 +123,14 @@ export class HuggingFaceProvider extends BaseProvider {
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
                 toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[HuggingFaceProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface with enhanced tool call parsing

package/dist/lib/providers/litellm.js

@@ -130,6 +130,14 @@ export class LiteLLMProvider extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("LiteLLMProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface

package/dist/lib/providers/mistral.js

@@ -59,6 +59,14 @@ export class MistralProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[MistralProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/lib/providers/openAI.js

@@ -224,8 +224,8 @@ export class OpenAIProvider extends BaseProvider {
             const allTools = shouldUseTools ? await this.getAllTools() : {};
             // OpenAI-specific fix: Validate tools format and filter out problematic ones
             let tools = this.validateAndFilterToolsForOpenAI(allTools);
-            // OpenAI has limits on the number of tools per request - limit to 3 tools max for testing
-            const MAX_TOOLS = 3;
+            // OpenAI max tools limit - configurable via environment variable
+            const MAX_TOOLS = parseInt(process.env.OPENAI_MAX_TOOLS || "150", 10);
             if (Object.keys(tools).length > MAX_TOOLS) {
                 logger.warn(`OpenAI: Too many tools (${Object.keys(tools).length}), limiting to ${MAX_TOOLS} tools`);
                 const toolEntries = Object.entries(tools);
@@ -272,6 +272,16 @@ export class OpenAIProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
+                    // Handle tool execution storage
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[OpenAIProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Debug the actual result structure

package/dist/lib/providers/openaiCompatible.js

@@ -166,6 +166,14 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface

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

@@ -32,6 +32,8 @@ export interface SessionMemory {
     sessionId: string;
     /** User identifier (optional) */
     userId?: string;
+    /** Auto-generated conversation title (created on first user message) */
+    title?: string;
     /** Direct message storage - ready for immediate AI consumption */
     messages: ChatMessage[];
     /** When this session was created */
@@ -61,10 +63,26 @@ export interface ConversationMemoryStats {
  * Chat message format for conversation history
  */
 export interface ChatMessage {
-    /** Role of the message sender */
-    role: "user" | "assistant" | "system";
+    /** Role/type of the message */
+    role: "user" | "assistant" | "system" | "tool_call" | "tool_result";
     /** Content of the message */
     content: string;
+    /** Message ID (optional) - for new format */
+    id?: string;
+    /** Timestamp (optional) - for new format */
+    timestamp?: string;
+    /** Tool name (optional) - for tool_call/tool_result messages */
+    tool?: string;
+    /** Tool arguments (optional) - for tool_call messages */
+    args?: Record<string, unknown>;
+    /** Tool result (optional) - for tool_result messages */
+    result?: {
+        success?: boolean;
+        expression?: string;
+        result?: unknown;
+        type?: string;
+        error?: string;
+    };
 }
 /**
  * Content format for multimodal messages (used internally)
@@ -129,6 +147,36 @@ export type SessionIdentifier = {
     sessionId: string;
     userId?: string;
 };
+/**
+ * Lightweight session metadata for efficient session listing
+ * Contains only essential information without heavy message arrays
+ */
+export interface SessionMetadata {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * New Redis conversation storage object format
+ * Contains conversation metadata and history in a single object
+ */
+export type RedisConversationObject = {
+    /** Unique conversation identifier (UUID v4) */
+    id: string;
+    /** Auto-generated conversation title */
+    title: string;
+    /** Session identifier */
+    sessionId: string;
+    /** User identifier */
+    userId: string;
+    /** When this conversation was first created */
+    createdAt: string;
+    /** When this conversation was last updated */
+    updatedAt: string;
+    /** Array of conversation messages */
+    messages: ChatMessage[];
+};
 /**
  * Redis storage configuration
  */
@@ -143,6 +191,8 @@ export type RedisStorageConfig = {
     db?: number;
     /** Key prefix for Redis keys (default: 'neurolink:conversation:') */
     keyPrefix?: string;
+    /** Key prefix for user sessions mapping (default: derived from keyPrefix) */
+    userSessionsKeyPrefix?: string;
     /** Time-to-live in seconds (default: 86400, 24 hours) */
     ttl?: number;
     /** Additional Redis connection options */

package/dist/lib/utils/conversationMemory.js

@@ -32,8 +32,10 @@ export async function getConversationMessages(conversationMemory, options) {
         return [];
     }
     try {
+        // Extract userId from context
+        const userId = options.context?.userId;
         // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = await conversationMemory.buildContextMessages(sessionId);
+        const messages = await conversationMemory.buildContextMessages(sessionId, userId);
         logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
             sessionId,
             messageCount: messages.length,

package/dist/lib/utils/messageBuilder.d.ts

@@ -3,18 +3,26 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
-import type { ChatMessage, MultimodalChatMessage } from "../types/conversation.js";
+import type { MultimodalChatMessage } from "../types/conversation.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 import type { GenerateOptions } from "../types/generateTypes.js";
+/**
+ * Core message type compatible with AI SDK
+ */
+type CoreMessage = {
+    role: "user" | "assistant" | "system";
+    content: string;
+};
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
  */
-export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): ChatMessage[];
+export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): CoreMessage[];
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter
  */
 export declare function buildMultimodalMessagesArray(options: GenerateOptions, provider: string, model: string): Promise<MultimodalChatMessage[]>;
+export {};

package/dist/lib/utils/messageBuilder.js

@@ -8,6 +8,21 @@ import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerIma
 import { logger } from "./logger.js";
 import { request } from "undici";
 import { readFileSync, existsSync } from "fs";
+/**
+ * Convert ChatMessage to CoreMessage for AI SDK compatibility
+ */
+function toCoreMessage(message) {
+    // Only include messages with roles supported by AI SDK
+    if (message.role === "user" ||
+        message.role === "assistant" ||
+        message.role === "system") {
+        return {
+            role: message.role,
+            content: message.content,
+        };
+    }
+    return null; // Filter out tool_call and tool_result messages
+}
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
@@ -31,8 +46,14 @@ export function buildMessagesArray(options) {
         });
     }
     // Add conversation history if available
+    // Convert ChatMessages to CoreMessages and filter out tool messages
     if (hasConversationHistory && options.conversationMessages) {
-        messages.push(...options.conversationMessages);
+        for (const chatMessage of options.conversationMessages) {
+            const coreMessage = toCoreMessage(chatMessage);
+            if (coreMessage) {
+                messages.push(coreMessage);
+            }
+        }
     }
     // Add current user prompt (required)
     // Handle both TextGenerationOptions (prompt field) and StreamOptions (input.text field)

package/dist/lib/utils/redis.d.ts

@@ -4,7 +4,7 @@
  */
 import { createClient } from "redis";
 type RedisClient = ReturnType<typeof createClient>;
-import type { ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+import type { RedisStorageConfig, RedisConversationObject } from "../types/conversation.js";
 /**
  * Creates a Redis client with the provided configuration
  */
@@ -12,15 +12,19 @@ export declare function createRedisClient(config: Required<RedisStorageConfig>):
 /**
  * Generates a Redis key for session messages
  */
-export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string): string;
+export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string, userId?: string): string;
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export declare function serializeMessages(messages: ChatMessage[]): string;
+export declare function getUserSessionsKey(config: Required<RedisStorageConfig>, userId: string): string;
 /**
- * Deserializes messages from Redis storage
+ * Serializes conversation object for Redis storage
  */
-export declare function deserializeMessages(data: string | null): ChatMessage[];
+export declare function serializeConversation(conversation: RedisConversationObject): string;
+/**
+ * Deserializes conversation object from Redis storage
+ */
+export declare function deserializeConversation(data: string | null): RedisConversationObject | null;
 /**
  * Checks if Redis client is healthy
  */