@juspay/neurolink 7.37.1 → 7.38.0

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

@@ -224,6 +224,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * Get timeout value in milliseconds
      */
     getTimeout(options: TextGenerationOptions | StreamOptions): number;
+    /**
+     * Check if tool executions should be stored and handle storage
+     */
+    protected handleToolExecutionStorage(toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions | StreamOptions): Promise<void>;
     /**
      * Utility method to chunk large prompts into smaller pieces
      * @param prompt The prompt to chunk

package/dist/lib/core/baseProvider.js

@@ -297,6 +297,16 @@ export class BaseProvider {
             toolChoice: shouldUseTools ? "auto" : "none",
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            onStepFinish: ({ toolCalls, toolResults }) => {
+                logger.info("Tool execution completed", { toolResults, toolCalls });
+                // Handle tool execution storage
+                this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                    logger.warn("[BaseProvider] Failed to store tool executions", {
+                        provider: this.providerName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            },
         });
     }
     /**
@@ -1470,6 +1480,36 @@ export class BaseProvider {
         }
         return this.defaultTimeout;
     }
+    /**
+     * Check if tool executions should be stored and handle storage
+     */
+    async handleToolExecutionStorage(toolCalls, toolResults, options) {
+        // Check if tools are not empty
+        const hasToolData = (toolCalls && toolCalls.length > 0) ||
+            (toolResults && toolResults.length > 0);
+        // Check if NeuroLink instance is available and has tool execution storage
+        const hasStorageAvailable = this.neurolink?.isToolExecutionStorageAvailable();
+        // Early return if storage is not available or no tool data
+        if (!hasStorageAvailable || !hasToolData || !this.neurolink) {
+            return;
+        }
+        const sessionId = options.context?.sessionId ||
+            options.sessionId ||
+            `session-${Date.now()}`;
+        const userId = options.context?.userId ||
+            options.userId;
+        try {
+            await this.neurolink.storeToolExecutions(sessionId, userId, toolCalls, toolResults);
+        }
+        catch (error) {
+            logger.warn("[BaseProvider] Failed to store tool executions", {
+                provider: this.providerName,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't throw - tool storage failures shouldn't break generation
+        }
+    }
     /**
      * Utility method to chunk large prompts into smaller pieces
      * @param prompt The prompt to chunk

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

@@ -2,21 +2,65 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, RedisStorageConfig } from "../types/conversation.js";
-/**
- * Redis-based implementation of the ConversationMemoryManager
- * Uses the same interface but stores data in Redis
- */
+import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage, RedisStorageConfig, SessionMetadata, RedisConversationObject } from "../types/conversation.js";
 export declare class RedisConversationMemoryManager {
     config: ConversationMemoryConfig;
     private isInitialized;
     private redisConfig;
     private redisClient;
+    /**
+     * Temporary storage for tool execution data to prevent race conditions
+     * Key format: "${sessionId}:${userId}"
+     */
+    private pendingToolExecutions;
+    /**
+     * Track sessions currently generating titles to prevent race conditions
+     * Key format: "${sessionId}:${userId}"
+     */
+    private titleGenerationInProgress;
     constructor(config: ConversationMemoryConfig, redisConfig?: RedisStorageConfig);
     /**
      * Initialize the memory manager with Redis connection
      */
     initialize(): Promise<void>;
+    /**
+     * Get all sessions for a specific user
+     */
+    getUserSessions(userId: string): Promise<string[]>;
+    /**
+     * Add a session to user's session set (private method)
+     */
+    private addUserSession;
+    /**
+     * Remove a session from user's session set (private method)
+     */
+    private removeUserSession;
+    /**
+     * Generate next message ID for a conversation
+     */
+    private generateMessageId;
+    /**
+     * Generate current timestamp in ISO format
+     */
+    private generateTimestamp;
+    /**
+     * Generate a unique conversation ID using UUID v4
+     */
+    private generateUniqueId;
+    /**
+     * Store tool execution data for a session (temporarily to avoid race conditions)
+     */
+    storeToolExecution(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>;
     /**
      * Store a conversation turn for a session
      */
@@ -24,11 +68,41 @@ export declare class RedisConversationMemoryManager {
     /**
      * Build context messages for AI prompt injection
      */
-    buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
+    buildContextMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
+    /**
+     * Get session metadata for a specific user session (optimized for listing)
+     * Fetches only essential metadata without heavy message arrays
+     *
+     * @param userId The user identifier
+     * @param sessionId The session identifier
+     * @returns Session metadata or null if session doesn't exist
+     */
+    getUserSessionMetadata(userId: string, sessionId: string): Promise<SessionMetadata | null>;
+    /**
+     * Get conversation history for a specific user session
+     *
+     * @param userId The user identifier
+     * @param sessionId The session identifier
+     * @returns Array of chat messages or null if session doesn't exist
+     */
+    getUserSessionHistory(userId: string, sessionId: string): Promise<ChatMessage[] | null>;
+    /**
+     * Get the complete conversation object for a specific user session
+     *
+     * This method returns the full conversation object including title, metadata,
+     * timestamps, and all chat messages. Unlike getUserSessionHistory() which returns
+     * only the messages array, this method provides the complete conversation context.
+     *
+     * @param userId The user identifier who owns the session
+     * @param sessionId The unique session identifier
+     * @returns Complete conversation object with all data, or null if session doesn't exist
+     */
+    getUserSessionObject(userId: string, sessionId: string): Promise<RedisConversationObject | null>;
     /**
-     * Get session data
+     * Generate a conversation title from the first user message
+     * Uses AI to create a concise, descriptive title (5-8 words)
      */
-    getSession(sessionId: string): Promise<SessionMemory | undefined>;
+    generateConversationTitle(userMessage: string): Promise<string>;
     /**
      * Create summary system message
      */
@@ -44,23 +118,32 @@ export declare class RedisConversationMemoryManager {
     /**
      * Clear a specific session
      */
-    clearSession(sessionId: string): Promise<boolean>;
+    clearSession(sessionId: string, userId?: string): Promise<boolean>;
     /**
      * Clear all sessions
      */
     clearAllSessions(): Promise<void>;
     /**
-     * Summarize messages for a session
+     * Ensure Redis client is initialized
      */
-    private _summarizeMessages;
+    private ensureInitialized;
     /**
-     * Create summarization prompt
+     * Get session metadata for all sessions of a user (optimized for listing)
+     * Returns only essential metadata without heavy message arrays
+     *
+     * @param userId The user identifier
+     * @returns Array of session metadata objects
      */
-    private _createSummarizationPrompt;
+    getUserAllSessionsHistory(userId: string): Promise<SessionMetadata[]>;
     /**
-     * Ensure Redis client is initialized
+     * Clean up stale pending tool execution data
+     * Removes data older than 5 minutes to prevent memory leaks
      */
-    private ensureInitialized;
+    private cleanupStalePendingData;
+    /**
+     * Flush pending tool execution data for a session and merge into conversation
+     */
+    private flushPendingToolData;
     /**
      * Enforce session limit
      *