@juspay/neurolink 5.2.0 → 5.3.0

package/dist/providers/function-calling-provider.js

@@ -7,7 +7,7 @@ import { streamText as aiStreamText, generateText as aiGenerate, Output, } from
 import { getAvailableFunctionTools, executeFunctionCall, isFunctionCallingAvailable, } from "../mcp/function-calling.js";
 import { createExecutionContext } from "../mcp/context-manager.js";
 import { mcpLogger } from "../mcp/logging.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 /**
  * Enhanced provider that enables real function calling with MCP tools
  */
@@ -16,11 +16,22 @@ export class FunctionCallingProvider {
     enableFunctionCalling;
     sessionId;
     userId;
+    cachedToolsObject = null;
+    cachedToolMap = null;
+    cacheTimestamp = null;
+    cacheExpiryMs;
     constructor(baseProvider, options = {}) {
         this.baseProvider = baseProvider;
         this.enableFunctionCalling = options.enableFunctionCalling ?? true;
         this.sessionId = options.sessionId || `function-calling-${Date.now()}`;
         this.userId = options.userId || "function-calling-user";
+        // Configurable cache expiry: default 5 minutes, with environment override, then constructor option
+        const defaultExpiryMs = 5 * 60 * 1000; // 5 minutes
+        const envExpiryMs = process.env.NEUROLINK_CACHE_EXPIRY_MS
+            ? parseInt(process.env.NEUROLINK_CACHE_EXPIRY_MS, 10)
+            : undefined;
+        this.cacheExpiryMs =
+            options.cacheExpiryMs ?? envExpiryMs ?? defaultExpiryMs;
     }
     /**
      * PRIMARY METHOD: Stream content using AI (recommended for new code)
@@ -91,8 +102,30 @@ export class FunctionCallingProvider {
                 }
                 return result;
             }
-            // Get available function tools
-            const { tools, toolMap } = await getAvailableFunctionTools();
+            // Get available function tools (with automatic cache invalidation)
+            let toolsObject, toolMap;
+            const now = Date.now();
+            const isCacheExpired = this.cacheTimestamp === null ||
+                now - this.cacheTimestamp > this.cacheExpiryMs;
+            if (this.cachedToolsObject && this.cachedToolMap && !isCacheExpired) {
+                toolsObject = this.cachedToolsObject;
+                toolMap = this.cachedToolMap;
+                mcpLogger.debug(`[${functionTag}] Using cached tools (${Math.round((now - this.cacheTimestamp) / 1000)}s old)`);
+            }
+            else {
+                if (isCacheExpired && this.cachedToolsObject) {
+                    mcpLogger.debug(`[${functionTag}] Cache expired, refreshing tools`);
+                }
+                const result = await getAvailableFunctionTools();
+                toolsObject = result.toolsObject;
+                toolMap = result.toolMap;
+                // Cache the results for future use with timestamp
+                this.cachedToolsObject = toolsObject;
+                this.cachedToolMap = toolMap;
+                this.cacheTimestamp = now;
+                mcpLogger.debug(`[${functionTag}] Cached ${Object.keys(toolsObject).length} tools with expiry in ${this.cacheExpiryMs / 1000}s`);
+            }
+            const tools = Object.values(toolsObject);
             if (tools.length === 0) {
                 mcpLogger.debug(`[${functionTag}] No tools available, using base provider`);
                 const result = await this.baseProvider.generate(options, analysisSchema);
@@ -113,8 +146,8 @@ export class FunctionCallingProvider {
                 aiProvider: this.baseProvider.constructor.name,
             });
             // Use the AI SDK's native function calling by calling generate directly
-            // We need to get the underlying model from the base provider
-            const result = await this.generateWithTools(options, tools, toolMap, context, analysisSchema);
+            // We can now use the toolsObject directly instead of converting from array
+            const result = await this.generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema);
             if (!result) {
                 return {
                     content: "No response generated",
@@ -150,14 +183,83 @@ export class FunctionCallingProvider {
         }
     }
     /**
-     * Generate text using AI SDK's native function calling
+     * Generate text with tools using the AI SDK's generate function (with tools object)
+     */
+    async generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema) {
+        const functionTag = "FunctionCallingProvider.generateWithToolsObject";
+        try {
+            // Use the toolsObject directly with proper execution wrapped
+            const toolsWithExecution = this.wrapToolsWithExecution(toolsObject, toolMap, context);
+            mcpLogger.debug(`[${functionTag}] Using tools object with ${Object.keys(toolsWithExecution).length} tools`);
+            // Get the model from base provider
+            const modelInfo = await this.getModelFromProvider();
+            if (!modelInfo) {
+                mcpLogger.warn(`[${functionTag}] Could not get model from provider, falling back to base provider`);
+                const result = await this.baseProvider.generate(options, analysisSchema);
+                if (!result) {
+                    return {
+                        content: "No response generated",
+                        provider: "function-calling",
+                        model: "unknown",
+                    };
+                }
+                return result;
+            }
+            // Use AI SDK's generate directly with tools
+            const generateOptions = {
+                model: modelInfo.model,
+                prompt: options.prompt,
+                system: options.systemPrompt || "You are a helpful AI assistant.",
+                temperature: options.temperature || 0.7,
+                maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+                tools: toolsWithExecution,
+                toolChoice: "auto", // Let the AI decide when to use tools
+                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
+            };
+            // Add experimental_output if schema is provided
+            if (analysisSchema) {
+                generateOptions.experimental_output = Output.object({
+                    schema: analysisSchema,
+                });
+            }
+            const result = await aiGenerate(generateOptions);
+            mcpLogger.debug(`[${functionTag}] AI SDK generate completed`, {
+                toolCalls: result.toolCalls?.length || 0,
+                finishReason: result.finishReason,
+                usage: result.usage,
+            });
+            return {
+                content: result.text,
+                provider: "function-calling",
+                model: "unknown",
+                usage: result.usage
+                    ? {
+                        inputTokens: result.usage.promptTokens,
+                        outputTokens: result.usage.completionTokens,
+                        totalTokens: result.usage.totalTokens,
+                    }
+                    : undefined,
+                responseTime: 0,
+                toolsUsed: result.toolCalls?.map((tc) => tc.toolName) || [],
+                toolExecutions: [],
+                enhancedWithTools: (result.toolCalls?.length || 0) > 0,
+                availableTools: [],
+            };
+        }
+        catch (error) {
+            mcpLogger.error(`[${functionTag}] Failed to generate text with tools:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Generate text using AI SDK's native function calling (legacy array-based)
      */
     async generateWithTools(options, tools, toolMap, context, analysisSchema) {
         const functionTag = "FunctionCallingProvider.generateWithTools";
         try {
             // Convert our tools to AI SDK format with proper execution
             const toolsWithExecution = this.convertToAISDKTools(tools, toolMap, context);
-            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: 5`);
+            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: ${options.maxSteps ?? DEFAULT_MAX_STEPS}`);
             mcpLogger.debug(`[${functionTag}] Sanitized tool names:`, Object.keys(toolsWithExecution));
             // Log the first few tools to debug the issue
             const toolNames = Object.keys(toolsWithExecution);
@@ -187,7 +289,7 @@ export class FunctionCallingProvider {
                 maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
                 tools: toolsWithExecution,
                 toolChoice: "auto", // Let the AI decide when to use tools
-                maxSteps: 5, // CRITICAL: Enable multi-turn tool execution
+                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
             };
             // Add experimental_output if schema is provided
             if (analysisSchema) {
@@ -270,7 +372,52 @@ export class FunctionCallingProvider {
         return sanitized;
     }
     /**
-     * Convert our tools to AI SDK format with proper execution
+     * Wrap tools with proper execution context (for object-based tools)
+     */
+    wrapToolsWithExecution(toolsObject, toolMap, context) {
+        const functionTag = "FunctionCallingProvider.wrapToolsWithExecution";
+        const wrappedTools = {};
+        for (const [toolName, tool] of Object.entries(toolsObject)) {
+            const toolInfo = toolMap.get(toolName);
+            const originalToolName = toolInfo ? toolInfo.toolName : toolName;
+            // Create a version with actual MCP execution
+            wrappedTools[toolName] = {
+                description: tool.description,
+                parameters: tool.parameters,
+                execute: async (args) => {
+                    // Debug logging only in debug mode
+                    if (process.env.NEUROLINK_DEBUG === "true") {
+                        const providerName = this.baseProvider.constructor.name;
+                        mcpLogger.debug(`Tool execution - Provider: ${providerName}`);
+                        mcpLogger.debug(`Tool: ${toolName} (original: ${originalToolName})`);
+                        mcpLogger.debug(`Args:`, args);
+                    }
+                    try {
+                        // Execute the actual MCP tool
+                        const result = await executeFunctionCall(toolName, args);
+                        if (process.env.NEUROLINK_DEBUG === "true") {
+                            mcpLogger.debug(`Tool result:`, result);
+                        }
+                        if (result.success) {
+                            return result.data || { success: true };
+                        }
+                        else {
+                            return { error: result.error || "Tool execution failed" };
+                        }
+                    }
+                    catch (error) {
+                        mcpLogger.error(`[${functionTag}] Tool execution error: ${toolName}`, error);
+                        return {
+                            error: error instanceof Error ? error.message : String(error),
+                        };
+                    }
+                },
+            };
+        }
+        return wrappedTools;
+    }
+    /**
+     * Convert our tools to AI SDK format with proper execution (legacy array-based)
      */
     convertToAISDKTools(tools, toolMap, context) {
         const functionTag = "FunctionCallingProvider.convertToAISDKTools";
@@ -394,6 +541,57 @@ These functions provide accurate, real-time data. Use them actively to enhance y
     /**
      * Alias for generate() - CLI-SDK consistency
      */
+    /**
+     * Clear cached tools - Cache Invalidation Strategy
+     *
+     * WHEN TO CALL clearToolsCache():
+     *
+     * 1. **MCP Server Changes**: When MCP servers are added, removed, or restarted
+     *    - After calling unifiedRegistry.addServer() or removeServer()
+     *    - When MCP server configurations change
+     *    - After MCP server restart or reconnection
+     *
+     * 2. **Tool Registration Changes**: When custom tools are modified
+     *    - After registering new SDK tools via registerTool()
+     *    - When tool implementations change
+     *    - After unregistering tools
+     *
+     * 3. **Provider Reinitialization**: When the provider context changes
+     *    - Before switching between different AI providers
+     *    - When session context changes significantly
+     *    - After provider authentication refresh
+     *
+     * 4. **Error Recovery**: When tool execution encounters systematic failures
+     *    - After MCP connection errors are resolved
+     *    - When tool discovery needs to be re-run
+     *    - During error recovery workflows
+     *
+     * 5. **Development/Testing**: During development and testing cycles
+     *    - Between test cases that modify tool availability
+     *    - When testing different tool configurations
+     *    - During hot reloading scenarios
+     *
+     * CACHE LIFECYCLE:
+     * - Cache is populated on first generate() call via getAvailableFunctionTools()
+     * - Cache persists across multiple generate() calls for performance
+     * - Cache is invalidated by calling this method
+     * - Next generate() call will rebuild cache from current tool state
+     *
+     * PERFORMANCE IMPACT:
+     * - Clearing cache forces tool discovery on next usage (~100-500ms overhead)
+     * - Recommended to clear cache proactively rather than reactively
+     * - Consider batching tool changes before clearing cache
+     *
+     * THREAD SAFETY:
+     * - This method is not thread-safe
+     * - Avoid calling during active generate() operations
+     * - Safe to call between separate AI generation requests
+     */
+    clearToolsCache() {
+        this.cachedToolsObject = null;
+        this.cachedToolMap = null;
+        this.cacheTimestamp = null;
+    }
     /**
      * Short alias for generate() - CLI-SDK consistency
      */
@@ -422,6 +620,7 @@ export function createMCPAwareProviderV3(baseProvider, options = {}) {
         enableFunctionCalling: options.enableFunctionCalling,
         sessionId: options.sessionId,
         userId: options.userId,
+        cacheExpiryMs: options.cacheExpiryMs,
     });
     mcpLogger.debug(`[${functionTag}] Created MCP-aware provider with function calling`, {
         providerName: options.providerName,

package/dist/providers/mcp-provider.js

@@ -62,11 +62,26 @@ export class MCPAwareProvider {
                     exists: async () => false,
                 },
                 path: {
-                    join: (...paths) => require("path").join(...paths),
-                    resolve: (...paths) => require("path").resolve(...paths),
-                    relative: (from, to) => require("path").relative(from, to),
-                    dirname: (path) => require("path").dirname(path),
-                    basename: (path, ext) => require("path").basename(path, ext),
+                    join: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.join(...paths);
+                    },
+                    resolve: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.resolve(...paths);
+                    },
+                    relative: (from, to) => {
+                        const pathModule = require("path");
+                        return pathModule.relative(from, to);
+                    },
+                    dirname: (pathArg) => {
+                        const pathModule = require("path");
+                        return pathModule.dirname(pathArg);
+                    },
+                    basename: (pathArg, ext) => {
+                        const pathModule = require("path");
+                        return pathModule.basename(pathArg, ext);
+                    },
                 },
                 grantedPermissions: [],
                 log: console.log,

package/dist/services/streaming/streaming-manager.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { logger } from "../../utils/logger.js";
 export class StreamingManager extends EventEmitter {
     activeSessions = new Map();
     streamingPools = new Map();
@@ -40,7 +41,7 @@ export class StreamingManager extends EventEmitter {
         };
         this.activeSessions.set(sessionId, session);
         this.updateGlobalMetrics();
-        console.log(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
+        logger.debug(`[Streaming Manager] Created session ${sessionId} for provider ${config.provider}`);
         this.emit("session-created", session);
         return session;
     }
@@ -52,7 +53,7 @@ export class StreamingManager extends EventEmitter {
         session.status = "terminated";
         this.activeSessions.delete(sessionId);
         this.updateGlobalMetrics();
-        console.log(`[Streaming Manager] Terminated session ${sessionId}`);
+        logger.debug(`[Streaming Manager] Terminated session ${sessionId}`);
         this.emit("session-terminated", session);
     }
     async pauseStreamingSession(sessionId) {
@@ -62,7 +63,7 @@ export class StreamingManager extends EventEmitter {
         }
         if (session.status === "active") {
             session.status = "paused";
-            console.log(`[Streaming Manager] Paused session ${sessionId}`);
+            logger.debug(`[Streaming Manager] Paused session ${sessionId}`);
             this.emit("session-paused", session);
         }
     }
@@ -74,7 +75,7 @@ export class StreamingManager extends EventEmitter {
         if (session.status === "paused") {
             session.status = "active";
             session.lastActivity = Date.now();
-            console.log(`[Streaming Manager] Resumed session ${sessionId}`);
+            logger.debug(`[Streaming Manager] Resumed session ${sessionId}`);
             this.emit("session-resumed", session);
         }
     }
@@ -97,7 +98,7 @@ export class StreamingManager extends EventEmitter {
             session.config.bufferSize = Math.max(session.config.bufferSize * 0.8, 1024);
             session.config.streamingMode = "real-time";
         }
-        console.log(`[Streaming Manager] Optimized session ${sessionId}: latency=${currentLatency}ms, mode=${session.config.streamingMode}`);
+        logger.debug(`[Streaming Manager] Optimized session ${sessionId}: latency=${currentLatency}ms, mode=${session.config.streamingMode}`);
     }
     async enableStreamingCompression(sessionId) {
         const session = this.activeSessions.get(sessionId);
@@ -105,7 +106,7 @@ export class StreamingManager extends EventEmitter {
             return;
         }
         session.config.compressionEnabled = true;
-        console.log(`[Streaming Manager] Enabled compression for session ${sessionId}`);
+        logger.debug(`[Streaming Manager] Enabled compression for session ${sessionId}`);
     }
     async configureStreamingBuffering(sessionId, bufferConfig) {
         const session = this.activeSessions.get(sessionId);
@@ -114,7 +115,7 @@ export class StreamingManager extends EventEmitter {
         }
         session.config.bufferSize = bufferConfig.maxSize;
         session.config.maxChunkSize = Math.min(session.config.maxChunkSize, bufferConfig.flushThreshold);
-        console.log(`[Streaming Manager] Updated buffer config for session ${sessionId}:`, bufferConfig);
+        logger.debug(`[Streaming Manager] Updated buffer config for session ${sessionId}:`, bufferConfig);
     }
     // Multi-Stream Coordination
     async createStreamingPool(poolId, config) {
@@ -126,7 +127,7 @@ export class StreamingManager extends EventEmitter {
             loadBalancer: config.loadBalancing,
         };
         this.streamingPools.set(poolId, pool);
-        console.log(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
+        logger.debug(`[Streaming Manager] Created pool ${poolId} with max ${config.maxConcurrentSessions} sessions`);
     }
     async balanceStreamingLoad(poolId) {
         const pool = this.streamingPools.get(poolId);
@@ -160,7 +161,7 @@ export class StreamingManager extends EventEmitter {
         const newMaxSessions = Math.max(1, Math.floor(pool.maxSessions * scale));
         pool.maxSessions = newMaxSessions;
         pool.config.maxConcurrentSessions = newMaxSessions;
-        console.log(`[Streaming Manager] Scaled pool ${poolId} to ${newMaxSessions} max sessions (${scale}x)`);
+        logger.debug(`[Streaming Manager] Scaled pool ${poolId} to ${newMaxSessions} max sessions (${scale}x)`);
     }
     // Performance Monitoring
     getStreamingMetrics(sessionId) {
@@ -217,7 +218,7 @@ export class StreamingManager extends EventEmitter {
         this.healthCheckInterval = setInterval(() => {
             const health = this.getStreamingHealthStatus();
             if (health.status !== "healthy") {
-                console.warn("[Streaming Manager] Health check:", health);
+                logger.debug("[Streaming Manager] Health check:", health);
                 this.emit("health-warning", health);
             }
         }, 30000); // Check every 30 seconds

package/dist/services/websocket/websocket-server.js

@@ -1,6 +1,7 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { logger } from "../../utils/logger.js";
 export class NeuroLinkWebSocketServer extends EventEmitter {
     wss;
     connections = new Map();
@@ -32,7 +33,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleConnection(ws, request);
         });
         this.wss.on("error", (error) => {
-            console.error("[WebSocket Server] Error:", error);
+            logger.error("[WebSocket Server] Error:", error);
             this.emit("error", error);
         });
     }
@@ -64,7 +65,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleDisconnection(connectionId);
         });
         ws.on("error", (error) => {
-            console.error(`[WebSocket] Connection ${connectionId} error:`, error);
+            logger.error(`[WebSocket] Connection ${connectionId} error:`, error);
             this.handleDisconnection(connectionId);
         });
         // Send connection confirmation
@@ -82,7 +83,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 },
             },
         });
-        console.log(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("connection", { connectionId, userAgent, ipAddress });
     }
     handleMessage(connectionId, data) {
@@ -101,7 +102,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
+            logger.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
             this.sendError(connectionId, "Invalid message format");
         }
     }
@@ -124,7 +125,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Clean up
         this.connections.delete(connectionId);
         this.connectionInfo.delete(connectionId);
-        console.log(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("disconnection", { connectionId });
     }
     // Room Management
@@ -150,7 +151,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: this.rooms.get(roomId).size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} joined room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} joined room ${roomId}`);
         return true;
     }
     leaveRoom(connectionId, roomId) {
@@ -179,7 +180,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: room.size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} left room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} left room ${roomId}`);
         return true;
     }
     broadcastToRoom(roomId, message) {
@@ -231,7 +232,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             return true;
         }
         catch (error) {
-            console.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
+            logger.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
             return false;
         }
     }
@@ -269,7 +270,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                     const connection = this.connectionInfo.get(connectionId);
                     if (connection &&
                         Date.now() - connection.lastActivity > this.options.timeoutMs) {
-                        console.log(`[WebSocket] Timeout for connection ${connectionId}`);
+                        logger.debug(`[WebSocket] Timeout for connection ${connectionId}`);
                         ws.terminate();
                     }
                 }
@@ -296,9 +297,9 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Implementation for channel data handling
     }
     handleChannelError(channelId, error) {
-        console.error(`[Streaming Channel] ${channelId} error:`, error);
+        logger.error(`[Streaming Channel] ${channelId} error:`, error);
     }
     handleChannelClose(channelId) {
-        console.log(`[Streaming Channel] ${channelId} closed`);
+        logger.debug(`[Streaming Channel] ${channelId} closed`);
     }
 }

package/dist/telemetry/telemetry-service.js

@@ -6,6 +6,7 @@ import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
     sdk;
@@ -27,7 +28,7 @@ export class TelemetryService {
             this.initializeTelemetry();
         }
         else {
-            console.log("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
+            logger.debug("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
         }
     }
     static getInstance() {
@@ -58,10 +59,10 @@ export class TelemetryService {
             this.meter = metrics.getMeter("neurolink-ai");
             this.tracer = trace.getTracer("neurolink-ai");
             this.initializeMetrics();
-            console.log("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
         }
         catch (error) {
-            console.error("[Telemetry] Failed to initialize:", error);
+            logger.error("[Telemetry] Failed to initialize:", error);
             this.enabled = false;
         }
     }
@@ -97,10 +98,10 @@ export class TelemetryService {
         }
         try {
             await this.sdk?.start();
-            console.log("[Telemetry] SDK started successfully");
+            logger.debug("[Telemetry] SDK started successfully");
         }
         catch (error) {
-            console.error("[Telemetry] Failed to start SDK:", error);
+            logger.error("[Telemetry] Failed to start SDK:", error);
             this.enabled = false;
         }
     }
@@ -251,10 +252,10 @@ export class TelemetryService {
         if (this.enabled && this.sdk) {
             try {
                 await this.sdk.shutdown();
-                console.log("[Telemetry] SDK shutdown completed");
+                logger.debug("[Telemetry] SDK shutdown completed");
             }
             catch (error) {
-                console.error("[Telemetry] Error during shutdown:", error);
+                logger.error("[Telemetry] Error during shutdown:", error);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -149,25 +149,22 @@
     "@opentelemetry/sdk-node": "^0.54.2",
     "@opentelemetry/semantic-conventions": "^1.34.0",
     "ai": "^4.0.0",
+    "chalk": "^5.3.0",
     "dotenv": "^16.5.0",
+    "inquirer": "^9.2.15",
+    "mathjs": "^14.5.3",
     "ollama-ai-provider": "^1.2.0",
+    "ora": "^7.0.1",
     "reconnecting-eventsource": "^1.6.4",
     "undici": "^6.6.2",
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
+    "yargs": "^17.7.2",
     "zod": "^3.22.0",
-    "zod-to-json-schema": "^3.24.5",
-    "chalk": "^5.3.0",
-    "inquirer": "^9.2.15",
-    "ora": "^7.0.1",
-    "yargs": "^17.7.2"
+    "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.2",
-    "@types/ws": "^8.18.1",
-    "@vitest/coverage-v8": "^2.1.9",
-    "cors": "^2.8.5",
-    "express": "^5.1.0",
     "@eslint/js": "^9.0.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.0",
@@ -183,15 +180,20 @@
     "@types/express": "^5.0.3",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "cors": "^2.8.5",
     "eslint": "^9.0.0",
+    "express": "^5.1.0",
     "playwright": "^1.52.0",
     "prettier": "^3.0.0",
     "publint": "^0.3.2",
     "puppeteer": "^24.10.0",
     "semantic-release": "^24.0.0",
+    "shell-quote": "^1.8.3",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "tslib": "^2.4.1",