@juspay/neurolink 7.48.0 → 7.49.0

package/dist/cli/loop/session.js

@@ -1,12 +1,12 @@
 import chalk from "chalk";
 import readline from "readline";
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
 import { logger } from "../../lib/utils/logger.js";
 import { globalSession } from "../../lib/session/globalSessionState.js";
 import { textGenerationOptionsSchema } from "./optionsSchema.js";
 import { handleError } from "../errorHandler.js";
+import { ConversationSelector } from "./conversationSelector.js";
+import { NeuroLink } from "../../lib/neurolink.js";
+import { displaySessionMessage, verifyConversationContext, getConversationPreview, loadCommandHistory, saveCommandToHistory, displayConversationPreview, parseValue, restoreSessionVariables, } from "../../lib/utils/loopUtils.js";
 // Banner Art
 const NEUROLINK_BANNER = `
 ▗▖  ▗▖▗▄▄▄▖▗▖ ▗▖▗▄▄▖  ▗▄▖ ▗▖   ▗▄▄▄▖▗▖  ▗▖▗▖ ▗▖
@@ -14,33 +14,58 @@ const NEUROLINK_BANNER = `
 ▐▌ ▝▜▌▐▛▀▀▘▐▌ ▐▌▐▛▀▚▖▐▌ ▐▌▐▌     █  ▐▌ ▝▜▌▐▛▚▖ 
 ▐▌  ▐▌▐▙▄▄▖▝▚▄▞▘▐▌ ▐▌▝▚▄▞▘▐▙▄▄▖▗▄█▄▖▐▌  ▐▌▐▌ ▐▌
 `;
-// Global command history file
-const HISTORY_FILE = path.join(os.homedir(), ".neurolink_history");
 export class LoopSession {
     conversationMemoryConfig;
+    options;
     initializeCliParser;
     isRunning = false;
     sessionId;
     commandHistory = [];
     sessionVariablesSchema = textGenerationOptionsSchema;
-    constructor(initializeCliParser, conversationMemoryConfig) {
+    constructor(initializeCliParser, conversationMemoryConfig, options) {
         this.conversationMemoryConfig = conversationMemoryConfig;
+        this.options = options;
         this.initializeCliParser = initializeCliParser;
     }
     async start() {
         // Initialize global session state
         this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
         // Load command history from global file, reverse once for most recent first
-        this.commandHistory = (await this.loadHistory()).reverse();
+        this.commandHistory = (await loadCommandHistory()).reverse();
         this.isRunning = true;
         logger.always(chalk.bold.green(NEUROLINK_BANNER));
         logger.always(chalk.bold.green("Welcome to NeuroLink Loop Mode!"));
+        // Check for direct CLI options
+        const directResumeSessionId = this.options?.directResumeSessionId;
+        const forceNewSession = this.options?.forceNewSession;
+        // Handle conversation discovery and selection if memory is enabled
         if (this.conversationMemoryConfig?.enabled) {
-            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
             logger.always(chalk.gray("Conversation memory enabled"));
+            // Handle direct resume option
+            if (directResumeSessionId) {
+                await this.handleDirectSessionResume(directResumeSessionId);
+            }
+            // Handle force new session option
+            else if (forceNewSession) {
+                logger.always(chalk.blue("Force starting new conversation..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+            // Default behavior: check for existing conversations
+            else {
+                await this.handleConversationSelection();
+            }
+            // Display session information
+            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
             logger.always(chalk.gray(`Max sessions: ${this.conversationMemoryConfig.maxSessions}`));
             logger.always(chalk.gray(`Max turns per session: ${this.conversationMemoryConfig.maxTurnsPerSession}\n`));
         }
+        else {
+            // No conversation memory - just create a new session
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
+        }
+        // Load command history from global file
+        this.commandHistory = (await loadCommandHistory()).reverse();
         logger.always(chalk.gray('Type "help" for a list of commands.'));
         logger.always(chalk.gray('Type "exit", "quit", or ":q" to leave the loop.'));
         while (this.isRunning) {
@@ -61,7 +86,7 @@ export class LoopSession {
                     // Save session commands to history (both memory and file)
                     if (command && command.trim()) {
                         this.commandHistory.unshift(command);
-                        await this.saveCommand(command);
+                        await saveCommandToHistory(command);
                     }
                     continue;
                 }
@@ -81,7 +106,7 @@ export class LoopSession {
                 // Save command to history (both memory and file)
                 if (command && command.trim()) {
                     this.commandHistory.unshift(command);
-                    await this.saveCommand(command);
+                    await saveCommandToHistory(command);
                 }
             }
             catch (error) {
@@ -90,8 +115,96 @@ export class LoopSession {
             }
         }
         // Cleanup on exit
-        globalSession.clearLoopSession();
-        logger.always(chalk.yellow("Loop session ended."));
+        this.cleanup();
+    }
+    /**
+     * Handle direct session resume from CLI option
+     */
+    async handleDirectSessionResume(directResumeSessionId) {
+        logger.always(chalk.blue(`Attempting to resume session: ${directResumeSessionId.slice(0, 12)}...`));
+        try {
+            const restoreResult = await this.restoreSession(directResumeSessionId);
+            if (restoreResult.success) {
+                displaySessionMessage(restoreResult);
+                this.sessionId = directResumeSessionId;
+                // Display conversation preview
+                const preview = await getConversationPreview(directResumeSessionId, 2);
+                displayConversationPreview(preview, 2);
+            }
+            else {
+                displaySessionMessage(restoreResult);
+                logger.always(chalk.yellow("Starting new conversation instead..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to resume session ${directResumeSessionId}:`, error);
+            logger.always(chalk.yellow("Starting new conversation instead..."));
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+        }
+    }
+    /**
+     * Handle conversation selection logic when no direct resume is specified
+     */
+    async handleConversationSelection() {
+        logger.always(chalk.gray("Checking for existing conversations...\n"));
+        try {
+            const conversationSelector = new ConversationSelector();
+            // Check if there are any stored conversations
+            const hasStoredConversations = await conversationSelector.hasStoredConversations();
+            if (hasStoredConversations) {
+                // Show conversation selection menu
+                const selectedSessionId = await conversationSelector.displayConversationMenu();
+                if (selectedSessionId !== "NEW_CONVERSATION") {
+                    // Restore the selected conversation
+                    logger.always(chalk.blue("Restoring conversation..."));
+                    const restoreResult = await this.restoreSession(selectedSessionId);
+                    if (restoreResult.success) {
+                        displaySessionMessage(restoreResult);
+                        this.sessionId = selectedSessionId;
+                        // Display conversation preview
+                        const preview = await getConversationPreview(selectedSessionId, 2);
+                        displayConversationPreview(preview, 2);
+                    }
+                    else {
+                        displaySessionMessage(restoreResult);
+                        logger.always(chalk.yellow("Starting new conversation instead..."));
+                        this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+                    }
+                }
+                else {
+                    // User chose to start new conversation
+                    logger.always(chalk.blue("Starting new conversation..."));
+                    this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+                }
+            }
+            else {
+                // No existing conversations found
+                logger.always(chalk.gray("No existing conversations found."));
+                logger.always(chalk.blue("Starting new conversation..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+            // Close the conversation selector
+            await conversationSelector.close();
+        }
+        catch (error) {
+            logger.warn("Failed to check for existing conversations:", error);
+            logger.always(chalk.yellow("Starting new conversation..."));
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+        }
+    }
+    /**
+     * Clean up session resources and connections
+     */
+    cleanup() {
+        try {
+            globalSession.clearLoopSession();
+            logger.always(chalk.yellow("Loop session ended."));
+        }
+        catch (error) {
+            // Silently handle cleanup errors to avoid hanging
+            logger.error("Error during cleanup:", error);
+        }
     }
     async handleSessionCommands(command) {
         const parts = command.split(" ");
@@ -113,7 +226,7 @@ export class LoopSession {
                         return true;
                     }
                     const valueStr = parts.slice(2).join(" ");
-                    let value = this.parseValue(valueStr);
+                    let value = parseValue(valueStr);
                     // Validate type
                     if (schema.type === "boolean" && typeof value !== "boolean") {
                         logger.always(chalk.red(`Error: Invalid value for "${key}". Expected a boolean (true/false).`));
@@ -196,21 +309,6 @@ export class LoopSession {
                 return false;
         }
     }
-    parseValue(value) {
-        // Try to parse as number
-        if (!isNaN(Number(value))) {
-            return Number(value);
-        }
-        // Try to parse as boolean
-        if (value.toLowerCase() === "true") {
-            return true;
-        }
-        if (value.toLowerCase() === "false") {
-            return false;
-        }
-        // Return as string
-        return value;
-    }
     showHelp() {
         logger.always(chalk.cyan("Available Loop Mode Commands:"));
         const commands = [
@@ -254,39 +352,6 @@ export class LoopSession {
             }
         }
     }
-    /**
-     * Load command history from the global history file
-     */
-    async loadHistory() {
-        try {
-            const content = await fs.readFile(HISTORY_FILE, "utf8");
-            return content.split("\n").filter((line) => line.trim());
-        }
-        catch {
-            // File doesn't exist yet or can't be read
-            return [];
-        }
-    }
-    /**
-     * Save a command to the global history file
-     */
-    async saveCommand(command) {
-        try {
-            // Skip potentially sensitive commands
-            const sensitivePattern = /\b(api[-_]?key|token|password|secret|authorization)\b/i;
-            if (sensitivePattern.test(command)) {
-                return;
-            }
-            // Use writeFile with flag 'a' and mode 0o600 to ensure permissions on creation
-            await fs.writeFile(HISTORY_FILE, command + "\n", { flag: "a", mode: 0o600 });
-            // Ensure existing file remains private (best-effort)
-            await fs.chmod(HISTORY_FILE, 0o600);
-        }
-        catch (error) {
-            // Log file write errors as warnings, but do not interrupt CLI flow
-            logger.warn("Warning: Could not save command to history:", error);
-        }
-    }
     /**
      * Get command input with history support using readline
      */
@@ -310,4 +375,135 @@ export class LoopSession {
             });
         });
     }
