@juspay/neurolink 7.48.1 → 7.50.0

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>>;

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.d.ts

@@ -236,4 +236,13 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns Array of prompt chunks
      */
     static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
+    /**
+     * Create telemetry configuration for Vercel AI SDK experimental_telemetry
+     * This enables automatic OpenTelemetry tracing when telemetry is enabled
+     */
+    protected getStreamTelemetryConfig(options: StreamOptions | TextGenerationOptions, operationType?: "stream" | "generate"): {
+        isEnabled: boolean;
+        functionId?: string;
+        metadata?: Record<string, string | number | boolean>;
+    } | undefined;
 }

package/dist/lib/core/baseProvider.js

@@ -6,6 +6,8 @@ import { DEFAULT_MAX_STEPS, STEP_LIMITS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { nanoid } from "nanoid";
+import { createAnalytics } from "./analytics.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray, buildMultimodalMessagesArray, } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
@@ -98,6 +100,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 +114,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 +233,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 +248,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 +267,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) => {
@@ -297,6 +306,7 @@ export class BaseProvider {
             toolChoice: shouldUseTools ? "auto" : "none",
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            experimental_telemetry: this.getStreamTelemetryConfig(options, "generate"),
             onStepFinish: ({ toolCalls, toolResults }) => {
                 logger.info("Tool execution completed", { toolResults, toolCalls });
                 // Handle tool execution storage
@@ -1276,9 +1286,8 @@ export class BaseProvider {
      */
     async createStreamAnalytics(result, startTime, options) {
         try {
-            const { createAnalytics } = await import("./analytics.js");
             const analytics = createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: `${this.providerName}-stream-${Date.now()}`,
+                requestId: `${this.providerName}-stream-${nanoid()}`,
                 streamingMode: true,
                 ...options.context,
             });
@@ -1511,7 +1520,7 @@ export class BaseProvider {
         }
         const sessionId = options.context?.sessionId ||
             options.sessionId ||
-            `session-${Date.now()}`;
+            `session-${nanoid()}`;
         const userId = options.context?.userId ||
             options.userId;
         try {
@@ -1558,4 +1567,35 @@ export class BaseProvider {
         }
         return chunks;
     }
+    /**
+     * Create telemetry configuration for Vercel AI SDK experimental_telemetry
+     * This enables automatic OpenTelemetry tracing when telemetry is enabled
+     */
+    getStreamTelemetryConfig(options, operationType = "stream") {
+        // Check if telemetry is enabled via NeuroLink observability config
+        if (!this.neurolink?.isTelemetryEnabled()) {
+            return undefined;
+        }
+        const functionId = `${this.providerName}-${operationType}-${nanoid()}`;
+        const metadata = {
+            provider: this.providerName,
+            model: this.modelName,
+            toolsEnabled: !options.disableTools,
+            neurolink: true,
+        };
+        // Add sessionId if available
+        if ("sessionId" in options && options.sessionId) {
+            const sessionId = options.sessionId;
+            if (typeof sessionId === "string" ||
+                typeof sessionId === "number" ||
+                typeof sessionId === "boolean") {
+                metadata.sessionId = sessionId;
+            }
+        }
+        return {
+            isEnabled: true,
+            functionId,
+            metadata,
+        };
+    }
 }

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/index.d.ts

@@ -21,6 +21,9 @@ import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
+export type { ObservabilityConfig, LangfuseConfig, OpenTelemetryConfig, } from "./types/observability.js";
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus } from "./services/server/ai/observability/instrumentation.js";
+export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, };
 export type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./types/middlewareTypes.js";
 export { MiddlewareFactory } from "./middleware/factory.js";
 export declare const VERSION = "1.0.0";
@@ -82,10 +85,13 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
 export { initializeMCPEcosystem, listMCPs, executeMCP, getMCPStats, mcpLogger, } from "./mcp/index.js";
 export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, LogLevel, } from "./mcp/index.js";
 export declare function initializeTelemetry(): Promise<boolean>;
-export declare function getTelemetryStatus(): {
+export declare function getTelemetryStatus(): Promise<{
     enabled: boolean;
     initialized: boolean;
-};
+    endpoint?: string;
+    service?: string;
+    version?: string;
+}>;
 export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, EvaluationData, } from "./types/index.js";
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function

package/dist/lib/index.js

@@ -19,6 +19,9 @@ export { dynamicModelProvider } from "./core/dynamicModels.js";
 // Main NeuroLink wrapper class and diagnostic types
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, } from "./services/server/ai/observability/instrumentation.js";
+import { initializeTelemetry as init, getTelemetryStatus as getStatus, } from "./telemetry/index.js";
+export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, };
 export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
@@ -96,20 +99,18 @@ initializeMCPEcosystem, listMCPs, executeMCP, getMCPStats, mcpLogger, } from "./
 // Real-time Services (Phase 1) - Basic SSE functionality only
 // export { createEnhancedChatService } from './chat/index.js';
 // export type * from './services/types.js';
-// Optional Telemetry (Phase 2) - Conditional export based on feature flag
+// Optional Telemetry (Phase 2) - Telemetry service initialization
 export async function initializeTelemetry() {
-    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
-        const { initializeTelemetry: init } = await import("./telemetry/index.js");
+    try {
         const result = await init();
-        return !!result; // Convert TelemetryService to boolean
+        return !!result;
     }
-    return Promise.resolve(false);
-}
-export function getTelemetryStatus() {
-    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
-        return { enabled: true, initialized: false };
+    catch {
+        return false;
     }
-    return { enabled: false, initialized: false };
+}
+export async function getTelemetryStatus() {
+    return getStatus();
 }
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function