@juspay/neurolink 7.48.1 → 7.50.0

package/dist/cli/factories/commandFactory.js

@@ -49,6 +49,26 @@ export class CLICommandFactory {
             description: "Add image file for multimodal analysis (can be used multiple times)",
             alias: "i",
         },
+        csv: {
+            type: "string",
+            description: "Add CSV file for data analysis (can be used multiple times)",
+            alias: "c",
+        },
+        file: {
+            type: "string",
+            description: "Add file with auto-detection (CSV, image, etc. - can be used multiple times)",
+        },
+        csvMaxRows: {
+            type: "number",
+            default: 1000,
+            description: "Maximum number of CSV rows to process",
+        },
+        csvFormat: {
+            type: "string",
+            choices: ["raw", "markdown", "json"],
+            default: "raw",
+            description: "CSV output format (raw recommended for large files)",
+        },
         model: {
             type: "string",
             description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
@@ -188,6 +208,20 @@ export class CLICommandFactory {
         // File paths will be converted to base64 by the message builder
         return imagePaths;
     }
+    // Helper method to process CLI CSV files
+    static processCliCSVFiles(csvFiles) {
+        if (!csvFiles) {
+            return undefined;
+        }
+        return Array.isArray(csvFiles) ? csvFiles : [csvFiles];
+    }
+    // Helper method to process CLI files with auto-detection
+    static processCliFiles(files) {
+        if (!files) {
+            return undefined;
+        }
+        return Array.isArray(files) ? files : [files];
+    }
     // Helper method to process common options
     static processOptions(argv) {
         // Handle noColor option by disabling chalk
@@ -674,7 +708,7 @@ export class CLICommandFactory {
     static createLoopCommand() {
         return {
             command: "loop",
-            describe: "Start an interactive loop session",
+            describe: "Start an interactive loop session with conversation management",
             builder: (yargs) => this.buildOptions(yargs, {
                 "enable-conversation-memory": {
                     type: "boolean",
@@ -696,9 +730,27 @@ export class CLICommandFactory {
                     description: "Automatically use Redis if available",
                     default: true,
                 },
+                resume: {
+                    type: "string",
+                    description: "Directly resume a specific conversation by session ID",
+                    alias: "r",
+                },
+                new: {
+                    type: "boolean",
+                    description: "Force start a new conversation (skip selection menu)",
+                    alias: "n",
+                },
+                "list-conversations": {
+                    type: "boolean",
+                    description: "List available conversations and exit",
+                    alias: "l",
+                },
             })
-                .example("$0 loop --no-auto-redis", "Start loop with memory storage only")
-                .example("$0 loop", "Start interactive session")
+                .example("$0 loop", "Start interactive session with conversation selection")
+                .example("$0 loop --new", "Force start new conversation")
+                .example("$0 loop --resume abc123", "Resume specific conversation")
+                .example("$0 loop --list-conversations", "List available conversations")
+                .example("$0 loop --no-auto-redis", "Use in-memory storage only")
                 .example("$0 loop --enable-conversation-memory", "Start loop with memory"),
             handler: async (argv) => {
                 if (globalSession.getCurrentSessionId()) {
@@ -706,7 +758,7 @@ export class CLICommandFactory {
                     return;
                 }
                 let conversationMemoryConfig;
-                const { enableConversationMemory, maxSessions, maxTurnsPerSession, autoRedis, } = argv;
+                const { enableConversationMemory, maxSessions, maxTurnsPerSession, autoRedis, listConversations, } = argv;
                 if (enableConversationMemory) {
                     let storageType = "memory";
                     if (autoRedis) {
@@ -731,7 +783,48 @@ export class CLICommandFactory {
                         maxTurnsPerSession: maxTurnsPerSession,
                     };
                 }
-                const session = new LoopSession(initializeCliParser, conversationMemoryConfig);
+                // Handle --list-conversations option
+                if (listConversations) {
+                    const { ConversationSelector } = await import("../loop/conversationSelector.js");
+                    const conversationSelector = new ConversationSelector();
+                    try {
+                        const hasConversations = await conversationSelector.hasStoredConversations();
+                        if (!hasConversations) {
+                            logger.always(chalk.yellow("📝 No stored conversations found"));
+                            return;
+                        }
+                        const conversations = await conversationSelector.getAvailableConversations();
+                        logger.always(chalk.blue("📋 Available Conversations:"));
+                        conversations.forEach((conv, index) => {
+                            const sessionId = conv.sessionId.slice(0, 12) + "...";
+                            const title = conv.title || "Untitled Conversation";
+                            const messageCount = conv.messageCount || 0;
+                            const lastActivity = conv.updatedAt
+                                ? new Date(conv.updatedAt).toLocaleDateString()
+                                : "Unknown";
+                            logger.always(`${index + 1}. ${chalk.cyan(sessionId)} - ${title}`);
+                            logger.always(`   ${chalk.gray(`${messageCount} messages | Last: ${lastActivity}`)}`);
+                        });
+                        logger.always(chalk.gray(`\nUse: neurolink loop --resume <session-id> to resume a conversation`));
+                    }
+                    catch (error) {
+                        logger.error("Failed to list conversations:", error);
+                    }
+                    finally {
+                        await conversationSelector.close();
+                    }
+                    return;
+                }
+                // Create enhanced session with direct session management options
+                const sessionOptions = {};
+                // Pass CLI options to session for direct session management
+                if (argv.resume && typeof argv.resume === "string") {
+                    sessionOptions.directResumeSessionId = argv.resume;
+                }
+                if (argv.new) {
+                    sessionOptions.forceNewSession = true;
+                }
+                const session = new LoopSession(initializeCliParser, conversationMemoryConfig, sessionOptions);
                 await session.start();
             },
         };
@@ -951,6 +1044,7 @@ export class CLICommandFactory {
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
                 if (!globalSession.getCurrentSessionId()) {
+                    await this.flushLangfuseTraces();
                     process.exit(0);
                 }
             }
@@ -967,12 +1061,21 @@ export class CLICommandFactory {
                     toolsEnabled: !options.disableTools,
                 });
             }
-            // Process CLI images if provided
+            // Process CLI multimodal inputs
             const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+            const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
+            const files = CLICommandFactory.processCliFiles(argv.file);
             const result = await sdk.generate({
-                input: imageBuffers
-                    ? { text: inputText, images: imageBuffers }
-                    : { text: inputText },
+                input: {
+                    text: inputText,
+                    ...(imageBuffers && { images: imageBuffers }),
+                    ...(csvFiles && { csvFiles }),
+                    ...(files && { files }),
+                },
+                csvOptions: {
+                    maxRows: argv.csvMaxRows,
+                    formatStyle: argv.csvFormat,
+                },
                 provider: enhancedOptions.provider,
                 model: enhancedOptions.model,
                 temperature: enhancedOptions.temperature,
@@ -1018,6 +1121,7 @@ export class CLICommandFactory {
                 }
             }
             if (!globalSession.getCurrentSessionId()) {
+                await this.flushLangfuseTraces();
                 process.exit(0);
             }
         }
@@ -1126,6 +1230,7 @@ export class CLICommandFactory {
             logger.debug("Mode: DRY-RUN (no actual API calls made)");
         }
         if (!globalSession.getCurrentSessionId()) {
+            await this.flushLangfuseTraces();
             process.exit(0);
         }
     }
@@ -1140,12 +1245,21 @@ export class CLICommandFactory {
         const context = sessionId
             ? { ...contextMetadata, sessionId }
             : contextMetadata;
-        // Process CLI images if provided
+        // Process CLI multimodal inputs
         const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+        const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
+        const files = CLICommandFactory.processCliFiles(argv.file);
         const stream = await sdk.stream({
-            input: imageBuffers
-                ? { text: inputText, images: imageBuffers }
-                : { text: inputText },
+            input: {
+                text: inputText,
+                ...(imageBuffers && { images: imageBuffers }),
+                ...(csvFiles && { csvFiles }),
+                ...(files && { files }),
+            },
+            csvOptions: {
+                maxRows: argv.csvMaxRows,
+                formatStyle: argv.csvFormat,
+            },
             provider: enhancedOptions.provider,
             model: enhancedOptions.model,
             temperature: enhancedOptions.temperature,
@@ -1179,11 +1293,14 @@ export class CLICommandFactory {
         let fullContent = "";
         let contentReceived = false;
         const abortController = new AbortController();
-        // Create timeout promise for stream consumption (30 seconds)
+        // Create timeout promise for stream consumption (default: 30 seconds, respects user-provided timeout)
+        const streamTimeout = options.timeout && typeof options.timeout === "number"
+            ? options.timeout * 1000
+            : 30000;
         const timeoutPromise = new Promise((_, reject) => {
             const timeoutId = setTimeout(() => {
                 if (!contentReceived) {
-                    const timeoutError = new Error("\n❌ Stream timeout - no content received within 30 seconds\n" +
+                    const timeoutError = new Error(`\n❌ Stream timeout - no content received within ${streamTimeout / 1000} seconds\n` +
                         "This usually indicates authentication or network issues\n\n" +
                         "🔧 Try these steps:\n" +
                         "1. Check your provider credentials are configured correctly\n" +
@@ -1191,7 +1308,7 @@ export class CLICommandFactory {
                         `3. Use debug mode: neurolink stream "test" --provider ${options.provider} --debug`);
                     reject(timeoutError);
                 }
-            }, 30000);
+            }, streamTimeout);
             // Clean up timeout when aborted
             abortController.signal.addEventListener("abort", () => {
                 clearTimeout(timeoutId);
@@ -1375,6 +1492,7 @@ export class CLICommandFactory {
             const fullContent = await this.executeRealStream(argv, options, inputText, contextMetadata);
             await this.handleStreamOutput(options, fullContent);
             if (!globalSession.getCurrentSessionId()) {
+                await this.flushLangfuseTraces();
                 process.exit(0);
             }
         }
@@ -1496,6 +1614,7 @@ export class CLICommandFactory {
             // Handle output with universal formatting
             this.handleOutput(results, options);
             if (!globalSession.getCurrentSessionId()) {
+                await this.flushLangfuseTraces();
                 process.exit(0);
             }
         }
@@ -1891,4 +2010,18 @@ export class CLICommandFactory {
             handleError(error, "Completion generation");
         }
     }
+    /**
+     * Flush Langfuse traces before exit
+     */
+    static async flushLangfuseTraces() {
+        try {
+            logger.debug("[CLI] Flushing Langfuse traces before exit...");
+            const { flushOpenTelemetry } = await import("../../lib/services/server/ai/observability/instrumentation.js");
+            await flushOpenTelemetry();
+            logger.debug("[CLI] Langfuse traces flushed successfully");
+        }
+        catch (error) {
+            logger.error("[CLI] Error flushing Langfuse traces", { error });
+        }
+    }
 }

package/dist/cli/index.js

@@ -32,17 +32,28 @@ const cli = initializeCliParser();
     try {
         // Parse and execute commands
         await cli.parse();
+        await cleanup();
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
         process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
+        await cleanup();
         process.exit(1);
     }
 })();
 // Cleanup on exit
-process.on("SIGINT", () => {
+process.on("SIGINT", async () => {
+    await cleanup();
     process.exit(0);
 });
-process.on("SIGTERM", () => {
+process.on("SIGTERM", async () => {
+    await cleanup();
     process.exit(0);
 });
+process.on("beforeExit", async () => {
+    await cleanup();
+});
+async function cleanup() {
+    const { flushOpenTelemetry } = await import("../lib/services/server/ai/observability/instrumentation.js");
+    await flushOpenTelemetry();
+}

package/dist/cli/loop/conversationSelector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Conversation Selector for Loop Mode
+ * Handles discovery and selection of stored conversations from Redis
+ */
+import type { ConversationSummary } from "../../lib/types/conversation.js";
+import type { RedisStorageConfig } from "../../lib/types/conversation.js";
+export declare class ConversationSelector {
+    private redisClient;
+    private redisConfig;
+    private conversationCache;
+    private cacheTimestamp;
+    constructor(redisConfig?: RedisStorageConfig);
+    /**
+     * Initialize Redis connection
+     */
+    private initializeRedis;
+    /**
+     * Get available conversations for a user
+     */
+    getAvailableConversations(userId?: string): Promise<ConversationSummary[]>;
+    /**
+     * Display conversation menu and get user selection
+     */
+    displayConversationMenu(userId?: string): Promise<string | "NEW_CONVERSATION">;
+    /**
+     * Check if there are any stored conversations
+     */
+    hasStoredConversations(userId?: string): Promise<boolean>;
+    /**
+     * Close Redis connection
+     */
+    close(): Promise<void>;
+    private scanConversationKeys;
+    private processConversationKeys;
+    private processSingleConversationKey;
+    private sortConversationsByDate;
+    private updateCache;
+    private filterConversationsByUser;
+    private createMenuChoices;
+    private showSelectionPrompt;
+    private handleRetrievalError;
+    private handleMenuError;
+    private createConversationSummary;
+    private formatConversationChoice;
+}

package/dist/cli/loop/conversationSelector.js

@@ -0,0 +1,222 @@
+/**
+ * Conversation Selector for Loop Mode
+ * Handles discovery and selection of stored conversations from Redis
+ */
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { createRedisClient, scanKeys, deserializeConversation, getNormalizedConfig, } from "../../lib/utils/redis.js";
+import { logger } from "../../lib/utils/logger.js";
+import { LOOP_CACHE_CONFIG, LOOP_DISPLAY_LIMITS, generateConversationTitle, truncateText, formatTimeAgo, getContentIcon, } from "../../lib/utils/loopUtils.js";
+export class ConversationSelector {
+    redisClient = null;
+    redisConfig;
+    conversationCache = null;
+    cacheTimestamp = 0;
+    constructor(redisConfig = {}) {
+        this.redisConfig = getNormalizedConfig(redisConfig);
+    }
+    /**
+     * Initialize Redis connection
+     */
+    async initializeRedis() {
+        if (!this.redisClient) {
+            this.redisClient = await createRedisClient(this.redisConfig);
+        }
+    }
+    /**
+     * Get available conversations for a user
+     */
+    async getAvailableConversations(userId) {
+        // Check if cached conversations are still valid (within TTL)
+        if (this.conversationCache &&
+            Date.now() - this.cacheTimestamp < LOOP_CACHE_CONFIG.TTL_MS) {
+            logger.debug("Using cached conversation list");
+            return this.filterConversationsByUser(this.conversationCache, userId);
+        }
+        try {
+            await this.initializeRedis();
+            if (!this.redisClient) {
+                throw new Error("Redis client not available");
+            }
+            const keys = await this.scanConversationKeys();
+            if (keys.length === 0) {
+                logger.debug("No conversations found in Redis");
+                return [];
+            }
+            const summaries = await this.processConversationKeys(keys);
+            const sortedSummaries = this.sortConversationsByDate(summaries);
+            this.updateCache(sortedSummaries);
+            return this.filterConversationsByUser(sortedSummaries, userId);
+        }
+        catch (error) {
+            return this.handleRetrievalError(error);
+        }
+    }
+    /**
+     * Display conversation menu and get user selection
+     */
+    async displayConversationMenu(userId) {
+        try {
+            const conversations = await this.getAvailableConversations(userId);
+            if (conversations.length === 0) {
+                logger.debug("No conversations available for selection");
+                return "NEW_CONVERSATION";
+            }
+            const choices = this.createMenuChoices(conversations);
+            return await this.showSelectionPrompt(choices);
+        }
+        catch (error) {
+            return this.handleMenuError(error);
+        }
+    }
+    /**
+     * Check if there are any stored conversations
+     */
+    async hasStoredConversations(userId) {
+        try {
+            const conversations = await this.getAvailableConversations(userId);
+            return conversations.length > 0;
+        }
+        catch (error) {
+            logger.debug("Failed to check for stored conversations:", error);
+            return false;
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async close() {
+        if (this.redisClient) {
+            await this.redisClient.quit();
+            this.redisClient = null;
+        }
+    }
+    async scanConversationKeys() {
+        if (!this.redisClient) {
+            throw new Error("Redis client not initialized");
+        }
+        const pattern = `${this.redisConfig.keyPrefix}*`;
+        const keys = await scanKeys(this.redisClient, pattern);
+        logger.debug(`Found ${keys.length} conversation keys in Redis`);
+        return keys;
+    }
+    async processConversationKeys(keys) {
+        const summaries = [];
+        for (const key of keys) {
+            const summary = await this.processSingleConversationKey(key);
+            if (summary) {
+                summaries.push(summary);
+            }
+        }
+        return summaries;
+    }
+    async processSingleConversationKey(key) {
+        if (!this.redisClient) {
+            logger.warn(`Redis client not available for key ${key}`);
+            return null;
+        }
+        try {
+            const conversationData = await this.redisClient.get(key);
+            const conversation = deserializeConversation(conversationData);
+            if (conversation &&
+                conversation.messages &&
+                conversation.messages.length > 0) {
+                return this.createConversationSummary(conversation);
+            }
+            return null;
+        }
+        catch (error) {
+            logger.warn(`Failed to process conversation key ${key}:`, error);
+            return null;
+        }
+    }
+    sortConversationsByDate(summaries) {
+        return summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    updateCache(summaries) {
+        this.conversationCache = summaries;
+        this.cacheTimestamp = Date.now();
+        logger.debug(`Retrieved ${summaries.length} valid conversations`);
+    }
+    filterConversationsByUser(summaries, userId) {
+        if (!userId) {
+            return summaries;
+        }
+        return summaries.filter((summary) => summary.userId === userId);
+    }
+    /*
+     * Create menu choices for inquirer prompt
+     */
+    createMenuChoices(conversations) {
+        const choices = [
+            {
+                name: chalk.green("🆕 Start New Conversation"),
+                value: "NEW_CONVERSATION",
+                short: "New Conversation",
+            },
+            new inquirer.Separator(),
+        ];
+        for (const conversation of conversations.slice(0, LOOP_DISPLAY_LIMITS.MAX_CONVERSATIONS)) {
+            const choice = this.formatConversationChoice(conversation);
+            choices.push(choice);
+        }
+        return choices;
+    }
+    async showSelectionPrompt(choices) {
+        const answer = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedConversation",
+                message: "Select a conversation to continue:",
+                choices,
+                pageSize: LOOP_DISPLAY_LIMITS.PAGE_SIZE,
+            },
+        ]);
+        return answer.selectedConversation;
+    }
+    handleRetrievalError(error) {
+        logger.error("Failed to retrieve conversations:", error);
+        return [];
+    }
+    handleMenuError(error) {
+        logger.error("Failed to display conversation menu:", error);
+        return "NEW_CONVERSATION";
+    }
+    createConversationSummary(conversation) {
+        const messages = conversation.messages;
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        return {
+            sessionId: conversation.sessionId,
+            id: conversation.id,
+            title: conversation.title || generateConversationTitle(firstMessage.content),
+            firstMessage: {
+                content: truncateText(firstMessage.content, LOOP_DISPLAY_LIMITS.CONTENT_LENGTH),
+                timestamp: firstMessage.timestamp || conversation.createdAt,
+            },
+            lastMessage: {
+                content: truncateText(lastMessage.content, LOOP_DISPLAY_LIMITS.CONTENT_LENGTH),
+                timestamp: lastMessage.timestamp || conversation.updatedAt,
+            },
+            messageCount: messages.length,
+            userId: conversation.userId,
+            duration: formatTimeAgo(conversation.updatedAt),
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
+        };
+    }
+    formatConversationChoice(summary) {
+        const icon = getContentIcon(summary.firstMessage.content);
+        const title = chalk.white(summary.title || "Untitled Conversation");
+        const duration = chalk.gray(`(${summary.duration})`);
+        const details = chalk.gray(`     └ ${summary.messageCount} message${summary.messageCount !== 1 ? "s" : ""} | ` +
+            `Session: ${summary.sessionId.slice(0, LOOP_DISPLAY_LIMITS.SESSION_ID_DISPLAY)}... | ` +
+            `Updated: ${new Date(summary.updatedAt).toLocaleString()}`);
+        const name = `${icon} ${title} ${duration}\n${details}`;
+        return {
+            name,
+            value: summary.sessionId,
+            short: `${summary.title} (${summary.sessionId.slice(0, LOOP_DISPLAY_LIMITS.SESSION_ID_SHORT)}...)`,
+        };
+    }
+}

package/dist/cli/loop/optionsSchema.d.ts

@@ -12,4 +12,4 @@ export interface OptionSchema {
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions">, OptionSchema>;

package/dist/cli/loop/session.d.ts

@@ -2,27 +2,55 @@ import type { Argv } from "yargs";
 import type { ConversationMemoryConfig } from "../../lib/types/conversation.js";
 export declare class LoopSession {
     private conversationMemoryConfig?;
+    private options?;
     private initializeCliParser;
     private isRunning;
     private sessionId?;
     private commandHistory;
     private sessionVariablesSchema;
-    constructor(initializeCliParser: () => Argv, conversationMemoryConfig?: ConversationMemoryConfig | undefined);
+    constructor(initializeCliParser: () => Argv, conversationMemoryConfig?: ConversationMemoryConfig | undefined, options?: {
+        directResumeSessionId?: string;
+        forceNewSession?: boolean;
+    } | undefined);
     start(): Promise<void>;
+    /**
+     * Handle direct session resume from CLI option
+     */
+    private handleDirectSessionResume;
+    /**
+     * Handle conversation selection logic when no direct resume is specified
+     */
+    private handleConversationSelection;
+    /**
+     * Clean up session resources and connections
+     */
+    private cleanup;
     private handleSessionCommands;
-    private parseValue;
     private showHelp;
     private showSetHelp;
     /**
-     * Load command history from the global history file
+     * Get command input with history support using readline
+     */
+    private getCommandWithHistory;
+    /**
+     * Restore a conversation session and set up the global session state
      */
-    private loadHistory;
+    private restoreSession;
     /**
-     * Save a command to the global history file
+     * Create NeuroLink instance and validate conversation in one step
+     * Eliminates redundant instance creation and initialization
      */
-    private saveCommand;
+    private createAndValidateNeurolinkInstance;
     /**
-     * Get command input with history support using readline
+     * Configure tool execution context for the restored session
      */
-    private getCommandWithHistory;
+    private configureToolContext;
+    /**
+     * Verify that tools are available and working in the restored session
+     */
+    private verifyToolAvailability;
+    /**
+     * Restore global session state and session variables
+     */
+    private restoreGlobalSessionState;
 }