+    // === SESSION RESTORATION METHODS ===
+    /**
+     * Restore a conversation session and set up the global session state
+     */
+    async restoreSession(sessionId, userId) {
+        // Local helper for creating failure results with bound sessionId
+        const createFailure = (error) => ({
+            success: false,
+            sessionId,
+            messageCount: 0,
+            error,
+        });
+        try {
+            logger.debug(`Attempting to restore session: ${sessionId}`);
+            // 1. Create NeuroLink instance and validate conversation in one step
+            const { neurolinkInstance, conversationData } = await this.createAndValidateNeurolinkInstance(sessionId, userId);
+            if (!conversationData) {
+                return createFailure(`Conversation ${sessionId} not found or inaccessible`);
+            }
+            // 2. Set up tool execution context
+            await this.configureToolContext(neurolinkInstance, sessionId, userId);
+            // 3. Restore global session state
+            this.restoreGlobalSessionState(sessionId, neurolinkInstance, conversationData);
+            // 4. Verify conversation context accessibility
+            await verifyConversationContext(sessionId);
+            const result = {
+                success: true,
+                sessionId,
+                messageCount: conversationData.messages?.length || 0,
+                lastActivity: conversationData.updatedAt,
+            };
+            logger.info(`Session restored successfully: ${sessionId}`, {
+                messageCount: result.messageCount,
+                lastActivity: result.lastActivity,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error(`Failed to restore session ${sessionId}:`, error);
+            return createFailure(error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Create NeuroLink instance and validate conversation in one step
+     * Eliminates redundant instance creation and initialization
+     */
+    async createAndValidateNeurolinkInstance(sessionId, userId) {
+        // Create NeuroLink instance with proper configuration
+        const neurolinkOptions = {};
+        if (this.conversationMemoryConfig?.enabled) {
+            neurolinkOptions.conversationMemory = {
+                enabled: true,
+                maxSessions: this.conversationMemoryConfig.maxSessions,
+                maxTurnsPerSession: this.conversationMemoryConfig.maxTurnsPerSession,
+            };
+            neurolinkOptions.sessionId = sessionId;
+        }
+        const neurolinkInstance = new NeuroLink(neurolinkOptions);
+        await neurolinkInstance.ensureConversationMemoryInitialized();
+        // Use the same instance to validate conversation exists
+        try {
+            const messages = await neurolinkInstance.getConversationHistory(sessionId);
+            if (!messages || messages.length === 0) {
+                logger.debug(`No conversation messages found for session ${sessionId}`);
+                return { neurolinkInstance, conversationData: null };
+            }
+            // Create conversation object with available data
+            const conversationData = {
+                id: sessionId,
+                sessionId,
+                userId: userId || "unknown",
+                messages,
+                createdAt: new Date().toISOString(), // Fallback
+                updatedAt: new Date().toISOString(), // Fallback
+                title: messages[0]?.content?.slice(0, 50) + "..." || "Untitled Conversation",
+            };
+            return { neurolinkInstance, conversationData };
+        }
+        catch (error) {
+            logger.debug(`Error accessing conversation for session ${sessionId}:`, error);
+            return { neurolinkInstance, conversationData: null };
+        }
+    }
+    /**
+     * Configure tool execution context for the restored session
+     */
+    async configureToolContext(neurolinkInstance, sessionId, userId) {
+        const toolContext = {
+            sessionId,
+            userId: userId || "loop-user",
+            source: "loop-mode",
+            restored: true,
+            timestamp: new Date().toISOString(),
+        };
+        neurolinkInstance.setToolContext(toolContext);
+        logger.debug("Tool execution context configured for restored session", {
+            sessionId,
+            userId,
+            hasToolContext: true,
+        });
+        await this.verifyToolAvailability(neurolinkInstance);
+    }
+    /**
+     * Verify that tools are available and working in the restored session
+     */
+    async verifyToolAvailability(neurolinkInstance) {
+        try {
+            const availableTools = await neurolinkInstance.getAllAvailableTools();
+            logger.debug(`Tools available in restored session: ${availableTools.length} tools`, {
+                toolNames: availableTools.slice(0, 5).map((t) => t.name),
+                hasFileTools: availableTools.some((t) => t.name.includes("file") || t.name.includes("File")),
+                hasDirectoryTools: availableTools.some((t) => t.name.includes("directory") || t.name.includes("Directory")),
+            });
+            if (availableTools.length === 0) {
+                logger.warn("No tools available in restored session - this may affect AI capabilities");
+            }
+        }
+        catch (error) {
+            logger.warn("Could not verify tool availability in restored session:", error);
+        }
+    }
+    /**
+     * Restore global session state and session variables
+     */
+    restoreGlobalSessionState(sessionId, neurolinkInstance, conversationData) {
+        globalSession.clearLoopSession();
+        globalSession.restoreLoopSession(sessionId, neurolinkInstance, this.conversationMemoryConfig, {});
+        if (conversationData) {
+            restoreSessionVariables(conversationData);
+        }
+    }
 }

package/dist/core/baseProvider.js

@@ -98,6 +98,7 @@ export class BaseProvider {
                     // Convert stream options to text generation options
                     const textOptions = {
                         prompt: options.input?.text || "",
+                        input: options.input,
                         systemPrompt: options.systemPrompt,
                         temperature: options.temperature,
                         maxTokens: options.maxTokens,
@@ -111,6 +112,7 @@ export class BaseProvider {
                         evaluationDomain: options.evaluationDomain,
                         toolUsageContext: options.toolUsageContext,
                         context: options.context,
+                        csvOptions: options.csvOptions,
                     };
                     logger.debug(`Calling generate for fake streaming`, {
                         provider: this.providerName,
@@ -229,7 +231,9 @@ export class BaseProvider {
             const input = opts.input;
             const hasImages = !!input?.images?.length;
             const hasContent = !!input?.content?.length;
-            return hasImages || hasContent;
+            const hasCSVFiles = !!input?.csvFiles?.length;
+            const hasFiles = !!input?.files?.length;
+            return hasImages || hasContent || hasCSVFiles || hasFiles;
         };
         let messages;
         if (hasMultimodalInput(options)) {
@@ -242,7 +246,10 @@ export class BaseProvider {
                     text: options.prompt || options.input?.text || "",
                     images: input?.images,
                     content: input?.content,
+                    csvFiles: input?.csvFiles,
+                    files: input?.files,
                 },
+                csvOptions: options.csvOptions,
                 provider: options.provider,
                 model: options.model,
                 temperature: options.temperature,
@@ -258,7 +265,7 @@ export class BaseProvider {
             if (process.env.NEUROLINK_DEBUG === "true") {
                 logger.debug("No multimodal input detected, using standard message builder");
             }
-            messages = buildMessagesArray(options);
+            messages = await buildMessagesArray(options);
         }
         // Convert messages to Vercel AI SDK format
         return messages.map((msg) => {

package/dist/core/evaluation.js

@@ -225,8 +225,11 @@ Completeness: [score]
 Overall: [score]
 Reasoning: [Provide a detailed explanation of your evaluation, explaining why you gave these scores. Include specific observations about the response's strengths and all possible areas for improvement.]
 `;
-        // Generate evaluation
-        const result = await provider.generate(prompt);
+        // Generate evaluation (simple text prompt only - no file processing)
+        const result = await provider.generate({
+            input: { text: prompt },
+            disableTools: true, // Evaluation doesn't need tools
+        });
         if (!result) {
             logger.debug(`[${functionTag}] No response from provider`);
             return getDefaultEvaluation("no-response", Date.now() - startTime, context);

package/dist/factories/providerRegistry.js

@@ -45,9 +45,9 @@ export class ProviderRegistry {
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk) => {
                 const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
-                return new AzureOpenAIProvider(modelName);
+                return new AzureOpenAIProvider(modelName, sdk);
             }, process.env.AZURE_MODEL ||
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||

package/dist/lib/agent/directTools.d.ts

@@ -346,6 +346,61 @@ export declare const directAgentTools: {
             count?: undefined;
         }>;
     };
+    analyzeCSV: import("ai").Tool<z.ZodObject<{
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        operation: z.ZodEnum<["count_by_column", "sum_by_column", "average_by_column", "min_max_by_column", "describe"]>;
+        column: z.ZodOptional<z.ZodString>;
+        maxRows: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        maxRows?: number | undefined;
+        column?: string | undefined;
+    }, {
+        filePath: string;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        maxRows?: number | undefined;
+        column?: string | undefined;
+    }>, {
+        success: boolean;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        column: string | undefined;
+        result: string;
+        rowCount: number;
+    } | {
+        success: boolean;
+        error: string;
+        operation?: undefined;
+        column?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        column: string | undefined;
+    }> & {
+        execute: (args: {
+            filePath: string;
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            maxRows?: number | undefined;
+            column?: string | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            column: string | undefined;
+            result: string;
+            rowCount: number;
+        } | {
+            success: boolean;
+            error: string;
+            operation?: undefined;
+            column?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            column: string | undefined;
+        }>;
+    };
     websearchGrounding: import("ai").Tool<z.ZodObject<{
         query: z.ZodString;
         maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;