@juspay/neurolink 7.48.1 → 7.49.0

package/dist/lib/agent/directTools.js

@@ -8,6 +8,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { logger } from "../utils/logger.js";
 import { VertexAI } from "@google-cloud/vertexai";
+import { CSVProcessor } from "../utils/csvProcessor.js";
 // Runtime Google Search tool creation - bypasses TypeScript strict typing
 function createGoogleSearchTools() {
     const searchTool = {};
@@ -336,6 +337,271 @@ export const directAgentTools = {
             }
         },
     }),
+    analyzeCSV: tool({
+        description: "Analyze CSV file for accurate counting, aggregation, and statistical analysis. Use this for precise data operations like counting rows by column, calculating sums/averages, finding min/max values, etc. The tool reads the file directly - do NOT pass CSV content.",
+        parameters: z.object({
+            filePath: z
+                .string()
+                .refine((inputPath) => {
+                const resolvedPath = path.resolve(inputPath);
+                const normalizedPath = resolvedPath
+                    .toLowerCase()
+                    .replace(/\\/g, "/");
+                const sensitivePatterns = [
+                    "/etc/",
+                    "/sys/",
+                    "/proc/",
+                    "/dev/",
+                    "/root/",
+                    "/.ssh/",
+                    "/private/etc/",
+                    "/private/var/",
+                    "c:/windows/",
+                    "c:/program files/",
+                    "c:/programdata/",
+                ];
+                return !sensitivePatterns.some((pattern) => normalizedPath.startsWith(pattern));
+            }, {
+                message: "Invalid file path: access to system directories is not allowed",
+            })
+                .describe("Path to the CSV file to analyze (e.g., 'test/data.csv' or '/absolute/path/file.csv')"),
+            operation: z
+                .enum([
+                "count_by_column",
+                "sum_by_column",
+                "average_by_column",
+                "min_max_by_column",
+                "describe",
+            ])
+                .describe("Type of analysis to perform"),
+            column: z
+                .string()
+                .optional()
+                .describe("Column name for the operation (required for most operations)"),
+            maxRows: z
+                .number()
+                .optional()
+                .describe("Maximum rows to process (default: 1000)"),
+        }),
+        execute: async ({ filePath, operation, column, maxRows = 1000 }) => {
+            const startTime = Date.now();
+            logger.info(`[analyzeCSV] 🚀 START: file=${filePath}, operation=${operation}, column=${column}, maxRows=${maxRows}`);
+            try {
+                // Resolve file path
+                logger.debug(`[analyzeCSV] Resolving file: ${filePath}`);
+                const path = await import("path");
+                // Resolve path (support both relative and absolute)
+                const resolvedPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.resolve(process.cwd(), filePath);
+                logger.debug(`[analyzeCSV] Resolved path: ${resolvedPath}`);
+                // Parse CSV using streaming from disk (memory efficient)
+                logger.info(`[analyzeCSV] Starting CSV parsing (max ${maxRows} rows)...`);
+                const rows = (await CSVProcessor.parseCSVFile(resolvedPath, maxRows));
+                logger.info(`[analyzeCSV] ✅ CSV parsing complete: ${rows.length} rows`);
+                if (rows.length === 0) {
+                    logger.warn(`[analyzeCSV] No data rows found`);
+                    return {
+                        success: false,
+                        error: "No data rows found in CSV",
+                    };
+                }
+                // Log column names
+                const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+                logger.info(`[analyzeCSV] Found ${rows.length} rows with columns:`, columnNames);
+                logger.info(`[analyzeCSV] Executing operation: ${operation}`);
+                let result;
+                switch (operation) {
+                    case "count_by_column": {
+                        logger.info(`[analyzeCSV] count_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for count_by_column operation",
+                            };
+                        }
+                        // Count occurrences of each value in the column
+                        const counts = {};
+                        logger.debug(`[analyzeCSV] Counting rows...`);
+                        for (const row of rows) {
+                            const value = row[column];
+                            if (value !== undefined) {
+                                counts[value] = (counts[value] || 0) + 1;
+                            }
+                        }
+                        logger.debug(`[analyzeCSV] Found ${Object.keys(counts).length} unique values`);
+                        // Sort by count descending
+                        logger.debug(`[analyzeCSV] Sorting results...`);
+                        result = Object.fromEntries(Object.entries(counts).sort(([, a], [, b]) => b - a));
+                        logger.info(`[analyzeCSV] ✅ count_by_column complete. Result:`, result);
+                        break;
+                    }
+                    case "sum_by_column": {
+                        logger.info(`[analyzeCSV] sum_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for sum_by_column operation",
+                            };
+                        }
+                        // Sum numeric values from the target column itself for each group
+                        const groups = {};
+                        logger.debug(`[analyzeCSV] Grouping and summing ${rows.length} rows...`);
+                        let processedRows = 0;
+                        let totalNumericValuesFound = 0;
+                        for (const row of rows) {
+                            const key = row[column];
+                            if (!key) {
+                                continue;
+                            }
+                            // Parse numeric value from the target column
+                            const value = row[column];
+                            if (value === undefined || value === null || value === "") {
+                                continue;
+                            }
+                            const num = parseFloat(value);
+                            if (isNaN(num)) {
+                                continue;
+                            }
+                            if (!groups[key]) {
+                                groups[key] = 0;
+                            }
+                            groups[key] += num;
+                            totalNumericValuesFound++;
+                            processedRows++;
+                            if (processedRows % 10 === 0) {
+                                logger.debug(`[analyzeCSV] Processed ${processedRows}/${rows.length} rows`);
+                            }
+                        }
+                        // Fail fast if no numeric data found in the requested column
+                        if (totalNumericValuesFound === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for sum_by_column operation`,
+                            };
+                        }
+                        logger.debug(`[analyzeCSV] Calculated sums for ${Object.keys(groups).length} groups (${totalNumericValuesFound} numeric values)`);
+                        result = groups;
+                        logger.info(`[analyzeCSV] ✅ sum_by_column complete`);
+                        break;
+                    }
+                    case "average_by_column": {
+                        logger.info(`[analyzeCSV] average_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for average_by_column operation",
+                            };
+                        }
+                        // Average numeric values from the target column itself for each group
+                        const groups = {};
+                        logger.debug(`[analyzeCSV] Grouping and averaging ${rows.length} rows...`);
+                        let processedRows = 0;
+                        let totalNumericValuesFound = 0;
+                        for (const row of rows) {
+                            const key = row[column];
+                            if (!key) {
+                                continue;
+                            }
+                            // Parse numeric value from the target column
+                            const value = row[column];
+                            if (value === undefined || value === null || value === "") {
+                                continue;
+                            }
+                            const num = parseFloat(value);
+                            if (isNaN(num)) {
+                                continue;
+                            }
+                            if (!groups[key]) {
+                                groups[key] = { sum: 0, count: 0 };
+                            }
+                            groups[key].sum += num;
+                            groups[key].count++;
+                            totalNumericValuesFound++;
+                            processedRows++;
+                            if (processedRows % 10 === 0) {
+                                logger.debug(`[analyzeCSV] Processed ${processedRows}/${rows.length} rows`);
+                            }
+                        }
+                        // Fail fast if no numeric data found in the requested column
+                        if (totalNumericValuesFound === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for average_by_column operation`,
+                            };
+                        }
+                        logger.debug(`[analyzeCSV] Calculated averages for ${Object.keys(groups).length} groups (${totalNumericValuesFound} numeric values)`);
+                        result = Object.fromEntries(Object.entries(groups).map(([k, v]) => [
+                            k,
+                            v.count > 0 ? v.sum / v.count : 0,
+                        ]));
+                        logger.info(`[analyzeCSV] ✅ average_by_column complete`);
+                        break;
+                    }
+                    case "min_max_by_column": {
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for min_max_by_column operation",
+                            };
+                        }
+                        const values = rows
+                            .map((row) => row[column])
+                            .filter((v) => v !== undefined && v !== "");
+                        const numericValues = values
+                            .map((v) => parseFloat(v))
+                            .filter((n) => !isNaN(n));
+                        if (numericValues.length === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for min_max_by_column operation`,
+                            };
+                        }
+                        result = {
+                            min: Math.min(...numericValues),
+                            max: Math.max(...numericValues),
+                            numericCount: numericValues.length,
+                            totalCount: values.length,
+                        };
+                        break;
+                    }
+                    case "describe": {
+                        const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+                        result = {
+                            total_rows: rows.length,
+                            columns: columnNames,
+                            column_count: columnNames.length,
+                        };
+                        break;
+                    }
+                    default:
+                        return {
+                            success: false,
+                            error: `Unknown operation: ${operation}`,
+                        };
+                }
+                const duration = Date.now() - startTime;
+                logger.info(`[analyzeCSV] 🏁 COMPLETE: ${operation} took ${duration}ms`);
+                const response = {
+                    success: true,
+                    operation,
+                    column,
+                    result: JSON.stringify(result, null, 2),
+                    rowCount: rows.length,
+                };
+                logger.debug(`[analyzeCSV] 📤 RETURNING TO LLM:`, JSON.stringify(response, null, 2));
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    operation,
+                    column,
+                };
+            }
+        },
+    }),
     websearchGrounding: tool({
         description: "Search the web for current information using Google Search grounding. Returns raw search data for AI processing.",
         parameters: z.object({

package/dist/lib/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/lib/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/lib/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/mcp/factory.d.ts

@@ -3,162 +3,7 @@
  * Factory-First Architecture: MCP servers create tools for internal orchestration
  * Compatible with MCP patterns for seamless integration
  */
-import type { ExecutionContext } from "./contracts/mcpContract.js";
-/**
- * MCP Server Categories for organization and discovery
- */
-export type MCPServerCategory = "aiProviders" | "frameworks" | "development" | "business" | "content" | "data" | "integrations" | "automation" | "analysis" | "custom";
-/**
- * Tool execution context - Rich context passed to every tool execution
- * Following standard patterns for rich tool context
- * Extends ExecutionContext for compatibility
- */
-export interface NeuroLinkExecutionContext extends ExecutionContext {
-    aiProvider?: string;
-    modelId?: string;
-    temperature?: number;
-    maxTokens?: number;
-    appId?: string;
-    clientId?: string;
-    clientVersion?: string;
-    organizationId?: string;
-    projectId?: string;
-    environment?: string;
-    environmentType?: "development" | "staging" | "production";
-    platform?: string;
-    device?: string;
-    browser?: string;
-    userAgent?: string;
-    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
-    toolChain?: string[];
-    parentToolId?: string;
-    locale?: string;
-    timezone?: string;
-    ipAddress?: string;
-    requestId?: string;
-    timestamp?: number;
-    permissions?: string[];
-    features?: string[];
-    enableDemoMode?: boolean;
-    securityLevel?: "public" | "private" | "organization";
-    metadata?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-/**
- * Tool execution result - Standardized result format
- */
-export interface ToolResult {
-    success: boolean;
-    data?: unknown;
-    error?: string | Error;
-    usage?: {
-        tokens?: number;
-        cost?: number;
-        provider?: string;
-        model?: string;
-        executionTime?: number;
-    };
-    metadata?: {
-        toolName?: string;
-        serverId?: string;
-        serverTitle?: string;
-        sessionId?: string;
-        timestamp?: number;
-        executionTime?: number;
-        executionId?: string;
-        [key: string]: unknown;
-    };
-}
-/**
- * MCP Tool Interface - Standalone definition to avoid confusion with ToolDefinition execute signature
- */
-/**
- * NeuroLink MCP Tool Interface - Standardized tool definition for MCP integration
- *
- * This interface defines the contract for all tools in the NeuroLink ecosystem,
- * ensuring consistent execution patterns and metadata handling across different
- * MCP servers and tool implementations.
- *
- * Key features:
- * - Promise-based execution with ToolResult return type
- * - Rich context support for session management and permissions
- * - Optional schema validation for input/output
- * - Comprehensive metadata support for tool discovery
- *
- * @example
- * ```typescript
- * const calculatorTool: NeuroLinkMCPTool = {
- *   name: "calculator",
- *   description: "Performs basic arithmetic operations",
- *   category: "math",
- *   inputSchema: z.object({ a: z.number(), b: z.number(), op: z.string() }),
- *   async execute(params, context) {
- *     const { a, b, op } = params as { a: number; b: number; op: string };
- *     const result = op === "add" ? a + b : a - b;
- *     return { success: true, data: result };
- *   }
- * };
- * ```
- */
-export interface NeuroLinkMCPTool {
-    /** Unique tool identifier for MCP registration and execution */
-    name: string;
-    /** Human-readable description of tool functionality */
-    description: string;
-    /** Optional category for tool organization and discovery */
-    category?: string;
-    /** Optional input schema for parameter validation (Zod or JSON Schema) */
-    inputSchema?: unknown;
-    /** Optional output schema for result validation */
-    outputSchema?: unknown;
-    /** Implementation status flag for development tracking */
-    isImplemented?: boolean;
-    /** Required permissions for tool execution in secured environments */
-    permissions?: string[];
-    /** Tool version for compatibility and update management */
-    version?: string;
-    /** Additional metadata for tool information and capabilities */
-    metadata?: Record<string, unknown>;
-    /**
-     * Tool execution function with standardized signature
-     *
-     * @param params - Input parameters for the tool (validated against inputSchema if provided)
-     * @param context - Execution context with session, user, and environment information
-     * @returns Promise resolving to ToolResult with success status, data, and metadata
-     * @throws ValidationError if parameters fail validation
-     */
-    execute: (params: unknown, context: NeuroLinkExecutionContext) => Promise<ToolResult>;
-}
-/**
- * MCP Server Interface - Standard compatible
- */
-export interface NeuroLinkMCPServer {
-    id: string;
-    title: string;
-    description?: string;
-    version?: string;
-    category?: MCPServerCategory;
-    visibility?: "public" | "private" | "organization";
-    tools: Record<string, NeuroLinkMCPTool>;
-    registerTool(tool: NeuroLinkMCPTool): NeuroLinkMCPServer;
-    metadata?: Record<string, unknown>;
-    dependencies?: string[];
-    capabilities?: string[];
-}
-/**
- * MCP Server Configuration for creation
- */
-export interface MCPServerConfig {
-    id: string;
-    title: string;
-    description?: string;
-    version?: string;
-    category?: MCPServerCategory;
-    visibility?: "public" | "private" | "organization";
-    metadata?: Record<string, unknown>;
-    dependencies?: string[];
-    capabilities?: string[];
-}
+import type { MCPServerDomainCategory, NeuroLinkMCPTool, NeuroLinkMCPServer, MCPServerConfig } from "../types/mcpTypes.js";
 /**
  * Create MCP Server Factory Function
  *
@@ -200,7 +45,7 @@ export declare function getServerInfo(server: NeuroLinkMCPServer): {
     id: string;
     title: string;
     description?: string;
-    category?: MCPServerCategory;
+    category?: MCPServerDomainCategory;
     toolCount: number;
     capabilities: string[];
 };

package/dist/lib/mcp/flexibleToolValidator.d.ts

@@ -9,11 +9,7 @@
  * - No context-specific validation or arbitrary pattern restrictions
  * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
  */
-export interface FlexibleValidationResult {
-    isValid: boolean;
-    error?: string;
-    warnings?: string[];
-}
+import type { FlexibleValidationResult } from "../types/mcpTypes.js";
 export declare class FlexibleToolValidator {
     private static readonly MAX_TOOL_NAME_LENGTH;
     private static readonly MIN_TOOL_NAME_LENGTH;

package/dist/lib/mcp/index.d.ts

@@ -3,10 +3,11 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, } from "./contracts/mcpContract.js";
+export type { McpMetadata, DiscoveredMcp } from "../types/mcpTypes.js";
+export type { ExecutionContext, ToolInfo, ToolExecutionResult, } from "../types/tools.js";
 export { mcpLogger } from "../utils/logger.js";
 export type { LogLevel } from "../utils/logger.js";
-import type { McpMetadata } from "./contracts/mcpContract.js";
+import type { McpMetadata } from "../types/mcpTypes.js";
 /**
  * Initialize the MCP ecosystem - simplified
  */

package/dist/lib/mcp/mcpCircuitBreaker.d.ts

@@ -4,81 +4,7 @@
  * Provides fault tolerance and prevents cascading failures
  */
 import { EventEmitter } from "events";
-/**
- * Circuit breaker states
- */
-export type CircuitBreakerState = "closed" | "open" | "half-open";
-/**
- * Circuit breaker configuration
- */
-export interface CircuitBreakerConfig {
-    /** Number of failures before opening the circuit */
-    failureThreshold: number;
-    /** Time to wait before attempting reset (milliseconds) */
-    resetTimeout: number;
-    /** Maximum calls allowed in half-open state */
-    halfOpenMaxCalls: number;
-    /** Timeout for individual operations (milliseconds) */
-    operationTimeout: number;
-    /** Minimum number of calls before calculating failure rate */
-    minimumCallsBeforeCalculation: number;
-    /** Window size for calculating failure rate (milliseconds) */
-    statisticsWindowSize: number;
-}
-/**
- * Circuit breaker statistics
- */
-export interface CircuitBreakerStats {
-    /** Current state */
-    state: CircuitBreakerState;
-    /** Total number of calls */
-    totalCalls: number;
-    /** Number of successful calls */
-    successfulCalls: number;
-    /** Number of failed calls */
-    failedCalls: number;
-    /** Current failure rate (0-1) */
-    failureRate: number;
-    /** Calls in current time window */
-    windowCalls: number;
-    /** Last state change timestamp */
-    lastStateChange: Date;
-    /** Next retry time (for open state) */
-    nextRetryTime?: Date;
-    /** Half-open call count */
-    halfOpenCalls: number;
-}
-/**
- * Circuit breaker events
- */
-export interface CircuitBreakerEvents {
-    stateChange: {
-        oldState: CircuitBreakerState;
-        newState: CircuitBreakerState;
-        reason: string;
-        timestamp: Date;
-    };
-    callSuccess: {
-        duration: number;
-        timestamp: Date;
-    };
-    callFailure: {
-        error: string;
-        duration: number;
-        timestamp: Date;
-    };
-    circuitOpen: {
-        failureRate: number;
-        totalCalls: number;
-        timestamp: Date;
-    };
-    circuitHalfOpen: {
-        timestamp: Date;
-    };
-    circuitClosed: {
-        timestamp: Date;
-    };
-}
+import type { CircuitBreakerConfig, CircuitBreakerStats } from "../types/mcpTypes.js";
 /**
  * MCPCircuitBreaker
  * Implements circuit breaker pattern for fault tolerance

package/dist/lib/mcp/mcpClientFactory.d.ts

@@ -8,26 +8,7 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
 import { ChildProcess } from "child_process";
 import type { MCPTransportType } from "../types/externalMcp.js";
-import type { MCPServerInfo } from "../types/mcpTypes.js";
-/**
- * MCP client creation result
- */
-export interface MCPClientResult {
-    /** Whether client creation was successful */
-    success: boolean;
-    /** Created client instance */
-    client?: Client;
-    /** Created transport instance */
-    transport?: Transport;
-    /** Created process (for stdio transport) */
-    process?: ChildProcess;
-    /** Error message if failed */
-    error?: string;
-    /** Creation duration in milliseconds */
-    duration: number;
-    /** Server capabilities reported during handshake */
-    capabilities?: ClientCapabilities;
-}
+import type { MCPServerInfo, MCPClientResult } from "../types/mcpTypes.js";
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports

package/dist/lib/mcp/mcpClientFactory.js

@@ -205,6 +205,7 @@ export class MCPClientFactory {
                 .filter(([, value]) => value !== undefined)
                 .map(([key, value]) => [key, String(value)])),
             cwd: config.cwd,
+            stderr: "ignore", // Suppress MCP server startup messages
         });
         return { transport, process: childProcess };
     }